diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..b6371c7d8d1a2354deafe5a5e0e38dfb88d8376b 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,4 @@ 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 +snap-python/source/dev/examples/demo.graph.dat filter=lfs diff=lfs merge=lfs -text diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..70cf52054f881b2382eea929be14619b8612c7c1 --- /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", "snap-python/mcp_output/start_mcp.py"] diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..fb268542244d9725efb56c3062792fa70c112671 --- /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__), "snap-python", "mcp_output", "mcp_plugin") +sys.path.insert(0, mcp_plugin_path) + +app = FastAPI( + title="Snap-Python MCP Service", + description="Auto-generated MCP service for snap-python", + version="1.0.0" +) + +@app.get("/") +def root(): + return { + "service": "Snap-Python 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": "snap-python 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/port.json b/port.json new file mode 100644 index 0000000000000000000000000000000000000000..441981a4b5e4eaa04147ebef1a6f209d2b749348 --- /dev/null +++ b/port.json @@ -0,0 +1,5 @@ +{ + "repo": "snap-python", + "port": 7916, + "timestamp": 1773243382 +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..03c0670452e2e1512d75e3a948723e5e5e76bb71 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +fastmcp +fastapi +uvicorn[standard] +pydantic>=2.0.0 +snapx package modules under source.snapx.snapx diff --git a/run_docker.ps1 b/run_docker.ps1 new file mode 100644 index 0000000000000000000000000000000000000000..f06853aa52e40e93c0ee494971a16c8ac72a9243 --- /dev/null +++ b/run_docker.ps1 @@ -0,0 +1,26 @@ +cd $PSScriptRoot +$ErrorActionPreference = "Stop" +$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "snap-python" } +$entryUrl = if ($env:MCP_ENTRY_URL) { $env:MCP_ENTRY_URL } else { "http://localhost:7916/mcp" } +$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "snap-python-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 = @{} } +} +$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 +docker build -t $imageName . +docker run --rm -p 7916:7860 $imageName diff --git a/run_docker.sh b/run_docker.sh new file mode 100644 index 0000000000000000000000000000000000000000..fddaf8883c0bc1e4ba291d5d64acff4f32d0635b --- /dev/null +++ b/run_docker.sh @@ -0,0 +1,75 @@ +#!/usr/bin/env bash +set -euo pipefail +cd "$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)" +mcp_entry_name="${MCP_ENTRY_NAME:-snap-python}" +mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7916/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 +fi +docker build -t snap-python-mcp . +docker run --rm -p 7916:7860 snap-python-mcp diff --git a/snap-python/mcp_output/README_MCP.md b/snap-python/mcp_output/README_MCP.md new file mode 100644 index 0000000000000000000000000000000000000000..8940137a017db847ee57f08fe5ba6b1729d218f8 --- /dev/null +++ b/snap-python/mcp_output/README_MCP.md @@ -0,0 +1,110 @@ +# snap-python MCP (Model Context Protocol) Service README + +## 1) Project Introduction + +This MCP (Model Context Protocol) service exposes graph analytics capabilities built on top of the `snap-python` repository (Stanford SNAP bindings + `snapx` Pythonic API). +It is designed for developer workflows where an LLM or client app needs to: + +- Create/load graphs +- Run shortest path and connectivity analysis +- Compute community/centrality metrics +- Convert between Python data structures and graph objects + +Main usable layers: + +- `swig.snap` (high-performance SNAP bindings, broad algorithm coverage) +- `snapx` (NetworkX-like API wrapping SNAP-style behavior) + +--- + +## 2) Installation Method + +### Requirements + +- Python 3.x +- `pip` +- Build toolchain for native extension (C/C++ compiler, SWIG-compatible environment) for `swig.snap` usage +- Optional: `networkx`, `numpy`, `scipy` for interoperability or specific algorithm paths + +### Install + +- Install from repository root: + - `pip install .` +- Editable/dev install: + - `pip install -e .` + +If native build fails, you can still use pure Python `snapx` portions where applicable, but full SNAP performance/features require successful extension build. + +--- + +## 3) Quick Start + +### Basic graph + shortest path (snapx-style) + +- Create graph with `snapx.classes.graph.Graph` or generators (`snapx.generators.classic.path_graph`) +- Use unweighted/weighted shortest path modules: + - `snapx.algorithms.shortest_paths.unweighted.single_source_shortest_path` + - `snapx.algorithms.shortest_paths.weighted.dijkstra_path` + +### Core analysis functions (SNAP SWIG layer) + +Typical high-value functions available in `snap` include: + +- Connectivity: `GetWccs`, `GetSccs`, `IsConnected`, `GetMxWcc` +- Path/BFS: `GetBfsTree`, `GetShortPath`, `GetBfsEffDiam` +- Centrality: `GetDegreeCentr`, `GetClosenessCentr`, `GetBetweennessCentr` +- Community: `CommunityCNM`, `CommunityGirvanNewman` +- Generation: `GenRndGnm`, `GenPrefAttach`, `GenSmallWorld`, `GenRMat` + +--- + +## 4) Available Tools and Endpoints List + +Recommended MCP (Model Context Protocol) service surface (developer-oriented grouping): + +- `graph.create` + - Create empty/path/basic graphs (snapx generators, SNAP constructors) +- `graph.load` + - Load edge lists / persisted graphs (`LoadEdgeList`, `*_Load`) +- `graph.convert` + - Convert dict-of-dicts and Python structures (`to_snapx_graph`, `from_dict_of_dicts`) +- `analysis.connectivity` + - Components and connectedness (`connected_components`, `GetWccs`, `GetSccs`) +- `analysis.shortest_path` + - Unweighted + Dijkstra + all-pairs (`single_source_shortest_path`, `dijkstra_path`, `johnson`) +- `analysis.centrality` + - Degree/closeness/betweenness/eigenvector variants +- `analysis.community` + - CNM and Girvan-Newman community detection +- `analysis.stats` + - Degree distributions, triads, clustering, diameter/ANF estimates +- `graph.relabel` + - Node relabel operations (`relabel_nodes`, integer relabeling) + +Note: Repository does not define a ready-made CLI endpoint set; expose these as MCP (Model Context Protocol) service methods in your host runtime. + +--- + +## 5) Common Issues and Notes + +- Native build friction: + - Most installation issues come from missing compiler/SWIG toolchain. +- Mixed API layers: + - `swig.snap` and `snapx` overlap conceptually; keep service contracts explicit about which backend each endpoint uses. +- Performance: + - Prefer SWIG SNAP functions for large graphs and heavy analytics. +- Compatibility: + - Some conversion paths may assume NetworkX-like inputs. +- Testing/examples: + - Use `test/` and `examples/` as validation references for endpoint behavior and expected outputs. + +--- + +## 6) Reference Links / Documentation + +- Repository: https://github.com/snap-stanford/snap-python +- Root docs: `README.md`, `troubleshooting.md`, `RELEASE.txt` +- SWIG notes: `swig/README.txt` +- Docker/environment help: `docker/README.md` +- Examples: `examples/`, `dev/examples/` +- Tests: `test/`, `dev/test/` \ No newline at end of file diff --git a/snap-python/mcp_output/analysis.json b/snap-python/mcp_output/analysis.json new file mode 100644 index 0000000000000000000000000000000000000000..57d2e11c9a63ff065a3dba56f65316a3b0ae5228 --- /dev/null +++ b/snap-python/mcp_output/analysis.json @@ -0,0 +1,2104 @@ +{ + "summary": { + "repository_url": "https://github.com/snap-stanford/snap-python", + "summary": "Imported via zip fallback, file count: 238", + "file_tree": { + "CREDITS.txt": { + "size": 1015 + }, + "README.md": { + "size": 4798 + }, + "RELEASE.txt": { + "size": 8899 + }, + "dev/examples/benchmark.py": { + "size": 13737 + }, + "dev/examples/convert.py": { + "size": 6243 + }, + "dev/examples/data/p2p-Gnutella08.txt": { + "size": 194493 + }, + "dev/examples/getstats.py": { + "size": 9553 + }, + "dev/examples/load.py": { + "size": 207 + }, + "dev/examples/plot_results.py": { + "size": 5349 + }, + "dev/examples/result3.txt": { + "size": 131 + }, + "dev/examples/results-madmax/BFS_all.txt": { + "size": 5183 + }, + "dev/examples/results-madmax/BFS_pref.txt": { + "size": 868 + }, + "dev/examples/results-madmax/BFS_prefdeg3.txt": { + "size": 866 + }, + "dev/examples/results-madmax/BFS_rmat.txt": { + "size": 864 + }, + "dev/examples/results-madmax/BFS_rmatdeg3.txt": { + "size": 861 + }, + "dev/examples/results-madmax/BFS_sw.txt": { + "size": 864 + }, + "dev/examples/results-madmax/BFS_swdeg3.txt": { + "size": 860 + }, + "dev/examples/results-madmax/triads_all.txt": { + "size": 5163 + }, + "dev/examples/results-madmax/triads_pref.txt": { + "size": 863 + }, + "dev/examples/results-madmax/triads_prefdeg3.txt": { + "size": 860 + }, + "dev/examples/results-madmax/triads_rmat.txt": { + "size": 862 + }, + "dev/examples/results-madmax/triads_rmatdeg3.txt": { + "size": 860 + }, + "dev/examples/results-madmax/triads_sw.txt": { + "size": 861 + }, + "dev/examples/results-madmax/triads_swdeg3.txt": { + "size": 857 + }, + "dev/examples/snapswig-check.py": { + "size": 1191 + }, + "dev/examples/tneanet-cpp.py": { + "size": 262 + }, + "dev/examples/tneanet.py": { + "size": 9117 + }, + "dev/examples/tnodei.py": { + "size": 76 + }, + "dev/examples/tungraph.py": { + "size": 2674 + }, + "dev/examples/vector_comp.py": { + "size": 1563 + }, + "dev/swig-r/snappy.py": { + "size": 1067 + }, + "dev/test/adjlist.py": { + "size": 2256 + }, + "dev/test/data/p2p-Gnutella08.txt": { + "size": 194493 + }, + "dev/test/genrnd.py": { + "size": 847 + }, + "dev/test/hash.py": { + "size": 2654 + }, + "dev/test/hkey.py": { + "size": 390 + }, + "dev/test/install-dir.py": { + "size": 542 + }, + "dev/test/memtest.py": { + "size": 471 + }, + "dev/test/printstat.py": { + "size": 472 + }, + "dev/test/readvec.py": { + "size": 428 + }, + "dev/test/results-sheridan/coeff.txt": { + "size": 24 + }, + "dev/test/results-sheridan/pref-CDD.txt": { + "size": 139 + }, + "dev/test/results-sheridan/pref-ClustCoef.txt": { + "size": 139 + }, + "dev/test/results-sheridan/pref-DD.txt": { + "size": 139 + }, + "dev/test/results-sheridan/pref-HOP.txt": { + "size": 139 + }, + "dev/test/results-sheridan/pref-SVal.txt": { + "size": 140 + }, + "dev/test/results-sheridan/pref-SVec.txt": { + "size": 139 + }, + "dev/test/results-sheridan/pref-Scc.txt": { + "size": 139 + }, + "dev/test/results-sheridan/pref-Wcc.txt": { + "size": 139 + }, + "dev/test/results-sheridan/pref-info.txt": { + "size": 139 + }, + "dev/test/results-sheridan/rmat-CDD.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-ClustCoef.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-DD.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-HOP.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-SVal.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-SVec.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-Scc.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-Wcc.txt": { + "size": 140 + }, + "dev/test/results-sheridan/rmat-info.txt": { + "size": 140 + }, + "dev/test/results-sheridan/sw-CDD.txt": { + "size": 208 + }, + "dev/test/results-sheridan/sw-ClustCoef.txt": { + "size": 208 + }, + "dev/test/results-sheridan/sw-DD.txt": { + "size": 208 + }, + "dev/test/results-sheridan/sw-HOP.txt": { + "size": 208 + }, + "dev/test/results-sheridan/sw-SVal.txt": { + "size": 187 + }, + "dev/test/results-sheridan/sw-SVec.txt": { + "size": 187 + }, + "dev/test/results-sheridan/sw-Scc.txt": { + "size": 208 + }, + "dev/test/results-sheridan/sw-Wcc.txt": { + "size": 208 + }, + "dev/test/results-sheridan/sw-info.txt": { + "size": 208 + }, + "dev/test/tungraph.py": { + "size": 2714 + }, + "dev/test/vec.py": { + "size": 1487 + }, + "doc/README-DOC.TXT": { + "size": 3253 + }, + "doc/guide.txt": { + "size": 653 + }, + "doc/source/conf.py": { + "size": 8055 + }, + "doc/todo.txt": { + "size": 567 + }, + "docker/README.md": { + "size": 11893 + }, + "docker/requirements.txt": { + "size": 138 + }, + "examples/benchmark.py": { + "size": 14022 + }, + "examples/data/p2p-Gnutella08.txt": { + "size": 194493 + }, + "examples/stackoverflow/doJoin.py": { + "size": 1516 + }, + "examples/stackoverflow/getAnswers.py": { + "size": 1438 + }, + "examples/stackoverflow/getQuestions.py": { + "size": 1675 + }, + "examples/stackoverflow/getStats.py": { + "size": 2111 + }, + "examples/stackoverflow/getTag.py": { + "size": 1599 + }, + "examples/tneanet.py": { + "size": 9115 + }, + "hellotest/setup.py": { + "size": 148 + }, + "setup.py": { + "size": 1596 + }, + "setup/setup.py": { + "size": 2613 + }, + "setup/snap.py": { + "size": 524313 + }, + "snapx/README.md": { + "size": 2732 + }, + "snapx/setup.py": { + "size": 293 + }, + "snapx/snapx/__init__.py": { + "size": 271 + }, + "snapx/snapx/algorithms/__init__.py": { + "size": 171 + }, + "snapx/snapx/algorithms/centrality/__init__.py": { + "size": 24 + }, + "snapx/snapx/algorithms/centrality/snap_cent.py": { + "size": 115 + }, + "snapx/snapx/algorithms/community/__init__.py": { + "size": 50 + }, + "snapx/snapx/algorithms/community/snap_cmty.py": { + "size": 368 + }, + "snapx/snapx/algorithms/components/__init__.py": { + "size": 26 + }, + "snapx/snapx/algorithms/components/components.py": { + "size": 3784 + }, + "snapx/snapx/algorithms/dag.py": { + "size": 28823 + }, + "snapx/snapx/algorithms/shortest_paths/__init__.py": { + "size": 112 + }, + "snapx/snapx/algorithms/shortest_paths/unweighted.py": { + "size": 14520 + }, + "snapx/snapx/algorithms/shortest_paths/weighted.py": { + "size": 72792 + }, + "snapx/snapx/classes/__init__.py": { + "size": 168 + }, + "snapx/snapx/classes/_nodeiter.py": { + "size": 2521 + }, + "snapx/snapx/classes/attrdict.py": { + "size": 7278 + }, + "snapx/snapx/classes/coreviews.py": { + "size": 7082 + }, + "snapx/snapx/classes/digraph.py": { + "size": 40018 + }, + "snapx/snapx/classes/filters.py": { + "size": 1756 + }, + "snapx/snapx/classes/function.py": { + "size": 9997 + }, + "snapx/snapx/classes/graph.py": { + "size": 51329 + }, + "snapx/snapx/classes/graphviews.py": { + "size": 4930 + }, + "snapx/snapx/classes/reportviews.py": { + "size": 7755 + }, + "snapx/snapx/classes/tests/__init__.py": { + "size": 12 + }, + "snapx/snapx/classes/tests/test_attrdict.py": { + "size": 3830 + }, + "snapx/snapx/classes/tests/test_coreviews.py": { + "size": 4165 + }, + "snapx/snapx/classes/tests/test_graph.py": { + "size": 26667 + }, + "snapx/snapx/classes/tests/test_reportviews.py": { + "size": 14382 + }, + "snapx/snapx/convert.py": { + "size": 8514 + }, + "snapx/snapx/exception.py": { + "size": 1082 + }, + "snapx/snapx/generators/__init__.py": { + "size": 74 + }, + "snapx/snapx/generators/classic.py": { + "size": 4037 + }, + "snapx/snapx/generators/ego.py": { + "size": 2150 + }, + "snapx/snapx/relabel.py": { + "size": 7699 + }, + "snapx/snapx/testing/__init__.py": { + "size": 35 + }, + "snapx/snapx/testing/utils.py": { + "size": 1780 + }, + "snapx/snapx/utils/__init__.py": { + "size": 68 + }, + "snapx/snapx/utils/decorator.py": { + "size": 17222 + }, + "snapx/snapx/utils/decorators.py": { + "size": 3454 + }, + "snapx/snapx/utils/misc.py": { + "size": 577 + }, + "swig/README.txt": { + "size": 3310 + }, + "swig/gen/NOTES.TXT": { + "size": 3315 + }, + "swig/gen/disp-custom.py": { + "size": 6928 + }, + "swig/gen/dispatch-pneanet.txt": { + "size": 2480 + }, + "swig/gen/dispatch-pngraph.txt": { + "size": 2480 + }, + "swig/gen/dispatch-pngraphmp.txt": { + "size": 2534 + }, + "swig/gen/dispatch-pungraph.txt": { + "size": 2599 + }, + "swig/gen/dispatch.txt": { + "size": 10093 + }, + "swig/gen/genClassFn/README.txt": { + "size": 1193 + }, + "swig/gen/genClassFn/archive/README.txt": { + "size": 698 + }, + "swig/gen/genClassFn/archive/classFn.txt": { + "size": 266 + }, + "swig/gen/genClassFn/archive/classFnDef.txt": { + "size": 2415 + }, + "swig/gen/genClassFn/archive/classFnExt.txt": { + "size": 7672 + }, + "swig/gen/genClassFn/archive/genClassFnExt.py": { + "size": 2702 + }, + "swig/gen/genClassFn/classFn.txt": { + "size": 1728 + }, + "swig/gen/genClassFn/genPyClassFn.py": { + "size": 589 + }, + "swig/gen/gendispatch.py": { + "size": 1874 + }, + "swig/gen/gentypes.py": { + "size": 823 + }, + "swig/gen/hashes.txt": { + "size": 616 + }, + "swig/gen/types.txt": { + "size": 2858 + }, + "swig/gen/vectors.txt": { + "size": 969 + }, + "swig/setup.py": { + "size": 2136 + }, + "swig/snap/__init__.py": { + "size": 509 + }, + "test/adjlist.py": { + "size": 2286 + }, + "test/attributes.py": { + "size": 1128 + }, + "test/attrtest.py": { + "size": 804 + }, + "test/bfs.py": { + "size": 1529 + }, + "test/bug-2015-130-GetRndNI.py": { + "size": 146 + }, + "test/bug-2015-18-attr.py": { + "size": 1074 + }, + "test/bug-20150706-pagerank.py": { + "size": 160 + }, + "test/bug-328-cnm.py": { + "size": 170 + }, + "test/bug-585-genrndpowerlaw.py": { + "size": 171 + }, + "test/bug-AddFltAttrN.py": { + "size": 492 + }, + "test/bug-attr-mem.py": { + "size": 3056 + }, + "test/cncom.py": { + "size": 1602 + }, + "test/cpm_communities.py": { + "size": 671 + }, + "test/data/cooccurrence.txt": { + "size": 222 + }, + "test/data/data-table.txt": { + "size": 89 + }, + "test/data/example-LoadConnListStr.txt": { + "size": 12 + }, + "test/data/final_sorted_edges.txt": { + "size": 524313 + }, + "test/data/p2p-Gnutella08.txt": { + "size": 194498 + }, + "test/data/test-509.txt": { + "size": 12 + }, + "test/delnode.py": { + "size": 1141 + }, + "test/demo-random.py": { + "size": 505 + }, + "test/except.py": { + "size": 497 + }, + "test/genrnd.py": { + "size": 863 + }, + "test/getidv.py": { + "size": 207 + }, + "test/gnuplot.py": { + "size": 139 + }, + "test/graphviz.py": { + "size": 315 + }, + "test/hash.py": { + "size": 2688 + }, + "test/hkey.py": { + "size": 407 + }, + "test/intro.py": { + "size": 3055 + }, + "test/make-graph.py": { + "size": 749 + }, + "test/make-tab.py": { + "size": 330 + }, + "test/net.py": { + "size": 9161 + }, + "test/ops.py": { + "size": 2989 + }, + "test/ops1.py": { + "size": 1078 + }, + "test/pagerank.py": { + "size": 490 + }, + "test/plotdeg.py": { + "size": 368 + }, + "test/printsnap.py": { + "size": 59 + }, + "test/printstat.py": { + "size": 511 + }, + "test/props.py": { + "size": 594 + }, + "test/quick_test.py": { + "size": 291 + }, + "test/readgraph.py": { + "size": 2682 + }, + "test/readvec.py": { + "size": 439 + }, + "test/rnd.py": { + "size": 330 + }, + "test/snap-test-pylayer.py": { + "size": 137859 + }, + "test/snap-test.py": { + "size": 138461 + }, + "test/table-test-avery.py": { + "size": 3128 + }, + "test/test-131-setiter.py": { + "size": 334 + }, + "test/test-2015-18a-attr.py": { + "size": 1365 + }, + "test/test-2015-298.py": { + "size": 576 + }, + "test/test-20160801-LoadConnListStr.py": { + "size": 407 + }, + "test/test-20180416-table.py": { + "size": 805 + }, + "test/test-346-getei.py": { + "size": 917 + }, + "test/test-356-getei.py": { + "size": 545 + }, + "test/test-374-addstrattrdate.py": { + "size": 330 + }, + "test/test-384-deledge.py": { + "size": 205 + }, + "test/test-509-load.py": { + "size": 390 + }, + "test/test-582-getnodewcc.py": { + "size": 209 + }, + "test/test-585-genrndpowerlaw.py": { + "size": 57 + }, + "test/test-613-getbfstree.py": { + "size": 453 + }, + "test/test-GetBetweennessCentr.py": { + "size": 1035 + }, + "test/test-GetClosenessCentr.py": { + "size": 614 + }, + "test/test-GetFarnessCentr.py": { + "size": 596 + }, + "test/test-THashKeyDatI.py": { + "size": 178 + }, + "test/test-emptystr.py": { + "size": 353 + }, + "test/test-girvan-newman.py": { + "size": 710 + }, + "test/test-gnuplot.py": { + "size": 121 + }, + "test/test-graphviz.py": { + "size": 109 + }, + "test/test-io.py": { + "size": 2464 + }, + "test/test-node2vec.py": { + "size": 224 + }, + "test/test-pajek.py": { + "size": 1466 + }, + "test/test-rewire.py": { + "size": 278 + }, + "test/test-table.py": { + "size": 1780 + }, + "test/test-tnodei.py": { + "size": 1866 + }, + "test/test-vec-ops.py": { + "size": 1235 + }, + "test/thash.py": { + "size": 923 + }, + "test/titer.py": { + "size": 6659 + }, + "test/tmany.py": { + "size": 4540 + }, + "test/tneanet.py": { + "size": 29824 + }, + "test/tnodei.py": { + "size": 955 + }, + "test/tpair.py": { + "size": 83 + }, + "test/tree.py": { + "size": 369 + }, + "test/tutorial.py": { + "size": 3825 + }, + "test/tvec.py": { + "size": 704 + }, + "test/vec.py": { + "size": 1511 + }, + "test/vector_comp.py": { + "size": 1568 + }, + "troubleshooting.md": { + "size": 1594 + } + }, + "processed_by": "zip_fallback", + "success": true + }, + "structure": { + "packages": [ + "source.snapx.snapx", + "source.swig.snap" + ] + }, + "dependencies": { + "has_environment_yml": false, + "has_requirements_txt": false, + "pyproject": false, + "setup_cfg": false, + "setup_py": true + }, + "entry_points": { + "imports": [], + "cli": [], + "modules": [] + }, + "llm_analysis": { + "core_modules": [ + { + "package": "setup", + "module": "setup", + "functions": [], + "classes": [ + "SwigBuild", + "SwigExtension" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "swig", + "module": "setup", + "functions": [], + "classes": [ + "PkgBuild", + "SwigExtension" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "swig.gen", + "module": "disp-custom", + "functions": [ + "ConvertESubGraph", + "ConvertGraph", + "ConvertSubGraph", + "ToGraph", + "ToNetwork" + ], + "classes": [], + "function_signatures": { + "ConvertGraph": [ + "toutspec", + "tinspec" + ], + "ConvertSubGraph": [ + "toutspec", + "tinspec" + ], + "ConvertESubGraph": [ + "toutspec", + "tinspec" + ], + "ToNetwork": [ + "tspec" + ], + "ToGraph": [ + "tspec" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "swig.gen.genClassFn.archive", + "module": "genClassFnExt", + "functions": [ + "genFuncCall", + "getFuncName", + "removeFirstParam", + "stripTypes" + ], + "classes": [], + "function_signatures": { + "removeFirstParam": [ + "funcDecl" + ], + "stripTypes": [ + "decl" + ], + "genFuncCall": [ + "funcDecl", + "funcName", + "graphType" + ], + "getFuncName": [ + "funcDecl" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "setup", + "module": "snap", + "functions": [ + "CalcAvgDiamPdf", + "CalcEffDiam", + "CalcEffDiamPdf", + "CmtyGirvanNewmanStep", + "CntDegNodes", + "CntEdgesToSet", + "CntInDegNodes", + "CntNonZNodes", + "CntOutDegNodes", + "CntSelfEdges", + "CntUniqBiDirEdges", + "CntUniqDirEdges", + "CntUniqUndirEdges", + "CommunityCNM", + "CommunityGirvanNewman", + "DrawGViz", + "ErrNotify", + "ExeStop", + "GVizDoLayout", + "GVizGetLayoutStr", + "GenConfModel", + "GenCopyModel", + "GenDegSeq", + "GenForestFire", + "GenGeoPrefAttach", + "GenPrefAttach", + "GenRMat", + "GenRMatEpinions", + "GenRewire", + "GenRndBipart", + "GenRndDegK", + "GenRndGnm", + "GenRndPowerLaw", + "GenSmallWorld", + "Get1CnCom", + "Get1CnComSzCnt", + "GetAnf", + "GetAnfEffDiam", + "GetArtPoints", + "GetBetweennessCentr", + "GetBfsEffDiam", + "GetBfsFullDiam", + "GetBfsTree", + "GetBiCon", + "GetBiConSzCnt", + "GetClosenessCentr", + "GetClustCf", + "GetCmnNbrs", + "GetDegCnt", + "GetDegSeqV", + "GetDegreeCentr", + "GetEdgeBridges", + "GetEdgesInOut", + "GetEigVals", + "GetEigVec", + "GetEigenVectorCentr", + "GetFarnessCentr", + "GetInDegCnt", + "GetInvParticipRat", + "GetInvParticipRatEig", + "GetModularity", + "GetMxBiCon", + "GetMxDegNId", + "GetMxInDegNId", + "GetMxOutDegNId", + "GetMxScc", + "GetMxWcc", + "GetMxWccSz", + "GetNodeClustCf", + "GetNodeInDegV", + "GetNodeOutDegV", + "GetNodeWcc", + "GetNodesAtHop", + "GetNodesAtHops", + "GetOutDegCnt", + "GetSccSzCnt", + "GetSccs", + "GetShortPath", + "GetSngVals", + "GetSngVec", + "GetSubGraph", + "GetSubTreeSz", + "GetTriadEdges", + "GetTriadParticip", + "GetTriads", + "GetWccSzCnt", + "GetWccs", + "InfoNotify", + "IsConnected", + "IsWeaklyConn", + "LoadDyNet", + "LoadDyNetGraphV", + "LoadEdgeList", + "MxDegree", + "MxSccSz", + "MxWccSz", + "NodesGTEDegree", + "PNEANet_New", + "PercentDegree", + "PercentMxScc", + "PercentMxWcc", + "PrintGraphStatTable", + "PyTFltV", + "PyToTIntV", + "SaveToErrLog", + "StatNotify", + "TBPGraph_GetSmallGraph", + "TBPGraph_Load", + "TBPGraph_New", + "TBigStrPool_Load", + "TBigStrPool_New", + "TBool_Get01Str", + "TBool_GetRnd", + "TBool_GetValFromStr", + "TBool_GetYNStr", + "TBool_GetYesNoStr", + "TBool_IsValStr", + "TChAIn_New", + "TChA_LoadTxt", + "TCh_GetHex", + "TCh_GetHexCh", + "TCh_GetNum", + "TCh_GetUc", + "TCh_GetUsFromYuAscii", + "TCh_IsAlNum", + "TCh_IsAlpha", + "TCh_IsHex", + "TCh_IsNum", + "TCh_IsUc", + "TCh_IsWs", + "TCnCom_Dump", + "TCnCom_SaveTxt", + "TCs_GetCsFromBf", + "TFIn_New", + "TFOut_New", + "TFfGGen_GenFFGraphs", + "TFile_Del", + "TFile_DelWc", + "TFile_Exists", + "TFile_GetUniqueFNm", + "TFile_Rename", + "TFltRect_Intersection", + "TFlt_Abs", + "TFlt_Eq6", + "TFlt_GetGigaStr", + "TFlt_GetInRng", + "TFlt_GetKiloStr", + "TFlt_GetMegaStr", + "TFlt_GetMn", + "TFlt_GetMx", + "TFlt_GetPrcStr", + "TFlt_GetRnd", + "TFlt_Round", + "TFlt_Sign", + "TForestFire_GenGraph", + "TGUtil_GetCCdf", + "TGUtil_GetCdf", + "TGUtil_GetPdf", + "TGUtil_MakeExpBins", + "TGUtil_Normalize", + "TIntIntVV_GetV", + "TIntIntVV_SwapI", + "TIntVToPy", + "TIntV_GetV", + "TIntV_SwapI", + "TInt_Abs", + "TInt_GetHexStr", + "TInt_GetInRng", + "TInt_GetKiloStr", + "TInt_GetMegaStr", + "TInt_GetMn", + "TInt_GetMx", + "TInt_GetRnd", + "TInt_IsEven", + "TInt_IsOdd", + "TInt_LoadFrugalInt", + "TInt_LoadFrugalIntV", + "TInt_SaveFrugalInt", + "TInt_SaveFrugalIntV", + "TInt_Sign", + "TInt_Swap", + "TInt_TestFrugalInt", + "TMIn_New", + "TMOut_New", + "TMemIn_New", + "TMemOut_New", + "TMem_LoadMem", + "TMem_New", + "TNEANet_Load", + "TNEANet_New", + "TNEGraph_Load", + "TNEGraph_New", + "TNGraph_GetSmallGraph", + "TNGraph_Load", + "TNGraph_New", + "TPairHashImpl1_GetHashCd", + "TPairHashImpl2_GetHashCd", + "TPrGraph", + "TRStr_CmpI", + "TRStr_GetNullRStr", + "TRnd_GetExpDevStep", + "TRnd_GetNrmDevStep", + "TRnd_GetUniDevStep", + "TRnd_LoadTxt", + "TStdIn_New", + "TStdOut_New", + "TStrHashF_DJB_GetPrimHashCd", + "TStrHashF_DJB_GetSecHashCd", + "TStrHashF_Md5_GetPrimHashCd", + "TStrHashF_Md5_GetSecHashCd", + "TStrHashF_OldGLib_GetPrimHashCd", + "TStrHashF_OldGLib_GetSecHashCd", + "TStrIn_New", + "TStrPool64_Load", + "TStrPool64_New", + "TStrPool_Load", + "TStrPool_New", + "TStrUtil_CountWords", + "TStrUtil_GetAddWIdV", + "TStrUtil_GetCleanStr", + "TStrUtil_GetCleanWrdStr", + "TStrUtil_GetDomNm", + "TStrUtil_GetDomNm2", + "TStrUtil_GetNormalizedUrl", + "TStrUtil_GetShorStr", + "TStrUtil_GetStdName", + "TStrUtil_GetStdNameV", + "TStrUtil_GetTmFromStr", + "TStrUtil_GetWIdV", + "TStrUtil_GetWebsiteNm", + "TStrUtil_GetXmlTagNmVal", + "TStrUtil_GetXmlTagNmVal2", + "TStrUtil_GetXmlTagVal", + "TStrUtil_IsLatinStr", + "TStrUtil_RemoveHtmlTags", + "TStrUtil_SplitLines", + "TStrUtil_SplitOnCh", + "TStrUtil_SplitSentences", + "TStrUtil_SplitWords", + "TStrUtil_StripEnd", + "TStrV_GetV", + "TStrV_SwapI", + "TStr_AddToFMid", + "TStr_Fmt", + "TStr_GetChStr", + "TStr_GetDChStr", + "TStr_GetFNmStr", + "TStr_GetNrAbsFPath", + "TStr_GetNrFExt", + "TStr_GetNrFMid", + "TStr_GetNrFNm", + "TStr_GetNrFPath", + "TStr_GetNrNumFExt", + "TStr_GetNullStr", + "TStr_GetNumFNm", + "TStr_GetSpaceStr", + "TStr_IsAbsFPath", + "TStr_LoadTxt", + "TStr_MkClone", + "TStr_PutFBase", + "TStr_PutFBaseIfEmpty", + "TStr_PutFExt", + "TStr_PutFExtIfEmpty", + "TUInt64_GetHexStr", + "TUInt64_GetKiloStr", + "TUInt64_GetMegaStr", + "TUInt_GetKiloStr", + "TUInt_GetMegaStr", + "TUInt_GetRnd", + "TUInt_GetStrFromIpUInt", + "TUInt_GetUIntFromIpStr", + "TUInt_IsIpStr", + "TUInt_IsIpv6Str", + "TUInt_JavaUIntToCppUInt", + "TUNGraph_GetSmallGraph", + "TUNGraph_Load", + "TUNGraph_New", + "WarnNotify", + "WrNotify", + "accept_array", + "count", + "print_array" + ], + "classes": [ + "PNEANet", + "TArtPointVisitor", + "TAscFlt", + "TBPGraph", + "TBiConVisitor", + "TBigStrPool", + "TBool", + "TCRef", + "TCh", + "TChA", + "TChAIn", + "TChRet", + "TCnCom", + "TConv_Pt64Ints32", + "TCs", + "TDbStr", + "TFIn", + "TFOut", + "TFfGGen", + "TFile", + "TFlt", + "TFltRect", + "TForestFire", + "TGUtil", + "TInt", + "TIntH", + "TIntHI", + "TIntIntVH", + "TIntIntVV", + "TIntV", + "TLFlt", + "TLnRet", + "TMIn", + "TMOut", + "TMem", + "TMemIn", + "TMemOut", + "TNEANet", + "TNEANetAFltI", + "TNEANetAIntI", + "TNEANetAStrI", + "TNEANetEdgeI", + "TNEANetNodeI", + "TNEGraph", + "TNGraph", + "TNGraphEdgeI", + "TNGraphMtx", + "TNGraphNodeI", + "TPairHashImpl1", + "TPairHashImpl2", + "TRStr", + "TRnd", + "TSBase", + "TSFlt", + "TSIn", + "TSInOut", + "TSInt", + "TSOut", + "TSOutMnp", + "TSStr", + "TStdIn", + "TStdOut", + "TStr", + "TStrHashF_DJB", + "TStrHashF_Md5", + "TStrHashF_OldGLib", + "TStrIn", + "TStrPool", + "TStrPool64", + "TStrUtil", + "TStrV", + "TUCh", + "TUInt", + "TUInt64", + "TUNGraph", + "TUNGraphEdgeI", + "TUNGraphMtx", + "TUNGraphNodeI", + "TUndirFFire", + "TVoid" + ], + "function_signatures": { + "CalcEffDiam": [], + "CalcEffDiamPdf": [], + "CalcAvgDiamPdf": [], + "WrNotify": [], + "SaveToErrLog": [], + "InfoNotify": [], + "WarnNotify": [], + "ErrNotify": [], + "StatNotify": [], + "ExeStop": [], + "TPairHashImpl1_GetHashCd": [], + "TPairHashImpl2_GetHashCd": [], + "GetDegreeCentr": [], + "GetFarnessCentr": [], + "GetClosenessCentr": [], + "GetBetweennessCentr": [], + "GetEigenVectorCentr": [], + "CommunityGirvanNewman": [], + "CommunityCNM": [], + "CmtyGirvanNewmanStep": [], + "GetBiConSzCnt": [], + "GetBiCon": [], + "GetArtPoints": [], + "GetEdgeBridges": [], + "Get1CnComSzCnt": [], + "Get1CnCom": [], + "TCnCom_Dump": [], + "TCnCom_SaveTxt": [], + "TForestFire_GenGraph": [], + "TFfGGen_GenFFGraphs": [], + "TCs_GetCsFromBf": [], + "TStdIn_New": [], + "TStdOut_New": [], + "TFIn_New": [], + "TFOut_New": [], + "TMIn_New": [], + "TMOut_New": [ + "MxBfL" + ], + "TFile_Exists": [], + "TFile_Del": [], + "TFile_DelWc": [], + "TFile_Rename": [], + "TFile_GetUniqueFNm": [], + "TUNGraph_New": [], + "TUNGraph_Load": [], + "TUNGraph_GetSmallGraph": [], + "TNGraph_New": [], + "TNGraph_Load": [], + "TNGraph_GetSmallGraph": [], + "TNEGraph_New": [], + "TNEGraph_Load": [], + "TBPGraph_New": [], + "TBPGraph_Load": [], + "TBPGraph_GetSmallGraph": [], + "GetSngVals": [], + "GetSngVec": [], + "GetEigVals": [], + "GetEigVec": [], + "GetInvParticipRat": [], + "GetInvParticipRatEig": [], + "LoadDyNet": [], + "LoadDyNetGraphV": [], + "GVizDoLayout": [], + "GVizGetLayoutStr": [], + "TBigStrPool_New": [], + "TBigStrPool_Load": [], + "TStrHashF_OldGLib_GetPrimHashCd": [], + "TStrHashF_OldGLib_GetSecHashCd": [], + "TStrHashF_Md5_GetPrimHashCd": [], + "TStrHashF_Md5_GetSecHashCd": [], + "TStrHashF_DJB_GetPrimHashCd": [], + "TStrHashF_DJB_GetSecHashCd": [], + "GenRndBipart": [], + "GenRndDegK": [], + "GenRndPowerLaw": [], + "GenDegSeq": [], + "GenPrefAttach": [], + "GenGeoPrefAttach": [], + "GenSmallWorld": [], + "GenForestFire": [], + "GenCopyModel": [], + "GenRMat": [], + "GenRMatEpinions": [], + "GenRewire": [], + "GenConfModel": [], + "GetSubGraph": [], + "TGUtil_GetCdf": [], + "TGUtil_GetCCdf": [], + "TGUtil_GetPdf": [], + "TGUtil_Normalize": [], + "TGUtil_MakeExpBins": [], + "TStrUtil_GetXmlTagVal": [], + "TStrUtil_GetXmlTagNmVal": [], + "TStrUtil_GetXmlTagNmVal2": [], + "TStrUtil_GetDomNm": [], + "TStrUtil_GetDomNm2": [], + "TStrUtil_GetWebsiteNm": [], + "TStrUtil_GetNormalizedUrl": [], + "TStrUtil_StripEnd": [], + "TStrUtil_GetShorStr": [], + "TStrUtil_GetCleanStr": [], + "TStrUtil_GetCleanWrdStr": [], + "TStrUtil_CountWords": [], + "TStrUtil_SplitWords": [], + "TStrUtil_SplitOnCh": [], + "TStrUtil_SplitLines": [], + "TStrUtil_SplitSentences": [], + "TStrUtil_RemoveHtmlTags": [], + "TStrUtil_IsLatinStr": [], + "TStrUtil_GetWIdV": [], + "TStrUtil_GetAddWIdV": [], + "TStrUtil_GetTmFromStr": [], + "TStrUtil_GetStdName": [], + "TStrUtil_GetStdNameV": [], + "TRnd_GetUniDevStep": [], + "TRnd_GetNrmDevStep": [], + "TRnd_GetExpDevStep": [], + "TRnd_LoadTxt": [], + "TMem_New": [], + "TMem_LoadMem": [], + "TMemIn_New": [], + "TMemOut_New": [], + "TChA_LoadTxt": [], + "TChAIn_New": [], + "TRStr_CmpI": [], + "TRStr_GetNullRStr": [], + "TStr_GetNrFPath": [], + "TStr_GetNrFMid": [], + "TStr_GetNrFExt": [], + "TStr_GetNrNumFExt": [], + "TStr_GetNrFNm": [], + "TStr_GetNrAbsFPath": [], + "TStr_IsAbsFPath": [], + "TStr_PutFExt": [], + "TStr_PutFExtIfEmpty": [], + "TStr_PutFBase": [], + "TStr_PutFBaseIfEmpty": [], + "TStr_AddToFMid": [], + "TStr_GetNumFNm": [], + "TStr_GetFNmStr": [], + "TStr_LoadTxt": [], + "TStr_GetChStr": [], + "TStr_GetDChStr": [], + "TStr_Fmt": [], + "TStr_GetSpaceStr": [], + "TStr_MkClone": [], + "TStr_GetNullStr": [], + "TStrIn_New": [], + "TStrPool_New": [], + "TStrPool_Load": [], + "TStrPool64_New": [ + "MxBfL", + "GrowBy" + ], + "TStrPool64_Load": [], + "TBool_GetRnd": [], + "TBool_GetYNStr": [], + "TBool_GetYesNoStr": [], + "TBool_Get01Str": [], + "TBool_IsValStr": [], + "TBool_GetValFromStr": [], + "TCh_IsWs": [], + "TCh_IsAlpha": [], + "TCh_IsNum": [], + "TCh_IsAlNum": [], + "TCh_GetNum": [], + "TCh_IsHex": [], + "TCh_GetHex": [], + "TCh_GetHexCh": [], + "TCh_IsUc": [], + "TCh_GetUc": [], + "TCh_GetUsFromYuAscii": [], + "TInt_Abs": [], + "TInt_Sign": [], + "TInt_Swap": [], + "TInt_GetRnd": [ + "Range" + ], + "TInt_IsOdd": [], + "TInt_IsEven": [], + "TInt_GetMn": [], + "TInt_GetMx": [], + "TInt_GetInRng": [], + "TInt_GetHexStr": [], + "TInt_GetKiloStr": [], + "TInt_GetMegaStr": [], + "TInt_SaveFrugalInt": [], + "TInt_LoadFrugalInt": [], + "TInt_TestFrugalInt": [], + "TInt_SaveFrugalIntV": [], + "TInt_LoadFrugalIntV": [], + "TUInt_GetRnd": [ + "Range" + ], + "TUInt_GetKiloStr": [], + "TUInt_GetMegaStr": [], + "TUInt_JavaUIntToCppUInt": [], + "TUInt_IsIpStr": [], + "TUInt_GetUIntFromIpStr": [], + "TUInt_GetStrFromIpUInt": [], + "TUInt_IsIpv6Str": [], + "TUInt64_GetHexStr": [], + "TUInt64_GetKiloStr": [], + "TUInt64_GetMegaStr": [], + "TFlt_Abs": [], + "TFlt_Sign": [], + "TFlt_Round": [], + "TFlt_GetRnd": [], + "TFlt_Eq6": [], + "TFlt_GetMn": [], + "TFlt_GetMx": [], + "TFlt_GetInRng": [], + "TFlt_GetPrcStr": [], + "TFlt_GetKiloStr": [], + "TFlt_GetMegaStr": [], + "TFlt_GetGigaStr": [], + "TFltRect_Intersection": [], + "TIntV_SwapI": [], + "TIntV_GetV": [], + "TIntIntVV_SwapI": [], + "TIntIntVV_GetV": [], + "TStrV_SwapI": [], + "TStrV_GetV": [], + "TPrGraph": [], + "accept_array": [], + "print_array": [], + "PyTFltV": [], + "PyToTIntV": [], + "count": [], + "TIntVToPy": [], + "TNEANet_New": [], + "TNEANet_Load": [], + "PercentDegree": [], + "PercentMxWcc": [], + "PercentMxScc": [], + "LoadEdgeList": [], + "PrintGraphStatTable": [], + "GenRndGnm": [], + "NodesGTEDegree": [], + "MxDegree": [], + "MxSccSz": [], + "MxWccSz": [], + "PNEANet_New": [], + "GetNodeWcc": [], + "IsConnected": [], + "IsWeaklyConn": [], + "GetWccSzCnt": [], + "GetWccs": [], + "GetSccSzCnt": [], + "GetSccs": [], + "GetMxWccSz": [], + "GetMxWcc": [], + "GetMxScc": [], + "GetMxBiCon": [], + "CntInDegNodes": [], + "CntOutDegNodes": [], + "CntDegNodes": [], + "CntNonZNodes": [], + "CntEdgesToSet": [], + "GetMxDegNId": [], + "GetMxInDegNId": [], + "GetMxOutDegNId": [], + "GetInDegCnt": [], + "GetOutDegCnt": [], + "GetDegCnt": [], + "GetDegSeqV": [], + "GetNodeInDegV": [], + "GetNodeOutDegV": [], + "CntUniqUndirEdges": [], + "CntUniqDirEdges": [], + "CntUniqBiDirEdges": [], + "CntSelfEdges": [], + "GetBfsTree": [], + "GetSubTreeSz": [], + "GetNodesAtHop": [], + "GetNodesAtHops": [], + "GetShortPath": [], + "GetBfsFullDiam": [], + "GetBfsEffDiam": [], + "DrawGViz": [], + "GetClustCf": [], + "GetNodeClustCf": [], + "GetTriads": [], + "GetTriadEdges": [], + "GetTriadParticip": [], + "GetCmnNbrs": [], + "GetModularity": [], + "GetEdgesInOut": [], + "GetAnf": [], + "GetAnfEffDiam": [] + }, + "description": "Discovered via AST scan" + }, + { + "package": "dev.examples", + "module": "tneanet-cpp", + "functions": [ + "main" + ], + "classes": [], + "function_signatures": { + "main": [] + }, + "description": "Discovered via AST scan" + }, + { + "package": "dev.examples", + "module": "snapswig-check", + "functions": [ + "BfsDfsTest", + "GVizTest", + "main" + ], + "classes": [ + "GVizTests" + ], + "function_signatures": { + "GVizTest": [ + "NNodes", + "NEdges" + ], + "BfsDfsTest": [ + "NNodes", + "NEdges" + ], + "main": [] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx", + "module": "exception", + "functions": [], + "classes": [ + "NodeNotFound", + "SnapXAlgorithmError", + "SnapXError", + "SnapXException", + "SnapXKeyError", + "SnapXNoPath", + "SnapXTypeError", + "SnapXUnfeasible" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx", + "module": "relabel", + "functions": [ + "convert_node_labels_to_integers", + "relabel_nodes" + ], + "classes": [], + "function_signatures": { + "relabel_nodes": [ + "G", + "mapping", + "copy" + ], + "convert_node_labels_to_integers": [ + "G", + "first_label", + "ordering", + "label_attribute" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx", + "module": "convert", + "functions": [ + "from_dict_of_dicts", + "to_snapx_graph" + ], + "classes": [], + "function_signatures": { + "to_snapx_graph": [ + "data", + "create_using", + "multigraph_input" + ], + "from_dict_of_dicts": [ + "d", + "create_using", + "multigraph_input" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "coreviews", + "functions": [], + "classes": [ + "AdjacencyView", + "AtlasView", + "FilterAdjacency", + "FilterAtlas", + "FilterMultiAdjacency" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "graph", + "functions": [], + "classes": [ + "Graph" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "attrdict", + "functions": [], + "classes": [ + "AttributeDict" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "reportviews", + "functions": [], + "classes": [ + "EdgeDataView", + "EdgeView", + "NodeDataView", + "NodeView", + "OutEdgeDataView", + "OutEdgeView" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "digraph", + "functions": [], + "classes": [ + "DiGraph" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "filters", + "functions": [ + "hide_diedges", + "hide_edges", + "hide_multidiedges", + "hide_multiedges", + "hide_nodes", + "no_filter", + "show_diedges", + "show_edges", + "show_multidiedges", + "show_multiedges" + ], + "classes": [ + "show_nodes" + ], + "function_signatures": { + "no_filter": [], + "hide_nodes": [ + "nodes" + ], + "hide_diedges": [ + "edges" + ], + "hide_edges": [ + "edges" + ], + "hide_multidiedges": [ + "edges" + ], + "hide_multiedges": [ + "edges" + ], + "show_diedges": [ + "edges" + ], + "show_edges": [ + "edges" + ], + "show_multidiedges": [ + "edges" + ], + "show_multiedges": [ + "edges" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "function", + "functions": [ + "freeze", + "frozen", + "set_edge_attributes", + "set_node_attributes" + ], + "classes": [], + "function_signatures": { + "set_node_attributes": [ + "G", + "values", + "name" + ], + "set_edge_attributes": [ + "G", + "values", + "name" + ], + "frozen": [], + "freeze": [ + "G" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.classes", + "module": "graphviews", + "functions": [ + "subgraph_view" + ], + "classes": [], + "function_signatures": { + "subgraph_view": [ + "G", + "filter_node", + "filter_edge" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.algorithms", + "module": "dag", + "functions": [ + "topological_sort" + ], + "classes": [], + "function_signatures": { + "topological_sort": [ + "G" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.algorithms.centrality", + "module": "snap_cent", + "functions": [ + "get_degree_centr" + ], + "classes": [], + "function_signatures": { + "get_degree_centr": [ + "graph", + "nid" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.algorithms.components", + "module": "components", + "functions": [ + "connected_components", + "max_connected_component" + ], + "classes": [], + "function_signatures": { + "connected_components": [ + "G" + ], + "max_connected_component": [ + "G" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.algorithms.shortest_paths", + "module": "weighted", + "functions": [ + "all_pairs_dijkstra", + "all_pairs_dijkstra_path", + "all_pairs_dijkstra_path_length", + "bidirectional_dijkstra", + "dijkstra_path", + "dijkstra_path_length", + "dijkstra_predecessor_and_distance", + "johnson", + "multi_source_dijkstra", + "multi_source_dijkstra_path", + "multi_source_dijkstra_path_length", + "single_source_dijkstra", + "single_source_dijkstra_path", + "single_source_dijkstra_path_length" + ], + "classes": [], + "function_signatures": { + "dijkstra_path": [ + "G", + "source", + "target", + "weight" + ], + "dijkstra_path_length": [ + "G", + "source", + "target", + "weight" + ], + "single_source_dijkstra_path": [ + "G", + "source", + "cutoff", + "weight" + ], + "single_source_dijkstra_path_length": [ + "G", + "source", + "cutoff", + "weight" + ], + "single_source_dijkstra": [ + "G", + "source", + "target", + "cutoff", + "weight" + ], + "multi_source_dijkstra_path": [ + "G", + "sources", + "cutoff", + "weight" + ], + "multi_source_dijkstra_path_length": [ + "G", + "sources", + "cutoff", + "weight" + ], + "multi_source_dijkstra": [ + "G", + "sources", + "target", + "cutoff", + "weight" + ], + "dijkstra_predecessor_and_distance": [ + "G", + "source", + "cutoff", + "weight" + ], + "all_pairs_dijkstra": [ + "G", + "cutoff", + "weight" + ], + "all_pairs_dijkstra_path_length": [ + "G", + "cutoff", + "weight" + ], + "all_pairs_dijkstra_path": [ + "G", + "cutoff", + "weight" + ], + "bidirectional_dijkstra": [ + "G", + "source", + "target", + "weight" + ], + "johnson": [ + "G", + "weight" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.algorithms.shortest_paths", + "module": "unweighted", + "functions": [ + "all_pairs_shortest_path_length", + "bidirectional_shortest_path", + "single_source_shortest_path", + "single_source_shortest_path_length", + "single_target_shortest_path", + "single_target_shortest_path_length" + ], + "classes": [], + "function_signatures": { + "single_source_shortest_path_length": [ + "G", + "source", + "cutoff" + ], + "single_target_shortest_path_length": [ + "G", + "target", + "cutoff" + ], + "all_pairs_shortest_path_length": [ + "G", + "cutoff" + ], + "bidirectional_shortest_path": [ + "G", + "source", + "target" + ], + "single_source_shortest_path": [ + "G", + "source", + "cutoff" + ], + "single_target_shortest_path": [ + "G", + "target", + "cutoff" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.algorithms.community", + "module": "snap_cmty", + "functions": [ + "community_CNM", + "community_girvan_newman" + ], + "classes": [], + "function_signatures": { + "community_CNM": [ + "graph" + ], + "community_girvan_newman": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.utils", + "module": "misc", + "functions": [ + "pairwise" + ], + "classes": [], + "function_signatures": { + "pairwise": [ + "iterable", + "cyclic" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.utils", + "module": "decorator", + "functions": [ + "append", + "contextmanager", + "decorate", + "decorator", + "dispatch_on" + ], + "classes": [ + "ContextManager", + "FunctionMaker" + ], + "function_signatures": { + "decorate": [ + "func", + "caller", + "extras" + ], + "decorator": [ + "caller", + "_func" + ], + "contextmanager": [ + "func" + ], + "append": [ + "a", + "vancestors" + ], + "dispatch_on": [] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.utils", + "module": "decorators", + "functions": [ + "nodes_or_number", + "not_implemented_for" + ], + "classes": [], + "function_signatures": { + "nodes_or_number": [ + "which_args" + ], + "not_implemented_for": [] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.generators", + "module": "classic", + "functions": [ + "empty_graph", + "path_graph" + ], + "classes": [], + "function_signatures": { + "empty_graph": [ + "n", + "create_using", + "default" + ], + "path_graph": [ + "n", + "create_using" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "snapx.snapx.generators", + "module": "ego", + "functions": [ + "ego_graph" + ], + "classes": [], + "function_signatures": { + "ego_graph": [ + "G", + "n", + "radius", + "sample", + "traversal", + "copy_attr" + ] + }, + "description": "Discovered via AST scan" + } + ], + "cli_commands": [], + "import_strategy": { + "primary": "import", + "fallback": "blackbox", + "confidence": 0.9 + }, + "dependencies": { + "required": [ + "python (runtime)", + "snapx package modules under source.snapx.snapx" + ], + "optional": [ + "networkx (for interoperability paths in convert layer, if used)", + "compiled SNAP/SWIG extension for source.swig.snap usage", + "numpy/scipy (only if specific algorithm paths request them indirectly)" + ] + }, + "risk_assessment": { + "import_feasibility": 0.82, + "intrusiveness_risk": "low", + "complexity": "medium" + } + }, + "deepwiki_analysis": { + "repo_url": "https://github.com/snap-stanford/snap-python", + "repo_name": "snap-python", + "error": "DeepWiki analysis failed", + "model": "gpt-5.3-codex", + "source": "llm_direct_analysis", + "success": false + }, + "deepwiki_options": { + "enabled": true, + "model": "gpt-5.3-codex" + }, + "risk": { + "import_feasibility": 0.82, + "intrusiveness_risk": "low", + "complexity": "medium" + } +} \ No newline at end of file diff --git a/snap-python/mcp_output/diff_report.md b/snap-python/mcp_output/diff_report.md new file mode 100644 index 0000000000000000000000000000000000000000..1769bec05387b01b5eebd5a065af83c643a7c4f4 --- /dev/null +++ b/snap-python/mcp_output/diff_report.md @@ -0,0 +1,133 @@ +# Difference Report — `snap-python` + +**Generated:** 2026-03-11 23:35:38 +**Repository:** `snap-python` +**Project Type:** Python library +**Scope:** Basic functionality +**Change Intrusiveness:** None +**Workflow Status:** ✅ Success +**Test Status:** ❌ Failed + +--- + +## 1) Project Overview + +This change set introduces **8 new files** with **no modifications** to existing files. +The update appears to be an additive baseline increment for core/library scaffolding or initial feature enablement, with no direct refactors to current code paths. + +--- + +## 2) Change Summary + +| Metric | Value | +|---|---| +| New files | 8 | +| Modified files | 0 | +| Deleted files | 0 (not reported) | +| Intrusive changes | None | +| CI/Workflow | Success | +| Tests | Failed | + +### Interpretation +- The delivery is structurally low-risk in terms of regressions to existing files. +- However, **failed tests** indicate integration, environment, or quality-gate issues that currently block confidence in release readiness. + +--- + +## 3) Difference Analysis + +## 3.1 Functional Delta +- Since only new files were added, this likely introduces: + - new module(s), utility code, or packaging/config artifacts, + - potential test assets and/or docs scaffolding. +- No existing behavior is explicitly rewritten, but runtime behavior can still change if imports, entry points, or package discovery now include new modules. + +## 3.2 Risk Profile +- **Code churn risk:** Low (no modified files). +- **Integration risk:** Medium (new files can alter dependency graph, import order, packaging metadata, or test discovery). +- **Release risk:** Medium–High due to failed tests. + +--- + +## 4) Technical Analysis + +## 4.1 CI vs Test Signal +- **Workflow success + test failure** commonly means: + 1. Pipeline execution succeeded technically (jobs ran to completion), + 2. but quality gate failed at the test stage. + +## 4.2 Likely Failure Categories (for additive-only changes) +- Missing/incorrect test fixtures for new modules. +- Import path or package init issues (`__init__.py`, relative imports, namespace package behavior). +- Dependency/version mismatch introduced by new files or metadata. +- Pytest discovery picking up incomplete tests or placeholders. +- Type/runtime assumptions not met in CI environment. + +## 4.3 Maintainability Impact +- Additive changes improve extensibility if structured cleanly. +- Without passing tests, maintainability confidence is reduced (uncertain behavior contract). + +--- + +## 5) Recommendations & Improvements + +## 5.1 Immediate (Blocker Resolution) +1. **Triage failing tests first** + - Identify exact failing test cases and stack traces. + - Classify as: test defect vs implementation defect vs environment defect. +2. **Run focused local reproduction** + - Re-run with verbose output (`-vv`) and isolated target modules. +3. **Validate packaging/import topology** + - Confirm module discovery and path correctness for all 8 new files. +4. **Stabilize CI matrix** + - Verify Python version compatibility and dependency lock consistency. + +## 5.2 Quality Hardening +- Add/expand unit tests for each new file’s primary behavior. +- Include smoke tests for package import and minimal public API usage. +- Enforce lint/type checks (if not already gated): `ruff/flake8`, `mypy/pyright`. +- Add coverage threshold for newly introduced modules. + +## 5.3 Process Improvements +- Require “tests pass” as mandatory merge gate. +- Include a brief architectural note for newly added modules (purpose, ownership, API boundary). +- Add changelog entry describing user-visible impact (if any). + +--- + +## 6) Deployment Information + +**Deployment Readiness:** ❌ **Not ready for production release** (due to failed tests) + +### Pre-deployment checklist +- [ ] All test suites pass in CI +- [ ] New files validated for packaging/distribution inclusion +- [ ] Dependency graph unchanged or reviewed +- [ ] Versioning/changelog updated +- [ ] Rollback strategy documented (if release proceeds) + +--- + +## 7) Future Planning + +## 7.1 Short-term (next iteration) +- Resolve current failures and re-run full CI. +- Add regression tests specifically tied to new modules/files. +- Confirm backward compatibility of public APIs. + +## 7.2 Mid-term +- Establish module-level ownership and code health KPIs. +- Introduce automated release notes based on file-level changes. +- Add contract tests for library consumers (import + basic call flows). + +## 7.3 Long-term +- Maintain a stable compatibility matrix across Python versions. +- Implement semantic versioning discipline tied to API impact. +- Improve observability of test failures (flaky test detection, trend dashboards). + +--- + +## 8) Executive Conclusion + +The current diff is **additive and non-intrusive** (8 new files, 0 modified), which is favorable for controlled evolution of the library. +However, **failed tests are a hard release blocker**. Priority should be given to failure triage, import/packaging verification, and targeted test stabilization before deployment. \ No newline at end of file diff --git a/snap-python/mcp_output/mcp_plugin/__init__.py b/snap-python/mcp_output/mcp_plugin/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/snap-python/mcp_output/mcp_plugin/adapter.py b/snap-python/mcp_output/mcp_plugin/adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..02bdbd7a96ba0564318bec1d75462741c0b14cb9 --- /dev/null +++ b/snap-python/mcp_output/mcp_plugin/adapter.py @@ -0,0 +1,383 @@ +import os +import sys +import importlib +import importlib.util +from typing import Any, Dict, Optional, Tuple + +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) + + +class Adapter: + """ + Import-mode adapter for snap-python repository integration. + + This adapter attempts to import repository-local modules discovered by analysis and + exposes callable wrappers with unified response dictionaries. + + All public methods return: + { + "status": "success" | "error" | "fallback", + "mode": "import" | "fallback", + ... + } + """ + + # ------------------------------------------------------------------------- + # Lifecycle and module management + # ------------------------------------------------------------------------- + def __init__(self) -> None: + """ + Initialize adapter in import mode and attempt best-effort module loading. + """ + self.mode = "import" + self._modules: Dict[str, Any] = {} + self._import_errors: Dict[str, str] = {} + self._load_modules() + + def _result(self, status: str, **kwargs: Any) -> Dict[str, Any]: + data = {"status": status, "mode": self.mode} + data.update(kwargs) + return data + + def _safe_import(self, key: str, module_path: str) -> None: + try: + self._modules[key] = importlib.import_module(module_path) + except Exception as e: + self._modules[key] = None + self._import_errors[key] = ( + f"Failed to import '{module_path}'. " + f"Ensure repository source is available under '{source_path}' and dependencies are installed. " + f"Details: {e}" + ) + + def _load_hyphen_module(self, key: str, relative_path: str) -> None: + abs_path = os.path.join(source_path, relative_path) + try: + if not os.path.exists(abs_path): + raise FileNotFoundError( + f"Module file not found at '{abs_path}'. Check repository extraction path." + ) + spec = importlib.util.spec_from_file_location(key, abs_path) + if spec is None or spec.loader is None: + raise ImportError( + f"Could not create import spec for '{abs_path}'." + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + self._modules[key] = module + except Exception as e: + self._modules[key] = None + self._import_errors[key] = ( + f"Failed to load module from '{abs_path}'. " + f"Verify file presence and Python compatibility. Details: {e}" + ) + + def _load_modules(self) -> None: + """ + Load all discovered modules/classes/functions from analysis. + """ + # Classes in setup modules + self._safe_import("setup_setup", "setup") + self._safe_import("swig_setup", "swig.setup") + + # Functions in standard importable module + self._safe_import("genClassFnExt", "swig.gen.genClassFn.archive.genClassFnExt") + + # Functions in modules with hyphenated filenames (manual load) + self._load_hyphen_module("disp_custom", os.path.join("swig", "gen", "disp-custom.py")) + self._load_hyphen_module("tneanet_cpp", os.path.join("dev", "examples", "tneanet-cpp.py")) + self._load_hyphen_module("snapswig_check", os.path.join("dev", "examples", "snapswig-check.py")) + + if self._import_errors: + self.mode = "fallback" + + def health_check(self) -> Dict[str, Any]: + """ + Return adapter/module import status. + + Returns: + dict: Unified status payload with loaded module keys and import errors. + """ + loaded = [k for k, v in self._modules.items() if v is not None] + return self._result( + "success" if not self._import_errors else "fallback", + loaded_modules=loaded, + import_errors=self._import_errors, + guidance=( + "If imports failed, ensure the repository is present under the configured source path, " + "and install optional build/runtime dependencies for SWIG-based modules." + ), + ) + + # ------------------------------------------------------------------------- + # Class instance creators + # ------------------------------------------------------------------------- + def create_setup_swigbuild(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Create instance of setup.SwigBuild. + + Parameters: + *args: Positional arguments forwarded to setup.SwigBuild constructor. + **kwargs: Keyword arguments forwarded to setup.SwigBuild constructor. + + Returns: + dict: status and created instance or actionable error. + """ + module = self._modules.get("setup_setup") + if module is None or not hasattr(module, "SwigBuild"): + return self._result( + "fallback", + error="Class 'SwigBuild' in module 'setup' is unavailable.", + guidance="Ensure 'setup.py' is importable and supports runtime class instantiation.", + ) + try: + instance = module.SwigBuild(*args, **kwargs) + return self._result("success", class_name="SwigBuild", instance=instance) + except Exception as e: + return self._result( + "error", + error=f"Failed to instantiate setup.SwigBuild: {e}", + guidance="Check constructor arguments required by distutils/setuptools command classes.", + ) + + def create_setup_swigextension(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Create instance of setup.SwigExtension. + """ + module = self._modules.get("setup_setup") + if module is None or not hasattr(module, "SwigExtension"): + return self._result( + "fallback", + error="Class 'SwigExtension' in module 'setup' is unavailable.", + guidance="Ensure setup module loads successfully.", + ) + try: + instance = module.SwigExtension(*args, **kwargs) + return self._result("success", class_name="SwigExtension", instance=instance) + except Exception as e: + return self._result( + "error", + error=f"Failed to instantiate setup.SwigExtension: {e}", + guidance="Provide valid extension constructor parameters (name, sources, and config).", + ) + + def create_swig_setup_pkgbuild(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Create instance of swig.setup.PkgBuild. + """ + module = self._modules.get("swig_setup") + if module is None or not hasattr(module, "PkgBuild"): + return self._result( + "fallback", + error="Class 'PkgBuild' in module 'swig.setup' is unavailable.", + guidance="Ensure swig setup module is present and importable.", + ) + try: + instance = module.PkgBuild(*args, **kwargs) + return self._result("success", class_name="PkgBuild", instance=instance) + except Exception as e: + return self._result( + "error", + error=f"Failed to instantiate swig.setup.PkgBuild: {e}", + guidance="Verify arguments expected by build command classes.", + ) + + def create_swig_setup_swigextension(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Create instance of swig.setup.SwigExtension. + """ + module = self._modules.get("swig_setup") + if module is None or not hasattr(module, "SwigExtension"): + return self._result( + "fallback", + error="Class 'SwigExtension' in module 'swig.setup' is unavailable.", + guidance="Ensure swig setup module import succeeds.", + ) + try: + instance = module.SwigExtension(*args, **kwargs) + return self._result("success", class_name="SwigExtension", instance=instance) + except Exception as e: + return self._result( + "error", + error=f"Failed to instantiate swig.setup.SwigExtension: {e}", + guidance="Pass valid extension initialization arguments.", + ) + + # ------------------------------------------------------------------------- + # Function call wrappers + # ------------------------------------------------------------------------- + def call_convert_esubgraph(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call swig.gen.disp-custom.ConvertESubGraph. + + Parameters: + *args: Forwarded to ConvertESubGraph. + **kwargs: Forwarded to ConvertESubGraph. + """ + module = self._modules.get("disp_custom") + if module is None or not hasattr(module, "ConvertESubGraph"): + return self._result( + "fallback", + error="Function 'ConvertESubGraph' is unavailable.", + guidance="Check swig/gen/disp-custom.py availability and compatibility.", + ) + try: + result = module.ConvertESubGraph(*args, **kwargs) + return self._result("success", function="ConvertESubGraph", result=result) + except Exception as e: + return self._result( + "error", + error=f"ConvertESubGraph execution failed: {e}", + guidance="Validate argument types and graph object compatibility.", + ) + + def call_convert_graph(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call swig.gen.disp-custom.ConvertGraph. + """ + module = self._modules.get("disp_custom") + if module is None or not hasattr(module, "ConvertGraph"): + return self._result( + "fallback", + error="Function 'ConvertGraph' is unavailable.", + guidance="Check swig/gen/disp-custom.py load status.", + ) + try: + result = module.ConvertGraph(*args, **kwargs) + return self._result("success", function="ConvertGraph", result=result) + except Exception as e: + return self._result( + "error", + error=f"ConvertGraph execution failed: {e}", + guidance="Ensure provided graph parameters match expected SNAP/SWIG types.", + ) + + def call_convert_subgraph(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call swig.gen.disp-custom.ConvertSubGraph. + """ + module = self._modules.get("disp_custom") + if module is None or not hasattr(module, "ConvertSubGraph"): + return self._result( + "fallback", + error="Function 'ConvertSubGraph' is unavailable.", + guidance="Check swig/gen/disp-custom.py and repository source path.", + ) + try: + result = module.ConvertSubGraph(*args, **kwargs) + return self._result("success", function="ConvertSubGraph", result=result) + except Exception as e: + return self._result( + "error", + error=f"ConvertSubGraph execution failed: {e}", + guidance="Review node/edge subset arguments and graph input types.", + ) + + def call_gen_func_call(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call swig.gen.genClassFn.archive.genClassFnExt.genFuncCall. + """ + module = self._modules.get("genClassFnExt") + if module is None or not hasattr(module, "genFuncCall"): + return self._result( + "fallback", + error="Function 'genFuncCall' is unavailable.", + guidance="Ensure module swig.gen.genClassFn.archive.genClassFnExt imports correctly.", + ) + try: + result = module.genFuncCall(*args, **kwargs) + return self._result("success", function="genFuncCall", result=result) + except Exception as e: + return self._result( + "error", + error=f"genFuncCall execution failed: {e}", + guidance="Verify expected inputs for class/function generation utility.", + ) + + def call_get_func_name(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call swig.gen.genClassFn.archive.genClassFnExt.getFuncName. + """ + module = self._modules.get("genClassFnExt") + if module is None or not hasattr(module, "getFuncName"): + return self._result( + "fallback", + error="Function 'getFuncName' is unavailable.", + guidance="Check import status for swig.gen.genClassFn.archive.genClassFnExt.", + ) + try: + result = module.getFuncName(*args, **kwargs) + return self._result("success", function="getFuncName", result=result) + except Exception as e: + return self._result( + "error", + error=f"getFuncName execution failed: {e}", + guidance="Provide input matching expected parser/line format.", + ) + + def call_remove_first_param(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call swig.gen.genClassFn.archive.genClassFnExt.removeFirstParam. + """ + module = self._modules.get("genClassFnExt") + if module is None or not hasattr(module, "removeFirstParam"): + return self._result( + "fallback", + error="Function 'removeFirstParam' is unavailable.", + guidance="Ensure genClassFnExt module loaded without syntax/runtime issues.", + ) + try: + result = module.removeFirstParam(*args, **kwargs) + return self._result("success", function="removeFirstParam", result=result) + except Exception as e: + return self._result( + "error", + error=f"removeFirstParam execution failed: {e}", + guidance="Check parameter string structure before invoking this utility.", + ) + + def call_tneanet_cpp_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call dev.examples.tneanet-cpp.main. + """ + module = self._modules.get("tneanet_cpp") + if module is None or not hasattr(module, "main"): + return self._result( + "fallback", + error="Function 'main' in tneanet-cpp is unavailable.", + guidance="Check file dev/examples/tneanet-cpp.py exists and is valid.", + ) + try: + result = module.main(*args, **kwargs) + return self._result("success", function="tneanet_cpp.main", result=result) + except Exception as e: + return self._result( + "error", + error=f"tneanet_cpp.main execution failed: {e}", + guidance="Confirm runtime prerequisites for example script are met.", + ) + + def call_snapswig_check_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: + """ + Call dev.examples.snapswig-check.main. + """ + module = self._modules.get("snapswig_check") + if module is None or not hasattr(module, "main"): + return self._result( + "fallback", + error="Function 'main' in snapswig-check is unavailable.", + guidance="Check file dev/examples/snapswig-check.py exists and imports succeed.", + ) + try: + result = module.main(*args, **kwargs) + return self._result("success", function="snapswig_check.main", result=result) + except Exception as e: + return self._result( + "error", + error=f"snapswig_check.main execution failed: {e}", + guidance="Ensure SWIG SNAP extension is built and importable before running checks.", + ) \ No newline at end of file diff --git a/snap-python/mcp_output/mcp_plugin/main.py b/snap-python/mcp_output/mcp_plugin/main.py new file mode 100644 index 0000000000000000000000000000000000000000..fca6ec384e22f703b287550e94cc00baaaa4c4a7 --- /dev/null +++ b/snap-python/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/snap-python/mcp_output/mcp_plugin/mcp_service.py b/snap-python/mcp_output/mcp_plugin/mcp_service.py new file mode 100644 index 0000000000000000000000000000000000000000..5bf647540304673331e827780823807a25223f3d --- /dev/null +++ b/snap-python/mcp_output/mcp_plugin/mcp_service.py @@ -0,0 +1,271 @@ +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 + +from setup import SwigExtension, SwigBuild +from swig.setup import SwigExtension, PkgBuild +from swig.gen.disp-custom import ConvertGraph, ConvertSubGraph, ConvertESubGraph +from swig.gen.genClassFn.archive.genClassFnExt import removeFirstParam, genFuncCall, getFuncName +from dev.examples.tneanet-cpp import main +from dev.examples.snapswig-check import main + +mcp = FastMCP("unknown_service") + + +@mcp.tool(name="swigbuild", description="SwigBuild class") +def swigbuild(*args, **kwargs): + """SwigBuild class""" + try: + if SwigBuild is None: + return {"success": False, "result": None, "error": "Class SwigBuild is not available, path may need adjustment"} + + # MCP parameter type conversion + converted_args = [] + converted_kwargs = kwargs.copy() + + # Handle position argument type conversion + for arg in args: + if isinstance(arg, str): + # Try to convert to numeric type + try: + if '.' in arg: + converted_args.append(float(arg)) + else: + converted_args.append(int(arg)) + except ValueError: + converted_args.append(arg) + else: + converted_args.append(arg) + + # Handle keyword argument type conversion + for key, value in converted_kwargs.items(): + if isinstance(value, str): + try: + if '.' in value: + converted_kwargs[key] = float(value) + else: + converted_kwargs[key] = int(value) + except ValueError: + pass + + instance = SwigBuild(*converted_args, **converted_kwargs) + return {"success": True, "result": str(instance), "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="swigextension", description="SwigExtension class") +def swigextension(*args, **kwargs): + """SwigExtension class""" + try: + if SwigExtension is None: + return {"success": False, "result": None, "error": "Class SwigExtension is not available, path may need adjustment"} + + # MCP parameter type conversion + converted_args = [] + converted_kwargs = kwargs.copy() + + # Handle position argument type conversion + for arg in args: + if isinstance(arg, str): + # Try to convert to numeric type + try: + if '.' in arg: + converted_args.append(float(arg)) + else: + converted_args.append(int(arg)) + except ValueError: + converted_args.append(arg) + else: + converted_args.append(arg) + + # Handle keyword argument type conversion + for key, value in converted_kwargs.items(): + if isinstance(value, str): + try: + if '.' in value: + converted_kwargs[key] = float(value) + else: + converted_kwargs[key] = int(value) + except ValueError: + pass + + instance = SwigExtension(*converted_args, **converted_kwargs) + return {"success": True, "result": str(instance), "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="pkgbuild", description="PkgBuild class") +def pkgbuild(*args, **kwargs): + """PkgBuild class""" + try: + if PkgBuild is None: + return {"success": False, "result": None, "error": "Class PkgBuild is not available, path may need adjustment"} + + # MCP parameter type conversion + converted_args = [] + converted_kwargs = kwargs.copy() + + # Handle position argument type conversion + for arg in args: + if isinstance(arg, str): + # Try to convert to numeric type + try: + if '.' in arg: + converted_args.append(float(arg)) + else: + converted_args.append(int(arg)) + except ValueError: + converted_args.append(arg) + else: + converted_args.append(arg) + + # Handle keyword argument type conversion + for key, value in converted_kwargs.items(): + if isinstance(value, str): + try: + if '.' in value: + converted_kwargs[key] = float(value) + else: + converted_kwargs[key] = int(value) + except ValueError: + pass + + instance = PkgBuild(*converted_args, **converted_kwargs) + return {"success": True, "result": str(instance), "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="swigextension", description="SwigExtension class") +def swigextension(*args, **kwargs): + """SwigExtension class""" + try: + if SwigExtension is None: + return {"success": False, "result": None, "error": "Class SwigExtension is not available, path may need adjustment"} + + # MCP parameter type conversion + converted_args = [] + converted_kwargs = kwargs.copy() + + # Handle position argument type conversion + for arg in args: + if isinstance(arg, str): + # Try to convert to numeric type + try: + if '.' in arg: + converted_args.append(float(arg)) + else: + converted_args.append(int(arg)) + except ValueError: + converted_args.append(arg) + else: + converted_args.append(arg) + + # Handle keyword argument type conversion + for key, value in converted_kwargs.items(): + if isinstance(value, str): + try: + if '.' in value: + converted_kwargs[key] = float(value) + else: + converted_kwargs[key] = int(value) + except ValueError: + pass + + instance = SwigExtension(*converted_args, **converted_kwargs) + return {"success": True, "result": str(instance), "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="ConvertESubGraph", description="Auto-wrapped function ConvertESubGraph") +def ConvertESubGraph(payload: dict): + try: + if ConvertESubGraph is None: + return {"success": False, "result": None, "error": "Function ConvertESubGraph is not available"} + result = ConvertESubGraph(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="ConvertGraph", description="Auto-wrapped function ConvertGraph") +def ConvertGraph(payload: dict): + try: + if ConvertGraph is None: + return {"success": False, "result": None, "error": "Function ConvertGraph is not available"} + result = ConvertGraph(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="ConvertSubGraph", description="Auto-wrapped function ConvertSubGraph") +def ConvertSubGraph(payload: dict): + try: + if ConvertSubGraph is None: + return {"success": False, "result": None, "error": "Function ConvertSubGraph is not available"} + result = ConvertSubGraph(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="genFuncCall", description="Auto-wrapped function genFuncCall") +def genFuncCall(payload: dict): + try: + if genFuncCall is None: + return {"success": False, "result": None, "error": "Function genFuncCall is not available"} + result = genFuncCall(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="getFuncName", description="Auto-wrapped function getFuncName") +def getFuncName(payload: dict): + try: + if getFuncName is None: + return {"success": False, "result": None, "error": "Function getFuncName is not available"} + result = getFuncName(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="removeFirstParam", description="Auto-wrapped function removeFirstParam") +def removeFirstParam(payload: dict): + try: + if removeFirstParam is None: + return {"success": False, "result": None, "error": "Function removeFirstParam is not available"} + result = removeFirstParam(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="main", description="Auto-wrapped function main") +def main(payload: dict): + try: + if main is None: + return {"success": False, "result": None, "error": "Function main is not available"} + result = main(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + +@mcp.tool(name="main", description="Auto-wrapped function main") +def main(payload: dict): + try: + if main is None: + return {"success": False, "result": None, "error": "Function main is not available"} + result = main(**payload) + return {"success": True, "result": result, "error": None} + except Exception as e: + return {"success": False, "result": None, "error": str(e)} + + + +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/snap-python/mcp_output/requirements.txt b/snap-python/mcp_output/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..03c0670452e2e1512d75e3a948723e5e5e76bb71 --- /dev/null +++ b/snap-python/mcp_output/requirements.txt @@ -0,0 +1,5 @@ +fastmcp +fastapi +uvicorn[standard] +pydantic>=2.0.0 +snapx package modules under source.snapx.snapx diff --git a/snap-python/mcp_output/start_mcp.py b/snap-python/mcp_output/start_mcp.py new file mode 100644 index 0000000000000000000000000000000000000000..fc7fcbd9646ad53f089fc94af8129043a703325a --- /dev/null +++ b/snap-python/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/snap-python/mcp_output/workflow_summary.json b/snap-python/mcp_output/workflow_summary.json new file mode 100644 index 0000000000000000000000000000000000000000..5eebc3bae2af2cda0b71c96b76068990ae4d03ca --- /dev/null +++ b/snap-python/mcp_output/workflow_summary.json @@ -0,0 +1,209 @@ +{ + "repository": { + "name": "snap-python", + "url": "https://github.com/snap-stanford/snap-python", + "local_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/snap-python", + "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": 1773242722.183267, + "end_time": 1773243206.42227, + "duration": 484.23900389671326, + "status": "success", + "workflow_status": "success", + "nodes_executed": [ + "download", + "analysis", + "env", + "generate", + "run", + "review", + "finalize" + ], + "total_files_processed": 2, + "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.snapx.snapx", + "source.swig.snap" + ] + }, + "dependencies": { + "has_environment_yml": false, + "has_requirements_txt": false, + "pyproject": false, + "setup_cfg": false, + "setup_py": true + }, + "entry_points": { + "imports": [], + "cli": [], + "modules": [] + }, + "risk_assessment": { + "import_feasibility": 0.82, + "intrusiveness_risk": "low", + "complexity": "medium" + }, + "deepwiki_analysis": { + "repo_url": "https://github.com/snap-stanford/snap-python", + "repo_name": "snap-python", + "error": "DeepWiki analysis failed", + "model": "gpt-5.3-codex", + "source": "llm_direct_analysis", + "success": false + }, + "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": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/snap-python/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": [ + "add a minimal CI pipeline (GitHub Actions) to build/install the SWIG extension and run both `test/` and `snapx/snapx/classes/tests/`", + "consolidate packaging into a single modern `pyproject.toml` (keep one `setup.py` path only) and define optional extras (e.g. `dev`", + "`docs`", + "`interop`)", + "add a top-level `requirements.txt` or lockfile for reproducible local/dev installs", + "deduplicate legacy `dev/` vs main `examples/` and `test/` trees to reduce maintenance drift", + "split the huge generated `setup/snap.py` into generated+checked artifacts with clear regeneration scripts and version pinning", + "standardize naming/style (many legacy test filenames and mixed conventions) and enforce with `ruff`/`black`/`isort`", + "introduce test markers for slow/integration/SWIG-dependent tests and publish baseline coverage", + "add smoke tests for key MCP endpoints and auto-generate endpoint docs from adapter metadata", + "improve README with a clear “pure Python snapx vs compiled SNAP/SWIG” architecture/install matrix", + "add typed public APIs for `snapx` (at least core graph/algorithms) and run `mypy` in CI", + "add benchmark automation comparing key algorithms across representative graph sizes and track regressions", + "add dependency/security scanning (Dependabot + pip-audit) and binary build checks across Python versions/platforms", + "add contributor docs for build toolchain prerequisites (SWIG/compiler) and a troubleshooting decision tree", + "remove or gate large test/example data files from source distribution where possible and fetch on demand", + "create a release checklist that validates wheel/sdist contents and MCP plugin compatibility before tagging" + ], + "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": [ + "Workflow completed end-to-end with status=success across all planned nodes (download, analysis, env, generate, run, review, finalize).", + "Import-based adapter strategy was feasible (import_feasibility=0.82), enabling plugin startup without invasive code changes.", + "MCP plugin runtime checks passed (service_health=healthy, transport=stdio), confirming baseline service operability.", + "Low assessed intrusiveness risk reduced integration friction with legacy mixed codebase (snapx + SWIG layers)." + ], + "failure_reasons": [ + "No hard workflow failure occurred.", + "Quality signal gap: original project tests were not executed successfully (passed=false with empty details), so behavioral equivalence is unverified.", + "DeepWiki enrichment failed, reducing external architectural/context confidence.", + "Telemetry incompleteness (0/unknown metrics for LOC, file size, CPU, memory, response time) limits objective performance validation." + ], + "overall_assessment": "good", + "node_performance": { + "download_time": "Repository ingest succeeded via zip fallback; effective for reliability, but likely slower/less metadata-rich than native clone.", + "analysis_time": "AST/module discovery covered a large surface (hundreds of functions/classes), indicating substantial analysis effort and likely primary time contributor.", + "generation_time": "Generation completed quickly enough to produce full plugin scaffold (entrypoint, adapter, service, docs, requirements) with no generation errors.", + "test_time": "MCP smoke/health checks passed, but project-level test execution was effectively absent; test stage is functionally incomplete for regression assurance." + }, + "resource_usage": { + "memory_efficiency": "Unknown due to missing metrics; no OOM/failure signs, so operationally acceptable but not measurable.", + "cpu_efficiency": "Unknown due to missing CPU telemetry; long total runtime (~484s) suggests analysis/reflection overhead on large API surface.", + "disk_usage": "Generated artifact size reported as 0 (likely instrumentation issue); repository includes large files, so packaging/disk controls should be tightened." + } + }, + "technical_quality": { + "code_quality_score": 74, + "architecture_score": 78, + "performance_score": 62, + "maintainability_score": 68, + "security_score": 85, + "scalability_score": 70 + } +} \ No newline at end of file diff --git a/snap-python/source/.DS_Store b/snap-python/source/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..efbc6ee701015326632ad8affd108baa9a7fe233 Binary files /dev/null and b/snap-python/source/.DS_Store differ diff --git a/snap-python/source/CREDITS.txt b/snap-python/source/CREDITS.txt new file mode 100644 index 0000000000000000000000000000000000000000..6e808ab71da6b1ce29201386fef384c3111f7d65 --- /dev/null +++ b/snap-python/source/CREDITS.txt @@ -0,0 +1,34 @@ +Snap.py is a Python interface for SNAP. SNAP is a general purpose, high +performance system for analysis and manipulation of large networks. SNAP +is written in C++ and optimized for maximum performance and compact graph +representation. It easily scales to massive networks with hundreds of +millions of nodes, and billions of edges. + +Snap.py provides performance benefits of SNAP, combined with flexibility +of Python. Most of the SNAP functionality is available via Snap.py in Python. + +The following people contributed to the development of Snap.py (in +alphabetical order): +Ruth-Ann Armstrong +Roger Chen +Benoît Coste +Carlos Hernandez +Jihun Hong +Farzaan Kaiyom +Viswesh Krishna +Daiki Kumazawa +Jure Leskovec +Stephen Macke +Ben Pastel +Karthik Ramachandran +Sheila Ramaswamy +Avery Rogers +Nicholas Shelly +Rok Sosic +Ming Han Teh +Cameron Tew +Albert Zheng + +Special thanks go to the students in the 2013 class of CS224W at Stanford +University, who helped with the initial version of the manuals and the beta +releases of Snap.py. diff --git a/snap-python/source/LICENSE b/snap-python/source/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f07e0ccba446b922c4342e71514c071bc2367b7a --- /dev/null +++ b/snap-python/source/LICENSE @@ -0,0 +1,24 @@ +* Copyright (c) 2007-2019, Jure Leskovec +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* * Neither the name of Stanford University nor the names of its contributors +* may be used to endorse or promote products derived from this software +* without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY +* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY +* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/snap-python/source/MANIFEST.in b/snap-python/source/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..9870fbafe2dd0a0fcddaa942ba5801a513304a2c --- /dev/null +++ b/snap-python/source/MANIFEST.in @@ -0,0 +1 @@ +include snap/__init__.py diff --git a/snap-python/source/Makefile b/snap-python/source/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..33b5ceb94230f9a88630401c195b2f3145f1d419 --- /dev/null +++ b/snap-python/source/Makefile @@ -0,0 +1,26 @@ +# +# Top level Python SNAP Makefile +# + +.PHONY: swig test examples + +build: swig + +#all: swig-r swig-sw test examples +all: swig test examples + +# run SWIG and create Python interface code +swig: + make -C swig + +# run tests +test: + make -C test + +examples: + make -C examples + +clean: + make -C swig clean + make -C test clean + make -C examples clean diff --git a/snap-python/source/Makefile.config b/snap-python/source/Makefile.config new file mode 100644 index 0000000000000000000000000000000000000000..1c3e463768774cc838ab375473b5adb044e80cd3 --- /dev/null +++ b/snap-python/source/Makefile.config @@ -0,0 +1,174 @@ +# +# compilation parameters for SNAP Python +# + +UNAME := $(shell uname) +SETUP = setup.py + +ifeq ($(UNAME), Linux) + # Linux flags + SWIGFLAGS += -D_CMPWARN -D__stdcall -DSW_SNAPPY -D_OPENMP -DNONUMPY -DUSE_OPENMP -DGCC_ATOMIC + CXXFLAGS += -fPIC -D__STDC_LIMIT_MACROS -DSW_SNAPPY -fopenmp + MANIFEST = MANIFEST.nx + MANIFEST_IN = MANIFEST.in.nx + PYTHON = python + PYTHON3 = python3 + # SNAP_PY is set externally for the manylinux1 environment + ifeq ($(SNAP_PY), 3.9) + IFLAGS3 = -I/opt/python/cp39-cp39/include/python3.9 + LDFLAGS3 += -shared -fopenmp + PYTHON3 = /opt/python/cp39-cp39/bin/python3 + else ifeq ($(SNAP_PY), 3.8) + IFLAGS3 = -I/opt/python/cp38-cp38/include/python3.8 + LDFLAGS3 += -shared -fopenmp + PYTHON3 = /opt/python/cp38-cp38/bin/python3 + else ifeq ($(SNAP_PY), 3.7) + IFLAGS3 = -I/opt/python/cp37-cp37m/include/python3.7m + LDFLAGS3 += -shared -fopenmp + PYTHON3 = /opt/python/cp37-cp37m/bin/python3 + else ifeq ($(SNAP_PY), 3.6) + IFLAGS3 = -I/opt/python/cp36-cp36m/include/python3.6m + LDFLAGS3 += -shared -fopenmp + PYTHON3 = /opt/python/cp36-cp36m/bin/python3 + else ifeq ($(SNAP_PY), 3.5) + IFLAGS3 = -I/opt/python/cp35-cp35m/include/python3.5m + LDFLAGS3 += -shared -fopenmp + PYTHON3 = /opt/python/cp35-cp35m/bin/python3 + else ifeq ($(SNAP_PY), 2.7m) + IFLAGS = -I/opt/python/cp27-cp27m/include/python2.7 + LDFLAGS += -shared -fopenmp + PYTHON = /opt/python/cp27-cp27m/bin/python2 + else ifeq ($(SNAP_PY), 2.7mu) + IFLAGS = -I/opt/python/cp27-cp27mu/include/python2.7 + LDFLAGS += -shared -fopenmp + PYTHON = /opt/python/cp27-cp27mu/bin/python2 + else + IFLAGS ?= -I/usr/include/python2.6 -I/usr/include/python2.7 -I/usr/lib/python2.7/dist-packages/numpy/core/include + IFLAGS3 ?= -I/usr/local/include/python3.7m -I/usr/include/python3.7m + IFLAGS3 += -I/usr/local/include/python3.6m -I/usr/include/python3.6m + IFLAGS3 += -I/usr/local/include/python3.5m -I/usr/include/python3.5m + LDFLAGS += -shared -fopenmp + LDFLAGS3 += -shared -fopenmp + endif +else ifeq ($(UNAME), Darwin) + # OS X flags + CC = g++ + SWIGFLAGS += -D_CMPWARN -D__stdcall -DSW_SNAPPY -DNONUMPY + CXXFLAGS = -std=c++98 -fwrapv -Wall -Wno-unknown-pragmas -O3 -DNDEBUG -DNOMP -DSW_SNAPPY + CXXFLAGS += -DSW_SNAPPY + + MANIFEST = MANIFEST.mac + MANIFEST_IN = MANIFEST.in.nx + PYTHON = python + PYTHON3 = python3 + IFLAGS = -I/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/include + IFLAGS3 = $(IFLAGS) + LDFLAGS = -bundle -undefined dynamic_lookup + LDFLAGS += -L/usr/local/opt/readline/lib -L/usr/local/opt/openssl@1.1/lib + LDFLAGS3 = $(LDFLAGS) + # SNAP_PY is set externally for the python build environment + ifeq ($(SNAP_PY), 2.7) + PYPATH = /Users/rok/.pyenv/versions/2.7.18 + CXXFLAGS += -fno-strict-aliasing + IFLAGS += -I$(PYPATH)/include/python2.7 + LDFLAGS += -L$(PYPATH)/lib + else ifeq ($(SNAP_PY), 3.5) + PYPATH = /Users/rok/.pyenv/versions/3.5.10 + IFLAGS3 += -I$(PYPATH)/include/python3.5m + LDFLAGS3 += -L$(PYPATH)/lib + else ifeq ($(SNAP_PY), 3.6) + PYPATH = /Users/rok/.pyenv/versions/3.6.12 + IFLAGS3 += -I$(PYPATH)/include/python3.6m + LDFLAGS3 += -L$(PYPATH)/lib + else ifeq ($(SNAP_PY), 3.7) + PYPATH = /Users/rok/.pyenv/versions/3.7.9 + IFLAGS3 += -I$(PYPATH)/include/python3.7m + LDFLAGS3 += -L$(PYPATH)/lib + else ifeq ($(SNAP_PY), 3.8) + PYPATH = /Users/rok/.pyenv/versions/3.8.6 + IFLAGS3 += -I$(PYPATH)/include/python3.8 + LDFLAGS3 += -L$(PYPATH)/lib + else ifeq ($(SNAP_PY), 3.9) + PYPATH = /Users/rok/.pyenv/versions/3.9.0 + IFLAGS3 += -I$(PYPATH)/include/python3.9 + LDFLAGS3 += -L$(PYPATH)/lib + else + + # the build environment is not specified, try to figure out the parameters + PY_CONDA3 := $(shell which python3 | grep conda3) + PY_BREW := $(shell which python3 | grep local) + + IFLAGS := $(shell python-config --includes) + IFLAGS3 := $(shell python3-config --includes) + LDFLAGS := $(shell python-config --ldflags) -dynamiclib -headerpad_max_install_names + LDFLAGS3 := $(shell python3-config --ldflags) -dynamiclib -headerpad_max_install_names + CLANG := $(shell g++ -v 2>&1 | grep clang | cut -d " " -f 2) + ifeq ($(CLANG), LLVM) + CXXFLAGS += -DNOMP + CXXOPENMP = + else ifeq ($(CLANG), clang) + CXXFLAGS += -DNOMP + CXXOPENMP = + else + #SWIGFLAGS += -DGCC_ATOMIC + CXXFLAGS += -fopenmp + LDFLAGS += -fopenmp + #CXXOPENMP += -fopenmp + endif + ifneq ($(PY_CONDA3), ) + CC = x86_64-apple-darwin13.4.0-clang + CXXFLAGS = -std=c++98 -Wall -Wno-unknown-pragmas -O3 + CXXFLAGS += -fPIC -flto -mmacosx-version-min=10.9 + CXXFLAGS += -DNDEBUG -DSW_SNAPPY -DNOMP + CXXFLAGS += -isystem $(CONDA_PREFIX)/include + IFLAGS3 = -I$(CONDA_PREFIX)/include/python3.7m + LDFLAGS3 = -bundle -undefined dynamic_lookup -flto -arch x86_64 -mmacosx-version-min=10.9 + LDFLAGS3 += -isystem $(CONDA_PREFIX)/include + LDFLAGS3 += -L$(CONDA_PREFIX)/lib + LIBS = + endif + + ifneq ($(PY_BREW), ) + CC = clang + CXXFLAGS = -std=c++98 -Wall -Wno-unknown-pragmas -O3 + CXXFLAGS += -dynamic + CXXFLAGS += -DNDEBUG -DSW_SNAPPY -DNOMP + CXXFLAGS += -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk + IFLAGS3 = -I/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/include + IFLAGS3 += -I/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Tk.framework/Versions/8.5/Headers + IFLAGS3 += -I/usr/local/include + IFLAGS3 += -I/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/include/python3.7m + LDFLAGS3 = -bundle -undefined dynamic_lookup -flto + LDFLAGS3 += -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk + LDFLAGS3 += -L/usr/local/lib + LIBS = + endif + endif + +else ifeq ($(shell uname -o), Cygwin) + # Cygwin flags + SWIGFLAGS += -D_CMPWARN -D__stdcall -DSW_SNAPPY -DNONUMPY + CXXFLAGS += -shared -D__STDC_LIMIT_MACROS -DSW_SNAPPY + LIBS += -lpython2.6 + MANIFEST = MANIFEST.win + MANIFEST_IN = MANIFEST.in.win + + ifeq ($(SNAP_PY), 2.7) + PYTHON = /cygdrive/c/Python27/python + else ifeq ($(SNAP_PY), 3.5) + PYTHON = /cygdrive/c/Program\ Files/Python35/python + else ifeq ($(SNAP_PY), 3.6) + PYTHON = /cygdrive/c/Program\ Files/Python36/python + else ifeq ($(SNAP_PY), 3.7) + PYTHON = /cygdrive/c/Program\ Files/Python37/python + else ifeq ($(SNAP_PY), 3.8) + PYTHON = /cygdrive/c/Program\ Files/Python38/python + else ifeq ($(SNAP_PY), 3.9) + PYTHON = /cygdrive/c/Program\ Files/Python39/python + endif +else + PYTHON = "/cygdrive/c/Program\ Files/Python37/python" +endif + +SWIGFLAGS3 += $(SWIGFLAGS) + diff --git a/snap-python/source/README.md b/snap-python/source/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ebb20372d9e063e6d67950c88c7e72fa62cf4546 --- /dev/null +++ b/snap-python/source/README.md @@ -0,0 +1,112 @@ +snap-python +=========== + +1. Install SWIG for your platform (see below). Swig should be able to run from the command-line. + +2. Checkout the snap-python repository as well as the SNAP C++ repository. + + git clone git@github.com:snap-stanford/snap-python.git + git clone git@github.com:snap-stanford/snap.git + +2. Then, run `make` from the top-level of `snap-python`. This will make the SNAP code into a Python module, using SWIG. Finally, it will run some Python tests in the `test` directory. + + cd snap-python + make + + From a Python interpreter, you should be able to import `snap` module: + + $ python + >>> import sys + >>> sys.path.append("swig") + >>> import snap + +3. There are some examples in the `examples` directory. For example, to run benchmarks: + + $ cd examples + $ python benchmark.py -h + usage: benchmark.py [-h] [-v] [-r RANGE] [-e EDGES_DEG] [-d] [-t GRAPH_TYPES] + [-n NUM_ITERATIONS] [-o OUTPUT_FILE] [-g] [-w] + + optional arguments: + -h, --help show this help message and exit + -v, --verbose increase output verbosity + -r RANGE, --range RANGE + range (4-6) (10^4 to 10^6 nodes) + -e EDGES_DEG, --edges_deg EDGES_DEG + range of degrees (e.g "2-3" => (10^1 to 10^3 edges per + node) + -d, --deterministic deterministic benchmark + -t GRAPH_TYPES, --graph_types GRAPH_TYPES + Graph types, comma separated. Available: rand_ungraph, + rand_ngraph, rmat, pref, sw + -n NUM_ITERATIONS, --num_iterations NUM_ITERATIONS + number of iterations + -o OUTPUT_FILE, --output_file OUTPUT_FILE + file to output results + -g, --generate generate new graphs + -w, --write_graph save graph + $ python benchmark.py -v -g -r 4-6 # needs about 4.3GB RAM and 4 min to run + + +SWIG Installation +----------------- + +### Linux + +Follow the instructions from SWIG's website: download, configure and make, [SWIG files](http://www.swig.org/download.html). Or, use your built-in installer (a CentOS example): + + sudo yum install swig + +### Mac OS X + +swig-1.3.12 and later support OS-X/Darwin. + +0. If you have ``homebrew``, simply hit ``brew install swig`` in terminal and ignore the rest of the instructions. Otherwise, download the Unix sources, configure, and build from the command terminal. This has been tested on 10.8.2. The following is adopted from [ColourBlomb](http://blog.colourbomb.net/?p=49). + +1. Download the Unix source from http://swig.org/download.html + +2. Moving to the terminal, extract the files from the tarball and move to the root directory of the SWIG install: + + cd /Developer/SWIG + tar -xf swig-2.0.4.tar.gz + cd swig-2.0.4 + +3. Run `./configure`. This will produce an error if you don't have the PCRE (Perl Compatible Regular Expressions) library package installed. +This dependency is needed for configure to complete. Either: + - Install the PCRE developer package on your system (preferred approach). + - Download the PCRE source tarball, build and install on your system + as you would for any package built from source distribution. + - Use the `Tools/pcre-build.sh` script to build PCRE just for SWIG to statically + link against. Run `Tools/pcre-build.sh -help` for instructions. + (quite easy and does not require privileges to install PCRE on your system) + - Configure using the `-without-pcre` option to disable regular expressions support in SWIG + (not recommended). + See `config.log` for more details. + + make + sudo make install + +4. PCRE should now have successfully installed so move to the swig install directory and try `./configure` again: + + cd ../swig-2.0.4 + ./configure + + This time no errors are thrown so try and install: + + make + sudo make install + +5. Once this has completed test that SWIG has installed correctly, type `swig` into the terminal and hopefully you'll get the response: + Must specify an input file. Use `-help` for available options. + +SWIG Benchmarks +----------------- +Example SWIG programs using the SNAP Ringo for multi-attribute edges are in the `examples` directory. The benchmark program `benchmark.py` performs a series of functions on the graph data, including node/edge iteration, degree checks, clustering coefficients, largest weakly and strongest components, etc. For R-MAT graphs with 1 million nodes and 10 million edges, this takes on average: + +- On CentOS 6.3 with 2.66 GHz processor, 19.71 sec to generate a new graph and and 17.49 sec to run the tests. +- On Mac OSX 10.8 with 2.6 GHz processor, 13.95 sec to generate and 15.06 sec to run the tests. + +To run a benchmark test you can run the following command: + + python benchmark.py --verbose -n 5 --range 4-7 --type rmat --generate + diff --git a/snap-python/source/RELEASE.txt b/snap-python/source/RELEASE.txt new file mode 100644 index 0000000000000000000000000000000000000000..46b29ee73e88a1acd5acb072fa66ef9034a57b2e --- /dev/null +++ b/snap-python/source/RELEASE.txt @@ -0,0 +1,203 @@ +Snap.py 6.0 Release Notes +December 2020 + +Snap.py is a Python interface for SNAP (Stanford Network Analysis Platform). +SNAP is a general purpose, high performance system for analysis and +manipulation of large networks. SNAP is written in C++ and optimized +for maximum performance and compact graph representation. It easily scales +to massive networks with hundreds of millions of nodes, and billions of edges. +Snap.py provides performance benefits of SNAP, combined with flexibility +of Python. Most of the SNAP functionality is available via Snap.py in Python. + +Snap.py 6.0 is a major release with a large number of new features, most +notably a significantly improved way to call Snap.py functions in Python, a +NetworkX compatibility layer, standard Python functions to handle SNAP vector +and hash types, new functions for egonets and graph union, and a completely +revised package building infrastructure with a better support for various +versions of Python. These enhancements are backward compatible, so existing +Snap.py based programs should continue to work. + +A high-level description of changes in Snap.py releases is provided below. + +Release 6.0.0, Dec 28, 2020 + +- implemented pylayer, a significantly improved way to call SNAP C++ functions + - standalone functions are available as class methods + - built-in Python classes (lists, dictionaries) can be provided as parameters + - results are available as return values rather than as reference parameters + - support for optional parameters has been enhanced +- implemented SnapX, a NetworkX compatible graph manipulation layer, as a + module within Snap.py +- implemented standard Python interface functions for SNAP vector and hash + types to be compatible with Python lists and dictionaries +- implemented new functions to calculate egonets, GetEgonet, GetEgonetHop, + GetInEgonetHop, GetOutEgonetHop, GetInEgonetSub +- implemented new functions to perform graph union, GetGraphUnion, + GetGraphUnionAttr +- added Dockerfile to containerize a release +- replaced setup.py with a completely new implementation +- added scripts for building wheel packages on macOS, Linux and Windows +- performed a large number of updates in Makefiles +- performed a major rewrite and extensions of the Snap.py documentation +- expanded functionality tests +- added a program to test the speed of various methods for writing and + reading a graph +- fixed formatting problems in creating the documentation with Sphinx +- added hellotest, a simple module to test the building of Python C/C++ + +Release 5.0.0, Aug 30, 2019 + +- implemented support for py3 +- implemented wheel packages and pip for py2 and py3 +- updated tests and documentation for py3 +- updated other python code for the py3 print function +- upgraded build platforms to Ubuntu 18.04, macOS 14.10, Windows 10 +- upgraded Visual Studio files to VS2019 +- updated install_name_tool to the version from High Sierra 10.13 +- updated setup.py from distutils to setuptools +- improved the tests for generated files, such as gnuplot files +- removed the need for Unix dependent commands grep and rm in tests +- commented out tests for PNG files, since these differ on various platforms +- implemented various other improvements in tests +- improved the update_dynlib.sh script +- improved the package build process +- added a license text +- added troubleshooting notes +- improved documentation on graph creation +- updated conf.py for the next release + +Release 4.1.0, Jul 27, 2018 + +- updated C++ codebase to SNAP 4.1 +- implemented GetSubGraphRenumber() +- implemented GetLen2Paths() +- implemented GetEigVec() +- implemented GetSngVec() +- implemented GetBfsEffDiamAll() +- implemented GetClustCfAll() +- implemented GetTriadsAll() +- implemented GetNodeTriadsAll() +- improved support for node2vec +- expanded the set of supported node iterator methods +- defined TFltVFltV +- added test programs for gnuplot and Graphviz +- improved documentation for GetEdgesInOut() +- improved documentation for GetSubTreeSz() +- improved documentation for IsTree() +- improved documentation for GetMxNId() +- improved documentation for CommunityCNM() +- improved documentation for CommunityCNM() +- improved documentation for GetRndNId() +- performed other minor updates in the documentation + +Release 4.0.0, Jul 28, 2017 + +- updated C++ codebase to SNAP 4.0 +- added a test for TTable +- minor updates in the documentation + +Release 3.0.2, Oct 7, 2016 + +- fixed a missing ToNetwork() function +- fixed a few issues with documentation +- further improved Anaconda Python handling in setup.py + +Release 3.0.1, Sep 28, 2016 + +- improved setup.py for installations with Anaconda Python + +Release 3.0.0, Sep 14, 2016 + +- this is a major release with many new features +- version number synced up with SNAP +- updated C++ codebase to SNAP 3.0 +- added support for new classes: multimodal networks TMMNet, TModeNet, + TCrossNet, TDirNet, TUndirNet, TNGraphMP, TNEANetMP +- included support for GetBetweennessCentr(), GetClosenessCentr(), + GetFarnessCentr() on TUNGraph(), TNGraph(), TNEANet() +- implemented multithreaded execution of many operations on Linux and Mac OS X +- extended test suite in snap-test.py +- added a batch script for testing on Windows +- fixed attributes in TNEANet and added a test +- fixed edge iterators and added a test +- fixed edge deletion in TNEANet and added a test +- fixed LoadConnListStr() and added a test +- fixed LoadEdgeListStr() and added a test +- fixed GetBfsTree() and added a test +- fixed GetBetweennessCentr() and added a test +- fixed GetClosenessCentr() and added a test +- fixed GetFarnessCentr() and added a test +- fixed THashKeyDatI and added a test +- added a test for vector operations +- extended Makefile with support for new classes: multimodal networks TMMNet, + TModeNet, TCrossNet, TNGraphMP, TNEANetMP +- added documentation for multimodal networks TMMNet +- added documentation for tables TTable +- added documentation for conversion of tables to graphs +- added documentation for sparse attributes +- added documentation for TUndirNet, TDirNet +- added documentation for sparse attributes for TNEANet +- fixed documentation for LoadConnListStr(), LoadEdgeListStr() +- added GetDat() to documentation on THash +- fixed a minor typo in documentation for PlotSccDistr() + +Release 1.2, May 12, 2015 + +- updated C++ codebase to SNAP 2.4 +- implemented and documented IsAttrDeletedN(), IsIntAttrDeletedN(), + IsFltAttrDeletedN(), IsStrAttrDeletedN(), IsAttrDeletedE(), + IsIntAttrDeletedE(), IsFltAttrDeletedE(), IsStrAttrDeletedE(), + GetNIdV(), GetEIdV(), GetRndEI() +- implemented GetIntAttrIndDatE(), GetFtlAttrIndDatE(), GetStrAttrIndDatE() +- implemented and documented GetAttrIndN(), GetAttrIndE(), IntAttrNameNI(), + FltAttrNameNI(), StrAttrNameNI(), IntAttrValueNI(), FltAttrValueNI(), + StrAttrValueNI(), GetIntAttrIndDatN(), GetFltAttrIndDatN(), + GetStrAttrIndDatN() +- expanded the code for the TNEAnet.GetEI() +- changed THashSet iterator to use THashSetKeyI +- fixed redefinition of Python built-in len() function +- fixed error with THashSet iterator +- fixed the code and the documentation for GetEI() in graphs and networks +- improved tneanet.py, fixed a few typos +- added tests for empty strings and nested iterators over TIntSet() +- added programs for the bug reports from CS224W +- added a bug program for GenRndPowerLaw() +- added a code that reproduces problem with LoadEdgeListStr() +- configured short compilation +- updated documentation and test program for AttrNameNI(), AttrValueNI(), + AttrNameEI(), AttrValueEI() +- documented GetIntAttrIndDatN(), GetFtlAttrIndDatN(), GetStrAttrIndDatN(), + IntAttrNameEI(), FltAttrNameEI(), StrAttrNameEI(), IntAttrValueEI(), + FltAttrValueEI(), StrAttrValueEI() +- updated typo in the documentation for GetNodeWcc() +- improved documentation for GetNodesAtHop() and GetNodesAtHops() +- fixed typos in documentation for GetMxSccSz +- fixed the documentation about the THashKeyDatI Next() iterator +- fixed errors in reference manual for GetOutDegCnt and GetInDegCnt +- fixed an small bug in the sample code for GetMxSccSz in the reference manual +- split documentation on node and edge attribute methods for TNEANet +- fixed documentation for TNEANetEdgeI.GetId() +- improved the documentation and a test for the set iterator +- improved documentation on PrintInfo() + +Release 1.1, Jun 16, 2014 + +- updated C++ codebase to SNAP 2.3 +- added support for installation with Anaconda or Homebrew python on Mac +- added StackOverflow example +- added AGM related functionality for community detection +- added clique percolation method for community detection +- added a test program and data for clique percolation method for + community detection +- added OpenMP support +- added more comprehensive tests +- updated TVec and THash samples +- added README.txt +- updated Makefile for tests +- improved top level Makefile + +Release 1.0, Mar 20, 2014 + +- initial public release of Snap.py +- included C++ codebase SNAP 2.2 + diff --git a/snap-python/source/__init__.py b/snap-python/source/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..666c53953fa7eccafb7969f5cdfab05928c92e44 --- /dev/null +++ b/snap-python/source/__init__.py @@ -0,0 +1,4 @@ +# -*- coding: utf-8 -*- +""" +snap-python Project Package Initialization File +""" diff --git a/snap-python/source/dev/__init__.py b/snap-python/source/dev/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/dev/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/dev/examples/Makefile b/snap-python/source/dev/examples/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..0a649c12b062bc0101c63246fa9f3a3acf8ec102 --- /dev/null +++ b/snap-python/source/dev/examples/Makefile @@ -0,0 +1,14 @@ +# +# Makefile for running +# + +all: benchmark, tneanet + +benchmark: + python benchmark.py + +tneanet: + python tneanet.py + +clean: + rm -rf results *.graph diff --git a/snap-python/source/dev/examples/__init__.py b/snap-python/source/dev/examples/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/dev/examples/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/dev/examples/benchmark.py b/snap-python/source/dev/examples/benchmark.py new file mode 100644 index 0000000000000000000000000000000000000000..95e83361cd67774fb64f8f7b3c22056fe30d1050 --- /dev/null +++ b/snap-python/source/dev/examples/benchmark.py @@ -0,0 +1,431 @@ +#!/usr/bin/python +# benchmark.py +# +# Author: Nick Shelly, Spring 2013 +# Description: +# - Loads SNAP as a Python module. +# - Randomly generates a graph of specified size and type, and saves +# or loads the graph if it has already been created. +# - Benchmarks a number of "is this a good graph?" tests on the graph, +# calculating the amount of time required and appends to a file. +# +# usage: benchmark.py [-h] [-v] [-r RANGE] [-d] [-t GRAPH_TYPES] +# [-n NUM_ITERATIONS] [-o OUTPUT_FILE] [-g] +# +# optional arguments: +# -h, --help show this help message and exit +# -v, --verbose increase output verbosity +# -r RANGE, --range RANGE +# range (4-6) (10^4 to 10^6 nodes) +# -d, --deterministic deterministic benchmark +# -t GRAPH_TYPES, --graph_types GRAPH_TYPES +# Graph types, comma separated. Available: rand_ungraph, +# rand_ngraph, rmat, pref, sw +# -n NUM_ITERATIONS, --num_iterations NUM_ITERATIONS +# number of iterations +# -o OUTPUT_FILE, --output_file OUTPUT_FILE +# file to output results +# -g, --generate generate new graphs +# +# Examples: +# 1. Use default arguments. +# $ python menchmark.py +# 2. Generate deterministic RMAT graphs from 10^2-10^3 nodes, and +# run 3 times, outputing to results.txt. +# $ python benchmark.py -v -n 3 -g -d -r 2-3 -t rmat -o results/results.txt +# + +import os.path +import sys +import argparse +from socket import gethostname +from time import clock +from datetime import datetime + +sys.path.append("../swig-r") +import snap + +PROPERTY_TYPES = [1, 10] # 1=Triads, 10=BFS + +# Comma-separated, graph types: +# 'rmat' - R-MAT +# 'pref' - preferential attachment +# 'sw' - small world +# 'rand_ungraph' - random undirected +# 'rand_ngraph' - random directed +# 'rand_neanet' - random directed attribute +# 'syn_ngraph' - random directed +# 'syn_negraph' - synthetic multi-edge +# 'syn_neanet' - synthetic directed multi-edge attribute + +DEFAULT_TYPES = "rand_neanet" + +# Average is 1, non-average is 0. +DEFAULT_DEGREES = "1-2" # Default is 10x and 100x edges/node +DEFAULT_WRITE = False +SW_REWIRE_PROB = 0.1 +SYNTHETIC_DELTA = 10 + +# Exponent range (e.g. 10^x to 10^y) +DEFAULT_VERBOSE=True +DEFAULT_RANGE = '3-4' +DEFAULT_ITERATIONS = 1 + +# Hostname for results +HOSTNAME = gethostname() + +RESULTS_DIR = 'results' +DEFAULT_RESULTS_FILE = os.path.join(RESULTS_DIR, 'results%s.txt' % \ + datetime.now().strftime('%m%d-%H%M%S')) + +def benchmark_ngraph(Graph): + ''' + Perform benchmark tests for Directed Graphs + ''' + + results = {} + results['num_nodes'] = Graph.GetNodes() + results['num_edges'] = Graph.GetEdges() + + for degree in range(0, 11): + num = snap.NodesGTEDegree_PNGraph(Graph, degree) + percent_deg = float(num) / results['num_nodes'] + results['deg_gte_%d' % degree] = num + results['deg_gte_%d_percent' % degree] = percent_deg + + # Check for over-weighted nodes + results['max_degree'] = snap.MxDegree_PNGraph(Graph) + + num = snap.NodesGTEDegree_PNGraph(Graph, results['max_degree']) + results['max_degree_num'] = num + + results['max_wcc_percent'] = snap.MxWccSz_PNGraph(Graph) \ + / results['num_nodes'] + results['max_scc_percent'] = snap.MxSccSz_PNGraph(Graph).GetNodes() \ + / results['num_nodes'] + + return results + +def benchmark_ungraph(Graph): + ''' + Perform benchmark tests for Undirected Graphs + ''' + + results = {} + results['num_nodes'] = Graph.GetNodes() + results['num_edges'] = Graph.GetEdges() + + for degree in range(0,11): + num = snap.NodesGTEDegree_PUNGraph(Graph, degree) + percent_deg = float(num) / results['num_nodes'] + results['deg_gte_%d' % degree] = num + results['deg_gte_%d_percent' % degree] = percent_deg + + # Check for over-weighted nodes + results['max_degree'] = snap.MxDegree_PUNGraph(Graph) + + num = snap.NodesGTEDegree_PUNGraph(Graph, results['max_degree']) + results['max_degree_num'] = num + results['max_wcc_percent'] = snap.MxWccSz_PUNGraph(Graph) \ + / results['num_nodes'] + results['max_scc_percent'] = snap.MxSccSz_PUNGraph(Graph).GetNodes() \ + / results['num_nodes'] + + # TODO: Calculate graph skew + return results + +def benchmark_neanet(Graph): + ''' + Perform benchmark tests for Directed Attribute Graphs + ''' + + results = {} + results['num_nodes'] = Graph.GetNodes() + results['num_edges'] = Graph.GetEdges() + + for degree in range(0, 11): + num = snap.NodesGTEDegree(Graph, degree) + percent_deg = float(num) / results['num_nodes'] + results['deg_gte_%d' % degree] = num + results['deg_gte_%d_percent' % degree] = percent_deg + + # Check for over-weighted nodes + results['max_degree'] = snap.MxDegree(Graph) + + num = snap.NodesGTEDegree(Graph, results['max_degree']) + results['max_degree_num'] = num + + results['max_wcc_percent'] = snap.MxWccSz(Graph) \ + / results['num_nodes'] + results['max_scc_percent'] = snap.MxSccSz(Graph).GetNodes() \ + / results['num_nodes'] + + return results + + +def convert_graph(Graph, TypeSrc, TypeDst): + ''' + Converts a GRAPH from type TYPESRC to a TYPEDST and returns the new graph + ''' + pass + + +def generate_graph(NNodes, NEdges, Model, Type, Rnd): + + if Model == 'rand_ungraph': + # GnRndGnm returns error, so manually generate + Graph = snap.GenRndGnm_PUNGraph(NNodes, NEdges, 0) + + elif Model == 'rand_ngraph': + Graph = snap.GenRndGnm_PNGraph(NNodes, NEdges, 1) + + elif Model == 'rand_neanet': + Graph = snap.GenRndGnm(NNodes, NEdges, 1) + + elif Model == 'syn_neanet': + Graph = snap.GenSyntheticGraph(NNodes, NEdges/NNodes, + SYNTHETIC_DELTA) + + elif Model == 'syn_ngraph': + Graph = snap.GenSyntheticGraph_PNGraph(NNodes, NEdges/NNodes, + SYNTHETIC_DELTA) + + elif Model == 'rmat': + Graph = snap.GenRMat(NNodes, NEdges, 0.40, 0.25, 0.2, Rnd) + + elif Model == 'sw': + Graph = snap.GenSmallWorld(NNodes, NNodes/NEdges, 0.1) + + elif Model == 'pref': + Graph = snap.GenPrefAttach(NNodes, NNodes/NEdges) + + return Graph + +def run_tests(num_iterations=3, min_nodes_exponent=3, max_nodes_exponent=4): + ''' + Perform tests with specified exponent range + ''' + + if verbose: + print "Running results from %e to %e" % (min_nodes_exponent, + max_nodes_exponent) + + Rnd = snap.TRnd() + + for exp in range(min_nodes_exponent,max_nodes_exponent+1): + + for n in range(num_iterations): + + if verbose: + print "Iteration: %d of %d" % (n+1, num_iterations) + + # Random number of nodes of degree i + NNodes = 10**exp; + + for avg_deg in range(min_degree_edges, max_degree_edges+1): + + for g in graph_types: + + if deterministic: + if verbose: + print "Deterministic mode, putting seed" + else: + if verbose: + print "Non-deterministic mode" + Rnd.PutSeed(0) + + if verbose: print "Using average degree of 10^%d" % avg_deg + NEdges = NNodes*(10**avg_deg) + + Graph = None + if g in ['rmat', 'rand_ngraph', 'syn_ngraph','syn_negraph']: + Type = "directed" + + elif g in ['sw', 'pref', 'rand_ungraph']: + Type = "undirected" + + elif g in ['rand_neanet', 'syn_neanet']: + Type = "attribute" + + else: + print "Unknown graph type: %s" % g + sys.exit(1) + + StartTime = clock() + FName = os.path.join(RESULTS_DIR, "%s_10e%d_deg%d_%d.graph" % + (g, exp, NEdges/NNodes, n)) + + if not generate: + + if os.path.exists(FName): + try: + + if verbose: + print "Loading '%s' from ...'%s'" % (g, FName), + sys.stdout.flush() + + FIn = snap.TFIn(snap.TStr(FName)) + if Type == "directed": + Graph = snap.PNGraph_New() + elif Type == "undirected": + Graph = snap.PUNGraph_New() + elif Type == "attribute": + Graph = snap.PNEANet_New() + + Graph = Graph.Load(FIn) + if verbose: print "done" + + if verbose: + print "Re-loaded graph with %d Nodes and %d Edges" % \ + (Graph.GetNodes(), Graph.GetEdges()) + + except Exception, e: + print "Unable to load graph file, '%s': %s" % (FName, str(e)) + +# else: +# print "File not found: %s" % FName + + if not Graph: + + try: + + # User wants to re-generate graph, or no graph data available. + if verbose: + print "Generating '%s %s' graph with %e nodes, %e edges..." % \ + (Type, g, NNodes, NEdges), + sys.stdout.flush() + Graph = generate_graph(NNodes, NEdges, g, Type, Rnd) + if verbose: print "done" + + if opt_write: + + # Save the graph + if verbose: + print "Saving '%s' graph to file '%s'..." % (g, FName), + sys.stdout.flush() + + if Graph: + FOut = snap.TFOut(snap.TStr(FName)) + Graph.__ref__().Save(FOut) # Save as TUNGraph or TNGraph + FOut.Flush() + if verbose: print "done" + + except Exception, e: + print "Unable to generate/save graph file, '%s': %s" % \ + (FName, str(e)) + continue + + TimeGenerate = clock() - StartTime + + print "Running tests...", + sys.stdout.flush() + + StartTime = clock() + + if Type == 'directed': + results = benchmark_ngraph(Graph) + elif Type == 'undirected': + results = benchmark_ungraph(Graph) + elif Type == 'attribute': + results = benchmark_neanet(Graph) + + if verbose: print "done" + + TimeElapsed = clock() - StartTime + + print "Elapsed Time = %.4f sec" % TimeElapsed + + row_header = ["Hostname", "Model", "Type", "Nodes", "Edges", + "StartTime", "Generation Time", "Run Time"] + + print "Header: %s" % " ".join(row_header) + + import csv + with open(results_file, 'a+') as csvfile: + writer = csv.writer(csvfile) + if verbose: + print "Writing to '%s'..." % results_file, + sys.stdout.flush() + + row = [HOSTNAME, g, Type, NNodes, NEdges, + datetime.now().strftime("%d/%b/%Y:%H:%M:%S"), + TimeGenerate, TimeElapsed] + if verbose: print "done" + print "Time Data: %s" % repr(row) + writer.writerow(row) + + print "-"*75 + +def main(): + + global results_dir, verbose, deterministic, generate, graph_types, \ + hostname, num_iterations, results_file, \ + min_degree_edges, max_degree_edges, opt_write + + parser = argparse.ArgumentParser() + parser.add_argument("-v", "--verbose", default=DEFAULT_VERBOSE, + action="store_true", dest="verbose", + help="increase output verbosity") + + parser.add_argument("-r", "--range", default=DEFAULT_RANGE, + help="range (4-6) (10^4 to 10^6 nodes)") + + parser.add_argument("-e", "--edges_deg", default=DEFAULT_DEGREES, + help="range of degrees (e.g \"2-3\" => (10^1 to 10^3 edges per node)") + + parser.add_argument("-d", "--deterministic", default=False, + action="store_true", dest="deterministic", + help="deterministic benchmark") + + parser.add_argument("-t", "--graph_types", default=DEFAULT_TYPES, + help=''' + Graph types, comma separated. + Available: rand_ungraph, rand_ngraph, rmat, pref, sw''') + + parser.add_argument("-n", "--num_iterations", type=int, + default=DEFAULT_ITERATIONS, help="number of iterations") + + parser.add_argument("-o", "--output_file", + default=DEFAULT_RESULTS_FILE, + help="file to output results") + + parser.add_argument("-g", "--generate", default=False, + action="store_true", dest="generate", + help="generate new graphs") + + parser.add_argument("-w", "--write_graph", default=DEFAULT_WRITE, + action="store_true", dest="write", + help="save graph") + + args = parser.parse_args() + + verbose = args.verbose + generate = args.generate + deterministic = args.deterministic + results_file = args.output_file + num_iterations = args.num_iterations + graph_types = args.graph_types.split(",") + min_degree_edges = int(args.edges_deg.split("-")[0]) + max_degree_edges = int(args.edges_deg.split("-")[-1]) + opt_write = args.write + + + print "Edge degree = 10^%d to 10^%d edges/node" % \ + (min_degree_edges, max_degree_edges) + + if verbose: + print "Hostname: %s" % HOSTNAME + min = int(args.range.split("-")[0]) + max = int(args.range.split("-")[-1]) + print "Node range = 10^%d to 10^%d" % (min, max) + + if not os.path.exists(RESULTS_DIR): + print "Creating results directory %s" % RESULTS_DIR + os.makedirs(RESULTS_DIR) + + run_tests(num_iterations, min, max) + +if __name__ == "__main__": + main() + + diff --git a/snap-python/source/dev/examples/convert.py b/snap-python/source/dev/examples/convert.py new file mode 100644 index 0000000000000000000000000000000000000000..b0cb0cd0c5fc761ec5f50f1e0e56cd770ead51f0 --- /dev/null +++ b/snap-python/source/dev/examples/convert.py @@ -0,0 +1,220 @@ +#!/usr/bin/python +# convert.py +# +# Author: Nick Shelly, Spring 2013 +# Description: +# - Loads SNAP as a Python module. +# - Randomly generates a graph of specified size and type and saving, +# or loading the graph if has already been created. +# - Converts the graph to the specified file +# +# usage: convert.py [-h] [-v] +# +# optional arguments: +# -h, --help show this help message and exit +# +# Example: +# $ python benchmark.py -v -n 3 -g -d -r 2-3 -t rmat -o results/results.txt +# + +import os.path +import sys +import argparse +from socket import gethostname +from time import clock +from datetime import datetime + +sys.path.append("../swig-r") +import snap + +PROPERTY_TYPES = [1, 10] # 1=Triads, 10=BFS + +# Comma-separated, graph types: +# 'rmat' - R-MAT +# 'pref' - preferential attachment +# 'sw' - small world +# 'rand_ungraph' - random undirected +# 'rand_ngraph' - random directed +# 'rand_neagraph' - random directed attribute +# 'syn_ngraph' - random directed +# 'syn_negraph' - synthetic multi-edge +# 'syn_neagraph' - synthetic directed multi-edge attribute + +GRAPH_TYPES = ['rmat', 'pref', 'sw', \ + 'rand_ungraph', 'rand_ngraph', 'rand_neagraph', \ + 'syn_ngraph', 'syn_negraph', 'syn_neagraph'] +DEFAULT_TYPES = "rmat,rand_ungraph" + +DEFAULT_NODES_EXP = 3 +DEFAULT_EDGES_EXP = 4 + +# Average is 1, non-average is 0. +DEFAULT_DEGREES = 1-2 # Default is 10x and 100x edges/node +DEFAULT_WRITE = False +SW_REWIRE_PROB = 0.1 +SYNTHETIC_DELTA = 10 + +# Exponent range (e.g. 10^x to 10^y) +DEFAULT_RANGE = '5-7' +DEFAULT_ITERATIONS = 1 + +# Hostname for results +HOSTNAME = gethostname() + +RESULTS_DIR = 'results' +DEFAULT_RESULTS_FILE = os.path.join(RESULTS_DIR, 'results%s.txt' % \ + datetime.now().strftime('%m%d-%H%M%S')) + +def generate_graph(NNodes, NEdges, Model, Rnd): + + Graph = None + if Model == 'rand_ungraph': + # GnRndGnm returns error, so manually generate + Graph = snap.GenRndGnm_PUNGraph(NNodes, NEdges, 0) + + elif Model == 'rand_ngraph': + Graph = snap.GenRndGnm_PNGraph(NNodes, NEdges, 1) + + elif Model == 'rand_neagraph': + Graph = snap.GenRndGnm_PNEANet(NNodes, NEdges, 1) + + elif Model == 'syn_neagraph': + Graph = snap.GenSyntheticGraph_PNEANet(NNodes, NEdges/NNodes, + SYNTHETIC_DELTA) + + elif Model == 'syn_ngraph': + Graph = snap.GenSyntheticGraph_PNGraph(NNodes, NEdges/NNodes, + SYNTHETIC_DELTA) + + elif Model == 'rmat': + Graph = snap.GenRMat(NNodes, NEdges, 0.40, 0.25, 0.2, Rnd) + + elif Model == 'sw': + Graph = snap.GenSmallWorld(NNodes, NNodes/NEdges, 0.1) + + elif Model == 'pref': + Graph = snap.GenPrefAttach(NNodes, NNodes/NEdges) + + else: + print "Unknown model: %s" % Model + sys.exit(1) + + return Graph + + +def convert_graph(Graph, TypeSrc, TypeDst): + ''' + Converts a GRAPH from type TYPESRC to a TYPEDST and returns the new graph + ''' + + print "Converting from '%s' to '%s'..." % (TypeSrc, TypeDst) + sys.stdout.flush() + + + if TypeSrc == 'ngraph' and TypeDst == 'neagraph': + + GraphOut = snap.ConvertGraph_PNGraphToPNEANet(Graph) + + else: + print "Unable to convert: %s to %s" % (TypeSrc, TypeDst) + sys.exit(1) + + print "done" + + print "GraphIn (%s) has %d nodes, %d edges\n" % \ + (Graph.__class__, Graph.GetNodes(), Graph.GetEdges()) + print "GraphOut (%s) has %d nodes, %d edges" % \ + (GraphOut.__class__, GraphOut.GetNodes(), GraphOut.GetEdges()) + +def run(nodes_exp, edges_exp, InputModel, OutputType): + + ''' + Perform tests with specified exponent range + ''' + + if opt_verbose: + print "Running results from %e to %e" % (min_nodes_exponent, + max_nodes_exponent) + + Rnd = snap.TRnd() + + # Random number of nodes of degree i + NNodes = 10**nodes_exp + NEdges = 10**edges_exp + + if opt_deterministic: + if opt_verbose: + print "Deterministic mode, putting seed" + else: + if opt_verbose: + print "Non-deterministic mode" + Rnd.PutSeed(0) + + if opt_verbose: print "Using average degree of 10^%d" % avg_deg + + StartTime = clock() + + # User wants to re-generate graph, or no graph data available. + if opt_verbose: + print "Generating '%s %s' graph with %e nodes, %e edges..." % \ + (Type, g, NNodes, NEdges), + sys.stdout.flush() + Graph = generate_graph(NNodes, NEdges, InputModel, Rnd) + if opt_verbose: print "done" + + if InputModel in ['rmat', 'rand_ngraph', 'syn_ngraph','syn_negraph']: + TypeSrc = "ngraph" + + elif InputModel in ['sw', 'pref', 'rand_ungraph']: + TypeSrc = "ungraph" + + elif InputModel in ['rand_neagraph', 'syn_neagraph']: + TypeSrc = "neagraph" + + else: + print "Unknown graph type: %s" % g + sys.exit(1) + + convert_graph(Graph, TypeSrc, OutputType) + print "-"*75 + +def main(): + + parser = argparse.ArgumentParser() + parser.add_argument("-v", "--verbose", default=False, + action="store_true", dest="verbose", + help="increase output verbosity") + + parser.add_argument("-n", "--nodes_exp", default=DEFAULT_NODES_EXP, + help="number of nodes, exponent (e.g. 4 => 10^4 nodes)") + + parser.add_argument("-e", "--edges_exp", default=DEFAULT_EDGES_EXP, + help="number of edges, exponent (e.g. 4 => 10^4 edges)") + + parser.add_argument("-d", "--deterministic", default=False, + action="store_true", dest="deterministic", + help="deterministic benchmark") + + parser.add_argument("-i", "--input_model", required=True, + help=''' + Graph types, comma separated: (rmat, pref, rand_ngraph, syn_ngraph)''' + + parser.add_argument("-o", "--output_type", required=True, + help="output type (PNEANet)") + + args = parser.parse_args() + + global opt_verbose, opt_deterministic, opt_nodes_exp, opt_edges_exp + + opt_verbose = args.verbose + opt_deterministic = args.deterministic + + if opt_verbose: + print "Hostname: %s" % HOSTNAME + + run(args.nodes_exp, args.edges_exp, args.input_model, args.output_type) + +if __name__ == "__main__": + main() + + diff --git a/snap-python/source/dev/examples/data/p2p-Gnutella08.txt b/snap-python/source/dev/examples/data/p2p-Gnutella08.txt new file mode 100644 index 0000000000000000000000000000000000000000..6f4d562f90e368dee1332172c3e3ef4f20f01c3d --- /dev/null +++ b/snap-python/source/dev/examples/data/p2p-Gnutella08.txt @@ -0,0 +1,20781 @@ +# Directed graph: p2p-Gnutella08.txt +# epinions +# Nodes: 6301 Edges: 20777 +# FromNodeId ToNodeId +0 1 +0 2 +0 3 +0 4 +0 5 +0 6 +0 7 +0 8 +0 9 +0 10 +3 703 +3 826 +3 1097 +3 1287 +3 1591 +3 1895 +3 1896 +3 1897 +3 1898 +3 1899 +4 144 +4 258 +4 491 +4 1021 +4 1418 +4 1669 +4 1900 +4 1901 +4 1902 +4 1903 +5 121 +5 127 +5 128 +5 179 +5 247 +5 249 +5 264 +5 353 +5 424 +5 426 +7 145 +7 176 +7 177 +7 353 +7 753 +7 754 +7 762 +7 2064 +7 3002 +8 520 +8 665 +8 852 +8 1394 +8 1786 +8 1842 +8 1904 +8 1905 +8 1906 +8 1907 +9 124 +9 147 +9 177 +9 246 +9 247 +9 248 +9 249 +9 250 +9 251 +9 252 +703 898 +703 1581 +703 1620 +703 2634 +703 2635 +703 2636 +703 2637 +703 2638 +703 2639 +703 2640 +1287 38 +1287 331 +1287 626 +1287 1945 +1287 2690 +1287 3137 +1287 3138 +1287 3139 +1287 3140 +1287 3141 +1895 1860 +1896 1118 +1896 1227 +1896 1334 +1896 1556 +1896 1980 +1896 2333 +1896 3672 +1896 3677 +1896 3678 +1896 3679 +144 8 +144 121 +144 122 +144 125 +144 146 +144 246 +144 249 +144 264 +144 367 +1669 1573 +1669 3023 +1669 3216 +1669 3413 +1669 3414 +1669 3415 +1669 3416 +1669 3417 +1669 3418 +127 9 +127 144 +127 175 +127 177 +127 247 +127 427 +127 698 +127 762 +127 1246 +127 2076 +179 4 +179 9 +179 17 +179 31 +179 123 +179 125 +179 250 +179 559 +179 2018 +247 776 +247 900 +247 1067 +247 1068 +247 1069 +247 1070 +247 1071 +247 1072 +247 1073 +247 1074 +249 123 +249 250 +249 251 +249 351 +249 753 +249 755 +249 762 +249 983 +264 249 +264 697 +264 1787 +264 2193 +264 2194 +264 2224 +264 2225 +264 2226 +264 2227 +264 2228 +353 122 +353 123 +353 127 +353 249 +353 251 +353 367 +353 368 +353 666 +353 754 +353 856 +424 940 +424 960 +424 2409 +424 2410 +424 2411 +424 2412 +424 2413 +424 2414 +424 2415 +145 149 +145 246 +145 265 +145 367 +145 390 +145 667 +145 717 +145 1317 +145 2098 +176 5 +176 248 +176 369 +176 697 +176 700 +176 946 +176 947 +176 2001 +176 2122 +177 143 +177 145 +177 149 +177 266 +177 367 +177 368 +177 559 +177 856 +177 1245 +753 9 +753 121 +753 122 +753 127 +753 128 +753 129 +753 145 +753 177 +753 367 +762 3 +762 175 +762 176 +762 251 +762 264 +762 266 +762 559 +762 754 +762 2001 +762 2018 +665 4 +665 5 +665 9 +665 126 +665 148 +665 252 +665 352 +665 353 +665 666 +665 667 +852 250 +852 938 +852 1097 +852 1556 +852 1990 +852 2748 +852 2749 +852 2750 +852 2751 +852 2752 +1394 9 +1394 126 +1394 129 +1394 177 +1394 248 +1394 266 +1394 353 +1394 754 +1394 1317 +1394 2018 +1786 122 +1786 125 +1786 142 +1786 146 +1786 248 +1786 249 +1786 264 +1786 367 +1786 1245 +1842 628 +1842 1342 +1842 1383 +1842 2494 +1842 3577 +1842 3578 +1842 3579 +1842 3580 +1842 3581 +1842 3582 +1904 7 +1904 129 +1904 144 +1904 149 +1904 174 +1904 247 +1904 248 +1904 252 +1904 353 +1907 4 +1907 7 +1907 129 +1907 145 +1907 149 +1907 174 +1907 266 +1907 666 +124 122 +124 123 +124 145 +124 147 +124 176 +124 248 +124 390 +124 762 +124 2063 +124 2064 +147 8 +147 128 +147 176 +147 177 +147 264 +147 367 +147 424 +147 427 +147 1246 +248 326 +248 914 +248 915 +248 916 +248 917 +248 918 +248 919 +248 920 +248 921 +248 922 +250 51 +250 64 +250 114 +250 1349 +250 1389 +250 1644 +250 1726 +250 2018 +250 4180 +250 4181 +251 513 +251 586 +251 873 +251 1064 +251 1412 +251 2206 +251 2207 +251 2208 +251 2209 +251 2210 +252 62 +252 808 +252 1475 +252 2211 +252 2212 +252 2213 +252 2214 +252 2215 +252 2216 +898 1620 +898 2785 +1620 112 +1620 342 +1620 1658 +1620 2262 +1620 2612 +1620 2634 +1620 2706 +1620 3027 +1620 3382 +1620 3383 +2634 106 +2634 510 +2634 558 +2634 1817 +2634 2595 +2634 2635 +2634 3409 +2634 3897 +2634 4229 +2635 955 +2635 1265 +2635 1427 +2635 1584 +2635 1602 +2635 1699 +2635 2269 +2635 3310 +2635 4238 +2635 4239 +2638 179 +2638 1061 +2638 1317 +2638 2720 +2638 2721 +2638 3821 +2638 4230 +2638 4231 +2638 4232 +2638 4233 +2639 71 +2639 296 +2639 527 +2639 804 +2639 1017 +2639 2051 +2639 3215 +2639 3362 +2639 4234 +2639 4235 +38 725 +38 1376 +38 1915 +38 2002 +38 2007 +38 2167 +38 2168 +38 2169 +38 2170 +331 100 +331 332 +331 333 +331 334 +331 335 +331 336 +331 337 +331 338 +331 339 +1945 151 +1945 178 +1945 814 +1945 1144 +1945 1228 +1945 1653 +1945 2288 +1945 3722 +1945 3723 +1945 3724 +2690 581 +2690 1493 +2690 1636 +2690 1936 +2690 2234 +2690 2823 +2690 4258 +2690 4259 +2690 4260 +2690 4261 +3137 102 +3137 264 +3137 753 +3137 755 +3137 1212 +3137 3146 +3137 3849 +3137 4455 +3137 4546 +3137 4547 +3138 127 +3138 143 +3138 252 +3138 369 +3138 390 +3138 754 +3138 1387 +3138 1912 +3138 2050 +3138 4487 +3140 477 +3140 2593 +3140 2746 +3140 3364 +3140 3687 +3140 4159 +3140 4437 +3140 5629 +3140 5931 +3140 6071 +1118 560 +1118 813 +1118 2011 +1118 2625 +1118 2996 +1118 2997 +1118 2998 +1118 2999 +1118 3000 +1118 3001 +1556 123 +1556 700 +1556 792 +1556 859 +1556 1491 +1556 2184 +1556 3373 +1556 3374 +1556 3375 +1556 3376 +2333 126 +2333 529 +2333 1334 +2333 1706 +2333 1891 +2333 2344 +2333 3096 +2333 3672 +2333 3822 +2333 4030 +122 578 +122 658 +122 1428 +122 1451 +122 2057 +122 2058 +122 2059 +122 2060 +122 2061 +122 2062 +125 132 +125 222 +125 503 +125 1535 +125 2070 +125 2071 +125 2072 +125 2073 +125 2074 +125 2075 +146 7 +146 285 +146 3337 +146 5048 +146 5171 +146 5338 +146 5940 +146 5941 +146 5942 +367 4 +367 5 +367 7 +367 264 +367 266 +367 559 +367 666 +367 1317 +1573 224 +1573 490 +1573 491 +1573 496 +1573 1123 +1573 1140 +1573 2221 +1573 2222 +1573 2705 +1573 2953 +1573 2973 +1573 3376 +1573 3408 +3023 144 +3023 148 +3023 149 +3023 420 +3023 551 +3023 559 +3023 1184 +3023 1994 +3023 4425 +3023 4459 +3415 17 +3415 125 +3415 148 +3415 266 +3415 559 +3415 697 +3415 753 +3415 1317 +3415 1920 +3417 122 +3417 129 +3417 143 +3417 177 +3417 246 +3417 251 +3417 367 +3417 390 +3417 666 +175 1575 +175 3066 +175 3344 +175 3715 +175 3849 +175 4539 +175 5209 +175 5325 +175 5483 +175 5584 +427 4 +427 124 +427 251 +427 265 +427 353 +427 369 +427 695 +427 700 +427 946 +427 947 +17 1050 +17 2254 +17 2761 +17 3147 +17 3169 +17 3619 +17 3893 +17 4408 +17 4953 +31 124 +31 637 +31 870 +31 1219 +31 1954 +31 2237 +31 2524 +31 2630 +31 3637 +31 3874 +123 3 +123 7 +123 143 +123 145 +123 146 +123 147 +123 252 +123 367 +123 390 +123 423 +559 119 +559 756 +559 759 +559 818 +559 819 +559 820 +559 821 +559 822 +559 823 +559 824 +1067 969 +1067 1570 +1067 2976 +1067 2977 +1068 1688 +1068 2493 +1068 2972 +1068 2973 +1068 2974 +1070 2975 +351 121 +351 176 +351 352 +351 353 +351 354 +351 355 +351 356 +351 357 +351 358 +351 359 +697 870 +697 1441 +697 1589 +697 2034 +697 2214 +697 2597 +697 2598 +697 2599 +697 2600 +697 2601 +1787 549 +1787 802 +1787 1115 +1787 1574 +1787 1788 +1787 3563 +1787 3700 +1787 3701 +1787 3702 +2193 5 +2193 124 +2193 144 +2193 147 +2193 176 +2193 248 +2193 427 +2193 629 +2193 3914 +2193 3915 +2224 122 +2224 127 +2224 175 +2224 249 +2224 266 +2224 367 +2224 390 +2224 423 +2224 697 +2225 604 +2225 1054 +2225 1129 +2225 2278 +2225 2476 +2225 2600 +2225 2733 +2225 3235 +2225 3931 +2225 3932 +2226 260 +2226 282 +2226 822 +2226 889 +2226 1143 +2226 1975 +2226 2042 +2226 2414 +2226 2867 +2226 3933 +2228 222 +2228 1173 +2228 1374 +2228 2358 +2228 2552 +2228 3354 +2228 3934 +2228 3935 +2228 3936 +2228 3937 +856 5 +856 7 +856 145 +856 149 +856 174 +856 179 +856 180 +856 1317 +856 2018 +2411 246 +2411 351 +2411 503 +2411 944 +2411 2077 +2411 2593 +2411 3229 +2411 4089 +2411 4090 +2411 4091 +149 5 +149 10 +149 128 +149 148 +149 238 +149 250 +149 252 +149 265 +149 353 +149 1317 +390 108 +390 261 +390 391 +390 392 +390 393 +390 394 +390 395 +390 396 +390 397 +390 398 +667 152 +667 459 +667 468 +667 1350 +667 1956 +667 2578 +667 2579 +667 2580 +667 2581 +717 124 +717 175 +717 265 +717 369 +717 390 +717 426 +717 427 +717 554 +717 695 +717 754 +1317 1036 +1317 1534 +1317 2362 +1317 3109 +1317 3163 +1317 3164 +1317 3165 +1317 3166 +1317 3167 +1317 3168 +369 9 +369 145 +369 174 +369 246 +369 264 +369 266 +369 422 +369 559 +369 666 +700 584 +700 1056 +700 1517 +700 2614 +700 2615 +700 2616 +700 2617 +700 2618 +700 2619 +700 2620 +2001 253 +2001 261 +2001 924 +2001 1606 +2001 1867 +2001 2071 +2001 2281 +2001 3336 +2001 3771 +2001 3772 +143 122 +143 124 +143 128 +143 146 +143 246 +143 249 +143 367 +143 426 +143 427 +143 2098 +1245 5 +1245 126 +1245 146 +1245 147 +1245 149 +1245 175 +1245 180 +1245 368 +1245 422 +1245 2018 +129 133 +129 219 +129 778 +129 864 +129 2078 +129 2079 +129 2080 +129 2081 +129 2082 +129 2083 +126 127 +126 369 +126 696 +126 698 +126 754 +126 755 +126 946 +126 947 +126 2001 +126 2077 +148 121 +148 122 +148 123 +148 124 +148 176 +148 246 +148 248 +148 367 +148 422 +148 1245 +352 4 +352 146 +352 176 +352 249 +352 266 +352 367 +352 368 +352 422 +352 2001 +938 253 +938 534 +938 547 +938 939 +938 940 +938 941 +938 942 +938 943 +938 944 +938 945 +2748 165 +2748 1066 +2748 1140 +2748 3096 +2748 3801 +2748 3946 +2748 4153 +2748 4300 +2748 4301 +2748 4302 +2750 7 +2750 8 +2750 125 +2750 128 +2750 174 +2750 238 +2750 368 +2750 424 +2750 717 +2750 856 +2751 4 +2751 147 +2751 180 +2751 249 +2751 367 +2751 368 +2751 369 +2751 390 +2751 422 +2751 856 +628 9 +628 144 +628 145 +628 147 +628 149 +628 175 +628 176 +628 369 +628 629 +628 630 +1383 327 +1383 782 +1383 815 +1383 2359 +1383 2451 +1383 2964 +1383 3211 +1383 3227 +1383 3228 +1383 3229 +2494 1433 +2494 1978 +2494 2032 +2494 3530 +2494 4129 +3577 3 +3577 9 +3577 123 +3577 124 +3577 149 +3577 247 +3577 249 +3577 352 +3577 369 +3577 427 +3579 7 +3579 149 +3579 252 +3579 715 +3579 1481 +3579 2001 +3579 4172 +3579 4586 +3579 4679 +3579 4794 +3581 3750 +174 3 +174 5 +174 7 +174 122 +174 126 +174 142 +174 145 +174 249 +174 427 +174 667 +326 922 +326 1004 +326 2277 +326 2278 +326 2279 +326 2280 +326 2281 +326 2282 +326 2283 +326 2284 +914 2042 +918 451 +918 1047 +918 1213 +918 1376 +918 1708 +918 2624 +918 2818 +918 2819 +918 2820 +919 121 +919 122 +919 123 +919 126 +919 145 +919 149 +919 180 +919 250 +919 559 +922 2809 +922 2810 +922 2811 +922 2812 +922 2813 +922 2814 +922 2815 +922 2816 +922 2817 +64 91 +64 102 +64 106 +64 1946 +64 1947 +64 1948 +64 1949 +64 1950 +64 1951 +64 1952 +1389 143 +1389 732 +1389 1390 +1389 1391 +1389 1392 +1389 1393 +1389 1394 +1389 1395 +1389 1396 +1389 1397 +1644 424 +1644 823 +1644 1414 +1644 2040 +1644 2125 +1644 2399 +1644 2880 +1644 3162 +1644 3394 +1644 3395 +4180 143 +4180 476 +4180 693 +4180 911 +4180 1272 +4180 1273 +4180 2808 +4180 5126 +4180 5127 +4180 5128 +586 8 +586 126 +586 128 +586 149 +586 175 +586 247 +586 248 +586 666 +586 717 +586 754 +873 1227 +873 1336 +873 2392 +873 2433 +873 2581 +873 2756 +873 2757 +873 2758 +873 2759 +873 2760 +1412 9 +1412 127 +1412 145 +1412 149 +1412 174 +1412 179 +1412 264 +1412 422 +1412 427 +1412 1317 +62 1064 +62 1194 +62 1196 +62 1198 +62 1959 +62 1960 +62 1961 +62 1962 +62 1963 +11 12 +11 13 +11 14 +11 15 +11 16 +11 17 +11 18 +11 19 +11 20 +11 21 +13 2074 +14 809 +15 3 +15 123 +15 129 +15 143 +15 251 +15 264 +15 367 +15 426 +15 427 +15 718 +20 121 +20 147 +20 368 +20 427 +20 717 +20 856 +20 975 +20 1908 +20 1909 +20 1910 +21 92 +21 1702 +21 1711 +21 1833 +21 1916 +21 1917 +21 1918 +21 1919 +21 1920 +21 1921 +718 167 +718 243 +718 326 +718 404 +718 942 +718 1885 +718 1886 +718 1887 +2761 222 +2761 1780 +2761 2008 +2761 2048 +2761 2086 +2761 3484 +2761 3981 +2761 4093 +2761 4298 +2761 4299 +3147 240 +3147 534 +3147 4270 +3147 4653 +3893 126 +3893 145 +3893 147 +3893 252 +3893 667 +3893 732 +3893 754 +3893 1909 +3893 3349 +975 906 +975 940 +975 976 +975 977 +975 978 +975 979 +975 980 +975 981 +975 982 +975 983 +1910 271 +1910 549 +1910 659 +1910 711 +1910 1180 +1910 1583 +1910 2288 +1910 2634 +1910 2833 +1910 3682 +92 2015 +92 2016 +1711 2707 +1917 1601 +1917 1711 +1917 1845 +1917 1985 +1917 2181 +1917 2619 +1917 3052 +1917 3056 +1917 3683 +1917 3684 +1920 255 +1920 1005 +1920 1048 +1920 1548 +1920 1772 +1920 1956 +1920 2709 +1920 3685 +1920 3686 +1920 3687 +423 4 +423 127 +423 390 +423 427 +423 2403 +423 2404 +423 2405 +423 2406 +423 2407 +423 2408 +133 110 +133 253 +133 1193 +133 1531 +133 1896 +133 2084 +133 2085 +133 2086 +133 2087 +133 2088 +864 198 +864 290 +864 837 +864 894 +864 1333 +864 2517 +864 2744 +864 2745 +864 2746 +864 2747 +2079 295 +2079 864 +2079 1029 +2079 1850 +2079 2114 +2079 3228 +2079 3851 +2079 3852 +2079 3853 +2079 3854 +2080 71 +2080 1027 +2080 2424 +2080 2602 +2080 2653 +2080 3055 +2080 3448 +2080 3839 +2080 3840 +2080 3841 +695 106 +695 290 +695 1690 +695 1956 +695 2385 +695 2593 +695 2594 +695 2595 +695 2596 +167 8 +167 17 +167 121 +167 129 +167 175 +167 238 +167 266 +167 353 +167 424 +167 2018 +243 1564 +243 2189 +243 2190 +243 2191 +243 2192 +243 2193 +243 2194 +243 2195 +243 2196 +1885 5 +1885 143 +1885 144 +1885 147 +1885 174 +1885 252 +1885 264 +1885 390 +1885 423 +1885 558 +1780 1666 +1780 2049 +1780 3533 +1780 3534 +1780 3535 +2048 659 +2048 1801 +2048 1817 +2048 2305 +2048 2327 +2048 2764 +2048 2852 +2048 3149 +2048 3812 +2048 3813 +2086 381 +2086 1070 +2086 1587 +2086 1688 +2086 2720 +2086 2783 +2086 3842 +2086 3843 +2086 3844 +2086 3845 +3484 121 +3484 127 +3484 128 +3484 129 +3484 146 +3484 176 +3484 238 +3484 266 +3484 423 +3484 427 +3981 127 +3981 878 +3981 1007 +3981 1540 +3981 2592 +3981 3557 +3981 4793 +3981 5496 +3981 6241 +3981 6242 +4093 656 +4093 1156 +4093 1546 +4093 2207 +4093 2254 +4093 4039 +4093 4502 +4093 5049 +4093 5074 +4093 5075 +4298 911 +4298 1726 +4298 2789 +4298 3149 +4298 4371 +4298 4487 +4298 4770 +4298 5200 +4298 5201 +732 309 +732 928 +732 1071 +732 1233 +732 1246 +732 1435 +732 2228 +732 2650 +732 2651 +732 2652 +554 1547 +554 2148 +554 2472 +554 3141 +554 3283 +554 3312 +554 4477 +554 4515 +554 4516 +180 3 +180 1489 +180 1490 +180 1524 +180 1766 +180 2130 +180 2131 +180 2132 +180 2133 +180 2134 +906 303 +906 518 +906 907 +906 908 +906 909 +906 910 +906 911 +906 912 +906 913 +977 295 +977 2093 +977 2517 +977 2840 +977 2865 +977 2866 +977 2867 +977 2868 +977 2869 +977 2870 +978 215 +978 314 +978 315 +978 1140 +978 2877 +978 2878 +978 2879 +978 2880 +978 2881 +978 2882 +979 35 +979 119 +979 612 +979 762 +979 866 +979 1023 +979 1318 +979 1319 +979 1320 +979 1321 +981 8 +981 448 +981 731 +981 822 +981 1143 +981 1974 +981 2883 +981 2884 +981 2885 +981 2886 +982 3028 +982 3029 +982 3030 +982 3031 +659 123 +659 143 +659 667 +659 1084 +659 1814 +659 1870 +659 2244 +659 2295 +659 2576 +659 2577 +2288 3453 +2288 3791 +2288 3971 +2288 3972 +2288 3973 +2288 3974 +2288 3975 +2288 3976 +2288 3977 +2288 3978 +1601 125 +1601 126 +1601 129 +1601 148 +1601 149 +1601 179 +1601 247 +1601 248 +1601 717 +1601 754 +2181 63 +2181 291 +2181 307 +2181 1873 +2181 2546 +2181 2554 +2181 2646 +2181 2697 +2181 3204 +2181 3335 +3056 290 +3056 520 +3056 1493 +3056 2150 +3056 2334 +3056 3833 +3056 4481 +3056 4482 +3056 4483 +1005 174 +1005 227 +1005 1490 +1005 1624 +1005 2287 +1005 2330 +1005 2908 +1005 2909 +1005 2910 +1005 2911 +1048 844 +1048 973 +1048 1049 +1048 1050 +1048 1051 +1048 1052 +1048 1053 +1048 1054 +1048 1055 +1048 1056 +1548 169 +1548 880 +1548 1084 +1548 1947 +1548 2269 +1548 2822 +1548 3360 +1548 3361 +1548 3362 +1548 3363 +1772 255 +1772 815 +1772 1168 +1772 2265 +1772 2552 +1772 2736 +1772 2756 +1772 2943 +1772 2993 +1772 3530 +2709 23 +2709 518 +2709 2138 +2709 2360 +2709 2794 +2709 3992 +2709 4172 +2709 4287 +2709 4288 +2709 4289 +22 23 +22 24 +22 25 +22 26 +22 27 +22 28 +22 29 +22 30 +22 31 +22 32 +25 1022 +27 901 +27 960 +27 1511 +27 1624 +27 1836 +27 1911 +27 1912 +27 1913 +27 1914 +27 1915 +28 846 +28 1516 +28 1517 +29 962 +29 1656 +29 2201 +30 3 +30 5 +30 8 +30 121 +30 124 +30 126 +30 145 +30 174 +30 249 +30 424 +32 957 +32 1028 +32 1199 +32 1459 +32 1699 +32 1700 +32 1701 +32 1702 +32 1703 +1022 1023 +1022 1024 +1022 1025 +1022 1026 +1022 1027 +1022 1028 +1022 1029 +1022 1030 +1022 1031 +1022 1032 +1836 112 +1836 298 +1836 579 +1836 627 +1836 894 +1836 2485 +1836 2730 +1836 3569 +1836 3570 +846 152 +846 602 +846 847 +846 848 +846 849 +846 850 +846 851 +846 852 +846 853 +846 854 +962 867 +962 1228 +962 1777 +962 1778 +962 1779 +962 1780 +962 1781 +962 1782 +962 1783 +962 1784 +1656 2729 +1656 5140 +2201 1511 +2201 1815 +2201 1944 +2201 2090 +2201 2416 +2201 2943 +2201 2981 +2201 3205 +2201 3319 +2201 3928 +637 796 +637 869 +637 870 +637 871 +637 872 +637 873 +637 874 +637 875 +637 876 +637 877 +2237 1402 +2237 1454 +2237 1458 +2237 1728 +2237 1866 +2237 2658 +2237 2719 +2237 2789 +2237 3220 +2237 3357 +2524 38 +2524 103 +2524 289 +2524 1252 +2524 2551 +2524 2764 +2524 3114 +2524 3926 +2524 5653 +2524 5840 +1028 251 +1028 813 +1028 815 +1028 982 +1028 1798 +1028 2733 +1028 2940 +1028 2941 +1028 2942 +1028 2943 +1199 3 +1199 121 +1199 123 +1199 125 +1199 127 +1199 128 +1199 238 +1199 264 +1199 390 +1199 426 +1459 554 +1459 910 +1459 1179 +1459 1275 +1459 1491 +1459 1511 +1459 2494 +1459 3310 +1459 3311 +1459 3312 +1699 813 +1699 1064 +1699 2207 +1699 3241 +1699 3463 +1699 3464 +1699 3465 +1699 3466 +1699 3467 +1700 23 +1700 436 +1700 451 +1700 2165 +1700 2324 +1700 3455 +1700 3456 +1700 3457 +1700 3458 +1701 612 +1701 1659 +1701 1805 +1701 1939 +1701 2188 +1701 3459 +1701 3460 +1701 3461 +1701 3462 +1703 78 +1703 889 +1703 1358 +1703 2423 +1703 2906 +1703 3468 +1703 3469 +1703 3470 +1703 3471 +1025 99 +1025 584 +1025 689 +1025 902 +1025 2916 +1025 3191 +1025 3462 +1025 5106 +1025 5107 +1025 5108 +1026 129 +1026 177 +1026 251 +1026 1246 +1026 2199 +1026 2366 +1026 2791 +1026 2937 +1026 2938 +1026 2939 +1027 1221 +1027 1316 +1027 1750 +1027 2471 +1027 2612 +1027 2849 +1027 2859 +1027 2952 +1027 2953 +1027 2954 +1029 121 +1029 122 +1029 125 +1029 127 +1029 147 +1029 249 +1029 251 +1029 367 +1029 718 +1029 2098 +1030 791 +1030 2651 +1030 2693 +1030 2944 +1030 2945 +1030 2946 +1030 2947 +1030 2948 +1030 2949 +1030 2950 +112 1064 +112 1160 +112 2044 +112 2045 +112 2046 +112 2047 +112 2048 +112 2049 +112 2050 +298 7 +298 8 +298 121 +298 144 +298 252 +298 266 +298 352 +298 424 +298 666 +579 231 +579 893 +579 1476 +579 1629 +579 1682 +579 2529 +579 2530 +579 2531 +579 2532 +579 2533 +2485 33 +2485 100 +2485 568 +2485 2422 +2485 2588 +2485 2654 +2485 3335 +2485 4124 +2485 4125 +2485 4126 +848 448 +867 53 +867 470 +867 1734 +867 1738 +867 2527 +867 2766 +867 2767 +867 2768 +867 2769 +867 2770 +1228 23 +1228 123 +1228 126 +1228 173 +1228 1896 +1228 3323 +1228 4906 +1228 4907 +1782 503 +1782 1103 +1782 1224 +1782 1301 +1782 1585 +1782 2272 +1782 2766 +1782 3105 +1782 3531 +1782 3532 +1784 3 +1784 4 +1784 122 +1784 143 +1784 422 +1784 423 +1784 427 +1784 666 +1784 667 +1815 459 +1815 801 +1815 808 +1815 892 +1815 1794 +1815 1816 +1815 1817 +1815 1818 +1815 1819 +1815 1820 +869 586 +869 833 +869 1195 +869 1367 +869 1762 +869 2354 +869 2380 +869 2753 +869 2754 +869 2755 +874 149 +874 177 +874 307 +874 652 +874 1003 +874 1022 +874 1655 +874 2495 +874 2761 +874 2762 +876 541 +1402 55 +1402 96 +1402 1444 +1402 2186 +1402 2662 +1402 3137 +1402 3258 +1402 3259 +1402 3260 +1402 3261 +1454 3 +1454 629 +1454 691 +1454 937 +1454 1989 +1454 2089 +1454 3232 +1454 3307 +1454 3308 +1454 3309 +1458 4 +1458 5 +1458 125 +1458 144 +1458 148 +1458 149 +1458 353 +1458 422 +1458 666 +1458 856 +1866 4 +1866 123 +1866 127 +1866 368 +1866 390 +1866 1245 +1866 2572 +1866 3675 +1866 3676 +2719 92 +2719 182 +2719 835 +2719 1209 +2719 1255 +2719 1442 +2719 3117 +2719 4278 +2719 4279 +2719 4280 +3220 152 +3220 503 +3220 507 +3220 548 +3220 2345 +3220 2575 +3220 4600 +3220 4601 +3220 4602 +289 290 +289 291 +289 292 +289 293 +289 294 +289 295 +289 296 +289 297 +289 298 +289 299 +2551 962 +3926 2349 +3926 2362 +3926 2596 +3926 2925 +3926 3098 +3926 3358 +3926 4413 +3926 4534 +3926 5002 +3926 5003 +5653 538 +5653 614 +5653 675 +5653 2481 +5653 4655 +5653 5291 +5653 5601 +5653 5927 +5653 5928 +5653 5929 +2733 3 +2733 8 +2733 177 +2733 238 +2733 249 +2733 368 +2733 369 +2733 427 +2733 667 +2733 717 +2942 21 +2942 132 +2942 924 +2942 1335 +2942 1417 +2942 1842 +2942 1890 +2942 4415 +2942 4416 +2942 4417 +238 9 +238 143 +238 146 +238 174 +238 667 +238 2181 +238 2182 +238 2183 +238 2184 +238 2185 +910 518 +910 869 +910 2322 +910 2797 +910 2798 +910 2799 +910 2800 +910 2801 +910 2802 +910 2803 +1275 1276 +1275 1277 +1275 1278 +1275 1279 +1275 1280 +1275 1281 +1275 1282 +1275 1283 +1275 1284 +1275 1285 +3310 296 +3310 1444 +3310 1529 +3310 2453 +3310 3211 +3310 4664 +3310 4665 +3310 4666 +3310 4667 +3310 4668 +3311 493 +3311 498 +3311 560 +3311 767 +3311 2293 +3312 29 +3312 513 +3312 532 +3312 1784 +3312 2143 +3312 2695 +3312 2955 +3312 3997 +3312 4669 +3312 4670 +3463 257 +3463 478 +3463 786 +3463 1129 +3463 2261 +3463 2330 +3463 3417 +3463 4767 +3463 4768 +3465 7 +3465 8 +3465 126 +3465 149 +3465 427 +3465 1246 +3465 1388 +3465 2538 +3465 4551 +3465 4769 +3466 50 +3466 51 +3466 732 +3466 1313 +3466 1325 +3466 1980 +3466 2309 +3466 2984 +3466 3141 +3466 3405 +2324 240 +2324 566 +2324 810 +2324 968 +2324 1245 +2324 3230 +2324 3257 +2324 3475 +2324 3538 +2324 3752 +1659 143 +1659 522 +1659 1791 +1659 2285 +1659 2349 +1659 2862 +1659 3121 +1659 3175 +1659 3300 +1659 3412 +1805 871 +1805 1806 +1805 1807 +1805 1808 +1805 1809 +1805 1810 +1805 1811 +1805 1812 +1805 1813 +1805 1814 +1939 840 +3459 3 +3459 124 +3459 127 +3459 129 +3459 177 +3459 251 +3459 266 +3459 367 +3459 368 +3459 422 +3462 2115 +3462 2568 +3462 4393 +3462 4395 +3462 4761 +3462 4762 +3462 4763 +3462 4764 +3462 4765 +3462 4766 +78 725 +78 898 +78 1157 +78 1894 +78 2203 +78 2204 +78 2205 +889 2547 +889 2951 +2906 301 +2906 692 +2906 2106 +2906 2670 +2906 2916 +2906 3188 +2906 4334 +2906 4402 +2906 4403 +2906 4404 +3468 740 +3468 997 +3468 1565 +3468 3968 +3468 4206 +3468 4239 +3468 4355 +3468 4770 +3468 4771 +3468 4772 +3469 123 +3469 266 +3469 570 +3469 1630 +3469 2236 +3469 2752 +3469 2948 +3469 3247 +3469 4773 +3469 4774 +3470 583 +3470 1947 +3470 2360 +3470 2528 +3470 2636 +3470 4155 +3470 4775 +3470 4776 +3470 4777 +3471 714 +3471 2425 +3471 2517 +3471 3386 +3471 4854 +33 34 +33 35 +33 36 +33 37 +33 38 +33 39 +33 40 +33 41 +33 42 +33 43 +36 3 +36 123 +36 126 +36 145 +36 174 +36 179 +36 247 +36 249 +36 264 +36 424 +39 614 +39 1378 +39 1922 +39 1923 +39 1924 +39 1925 +39 1926 +39 1927 +39 1928 +39 1929 +43 1604 +43 1679 +43 1903 +43 1930 +43 1931 +43 1932 +43 1933 +43 1934 +43 1935 +43 1936 +2007 199 +2007 203 +2007 527 +2007 3581 +2007 3680 +2007 3785 +2007 3786 +2007 3787 +2007 3788 +2007 3789 +1922 873 +1922 1359 +1922 1526 +1922 2941 +1922 3612 +1922 3688 +1922 3689 +1922 3690 +1922 3691 +1922 3692 +1923 60 +1923 82 +1923 586 +1923 835 +1923 1749 +1923 1969 +1923 2317 +1923 3693 +1923 3694 +1923 3695 +1924 524 +1924 2451 +1924 2908 +1924 3051 +1924 3219 +1924 3867 +1926 982 +1926 1929 +1926 2090 +1926 2317 +1926 2407 +1926 3107 +1926 3696 +1926 3697 +1926 3698 +1926 3699 +1929 126 +1929 128 +1929 145 +1929 149 +1929 174 +1929 177 +1929 179 +1929 266 +1929 2001 +1929 2018 +1930 190 +1930 814 +1930 923 +1930 1655 +1930 2900 +1930 3703 +1930 3704 +1930 3705 +1930 3706 +1930 3707 +1932 364 +1932 685 +1932 921 +1932 1313 +1932 1829 +1932 2644 +1932 3018 +1932 3713 +1932 3714 +1934 4 +1934 5 +1934 144 +1934 145 +1934 175 +1934 367 +1934 390 +1934 559 +1934 718 +203 5973 +203 5974 +527 1020 +527 1171 +527 1342 +527 2671 +527 2837 +527 2935 +527 3786 +527 3840 +527 4248 +527 4455 +527 4876 +527 4979 +527 4980 +1359 626 +1359 913 +1359 1741 +1359 1958 +1359 1980 +1359 2194 +1359 2617 +1359 3206 +1359 3207 +1359 3208 +3612 4855 +3690 252 +3690 360 +3690 1224 +3690 1288 +3690 3868 +3690 4200 +3690 4884 +3690 4885 +3690 4886 +3690 4887 +60 1937 +60 1938 +60 1939 +60 1940 +60 1941 +60 1942 +60 1943 +60 1944 +60 1945 +1749 863 +1749 1094 +1749 1555 +1749 2722 +1749 2743 +1749 2996 +1749 3506 +1749 3507 +1749 3508 +1749 3509 +1969 1541 +1969 1548 +1969 2878 +1969 3179 +1969 3519 +1969 3549 +1969 3754 +1969 3755 +1969 3756 +1969 3757 +3693 3 +3693 123 +3693 126 +3693 144 +3693 149 +3693 179 +3693 251 +3693 367 +3693 424 +3693 717 +3694 1280 +2451 81 +2451 892 +2451 2345 +2451 3205 +2451 3442 +2451 3719 +2451 3735 +2451 4121 +2451 4122 +2451 4123 +3867 1297 +3867 1866 +3867 1867 +3867 2356 +3867 2376 +3867 3329 +3867 3615 +3867 4828 +3867 4971 +3867 4972 +2407 96 +2407 122 +2407 123 +2407 143 +2407 249 +2407 368 +2407 856 +2407 2001 +2407 2196 +2407 2563 +3699 195 +3699 1903 +3699 2479 +3699 2650 +3699 2768 +3699 3822 +3699 4180 +3699 4888 +3699 4889 +3699 4890 +923 451 +923 494 +923 685 +923 922 +923 924 +923 925 +923 926 +923 927 +923 928 +2900 177 +2900 303 +2900 1487 +2900 2751 +2900 3142 +2900 3179 +2900 3544 +2900 4384 +2900 4385 +2900 4386 +3703 459 +3703 1171 +3703 1822 +3703 3193 +3703 3204 +3703 3767 +3703 3778 +3703 4813 +3703 4893 +3705 276 +3705 552 +3705 995 +3705 1947 +3705 1972 +3705 2430 +3705 3594 +3705 4891 +3705 4892 +3714 1056 +44 45 +44 46 +44 47 +44 48 +44 49 +44 50 +44 51 +44 52 +44 53 +44 54 +49 101 +49 338 +49 2366 +49 2893 +49 3065 +49 3593 +49 3840 +49 3998 +49 3999 +101 143 +101 147 +101 249 +101 251 +101 264 +101 369 +101 422 +101 559 +101 718 +101 2018 +3998 255 +3998 1332 +3998 1730 +3998 1936 +3998 3213 +3998 3625 +3998 4704 +3998 5039 +3998 5040 +3998 5041 +422 1911 +422 2394 +422 2395 +422 2396 +422 2397 +422 2398 +422 2399 +422 2400 +422 2401 +422 2402 +3213 3 +3213 5 +3213 7 +3213 8 +3213 124 +3213 174 +3213 249 +3213 251 +3213 369 +3213 427 +5040 1010 +5040 2304 +5040 2392 +5040 2443 +5040 2853 +5040 3081 +5040 4507 +5040 5437 +5040 5612 +5040 5613 +55 56 +55 57 +55 58 +55 59 +55 60 +55 61 +55 62 +55 63 +55 64 +55 65 +61 907 +61 1922 +61 1992 +61 1993 +61 1994 +61 1995 +61 1996 +61 1997 +61 1998 +61 1999 +63 1364 +63 1950 +63 1977 +63 1978 +63 1979 +63 1980 +63 1981 +63 1982 +63 1983 +65 86 +65 1954 +65 2002 +65 2003 +65 2004 +65 2005 +65 2006 +65 2007 +65 2008 +65 2009 +1941 749 +1941 1362 +1941 2785 +1941 3136 +1941 3599 +1941 3708 +1941 3709 +1941 3710 +1941 3711 +1941 3712 +1942 2255 +1942 2272 +1942 2853 +1942 2932 +1942 3027 +1942 3718 +1942 3719 +1942 3720 +1942 3721 +1943 13 +1943 279 +1943 646 +1943 1887 +1943 2545 +1943 3256 +1943 3515 +1943 3715 +1943 3716 +1943 3717 +907 64 +907 1292 +907 1397 +907 2099 +907 2778 +907 2804 +907 2805 +907 2806 +907 2807 +907 2808 +1992 126 +1992 128 +1992 144 +1992 145 +1992 147 +1992 424 +1992 2018 +1992 2614 +1992 3466 +1992 3764 +1994 664 +1994 788 +1994 1022 +1994 1195 +1994 1371 +1994 1688 +1994 1762 +1994 1954 +1994 2001 +1994 2226 +1994 2255 +1994 2366 +1994 2377 +1994 2384 +1994 2490 +1994 2597 +1994 3429 +1994 3778 +1994 3779 +1994 3780 +1994 3781 +1994 3782 +1994 3783 +1994 3784 +1995 3767 +1996 909 +1996 1297 +1996 1535 +1996 1571 +1996 2201 +1996 2265 +1996 2942 +1996 3193 +1996 3765 +1996 3766 +1998 3770 +1999 209 +1999 924 +1999 1199 +1999 1297 +1999 1606 +1999 1608 +1999 1867 +1999 1868 +1999 3336 +1999 3769 +1198 338 +1198 1158 +1198 1382 +1198 1383 +1198 3059 +1198 3060 +1198 3061 +1198 3062 +1198 3063 +1198 3064 +1950 1528 +1950 2089 +1950 2462 +1950 2652 +1950 2931 +1981 451 +1981 1724 +1981 2255 +1981 2524 +1981 3758 +1981 3759 +1981 3760 +1981 3761 +1981 3762 +1981 3763 +1982 2086 +91 243 +91 1923 +91 2194 +102 1928 +102 1968 +102 2026 +102 2027 +102 2028 +1946 440 +1946 984 +1946 2486 +1946 2600 +1946 3058 +1946 3070 +1946 3310 +1946 3725 +1947 208 +1947 1934 +1947 2456 +1947 3419 +1947 3727 +1947 3728 +1947 3729 +1947 3730 +1947 3731 +1947 3732 +1948 121 +1948 126 +1948 128 +1948 144 +1948 145 +1948 148 +1948 265 +1948 368 +1948 559 +1948 1626 +1951 3113 +2003 442 +2003 494 +2003 918 +2003 1326 +2003 3230 +2003 3773 +2003 3774 +2003 3775 +2003 3776 +2003 3777 +1362 1026 +1362 1061 +1362 1348 +1362 1363 +1362 1364 +1362 1365 +1362 1366 +1362 1367 +1362 1368 +1362 1369 +3599 693 +3599 2916 +3599 3682 +3599 4852 +3599 4853 +3710 3335 +3710 3708 +3710 4959 +3027 29 +3027 38 +3027 576 +3027 1208 +3027 2018 +3027 2291 +3027 2396 +3027 4468 +3027 4469 +3027 4470 +3719 113 +3719 180 +3719 795 +3719 2186 +3719 2341 +3719 3523 +3719 3740 +3719 4884 +3719 4904 +3719 4905 +279 8 +279 280 +279 281 +279 282 +279 283 +279 284 +279 285 +279 286 +279 287 +279 288 +646 9 +646 126 +646 145 +646 147 +646 179 +646 252 +646 265 +646 368 +646 426 +3256 762 +3256 1361 +3256 2222 +3256 2753 +3256 3358 +3256 3467 +3256 4139 +3256 4636 +3256 4637 +3515 3 +3515 4 +3515 127 +3515 147 +3515 176 +3515 264 +3515 427 +3515 666 +3515 667 +3715 116 +3715 429 +3715 2287 +3715 4002 +3715 4476 +3715 4839 +3715 4894 +3715 4895 +3715 4896 +3715 4897 +3715 4898 +3716 977 +3716 3119 +3716 3301 +3716 3376 +3716 3890 +3716 4655 +3716 4900 +3716 4901 +3716 4902 +3716 4903 +151 152 +151 153 +151 154 +151 155 +151 156 +151 157 +151 158 +151 159 +151 160 +151 161 +178 255 +178 256 +178 554 +178 871 +178 1947 +178 2125 +178 2126 +178 2127 +178 2128 +178 2129 +1144 17 +1144 31 +1144 126 +1144 143 +1144 144 +1144 145 +1144 149 +1144 266 +1144 422 +1144 754 +1653 69 +1653 485 +1653 1246 +1653 1563 +1653 3403 +1292 3149 +1397 279 +1397 665 +1397 822 +1397 1143 +1397 1890 +1397 2160 +1397 2384 +1397 3194 +1397 3288 +1397 3289 +2778 3497 +2804 470 +2804 604 +2804 1325 +2804 1451 +2804 2422 +2804 2733 +2804 2768 +2804 3276 +2804 3772 +2804 4311 +2807 143 +2807 249 +2807 264 +2807 390 +2807 423 +2807 559 +2807 1842 +2807 4312 +2807 4313 +2807 4314 +2808 102 +2808 552 +2808 667 +2808 677 +2808 1056 +2808 1956 +2808 2719 +2808 4189 +2808 4316 +2808 4317 +2614 548 +2614 1165 +2614 1217 +2614 1342 +2614 1985 +2614 2018 +2614 2022 +2614 2343 +2614 2384 +2614 2465 +2614 3232 +2614 3385 +2614 3488 +2614 3903 +2614 4159 +2614 4212 +2614 4213 +2614 4214 +2614 4215 +2614 4216 +2614 4217 +2614 4218 +2377 227 +2377 432 +2377 500 +2377 561 +2377 2392 +2377 2646 +2377 2798 +2377 3172 +2377 4063 +2377 4064 +2384 187 +2384 503 +2384 1797 +2384 2350 +2384 2420 +2384 2563 +2384 4069 +2384 4070 +2384 4071 +2490 3 +2490 147 +2490 176 +2490 251 +2490 264 +2490 367 +2490 427 +2490 559 +2490 718 +2490 2018 +2597 21 +2597 352 +2597 476 +2597 505 +2597 621 +2597 1347 +2597 2964 +2597 3607 +2597 3687 +2597 3871 +3429 1447 +3429 2292 +3429 2413 +3429 2918 +3429 4020 +3781 327 +3781 1059 +3781 1086 +3781 1123 +3781 2519 +3781 3850 +3781 4031 +3781 4923 +3781 4924 +3781 4925 +3767 863 +3767 864 +3767 1239 +3767 1339 +3767 1711 +3767 2254 +3767 3299 +3767 4846 +3767 4920 +3767 4921 +909 124 +909 127 +909 175 +909 180 +909 251 +909 367 +909 368 +909 390 +909 718 +1297 289 +1297 435 +1297 753 +1297 901 +1297 1199 +1297 1504 +1297 1763 +1297 1764 +1297 1765 +1297 1766 +1535 261 +1535 694 +1535 1608 +1535 1631 +1535 1940 +1535 2179 +1535 2724 +1535 3334 +1535 3335 +1535 3336 +3193 1983 +3765 921 +3765 4586 +3765 4796 +3765 4918 +3765 4919 +209 976 +209 1903 +209 1940 +209 2103 +209 2429 +209 2430 +209 2431 +209 2432 +924 5 +924 7 +924 122 +924 123 +924 149 +924 176 +924 179 +924 249 +924 264 +924 717 +1867 665 +1867 810 +1867 1607 +1867 1849 +1867 2105 +1867 2787 +1867 3615 +1867 3616 +1867 3617 +1867 3618 +1868 146 +1868 148 +1868 149 +1868 174 +1868 251 +1868 252 +1868 367 +1868 390 +1868 718 +1868 1317 +1158 552 +1158 1017 +1158 1316 +1158 2146 +1158 2844 +1158 3039 +1158 3040 +1158 3041 +1158 3042 +1158 3043 +1382 130 +1382 208 +1382 476 +1382 849 +1382 874 +1382 1022 +1382 1384 +1382 1411 +1382 1671 +1382 1955 +1382 2226 +1382 2414 +1382 2612 +1382 2658 +1382 2819 +1382 3335 +1382 3552 +1382 4132 +1382 4170 +1382 4825 +1382 5241 +1382 5428 +1382 5487 +1382 5494 +1382 5717 +1382 5785 +1382 5786 +1382 5787 +1382 5788 +3059 7 +3059 8 +3059 123 +3059 129 +3059 144 +3059 149 +3059 174 +3059 248 +3059 367 +3059 717 +3060 92 +3060 268 +3060 393 +3060 1720 +3060 2114 +3060 2451 +3060 2500 +3060 3609 +3060 3959 +3060 4295 +3061 4 +3061 126 +3061 144 +3061 689 +3061 4428 +3061 4451 +3061 4486 +3061 4487 +3061 4488 +3063 707 +3063 926 +3063 3016 +3063 3570 +3063 4492 +1724 493 +1724 837 +1724 1677 +1724 1726 +1724 2038 +1724 3275 +1724 3487 +1724 3488 +1724 3489 +1724 3490 +3759 1217 +1968 476 +1968 955 +1968 1054 +1968 1773 +1968 2625 +1968 3733 +1968 3734 +1968 3735 +1968 3736 +440 261 +440 1607 +440 1868 +440 2312 +440 2399 +440 2492 +440 2784 +440 3617 +440 4781 +440 5476 +984 257 +984 440 +984 859 +984 985 +984 986 +984 987 +984 988 +984 989 +984 990 +984 991 +2486 133 +2486 309 +2486 478 +2486 691 +2486 1019 +2486 1235 +2486 1317 +2486 2196 +2486 4127 +2486 4128 +3058 122 +3058 124 +3058 143 +3058 247 +3058 252 +3058 264 +3058 367 +3058 369 +3058 559 +208 209 +208 210 +208 211 +208 212 +208 213 +208 214 +208 215 +208 216 +208 217 +2456 942 +3728 73 +3728 2923 +3728 3495 +3728 4908 +3728 4909 +3732 1454 +3732 1509 +3732 1568 +3732 1946 +3732 2276 +3732 5688 +3732 5796 +3732 5823 +3732 6138 +1626 340 +1626 637 +1626 860 +1626 2075 +1626 2410 +1626 2570 +1626 3110 +1626 3379 +1626 3380 +1626 3381 +494 658 +494 892 +494 924 +494 1372 +494 1787 +494 2475 +494 2476 +494 2477 +494 2478 +494 2479 +1326 335 +1326 2722 +1326 3192 +1326 3193 +1326 3194 +3776 77 +3776 262 +3776 492 +3776 1975 +3776 3343 +3776 3681 +3776 4266 +3776 4587 +3776 4664 +3776 4922 +66 16 +66 67 +66 68 +66 69 +66 70 +66 71 +66 72 +66 73 +66 74 +66 75 +67 472 +67 534 +67 762 +67 1123 +67 2222 +67 2789 +67 3052 +67 3332 +67 3769 +67 3956 +68 152 +68 219 +68 346 +68 965 +68 1953 +68 1954 +68 1955 +68 1956 +68 1957 +68 1958 +73 717 +73 1022 +73 1969 +73 1970 +73 1971 +73 1972 +73 1973 +73 1974 +73 1975 +73 1976 +75 190 +75 219 +75 262 +75 1142 +75 1337 +75 1964 +75 1965 +75 1966 +75 1967 +75 1968 +472 347 +472 1267 +472 1485 +472 1486 +472 1487 +472 1488 +472 1489 +472 1490 +472 1491 +472 1492 +3956 1030 +3956 2254 +3956 3822 +3956 5016 +3956 5017 +346 238 +346 343 +346 1018 +346 2301 +346 2302 +346 2303 +346 2304 +346 2305 +346 2306 +346 2307 +965 583 +965 1208 +965 1390 +965 1728 +965 2871 +965 2872 +965 2873 +965 2874 +965 2875 +965 2876 +1958 58 +1958 172 +1958 582 +1958 583 +1958 1250 +1958 1541 +1958 2394 +1958 2758 +1958 3159 +1958 3726 +1971 769 +1971 774 +1971 1127 +1971 1341 +1971 2847 +1971 3737 +1971 3738 +1971 3739 +1971 3740 +1971 3741 +1972 170 +1972 252 +1972 1615 +1972 2279 +1972 3563 +1972 3749 +1972 3750 +1972 3751 +1972 3752 +1972 3753 +1973 155 +1973 520 +1973 2020 +1973 2222 +1973 2889 +1973 3220 +1973 3595 +1973 3742 +1973 3743 +1974 694 +1974 1590 +1974 2368 +1974 3050 +1974 3530 +1974 3744 +1974 3745 +1974 3746 +1974 3747 +1974 3748 +1337 38 +1337 143 +1337 266 +1337 693 +1337 911 +1337 1221 +1337 1724 +1337 1725 +1337 1726 +1337 1727 +1267 251 +1267 459 +1267 1268 +1267 1269 +1267 1270 +1267 1271 +1267 1272 +1267 1273 +1267 1274 +1485 8 +1485 9 +1485 121 +1485 125 +1485 128 +1485 129 +1485 144 +1485 352 +1485 427 +1485 1246 +1487 3 +1487 127 +1487 177 +1487 183 +1487 247 +1487 249 +1487 367 +1487 427 +1487 718 +1487 2338 +3822 78 +3822 886 +3822 1423 +3822 2642 +3822 2982 +3822 3779 +3822 4623 +3822 4746 +3822 4939 +5016 133 +5016 241 +5016 582 +5016 965 +5016 1316 +5016 1541 +5016 1882 +5016 2090 +5016 5178 +5016 5601 +343 122 +343 127 +343 176 +343 249 +343 251 +343 558 +343 666 +343 667 +343 754 +343 1245 +2304 1327 +2304 1347 +2304 2189 +1390 313 +1390 387 +1390 1942 +1390 2322 +1390 2904 +1390 3230 +1390 3231 +1390 3232 +1390 3233 +1390 3234 +2871 13 +2871 554 +2871 1756 +2871 3247 +2871 3485 +2871 3489 +2871 3959 +2871 4342 +2871 4343 +2873 3 +2873 124 +2873 143 +2873 176 +2873 248 +2873 264 +2873 352 +2873 367 +2873 369 +2873 856 +2875 141 +2875 396 +2875 848 +2875 2313 +2875 3327 +2875 3894 +2875 4051 +2875 4357 +2875 4358 +2875 4359 +172 127 +172 128 +172 129 +172 145 +172 174 +172 177 +172 247 +172 353 +172 1246 +172 1317 +582 412 +582 715 +582 1068 +582 1541 +582 1854 +582 2354 +582 2414 +582 2535 +582 2536 +582 2537 +1250 193 +1250 308 +1250 878 +1250 935 +1250 1415 +1250 1524 +1250 2157 +1250 2179 +1250 3112 +1250 3113 +1541 3 +1541 122 +1541 325 +1541 548 +1541 679 +1541 1245 +1541 2039 +1541 3096 +1541 3323 +1541 3347 +3726 30 +3726 152 +3726 1917 +3726 2186 +3726 2646 +3726 2922 +3726 3259 +3726 3411 +3726 4913 +3726 4914 +3179 282 +3179 303 +3179 728 +3179 822 +3179 1143 +3179 1505 +3179 2528 +3179 2885 +3179 3769 +3179 4075 +3519 648 +3519 895 +3519 1227 +3519 4872 +3519 4883 +3549 190 +3549 227 +3549 260 +3549 412 +3549 637 +3549 979 +3549 1689 +3549 1702 +3549 2984 +3549 3136 +3757 123 +3757 127 +3757 147 +3757 249 +3757 251 +3757 368 +3757 423 +3757 718 +3757 1245 +769 1024 +769 1335 +769 2547 +769 2579 +769 2670 +769 2700 +769 2701 +769 2702 +769 2703 +769 2704 +1341 63 +1341 435 +1341 740 +1341 1754 +1341 2125 +1341 2217 +1341 2524 +1341 2740 +1341 3204 +1341 3205 +2847 244 +2847 498 +2847 510 +2847 527 +2847 747 +2847 1817 +2847 2535 +2847 3912 +2847 4335 +2847 4336 +3737 660 +3738 587 +3738 1216 +3738 1424 +3738 1792 +3738 2010 +3738 3084 +3738 4788 +3738 4915 +3738 4916 +2279 401 +2279 1273 +2279 1337 +2279 1587 +2279 1797 +2279 3397 +2279 3964 +2279 3965 +2279 3966 +2279 3967 +155 5 +155 121 +155 126 +155 128 +155 129 +155 175 +155 238 +155 353 +155 1317 +2020 5 +2020 126 +2020 144 +2020 145 +2020 149 +2020 176 +2020 247 +2020 249 +2020 251 +2020 352 +3742 979 +3742 1730 +3742 2204 +3742 2215 +3742 2556 +3742 3020 +3742 3523 +3742 4285 +3742 4408 +3742 4411 +694 174 +694 175 +694 265 +694 351 +694 695 +694 696 +694 697 +694 698 +694 699 +694 700 +1590 710 +1590 894 +1590 1179 +1590 1688 +1590 1886 +1590 2643 +1590 3104 +1590 3369 +1590 3370 +3744 3149 +3747 496 +3747 621 +3747 678 +3747 2875 +3747 2973 +3747 3993 +3747 4641 +3747 4877 +3747 4917 +693 1628 +693 2602 +693 2603 +693 2604 +693 2605 +693 2606 +693 2607 +693 2608 +693 2609 +693 2610 +955 690 +955 711 +955 781 +955 908 +955 1337 +955 1541 +955 1901 +955 2214 +955 2422 +955 2428 +955 2805 +955 2837 +955 2838 +955 2839 +955 2840 +955 2841 +955 2842 +955 2843 +3733 118 +3733 241 +3733 1086 +3733 2119 +3733 2364 +3733 2502 +3733 3260 +3733 4910 +3733 4911 +3733 4912 +3734 5 +3734 125 +3734 145 +3734 179 +3734 390 +3734 422 +3734 424 +3734 558 +3734 667 +3734 856 +76 77 +76 78 +76 79 +76 80 +76 81 +76 82 +76 83 +76 84 +76 85 +76 86 +80 2014 +81 1067 +81 1916 +81 1984 +81 1985 +81 1986 +81 1987 +81 1988 +81 1989 +81 1990 +81 1991 +83 7 +83 8 +83 9 +83 148 +83 351 +83 426 +83 762 +83 946 +83 2000 +83 2001 +2205 938 +2205 1608 +2205 1849 +2205 3109 +2205 4080 +2205 5310 +2205 5724 +2205 6000 +2205 6001 +2014 21 +2014 2304 +2014 3038 +2014 3052 +2014 3377 +2014 3574 +2014 3790 +2014 3791 +2014 3792 +2014 3793 +1984 255 +1984 361 +1984 2113 +1984 2721 +1984 3554 +1986 1103 +1987 227 +1987 2292 +1987 2528 +1987 2914 +1987 3709 +1987 5541 +1987 5584 +1987 5795 +1987 5796 +1987 5797 +1988 3768 +1989 848 +1989 1792 +1989 1845 +1989 2354 +1989 5177 +5724 3 +5724 7 +5724 122 +5724 123 +5724 124 +5724 125 +5724 145 +5724 177 +5724 352 +5724 427 +3038 308 +3038 1001 +3038 1239 +3038 1766 +3038 2490 +3038 3516 +3038 3564 +3038 3781 +3038 4471 +3038 4472 +3790 256 +3790 413 +3790 459 +3790 1305 +3790 1940 +3790 2113 +3790 2841 +3790 3288 +3790 4160 +3790 4581 +3791 174 +3791 823 +3791 2032 +3791 2971 +3791 3185 +3791 4419 +3791 4526 +3791 4894 +3791 4928 +3791 4929 +2721 959 +2721 1526 +2721 2341 +2721 2397 +2721 2524 +2721 3215 +2721 3441 +2721 3695 +2721 4290 +2292 298 +2292 667 +2292 1044 +2292 1259 +2292 1762 +2292 2497 +2292 3329 +2292 3982 +2292 3983 +2292 3984 +1792 1001 +1792 1203 +1792 2377 +1792 3000 +1792 3104 +1792 3536 +1792 3537 +1792 3538 +1792 3539 +1792 3540 +5177 1438 +5177 3109 +5177 4930 +5177 5681 +5177 5682 +5177 5683 +5177 5684 +5177 5685 +5177 5686 +5177 5687 +355 49 +355 117 +355 968 +355 2308 +355 2309 +355 2310 +355 2311 +355 2312 +355 2313 +355 2314 +356 572 +356 980 +356 1212 +356 2321 +356 2322 +356 2323 +356 2324 +356 2325 +356 2326 +356 2327 +359 520 +359 633 +359 1334 +359 1451 +359 2332 +359 2333 +359 2334 +359 2335 +359 2336 +359 2337 +253 219 +253 254 +253 255 +253 256 +253 257 +253 258 +253 259 +253 260 +253 261 +253 262 +2281 344 +2281 930 +2281 1744 +2281 2275 +2281 2292 +2281 2498 +2281 3296 +2281 3569 +2281 3962 +2281 3963 +3771 184 +3771 215 +3771 286 +3771 1979 +3771 2748 +3771 4301 +3771 4840 +3771 4926 +3771 4927 +3771 4928 +3772 2414 +87 88 +87 89 +87 90 +87 91 +87 92 +87 93 +87 94 +87 95 +87 96 +87 97 +89 211 +89 914 +89 1476 +89 1776 +89 1906 +89 1976 +89 2010 +89 2011 +89 2012 +89 2013 +211 494 +211 621 +211 1358 +211 1412 +211 2161 +211 2162 +211 2163 +211 2164 +211 2165 +211 2166 +1476 686 +1476 1390 +1476 3017 +1476 3077 +1476 3317 +1476 3318 +1476 3319 +1476 3320 +1476 3321 +1476 3322 +2164 57 +2164 453 +2164 851 +2164 1049 +2164 2423 +2164 2648 +2164 2669 +2164 2906 +2164 3468 +2164 3906 +686 1162 +686 1309 +686 1573 +686 1958 +686 2587 +686 2588 +686 2589 +686 2590 +686 2591 +686 2592 +3077 3 +3077 127 +3077 147 +3077 264 +3077 352 +3077 368 +3077 390 +3077 423 +3077 427 +3077 1245 +3317 4678 +3321 1913 +3321 1926 +3321 2433 +3321 4014 +3321 4675 +1564 3 +1564 127 +1564 144 +1564 146 +1564 149 +1564 176 +1564 177 +1564 238 +1564 247 +1564 367 +2195 244 +2195 1087 +2195 2697 +2195 2981 +2195 3205 +2195 3319 +2195 3916 +2195 3917 +2195 3918 +98 99 +98 100 +98 101 +98 102 +98 103 +98 104 +98 105 +98 106 +98 107 +98 108 +100 2017 +104 2025 +105 363 +105 820 +105 1041 +105 1240 +105 2019 +105 2020 +105 2021 +105 2022 +105 2023 +105 2024 +108 324 +108 365 +108 1486 +108 2037 +108 2038 +108 2039 +108 2040 +108 2041 +108 2042 +108 2043 +2017 96 +2017 1914 +2017 2750 +2017 2794 +2017 3713 +2017 3807 +2017 3808 +2017 3809 +2017 3810 +2017 3811 +820 3 +820 5 +820 7 +820 125 +820 126 +820 128 +820 145 +820 369 +820 424 +820 1317 +1041 69 +1041 529 +1041 621 +1041 789 +1041 1042 +1041 1043 +1041 1044 +1041 1045 +1041 1046 +1041 1047 +2022 2344 +2023 38 +2023 281 +2023 369 +2023 2152 +2023 2728 +2023 3487 +2023 3489 +2023 3595 +2023 3797 +2023 3798 +2024 29 +2024 53 +2024 56 +2024 1034 +2024 1230 +2024 1556 +2024 3489 +2024 3794 +2024 3795 +2024 3796 +324 568 +2037 148 +2037 176 +2037 179 +2037 238 +2037 265 +2037 369 +2037 424 +2037 426 +2037 1317 +2037 2098 +2038 266 +2038 390 +2038 422 +2038 423 +2038 559 +2038 736 +2038 754 +2038 856 +2038 886 +2038 2018 +2039 348 +2039 1033 +2039 3465 +2039 4438 +2039 5170 +2039 5171 +2039 5172 +2039 5173 +2039 5174 +2039 5175 +2043 125 +2043 191 +2043 449 +2043 2621 +2043 3010 +2043 3817 +2043 3818 +2043 3819 +2043 3820 +2043 3821 +2794 513 +2794 1042 +2794 1509 +2794 2001 +2794 2292 +2794 2615 +2794 3215 +2794 3907 +2794 4306 +3810 1471 +3810 1591 +3810 2037 +3810 2038 +3810 2625 +3810 3822 +3810 4213 +3810 4932 +3810 4933 +2396 20 +2396 1162 +2396 1670 +2396 2173 +2396 3059 +2396 4004 +2396 4082 +2396 4083 +2396 4084 +2398 2792 +2398 3019 +2398 3721 +2398 3813 +2398 4087 +2399 59 +2399 730 +2399 1904 +2399 2395 +2399 2398 +2399 2551 +2399 3328 +2399 3921 +2399 4085 +2399 4086 +756 127 +756 262 +756 531 +756 757 +756 758 +756 759 +756 760 +756 761 +756 762 +756 763 +759 77 +759 464 +759 568 +759 1454 +759 2707 +759 2708 +759 2709 +759 2710 +759 2711 +759 2712 +821 32 +821 928 +821 1223 +821 1224 +821 1231 +821 1873 +821 2734 +821 2735 +821 2736 +821 2737 +823 563 +823 894 +823 1264 +823 1322 +823 1323 +823 1324 +823 1325 +823 1326 +823 1327 +823 1328 +1043 3146 +1043 4264 +1046 3 +1046 17 +1046 31 +1046 146 +1046 147 +1046 175 +1046 250 +1046 368 +1046 1245 +2728 121 +2728 129 +2728 174 +2728 183 +2728 238 +2728 353 +2728 424 +2728 427 +2728 717 +2728 2338 +3797 788 +3797 1954 +3797 2127 +3797 3017 +3797 3600 +3797 5089 +3797 5891 +3797 5892 +3797 5893 +3797 5894 +3798 1313 +3798 2375 +3798 2378 +3798 2612 +3798 3211 +3798 3479 +3798 3563 +3798 4209 +3798 4534 +3798 4931 +1230 586 +1230 862 +1230 1061 +1230 1900 +1230 1923 +1230 2723 +1230 3670 +1230 4540 +3796 110 +3796 563 +3796 884 +3796 1313 +3796 2170 +3796 2216 +3796 3269 +3796 4930 +736 443 +736 737 +736 738 +736 739 +736 740 +736 741 +736 742 +736 743 +736 744 +736 745 +886 329 +886 887 +886 888 +886 889 +886 890 +886 891 +886 892 +886 893 +886 894 +886 895 +348 751 +348 930 +348 1322 +348 1364 +348 1366 +348 2004 +348 2292 +348 2293 +348 2294 +348 2295 +1033 281 +1033 554 +1033 659 +1033 1034 +1033 1035 +1033 1036 +1033 1037 +1033 1038 +1033 1039 +1033 1040 +4438 631 +4438 769 +4438 812 +4438 1317 +4438 1374 +4438 2906 +4438 3617 +4438 3635 +4438 4873 +4438 5275 +5171 795 +5171 1180 +5171 1338 +5171 2348 +5171 3453 +5171 3801 +5171 5642 +5171 5675 +5171 5676 +5171 5677 +5175 804 +5175 1770 +5175 2004 +5175 2214 +5175 3109 +5175 3596 +5175 3846 +5175 4912 +5175 5633 +5175 5638 +191 77 +191 2190 +191 2365 +191 2366 +191 2367 +191 2368 +191 2369 +191 2370 +191 2371 +191 2372 +449 4 +449 126 +449 129 +449 145 +449 147 +449 238 +449 266 +449 368 +449 1246 +2621 4 +2621 146 +2621 368 +2621 390 +2621 422 +2621 423 +2621 856 +2621 1245 +2621 1317 +2621 2001 +3010 31 +3010 709 +3010 845 +3010 1544 +3010 3056 +3010 4425 +3010 4449 +3010 4450 +3010 4451 +3010 4452 +3817 909 +3818 953 +3818 1021 +3818 1392 +3818 1798 +3818 2035 +3818 2285 +3818 4103 +3818 4936 +3818 4937 +3818 4938 +3819 432 +3819 514 +3819 730 +3819 1441 +3819 1538 +3819 2785 +3819 3249 +3819 3916 +3819 4484 +3819 4520 +3820 3 +3820 8 +3820 122 +3820 127 +3820 129 +3820 143 +3820 146 +3820 147 +3820 369 +3820 1245 +109 110 +109 111 +109 112 +109 113 +109 114 +109 115 +109 116 +109 117 +109 118 +109 119 +110 1332 +110 1361 +110 2029 +110 2030 +110 2031 +110 2032 +110 2033 +110 2034 +110 2035 +110 2036 +111 1419 +111 1561 +111 1670 +111 1787 +111 1846 +111 2065 +111 2066 +111 2067 +111 2068 +111 2069 +113 17 +113 143 +113 144 +113 145 +113 179 +113 368 +113 424 +113 754 +113 1317 +113 2018 +116 510 +116 1089 +116 2013 +116 2030 +116 2051 +116 2052 +116 2053 +116 2054 +116 2055 +116 2056 +1361 62 +1361 706 +1361 710 +1361 1814 +1361 2209 +1361 3237 +1361 3238 +1361 3239 +1361 3240 +1361 3241 +2032 3 +2032 121 +2032 125 +2032 179 +2032 249 +2032 251 +2032 264 +2032 423 +2032 427 +2032 717 +1419 740 +1419 1085 +1419 1131 +1419 1271 +1419 1420 +1419 1421 +1419 1422 +1419 1423 +1419 1424 +1419 1425 +1561 122 +1561 127 +1561 129 +1561 176 +1561 177 +1561 238 +1561 251 +1561 352 +1561 353 +1561 1245 +1670 113 +1670 473 +1670 1049 +1670 1321 +1670 1540 +1670 2298 +1670 2896 +1670 3014 +1670 3166 +1670 3572 +2065 585 +2066 4 +2066 17 +2066 144 +2066 145 +2066 148 +2066 149 +2066 179 +2066 424 +2066 559 +2066 856 +2068 119 +2068 1240 +2068 1415 +2068 1709 +2068 2664 +2068 3741 +2068 3879 +2069 347 +2069 1840 +2069 2051 +2069 2658 +2069 3357 +2069 3463 +2069 3637 +2069 3988 +2069 3989 +2069 3990 +2046 7 +2046 9 +2046 122 +2046 127 +2046 145 +2046 248 +2046 249 +2046 251 +2046 353 +2046 369 +2047 5 +2047 145 +2047 149 +2047 175 +2047 177 +2047 180 +2047 266 +2047 353 +2047 424 +2047 1246 +2049 740 +2049 1299 +2049 2684 +2049 2768 +2049 2903 +2049 3004 +2049 3039 +2049 3814 +2049 3815 +2049 3816 +2050 136 +2050 458 +2050 1414 +2050 1661 +2050 1747 +2050 2630 +2050 3822 +2050 3823 +2050 3824 +2050 3825 +1089 96 +1089 727 +1089 944 +1089 1313 +1089 2523 +1089 2872 +1089 3109 +2052 7 +2052 143 +2052 145 +2052 367 +2052 390 +2052 558 +2052 856 +2052 1040 +2052 1245 +2053 252 +2053 368 +2053 369 +2053 390 +2053 423 +2053 1208 +2053 2621 +2053 3675 +2053 3826 +2053 3827 +2055 31 +2055 489 +2055 2065 +2055 3290 +2055 3828 +2055 3829 +2055 3830 +2055 3831 +2055 3832 +2055 3833 +2056 10 +2056 127 +2056 145 +2056 175 +2056 176 +2056 247 +2056 353 +2056 369 +2056 629 +2056 993 +706 3501 +706 4623 +706 4624 +1814 442 +1814 1328 +1814 1817 +1814 2193 +1814 3204 +1814 3546 +1814 3547 +1814 3548 +1814 3549 +1814 3550 +740 124 +740 174 +740 1255 +740 1487 +740 1531 +740 1557 +740 1609 +740 2385 +740 2663 +740 4539 +1424 200 +1424 621 +1424 2261 +1424 2858 +1424 3282 +1424 3283 +1424 3284 +1424 3285 +1424 3286 +1424 3287 +473 1193 +473 1509 +473 3205 +473 3309 +473 4207 +473 4282 +473 4828 +473 4829 +473 4830 +1540 111 +1540 676 +1540 1023 +1540 1050 +1540 1167 +1540 1541 +1540 1542 +1540 1543 +1540 1544 +1540 1545 +3014 274 +3014 937 +3014 1016 +3014 1305 +3014 1503 +3014 1608 +3014 1800 +3014 1947 +3014 3706 +3014 4458 +3700 803 +3700 1050 +3700 1317 +3700 1396 +3700 1437 +3700 1481 +3700 2054 +3700 2114 +3700 4017 +3700 4899 +1415 17 +1415 455 +1415 747 +1415 2119 +1415 2311 +1415 2897 +1415 2975 +1415 3271 +1415 3272 +1415 3273 +1709 248 +1709 587 +1709 1306 +1709 1476 +1709 1509 +1709 1591 +1709 2291 +1709 2429 +1709 3007 +1709 3459 +3988 712 +3988 2209 +3988 2391 +3988 2523 +3988 3119 +3988 3362 +3988 4838 +3988 5024 +3988 5025 +3989 2705 +3989 3908 +3989 4103 +3989 4677 +3989 5028 +2852 159 +2852 288 +2852 422 +2852 554 +2852 576 +2852 837 +2852 1199 +2852 1429 +2852 1583 +2852 1591 +2852 1980 +2852 2547 +2852 2918 +2852 3105 +2852 3139 +2852 3921 +2852 4344 +2852 4345 +2852 4346 +2852 4347 +2852 4348 +2852 4349 +2852 4350 +2852 4351 +2852 4352 +2852 4353 +2852 4354 +2852 4355 +3149 1258 +3149 2007 +3149 2039 +3149 2067 +3149 2197 +3149 2218 +3149 2888 +3149 4380 +3149 4549 +3149 4550 +3813 491 +3813 637 +3813 1150 +3813 1338 +3813 1540 +3813 1947 +3813 4789 +3813 4895 +3813 4934 +3813 4935 +2903 117 +2903 380 +2903 716 +2903 1043 +2903 1706 +2903 1780 +2903 2761 +2903 3146 +2903 4387 +2903 4388 +3004 1900 +3004 1983 +3004 3463 +3004 4584 +3039 584 +3039 4599 +3815 178 +3815 1377 +3815 1614 +3815 2200 +3815 2901 +3815 3217 +3815 3225 +3815 3619 +3815 4207 +3815 4733 +136 57 +136 470 +136 852 +136 2480 +136 2984 +136 3219 +136 4463 +136 4944 +136 4945 +458 459 +458 460 +458 461 +458 462 +458 463 +458 464 +458 465 +458 466 +458 467 +458 468 +1414 9 +1414 17 +1414 31 +1414 126 +1414 180 +1414 266 +1414 424 +1414 666 +1414 697 +1414 2018 +3823 1085 +3823 1089 +3823 1794 +3823 1888 +3823 2625 +3823 3829 +3823 4940 +3823 4941 +3823 4942 +3823 4943 +3824 3149 +1534 303 +1534 424 +1534 771 +1534 804 +1534 1457 +1534 2288 +1534 3170 +1534 3282 +1534 4172 +1534 4301 +1534 4359 +1534 4793 +1534 4818 +1534 4891 +1534 5414 +1534 5895 +1534 5916 +1534 6061 +1534 6062 +2362 327 +2362 684 +2362 1954 +2362 2360 +2362 2666 +2362 4045 +2362 4046 +2362 4047 +2362 4048 +2362 4049 +3163 1021 +3163 2048 +3163 2476 +3163 2787 +3163 3617 +3163 4291 +3163 4566 +3163 4567 +3163 4568 +727 152 +2523 257 +2523 469 +2523 586 +2523 693 +2523 1356 +2523 1454 +2523 2500 +2523 3995 +2523 4158 +2523 4159 +558 7 +558 17 +558 122 +558 144 +558 146 +558 250 +558 353 +558 698 +558 5570 +558 5571 +1040 1023 +1040 1055 +1040 2254 +1040 2962 +1040 2963 +1040 2964 +1040 2965 +1040 2966 +1040 2967 +489 224 +489 490 +489 491 +489 492 +489 493 +489 494 +489 495 +489 496 +489 497 +489 498 +3831 33 +3831 1729 +3831 2357 +3831 3258 +3831 3259 +3831 4072 +3831 4363 +3831 4655 +3831 4946 +3831 4947 +3833 414 +3833 1168 +3833 1415 +3833 2257 +3833 4037 +3833 4948 +3833 4949 +3833 4950 +3833 4951 +3833 4952 +629 323 +629 336 +629 1067 +629 1426 +629 1427 +629 1428 +629 1429 +629 1430 +629 1431 +629 1432 +120 3 +120 121 +120 122 +120 123 +120 124 +120 125 +120 126 +120 127 +120 128 +120 129 +2060 3551 +132 5 +132 9 +132 147 +132 250 +132 353 +132 629 +132 753 +132 856 +132 1317 +132 2077 +2070 45 +2070 658 +2070 1425 +2070 2167 +2070 2595 +2070 2966 +2070 3834 +2070 3835 +2070 3836 +2070 3837 +2075 219 +2075 668 +2075 1575 +2075 1647 +2075 1786 +2075 1913 +2075 2229 +2075 2418 +2075 3586 +2075 3838 +3551 3 +3551 122 +3551 125 +3551 126 +3551 144 +3551 145 +3551 174 +3551 248 +3551 264 +3551 367 +285 134 +285 311 +285 712 +285 873 +285 955 +285 1197 +285 1227 +285 2218 +285 2219 +285 2243 +3337 32 +3337 1018 +3337 1061 +3337 1675 +3337 2723 +3337 3617 +3337 4286 +3337 4679 +3337 4680 +3337 4681 +5048 5566 +5338 4 +5338 122 +5338 143 +5338 180 +5338 252 +5338 266 +5338 368 +5338 369 +5338 427 +5338 754 +5940 376 +5941 110 +5941 858 +5941 1169 +5941 1509 +5941 2111 +5941 3249 +5941 5978 +5941 6073 +5941 6074 +5941 6075 +391 122 +391 124 +391 146 +391 248 +391 353 +391 422 +391 427 +391 717 +391 718 +391 2338 +392 814 +392 944 +392 1846 +392 2381 +392 2382 +392 2383 +392 2384 +392 2385 +392 2386 +392 2387 +398 176 +398 977 +398 1947 +398 2374 +398 2375 +398 2376 +398 2377 +398 2378 +398 2379 +398 2380 +668 669 +668 670 +668 671 +668 672 +668 673 +668 674 +668 675 +668 676 +668 677 +668 678 +1647 5 +1647 147 +1647 149 +1647 175 +1647 252 +1647 667 +1647 856 +1647 1245 +1647 2018 +3838 606 +3838 814 +3838 1701 +3838 2285 +3838 3371 +3838 4132 +3838 4954 +3838 4955 +3838 4956 +3838 4957 +3066 816 +3066 926 +3066 1568 +3066 1671 +3066 4640 +3066 4714 +3066 5001 +3066 5403 +3066 5404 +3066 5405 +3344 455 +3344 1317 +3344 3894 +3344 4688 +3344 4689 +3849 8 +3849 123 +3849 129 +3849 174 +3849 248 +3849 352 +3849 369 +3849 424 +3849 1317 +3849 2338 +4539 1651 +4539 2166 +4539 3352 +4539 3781 +4539 4553 +4539 5068 +4539 5085 +4539 5572 +4539 5868 +4539 5884 +1193 5 +1193 250 +1193 265 +1193 4711 +1193 5518 +1193 5519 +1193 5520 +1531 125 +1531 1257 +1531 1532 +1531 1533 +1531 1534 +1531 1535 +1531 1536 +1531 1537 +1531 1538 +1531 1539 +2084 3 +2084 8 +2084 128 +2084 176 +2084 238 +2084 247 +2084 266 +2084 390 +2084 424 +2084 856 +2087 30 +2087 364 +2087 1034 +2087 2681 +2087 3350 +2087 3376 +2087 3847 +2087 3848 +2087 3849 +2087 3850 +2088 131 +2088 267 +2088 532 +2088 1431 +2088 2066 +2088 2819 +2088 2966 +2088 3280 +2088 3516 +2088 3846 +198 412 +198 604 +198 870 +198 1466 +198 1556 +198 2147 +198 2148 +198 2149 +198 2150 +198 2151 +1333 386 +1333 604 +1333 837 +1333 2011 +1333 2093 +1333 2776 +1333 2871 +1333 3175 +1333 3176 +1333 3177 +1850 21 +1850 191 +1850 585 +1850 2041 +1850 3039 +1850 3595 +1850 3596 +1850 3597 +1850 3598 +1850 3599 +2114 979 +2114 1569 +2114 1581 +2114 1637 +2114 1770 +2114 1873 +2114 2409 +2114 2449 +2114 2547 +2114 3779 +3228 294 +3228 1511 +3228 2024 +3228 2677 +3228 2935 +3228 2936 +3228 3908 +3228 4614 +3228 4615 +3228 4616 +3851 850 +2424 8 +2424 63 +2424 1691 +2424 1901 +2424 1956 +2424 2231 +2424 2838 +2424 2842 +2653 2403 +2653 2764 +2653 2973 +2653 3576 +2653 4237 +2653 4426 +2653 5289 +2653 5417 +2653 5418 +3448 123 +3448 127 +3448 129 +3448 143 +3448 146 +3448 176 +3448 247 +3448 249 +3448 352 +3448 717 +3839 4063 +130 131 +130 132 +130 133 +130 134 +130 135 +130 136 +130 137 +130 138 +130 139 +130 140 +131 93 +131 1466 +131 1831 +131 1994 +131 2092 +131 2093 +131 2094 +131 2095 +131 2096 +131 2097 +135 34 +135 132 +135 786 +135 1150 +135 1274 +135 2099 +135 2100 +135 2101 +135 2102 +135 2103 +137 1728 +138 23 +138 446 +138 842 +138 1096 +138 1598 +138 1752 +138 2089 +138 2090 +138 2091 +1466 132 +1466 214 +1466 451 +1466 1162 +1466 2013 +1466 2524 +1466 3313 +1466 3314 +1466 3315 +1466 3316 +1831 3568 +2092 133 +2092 266 +2092 666 +2092 1531 +2092 1866 +2092 3124 +2092 3855 +2092 3856 +2092 3857 +2092 3858 +2093 427 +2093 484 +2093 958 +2093 1426 +2093 1529 +2093 1688 +2093 2244 +2093 3046 +2093 3769 +2093 3863 +2094 629 +2094 685 +2094 2317 +2094 2494 +2094 2540 +2094 2776 +2094 3594 +2094 3859 +2094 3860 +2094 3861 +2095 3862 +2096 7 +2096 147 +2096 248 +2096 250 +2096 289 +2096 353 +2096 390 +2096 753 +2096 754 +2096 762 +786 15 +786 331 +786 1300 +786 1326 +786 2091 +786 2714 +786 2715 +786 2716 +786 2717 +786 2718 +2102 1766 +2102 1956 +2102 2218 +2102 2841 +2102 3786 +2102 3869 +2102 3870 +2102 3871 +2102 3872 +2102 3873 +4463 81 +4463 637 +4463 697 +4463 2875 +4463 3813 +4463 5100 +4463 5306 +4463 5307 +4944 390 +4944 427 +4944 777 +4944 1842 +4944 2269 +4944 2862 +4944 3658 +4944 4578 +4944 5581 +4944 5582 +1752 83 +1752 690 +1752 1022 +1752 2198 +1752 2311 +1752 3272 +1752 3516 +1752 3517 +1752 3518 +1752 3519 +2091 681 +2091 979 +2091 1212 +2091 2326 +2091 2385 +2091 2395 +2091 3460 +2091 3864 +2091 3865 +2091 3866 +1162 452 +1162 453 +1162 460 +1162 563 +1162 803 +1162 847 +1162 1163 +1162 1164 +1162 1165 +1162 1166 +3315 1362 +3315 2087 +3315 2425 +3315 2999 +3315 3156 +3315 3849 +3315 4375 +3315 4559 +3315 4671 +3315 4672 +3568 43 +3568 221 +3568 918 +3568 1311 +3568 1934 +3568 2862 +3568 3614 +3568 4802 +3568 4836 +3568 4837 +3856 4 +3856 7 +3856 144 +3856 149 +3856 238 +3856 247 +3856 353 +3856 717 +3856 1317 +3856 2018 +3858 2081 +3858 2519 +3858 2762 +3858 3247 +3858 4439 +3858 4441 +3858 4828 +3858 4877 +484 337 +484 532 +484 786 +484 1352 +484 1764 +484 2493 +484 2494 +484 2495 +484 2496 +484 2497 +958 180 +958 558 +958 584 +958 1249 +958 1540 +958 3491 +958 4123 +958 4892 +958 4973 +958 4974 +1426 92 +1426 368 +1426 425 +1426 799 +1426 1339 +1426 2015 +1426 2588 +1426 3951 +1426 4635 +1426 4970 +1529 541 +1529 892 +1529 1385 +1529 2347 +1529 2854 +1529 2886 +1529 3330 +1529 3331 +1529 3332 +1529 3333 +2244 532 +2244 1219 +2244 1354 +2244 1776 +2244 1842 +2244 2650 +2244 2995 +2244 3943 +2244 3944 +2244 3945 +3046 715 +3046 1762 +3046 1865 +3046 2358 +3046 2563 +3046 2700 +3046 3109 +3046 4012 +3046 4658 +3046 5634 +3863 804 +3863 2399 +3863 3489 +3863 3543 +3863 3813 +3863 4333 +3863 4395 +3863 5229 +3863 5264 +3863 5337 +3594 363 +3594 1138 +3594 2498 +3594 2747 +3594 4846 +3594 4847 +3594 4848 +3594 4849 +3594 4850 +3594 4851 +3859 133 +3859 391 +3859 855 +3859 2676 +3859 3618 +3859 4285 +3859 4297 +3859 4960 +3859 4961 +3859 4962 +1427 2377 +1429 336 +1429 1546 +1429 2203 +1429 2319 +1429 2405 +1429 3266 +1429 3295 +1429 3296 +1429 3297 +1430 125 +1430 126 +1430 144 +1430 149 +1430 250 +1430 422 +1430 423 +1430 718 +1430 754 +1430 856 +1431 123 +1431 127 +1431 238 +1431 247 +1431 249 +1431 251 +1431 367 +1431 717 +1431 1245 +1431 3290 +257 69 +257 1137 +257 1233 +257 1300 +257 1301 +257 1302 +257 1303 +257 1304 +257 1305 +257 1306 +1533 85 +1533 279 +1533 529 +1533 1255 +1533 1401 +1533 1822 +1533 1920 +1533 2332 +1533 2884 +1533 2891 +1536 1050 +1537 5 +1537 9 +1537 128 +1537 145 +1537 148 +1537 176 +1537 179 +1537 248 +1537 352 +1537 424 +381 30 +381 279 +381 382 +381 383 +381 384 +381 385 +381 386 +381 387 +381 388 +381 389 +3843 17 +3843 143 +3843 148 +3843 175 +3843 250 +3843 266 +3843 423 +3843 697 +3843 754 +3843 1245 +3844 14 +3844 50 +3844 102 +3844 199 +3844 814 +3844 1749 +3844 2344 +3844 2486 +3844 2563 +3844 4958 +2681 222 +2681 325 +2681 1022 +2681 1064 +2681 1109 +2681 2885 +2681 3217 +2681 3252 +2681 3572 +2681 3848 +3350 648 +3350 1454 +3350 1812 +3350 2177 +3350 2825 +3350 3363 +3350 4657 +3350 4690 +3350 4691 +3350 4692 +3848 3212 +3850 125 +3850 129 +3850 146 +3850 249 +3850 251 +267 414 +267 813 +267 1050 +267 1749 +267 2229 +267 2230 +267 2231 +267 2232 +267 2233 +267 2234 +532 1329 +532 1330 +2819 5 +2819 144 +2819 148 +2819 149 +2819 252 +2819 266 +2819 422 +2819 559 +2819 856 +2819 2098 +3846 491 +3846 4241 +3846 4625 +3846 4893 +3846 5155 +3846 5229 +3846 5267 +3846 5937 +3846 5938 +3846 5939 +2715 285 +2715 693 +2715 1310 +2715 1592 +2715 1792 +2715 2476 +2715 2595 +2715 2891 +2715 3335 +2715 4061 +2716 196 +2716 524 +2716 1765 +2716 2452 +2716 3058 +2716 3138 +2716 4274 +2716 4275 +2716 4276 +2716 4277 +2718 748 +2718 2127 +2718 2293 +2718 2614 +2718 3558 +2718 3913 +2718 4052 +2718 4281 +2718 4282 +2718 4283 +1766 2218 +1766 2370 +1766 3680 +1766 3681 +5306 129 +5306 1509 +5306 1912 +5306 3566 +5306 5156 +5306 5369 +5306 5747 +5306 5767 +5306 5768 +777 352 +777 778 +777 779 +777 780 +777 781 +777 782 +777 783 +777 784 +777 785 +777 786 +2269 738 +2269 2500 +2269 3798 +2269 3855 +2269 3952 +2269 3953 +2269 3954 +2269 3955 +2269 3956 +2269 3957 +2862 455 +2862 633 +2862 1931 +2862 2407 +2862 3594 +2862 4280 +2862 4337 +2862 4338 +2862 4339 +2862 4340 +3658 520 +3658 1036 +3658 1587 +3658 1797 +3658 2334 +3658 3094 +3658 3473 +3658 4879 +3658 4880 +1212 665 +1212 777 +1212 840 +1212 1385 +1212 1402 +1212 1724 +1212 2790 +1212 3079 +1212 3080 +2326 3343 +2326 4130 +3865 23 +3865 1235 +3865 2036 +3865 4173 +3865 4904 +3865 4963 +3865 4964 +3865 4965 +3865 4966 +3865 4967 +3866 1549 +3866 2305 +3866 2310 +3866 2493 +3866 2806 +3866 3355 +3866 3960 +3866 4302 +3866 4968 +3866 4969 +141 7 +141 142 +141 143 +141 144 +141 145 +141 146 +141 147 +141 148 +141 149 +141 150 +2578 490 +2578 1775 +2578 2096 +2578 3405 +2578 3616 +2578 3967 +2578 4129 +2578 4222 +2578 4223 +2578 4224 +2581 129 +2581 171 +2581 889 +2581 2553 +2581 3109 +2581 4009 +2581 4201 +2581 4202 +2581 4203 +2581 4204 +311 127 +311 143 +311 251 +311 252 +311 264 +311 369 +311 753 +311 1245 +311 3677 +2243 9 +2243 123 +2243 125 +2243 126 +2243 129 +2243 144 +2243 176 +2243 352 +2243 367 +2243 427 +1675 214 +1675 281 +1675 322 +1675 402 +1675 554 +1675 776 +1675 829 +1675 858 +1675 898 +1675 1026 +1675 1087 +1675 1139 +1675 1575 +1675 1647 +1675 1671 +1675 1706 +1675 1787 +1675 1812 +1675 1952 +1675 2069 +1675 2278 +1675 2548 +1675 2585 +1675 2643 +1675 2964 +1675 3006 +1675 3170 +1675 3419 +1675 3420 +1675 3421 +1675 3422 +1675 3423 +1675 3424 +1675 3425 +1675 3426 +1675 3427 +1675 3428 +1675 3429 +1675 3430 +1675 3431 +1675 3432 +1675 3433 +1675 3434 +1675 3435 +1675 3436 +1675 3437 +1675 3438 +2723 661 +2723 814 +2723 1025 +2723 2038 +2723 2943 +2723 3613 +2723 4082 +2723 4284 +2723 4285 +2723 4286 +4680 1900 +4680 2477 +4680 3590 +4680 4080 +4680 4625 +1338 178 +1338 725 +1338 892 +1338 1530 +1338 2057 +1338 2570 +1338 2671 +1338 2786 +1338 3178 +1338 3179 +2348 1087 +3801 235 +3801 342 +3801 1120 +3801 1591 +3801 1592 +3801 2476 +3801 2612 +3801 3096 +3801 4131 +5675 2302 +5675 5474 +5675 5729 +5675 5933 +5675 5934 +5677 2625 +5677 3046 +5677 3292 +5677 4295 +5677 4806 +5677 5237 +5677 5315 +5677 5468 +5677 5935 +858 38 +858 263 +858 307 +858 412 +858 1704 +858 1705 +858 1706 +858 1707 +858 1708 +858 1709 +5978 124 +5978 238 +5978 266 +5978 353 +5978 367 +5978 422 +5978 423 +5978 427 +5978 559 +5978 717 +2184 3923 +2184 3924 +2184 3925 +2184 3926 +2184 3927 +158 411 +158 813 +158 1688 +158 2104 +158 2105 +158 2106 +158 2107 +158 2108 +160 13 +160 2053 +160 2056 +160 2109 +160 2110 +160 2111 +160 2112 +160 2113 +160 2114 +160 2115 +411 96 +411 835 +411 1256 +411 1814 +411 2266 +411 2839 +411 3306 +411 5013 +411 5014 +411 5015 +2112 463 +2112 803 +2112 1492 +2112 2091 +2112 2111 +2112 2115 +2112 2287 +2112 2818 +2112 2941 +2112 3868 +2115 123 +2115 199 +2115 751 +2115 1506 +2115 2474 +2115 2805 +2115 3365 +2115 3595 +2115 3886 +2115 3887 +1256 3114 +5014 124 +5014 129 +5014 146 +5014 247 +5014 249 +5014 353 +5014 368 +5014 369 +5014 390 +5014 1245 +1569 65 +1569 373 +1569 1153 +1569 1570 +1569 1571 +1569 1572 +1569 1573 +1569 1574 +1569 1575 +1569 1576 +1637 363 +1637 779 +1637 998 +1637 1503 +1637 1538 +1637 1976 +1637 2299 +1637 3386 +1637 3387 +1637 3388 +1770 2322 +751 31 +751 124 +751 146 +751 266 +751 367 +751 427 +751 559 +751 667 +751 856 +751 2001 +1506 1090 +1506 1507 +1506 1508 +1506 1509 +1506 1510 +1506 1511 +1506 1512 +1506 1513 +1506 1514 +1506 1515 +2474 330 +2474 534 +2474 970 +2474 1511 +2474 1764 +2474 1845 +2474 2300 +2474 5449 +2474 5450 +3886 451 +3886 478 +3886 677 +3886 1020 +3886 1230 +3886 2215 +3886 3275 +3886 4126 +3886 4977 +3886 4978 +3887 690 +3887 744 +3887 1300 +3887 1730 +3887 3053 +3887 4373 +3887 4984 +3887 4985 +3887 4986 +3887 4987 +162 163 +162 164 +162 165 +162 166 +162 167 +162 168 +162 169 +162 170 +162 171 +162 172 +165 102 +165 108 +165 531 +165 703 +165 1165 +165 1390 +165 1561 +165 1865 +165 2123 +165 2124 +169 818 +169 872 +169 1264 +169 1539 +169 2116 +169 2117 +169 2118 +169 2119 +169 2120 +169 2121 +531 80 +531 343 +531 346 +531 571 +531 572 +531 573 +531 574 +531 575 +531 576 +1165 535 +1165 1163 +1165 2089 +1165 2204 +1165 2561 +1165 2795 +1165 3055 +1165 3056 +1165 3057 +1165 3058 +2116 510 +2116 1018 +2116 1633 +2116 2069 +2116 2130 +2116 3724 +2116 3875 +2116 3876 +2116 3877 +2116 3878 +571 721 +571 765 +571 804 +571 1913 +571 2358 +571 2474 +571 2521 +571 2522 +571 2523 +571 2524 +572 584 +572 818 +572 979 +572 1353 +572 2119 +572 2306 +572 2337 +572 2892 +572 4318 +572 4319 +573 228 +573 2520 +574 31 +574 125 +574 175 +574 179 +574 180 +574 250 +574 266 +574 390 +574 424 +576 1827 +576 2481 +576 2953 +576 3171 +576 4846 +576 5235 +576 5236 +576 5237 +576 5238 +576 5239 +1163 632 +1163 1882 +1163 2593 +1163 3617 +1163 4494 +1163 4495 +1163 4496 +1163 4497 +1163 4498 +1163 4499 +387 825 +387 1733 +387 1961 +387 2001 +387 2353 +387 2354 +387 2355 +387 2356 +2322 376 +2322 2303 +2322 2528 +2322 4014 +2322 4015 +2322 4016 +2322 4017 +2322 4018 +2322 4019 +2322 4020 +2904 531 +2904 820 +2904 930 +2904 1608 +2904 1845 +2904 1956 +2904 4156 +2904 4399 +2904 4400 +2904 4401 +3232 56 +3232 811 +3232 2489 +3232 2524 +3232 3460 +3232 3994 +3232 4010 +3232 4617 +3232 4618 +3232 4619 +3233 8 +3233 122 +3233 144 +3233 148 +3233 174 +3233 179 +3233 424 +3233 427 +3233 1317 +3233 2338 +3234 4709 +1633 83 +1633 831 +1633 1634 +1633 1635 +1633 1636 +1633 1637 +1633 1638 +1633 1639 +1633 1640 +3877 478 +173 124 +173 128 +173 144 +173 174 +173 175 +173 176 +173 177 +173 178 +173 179 +173 180 +2133 86 +2133 433 +2133 1378 +2133 2451 +2133 2637 +2133 3185 +2133 3862 +2133 3880 +2133 3881 +2133 3882 +2134 710 +2134 712 +2134 2847 +2134 3166 +2134 3410 +2134 3756 +2134 3863 +2134 3883 +2134 3884 +2134 3885 +816 1048 +816 1129 +816 2237 +816 2548 +816 4695 +816 4844 +816 4878 +816 5224 +816 5628 +816 5629 +926 241 +926 347 +926 356 +926 478 +926 572 +926 2300 +926 2337 +926 2821 +926 2822 +926 2823 +5404 1143 +5404 2583 +5404 2658 +5404 2885 +5404 2961 +5404 5749 +5404 5763 +5404 5764 +5404 5805 +455 2038 +455 2188 +455 2241 +455 2441 +455 2442 +4689 924 +4689 1199 +4689 1288 +4689 1424 +4689 1866 +4689 1867 +4689 1868 +4689 2558 +4689 5423 +4689 5424 +4002 3 +4002 121 +4002 123 +4002 124 +4002 128 +4002 247 +4002 367 +4002 717 +4002 1246 +4002 2098 +4839 356 +4839 572 +4839 1137 +4839 1287 +4839 1671 +4839 2324 +4839 2475 +4839 2648 +4839 2822 +4839 4754 +4896 263 +4896 733 +4896 878 +4896 1031 +4896 2449 +4896 2779 +4896 3553 +4896 5080 +4896 5568 +4896 5569 +2338 256 +2338 840 +2338 1031 +2338 1457 +2338 1509 +2338 2785 +2338 3006 +2338 3743 +2338 5056 +2338 5645 +1651 129 +1651 262 +1651 855 +1651 1318 +1651 1974 +1651 2974 +1651 3399 +1651 3400 +1651 3401 +1651 3402 +4553 3 +4553 124 +4553 146 +4553 251 +4553 266 +4553 422 +4553 667 +4553 856 +4553 2001 +4553 2018 +5572 56 +5572 206 +5572 787 +5572 788 +5572 4293 +5572 4676 +5572 5063 +5572 5879 +5572 5880 +5572 5881 +5884 6040 +1441 567 +1441 1957 +1441 2493 +1441 3093 +1441 3187 +1441 3298 +1441 3299 +1441 3300 +1441 3301 +1589 156 +1589 1056 +1589 1203 +1589 1327 +1589 2304 +1589 3364 +1589 3365 +1589 3366 +1589 3367 +1589 3368 +2599 665 +2599 1175 +2599 1866 +2599 1867 +2599 2563 +2599 3033 +2599 3980 +2599 4199 +2599 4200 +584 585 +584 586 +584 587 +2615 453 +2615 1273 +2615 1656 +2615 2787 +2615 3053 +2615 3509 +2615 4143 +2615 4219 +2615 4220 +2615 4221 +2617 215 +2617 1313 +2617 1803 +2617 2443 +2617 2643 +2617 2654 +2617 3558 +2617 4037 +1547 1023 +1547 1339 +1547 1636 +1547 2499 +1547 3169 +1547 3342 +1547 3343 +1547 3344 +1547 3345 +1547 3346 +2148 1048 +2148 2067 +2148 2179 +2148 3134 +2148 3196 +2148 3891 +2148 3892 +2148 3893 +2148 3894 +2148 3895 +4516 282 +4516 665 +4516 1143 +4516 1988 +4516 2961 +4516 3777 +4516 5333 +4516 5334 +4516 5335 +433 20 +433 1370 +433 1565 +433 1824 +433 2433 +3881 528 +3881 756 +3881 874 +3881 3023 +3881 3205 +3881 3271 +3881 3488 +3881 4841 +3881 4975 +3881 4976 +3883 8 +3883 123 +3883 146 +3883 247 +3883 248 +3883 249 +3883 266 +3883 369 +3883 427 +3883 667 +3885 2051 +3885 2164 +3885 2708 +3885 3362 +3885 3587 +181 182 +181 183 +181 184 +181 185 +181 186 +181 187 +181 188 +181 189 +181 190 +181 191 +192 38 +192 193 +192 194 +192 195 +192 196 +193 2062 +193 2222 +193 2388 +193 2389 +193 2390 +193 2391 +194 86 +194 139 +194 1020 +194 2135 +194 2136 +194 2137 +194 2138 +194 2139 +194 2140 +194 2141 +195 4 +195 124 +195 143 +195 176 +195 368 +195 422 +195 558 +195 736 +195 1245 +196 246 +196 424 +196 659 +196 809 +196 2120 +196 2142 +196 2143 +196 2144 +196 2145 +196 2146 +2388 261 +2388 937 +2388 1229 +2388 2225 +2388 2595 +2388 2948 +2388 3205 +2388 4072 +2388 4073 +2388 4074 +2391 478 +2391 986 +2391 1370 +2391 3457 +2391 3487 +2391 4075 +2391 4076 +2391 4077 +2391 4078 +2391 4079 +2136 3888 +2143 494 +2143 1068 +2143 1402 +2143 1545 +2143 2165 +2143 2166 +2143 2215 +2143 2646 +2143 3889 +2143 3890 +2145 262 +2145 1407 +2145 1637 +2145 1926 +2145 3900 +2145 3901 +2145 3902 +2145 3903 +2145 3904 +2145 3905 +2146 4 +2146 5 +2146 9 +2146 10 +2146 147 +2146 266 +2146 368 +2146 423 +2146 1245 +937 5 +937 7 +937 143 +937 145 +937 146 +937 249 +937 251 +937 367 +937 666 +937 1317 +1229 1916 +1229 2140 +1229 2949 +1229 2984 +1229 3084 +1229 3085 +1229 3086 +1229 3087 +1229 3088 +2948 355 +2948 607 +2948 823 +2948 1466 +2948 3855 +2948 4424 +2948 4425 +2948 4426 +2948 4427 +2948 4428 +4072 4854 +4073 134 +4073 1224 +4073 1250 +4073 1739 +4073 1862 +4073 2050 +4073 3460 +4073 4262 +4073 5072 +4073 5073 +478 479 +478 480 +478 481 +478 482 +478 483 +478 484 +478 485 +478 486 +478 487 +478 488 +986 145 +986 146 +986 251 +986 264 +986 367 +986 559 +986 666 +986 667 +986 1245 +1370 825 +1370 1371 +1370 1372 +1370 1373 +1370 1374 +1370 1375 +1370 1376 +1370 1377 +1370 1378 +4076 175 +4076 251 +4076 252 +4076 266 +4076 292 +4076 390 +4076 422 +4076 558 +4076 856 +4076 3933 +4078 387 +4078 584 +4078 674 +4078 1670 +4078 2091 +4078 3091 +4078 4328 +4078 4467 +4078 5070 +4078 5071 +737 898 +737 1539 +737 2516 +737 2659 +737 2660 +737 2661 +737 2662 +737 2663 +739 1380 +739 1609 +739 2664 +739 2665 +739 2666 +741 31 +741 538 +741 1575 +741 2272 +741 2538 +741 2719 +741 2720 +741 2721 +741 2722 +741 2723 +742 1476 +742 1975 +742 2412 +742 2453 +742 2678 +742 2679 +742 2680 +742 2681 +742 2682 +742 2683 +1084 49 +1084 184 +1084 505 +1084 725 +1084 1085 +1084 1086 +1084 1087 +1084 1088 +1084 1089 +1084 1090 +1870 71 +1870 642 +1870 706 +1870 1705 +1870 1714 +1870 1871 +1870 1872 +1870 1873 +1870 1874 +1870 1875 +2295 76 +2295 612 +2295 1512 +2295 2348 +2295 2403 +2295 2868 +2295 3082 +2295 3127 +2295 3794 +2576 111 +2576 3699 +2576 4004 +2576 4175 +2576 4176 +2577 330 +2577 388 +2577 553 +2577 962 +2577 1306 +2577 2010 +2577 3179 +2577 4177 +2577 4178 +2577 4179 +1545 1837 +2646 1544 +2646 1854 +2646 1936 +2646 3105 +2646 3608 +2646 3731 +2646 4236 +2646 4237 +3890 3 +3890 123 +3890 129 +3890 251 +3890 264 +3890 367 +3890 426 +3890 427 +3890 718 +3890 2717 +3900 158 +3900 1243 +3900 1331 +3900 2024 +3900 3416 +3900 4752 +3900 4916 +3900 4988 +3900 4989 +3900 4990 +3903 690 +3903 902 +3903 2325 +3903 2942 +3903 3106 +3903 3563 +3903 4847 +3903 4981 +3903 4982 +3903 4983 +3904 312 +3904 1656 +3904 2175 +3904 3489 +3904 4091 +3904 4718 +3904 4998 +3904 4999 +3904 5000 +3904 5001 +197 198 +197 199 +197 200 +197 201 +197 202 +197 203 +197 204 +197 205 +197 206 +197 207 +201 714 +201 2152 +201 2153 +201 2154 +201 2155 +201 2156 +201 2157 +201 2158 +201 2159 +201 2160 +412 769 +412 2253 +412 2532 +412 3029 +412 3215 +412 3485 +412 4254 +412 5484 +412 5501 +412 5502 +2153 1219 +2153 2847 +2153 3804 +2153 3856 +2153 3908 +2153 3909 +2153 3910 +2153 3911 +2153 3912 +2153 3913 +2156 1016 +2156 2309 +2156 2354 +2156 3300 +2156 3431 +2156 5343 +2156 5468 +2156 5958 +2156 5959 +2156 5960 +2158 262 +2158 1021 +2158 1115 +2158 2002 +2158 3433 +2158 3467 +2158 3896 +2158 3897 +2158 3898 +2158 3899 +2253 113 +2253 222 +2253 382 +2253 411 +2253 1157 +2253 2169 +2253 2552 +2253 3949 +2253 3950 +2532 665 +2532 774 +2532 924 +2532 1709 +2532 1859 +2532 2767 +2532 3136 +2532 3682 +2532 3698 +2532 4160 +859 671 +859 860 +859 861 +859 862 +859 863 +859 864 +859 865 +859 866 +859 867 +859 868 +3373 4 +3373 9 +3373 251 +3373 698 +3373 2599 +3373 4250 +3373 4710 +3373 4711 +3373 4712 +3373 4713 +3374 1090 +3374 1528 +3374 1816 +3374 2474 +3374 2524 +3374 3067 +3374 3108 +3374 3233 +3374 3755 +3374 4210 +3910 122 +3910 124 +3910 127 +3910 143 +3910 247 +3910 264 +3910 352 +3910 353 +3910 390 +3910 1245 +3912 889 +3912 1367 +3912 3266 +3912 3856 +3912 4735 +3912 4894 +3912 4991 +3912 4992 +3912 4993 +3912 4994 +3913 204 +3913 607 +3913 804 +3913 1072 +3913 1605 +3913 1728 +3913 1780 +3913 3339 +3913 4995 +2309 1333 +2309 2017 +2309 2138 +2309 2667 +2309 3124 +2309 3841 +2309 4004 +2309 4005 +2309 4006 +2309 4007 +3431 2077 +3431 2411 +3431 4824 +5343 946 +5343 2414 +5343 2563 +5343 2780 +5343 3930 +5343 4245 +5343 4675 +5343 5300 +5343 5781 +5343 5782 +5960 3304 +3433 105 +3433 231 +3433 424 +3433 833 +3433 921 +3433 2911 +3433 3170 +3433 3497 +3433 4461 +3433 4472 +3897 1223 +3897 3695 +3897 3981 +3897 4059 +3897 4371 +892 2200 +892 2959 +892 2960 +892 2961 +218 219 +218 220 +218 221 +218 222 +218 223 +218 224 +218 225 +218 226 +218 227 +225 199 +225 221 +225 893 +225 1343 +225 1749 +225 1861 +225 2177 +225 2178 +225 2179 +225 2180 +226 168 +226 314 +226 1114 +226 1564 +226 2171 +226 2172 +226 2173 +226 2174 +226 2175 +226 2176 +1343 351 +1343 1168 +1343 1504 +1343 1764 +1343 1765 +1343 2585 +1343 3195 +1343 3196 +1343 3197 +1343 3198 +2178 17 +2178 31 +2178 123 +2178 126 +2178 145 +2178 149 +2178 176 +2178 697 +2178 1317 +314 121 +314 147 +314 177 +314 248 +314 249 +314 252 +314 264 +314 266 +314 423 +314 1245 +2171 3907 +2172 96 +2172 604 +2172 828 +2172 1291 +2172 1575 +2172 1961 +2172 2533 +2172 2555 +2172 3020 +2172 3713 +2173 2569 +2174 1144 +2176 3 +2176 175 +2176 266 +2176 368 +2176 390 +2176 423 +2176 427 +2176 697 +2176 1245 +1168 1909 +1168 1912 +1168 2574 +1168 2791 +1168 2797 +1168 3045 +1168 3046 +1168 3047 +1168 3048 +1168 3049 +1504 127 +1504 128 +1504 179 +1504 249 +1504 353 +1504 424 +1504 426 +1504 1354 +1504 3326 +1504 3327 +1765 839 +1765 2420 +1765 2477 +1765 3086 +1765 3185 +1765 3193 +1765 3197 +1765 3301 +1765 3527 +3197 585 +3197 1036 +3197 1730 +3197 1797 +3197 2556 +3197 2997 +3197 3619 +3197 3808 +3197 4582 +3197 4583 +863 202 +863 513 +863 649 +863 1481 +863 1775 +863 2125 +863 2740 +863 2741 +863 2742 +863 2743 +1094 121 +1094 124 +1094 127 +1094 128 +1094 144 +1094 145 +1094 174 +1094 179 +1094 247 +1094 1246 +2743 14 +2743 1022 +2743 1278 +2743 1352 +2743 2726 +2743 2974 +2743 3312 +2743 4151 +2743 4296 +2743 4297 +3507 738 +3507 1251 +3507 1458 +3507 1509 +3507 2077 +3507 2825 +3507 3249 +3507 4679 +3507 4789 +3507 4790 +2569 79 +2569 164 +2569 243 +2569 296 +2569 455 +2569 1289 +2569 2641 +2569 2740 +2569 3735 +2569 4172 +228 176 +228 182 +228 229 +228 230 +228 231 +228 232 +228 233 +228 234 +228 235 +229 840 +229 1123 +229 1194 +229 1726 +229 2217 +229 2218 +229 2219 +229 2220 +229 2221 +229 2222 +232 2223 +2217 5 +2217 9 +2217 149 +2217 177 +2217 238 +2217 247 +2217 249 +2217 369 +2217 424 +2217 1317 +2221 152 +2221 219 +2221 976 +2221 1044 +2221 1235 +2221 2248 +2221 2673 +2221 3589 +2221 3929 +2223 107 +2223 883 +2223 1021 +2223 1048 +2223 1175 +2223 1269 +2223 1936 +2223 2414 +2223 3868 +2223 3930 +1235 123 +1235 143 +1235 176 +1235 264 +1235 352 +1235 353 +1235 390 +1235 423 +1235 718 +1235 2338 +2248 117 +2248 485 +2248 820 +2248 2353 +2248 3671 +2248 4067 +2248 5114 +2248 5115 +2248 5116 +2248 5117 +3929 76 +3929 513 +3929 550 +3929 604 +3929 712 +3929 1940 +3929 1955 +3929 1969 +3929 3022 +3929 3509 +3930 1228 +3930 1777 +3930 1928 +3930 2933 +3930 3331 +3930 4461 +3930 5004 +3930 5005 +3930 5006 +3930 5007 +236 24 +236 237 +236 238 +236 239 +236 240 +236 241 +236 242 +236 243 +236 244 +236 245 +241 2010 +241 2186 +241 2187 +241 2188 +244 338 +244 612 +244 1264 +244 1284 +244 2197 +244 2198 +244 2199 +244 2200 +244 2201 +244 2202 +1284 148 +1284 174 +1284 266 +1284 368 +1284 369 +1284 423 +1284 427 +1284 559 +1284 1245 +1284 1317 +2199 322 +2199 412 +2199 527 +2199 2940 +2199 3593 +2199 3697 +2199 3919 +2199 3920 +2199 3921 +2199 3922 +307 711 +307 883 +307 1018 +307 2260 +307 2261 +307 2262 +307 2263 +307 2264 +307 2265 +307 2266 +2546 2 +2546 3 +2546 8 +2546 147 +2546 247 +2546 351 +2546 1317 +2546 2064 +2546 4161 +2546 4162 +2554 534 +2554 1400 +2554 2843 +2554 3684 +2554 3781 +2554 4166 +2554 4167 +2554 4168 +2554 4169 +3919 7 +3919 219 +3919 256 +3919 424 +3919 1602 +3919 2119 +3919 2364 +3919 3120 +3919 4756 +3919 4996 +3920 49 +3920 1056 +3920 1512 +3920 1739 +3920 2789 +3920 3322 +3920 4412 +3920 4597 +3920 4716 +3920 4997 +3921 312 +3921 837 +3921 894 +3921 897 +3921 942 +3921 1016 +3921 1267 +3921 1524 +3921 3612 +3921 4889 +3922 21 +3922 3144 +3922 3963 +3922 4022 +2974 50 +2974 892 +2974 1077 +2974 1203 +2974 2089 +2974 2562 +2974 2861 +2974 3749 +2974 4436 +2974 4437 +1004 106 +1004 693 +1004 1591 +1004 1760 +1004 2212 +1004 2552 +1004 2903 +1004 2904 +1004 2905 +1004 2906 +2278 152 +2278 1313 +2278 1901 +2278 1997 +2278 2200 +2278 2602 +2278 2975 +2278 3968 +2278 3969 +2278 3970 +2284 4105 +1393 4 +1393 5 +1393 145 +1393 147 +1393 149 +1393 183 +1393 252 +1393 390 +1393 423 +1393 667 +1396 266 +1396 437 +1396 459 +1396 1178 +1396 1409 +1396 1504 +1396 1800 +1396 1842 +1396 2871 +1396 3281 +3394 1724 +3394 2066 +3394 2275 +3394 3660 +3394 4603 +3394 4727 +3394 4728 +3394 4729 +3394 4730 +1273 330 +1273 2868 +1273 3120 +1273 3121 +1273 3122 +1273 3123 +1273 3124 +1273 3125 +1273 3126 +1273 3127 +1336 260 +2392 21 +2392 503 +2392 804 +2392 808 +2392 1339 +2392 1547 +2392 2839 +2392 3346 +2392 4080 +2392 4081 +2757 1829 +2757 3882 +2757 4405 +2757 4406 +1137 83 +1137 2086 +1137 2657 +1137 2966 +1137 3003 +1137 3004 +1137 3005 +1137 3006 +1137 3007 +1137 3008 +1301 866 +1301 1305 +1301 1345 +1301 1346 +1301 1347 +1301 1348 +1301 1349 +1301 1350 +1301 1351 +1305 67 +1305 124 +1305 176 +1305 339 +1305 427 +1305 1669 +1305 1749 +1305 3150 +1305 3151 +1305 3152 +2657 1245 +2657 2687 +2657 2866 +2657 3488 +2657 3680 +2657 3886 +2657 4074 +2657 4240 +2657 4241 +2657 4242 +3003 219 +3003 1087 +3003 1761 +3003 1930 +3003 2645 +3003 2787 +3003 2871 +3003 3207 +3003 4082 +3003 4445 +866 162 +866 416 +866 635 +866 1351 +866 1408 +866 1860 +866 2326 +866 2763 +866 2764 +866 2765 +1346 1730 +1346 1766 +1346 2503 +1346 2708 +1346 3177 +1346 3187 +1346 3188 +1346 3189 +1346 3190 +1346 3191 +339 4 +339 5 +339 7 +339 148 +339 264 +339 364 +339 559 +339 1317 +339 1755 +339 2278 +3152 769 +3152 1078 +3152 1409 +3152 2374 +3152 4116 +3152 4316 +3152 4442 +3152 4553 +3152 4554 +3152 4555 +263 4 +263 126 +263 146 +263 147 +263 264 +263 265 +263 266 +263 267 +263 268 +263 269 +2231 132 +2231 686 +2231 970 +2231 1598 +2231 2802 +2231 3938 +2231 3939 +2231 3940 +2231 3941 +2231 3942 +1129 5 +1129 7 +1129 145 +1129 248 +1129 353 +1129 426 +1129 629 +1129 753 +1129 2077 +1129 3002 +3235 255 +3235 542 +3235 884 +3235 1313 +3235 1538 +3235 2726 +3235 2758 +3235 4620 +3235 4621 +3235 4622 +3931 566 +3931 3212 +3931 3352 +3931 5051 +1143 172 +1143 1556 +1143 1766 +1143 1852 +1143 1890 +1143 2384 +1143 2544 +1143 2666 +1143 3032 +1143 3033 +3933 45 +3933 219 +3933 425 +3933 1056 +3933 2344 +3933 2781 +3933 3995 +3933 4361 +3933 4720 +3933 5008 +1173 412 +1173 1001 +1173 1060 +1173 1441 +1173 2683 +1173 2746 +1173 3781 +1173 3865 +1173 5009 +2358 215 +2358 1522 +2358 2443 +2358 4056 +2358 4281 +2358 4844 +2358 6168 +2358 6232 +3934 15 +3934 855 +3934 1212 +3934 2563 +3934 4629 +3934 4950 +3934 5088 +3934 5414 +3934 5889 +3934 5890 +3937 4 +3937 125 +3937 143 +3937 144 +3937 146 +3937 147 +3937 175 +3937 179 +3937 180 +3937 558 +270 190 +270 271 +270 272 +270 273 +270 274 +270 275 +270 276 +270 277 +270 278 +276 272 +276 274 +276 600 +276 1583 +276 1800 +276 2247 +276 2248 +276 2249 +485 8 +485 121 +485 123 +485 148 +485 179 +485 249 +485 251 +485 353 +485 369 +485 1317 +280 318 +280 552 +280 790 +280 967 +280 1202 +280 1259 +280 1412 +280 1620 +280 1933 +280 2235 +283 552 +283 632 +283 779 +283 838 +283 1321 +283 1371 +283 1571 +283 1891 +283 1892 +283 2236 +284 32 +284 503 +284 1699 +284 1789 +284 2237 +284 2238 +284 2239 +284 2240 +284 2241 +284 2242 +288 92 +288 209 +288 1917 +288 1946 +288 1957 +288 2015 +288 2244 +288 2245 +288 2246 +967 15 +967 440 +967 669 +967 2855 +967 2856 +967 2857 +967 2858 +967 2859 +967 2860 +967 2861 +1202 3105 +1259 5 +1259 126 +1259 148 +1259 149 +1259 174 +1259 176 +1259 249 +1259 251 +1259 265 +1259 352 +1891 199 +1891 538 +1891 725 +1891 852 +1891 1397 +1891 2914 +1891 3166 +1891 3670 +1891 3671 +1891 3672 +2241 3 +2241 163 +2241 1056 +2241 1362 +2241 1539 +2241 2097 +2241 2579 +2241 3946 +2241 3947 +2241 3948 +2245 4092 +2859 571 +2859 609 +2859 695 +2859 802 +2859 864 +2859 870 +2859 2638 +2859 3109 +2859 4334 +2859 4356 +2860 122 +2860 127 +2860 143 +2860 177 +2860 179 +2860 367 +2860 369 +2860 390 +2860 422 +2860 718 +2861 7 +2861 143 +2861 147 +2861 174 +2861 175 +2861 368 +2861 559 +2861 666 +2861 754 +2861 2018 +1658 92 +1658 860 +1658 963 +1658 1767 +1658 2015 +1658 2880 +1658 2953 +1658 3409 +1658 3410 +1658 3411 +2262 2354 +2262 2385 +2262 2687 +2262 2881 +2262 3951 +2612 726 +2612 1571 +2612 1789 +2612 2274 +2612 2630 +2612 3423 +2612 3570 +2612 3951 +2612 4210 +2612 4211 +3382 1547 +3382 2331 +3382 2348 +3382 3194 +3382 3617 +3382 4665 +3382 4719 +3382 4720 +3382 4721 +3383 835 +3383 1003 +3383 1288 +3383 2788 +3383 2867 +3383 4625 +3383 4722 +3383 4723 +3383 4724 +3670 406 +3670 933 +3670 1787 +3670 2344 +3670 2595 +3670 3699 +3670 3922 +3670 4540 +3670 4870 +3670 4882 +3946 124 +3946 249 +3946 251 +3946 264 +3946 367 +3946 422 +3946 667 +3946 718 +3946 856 +3948 124 +3948 127 +3948 143 +3948 247 +3948 251 +3948 264 +3948 367 +3948 390 +3948 718 +3948 1245 +908 648 +908 697 +908 942 +908 1512 +908 1842 +908 2786 +908 2787 +908 2788 +908 2789 +908 2790 +2428 451 +2428 532 +2428 1766 +2428 2068 +2428 2069 +2428 2193 +2428 4028 +2428 4095 +2428 4096 +2428 4097 +1354 163 +1354 1642 +1354 1741 +1354 2134 +1354 2329 +1354 2683 +1354 2880 +1354 3202 +1354 3203 +3943 2539 +3943 2744 +3943 2747 +3943 2859 +3943 2898 +3943 3779 +3943 4613 +3943 5010 +3943 5011 +3943 5012 +3945 122 +3945 123 +3945 124 +3945 126 +3945 149 +3945 177 +3945 247 +3945 698 +299 175 +299 378 +299 443 +299 774 +299 1573 +299 1704 +299 2035 +299 2250 +299 2251 +299 2252 +378 121 +378 122 +378 123 +378 127 +378 143 +378 251 +378 390 +378 667 +378 717 +378 1245 +1704 9 +1704 121 +1704 126 +1704 149 +1704 176 +1704 352 +1704 423 +1704 424 +1704 427 +1704 667 +2252 3 +2252 7 +2252 8 +2252 123 +2252 128 +2252 148 +2252 176 +2252 179 +2252 424 +2252 717 +490 356 +490 520 +490 852 +490 2069 +490 2167 +490 2214 +490 2403 +490 2464 +490 2465 +490 2466 +496 164 +496 418 +496 633 +496 762 +496 1471 +496 2358 +496 2376 +496 2472 +496 2473 +496 2474 +3408 462 +3408 582 +3408 940 +3408 1530 +3408 2795 +3408 3717 +3408 4237 +3408 4519 +3408 4752 +3408 4753 +300 218 +300 301 +300 302 +300 303 +300 304 +300 305 +300 306 +300 307 +300 308 +300 309 +302 1233 +302 2519 +303 309 +303 341 +303 764 +303 909 +303 1061 +303 1093 +303 1095 +303 2253 +303 2254 +303 2255 +305 587 +305 710 +305 838 +305 1498 +305 1776 +305 1850 +305 2256 +305 2257 +305 2258 +305 2259 +341 370 +341 862 +341 1591 +341 1805 +341 1891 +341 2177 +341 2288 +341 2289 +341 2290 +341 2291 +764 765 +764 766 +764 767 +764 768 +764 769 +764 770 +764 771 +764 772 +764 773 +764 774 +2260 38 +2260 1688 +2260 2191 +2260 2941 +2260 3804 +2260 4501 +2260 4894 +2260 5909 +2260 6108 +2260 6181 +2261 122 +2261 124 +2261 128 +2261 129 +2261 176 +2261 249 +2261 264 +2261 367 +2261 368 +2261 369 +370 371 +370 372 +370 373 +370 374 +370 375 +370 376 +370 377 +370 378 +370 379 +370 380 +2290 10 +2290 121 +2290 128 +2290 145 +2290 266 +2290 352 +2290 422 +2290 559 +2290 666 +2290 1317 +766 17 +766 262 +766 1332 +766 1689 +766 1956 +766 2330 +766 2569 +766 2697 +766 2698 +766 2699 +767 1618 +767 1863 +767 2550 +767 2690 +767 2691 +767 2692 +767 2693 +767 2694 +767 2695 +767 2696 +771 507 +771 838 +771 1003 +771 1402 +771 1717 +771 1896 +771 1968 +771 2689 +771 2705 +771 2706 +773 2907 +382 996 +382 1969 +382 2345 +382 2346 +382 2347 +382 2348 +382 2349 +382 2350 +382 2351 +382 2352 +5909 282 +5909 342 +5909 1805 +5909 2612 +5909 3963 +5909 4170 +5909 4333 +5909 4365 +5909 5729 +6108 76 +6108 131 +6108 1023 +6108 1863 +6108 2080 +6108 2127 +6108 3677 +6108 3962 +6108 4260 +6108 6182 +6181 8 +6181 122 +6181 177 +6181 247 +6181 249 +6181 251 +6181 266 +6181 353 +6181 422 +6181 718 +2881 4 +2881 144 +2881 148 +2881 175 +2881 180 +2881 266 +2881 424 +2881 666 +2881 886 +2881 2018 +310 311 +310 312 +310 313 +310 314 +310 315 +310 316 +310 317 +310 318 +310 319 +310 320 +316 2267 +2267 855 +2267 1323 +2267 1439 +2267 1808 +2267 3568 +2267 4275 +2267 4738 +2267 4806 +2267 6121 +2267 6122 +855 249 +855 251 +855 266 +855 322 +855 367 +855 558 +855 667 +855 856 +855 857 +855 858 +1323 137 +1323 557 +1323 1039 +1323 1728 +1323 2646 +1323 3079 +1323 3199 +1323 3200 +1323 3201 +4275 4 +4275 122 +4275 143 +4275 146 +4275 266 +4275 367 +4275 666 +4275 667 +4275 754 +4275 856 +4738 77 +4738 586 +4738 672 +4738 1980 +4738 2147 +4738 3138 +4738 5016 +4738 5303 +4738 5451 +4738 5452 +4806 5451 +321 32 +321 322 +321 323 +321 324 +321 325 +321 326 +321 327 +321 328 +321 329 +321 330 +325 82 +325 1507 +325 1669 +325 2159 +325 2187 +325 2268 +325 2269 +325 2270 +325 2271 +325 2272 +327 8 +327 96 +327 627 +327 681 +327 822 +327 2179 +327 2273 +327 2274 +327 2275 +327 2276 +2275 587 +2275 989 +2275 1435 +2275 2412 +2275 2726 +2275 3768 +2275 3958 +2275 3959 +2275 3960 +2275 3961 +2500 297 +2500 660 +2500 1573 +2500 2221 +2500 3057 +2500 3705 +2500 4148 +2500 4149 +2500 4150 +2500 4151 +3952 4706 +401 122 +401 124 +401 127 +401 146 +401 247 +401 264 +401 422 +401 423 +401 427 +401 559 +3397 4304 +3966 788 +3966 944 +3966 1163 +3966 1313 +3966 2068 +3966 3524 +3966 4371 +3966 4694 +3966 4801 +3966 5021 +3967 1123 +3967 1195 +3967 1288 +3967 1833 +3967 2035 +3967 2529 +3967 2755 +3967 4330 +3967 5019 +3967 5020 +344 881 +930 5 +930 7 +930 147 +930 148 +930 367 +930 368 +930 422 +930 559 +930 1317 +2498 819 +2498 2502 +2498 3129 +2498 3489 +2498 4107 +2498 4143 +2498 4144 +2498 4145 +2498 4146 +2498 4147 +3296 918 +3296 2027 +3296 2067 +3296 3714 +3296 4204 +3296 4657 +3296 4658 +3296 4659 +3296 4660 +3296 4661 +3962 1122 +3962 1557 +3962 1992 +3962 2380 +3962 2383 +3962 3350 +3962 3981 +3962 4434 +3962 4693 +3962 5018 +3963 23 +3963 96 +3963 350 +3963 1322 +3963 1664 +3963 1798 +3963 3144 +3963 4022 +3963 4890 +989 8 +989 49 +989 53 +989 108 +989 751 +989 756 +989 986 +989 990 +989 991 +989 1047 +989 1383 +989 1424 +989 2054 +989 2375 +989 2399 +989 2525 +989 2606 +989 2890 +989 2891 +989 2892 +989 2893 +989 2894 +989 2895 +989 2896 +989 2897 +334 268 +334 376 +334 843 +334 1587 +334 1888 +334 2053 +334 2285 +334 2286 +334 2287 +335 81 +335 141 +335 494 +335 1052 +335 2023 +335 2319 +335 3590 +335 4152 +335 4153 +335 4154 +1888 345 +1888 846 +1888 1251 +1888 1826 +1888 1889 +1888 1890 +1888 1891 +1888 1892 +1888 1893 +1888 1894 +2285 309 +2285 1019 +2285 1176 +2285 2848 +2285 3164 +2285 3457 +2285 3977 +2285 3979 +2285 3980 +2285 3981 +2286 123 +2286 124 +2286 179 +2286 238 +2286 367 +2286 423 +2286 427 +2286 853 +2286 2059 +2286 3764 +3590 4845 +4152 468 +4152 1655 +4152 2011 +4152 2645 +4152 3016 +4152 4197 +4152 4275 +4152 4438 +4152 4472 +4152 5092 +4154 586 +4154 1085 +4154 1859 +4154 2387 +4154 2894 +4154 4202 +4154 4628 +4154 5093 +4154 5094 +4154 5095 +345 126 +345 149 +345 177 +345 179 +345 248 +345 266 +345 424 +345 754 +345 2001 +1251 262 +1251 416 +1251 1057 +1251 1252 +1251 1253 +1251 1254 +1251 1255 +1251 1256 +1251 1257 +1251 1258 +1889 58 +1889 351 +1889 829 +1889 832 +1889 835 +1889 1306 +1889 1327 +1889 3636 +1889 3637 +1889 3638 +1890 39 +1890 158 +1890 1047 +1890 3341 +1890 3639 +1890 3640 +1890 3641 +1890 3642 +1890 3643 +1890 3644 +1890 3645 +1890 3646 +1890 3647 +1890 3648 +1890 3649 +1890 3650 +1890 3651 +1890 3652 +1890 3653 +1890 3654 +1890 3655 +1890 3656 +1890 3657 +1890 3658 +1890 3659 +1890 3660 +1890 3661 +1890 3662 +1890 3663 +1890 3664 +1890 3665 +1890 3666 +1890 3667 +1890 3668 +1893 1023 +1893 3136 +1019 551 +1019 898 +1019 945 +1019 1533 +1019 2018 +1019 2926 +1019 2927 +1019 2928 +1019 2929 +1019 2930 +1176 124 +1176 147 +1176 251 +1176 266 +1176 367 +1176 368 +1176 422 +1176 2001 +1176 2018 +3979 8 +3979 9 +3979 125 +3979 128 +3979 175 +3979 250 +3979 353 +3979 424 +3979 754 +3016 995 +3016 1034 +3016 2148 +3016 3070 +3016 3740 +3016 4532 +3016 5179 +3016 5324 +3016 5325 +3016 5326 +4197 5 +4197 31 +4197 126 +4197 143 +4197 180 +4197 250 +4197 368 +4197 697 +4197 856 +4197 1245 +4472 5 +4472 123 +4472 125 +4472 144 +4472 177 +4472 247 +4472 248 +4472 249 +4472 717 +4472 1317 +1859 23 +1859 56 +1859 125 +1859 1137 +1859 3093 +1859 3605 +1859 3606 +1859 3607 +1859 3608 +4628 68 +4628 831 +4628 1787 +4628 2355 +4628 2862 +4628 3304 +4628 3470 +4628 4889 +4628 5384 +4628 5385 +5093 2031 +340 341 +340 342 +340 343 +340 344 +340 345 +340 346 +340 347 +340 348 +340 349 +340 350 +349 473 +349 855 +349 946 +349 1716 +349 2296 +349 2297 +349 2298 +349 2299 +349 2300 +350 329 +350 378 +350 432 +350 558 +350 1734 +350 2264 +350 2328 +350 2329 +350 2330 +350 2331 +881 260 +881 667 +881 837 +881 1511 +881 2579 +881 2593 +881 2594 +881 2595 +881 2771 +881 2772 +1366 1152 +1366 2093 +1366 2215 +1366 2561 +1366 2789 +1366 3214 +1366 3215 +1366 3216 +1366 3217 +2293 118 +2293 717 +2293 771 +2293 1364 +2293 1365 +2293 1366 +2293 1946 +2293 2581 +2293 3985 +2293 3986 +2296 3987 +2299 424 +2299 2127 +2299 2330 +2299 2898 +2299 2907 +2299 2911 +2299 3991 +2299 3992 +2299 3993 +2299 3994 +2300 136 +2300 388 +2300 1456 +2300 1457 +2300 1677 +2300 1936 +2300 3995 +2300 3996 +2300 3997 +1734 157 +1734 351 +1734 554 +1734 814 +1734 1137 +1734 1808 +1734 2870 +1734 3566 +1734 5176 +2329 103 +2329 1631 +2329 2114 +2329 3283 +2329 3329 +2329 3466 +2329 4027 +2329 4028 +2329 4029 +2331 5437 +371 4 +371 7 +371 9 +371 148 +371 251 +371 264 +371 265 +371 367 +371 422 +371 1245 +372 231 +372 295 +372 1928 +372 2177 +372 2315 +372 2316 +372 2317 +372 2318 +372 2319 +372 2320 +377 127 +377 129 +377 176 +377 369 +377 423 +377 718 +377 856 +377 2018 +377 2338 +379 2373 +380 218 +380 1030 +380 1230 +380 1231 +380 1232 +380 1233 +380 1234 +380 1235 +380 1236 +1806 124 +1806 251 +1806 368 +1806 369 +1806 422 +1806 718 +1806 754 +1806 856 +1806 2018 +1806 3216 +1811 117 +1811 522 +1811 711 +1811 1636 +1811 1650 +1811 2792 +1811 3542 +1811 3543 +1811 3544 +1811 3545 +1813 146 +1813 176 +1813 246 +1813 252 +1813 264 +1813 368 +1813 369 +1813 390 +1813 667 +1813 718 +3975 57 +3976 149 +3976 266 +3976 368 +3976 423 +3976 424 +3976 559 +3976 718 +3976 856 +3976 1245 +2593 866 +2593 932 +2593 1303 +2593 1377 +2593 1492 +2593 4190 +2593 4191 +2593 4192 +2593 4193 +3982 108 +3982 503 +3982 534 +3982 1511 +3982 1805 +3982 2090 +3982 3461 +3982 4658 +3982 5022 +1365 1087 +1365 1361 +1365 1477 +1365 2082 +1365 3209 +1365 3210 +1365 3211 +1365 3212 +1365 3213 +3985 563 +3985 1846 +3985 2489 +3985 2517 +3985 3819 +3985 3863 +3985 3988 +3985 4241 +3985 4565 +3985 5023 +3986 531 +3986 749 +3986 1279 +3986 2207 +3986 2383 +3986 2864 +3986 4087 +3986 4734 +3986 5026 +3986 5027 +2868 167 +2868 1232 +2868 1451 +2868 2266 +2868 2723 +2868 2931 +2868 2941 +2868 3375 +2868 3981 +2868 4341 +3127 2157 +3127 2422 +3127 3185 +3127 4573 +3127 4640 +3127 4641 +3309 9 +3309 97 +3309 413 +3309 581 +3309 1023 +3309 1026 +3309 1533 +3309 3460 +3309 3786 +3309 3822 +4207 97 +4207 706 +4207 1685 +4207 1903 +4207 4231 +4282 125 +4282 824 +4282 1088 +4282 2220 +4282 3138 +4282 3468 +4282 4339 +4282 4414 +4282 4502 +4282 5182 +2898 932 +2898 1305 +2898 2353 +2898 2694 +2898 2770 +2898 3138 +2898 4058 +2898 4381 +2898 4382 +2898 4383 +2907 112 +2907 117 +2907 841 +2907 2154 +2907 3526 +2907 4082 +2907 4389 +2907 4390 +2907 4391 +2907 4392 +3991 289 +3991 1846 +3991 2330 +3991 3479 +3991 3632 +3991 4242 +3991 4503 +3991 4587 +3991 5036 +3991 5037 +3997 28 +3997 714 +3997 1861 +3997 2425 +3997 3343 +3997 3386 +3997 3471 +3997 3702 +3997 4189 +3997 4854 +2870 23 +2870 1431 +2870 1754 +2870 2344 +2870 2778 +2870 4360 +2870 4361 +2870 4362 +2870 4363 +2870 4364 +3566 828 +3566 1289 +3566 1491 +3566 2826 +3566 3928 +3566 4104 +3566 4655 +3566 4751 +3566 4825 +3566 4826 +968 739 +968 828 +968 889 +968 969 +968 970 +968 971 +968 972 +968 973 +968 974 +2312 148 +2312 174 +2312 251 +2312 264 +2312 367 +2312 368 +2312 390 +2312 422 +2312 718 +2312 1317 +2313 3 +2313 121 +2313 129 +2313 143 +2313 179 +2313 264 +2313 353 +2313 367 +2313 390 +2313 717 +2314 750 +2314 2067 +2314 2950 +2314 3097 +2314 4172 +2314 4373 +2314 5162 +2314 5163 +2314 5164 +2314 5165 +2325 3144 +2325 3894 +2325 3963 +2325 4021 +2325 4022 +2325 4023 +2325 4024 +2325 4025 +2325 4026 +2332 714 +2332 859 +2332 2515 +2332 2646 +2332 2729 +2332 2965 +2332 4031 +2332 4032 +2332 4033 +2336 158 +2336 1227 +2336 1892 +2336 2099 +2336 2528 +2336 2538 +2336 2799 +2336 2805 +2336 3136 +2336 4041 +2337 450 +2337 452 +2337 532 +2337 1239 +2337 1741 +2337 2381 +2337 2923 +2337 3102 +2337 3728 +972 469 +972 2229 +972 2862 +972 2863 +972 2864 +4004 682 +4004 2149 +4004 2442 +4004 5029 +4004 5030 +4004 5031 +4004 5032 +4004 5033 +4004 5034 +4004 5035 +4005 1228 +4005 1537 +4005 1587 +4005 2291 +4005 2547 +4005 2563 +4005 3846 +4005 5048 +4005 5049 +4005 5050 +750 385 +750 817 +750 1417 +750 2127 +750 2294 +750 2397 +750 2674 +750 2675 +750 2676 +750 2677 +2950 4435 +5163 1002 +5163 3595 +5163 3822 +5163 4607 +5163 4628 +5163 4734 +5163 4880 +5163 5036 +5163 5272 +5163 5671 +5165 5407 +2892 763 +2892 2052 +2892 2628 +2892 2773 +2892 4219 +2892 4372 +2892 4373 +2892 4374 +2892 4375 +2892 4376 +4319 720 +4319 866 +4319 1425 +4319 1719 +4319 2546 +4319 4251 +4319 5210 +4319 5211 +4319 5212 +4319 5213 +1385 69 +1385 191 +1385 616 +1385 3213 +1385 3248 +1385 3249 +1385 3250 +1385 3251 +1385 3252 +1385 3253 +2790 8 +2790 121 +2790 128 +2790 144 +2790 147 +2790 266 +2790 352 +2790 424 +2790 559 +2790 1317 +3080 38 +3080 706 +3080 1904 +3080 3334 +3080 3409 +3080 3679 +3080 3698 +3080 3849 +3080 4501 +3080 4502 +4016 9 +4016 124 +4016 125 +4016 144 +4016 145 +4016 148 +4016 247 +4016 352 +4016 353 +4016 424 +3257 235 +3257 364 +3257 422 +3257 962 +3257 1565 +3257 2699 +3257 2965 +3257 3605 +3257 4380 +3475 18 +3475 498 +3475 1476 +3475 1554 +3475 2383 +3475 3219 +3475 3717 +3475 4778 +3475 4779 +4021 156 +4021 476 +4021 802 +4021 921 +4021 1336 +4021 2347 +4021 2806 +4021 3053 +4021 3343 +4021 3866 +4026 1330 +4026 5124 +4026 5125 +4032 144 +4032 147 +4032 149 +4032 177 +4032 266 +4032 353 +4032 424 +4032 558 +4032 856 +4032 2338 +4033 21 +4033 385 +4033 1084 +4033 1137 +4033 1167 +4033 1342 +4033 2690 +4033 3829 +4033 4876 +4033 4915 +1706 8 +1706 121 +1706 123 +1706 128 +1706 179 +1706 238 +1706 247 +1706 248 +1706 264 +1706 353 +3096 654 +3096 1289 +3096 1860 +3096 4459 +3096 4512 +3096 4517 +3096 4518 +3096 4519 +3096 4520 +4041 924 +4041 1199 +4041 1213 +4041 1608 +4041 1867 +4041 1868 +4041 1915 +4041 3336 +4041 4412 +4041 5052 +450 38 +450 203 +450 451 +450 452 +450 453 +450 454 +450 455 +450 456 +450 457 +2381 193 +2381 924 +2381 1243 +2381 1297 +2381 1515 +2381 1868 +2381 2213 +2381 4066 +2381 4067 +2381 4068 +3102 815 +3102 1066 +3102 2067 +3102 2234 +3102 3916 +3102 4017 +3102 4257 +3102 4478 +3102 4535 +3102 4536 +360 65 +360 361 +360 362 +360 363 +360 364 +360 365 +366 3 +366 124 +366 147 +366 177 +366 251 +366 264 +366 266 +366 367 +366 368 +366 369 +2315 458 +2315 869 +2315 881 +2315 1447 +2315 2886 +2315 3547 +2315 4000 +2315 4001 +2315 4002 +2315 4003 +2318 1021 +2318 2538 +2318 3763 +2318 3789 +2318 4008 +2318 4009 +2318 4010 +2318 4011 +2318 4012 +2318 4013 +1232 263 +1232 1854 +1232 1881 +1232 2493 +1232 3089 +1232 3090 +1232 3091 +1232 3092 +1232 3093 +1232 3094 +1234 228 +1234 342 +1234 1023 +1234 2093 +1234 2612 +1234 2678 +1234 2871 +1234 3095 +1234 3096 +1234 3097 +2886 121 +2886 125 +2886 129 +2886 146 +2886 176 +2886 238 +2886 248 +2886 264 +2886 352 +2886 427 +3547 711 +4000 294 +4000 2964 +4000 4658 +4000 4961 +4000 5038 +4003 3 +4003 8 +4003 127 +4003 143 +4003 177 +4003 248 +4003 352 +4003 353 +4003 367 +4003 424 +4008 1199 +4008 1297 +4008 1867 +4008 2664 +4008 3071 +4008 3801 +4008 4723 +4008 5042 +4008 5043 +4008 5044 +4010 110 +4010 2795 +4010 3003 +4010 3404 +4010 4533 +4010 4904 +4010 5045 +4010 5046 +4010 5047 +4012 1010 +4012 1300 +4012 1571 +4012 2230 +4012 2377 +4012 2887 +4012 3185 +4012 3781 +4012 4655 +4012 4847 +5645 57 +5645 271 +5645 2249 +5645 3675 +5645 4077 +5645 5923 +5645 5924 +5645 5925 +5645 5926 +2693 82 +2693 1536 +2693 1734 +2693 2039 +2693 2433 +2693 2820 +2693 4262 +2693 4263 +2693 4264 +2693 4265 +2944 1240 +2944 1425 +2944 1731 +2944 4537 +2944 4538 +2946 1787 +2946 1939 +2946 2190 +2946 4005 +2946 4007 +2946 4354 +2946 4429 +2946 4430 +2946 4431 +2946 4432 +2949 163 +2949 264 +2949 667 +2949 708 +2949 1903 +2949 1926 +2949 2035 +2949 3365 +2949 4402 +2949 4421 +1854 575 +1854 1290 +1854 1291 +1854 1731 +1854 2049 +1854 2394 +1854 3599 +1854 3602 +1854 3603 +1854 3604 +1881 263 +1881 1085 +1881 1456 +1881 2397 +1881 3392 +1881 3479 +1881 3632 +1881 3633 +1881 3634 +1881 3635 +3092 1424 +3092 1524 +3092 2257 +3092 3053 +3092 3096 +3092 3105 +3092 3269 +3092 3716 +3092 4130 +3092 4532 +2678 2314 +2678 2481 +2678 2788 +2678 2828 +2678 3279 +2678 4251 +2678 4252 +2678 4253 +2678 4254 +2678 4255 +3095 369 +3095 493 +3095 553 +3095 1599 +3095 1796 +3095 2211 +3095 3220 +3095 4521 +3095 4522 +3095 4523 +3095 4524 +3095 4525 +3095 4526 +3095 4527 +3095 4528 +3095 4529 +3095 4530 +3095 4531 +385 23 +385 314 +385 1741 +385 2162 +385 2339 +385 2340 +385 2341 +385 2342 +385 2343 +385 2344 +386 389 +386 609 +386 1077 +386 1451 +386 2035 +386 2360 +386 2361 +386 2362 +386 2363 +386 2364 +389 693 +389 882 +389 951 +389 1383 +389 1538 +389 1792 +389 2271 +389 2357 +389 2358 +389 2359 +996 77 +996 997 +996 998 +2345 510 +2345 881 +2345 3034 +2345 3184 +2345 3547 +2345 4001 +2345 4002 +2345 4042 +2345 4043 +2345 4044 +2347 38 +2347 540 +2347 554 +2347 584 +2347 1424 +2347 1940 +2347 2086 +2347 2653 +2347 4034 +2350 4 +2350 5 +2350 17 +2350 121 +2350 122 +2350 126 +2350 180 +2350 247 +2350 250 +2350 424 +2351 1248 +2351 1335 +2351 1779 +2351 2669 +2351 2792 +2351 3172 +2351 3580 +2351 3935 +2351 4035 +2352 63 +2352 738 +2352 1556 +2352 1949 +2352 2279 +2352 2699 +2352 3204 +2352 3863 +2352 4039 +2352 4040 +2343 338 +2343 1196 +2343 1198 +2343 1766 +2343 2320 +2343 2889 +2343 3113 +2343 3301 +2343 3565 +2343 3566 +1077 1022 +2360 740 +2360 925 +2360 1062 +2360 1245 +2360 3550 +2360 3626 +2360 4053 +2360 4054 +2360 4055 +2360 4056 +2361 325 +2361 2662 +2361 2911 +2361 3384 +2361 4088 +2364 1999 +2364 4050 +2364 4051 +2364 4052 +825 826 +825 827 +825 828 +825 829 +825 830 +825 831 +825 832 +825 833 +825 834 +825 835 +1733 73 +1733 407 +1733 830 +1733 2350 +1733 3491 +1733 3492 +1733 3493 +1733 3494 +1733 3495 +1733 3496 +2356 38 +2356 215 +2356 962 +2356 1522 +2356 2007 +2356 4035 +2356 4036 +2356 4037 +2356 4038 +882 2774 +997 522 +997 1332 +997 1829 +997 2061 +997 2383 +997 2507 +997 2902 +998 181 +998 668 +998 1536 +998 1735 +998 2023 +998 2451 +998 2898 +998 2899 +998 2900 +998 2901 +3034 127 +3034 289 +3034 1223 +3034 3035 +3034 3795 +3034 4292 +3034 4388 +3034 4466 +3034 4467 +4043 744 +4043 749 +4043 946 +4043 2040 +4043 2286 +4043 2912 +4043 4432 +4043 4675 +4043 5054 +4043 5055 +2699 3 +2699 122 +2699 127 +2699 143 +2699 146 +2699 177 +2699 238 +2699 249 +2699 352 +2699 856 +3550 748 +3550 813 +3550 1587 +3550 1766 +3550 2198 +3550 2744 +3550 2859 +3550 3080 +3550 4280 +3550 4815 +3626 102 +3626 1262 +3626 1647 +3626 3615 +3626 4412 +2662 4250 +684 93 +684 1376 +684 1955 +684 2227 +684 2300 +684 2421 +684 2630 +684 2631 +684 2632 +684 2633 +2666 8 +2666 1036 +2666 1482 +2666 1485 +2666 2035 +2666 4868 +2666 5154 +2666 5806 +2666 5807 +2666 5808 +4051 122 +4051 175 +4051 250 +4051 252 +4051 266 +4051 367 +4051 423 +4051 558 +4051 754 +4051 2001 +830 4 +830 31 +830 148 +830 179 +830 180 +830 368 +830 666 +830 736 +830 886 +830 2018 +407 412 +407 1217 +407 1749 +407 2392 +3495 3 +3495 145 +3495 174 +3495 176 +3495 177 +3495 249 +3495 251 +3495 353 +3495 1317 +3495 3995 +3496 566 +3496 645 +3496 674 +3496 884 +3496 1926 +3496 2302 +3496 2857 +3496 3768 +3496 4655 +1522 140 +1522 609 +1522 693 +1522 730 +1522 1249 +1522 1313 +1522 1349 +1522 2032 +1522 3328 +1522 3329 +4036 813 +4036 842 +4036 924 +4036 2904 +4036 2928 +4036 3058 +4036 3109 +4036 4248 +4036 4978 +4038 2236 +2604 4166 +2606 7 +2606 123 +2606 125 +2606 145 +2606 148 +2606 177 +2606 179 +2606 247 +2606 559 +2606 2018 +2607 357 +2607 1092 +2607 1866 +2607 2279 +2607 4150 +2607 4205 +2607 4206 +2607 4207 +2607 4208 +2607 4209 +2774 2440 +1001 614 +1001 788 +1001 1071 +1001 1100 +1001 1291 +1001 2198 +1001 2931 +1001 2932 +1001 2933 +1001 2934 +1001 2935 +1001 2936 +3536 751 +3536 1802 +3536 3795 +3536 3918 +3536 4804 +3536 4805 +3536 4806 +3536 4807 +3537 123 +3537 126 +3537 145 +3537 149 +3537 177 +3537 352 +3537 353 +3537 424 +3537 558 +3537 754 +3539 47 +3539 503 +3539 1342 +3539 3460 +3539 4199 +3539 4281 +3539 4727 +3539 4808 +3539 4809 +3539 4810 +2374 5 +2374 125 +2374 129 +2374 145 +2374 247 +2374 249 +2374 367 +2374 424 +2374 427 +2374 1317 +2375 2035 +2375 2298 +2375 3112 +2375 3695 +2375 4057 +2375 4058 +2375 4059 +2375 4060 +2375 4061 +2375 4062 +2376 94 +2376 522 +2376 802 +2376 1332 +2376 1738 +2376 2658 +2376 2906 +2376 3357 +2376 4065 +1243 138 +1243 982 +1243 988 +1243 1787 +1243 2465 +1243 2663 +1243 3106 +1243 3107 +1243 3108 +4068 113 +4068 363 +4068 828 +4068 2414 +4068 4885 +4068 4904 +4068 4953 +4068 5060 +4068 5061 +4068 5062 +2420 503 +2420 614 +2420 1763 +2420 2298 +2420 3014 +2420 3071 +2420 3439 +2420 3860 +2420 4093 +2420 4094 +4070 633 +4070 989 +4070 1726 +4070 2207 +4070 2615 +4070 2641 +4070 5059 +4070 5063 +4070 5064 +4070 5065 +2866 364 +2866 619 +2866 706 +2866 1620 +2866 1787 +2866 2089 +2866 3017 +2866 3156 +2866 3930 +2866 4368 +4057 459 +4057 1034 +4057 1054 +4057 1374 +4057 2833 +4057 5066 +4057 5067 +4057 5068 +4057 5069 +4058 550 +4058 628 +4058 1750 +4058 2649 +4058 5056 +4058 5057 +4059 3789 +4060 1571 +4060 1918 +4060 2543 +4060 2571 +4060 2745 +4060 2935 +4060 3153 +4060 4172 +4060 4492 +4060 4919 +4062 1787 +4062 2901 +4062 3058 +4062 3334 +4062 3672 +4062 4871 +4062 4880 +4062 5058 +4062 5059 +500 59 +500 1475 +500 1476 +2798 177 +2798 261 +2798 266 +2798 1134 +2798 1529 +2798 3304 +2798 3590 +2798 4307 +2798 4308 +2798 4309 +399 400 +399 401 +399 402 +399 403 +399 404 +399 405 +399 406 +399 407 +399 408 +399 409 +406 1999 +409 3 +409 146 +409 147 +409 175 +409 247 +409 248 +409 266 +409 368 +409 422 +409 2018 +1217 554 +1217 1424 +1217 1670 +1217 1749 +1217 2341 +1217 2672 +1217 2839 +1217 3081 +1217 3082 +1217 3083 +3081 9 +3081 549 +3081 1480 +3081 2089 +3081 2385 +3081 2719 +3081 3039 +3081 4278 +3081 4503 +3081 4504 +804 778 +804 805 +804 806 +804 807 +804 808 +804 809 +804 810 +804 811 +804 812 +804 813 +804 814 +804 815 +804 816 +804 817 +1339 377 +3346 75 +3346 759 +3346 1583 +3346 2248 +3346 2490 +3346 3966 +3346 4281 +3346 4464 +3346 4683 +3346 4684 +4081 541 +4081 760 +4081 937 +4081 1022 +4081 1929 +4081 1940 +4081 3738 +4081 4402 +4081 5076 +410 411 +410 412 +410 413 +410 414 +410 415 +410 416 +410 417 +410 418 +410 419 +410 420 +413 2393 +415 156 +415 427 +415 676 +415 799 +415 803 +415 1018 +415 1019 +415 1020 +415 1021 +416 640 +416 1002 +416 1477 +416 2013 +416 2327 +416 2434 +416 2435 +416 2436 +416 2437 +416 2438 +418 763 +418 1541 +418 1944 +418 2467 +418 2468 +418 2469 +418 2470 +418 2471 +1002 20 +1002 95 +1002 341 +1002 478 +1002 798 +1002 892 +1002 1408 +1002 1439 +1002 1440 +1002 1441 +1477 3 +1477 4 +1477 17 +1477 122 +1477 176 +1477 264 +1477 422 +1477 666 +1477 856 +2471 57 +2471 272 +2471 274 +2471 834 +2471 1583 +2471 2102 +2471 2141 +2471 2635 +2471 4120 +1328 1249 +1328 2377 +1328 2413 +1328 2448 +1328 3169 +1328 3170 +1328 3171 +1328 3172 +1328 3173 +1328 3174 +2670 4 +2670 121 +2670 145 +2670 148 +2670 174 +2670 252 +2670 265 +2670 422 +2670 559 +2670 666 +2702 351 +2702 2419 +2702 2566 +2702 3007 +2702 3797 +2702 3953 +2702 4266 +2702 4267 +2702 4268 +2702 4269 +2704 837 +2767 8 +2767 9 +2767 127 +2767 128 +2767 238 +2767 248 +2767 352 +2767 427 +2767 1317 +2767 4303 +4160 3 +4160 7 +4160 9 +4160 124 +4160 125 +4160 126 +4160 128 +4160 176 +4160 247 +4160 424 +551 586 +551 765 +551 955 +551 982 +551 1288 +551 1311 +551 2336 +551 2516 +551 2517 +551 2518 +945 336 +945 660 +945 801 +945 940 +945 1095 +945 2846 +945 3777 +945 4409 +945 4410 +945 4411 +2926 664 +2927 868 +2927 963 +2927 1749 +2927 2298 +2927 3717 +2927 4265 +2927 5777 +2927 5778 +2927 5779 +2927 5780 +2930 2158 +1440 292 +1440 1177 +1440 1557 +1440 1718 +1440 2656 +1440 3302 +1440 3303 +1440 3304 +1440 3305 +1440 3306 +548 469 +548 549 +548 550 +548 551 +548 552 +548 553 +548 554 +548 555 +548 556 +679 270 +679 680 +679 681 +679 682 +679 683 +679 684 +679 685 +679 686 +679 687 +679 688 +3323 122 +3323 127 +3323 145 +3323 148 +3323 176 +3323 177 +3323 249 +3323 424 +3323 427 +3323 1246 +421 8 +421 122 +421 123 +421 125 +421 264 +421 352 +421 390 +421 422 +421 423 +421 424 +4083 4317 +425 8 +425 121 +425 122 +425 128 +425 147 +425 177 +425 251 +425 422 +425 426 +425 427 +2596 1491 +2596 1689 +2596 2083 +2596 3681 +2596 3953 +2596 4194 +2596 4195 +2596 4196 +2596 4197 +2596 4198 +428 429 +428 430 +428 431 +428 432 +428 433 +428 434 +428 435 +428 436 +428 437 +428 438 +430 826 +430 1415 +430 2235 +430 2373 +430 2416 +430 2417 +430 2418 +430 2419 +430 2420 +430 2421 +431 487 +431 2214 +431 2311 +431 2422 +431 2423 +431 2424 +431 2425 +431 2426 +431 2427 +431 2428 +434 4 +434 5 +434 7 +434 127 +434 145 +434 148 +434 266 +434 559 +434 1317 +434 2018 +435 127 +437 1090 +437 1486 +437 2500 +438 156 +438 456 +438 1383 +438 1522 +438 2094 +438 2220 +438 2443 +438 2444 +438 2445 +438 2446 +2425 108 +2425 354 +2425 1968 +2425 2155 +2425 2964 +2425 3046 +2425 4098 +2425 4099 +2425 4100 +2425 4101 +1090 1374 +1090 1516 +1090 1568 +1090 1861 +1090 2078 +1090 2222 +1090 2430 +1090 3110 +1090 3111 +2444 478 +2444 2288 +2444 2420 +2444 2657 +2444 2690 +2444 3698 +2444 3700 +2444 4102 +2444 4103 +2444 4104 +747 2051 +747 2427 +747 2648 +747 2667 +747 2668 +747 2669 +747 2670 +747 2671 +747 2672 +747 2673 +2897 262 +2897 396 +2897 1397 +2897 4307 +2897 4366 +2897 4377 +2897 4378 +2897 4379 +2897 4380 +3273 623 +3273 962 +3273 1177 +3273 2337 +3273 2427 +3273 3981 +3273 4645 +3273 4646 +3273 4647 +1691 3669 +4098 762 +4098 2593 +4098 3956 +4098 4118 +4098 4871 +4095 38 +4095 257 +4095 573 +4095 2274 +4095 3299 +4095 3409 +4095 4164 +4095 4230 +4095 4695 +4095 5077 +4096 1772 +1377 247 +1377 963 +1377 1135 +1377 2006 +1377 2237 +1377 3082 +1377 3105 +1377 3224 +1377 3225 +1377 3226 +4149 5105 +4151 5091 +4102 50 +4102 2557 +4103 9 +4103 17 +4103 175 +4103 252 +4103 390 +4103 422 +4103 559 +4103 856 +4103 1245 +4103 1770 +439 440 +439 441 +439 442 +439 443 +439 444 +439 445 +439 446 +439 447 +439 448 +439 449 +448 108 +448 128 +448 148 +448 878 +448 1317 +448 1376 +448 1556 +448 1912 +448 2439 +448 2440 +2492 64 +2492 813 +2492 852 +2492 1608 +2492 1868 +2492 3196 +2492 3421 +2492 3617 +2492 4040 +4781 679 +4781 963 +4781 1359 +4781 5478 +4781 5479 +4781 5480 +4781 5481 +4781 5482 +4781 5483 +4781 5484 +878 59 +878 202 +878 510 +878 879 +878 880 +878 881 +878 882 +878 883 +878 884 +878 885 +2440 1881 +2440 4957 +2440 5304 +2440 5305 +963 1054 +963 1124 +963 1831 +963 2287 +963 2291 +963 2686 +963 2851 +963 2852 +963 2853 +963 2854 +5478 122 +5478 123 +5478 145 +5478 148 +5478 238 +5478 353 +5478 424 +5478 697 +5478 736 +5478 2001 +5479 2697 +5479 4065 +5479 5882 +885 2773 +5304 113 +5304 2313 +5304 2932 +5304 3017 +5304 3134 +5304 4702 +5304 5281 +5304 5299 +5304 5510 +5304 5657 +466 2447 +466 2448 +466 2449 +466 2450 +466 2451 +4121 732 +4121 960 +4121 1430 +4121 2259 +4121 2655 +4121 3937 +4121 4348 +4121 5083 +4121 5084 +4121 5085 +4122 77 +4122 1030 +4122 1721 +4122 1947 +4122 1982 +4122 2377 +4122 2448 +4122 2523 +4122 3153 +4122 3171 +469 41 +469 102 +469 470 +469 471 +469 472 +469 473 +469 474 +469 475 +469 476 +469 477 +475 1670 +475 1915 +475 2480 +475 2481 +475 2482 +475 2483 +475 2484 +475 2485 +475 2486 +475 2487 +581 2538 +1685 222 +1685 521 +1685 779 +1685 1652 +1685 1686 +1685 1687 +1685 1688 +1685 1689 +1685 1690 +1685 1691 +4502 125 +4502 174 +4502 424 +4502 503 +4502 1142 +4502 1516 +4502 2537 +4502 4170 +4502 5331 +4502 5332 +2654 836 +2654 908 +2654 1412 +2654 2076 +2654 2461 +2654 2660 +2654 3767 +2654 3995 +2654 4243 +2654 4244 +4124 1208 +4124 2474 +4124 2636 +4124 3404 +4124 3733 +4124 3806 +4124 4687 +4124 5087 +4124 5088 +4124 5089 +479 2452 +479 2453 +479 2454 +479 2455 +479 2456 +479 2457 +479 2458 +479 2459 +479 2460 +479 2461 +480 382 +480 507 +480 722 +480 726 +480 1048 +480 2319 +480 2358 +480 2462 +480 2463 +481 4 +481 124 +481 265 +481 353 +481 368 +481 369 +481 695 +481 700 +481 946 +481 947 +483 1812 +2452 77 +2452 1027 +2452 1321 +2452 1925 +2452 2373 +2452 3156 +2452 3849 +2452 4106 +2452 4107 +2452 4108 +2453 125 +2453 126 +2453 128 +2453 145 +2453 179 +2453 180 +2453 250 +2453 856 +2453 2001 +2454 586 +2459 215 +2459 856 +2459 960 +2459 1103 +2459 1152 +2459 1402 +2459 1709 +2459 3165 +2459 3866 +2459 4109 +2460 892 +2460 1019 +2460 1342 +2460 1476 +2460 2530 +2460 2531 +2460 2532 +2460 3874 +2460 4110 +2460 4111 +2461 559 +2461 1005 +2461 1081 +2461 1425 +2461 1549 +2461 2791 +2461 2796 +2461 4044 +2461 4112 +2461 4113 +507 3 +507 127 +507 143 +507 249 +507 251 +507 252 +507 427 +507 2491 +507 2492 +722 2713 +726 152 +726 406 +726 540 +726 3459 +726 3654 +726 3726 +726 4072 +726 5137 +726 5138 +726 5139 +2463 5 +2463 933 +2463 2592 +2463 2797 +2463 2798 +2463 3105 +2463 3927 +2463 4084 +2463 4114 +2463 4115 +1352 124 +1352 126 +1352 145 +1352 174 +1352 179 +1352 423 +1352 667 +1352 1353 +1352 1354 +1352 1355 +3156 477 +3156 710 +3156 2347 +3156 2540 +3156 3489 +3156 4344 +3156 4563 +3156 4564 +3156 4565 +4106 452 +4106 453 +4106 1587 +4106 3404 +4106 5081 +4107 652 +4107 816 +4107 1097 +4107 3714 +4107 3904 +4107 4012 +4107 4122 +4107 5078 +4107 5079 +4107 5080 +4109 795 +4109 843 +4109 979 +4109 1172 +4109 2085 +4109 2561 +4109 3925 +4109 4075 +4109 4183 +4109 5082 +2530 63 +2530 933 +2530 1220 +2530 1618 +2530 2579 +2530 2626 +2530 3758 +2530 4155 +2530 4156 +2530 4157 +4111 5 +4111 31 +4111 149 +4111 177 +4111 179 +4111 250 +4111 352 +4111 558 +4111 697 +4111 1317 +1081 512 +1081 922 +1081 940 +1081 1720 +1081 2978 +1081 2979 +1081 2980 +1081 2981 +1081 2982 +1081 2983 +1549 130 +1549 1009 +1549 1629 +1549 2230 +1549 2587 +1549 2673 +1549 3341 +2796 3 +2796 5 +2796 7 +2796 8 +2796 125 +2796 126 +2796 149 +2796 247 +2796 249 +2796 424 +4112 7 +4112 8 +4112 145 +4112 148 +4112 174 +4112 266 +4112 424 +4112 856 +4112 2338 +4113 123 +4113 127 +4113 176 +4113 179 +4113 248 +4113 249 +4113 352 +4113 422 +4113 427 +4113 667 +3654 586 +3654 1089 +3654 1280 +3654 1923 +3654 2723 +3654 4009 +3654 4124 +3654 4584 +3654 4877 +3654 4878 +5137 125 +5137 129 +5137 144 +5137 147 +5137 148 +5137 179 +5137 352 +5137 1246 +5137 1317 +5137 2001 +5138 2383 +1055 257 +1055 1347 +1055 2207 +1055 2411 +1055 2802 +1055 2968 +1055 2969 +1055 2970 +1055 2971 +2797 5 +2797 17 +2797 125 +2797 126 +2797 143 +2797 149 +2797 175 +2797 754 +2797 856 +4114 124 +4114 127 +4114 251 +4114 264 +4114 390 +4114 427 +4114 559 +4114 667 +4114 1245 +4114 2018 +1433 121 +1433 124 +1433 129 +1433 143 +1433 146 +1433 147 +1433 183 +1433 266 +1433 559 +1433 718 +2464 182 +2464 652 +2464 892 +2464 1988 +2464 2448 +2464 2982 +2464 4116 +2464 4117 +2464 4118 +2464 4119 +2465 3 +2465 31 +2465 124 +2465 146 +2465 175 +2465 180 +2465 247 +2465 266 +2465 367 +2465 2001 +652 175 +652 389 +652 424 +652 732 +652 1326 +652 2199 +652 2572 +652 2573 +652 2574 +652 2575 +4117 5086 +2961 345 +2961 415 +2961 937 +2961 1001 +2961 2377 +2961 3242 +2961 3906 +2961 4192 +2961 4433 +2961 4434 +499 71 +499 466 +499 500 +499 501 +499 502 +499 503 +499 504 +499 505 +499 506 +499 507 +504 3 +504 123 +504 125 +504 146 +504 264 +504 352 +504 353 +504 427 +504 1245 +504 1246 +505 5 +505 125 +505 145 +505 148 +505 174 +505 264 +505 368 +505 422 +505 1317 +505 2018 +508 260 +508 452 +508 487 +508 509 +508 510 +508 511 +508 512 +508 513 +508 514 +508 515 +509 14 +509 193 +509 363 +509 503 +509 828 +509 840 +509 2447 +509 2488 +509 2489 +509 2490 +2489 2661 +516 350 +516 517 +516 518 +516 519 +516 520 +516 521 +516 522 +516 523 +516 524 +516 525 +521 27 +521 117 +521 325 +521 577 +521 578 +521 579 +521 580 +521 581 +521 582 +521 583 +577 164 +577 584 +577 642 +577 977 +577 1610 +577 2506 +577 2525 +577 2526 +577 2527 +577 2528 +580 3 +580 910 +580 1275 +580 1427 +580 1782 +580 1792 +580 2539 +580 2540 +580 2541 +580 2542 +1610 60 +1610 234 +1610 269 +1610 721 +1610 1539 +1610 1611 +1610 1612 +1610 1613 +1610 1614 +1610 1615 +2506 983 +2506 2223 +2506 2646 +2506 2733 +2506 3569 +2506 3772 +2506 3894 +2506 4061 +2506 4141 +2506 4142 +2529 11 +2529 1904 +2529 2061 +2529 3080 +2529 3487 +2529 3849 +2529 4263 +2529 4980 +2529 5159 +2529 5600 +715 638 +715 834 +715 1068 +715 1195 +715 2472 +715 2645 +715 2646 +715 2647 +715 2648 +715 2649 +2536 2254 +526 56 +526 527 +528 17 +528 241 +528 529 +528 530 +528 531 +528 532 +528 533 +528 534 +528 535 +528 536 +533 1482 +533 1512 +533 1607 +533 2498 +533 2499 +533 2500 +533 2501 +533 2502 +533 2503 +533 2504 +536 1132 +2501 5 +2501 123 +2501 125 +2501 126 +2501 129 +2501 144 +2501 148 +2501 149 +2501 248 +2501 1317 +2503 132 +2503 181 +2503 397 +2503 707 +2503 1786 +2503 2750 +2503 2751 +2503 3801 +2503 3995 +2503 4136 +2504 894 +2504 1248 +2504 2653 +2504 3555 +2504 3775 +2504 4131 +2504 4132 +2504 4133 +2504 4134 +2504 4135 +1827 434 +1827 979 +1827 1697 +1827 1828 +1827 1829 +1827 1830 +1827 1831 +1827 1832 +1827 1833 +3171 113 +3171 870 +3171 997 +3171 3995 +3171 4017 +3171 4120 +3171 4206 +3171 4402 +3171 4569 +3171 4570 +4846 926 +4846 1258 +4846 1382 +4846 1706 +4846 3062 +4846 3064 +4846 4170 +4846 4339 +4846 5881 +5236 125 +5236 143 +5236 145 +5236 146 +5236 147 +5236 367 +5236 368 +5236 422 +5236 559 +5236 754 +5238 208 +5238 347 +5238 724 +5238 3129 +5238 3823 +5238 4764 +5238 5726 +5238 5727 +5238 5728 +5238 5729 +3129 334 +3129 2360 +3129 3634 +3129 3962 +3129 4548 +4143 685 +4143 1036 +4143 1797 +4143 2334 +4143 3562 +4144 322 +4144 462 +4144 1447 +4144 1481 +4144 1615 +4144 4214 +4144 4307 +4144 4955 +4144 5097 +4144 5098 +4146 621 +4146 2347 +4146 2537 +4146 3372 +4146 3485 +4146 3498 +4146 3608 +4146 4397 +4146 5103 +707 115 +707 1047 +707 1107 +707 1503 +707 1656 +707 1803 +707 2641 +707 2642 +707 2643 +707 2644 +3555 1039 +3555 1792 +3555 2314 +3555 4148 +3555 4350 +3555 4362 +3555 4675 +3555 4818 +3555 4819 +3555 4820 +537 538 +537 539 +537 540 +537 541 +537 542 +537 543 +537 544 +537 545 +537 546 +537 547 +541 200 +541 710 +541 2534 +544 522 +544 2505 +544 2506 +544 2507 +544 2508 +544 2509 +544 2510 +544 2511 +544 2512 +544 2513 +547 117 +547 335 +547 824 +547 1790 +547 2078 +547 2151 +547 2240 +547 2418 +547 2514 +547 2515 +2505 23 +2505 133 +2505 916 +2505 3594 +2505 4137 +2510 49 +2510 101 +2510 1339 +2510 1628 +2510 2114 +2510 2231 +2510 3077 +2510 4138 +2510 4139 +2510 4140 +4137 264 +4137 385 +4137 1227 +4137 1281 +4137 1310 +4137 3266 +4137 4077 +4137 4345 +4137 4362 +4137 4739 +4139 268 +4139 487 +4139 1339 +4139 2220 +4139 2898 +4139 4307 +4139 4328 +4139 4382 +4139 4841 +4139 4993 +4140 248 +4140 344 +4140 387 +4140 894 +4140 1942 +4140 2383 +4140 2394 +4140 3921 +4140 4210 +4140 5090 +553 2 +553 4 +553 175 +553 251 +553 554 +553 695 +553 696 +553 697 +553 946 +553 2077 +1636 197 +1636 1553 +1636 1672 +1636 2629 +1636 3033 +1636 3389 +1636 3390 +1636 3391 +1636 3392 +1636 3393 +2695 3 +2695 124 +2695 127 +2695 264 +2695 353 +2695 718 +2695 1245 +2695 1670 +2695 1878 +2695 1989 +4669 141 +4669 289 +4669 2227 +4669 2353 +4669 2625 +4669 3162 +4669 3562 +4669 5414 +4669 5415 +4669 5416 +557 124 +557 127 +557 147 +557 248 +557 251 +557 252 +557 390 +557 423 +557 558 +557 559 +760 38 +760 528 +760 536 +760 1688 +760 2026 +760 2152 +760 2517 +760 2687 +760 2688 +760 2689 +2710 163 +2710 464 +2710 919 +2710 2911 +2710 2948 +2710 3196 +2710 4272 +2710 4273 +2712 8 +2712 17 +2712 31 +2712 126 +2712 144 +2712 145 +2712 149 +2712 174 +2712 559 +2712 717 +928 2652 +1223 651 +1223 751 +1223 1800 +1223 1827 +1223 3156 +1223 3905 +1223 3981 +1223 5192 +1223 5311 +1223 5312 +2735 92 +2735 487 +2735 892 +2735 1718 +2735 2952 +2735 3163 +2735 3169 +2735 3471 +2735 4291 +2735 4292 +563 1575 +563 2582 +563 2583 +563 2584 +1325 731 +560 561 +560 562 +560 563 +560 564 +560 565 +560 566 +560 567 +560 568 +560 569 +560 570 +805 57 +805 106 +805 528 +805 637 +805 686 +805 769 +805 770 +805 1644 +805 2738 +805 2739 +811 643 +811 712 +811 965 +811 1151 +811 2176 +811 2729 +811 2730 +811 2731 +811 2732 +811 2733 +1356 48 +1356 270 +1356 281 +1356 472 +1356 1357 +1356 1358 +1356 1359 +1356 1360 +1356 1361 +4158 584 +4158 770 +4158 2229 +4158 3982 +4158 4739 +4158 4783 +4158 5099 +4158 5100 +4158 5101 +4158 5102 +4159 230 +4159 1425 +4159 2058 +4159 2869 +4159 3759 +4159 3786 +4159 4068 +4159 4270 +4159 5361 +4159 5788 +1318 756 +1318 1272 +1318 1273 +1318 1541 +1318 1955 +1318 2758 +1318 3159 +1318 3160 +1318 3161 +1318 3162 +1319 121 +1319 147 +1319 248 +1319 252 +1319 264 +1319 390 +1319 423 +1319 559 +1319 667 +1319 1245 +2773 557 +2773 583 +2773 810 +2773 832 +2773 1728 +2773 1866 +2773 2974 +2773 4304 +2773 4305 +720 4 +720 5 +720 8 +720 126 +720 145 +720 149 +720 353 +720 424 +720 2001 +720 2018 +5211 115 +5211 279 +5211 1597 +5211 2547 +5211 2594 +5211 3021 +5211 3912 +5211 4894 +5211 5121 +5211 5703 +5213 253 +5213 2330 +5213 2552 +5213 3883 +5213 5501 +5213 5705 +5213 5706 +5213 5707 +1832 604 +1832 1154 +1832 1408 +1832 1754 +1832 1888 +1832 1967 +1832 1984 +1832 1985 +1832 3583 +1832 3584 +4206 123 +4206 369 +4206 504 +4206 1442 +4206 1487 +4206 2060 +4206 3304 +4206 5146 +4206 5147 +4206 5148 +4402 190 +4402 3895 +4402 5220 +4402 5345 +4569 581 +4569 1026 +4569 2965 +4569 4455 +4569 4516 +4569 4821 +4569 4844 +4569 5359 +4569 5360 +4569 5361 +1258 145 +1258 149 +1258 177 +1258 247 +1258 699 +1258 856 +1258 1317 +1258 2063 +1258 3002 +1258 3118 +5881 6039 +724 152 +724 215 +724 725 +724 1313 +724 1424 +724 1434 +724 2443 +724 2653 +724 2654 +5726 4 +5726 9 +5726 17 +5726 126 +5726 149 +5726 175 +5726 422 +5726 559 +5726 754 +5727 1531 +5727 2241 +5727 2804 +5727 3334 +5727 5844 +5727 5947 +5727 5948 +5727 5949 +5727 5950 +5727 5951 +5729 586 +5729 898 +5729 2198 +5729 2227 +5729 2789 +5729 3275 +5729 4280 +5729 5756 +5729 5952 +5729 5953 +1612 1724 +1612 2222 +1612 3377 +1612 3378 +4263 11 +4263 20 +4263 1389 +4263 2628 +4263 2668 +4263 3080 +4263 3177 +4263 3945 +4263 4876 +4263 4980 +5600 4943 +2626 4227 +4157 5096 +2803 633 +2803 942 +2803 2095 +2803 2307 +2803 2327 +2803 2870 +2803 2927 +2803 3204 +2803 3808 +2803 4310 +1276 901 +1276 2075 +1276 2585 +1276 2874 +1276 3128 +1276 3153 +1276 3154 +1276 3155 +1276 3156 +1276 3157 +1278 412 +1278 1299 +1278 1947 +1278 1974 +1278 2035 +1278 2228 +1278 2547 +1278 3709 +1278 3841 +1278 5199 +1279 1227 +1279 1787 +1279 1993 +1279 2626 +1279 3017 +1279 3128 +1279 3129 +1279 3130 +1279 3131 +1279 3132 +1281 483 +1281 833 +1281 1431 +1281 1509 +1281 2034 +1281 2236 +1281 3133 +1281 3134 +1281 3135 +1281 3136 +1585 281 +1585 562 +1585 1586 +1585 1587 +1585 1588 +1585 1589 +1585 1590 +1585 1591 +1585 1592 +1585 1593 +3531 38 +3531 412 +3531 2266 +3531 2583 +3531 3441 +3531 3619 +3531 3671 +3531 3674 +3531 3868 +3531 4033 +1290 176 +1290 177 +1290 179 +1290 248 +1290 249 +1290 352 +1290 422 +1290 427 +1290 717 +1290 1317 +588 589 +588 590 +588 591 +588 592 +588 593 +588 594 +588 595 +588 596 +588 597 +588 598 +599 437 +599 564 +599 581 +599 600 +599 601 +599 602 +599 603 +599 604 +599 605 +599 606 +605 8 +605 121 +605 127 +605 147 +605 176 +605 238 +605 352 +605 353 +605 422 +605 424 +606 87 +606 820 +606 1040 +606 1097 +606 1439 +606 1644 +606 1730 +606 2555 +606 2556 +606 2557 +2962 823 +2962 1457 +2962 2397 +2962 2637 +2962 2873 +2962 2898 +2962 3127 +2962 3992 +2962 4443 +607 608 +607 609 +607 610 +607 611 +607 612 +607 613 +607 614 +607 615 +607 616 +608 2026 +610 881 +610 1217 +610 1392 +610 1990 +610 2273 +610 2558 +610 2559 +610 2560 +610 2561 +610 2562 +611 532 +611 586 +611 740 +611 808 +611 1500 +611 2265 +611 2480 +611 2543 +611 2544 +611 2545 +613 1631 +613 2337 +613 2453 +613 2546 +613 2547 +613 2548 +613 2549 +613 2550 +613 2551 +2559 43 +2559 788 +2559 2069 +2559 4170 +2559 4171 +2562 529 +2562 541 +2562 1787 +2562 1892 +2562 3280 +2562 3489 +2562 3779 +2562 4182 +2562 4183 +2562 4184 +2544 8 +2544 282 +2544 837 +2544 1048 +2544 2086 +2544 3032 +2544 4163 +2544 4164 +2544 4165 +2548 17 +2548 146 +2548 175 +2548 266 +2548 423 +2548 558 +2548 559 +2548 667 +2548 697 +2548 1245 +2549 5 +2549 126 +2549 148 +2549 149 +2549 179 +2549 180 +2549 266 +2549 754 +2549 1245 +2549 2018 +2550 2163 +4183 463 +4183 1235 +4183 2500 +4183 2823 +4183 4321 +4183 5109 +4183 5110 +4183 5111 +4183 5112 +4183 5113 +1255 148 +1255 150 +1255 179 +1255 352 +1255 390 +1255 906 +1255 1317 +1255 3115 +1255 3116 +1255 3117 +1557 367 +1557 562 +1557 931 +1557 943 +1557 1122 +1557 1177 +1557 1558 +1557 1559 +1557 1560 +1557 1561 +2663 107 +2663 325 +2663 1412 +2663 1504 +2663 2862 +2663 3204 +2663 3292 +2663 4247 +2663 4248 +2663 4249 +3032 125 +3032 128 +3032 148 +3032 248 +3032 353 +3032 424 +3032 559 +3032 1317 +3032 2001 +4164 8 +4164 121 +4164 127 +4164 146 +4164 177 +4164 353 +4164 369 +4164 422 +4164 427 +4164 717 +617 618 +617 619 +617 620 +617 621 +617 622 +617 623 +617 624 +617 625 +617 626 +617 627 +620 396 +620 409 +620 469 +620 534 +620 1583 +620 2272 +620 2385 +620 2552 +620 2553 +620 2554 +1400 326 +1400 657 +1400 922 +1400 3262 +1400 3263 +1400 3264 +1400 3265 +1400 3266 +1400 3267 +1400 3268 +4167 1026 +4167 1898 +4167 2784 +4167 2826 +4167 2886 +4167 3001 +4167 3220 +4167 3858 +4167 4102 +4167 5104 +4635 443 +4635 664 +4635 828 +4635 942 +4635 2772 +4635 4066 +4635 4333 +4635 4439 +4635 5396 +1546 1547 +1546 1548 +1546 1549 +1546 1550 +1546 1551 +1546 1552 +1546 1553 +1546 1554 +1546 1555 +1546 1556 +3266 651 +3266 1935 +3266 2032 +3266 2724 +3266 2948 +3266 3066 +3266 4638 +3266 4639 +3295 925 +3295 1387 +3295 1451 +3295 1587 +3295 2322 +3295 2430 +3295 2790 +3295 3586 +3295 4288 +3295 4663 +3297 921 +631 15 +631 632 +631 633 +631 634 +631 635 +634 308 +634 503 +634 717 +634 2941 +634 2968 +634 3112 +634 5880 +634 6131 +634 6132 +634 6133 +635 367 +635 404 +635 474 +635 668 +635 746 +635 747 +635 748 +635 749 +635 750 +635 751 +6132 3 +6132 125 +6132 176 +6132 249 +6132 251 +6132 353 +6132 559 +6132 754 +6132 1317 +6132 3371 +3371 265 +3371 385 +3371 4707 +3371 4708 +1417 8 +1417 121 +1417 122 +1417 123 +1417 127 +1417 147 +1417 177 +1417 246 +1417 251 +1417 353 +2676 63 +636 475 +636 507 +636 637 +636 638 +636 639 +636 640 +636 641 +636 642 +636 643 +1367 3218 +644 645 +645 330 +645 2223 +645 2430 +645 2563 +645 2564 +647 216 +647 585 +647 648 +647 649 +647 650 +647 651 +647 652 +647 653 +647 654 +647 655 +654 798 +654 1023 +654 1365 +654 2475 +654 2516 +654 2559 +654 2568 +654 2569 +654 2570 +654 2571 +655 1032 +655 1246 +655 1378 +655 1411 +655 1836 +655 1999 +655 2200 +655 2565 +655 2566 +655 2567 +2575 484 +2575 548 +2575 568 +2575 690 +2575 756 +2575 872 +2575 1025 +2575 2897 +2575 4173 +2575 4174 +1411 558 +1411 576 +1411 1412 +1411 1413 +1411 1414 +1411 1415 +1411 1416 +1411 1417 +1411 1418 +3192 2 +3192 8 +3192 248 +3192 390 +3192 554 +3192 697 +3192 946 +3192 1317 +3192 2001 +3192 2077 +3194 4587 +4174 8 +4174 122 +4174 143 +4174 146 +4174 174 +4174 196 +4174 352 +4174 353 +4174 369 +4174 424 +3210 691 +3210 2055 +3210 2691 +3210 2935 +3210 3221 +3210 4594 +3210 4595 +3210 4596 +3210 4597 +3210 4598 +1289 1043 +1289 1916 +1289 2944 +1289 2966 +1289 3142 +1289 3143 +1289 3144 +1289 3145 +1289 3146 +1413 1171 +1413 2575 +1413 2582 +1413 2640 +1413 2672 +1413 2828 +1413 2960 +1413 3035 +1413 3269 +1413 3270 +656 514 +656 568 +656 657 +656 658 +656 659 +656 660 +656 661 +656 662 +656 663 +656 664 +1086 152 +1086 219 +1086 424 +1086 1457 +1086 1824 +1086 2124 +1086 2984 +1086 2985 +1086 2986 +1714 824 +1714 1034 +1714 1037 +1714 1715 +1714 1716 +1714 1717 +1714 1718 +1714 1719 +1714 1720 +1714 1721 +1871 3491 +1872 356 +1872 458 +1872 1209 +1872 2383 +1872 3539 +1872 3619 +1872 3620 +1872 3621 +1872 3622 +1872 3623 +4175 5209 +4176 2205 +4176 2222 +4176 3318 +4176 3418 +4176 3563 +4176 4006 +4176 5494 +4176 5814 +4176 5815 +4179 3 +4179 123 +4179 127 +4179 144 +4179 145 +4179 238 +4179 251 +4179 352 +4179 369 +4179 2338 +3405 732 +3405 1947 +3405 2751 +3405 3232 +3405 3237 +3405 4223 +3405 4735 +3405 4736 +3405 4737 +3405 4738 +3616 321 +3616 699 +3616 3115 +3616 3934 +3616 4858 +3616 4859 +3616 4860 +3616 4861 +3616 4862 +3616 4863 +4222 156 +4222 582 +4222 726 +4222 892 +4222 894 +4222 904 +4222 1203 +4222 1559 +4222 1670 +4222 2536 +4203 875 +4203 1675 +4203 4118 +4203 4277 +4203 4917 +4203 5129 +4203 5130 +4204 202 +4204 989 +4204 2337 +4204 3367 +4204 3931 +4204 4248 +4204 5047 +4204 5131 +4204 5132 +680 144 +680 145 +680 251 +680 630 +680 1841 +680 1842 +680 1843 +680 1844 +680 1845 +680 1846 +682 309 +682 690 +682 712 +682 851 +682 1337 +682 1347 +682 2411 +682 2585 +682 2586 +1843 567 +1843 892 +1843 1021 +1843 2033 +1843 2853 +1843 3307 +1843 3573 +1843 3574 +1843 3575 +1843 3576 +1844 50 +1844 586 +1844 1064 +1844 1528 +1844 2221 +1844 3585 +1844 3586 +1844 3587 +1844 3588 +1844 3589 +2589 4185 +2590 57 +2590 1376 +2590 2248 +2590 4186 +2591 1162 +2591 2463 +2591 3677 +2591 4082 +2591 4083 +2591 4133 +2591 4187 +2591 4188 +2591 4189 +3573 184 +3573 412 +3573 725 +3573 2119 +3573 2461 +3573 3602 +3573 4382 +3573 4445 +3573 4834 +3573 4835 +3575 1842 +3587 94 +3587 352 +3587 2628 +3587 3109 +3587 3469 +3587 4141 +3587 4170 +3587 4455 +3587 4784 +3587 4844 +3588 4813 +4187 31 +4187 144 +4187 145 +4187 146 +4187 149 +4187 180 +4187 266 +4187 423 +4187 856 +4187 1317 +4189 107 +4189 298 +4189 1396 +4189 1718 +4189 1890 +4189 3543 +4189 4094 +4189 5118 +4189 5119 +4189 5120 +689 609 +689 690 +689 691 +689 692 +689 693 +4205 1501 +4208 252 +4208 1068 +4208 2564 +4208 3620 +4208 4071 +4208 5022 +4208 5133 +4208 5134 +4208 5135 +4208 5136 +699 529 +699 693 +699 1027 +699 1653 +699 1702 +699 2289 +699 2546 +699 2611 +699 2612 +699 2613 +2611 1956 +4191 370 +4191 432 +4191 495 +4191 503 +4191 2537 +4191 3004 +4191 3808 +4191 4293 +4191 4617 +4191 5121 +4193 365 +4193 787 +4193 995 +4193 1447 +4193 2601 +4193 2746 +4193 3499 +4193 3840 +4193 3896 +4193 4332 +4194 180 +4194 870 +4194 2432 +4194 3328 +4194 4589 +4196 127 +4196 248 +4196 423 +4196 559 +4196 667 +4196 717 +4196 856 +4196 1041 +4196 4638 +4196 5122 +4198 345 +4198 1318 +4198 1424 +4198 1814 +4198 3033 +4198 3205 +4198 4035 +4198 4960 +4198 5123 +3364 135 +3364 840 +3364 968 +3364 1740 +3364 1741 +3364 3132 +3364 3334 +3364 4705 +3364 4706 +3607 852 +3607 1457 +3607 2752 +3607 2820 +3607 4866 +3033 1476 +3033 1894 +3033 2361 +3033 2532 +3033 3173 +3033 3806 +3033 3833 +3033 3918 +3033 4464 +3033 4465 +4200 429 +4200 432 +4200 1288 +4200 1564 +4200 1573 +4200 1652 +4200 2202 +4200 3813 +1750 158 +1750 231 +1750 1216 +1750 1217 +1750 1424 +1750 1717 +1750 2385 +1750 3510 +1750 3511 +1750 3512 +2952 1374 +2952 1507 +2952 2035 +2952 2916 +2952 2953 +2952 3017 +2952 3134 +2952 3629 +2952 4422 +2952 4423 +3403 7 +3403 123 +3403 125 +3403 144 +3403 149 +3403 248 +3403 251 +3403 367 +3403 424 +3403 1317 +4211 4 +4211 10 +4211 122 +4211 251 +4211 265 +4211 369 +4211 426 +4211 427 +4211 698 +4211 946 +4213 477 +4213 579 +4213 856 +4213 1824 +4213 2214 +4213 2366 +4213 2463 +4213 4293 +4213 4894 +4213 5140 +4215 532 +4215 620 +4215 1067 +4215 1089 +4215 1799 +4215 3526 +4215 3682 +4215 4583 +4215 5149 +4216 11 +4216 325 +4216 649 +4216 1300 +4216 1592 +4216 2475 +4216 2928 +4216 4166 +4216 5141 +4216 5142 +4217 5 +4217 265 +4217 823 +4217 1947 +4217 4711 +4217 4712 +4217 4861 +4217 5143 +4217 5144 +4217 5145 +4220 143 +4220 146 +4220 248 +4220 249 +4220 367 +4220 390 +4220 423 +4220 427 +4220 717 +4220 1245 +3558 307 +3558 690 +3558 983 +3558 1367 +3558 3266 +3558 3737 +3558 3856 +3558 4686 +3558 4827 +701 118 +701 499 +701 506 +701 702 +701 703 +701 704 +701 705 +701 706 +701 707 +701 708 +704 612 +704 702 +704 851 +704 1531 +704 1539 +704 2621 +704 2622 +704 2623 +704 2624 +705 226 +705 352 +705 1594 +705 1600 +705 1641 +705 2625 +705 2626 +705 2627 +705 2628 +705 2629 +2622 889 +2622 892 +2622 1824 +2622 2193 +2622 2194 +2622 3076 +2622 3244 +2622 3999 +2622 4225 +2622 4226 +1594 1595 +1600 127 +1600 248 +1600 264 +1600 367 +1600 390 +1600 422 +1600 423 +1600 559 +1600 666 +1600 667 +1641 604 +1641 1077 +1641 1097 +1641 1642 +1641 1643 +1641 1644 +1641 1645 +1641 1646 +1641 1647 +2627 9 +2627 144 +2627 146 +2627 148 +2627 149 +2627 175 +2627 264 +2627 390 +2627 1245 +2629 127 +2629 128 +2629 129 +2629 176 +2629 229 +2629 353 +2629 1317 +2629 2115 +2629 3102 +2629 4228 +1107 998 +2642 813 +2642 4315 +3409 288 +3409 325 +3409 707 +3409 1120 +3409 1211 +3409 1904 +3409 3439 +3409 3849 +3409 4369 +3409 4754 +1265 2377 +1584 1036 +1602 121 +1602 122 +1602 123 +1602 143 +1602 246 +1602 247 +1602 249 +1602 264 +1602 352 +1602 1245 +4239 2184 +4230 781 +4230 1106 +4230 3119 +4230 3344 +4230 3683 +4230 4156 +4230 5000 +4230 5151 +4230 5152 +4230 5153 +4232 962 +4232 2338 +4232 2361 +4232 2885 +4232 5053 +4234 146 +4234 177 +4234 238 +4234 264 +4234 352 +4234 424 +4234 427 +4234 2098 +4235 1516 +4235 1698 +4235 1786 +4235 1804 +4235 2218 +4235 2400 +4235 3129 +4235 3362 +4235 3473 +4235 5154 +3244 120 +3244 257 +3244 456 +3244 872 +3244 1492 +3244 1651 +3244 1758 +3244 4626 +3244 4627 +3244 4628 +4227 123 +4227 127 +4227 176 +4227 238 +4227 367 +4227 422 +4227 427 +4227 667 +4227 717 +4227 2338 +4228 20 +4228 179 +4228 238 +4228 346 +4228 347 +4228 2337 +4228 3229 +4228 3480 +4228 4132 +4228 5150 +709 200 +709 205 +709 541 +709 552 +709 710 +709 711 +709 712 +709 713 +709 714 +709 715 +1544 3337 +1544 3338 +1544 3339 +1544 3340 +4236 1505 +4236 1645 +4236 5105 +4236 5155 +4236 5156 +716 124 +716 128 +716 174 +716 176 +716 177 +716 179 +716 353 +716 390 +716 717 +716 718 +719 479 +719 720 +719 721 +719 722 +719 723 +719 724 +719 725 +719 726 +719 727 +1434 78 +1434 309 +1434 762 +1434 891 +1434 1019 +1434 1317 +1434 1435 +1434 1436 +1434 1437 +1434 1438 +3284 452 +3284 453 +3284 1688 +3284 2354 +3284 2653 +3284 3408 +3284 4288 +3284 4654 +3284 4655 +3284 4656 +3285 17 +3285 1768 +3285 1827 +3285 1972 +3285 2244 +3285 3047 +3285 5638 +3285 6036 +3285 6037 +3285 6038 +1438 173 +1438 202 +1438 222 +1438 685 +1438 1421 +1438 1534 +1438 3291 +1438 3292 +1438 3293 +1438 3294 +5417 892 +5417 1107 +5417 1330 +5417 1617 +5417 1757 +5417 2112 +5417 3926 +5417 5415 +5417 5812 +5417 5813 +5418 7 +5418 124 +5418 144 +5418 146 +5418 148 +5418 266 +5418 698 +5418 754 +5418 1297 +5418 2803 +836 837 +836 838 +836 839 +836 840 +836 841 +836 842 +836 843 +836 844 +836 845 +2660 1840 +4244 904 +4244 918 +4244 986 +4244 1157 +4244 1547 +4244 3006 +4244 4628 +4244 4966 +4244 5157 +4244 5158 +2922 178 +2922 252 +2922 264 +2922 367 +2922 390 +2922 422 +2922 423 +2922 559 +2922 754 +2922 2001 +3259 1090 +3259 2049 +3259 2050 +3259 2566 +3259 3014 +3259 3815 +3259 4282 +3259 4633 +3259 4634 +3259 4635 +3411 440 +3411 793 +3411 892 +3411 1120 +3411 1439 +3411 1507 +3411 2769 +3411 4750 +3411 4751 +4914 125 +4914 498 +4914 1211 +4914 2798 +4914 3249 +4914 3819 +4914 4006 +4914 4474 +4914 5566 +4914 5567 +728 45 +728 89 +728 298 +728 729 +728 730 +728 731 +728 732 +728 733 +728 734 +728 735 +731 649 +731 982 +731 1156 +731 1258 +731 2053 +731 2176 +731 2655 +731 2656 +731 2657 +731 2658 +734 623 +734 893 +734 1412 +734 1734 +734 2015 +734 2582 +734 2631 +734 2684 +734 2685 +734 2686 +4242 407 +4242 651 +4242 1194 +4242 1369 +4242 1575 +4242 3250 +4242 3491 +4242 4072 +4242 4603 +4242 5161 +2659 945 +2659 1489 +2659 2086 +2659 2411 +2659 2982 +2659 3684 +2659 4245 +2659 4246 +1380 41 +1380 385 +1380 1437 +1380 1899 +1380 2054 +1380 2272 +1380 3076 +1380 3156 +1380 3235 +1380 3236 +2679 10 +2679 148 +2679 265 +2679 369 +2679 427 +2679 698 +2679 754 +2679 947 +2679 2064 +2679 4257 +2680 1466 +2680 1685 +2680 2881 +2680 3023 +2680 3207 +2680 3247 +2680 4095 +2680 4237 +2680 4256 +2682 4173 +2683 152 +2683 1695 +2683 2354 +2683 2385 +2683 3109 +2683 3343 +2683 3710 +2683 3879 +2683 3981 +2683 4170 +4245 437 +4245 481 +4245 505 +4245 870 +4245 1137 +4245 1741 +4245 1780 +4245 2114 +4245 2535 +4245 4166 +4246 496 +4246 1224 +4246 2058 +4246 2068 +4246 2744 +4246 3117 +4246 3133 +4246 3277 +4246 5159 +4246 5160 +3236 17 +3236 145 +3236 175 +3236 179 +3236 180 +3236 424 +3236 717 +3236 736 +3236 754 +3236 2001 +5154 49 +5154 803 +5154 1219 +5154 1255 +5154 2285 +5154 3017 +5154 3133 +5154 5023 +5154 5463 +5154 5670 +5807 648 +5807 1845 +5807 2264 +5807 3205 +5807 4170 +5807 5403 +5807 5992 +5807 5997 +5807 5998 +5807 5999 +3115 262 +3115 1100 +3115 1415 +3115 1845 +3115 1889 +3115 2113 +3115 3699 +3115 4539 +3115 4540 +3115 4541 +3117 308 +3117 860 +3117 1376 +3117 1457 +3117 1767 +3117 2305 +3117 2419 +3117 2712 +3117 2898 +3117 4545 +1559 144 +1559 145 +1559 147 +1559 251 +1559 252 +1559 264 +1559 266 +1559 368 +1559 667 +1209 325 +1209 583 +1209 1210 +1209 1211 +1209 1212 +1209 1213 +1209 1214 +1209 1215 +1209 1216 +1209 1217 +1442 575 +4279 5 +4279 121 +4279 125 +4279 129 +4279 148 +4279 174 +4279 176 +4279 369 +4279 424 +4279 717 +4280 464 +4280 759 +4280 828 +4280 2709 +4280 2948 +4280 3081 +4280 3859 +4280 4133 +4280 4584 +4280 5181 +3441 803 +3441 1750 +3441 2299 +3441 2646 +3441 3024 +3441 3439 +3441 3440 +3441 3654 +3441 4838 +3441 4839 +3441 4840 +3441 4841 +3441 4842 +3441 4843 +3613 944 +3613 2269 +3613 2621 +3613 3412 +3613 3904 +3613 4553 +3613 4856 +3613 4857 +4285 92 +4285 158 +4285 1645 +4285 1815 +4285 1929 +4285 3551 +4285 4007 +4285 4081 +4285 5183 +4285 5184 +4285 5185 +4285 5186 +4285 5187 +4285 5188 +4285 5189 +4285 5190 +4285 5191 +2828 113 +2828 256 +2828 518 +2828 2196 +2828 2322 +2828 2992 +2828 3963 +2828 4124 +2828 4325 +4252 115 +4252 760 +4252 1672 +4252 1838 +4252 1955 +4252 2690 +4252 4301 +4252 4961 +4252 4976 +4253 5169 +4255 1146 +4255 1635 +4255 2694 +4255 2936 +4255 3181 +4255 3813 +4255 4578 +4255 5166 +4255 5167 +4255 5168 +4257 9 +4257 123 +4257 126 +4257 145 +4257 148 +4257 149 +4257 248 +4257 369 +4257 1245 +4257 1317 +3207 54 +3207 219 +3207 318 +3207 554 +3207 883 +3207 1935 +3207 3209 +3207 3995 +3207 4591 +3247 321 +3247 452 +3247 453 +3247 531 +3247 736 +3247 1947 +3247 2035 +3247 2689 +3247 3095 +3247 4625 +4256 2613 +2885 129 +2885 176 +2885 177 +2885 180 +2885 266 +2885 368 +2885 390 +2885 427 +2885 667 +2885 856 +752 5 +752 180 +752 247 +752 250 +752 351 +752 426 +752 554 +752 753 +752 754 +752 755 +2698 470 +2698 802 +2698 928 +2698 958 +2698 1067 +2698 1590 +2698 3995 +2698 4137 +2698 4270 +2698 4271 +2694 3363 +1717 257 +1717 541 +1717 852 +1717 1441 +1717 1702 +1717 2356 +1717 2553 +1717 3484 +1717 3485 +1717 3486 +1493 1227 +2823 1089 +2823 1915 +2823 2021 +2823 2884 +2823 3119 +2823 4165 +2823 4321 +2823 4322 +2823 4323 +2823 4324 +4260 3 +4260 9 +4260 123 +4260 124 +4260 149 +4260 238 +4260 249 +4260 352 +4260 367 +4260 369 +4264 1157 +3363 990 +3363 2444 +3363 2689 +3363 3293 +3363 4221 +3363 4700 +3363 4701 +3363 4702 +3363 4703 +3363 4704 +4269 4797 +1444 5490 +1444 5491 +3258 124 +3258 127 +3258 128 +3258 143 +3258 147 +3258 247 +3258 251 +3258 266 +3258 369 +3258 1245 +3260 1212 +3260 1830 +3260 1845 +3260 1936 +3260 2108 +3260 2470 +3260 2563 +3260 2729 +3260 3601 +3526 3 +3526 8 +3526 121 +3526 122 +3526 123 +3526 129 +3526 367 +3526 422 +3526 424 +3526 667 +4389 208 +4389 1173 +4389 1362 +4389 4164 +4389 5248 +4389 5249 +4390 339 +4390 527 +4390 1339 +4390 2066 +4390 2839 +4390 2973 +4390 3524 +4390 3661 +4390 4723 +4390 5250 +4391 1894 +775 776 +1310 9 +1310 122 +1310 123 +1310 124 +1310 128 +1310 179 +1310 367 +1310 369 +1310 427 +1310 1317 +4274 164 +4274 230 +4274 424 +4274 2017 +4274 2148 +4274 2787 +4274 3523 +4274 3988 +4274 4813 +4274 5178 +4276 5 +4276 7 +4276 125 +4276 126 +4276 147 +4276 149 +4276 175 +4276 266 +4276 667 +4276 754 +4277 227 +4277 1698 +4277 1787 +4277 2115 +4277 3058 +4277 4026 +4277 4275 +4277 5179 +4277 5180 +787 276 +787 788 +787 789 +787 790 +787 791 +787 792 +787 793 +787 794 +787 795 +787 796 +797 289 +797 420 +797 460 +797 463 +797 798 +797 799 +797 800 +797 801 +797 802 +797 803 +801 940 +801 1866 +801 1867 +801 2036 +801 2200 +801 2724 +801 2725 +801 2726 +801 2727 +801 2728 +3676 102 +3676 327 +3676 551 +3676 707 +3676 825 +3676 979 +3676 1010 +3676 1115 +3676 3423 +3676 4295 +3615 155 +3615 2324 +3615 2502 +3615 2504 +3615 3345 +3615 4145 +3615 4864 +3615 4865 +2732 227 +2732 717 +2732 1735 +2732 1749 +2732 1862 +2732 2497 +2732 3009 +2732 4293 +2732 4294 +2732 4295 +4695 131 +4695 190 +4695 697 +4695 942 +4695 1730 +4695 1922 +4695 2423 +4695 5189 +4695 5428 +4695 5429 +5224 391 +5224 717 +5224 1542 +5224 1787 +5224 1881 +5224 2892 +5224 4490 +5224 4741 +5224 5720 +5629 92 +5629 133 +5629 177 +5629 731 +5629 2443 +5629 2779 +5629 4111 +5629 4646 +5629 5775 +1735 103 +1735 298 +1735 982 +1735 1332 +1735 1736 +1735 1737 +1735 1738 +1735 1739 +1735 1740 +1735 1741 +1862 748 +1862 1377 +1862 3799 +1862 3800 +1862 3801 +1862 3802 +1862 3803 +1862 3804 +1862 3805 +1862 3806 +3009 17 +3009 144 +3009 175 +3009 1245 +3009 1317 +3009 1667 +3009 2018 +3009 2627 +3009 4457 +4293 54 +4293 2253 +4293 4062 +4293 4636 +4293 5193 +4293 5194 +4293 5195 +4293 5196 +4293 5197 +4293 5198 +4295 96 +4295 346 +4295 509 +4295 1632 +4295 1942 +4295 2175 +4295 3292 +4295 4032 +4295 4286 +4295 4533 +5429 651 +5429 1534 +5429 1720 +5429 2690 +5429 4306 +5429 4439 +5429 4961 +5429 5040 +5429 5827 +5429 5828 +4490 810 +4490 981 +4490 1199 +4490 1297 +4490 1342 +4490 1607 +4490 1608 +4490 1867 +4490 3617 +4490 5320 +4741 1658 +4741 1974 +4741 2358 +4741 3127 +4741 3224 +4741 3860 +4741 4303 +4741 4306 +4741 5459 +4741 5460 +5720 5890 +2779 7 +2779 124 +2779 125 +2779 144 +2779 148 +2779 149 +2779 248 +2779 249 +2779 251 +2779 367 +5775 376 +5775 710 +5775 779 +5775 1122 +5775 1272 +5775 1375 +5775 2015 +5775 2422 +5775 2634 +5775 3335 +5775 4316 +5775 5850 +5775 5879 +5775 6008 +5775 6009 +5775 6010 +5775 6011 +5312 5278 +4291 5017 +4292 103 +4292 1061 +4292 1425 +4292 1827 +4292 1923 +4292 2480 +4292 3021 +4292 3055 +4292 4075 +4292 5192 +1039 1176 +1039 1651 +1039 1956 +1039 2271 +1039 2787 +1039 2955 +1039 2956 +1039 2957 +1039 2958 +3200 924 +3200 1517 +3200 2773 +3200 2916 +3200 2943 +3200 3516 +3200 4289 +3200 4478 +3200 4585 +3200 4586 +3174 262 +3174 344 +3174 2613 +3174 2994 +3174 4571 +887 1671 +887 1688 +887 1786 +887 1805 +887 2361 +887 2662 +887 2775 +887 2776 +887 2777 +887 2778 +845 127 +845 144 +845 145 +845 176 +845 177 +845 247 +845 265 +845 630 +845 698 +845 762 +941 6087 +4300 11 +4300 133 +4300 1492 +4300 2119 +4300 2479 +4300 3699 +4300 5202 +4300 5203 +4300 5204 +4301 165 +4301 1800 +4301 1868 +4301 2324 +4301 3462 +1707 1956 +1707 2246 +1707 2465 +1707 3477 +1707 3478 +1707 3479 +1707 3480 +1707 3481 +1707 3482 +1707 3483 +3478 1539 +3479 572 +3479 1085 +3479 1456 +3479 3015 +3479 3392 +3479 3634 +3479 3781 +3479 4405 +3479 4780 +3480 341 +3480 343 +3480 347 +3480 2306 +3480 2307 +3480 2337 +3480 3343 +3480 4170 +3480 4628 +3480 4663 +868 732 +868 1145 +868 1146 +868 1147 +868 1148 +868 1149 +868 1150 +868 1151 +868 1152 +868 1153 +2770 5 +2770 8 +2770 123 +2770 145 +2770 148 +2770 238 +2770 353 +2770 424 +2770 427 +2770 2338 +1146 2430 +1146 3180 +4297 4 +4297 9 +4297 125 +4297 143 +4297 145 +4297 148 +4297 264 +4297 368 +4297 1317 +3176 3 +3176 8 +3176 127 +3176 129 +3176 146 +3176 176 +3176 246 +3176 426 +3176 1245 +3176 2098 +4303 31 +4303 121 +4303 124 +4303 148 +4303 177 +4303 180 +4303 352 +4303 427 +4303 736 +4303 2001 +4405 3 +4405 124 +4405 177 +4405 249 +4405 251 +4405 252 +4405 264 +4405 368 +4405 559 +4405 2018 +4304 5157 +2777 1103 +2777 3292 +2777 5452 +2777 6039 +2777 6279 +5452 8 +5452 122 +5452 126 +5452 145 +5452 149 +5452 174 +5452 179 +5452 424 +5452 427 +5452 1317 +6039 202 +6039 503 +6039 810 +6039 814 +6039 1915 +6039 2149 +6039 2719 +6039 2755 +6039 2978 +6039 3275 +6039 3293 +6039 3325 +6039 3488 +6039 5049 +6039 5395 +6039 5554 +6039 5816 +6039 5888 +6039 5952 +6039 5966 +6039 6022 +6039 6157 +6039 6158 +6039 6159 +6039 6160 +6039 6161 +6039 6162 +6039 6163 +6039 6164 +6039 6165 +6039 6166 +6279 115 +6279 1845 +6279 5529 +6279 5970 +6279 6011 +6279 6284 +6279 6285 +6279 6286 +6279 6287 +6279 6288 +4433 8 +4433 1345 +4433 1890 +4433 3362 +4433 3677 +4434 352 +4434 777 +4434 926 +4434 2086 +4434 3932 +4434 3983 +4434 4757 +4434 4980 +4434 5273 +4434 5274 +896 563 +896 897 +896 898 +896 899 +896 900 +896 901 +896 902 +896 903 +896 904 +896 905 +902 1272 +902 2409 +902 2626 +902 2663 +902 2779 +902 2780 +902 2781 +902 2782 +902 2783 +902 2784 +904 492 +904 749 +904 1790 +904 2737 +904 2791 +904 2792 +904 2793 +904 2794 +904 2795 +904 2796 +2781 1980 +4306 4 +4306 143 +4306 175 +4306 249 +4306 251 +4306 264 +4306 369 +4306 422 +4306 856 +3276 5 +3276 8 +3276 31 +3276 149 +3276 176 +3276 352 +3276 353 +3276 558 +3276 754 +4312 280 +4312 492 +4312 704 +4312 1084 +4312 1862 +4312 2847 +4312 3717 +4312 5206 +4312 5207 +4312 5208 +4317 1511 +1134 164 +3304 125 +3304 174 +3304 180 +3304 252 +3304 264 +3304 266 +3304 368 +3304 390 +3304 422 +3304 559 +4308 1299 +4308 1533 +4308 1609 +4308 1872 +4308 1926 +4308 1955 +4308 3455 +4308 4078 +4308 4485 +4308 5205 +2821 73 +2821 176 +2821 353 +2821 354 +2821 367 +2821 667 +2821 823 +2821 1091 +2821 1267 +2821 4320 +2822 3 +2822 4 +2822 7 +2822 144 +2822 183 +2822 264 +2822 265 +2822 266 +2822 423 +2822 667 +1091 95 +1091 309 +1091 434 +1091 909 +1091 1092 +1091 1093 +1091 1094 +1091 1095 +1091 1096 +1091 1097 +4324 92 +4324 315 +4324 2200 +4324 3095 +4324 3136 +4324 3843 +4324 4721 +4324 5214 +4324 5215 +4324 5216 +929 335 +929 930 +929 931 +929 932 +929 933 +929 934 +929 935 +929 936 +929 937 +948 31 +948 862 +948 949 +948 950 +948 951 +949 1028 +949 1661 +949 2697 +949 2829 +949 2830 +949 2831 +949 2832 +949 2833 +949 2834 +949 2835 +950 870 +950 1570 +950 1631 +950 1747 +950 2793 +950 2824 +950 2825 +950 2826 +950 2827 +950 2828 +2829 43 +2829 122 +2829 123 +2829 251 +2829 423 +2829 1228 +2829 1245 +2829 1679 +2829 1721 +2829 4334 +2831 133 +2831 397 +2831 398 +2831 982 +2831 3221 +2831 3981 +2831 4326 +2831 4327 +2831 4328 +2831 4329 +2835 815 +2835 1197 +2835 1234 +2835 2821 +2835 3351 +2835 4191 +2835 4330 +2835 4331 +2835 4332 +2835 4333 +2826 249 +2826 1400 +2826 2287 +2826 2541 +2826 2558 +2826 2923 +2826 4336 +2826 5277 +2826 5516 +2826 5517 +1721 211 +1721 706 +1721 1104 +1721 2127 +1721 2373 +1721 2430 +1721 2720 +1721 3006 +1721 3476 +4334 57 +4334 3756 +4334 4036 +4334 4242 +4334 4397 +4334 4684 +4334 4814 +4334 5116 +4334 5220 +4334 5221 +4330 31 +4330 126 +4330 146 +4330 148 +4330 174 +4330 250 +4330 559 +4330 856 +4330 1245 +4330 3779 +4332 435 +4332 1219 +4332 2006 +4332 2042 +4332 2197 +4332 2776 +4332 3329 +4332 5217 +4332 5218 +4332 5219 +4336 4491 +5277 25 +5277 228 +5277 1227 +5277 3096 +5277 5758 +2992 928 +2992 1054 +2992 2906 +2992 2995 +2992 3681 +2992 4438 +2992 4439 +2992 4440 +2992 4441 +2992 4442 +952 749 +952 796 +952 953 +952 954 +952 955 +952 956 +952 957 +952 958 +952 959 +952 960 +956 2836 +4892 212 +4892 458 +4892 2272 +4892 3054 +4892 3931 +4892 4074 +4892 4563 +4892 5554 +4892 5555 +4973 140 +4973 350 +4973 1066 +4973 3417 +4973 4324 +4973 4501 +4973 4752 +4973 5310 +4973 5463 +4973 5521 +1167 274 +1167 1168 +1167 1169 +1167 1170 +1167 1171 +4752 2 +4752 5 +4752 8 +4752 174 +4752 699 +4752 753 +4752 762 +4752 946 +4752 2063 +4752 4257 +961 8 +961 262 +961 280 +961 560 +961 962 +961 963 +961 964 +961 965 +961 966 +961 967 +964 364 +964 697 +964 2213 +964 2844 +964 2845 +964 2846 +964 2847 +964 2848 +964 2849 +964 2850 +1124 360 +1124 1061 +1124 1064 +1124 1125 +1124 1126 +1124 1127 +1124 1128 +1124 1129 +1124 1130 +1124 1131 +1124 1132 +1124 1133 +1666 325 +1666 633 +1666 1339 +1666 2275 +1666 3228 +1666 3385 +1666 4109 +1666 4499 +1666 4803 +3535 32 +1126 3147 +1126 3148 +1130 2938 +1133 3158 +4344 684 +4344 1943 +4344 3861 +4344 4766 +4344 4973 +4344 5226 +4344 5227 +4344 5228 +4344 5229 +4344 5230 +4353 4 +4353 5 +4353 123 +4353 125 +4353 126 +4353 144 +4353 177 +4353 180 +4353 754 +4353 1317 +4355 202 +4355 472 +4355 867 +4355 1213 +4355 1929 +4355 4081 +4355 5185 +4355 5186 +4355 5240 +4355 5241 +4343 169 +4343 1050 +4343 1317 +4343 1437 +4343 3223 +4343 3362 +4343 4731 +4343 5200 +4343 5231 +3327 124 +3327 151 +3327 368 +3327 424 +3327 1317 +3327 1903 +3327 2086 +3327 3243 +3327 3994 +3327 4368 +4358 124 +4358 250 +4358 264 +4358 266 +4358 368 +4358 423 +4358 427 +4358 559 +4358 2018 +4359 113 +4359 190 +4359 363 +4359 1056 +4359 1805 +4359 2984 +4359 3275 +4359 4018 +4359 4589 +4359 5004 +4356 2927 +4356 3376 +4356 3916 +4356 4940 +4356 5323 +2864 352 +4337 165 +4337 1787 +4337 2539 +4337 4895 +4337 5222 +4338 56 +4338 363 +4338 432 +4338 554 +4338 1859 +4338 3608 +4338 4143 +4338 4151 +4338 4929 +4338 5225 +4340 1255 +4340 1300 +4340 1591 +4340 1792 +4340 2112 +4340 2164 +4340 3893 +4340 5141 +4340 5223 +4340 5224 +2879 5 +2879 31 +2879 125 +2879 126 +2879 148 +2879 175 +2879 179 +2879 238 +2879 353 +2879 558 +2883 337 +2883 409 +2883 1289 +2883 1473 +2883 2321 +2883 2744 +2883 3565 +2883 4365 +2883 4366 +2883 4367 +4360 381 +4360 1239 +4360 2568 +4360 3212 +4360 3566 +4360 4828 +4360 5232 +4360 5233 +4360 5234 +4362 437 +4362 906 +4362 2779 +4362 3687 +4362 3886 +4362 4286 +4362 5242 +4362 5243 +4362 5244 +4362 5245 +3160 2734 +3160 3138 +3160 4510 +3160 4556 +3160 4557 +3160 4558 +3160 4559 +3160 4560 +3160 4561 +3160 4562 +1473 9 +1473 121 +1473 127 +1473 128 +1473 144 +1473 149 +1473 238 +1473 247 +1473 426 +1473 1317 +988 138 +988 163 +988 870 +988 1610 +988 2474 +988 2630 +988 2767 +988 2887 +988 2888 +988 2889 +990 127 +990 148 +990 183 +990 249 +990 252 +990 264 +990 265 +990 266 +990 368 +990 666 +2887 177 +2887 411 +2887 586 +2887 706 +2887 1588 +2887 3363 +2887 4369 +2887 4370 +2887 4371 +2888 527 +2888 652 +2888 1738 +2888 2304 +2888 3017 +2888 4327 +2888 4393 +2888 4394 +2888 4395 +2888 4396 +2890 56 +2890 442 +2890 1279 +2890 2220 +2890 3156 +2890 3794 +2890 4368 +2890 4397 +2890 4398 +4369 3694 +4369 5186 +4369 5252 +4369 5253 +4369 5254 +4369 5255 +4369 5256 +4369 5257 +4369 5258 +4369 5259 +4378 255 +4378 363 +4378 741 +4378 869 +4378 1456 +4378 1762 +4378 2485 +4378 3109 +4378 4854 +4378 5251 +992 3 +992 174 +992 251 +992 265 +992 351 +992 369 +992 390 +992 697 +992 947 +992 993 +994 995 +2901 3 +2901 8 +2901 123 +2901 128 +2901 146 +2901 177 +2901 179 +2901 248 +2901 390 +2901 1245 +1737 710 +1737 740 +1737 2246 +1737 2758 +1737 3093 +1737 3236 +1737 3243 +1737 3528 +1737 3529 +1739 3 +1739 123 +1739 125 +1739 179 +1739 251 +1739 352 +1739 353 +1739 369 +1739 427 +1739 1317 +1740 38 +1740 106 +1740 605 +1740 1133 +1740 1209 +1740 1631 +1740 3273 +1740 3497 +1740 3498 +1740 3499 +4381 89 +4381 691 +4381 3189 +4381 3314 +4381 3849 +4381 4344 +4381 4788 +4381 4934 +4381 5246 +4382 4 +4382 124 +4382 146 +4382 247 +4382 249 +4382 367 +4382 427 +4382 559 +4382 718 +4382 754 +3142 124 +3142 129 +3142 177 +3142 248 +3142 249 +3142 266 +3142 667 +3142 717 +3142 856 +3142 1245 +3544 3 +3544 121 +3544 124 +3544 143 +3544 174 +3544 177 +3544 264 +3544 426 +3544 427 +3544 717 +999 716 +999 1000 +999 1001 +999 1002 +999 1003 +999 1004 +999 1005 +999 1006 +999 1007 +999 1008 +2936 534 +2936 2414 +2936 3772 +2936 4412 +2936 4413 +2936 4414 +3305 115 +3305 911 +3305 2189 +3305 2955 +3305 3189 +3305 3486 +3305 3524 +3305 3537 +3305 4469 +3305 4662 +4388 213 +4388 265 +4388 369 +4388 427 +4388 554 +4388 695 +4388 754 +4388 2914 +4388 3028 +4388 5247 +4399 5 +4399 125 +4399 127 +4399 179 +4399 248 +4399 250 +4399 559 +4399 667 +4399 717 +4399 2018 +4400 762 +4400 1647 +4400 2170 +4400 2579 +4400 2599 +4400 4097 +4400 4867 +4400 5260 +4400 5261 +4400 5262 +4403 202 +4403 280 +4403 1021 +4403 2251 +4403 2296 +4403 4117 +4403 4382 +4403 5263 +4403 5264 +1009 77 +1009 784 +1009 1010 +1009 1011 +1009 1012 +1009 1013 +1009 1014 +1009 1015 +1009 1016 +1009 1017 +1010 1191 +1010 1517 +1010 2411 +1010 2538 +1010 2920 +1010 2921 +1010 2922 +1010 2923 +1010 2924 +1010 2925 +1011 3044 +1013 302 +1013 406 +1013 435 +1013 2119 +1013 2909 +1013 2912 +1013 2913 +1013 2914 +1013 2915 +1015 503 +1015 535 +1015 673 +1015 840 +1015 979 +1015 2916 +1015 2917 +1015 2918 +1015 2919 +1191 116 +1191 1076 +1191 1079 +1191 1331 +1191 1339 +1191 1340 +1191 1341 +1191 1342 +1191 1343 +1191 1344 +2921 296 +2921 828 +2921 944 +2921 1456 +2921 2354 +2921 3139 +2921 3779 +2921 4248 +2921 4407 +2921 4408 +1331 390 +1331 548 +1331 892 +1331 1332 +1331 1333 +1331 1334 +1331 1335 +1331 1336 +1331 1337 +1331 1338 +1344 1219 +1344 1288 +1344 1309 +1344 2650 +1344 2744 +1344 2966 +1344 3018 +1344 3184 +1344 3185 +1344 3186 +4407 169 +4407 1342 +4407 2001 +4407 2046 +4407 3362 +4407 5265 +4407 5266 +4407 5267 +4407 5268 +1401 510 +1401 677 +1401 736 +1401 2546 +1401 3169 +1401 3254 +1401 3255 +1401 3256 +1401 3257 +3191 101 +3191 1171 +3191 1235 +3191 2335 +3191 2575 +3191 3134 +3191 3140 +3191 3339 +3191 4580 +3191 4581 +5106 1027 +5106 1940 +5106 2005 +5106 2429 +5106 2497 +5106 3238 +5106 4934 +5106 5244 +5106 5639 +5106 5640 +2938 486 +2938 494 +2938 534 +2938 924 +2938 1297 +2938 1559 +2938 1940 +2938 2650 +2938 4124 +2939 802 +2939 1866 +2939 2275 +2939 2412 +2939 2948 +2939 3636 +2939 4170 +2939 4418 +2939 4419 +2939 4420 +4761 159 +4761 813 +4761 2494 +4761 3306 +4761 4759 +4762 3497 +4766 21 +4766 892 +4766 940 +4766 1116 +4766 1658 +4766 1872 +4766 4754 +4766 5348 +4766 5469 +4766 5470 +4419 8 +4419 31 +4419 126 +4419 144 +4419 148 +4419 175 +4419 179 +4419 247 +4419 558 +4419 697 +4420 224 +4420 281 +4420 386 +4420 1401 +4420 3358 +4420 3448 +4420 3590 +4420 5270 +4420 5271 +1216 1591 +1216 1749 +4423 8 +4423 77 +4423 282 +4423 1143 +4423 1571 +4423 1765 +4423 2961 +4423 3138 +4423 4801 +4423 5282 +4416 122 +4416 527 +4416 571 +4416 894 +4416 1027 +4416 2563 +4416 2615 +4416 4373 +4416 4719 +4416 5269 +4417 95 +4417 1197 +4417 1619 +4417 2079 +4417 2114 +4417 3253 +4417 3598 +4417 4303 +4417 4950 +4417 5175 +4431 296 +4431 1434 +4431 2427 +4431 2643 +4431 5276 +4432 92 +4432 892 +4432 1217 +4432 1404 +4432 1989 +4432 4004 +4432 4031 +4432 4058 +4432 5277 +4432 5278 +4424 110 +4424 498 +4424 1804 +4424 2708 +4424 4885 +4424 5279 +4424 5280 +4424 5281 +4424 5282 +4424 5283 +4428 179 +4428 247 +4428 251 +4428 266 +4428 368 +4428 422 +4428 423 +4428 424 +4428 667 +4428 717 +4421 124 +4421 381 +4421 477 +4421 1655 +4421 2055 +4421 2169 +4421 2254 +4421 4129 +4421 5266 +4421 5272 +2958 458 +2958 669 +2958 852 +2958 1115 +2958 1786 +2958 1798 +2958 2255 +2958 2571 +2958 4136 +4443 173 +4443 489 +4443 1896 +4443 1974 +4443 2646 +4443 3114 +4443 3806 +4443 4036 +4443 4275 +4443 5284 +1057 164 +1057 1058 +1057 1059 +1057 1060 +1057 1061 +1057 1062 +1057 1063 +1057 1064 +1057 1065 +1057 1066 +1059 3 +1059 8 +1059 121 +1059 125 +1059 128 +1059 174 +1059 179 +1059 247 +1059 424 +1059 717 +1063 2493 +1063 2987 +1063 2988 +1063 2989 +1063 2990 +1063 2991 +1063 2992 +1063 2993 +1063 2994 +1063 2995 +2988 1396 +2988 1598 +2988 1821 +2988 2069 +2988 2276 +2988 3188 +2988 3433 +2988 3563 +2988 3974 +2988 4422 +2989 2232 +2989 2448 +2991 1335 +2991 2394 +2991 2663 +2991 2787 +2991 3244 +2991 3815 +2991 4423 +2991 4446 +2991 4447 +2991 4448 +1821 112 +1821 690 +1821 703 +1821 1636 +1821 1703 +1821 1822 +1821 1823 +1821 1824 +1821 1825 +1821 1826 +4446 4733 +4447 416 +4447 1287 +4447 2621 +4447 2886 +4447 4260 +4447 4462 +4447 4921 +4447 5288 +4447 5289 +4447 5290 +4441 76 +4441 1087 +4441 1726 +4441 2583 +4441 2762 +4441 3487 +4441 3511 +4441 3823 +4441 5287 +4442 522 +4442 837 +4442 1034 +4442 2670 +4442 3110 +4442 3141 +4442 3448 +4442 3737 +4442 5291 +1075 116 +1075 1076 +1075 1077 +1075 1078 +1075 1079 +1075 1080 +1075 1081 +1075 1082 +1075 1083 +1080 2868 +1082 3 +1082 7 +1082 8 +1082 124 +1082 126 +1082 144 +1082 238 +1082 248 +1082 352 +1082 427 +2986 3 +2986 121 +2986 128 +2986 143 +2986 147 +2986 176 +2986 177 +2986 264 +2986 422 +2986 718 +1098 1051 +1098 1099 +1098 1100 +1098 1101 +1098 1102 +1098 1103 +1098 1104 +1098 1105 +1098 1106 +1108 467 +1108 1109 +1108 1110 +1108 1111 +1108 1112 +1108 1113 +1108 1114 +1108 1115 +1108 1116 +1111 435 +1111 1618 +1111 1645 +1111 1982 +1111 2163 +1111 3018 +1111 3019 +1111 3020 +1111 3021 +1111 3022 +1113 4 +1113 124 +1113 249 +1113 266 +1113 367 +1113 368 +1113 369 +1113 423 +1113 1245 +1117 29 +1117 124 +1117 126 +1117 496 +1117 1118 +1117 1119 +1117 1120 +1117 1121 +1117 1122 +1117 1123 +2997 738 +2997 1635 +2997 1650 +2997 2312 +2997 2337 +2997 2414 +2997 2554 +2997 2858 +2997 3772 +2997 4444 +3001 200 +1650 526 +1650 876 +1650 1135 +1650 1565 +1650 1651 +1650 1652 +1650 1653 +1650 1654 +1650 1655 +1650 1656 +4444 769 +4444 770 +4444 1528 +4444 1744 +4444 3852 +4444 4062 +4444 4551 +4444 5182 +4444 5285 +4444 5286 +3148 3301 +1135 4 +1135 147 +1135 176 +1135 246 +1135 249 +1135 251 +1135 252 +1135 264 +1135 266 +1135 718 +1136 553 +1136 856 +1136 1137 +1136 1138 +1136 1139 +1136 1140 +1136 1141 +1136 1142 +1136 1143 +1136 1144 +1138 152 +1138 2013 +1138 2221 +1138 2770 +1138 2785 +1138 2848 +1138 3015 +1138 3016 +1138 3017 +1139 83 +1139 229 +1139 645 +1139 2359 +1139 3009 +1139 3010 +1139 3011 +1139 3012 +1139 3013 +1139 3014 +1141 162 +1141 490 +1141 1122 +1141 1949 +1141 2353 +1141 3023 +1141 3024 +1141 3025 +1141 3026 +1141 3027 +3011 94 +3011 352 +3011 466 +3011 1022 +3011 2628 +3011 3587 +3011 4453 +3011 4454 +3011 4455 +3011 4456 +3024 352 +3024 1139 +3024 1721 +3024 2790 +3024 3995 +3024 4460 +3024 4461 +3024 4462 +3024 4463 +3025 3221 +3025 3271 +3025 3335 +3025 4473 +3025 4474 +3026 3 +3026 123 +3026 128 +3026 129 +3026 143 +3026 146 +3026 177 +3026 251 +3026 367 +3026 1245 +4445 4 +4445 127 +4445 143 +4445 247 +4445 249 +4445 250 +4445 369 +4445 559 +4445 667 +4445 2001 +4532 4 +4532 127 +4532 143 +4532 248 +4532 266 +4532 390 +4532 422 +4532 423 +4532 667 +5326 701 +5326 703 +5326 1430 +5326 2149 +5326 3017 +5326 3027 +5326 4297 +5326 5268 +5326 5339 +5326 5352 +4449 162 +4449 199 +4449 290 +4449 757 +4449 2151 +4449 5292 +4449 5293 +4449 5294 +4449 5295 +4449 5296 +4452 228 +4452 554 +4452 789 +4452 1957 +4452 2153 +4452 2612 +4452 3083 +4452 3539 +4452 3919 +4452 5297 +4456 9 +4456 126 +4456 143 +4456 144 +4456 145 +4456 148 +4456 179 +4456 423 +4456 697 +4458 47 +4458 491 +4458 541 +4458 2869 +4458 3779 +4458 5118 +4458 5298 +4458 5299 +4458 5300 +4458 5301 +1184 2259 +4459 2139 +4459 2425 +4459 2431 +4459 2570 +4459 4507 +4459 5017 +4459 5116 +4459 5150 +4459 5302 +4459 5303 +4469 548 +4469 1160 +4469 2126 +4469 2499 +4469 2690 +4469 3574 +4469 3917 +4469 5308 +4469 5309 +4469 5310 +4470 4 +4470 7 +4470 126 +4470 143 +4470 147 +4470 266 +4470 422 +4470 558 +4470 754 +4470 856 +3341 18 +3341 551 +3341 952 +3341 1388 +3341 3421 +3341 3852 +3341 4043 +3341 4685 +3341 4686 +3341 4687 +3660 3 +3660 122 +3660 459 +3660 1252 +3660 1849 +3660 2077 +3660 3178 +3660 4170 +3660 4772 +3660 4881 +4465 143 +4465 175 +4465 176 +4465 252 +4465 367 +4465 368 +4465 422 +4465 2001 +4465 2018 +1154 538 +1154 738 +1154 744 +1154 921 +1154 1155 +1154 1156 +1154 1157 +1154 1158 +1154 1159 +1154 1160 +1155 823 +1155 824 +1155 955 +1155 2394 +1155 2966 +1155 3034 +1155 3035 +1155 3036 +1155 3037 +1155 3038 +3037 1212 +3037 2051 +3037 2782 +3037 2796 +3037 3740 +3037 4434 +3037 4477 +3037 4478 +3037 4479 +3037 4480 +3040 4 +3040 5 +3040 122 +3040 123 +3040 128 +3040 144 +3040 175 +3040 176 +3040 424 +3041 134 +3041 365 +3041 1061 +3041 3207 +3041 3819 +3041 3867 +3041 4136 +3041 4193 +3041 4484 +3041 4485 +3042 3 +3042 124 +3042 175 +3042 249 +3042 250 +3042 266 +3042 367 +3042 558 +3042 697 +3042 754 +3043 9 +3043 126 +3043 145 +3043 147 +3043 148 +3043 252 +3043 266 +3043 352 +3043 559 +3043 856 +4467 2345 +4467 3097 +4467 3260 +4467 3314 +4467 5037 +4478 1052 +4478 1146 +4478 1961 +4478 3418 +4478 4009 +4478 4364 +4478 5313 +4478 5314 +4478 5315 +4478 5316 +4479 183 +4479 604 +4479 913 +4479 2039 +4479 2291 +4479 3318 +4479 4378 +4479 5317 +4479 5318 +4479 5319 +3564 854 +3564 1123 +3564 1573 +3564 3409 +3564 4158 +3564 4339 +3564 4718 +3564 4823 +1161 3 +1161 5 +1161 8 +1161 121 +1161 122 +1161 124 +1161 144 +1161 145 +1161 177 +1161 248 +1882 486 +1882 1531 +1882 1862 +1882 1930 +1882 2337 +1882 3624 +1882 3625 +1882 3626 +1882 3627 +1882 3628 +3627 3022 +3627 3699 +3627 4867 +3627 4868 +3627 4869 +3628 352 +4482 3 +4482 8 +4482 127 +4482 143 +4482 176 +4482 177 +4482 248 +4482 352 +4482 353 +4482 367 +3045 42 +3045 125 +3045 219 +3045 550 +3045 614 +3045 2004 +3045 2499 +3045 3104 +3045 4475 +3045 4476 +4658 1973 +1172 296 +1172 1173 +1172 1174 +1172 1175 +1172 1176 +1172 1177 +1172 1178 +1172 1179 +1172 1180 +1174 1178 +1174 1233 +1174 1439 +1174 1491 +1174 1946 +1174 3050 +1174 3051 +1174 3052 +1174 3053 +4923 5428 +4967 1303 +4967 1989 +4967 2769 +4967 3245 +4967 4330 +4967 4337 +4967 5074 +4967 5507 +4967 5587 +1181 1182 +1181 1183 +1181 1184 +1181 1185 +1181 1186 +1181 1187 +1181 1188 +1181 1189 +1181 1190 +1181 1191 +1189 3054 +1192 338 +1192 834 +1192 900 +1192 1193 +1192 1194 +1192 1195 +1192 1196 +1192 1197 +1192 1198 +3552 2 +3552 123 +3552 147 +3552 177 +3552 250 +3552 251 +3552 351 +3552 946 +3552 983 +3552 2077 +4825 838 +4825 839 +4825 1716 +4825 2211 +4825 2226 +4825 4388 +4825 4915 +4825 5513 +4825 5514 +4825 5515 +5241 198 +5241 1192 +5241 1969 +5241 2776 +5241 2888 +5241 3395 +5241 4251 +5241 4641 +5241 4992 +5241 5725 +5487 5858 +5785 121 +5785 123 +5785 144 +5785 149 +5785 176 +5785 180 +5785 352 +5785 754 +5785 1317 +5788 1173 +5788 1487 +5788 1544 +5788 3531 +5788 4885 +5788 5546 +5788 5655 +5788 5980 +5788 5981 +5788 5982 +4487 842 +4487 1103 +4487 1141 +4487 1481 +4487 2201 +4487 2453 +4487 3207 +4487 3327 +4487 3714 +4487 4111 +4492 573 +4492 1138 +4492 1177 +4492 1212 +4492 1940 +4492 3343 +4492 3860 +4492 4254 +4492 5321 +4492 5322 +1200 229 +1200 341 +1200 1201 +1200 1202 +1200 1203 +1200 1204 +1200 1205 +1200 1206 +1200 1207 +1200 1208 +1204 1097 +1204 1322 +1204 2887 +1204 3098 +1204 3099 +1204 3100 +1204 3101 +1204 3102 +1204 3103 +1204 3104 +1205 141 +1205 1849 +1205 1850 +1205 2996 +1205 3065 +1205 3066 +1205 3067 +1205 3068 +1205 3069 +1205 3070 +1207 1749 +1207 2739 +1207 3071 +1207 3072 +1207 3073 +1207 3074 +1207 3075 +1207 3076 +1207 3077 +1207 3078 +3098 308 +3098 480 +3098 1376 +3098 2199 +3098 2362 +3098 2995 +3098 3273 +3098 4355 +3098 4533 +3098 4534 +3100 303 +3100 1017 +3100 1221 +3100 1941 +3100 2932 +3100 3123 +3100 3722 +3100 3788 +3100 4171 +3100 4544 +3067 318 +3067 908 +3067 1267 +3067 1412 +3067 2162 +3067 3487 +3067 3767 +3067 4489 +3067 4490 +3067 4491 +3074 289 +3074 979 +3074 1228 +3074 4288 +3074 4493 +3078 75 +3078 108 +3078 272 +3078 274 +3078 477 +3078 814 +3078 1542 +3078 2248 +3078 4019 +3078 4500 +4533 103 +4533 112 +4533 1382 +4533 1541 +4533 1741 +4533 2201 +4533 2312 +4533 2758 +4533 5338 +4533 5339 +4536 56 +4536 158 +4536 1199 +4536 1341 +4536 2304 +4536 4096 +4536 5081 +4536 5340 +4536 5341 +4489 3813 +4489 5392 +4500 120 +4500 1666 +4500 1884 +4500 4002 +4500 4799 +4500 4841 +4500 5187 +4500 5283 +4500 5315 +4500 5327 +1211 1800 +3250 1903 +3490 4781 +1218 58 +1218 165 +1218 292 +1218 514 +1218 941 +1218 1000 +1218 1219 +1218 1220 +1218 1221 +1222 49 +1222 78 +1222 468 +1222 1223 +1222 1224 +1222 1225 +1222 1226 +1222 1227 +1222 1228 +1222 1229 +3086 327 +3086 1087 +3086 1689 +3086 2195 +3086 3823 +3086 4505 +3086 4506 +3086 4507 +3086 4508 +3086 4509 +3087 38 +3087 2571 +3087 2948 +3087 4134 +3087 4420 +3087 4510 +3087 4511 +3087 4512 +3087 4513 +3087 4514 +3088 121 +3088 122 +3088 123 +3088 125 +3088 127 +3088 144 +3088 174 +3088 352 +3088 369 +3088 1317 +3557 23 +3557 113 +3557 1123 +3557 1227 +3557 1501 +3557 2214 +3557 2276 +3557 4371 +3557 4816 +3557 4817 +4793 105 +4793 127 +4793 423 +4793 442 +4793 918 +4793 1540 +4793 2445 +4793 4664 +4793 5497 +6241 424 +6241 1800 +6241 3712 +6241 5128 +6241 5182 +6241 6119 +6241 6120 +6241 6255 +6241 6256 +6241 6257 +4505 3456 +4506 5316 +4508 125 +4508 129 +4508 145 +4508 174 +4508 180 +4508 353 +4508 559 +4508 697 +4508 717 +4508 1317 +4510 157 +4510 158 +4510 442 +4510 1317 +4510 4177 +4510 4958 +4510 5328 +4510 5329 +4510 5330 +4513 904 +4513 1524 +4513 2164 +4513 2710 +4513 3241 +4513 3303 +4513 3478 +4513 5191 +4513 5336 +4513 5337 +3634 1052 +3634 1067 +3634 2479 +3634 2528 +3634 3524 +3634 3677 +3634 4371 +3634 4641 +3634 4870 +3634 4871 +3635 1144 +3635 2170 +3635 2332 +3635 3860 +3635 4136 +3635 4872 +3635 4873 +3635 4874 +3635 4875 +3635 4876 +3269 5 +3269 17 +3269 126 +3269 143 +3269 149 +3269 250 +3269 266 +3269 423 +3269 424 +3269 559 +1237 842 +1237 852 +1237 1238 +1237 1239 +1237 1240 +1237 1241 +1237 1242 +1237 1243 +1237 1244 +1241 1492 +3106 2543 +1247 158 +1247 582 +1247 583 +1247 955 +1247 1032 +1247 1068 +1247 1070 +1247 1248 +1247 1249 +1247 1250 +1253 13 +1253 750 +1253 2359 +1253 3119 +1254 813 +1254 1890 +1254 2207 +1254 2997 +1254 3007 +4541 495 +4541 1213 +4541 1214 +4541 1577 +4541 2661 +4541 3721 +4541 4038 +4541 4158 +4541 4735 +4541 5344 +1767 1084 +1767 1768 +1767 1769 +1767 1770 +1767 1771 +1767 1772 +1767 1773 +1767 1774 +1767 1775 +1767 1776 +1260 301 +1260 1084 +1260 1086 +1260 1261 +1260 1262 +1260 1263 +1260 1264 +1260 1265 +1260 1266 +1266 906 +3120 178 +3120 253 +3120 263 +3120 553 +3120 2325 +3120 2497 +3120 3826 +3120 3942 +3120 4542 +3120 4543 +3126 113 +3135 283 +3135 476 +3135 1511 +3135 1714 +3135 2860 +3135 3343 +3135 3463 +3135 4419 +3135 4551 +3135 4552 +4551 63 +4551 260 +4551 562 +4551 870 +4551 2236 +4551 3397 +4551 4407 +4551 4970 +4551 5348 +4551 5349 +4552 3813 +1286 391 +1286 1056 +1286 1100 +1286 1287 +1286 1288 +1286 1289 +1286 1290 +1286 1291 +1286 1292 +1286 1293 +1387 860 +1387 1454 +1387 1457 +1387 1509 +1387 3220 +1387 3221 +1387 3280 +5931 731 +5931 1129 +5931 5228 +5931 5686 +5931 5999 +6071 364 +6071 3298 +6071 5014 +6071 5081 +6071 5179 +6071 5980 +6071 6249 +6071 6250 +6071 6251 +6071 6252 +1294 148 +1294 369 +1294 438 +1294 690 +1294 1069 +1294 1295 +1294 1296 +1294 1297 +1294 1298 +1294 1299 +3326 418 +3326 1021 +3326 1030 +3326 1240 +3326 3478 +3326 3499 +3326 4430 +3326 4583 +3326 4673 +3326 4674 +3190 123 +3190 124 +3190 367 +3190 368 +3190 667 +3190 857 +3190 1208 +3190 4577 +3190 4578 +3190 4579 +1409 5 +1409 127 +1409 148 +1409 183 +1409 252 +1409 264 +1409 559 +1409 666 +1409 1317 +1307 240 +1307 1308 +1307 1309 +1307 1310 +1307 1311 +1307 1312 +1307 1313 +1307 1314 +1307 1315 +1307 1316 +1308 2661 +1308 2922 +1308 3181 +1308 3182 +1308 3183 +4891 249 +4891 290 +4891 1456 +4891 2149 +4891 2949 +4891 4639 +4891 5106 +4891 5550 +4891 5551 +4891 5552 +5414 855 +5895 122 +5895 123 +5895 128 +5895 129 +5895 249 +5895 251 +5895 266 +5895 368 +5895 427 +5895 718 +6061 6150 +6062 1956 +6062 2761 +6062 3587 +6062 4577 +6062 4818 +6062 5554 +6062 6013 +6062 6151 +6062 6152 +6062 6153 +4566 92 +4566 163 +4566 1129 +4566 1808 +4566 3524 +4566 3636 +4566 4431 +4566 4776 +4566 5277 +4566 5353 +4567 149 +4567 261 +4567 649 +4567 1042 +4567 1060 +4567 1867 +4567 1922 +4567 5350 +4567 5351 +4567 5352 +4568 202 +4568 1330 +4568 2791 +4568 5354 +4568 5355 +4568 5356 +4568 5357 +4568 5358 +4557 41 +4557 804 +4557 2247 +4557 2536 +4557 3996 +4557 4459 +4557 5162 +4557 5300 +4557 5346 +4557 5347 +4585 158 +4585 229 +4585 1591 +4585 2893 +4585 3316 +4585 3906 +4585 4098 +4585 4784 +4585 4839 +4585 5366 +4587 462 +4587 1359 +4587 1457 +4587 1688 +4587 2875 +4587 3038 +4587 3858 +4587 4880 +4587 5367 +4587 5368 +3178 1948 +3178 2119 +3178 3325 +3178 3457 +3178 4419 +3178 4572 +3178 4573 +3178 4574 +3178 4575 +3178 4576 +4572 5376 +4574 392 +4574 617 +4574 1616 +4574 1937 +4574 1987 +4574 3446 +4574 4960 +4574 5362 +4574 5363 +4574 5364 +4583 1068 +4583 1227 +4583 2036 +4583 3087 +4583 4194 +4583 4793 +4583 5281 +4583 5285 +4583 5382 +4583 5383 +4577 8 +4577 282 +4577 822 +4577 1143 +4577 1780 +4577 2016 +4577 3081 +4577 5128 +4577 5365 +3202 267 +3202 1466 +3202 2869 +3202 3488 +3202 3708 +3202 3796 +3202 3818 +3202 4165 +3202 4322 +3202 4590 +1360 968 +1360 1561 +1360 2356 +1360 2918 +1360 3223 +3206 2909 +3206 3403 +3206 3489 +3206 4588 +3206 4589 +3208 559 +3208 1037 +3208 1122 +3208 1175 +3208 2018 +3208 2524 +3208 4005 +3208 4508 +3208 4592 +3208 4593 +3223 1327 +3223 2265 +3223 3720 +3223 4609 +3223 4610 +4592 5380 +4593 227 +4593 727 +4593 802 +4593 945 +4593 1347 +4593 1956 +4593 2884 +4593 3485 +4593 4324 +4593 5369 +1369 256 +1369 308 +1369 860 +1369 1457 +1369 1767 +1369 1817 +1369 3219 +1369 3220 +1369 3221 +1369 3222 +3222 296 +3222 413 +3222 1903 +3222 1939 +3222 4603 +3222 4604 +3222 4605 +3222 4606 +3222 4607 +3222 4608 +4596 133 +4596 3949 +4596 4426 +4596 5308 +4596 5370 +4596 5371 +4596 5372 +4596 5373 +4596 5374 +4596 5375 +4598 4 +4598 146 +4598 180 +4598 250 +4598 368 +4598 390 +4598 697 +4598 1245 +4598 1317 +4603 5381 +4606 862 +4606 1458 +4606 1900 +4606 3220 +4606 3221 +4606 4287 +4606 4586 +4606 5377 +4606 5378 +4606 5379 +3224 2516 +3225 108 +3225 756 +3225 763 +3225 2911 +3225 3438 +3225 3679 +3225 3748 +3225 4611 +3225 4612 +3225 4613 +1379 602 +1379 1274 +1379 1380 +1379 1381 +1379 1382 +1379 1383 +1379 1384 +1379 1385 +1379 1386 +1379 1387 +4620 2645 +5515 8 +5515 123 +5515 124 +5515 127 +5515 179 +5515 247 +5515 367 +5515 390 +5515 423 +5515 1246 +5858 612 +5655 1608 +5980 563 +5980 762 +5980 789 +5980 835 +5980 977 +5980 1122 +5980 1903 +5980 1913 +5980 3956 +5980 6096 +5981 111 +5981 830 +5981 1811 +5981 2163 +5981 2193 +5981 3861 +5981 3953 +5981 4332 +5981 6094 +5981 6095 +5982 243 +5982 2260 +5982 3093 +5982 3231 +5982 4592 +5982 5569 +5982 5645 +5982 6097 +5982 6098 +5982 6099 +1388 122 +1388 123 +1388 147 +1388 176 +1388 177 +1388 246 +1388 264 +1388 422 +1388 1245 +3281 3070 +3281 3122 +3281 3326 +3281 4581 +3281 4641 +3281 4648 +3281 4649 +3281 4650 +3281 4651 +3281 4652 +4617 3716 +4617 3949 +4617 4783 +4617 5175 +4617 5211 +4617 5386 +4617 5387 +4617 5388 +4617 5389 +4617 5390 +4619 381 +4619 778 +4619 1592 +4619 1900 +4619 2166 +4619 2234 +4619 2646 +4619 2875 +4619 3327 +4619 4812 +4650 605 +4650 835 +4650 1430 +4650 2970 +4650 3369 +4650 5407 +4650 5408 +4650 5409 +4650 5410 +1398 554 +1398 736 +1398 1022 +1398 1399 +1398 1400 +1398 1401 +1398 1402 +1399 387 +1399 416 +1399 765 +1399 806 +1399 3242 +1399 3243 +1399 3244 +1399 3245 +1399 3246 +1399 3247 +3246 268 +3246 576 +3246 840 +3246 1797 +3246 3956 +3246 4608 +3246 4629 +3246 4630 +3246 4631 +3246 4632 +3254 1067 +3255 127 +3255 146 +3255 250 +3255 367 +3255 369 +3255 423 +3255 697 +3255 754 +3255 856 +1758 1135 +1758 2805 +1758 3126 +1758 3520 +1758 3521 +1758 3522 +1758 3523 +1758 3524 +1758 3525 +1758 3526 +4629 151 +4629 281 +4629 491 +4629 2360 +4629 2781 +4629 3576 +4629 3891 +4629 5328 +4629 5391 +4631 251 +4631 664 +4631 803 +4631 2218 +4631 2285 +4631 2309 +4631 4137 +4631 5393 +4631 5394 +4631 5395 +4638 159 +4638 828 +4638 1604 +4638 2886 +4638 5357 +4638 5399 +4638 5400 +4638 5401 +4638 5402 +4639 472 +4639 576 +4639 2060 +4639 4158 +4639 5406 +3358 132 +3358 1801 +3358 1900 +3358 2224 +3358 3039 +3358 3606 +3358 4533 +3358 4697 +3358 4698 +3358 4699 +4636 5 +4636 9 +4636 148 +4636 179 +4636 390 +4636 422 +4636 558 +4636 697 +4636 754 +4636 856 +3605 731 +4633 199 +4633 474 +4633 476 +4633 637 +4633 2269 +4633 3105 +4633 3227 +4633 4646 +4633 5397 +4633 5398 +1403 132 +1403 188 +1403 926 +1403 1404 +1403 1405 +1403 1406 +1403 1407 +1403 1408 +1403 1409 +1403 1410 +1404 228 +1404 2429 +1404 2477 +1404 2755 +1404 3274 +1404 3275 +1404 3276 +1404 3277 +1404 3278 +1404 3279 +3274 4644 +3270 522 +3270 4150 +3270 4365 +3270 4642 +3270 4643 +4643 538 +4643 1575 +4643 1731 +4643 2214 +4643 2784 +4643 3566 +4643 4336 +4643 5342 +4643 5343 +4654 1137 +4654 1239 +4654 1509 +4654 1616 +4654 1803 +4654 3141 +4654 3699 +4654 3807 +4654 4655 +4654 5852 +4654 5954 +4654 5955 +6036 474 +6036 810 +6036 1332 +6036 1458 +6036 1842 +6036 3213 +6036 3411 +6036 3658 +6036 3913 +6036 6137 +6038 50 +6038 190 +6038 1376 +6038 1557 +6038 1689 +6038 2254 +6038 2354 +6038 2414 +6038 2657 +6038 2750 +1550 126 +1550 145 +1550 149 +1550 183 +1550 246 +1550 390 +1550 423 +1550 667 +1550 718 +1550 856 +3524 330 +3524 945 +3524 1047 +3524 1797 +3524 2397 +3524 2705 +3524 3017 +3524 3235 +3524 3583 +3524 4802 +4662 828 +4662 1195 +4662 2698 +4662 2773 +4662 2891 +4662 3595 +4662 4770 +4662 4848 +4662 5392 +4662 5411 +1443 1444 +1445 326 +1445 502 +1445 578 +1445 1446 +1445 1447 +1445 1448 +1445 1449 +1445 1450 +1445 1451 +1445 1452 +1453 221 +1453 476 +1453 1195 +1453 1295 +1453 1454 +1453 1455 +1453 1456 +1453 1457 +1453 1458 +1453 1459 +4664 3635 +4664 5434 +4664 5435 +4664 5436 +4665 110 +4665 566 +4665 928 +4665 2254 +4665 2666 +4665 2744 +4665 2859 +4665 3097 +4665 5159 +4665 5412 +4666 15 +4666 1158 +4666 1278 +4666 1383 +4666 2558 +4666 3062 +4666 4296 +4666 4297 +4666 4988 +4666 5413 +4667 458 +4667 1482 +4667 1524 +4667 1599 +4667 2887 +4667 3046 +4667 3675 +4667 5101 +4667 5373 +1460 1461 +1462 1463 +1462 1464 +1462 1465 +1462 1466 +1462 1467 +1462 1468 +1462 1469 +1462 1470 +1462 1471 +1462 1472 +1474 158 +1478 110 +1478 798 +1478 1095 +1478 1215 +1478 1479 +1478 1480 +1478 1481 +1478 1482 +1478 1483 +1478 1484 +1484 1581 +1484 2071 +1484 2516 +1484 2532 +1484 3079 +1484 3200 +1484 3323 +1484 3324 +1484 3325 +1494 5 +1494 7 +1494 125 +1494 144 +1494 149 +1494 174 +1494 179 +1494 424 +1494 559 +1494 667 +1495 1496 +1497 125 +1497 828 +1497 1498 +1497 1499 +1497 1500 +1497 1501 +1497 1502 +1497 1503 +1497 1504 +1497 1505 +3499 788 +4674 5283 +1518 1519 +1519 561 +1519 725 +1519 756 +1519 982 +1519 1061 +1519 1120 +1519 1422 +1519 3348 +1519 3349 +1519 3350 +3348 124 +3348 128 +3348 146 +3348 147 +3348 176 +3348 238 +3348 249 +3348 264 +3348 368 +3348 718 +4692 532 +4692 2916 +4692 4371 +4692 4402 +4692 5425 +1520 609 +1520 614 +1520 883 +1520 958 +1520 1521 +1520 1522 +1520 1523 +1520 1524 +1520 1525 +1520 1526 +1527 3 +1527 454 +1527 462 +1527 691 +1527 970 +1527 1025 +1527 1492 +1527 1528 +1527 1529 +1527 1530 +3333 211 +3333 331 +3333 651 +3333 2125 +3333 2129 +3333 2377 +3333 3951 +3333 4249 +3333 4676 +3333 4677 +4676 524 +4676 3050 +4676 3780 +4676 4109 +5497 41 +5497 143 +5497 266 +5497 491 +5497 911 +5497 2202 +5497 3599 +5497 4652 +5497 5845 +5497 5846 +5552 353 +5552 785 +5552 849 +5552 918 +5552 1103 +5552 3618 +5552 4812 +5552 5040 +5552 5405 +5552 5873 +6152 371 +6152 762 +6152 1330 +6152 1797 +6152 2531 +6152 3305 +6152 3503 +6152 3900 +6152 4981 +6152 6171 +3338 133 +3338 1808 +3338 2971 +3338 3808 +3338 4281 +3338 4356 +3338 4412 +3338 4682 +3360 418 +1672 1673 +3390 661 +3390 976 +3390 1023 +3390 1313 +3390 1530 +3390 1802 +3390 2981 +3390 3727 +3390 4725 +3390 4726 +3393 646 +3393 1251 +3393 1487 +3393 1618 +3393 3223 +3393 3463 +3393 4731 +3393 4732 +4684 970 +4684 1731 +4684 3837 +4684 4176 +4684 4735 +4684 5343 +4684 5419 +4684 5420 +4686 315 +4686 337 +4686 353 +4686 629 +4686 1491 +4686 3571 +4686 4915 +4686 5300 +4686 5421 +4686 5422 +1816 628 +1816 820 +1816 1258 +1816 2873 +1816 2975 +1816 3262 +1816 3446 +1816 3551 +1816 3552 +1816 3553 +1562 391 +1562 405 +1562 824 +1562 1105 +1562 1563 +1562 1564 +1562 1565 +1562 1566 +1562 1567 +1562 1568 +1566 297 +1566 338 +1566 1192 +1566 1425 +1566 2450 +1566 3351 +1566 3352 +1566 3353 +1566 3354 +1566 3355 +3355 584 +3355 1837 +3355 2629 +3355 3035 +3355 3319 +3355 3335 +3355 4693 +3355 4694 +3355 4695 +3355 4696 +4693 416 +4693 705 +4693 1651 +4693 1968 +4693 2399 +4693 2848 +4693 3733 +4693 4640 +4693 5426 +4693 5427 +4694 1047 +4694 2449 +4694 3293 +4694 3929 +4694 4164 +4694 5430 +4694 5431 +4694 5432 +4694 5433 +1572 1127 +1572 1273 +1572 1550 +1572 1961 +1572 2400 +1572 2465 +1572 3356 +1572 3357 +1572 3358 +1572 3359 +3356 127 +3356 128 +3356 246 +3356 248 +3356 352 +3356 353 +3356 422 +3356 427 +3356 667 +3356 856 +3359 997 +1577 550 +1577 1578 +1579 391 +1579 602 +1579 1240 +1579 1246 +1579 1385 +1579 1580 +1579 1581 +1579 1582 +1579 1583 +1582 355 +1582 1791 +1582 1797 +1582 2285 +1582 2309 +1582 2799 +1582 3282 +1582 3371 +1582 3372 +1586 4 +1586 8 +1586 147 +1586 148 +1586 174 +1586 352 +1586 368 +1586 424 +1586 856 +1586 2098 +3369 104 +3369 391 +3369 860 +3369 1855 +3369 3014 +3369 4093 +3369 4120 +3369 4298 +3369 4714 +3369 4715 +4705 5 +4705 144 +4705 148 +4705 249 +4705 252 +4705 264 +4705 266 +4705 367 +4705 666 +4705 1245 +1855 161 +1855 473 +1855 552 +1855 1670 +1855 1731 +1855 2563 +1855 3364 +1855 3572 +1855 3600 +1855 3601 +1596 298 +1596 465 +1596 1597 +1596 1598 +1596 1599 +1596 1600 +1596 1601 +1596 1602 +1596 1603 +1596 1604 +1603 5 +1603 8 +1603 9 +1603 147 +1603 149 +1603 179 +1603 252 +1603 426 +1603 856 +1603 2098 +1605 102 +1605 430 +1605 472 +1605 1024 +1605 1297 +1605 1381 +1605 1606 +1605 1607 +1605 1608 +1605 1609 +3378 2875 +1616 288 +1616 1595 +1616 1617 +1616 1618 +1616 1619 +1616 1620 +1616 1621 +1616 1622 +1616 1623 +1616 1624 +4720 131 +4720 133 +4720 400 +4720 883 +4720 4031 +4720 4373 +4720 4400 +4720 4871 +4720 4951 +4720 5438 +4721 51 +4721 472 +4721 1411 +4721 1926 +4721 3552 +4721 4160 +4721 5159 +4721 5439 +4721 5440 +4721 5441 +4723 529 +4723 649 +4723 2358 +4723 3220 +4723 4670 +4723 4676 +4723 4844 +4723 5241 +4723 5428 +4723 5442 +4724 63 +4724 514 +4724 1694 +4724 4296 +4724 5155 +4724 5443 +4724 5444 +4724 5445 +4724 5446 +1625 29 +1625 303 +1625 364 +1625 1061 +1625 1626 +1625 1627 +1625 1628 +1625 1629 +1625 1630 +1625 1631 +1627 364 +1627 442 +1627 2278 +1627 3384 +1627 3385 +3380 248 +3380 487 +3380 910 +3380 1801 +3380 2002 +3380 3350 +3380 4716 +3380 4717 +3380 4718 +1632 1481 +1638 2017 +1673 389 +1673 503 +1673 1513 +1673 1940 +1673 2216 +1673 2359 +1673 2634 +1673 2636 +1673 3448 +1673 3449 +4725 255 +4725 381 +4725 2226 +4725 3181 +4725 5456 +4726 804 +4726 1507 +4726 2292 +4726 2697 +4726 3496 +4726 3516 +4726 3949 +4726 4042 +4726 5261 +4731 2554 +4731 3120 +4731 4770 +4731 5155 +4732 132 +4732 433 +4732 459 +4732 2060 +4732 2097 +4732 2332 +4732 2408 +4732 3312 +4732 3635 +4732 4667 +4728 102 +4728 126 +4728 144 +4728 145 +4728 179 +4728 266 +4728 483 +4728 1827 +4728 3290 +4728 4643 +4729 4986 +4730 2519 +4730 2776 +4730 2844 +4730 4273 +4730 4438 +4730 4441 +4730 4664 +4730 4944 +4730 5231 +4730 5453 +1648 1649 +1649 297 +1649 324 +1649 1044 +1649 1157 +1649 2793 +1649 3396 +1649 3397 +1649 3398 +3396 163 +3396 266 +3396 894 +3396 2196 +3396 2221 +3396 2443 +3396 4402 +3396 4689 +3396 4733 +3396 4734 +3398 341 +3398 1859 +3398 1955 +3398 2891 +3398 2905 +3398 3788 +3398 3822 +3398 4743 +3398 4744 +3398 4745 +4733 178 +4733 983 +4733 1679 +4733 2569 +4733 3590 +4733 3730 +4733 4526 +4733 4876 +4733 5447 +4733 5448 +4734 43 +4745 56 +4745 738 +4745 823 +4745 898 +4745 1568 +4745 2024 +4745 3681 +4745 4337 +4745 4769 +4745 5461 +1654 997 +1654 1023 +1654 2552 +1654 2825 +1654 2876 +1654 3282 +1654 3404 +1654 3405 +1654 3406 +1654 3407 +3406 1367 +3406 3292 +3406 3991 +3406 4739 +3406 4740 +3407 1246 +3407 1503 +3407 1650 +3407 1845 +3407 2343 +3407 3303 +3407 4206 +3407 4264 +3407 4741 +3407 4742 +4735 606 +4735 2249 +4735 3993 +4735 5473 +4735 5474 +4735 5475 +4739 260 +4739 762 +4739 1333 +4739 3475 +4739 3504 +4739 3807 +4739 3851 +4739 5454 +4739 5455 +4740 908 +4740 942 +4740 991 +4740 1412 +4740 2162 +4740 2708 +4740 3767 +4740 4113 +4740 5457 +4740 5458 +1657 89 +1657 547 +1657 1340 +1657 1658 +1657 1659 +1657 1660 +1657 1661 +1657 1662 +1657 1663 +1657 1664 +1663 266 +1663 1152 +1663 2257 +1663 2429 +1663 3140 +1663 3571 +3412 112 +3412 1636 +3412 2430 +3412 3760 +3412 4002 +3412 4402 +3412 4746 +3412 4747 +3412 4748 +3412 4749 +3571 199 +3571 293 +3571 364 +3571 659 +3571 1259 +3571 1266 +3571 2020 +3571 4831 +3571 4832 +3571 4833 +4754 115 +4754 124 +4754 483 +4754 521 +4754 1413 +4754 1654 +4754 1768 +4754 4113 +4754 4914 +4754 5467 +4751 8 +4751 122 +4751 129 +4751 177 +4751 249 +4751 251 +4751 352 +4751 353 +4751 367 +4751 856 +4746 798 +4746 2443 +4746 2635 +4746 2639 +4746 3071 +4746 3854 +4746 4811 +4746 5369 +4746 5462 +4746 5463 +4748 1337 +4748 1981 +4748 2383 +4748 3775 +4748 3810 +4748 4598 +4748 5102 +4748 5464 +4748 5465 +4748 5466 +4833 1056 +4833 1539 +4833 1974 +4833 2020 +4833 2114 +4833 2755 +4833 3277 +4833 4810 +4833 5521 +4833 5522 +1665 126 +1665 251 +1665 264 +1665 265 +1665 266 +1665 368 +1665 666 +1665 667 +1665 1666 +1665 1667 +4803 495 +4803 2497 +4803 3088 +4803 3422 +4803 4036 +4803 4187 +4803 4882 +4803 5043 +4803 5507 +4803 5508 +5082 348 +5082 731 +5082 1233 +5082 1323 +5082 1506 +5082 3213 +5082 3356 +5082 3468 +5082 4893 +5082 5373 +5043 2557 +5508 547 +5508 1301 +5508 2376 +5508 3813 +5508 4067 +5508 4382 +5508 5856 +5508 5857 +1668 71 +1668 1353 +1668 1669 +1668 1670 +1668 1671 +1674 513 +1674 1587 +1674 1675 +1674 1676 +1674 1677 +1674 1678 +1674 1679 +1674 1680 +1674 1681 +1674 1682 +1676 3 +1676 5 +1676 7 +1676 8 +1676 122 +1676 123 +1676 149 +1676 174 +1676 251 +1676 717 +1680 2131 +3428 1235 +3428 1539 +3428 1776 +3428 1947 +3428 3136 +3428 4373 +3428 4675 +3428 4755 +3428 4756 +3428 4757 +3430 4758 +4755 5 +4755 7 +4755 121 +4755 125 +4755 127 +4755 148 +4755 174 +4755 177 +4755 251 +4755 427 +4758 365 +4758 1321 +4758 1808 +4758 2304 +4758 3092 +4758 4031 +4758 4063 +4758 5451 +4758 5468 +1683 1684 +1687 721 +1687 1115 +1687 2359 +1687 3070 +1687 3100 +1687 3230 +1687 3439 +1687 3440 +1687 3441 +1687 3442 +4842 249 +1692 191 +1692 280 +1692 1084 +1692 1256 +1692 1693 +1692 1694 +1692 1695 +1692 1696 +1692 1697 +1692 1698 +1694 246 +1694 942 +1694 3032 +1694 3443 +1694 3444 +1694 3445 +1694 3446 +1694 3447 +1698 2026 +1698 2551 +1698 2850 +1698 2980 +1698 3220 +1698 3450 +1698 3451 +1698 3452 +1698 3453 +1698 3454 +3451 833 +3451 1599 +3451 1845 +3451 1881 +3451 1889 +3451 3218 +3451 3446 +3451 4541 +3451 4759 +3451 4760 +3452 9 +3452 17 +3452 143 +3452 144 +3452 147 +3452 149 +3452 179 +3452 424 +3452 559 +3452 2018 +4768 989 +4768 5477 +4769 983 +4769 2670 +4769 2986 +4769 3038 +4769 3337 +4769 4203 +4769 5085 +4769 5140 +4769 5471 +4769 5472 +4771 804 +4771 1090 +4771 1426 +4771 3951 +4771 4422 +1710 1711 +1712 1713 +1713 469 +1713 514 +1713 1219 +1713 1252 +1713 1776 +1713 2163 +1713 3472 +1713 3473 +1713 3474 +1713 3475 +4778 712 +4778 1034 +4778 1345 +4778 1743 +4778 1807 +4778 2391 +4778 3110 +4778 4003 +4778 5485 +4778 5486 +1722 1723 +1723 4 +1723 7 +1723 149 +1723 175 +1723 179 +1723 252 +1723 266 +1723 352 +1723 424 +1729 23 +1729 1058 +1729 1594 +1729 1647 +1729 1679 +1729 1730 +1729 1731 +1729 1732 +1729 1733 +1729 1734 +1732 9 +1732 128 +1732 148 +1732 149 +1732 175 +1732 179 +1732 238 +1732 352 +1732 353 +1732 559 +4826 230 +4826 1192 +4826 2217 +4826 2360 +4826 3903 +4826 4112 +4826 4215 +4826 5300 +4826 5523 +4826 5524 +3528 305 +3528 707 +3528 2285 +3528 2869 +3528 4726 +3528 4797 +3528 4798 +3528 4799 +3528 4800 +3528 4801 +3529 127 +3529 146 +3529 180 +3529 249 +3529 266 +3529 559 +3529 754 +3529 1245 +3529 2001 +4798 821 +4798 1456 +4798 1842 +4798 1955 +4798 2866 +4798 2889 +4798 3233 +4798 3805 +4798 5499 +4798 5500 +4799 1456 +4799 1618 +4799 2234 +4799 2896 +4799 4876 +4799 4883 +4799 5463 +4799 5498 +4800 1240 +4800 1559 +4800 1766 +4800 3205 +4800 3672 +4800 3678 +4800 4942 +4800 5503 +4800 5504 +4800 5505 +1742 577 +1742 813 +1742 938 +1742 1408 +1742 1600 +1742 1743 +1742 1744 +1742 1745 +1742 1746 +1742 1747 +1743 849 +1743 2016 +1743 2648 +1743 2735 +1743 2781 +1743 2836 +1743 3188 +1743 3500 +1743 3501 +1743 3502 +1746 255 +1746 406 +1746 538 +1746 889 +1746 2084 +1746 2314 +1746 2547 +1746 3503 +1746 3504 +1746 3505 +3500 2127 +3500 2420 +3500 4185 +3500 4626 +3500 4782 +3500 4783 +3500 4784 +3500 4785 +3500 4786 +3500 4787 +3503 176 +3503 937 +3503 1275 +3503 1387 +3503 2829 +3503 3596 +3503 4097 +3503 4445 +3503 4606 +3503 4788 +3505 3 +3505 143 +3505 145 +3505 177 +3505 251 +3505 353 +3505 753 +3505 754 +3505 3002 +3505 3132 +4782 1947 +4782 2524 +4782 2787 +4782 3140 +4782 3283 +4782 3288 +4782 3766 +4782 5487 +4782 5488 +4782 5489 +4783 51 +4783 651 +4783 1563 +4783 2186 +4783 2377 +4783 2452 +4783 2579 +4783 3418 +4783 3917 +4783 4293 +4784 122 +4784 123 +4784 124 +4784 127 +4784 129 +4784 248 +4784 845 +4784 2381 +4784 3305 +4784 5492 +4788 1909 +4788 1942 +4788 2068 +4788 4183 +4788 4216 +4788 4653 +4788 5115 +4788 5304 +4788 5493 +4788 5494 +1748 255 +1748 916 +1748 1028 +1748 1044 +1748 1564 +1748 1749 +1748 1750 +1748 1751 +1748 1752 +1751 103 +1751 123 +1751 3513 +1751 3514 +1751 3515 +3514 921 +3514 1160 +3514 1429 +3514 1898 +3514 2479 +3514 2555 +3514 3574 +3514 4600 +3514 4791 +3514 4792 +4790 547 +4790 909 +4790 1007 +4790 1812 +4790 2928 +4790 3033 +4790 4558 +4790 5050 +4790 5495 +4790 5496 +4792 769 +4792 874 +4792 1227 +4792 1894 +4792 2538 +4792 2670 +4792 4199 +4792 4338 +4792 4578 +4792 5327 +1753 182 +1753 1754 +1753 1755 +1753 1756 +1753 1757 +1753 1758 +1753 1759 +1753 1760 +1753 1761 +1753 1762 +3521 629 +3521 711 +3521 1049 +3521 2594 +3521 2650 +3521 2779 +3521 4096 +3521 4794 +3521 4795 +3521 4796 +3522 179 +3522 1089 +3522 1604 +3522 4096 +3522 4360 +3522 4362 +3522 4487 +3522 4516 +3522 4793 +1785 174 +1785 1574 +1785 1786 +1785 1787 +1785 1788 +1785 1789 +1785 1790 +1785 1791 +1785 1792 +1785 1793 +1793 1248 +1793 1901 +1793 2336 +1793 2543 +1793 2713 +1793 2818 +1793 2838 +1793 3541 +4805 55 +4805 325 +4805 490 +4805 963 +4805 1287 +4805 1370 +4805 1423 +4805 3577 +4805 5506 +4810 5 +4810 143 +4810 145 +4810 368 +4810 667 +4810 740 +4810 1548 +4810 2718 +4810 3002 +4810 3048 +1794 271 +1794 458 +1794 818 +1794 1250 +1794 1538 +1794 1766 +1794 1795 +1794 1796 +1794 1797 +1794 1798 +1799 554 +1799 655 +1799 661 +1799 853 +1799 1026 +1799 1800 +1799 1801 +1799 1802 +1799 1803 +1799 1804 +3542 470 +3542 2304 +3542 4625 +3542 4788 +3542 4793 +3542 4811 +3542 4812 +3542 4813 +3542 4814 +4811 3003 +4813 300 +4813 1434 +4813 1487 +4813 1730 +4813 2541 +4813 2787 +4813 2881 +4813 5510 +4815 463 +4815 1676 +4815 2274 +4815 2860 +4815 2900 +4815 3149 +4815 3295 +4815 4352 +4815 5509 +1818 18 +1818 270 +1818 725 +1818 1157 +1818 1575 +1818 3174 +1818 3413 +1818 3554 +1818 3555 +1818 3556 +1819 996 +1819 1492 +1819 2486 +1819 2869 +1819 3327 +1819 3563 +1819 3564 +1819 3565 +1819 3566 +1819 3567 +1820 894 +1820 1022 +1820 1139 +1820 2358 +1820 3557 +1820 3558 +1820 3559 +1820 3560 +1820 3561 +1820 3562 +3553 5 +3553 121 +3553 125 +3553 126 +3553 148 +3553 179 +3553 265 +3553 352 +3553 422 +3553 666 +3560 126 +3560 224 +3560 756 +3560 820 +3560 821 +3560 1362 +3560 3105 +3560 4450 +3560 4821 +3560 4822 +4822 1054 +4822 1561 +4822 1619 +4822 2310 +4822 2652 +4822 2713 +4822 2981 +4822 4598 +4822 5511 +4822 5512 +4837 5525 +1834 224 +1834 275 +1834 1287 +1834 1835 +1834 1836 +1834 1837 +1834 1838 +1834 1839 +1834 1840 +1839 53 +1839 222 +1839 818 +1839 2359 +1839 2377 +1839 2683 +1839 2767 +1839 3590 +1839 3591 +1839 3592 +1847 141 +1847 977 +1847 1848 +1847 1849 +1847 1850 +1847 1851 +1847 1852 +1847 1853 +1847 1854 +1847 1855 +1848 167 +1848 276 +1848 368 +1848 2127 +1848 2571 +1848 2787 +1848 2996 +1848 3593 +1848 3594 +4847 350 +4847 1040 +4847 1054 +4847 1512 +4847 2752 +4847 3417 +4847 4080 +4847 4251 +4847 4551 +4847 5526 +4852 554 +4852 763 +4852 1400 +4852 1881 +4852 4447 +4852 4645 +4852 5110 +4852 5527 +4852 5528 +4852 5529 +1856 289 +1856 1211 +1856 1857 +1856 1858 +1856 1859 +1856 1860 +1856 1861 +1856 1862 +1856 1863 +1857 757 +1857 758 +1857 884 +1857 2176 +1857 3609 +1857 3610 +1857 3611 +1857 3612 +1857 3613 +1857 3614 +3802 478 +3805 2059 +3805 2238 +3805 4508 +3805 5001 +3805 5848 +3805 5849 +3805 5850 +3805 5851 +3805 5852 +3805 5853 +4856 508 +4856 5393 +4856 5531 +4856 5532 +4857 114 +4857 387 +4857 473 +4857 531 +4857 588 +4857 1821 +4857 3511 +4857 4215 +4857 5530 +1864 58 +1864 924 +1864 1297 +1864 1606 +1864 1608 +1864 1865 +1864 1866 +1864 1867 +1864 1868 +1864 1869 +4864 141 +4864 279 +4864 1143 +4864 1443 +4864 2961 +4864 3452 +4864 5533 +4864 5534 +4864 5535 +4864 5536 +3621 4159 +1876 1288 +1877 477 +1877 534 +1877 1733 +1877 1878 +1877 1879 +1877 1880 +1877 1881 +1877 1882 +1877 1883 +1877 1884 +1880 219 +1880 363 +1880 846 +1880 925 +1880 1001 +1880 2563 +1880 3105 +1880 3629 +1880 3630 +1880 3631 +1883 534 +1883 621 +1883 944 +1883 1060 +1883 1261 +1883 2252 +1883 2789 +1883 3188 +1883 3673 +1883 3674 +1884 122 +1884 123 +1884 124 +1884 125 +1884 127 +1884 128 +1884 129 +1884 144 +1884 264 +1884 427 +3631 788 +3673 123 +3673 127 +3673 177 +3673 246 +3673 264 +3673 353 +3673 422 +3673 717 +3673 856 +3673 1245 +4874 123 +4874 249 +4874 250 +4874 251 +4874 264 +4874 422 +4874 427 +4874 1245 +4874 2001 +4875 107 +4875 1229 +4875 2093 +4875 2350 +4875 2408 +4875 2890 +4875 3395 +4875 3542 +4875 4158 +4875 5333 +4867 493 +4867 600 +4867 725 +4867 1034 +4867 2347 +4867 3968 +4867 5283 +4867 5543 +4867 5544 +4880 1598 +4880 4333 +4880 4395 +4880 5295 +4880 5545 +4880 5546 +4880 5547 +4880 5548 +4880 5549 +4881 5672 +4890 223 +4890 1029 +4890 1524 +4890 1695 +4890 1956 +4890 2911 +4890 3489 +4890 3590 +4890 3695 +4890 5553 +4900 5 +4900 8 +4900 121 +4900 129 +4900 149 +4900 174 +4900 179 +4900 249 +4900 251 +4900 352 +4902 996 +4902 2868 +4902 3188 +4902 3580 +4902 3804 +4902 4563 +4902 4903 +4902 5556 +4902 5557 +4902 5558 +4903 2679 +4903 3195 +4903 3822 +4903 4732 +4903 5056 +4903 5559 +4903 5560 +4903 5561 +4903 5562 +4908 424 +4908 5314 +4908 5563 +4908 5564 +4908 5565 +6138 129 +6138 143 +6138 146 +6138 177 +6138 249 +6138 367 +6138 369 +6138 423 +6138 424 +6138 2338 +5682 364 +5682 852 +5682 1700 +5682 1910 +5682 1945 +5682 2085 +5682 3299 +5682 4891 +5682 5116 +5682 5837 +4921 219 +4921 1798 +4921 2129 +4921 2235 +4921 4468 +4918 5577 +4932 1943 +4932 2276 +4932 2723 +4932 3786 +4932 4623 +4932 5572 +4932 5573 +4932 5574 +4932 5575 +4932 5576 +5089 3981 +5892 6049 +5893 8 +5893 124 +5893 238 +5893 248 +5893 249 +5893 251 +5893 352 +5893 422 +5893 423 +5893 667 +4937 1412 +4937 2162 +4937 2500 +4937 4012 +4937 4589 +4937 4811 +4937 4825 +4937 4889 +4937 5349 +4937 5578 +4935 1136 +4935 2151 +4935 2785 +4935 3849 +4935 3856 +4935 4103 +4935 5388 +4935 5448 +4935 5585 +4935 5586 +4940 988 +4940 1273 +4940 1480 +4940 2148 +4940 2201 +4940 2787 +4940 3169 +4940 3636 +4940 5579 +4940 5580 +4948 5583 +4949 31 +4949 127 +4949 143 +4949 368 +4949 422 +4949 427 +4949 558 +4949 856 +4949 2001 +4951 748 +4951 780 +4951 803 +4951 1280 +4951 2236 +4951 2285 +4951 2568 +4951 2583 +4951 4641 +4951 4799 +5024 114 +5028 156 +5028 1037 +5028 1129 +5028 1203 +5028 2752 +5028 3064 +5028 3797 +5028 5353 +5028 5605 +5267 3 +5267 9 +5267 122 +5267 125 +5267 126 +5267 145 +5267 149 +5267 174 +5267 247 +5267 1317 +5937 817 +5937 1652 +5937 3083 +5937 4075 +5937 5614 +5939 325 +5939 1007 +5939 1952 +5939 2477 +5939 3124 +5939 3416 +5939 3543 +5939 4877 +5939 5896 +5939 6072 +4986 200 +4986 1038 +4986 1044 +4986 2036 +4986 2425 +4986 3566 +4986 3794 +4986 4262 +4986 5588 +4986 5589 +4988 5 +4988 9 +4988 126 +4988 148 +4988 174 +4988 264 +4988 390 +4988 558 +4988 559 +4999 123 +4999 149 +4999 179 +4999 427 +4995 800 +4995 1590 +4995 1600 +4995 1872 +4995 2860 +4995 2930 +4995 3674 +4995 5291 +4995 5590 +5003 2916 +5003 2964 +5003 2981 +5003 3629 +5003 4247 +5003 5220 +5003 5507 +5003 5591 +5003 5592 +5003 5593 +5007 1880 +5007 2841 +5007 3460 +5007 4111 +5007 4619 +5007 5594 +5007 5595 +5007 5596 +5007 5597 +5007 5598 +5008 31 +5008 123 +5008 176 +5008 250 +5008 1317 +5008 1518 +5008 3781 +5008 3934 +5008 4754 +5008 5599 +5890 285 +5012 266 +5012 440 +5012 826 +5012 852 +5012 2394 +5012 2552 +5012 3334 +5012 3456 +5012 4281 +5021 5604 +5026 1050 +5026 1447 +5026 1590 +5026 1689 +5026 1912 +5026 2194 +5026 2337 +5026 4133 +5026 5602 +5026 5603 +5037 2765 +5037 5611 +5029 146 +5029 177 +5029 353 +5029 1047 +5029 1135 +5029 2130 +5029 2338 +5029 3503 +5029 4453 +5029 5617 +5030 281 +5030 1168 +5030 1447 +5030 1451 +5030 1590 +5030 2353 +5030 2885 +5030 3069 +5030 4687 +5030 4877 +5034 3029 +5035 2857 +5035 3681 +5035 3727 +5035 3772 +5035 4663 +5035 5606 +5035 5607 +5035 5608 +5035 5609 +5035 5610 +5272 203 +5272 852 +5272 1614 +5272 1797 +5272 2652 +5272 2706 +5272 5735 +5272 5736 +5272 5737 +5042 2968 +5044 122 +5044 123 +5044 125 +5044 144 +5044 174 +5044 352 +5044 369 +5044 424 +5044 427 +5044 2338 +5045 1015 +5045 2869 +5045 3084 +5045 5056 +5045 5080 +5045 5096 +5045 5425 +5045 5614 +5045 5615 +5045 5616 +5052 198 +5052 356 +5052 558 +5052 2234 +5052 2285 +5052 2354 +5052 3035 +5052 3133 +5052 4892 +5052 5618 +5924 276 +5924 619 +5924 1568 +5924 1983 +5924 2276 +5924 3173 +5924 3891 +5924 4052 +5924 5911 +5924 6071 +5925 125 +5925 229 +5925 3257 +5925 3852 +5925 4882 +5925 4894 +5925 5086 +5925 5128 +5925 5229 +5925 6070 +5066 164 +5066 523 +5066 815 +5066 2155 +5066 2237 +5066 2548 +5066 3407 +5066 4319 +5066 5159 +5066 5620 +5067 804 +5067 940 +5067 1710 +5067 2844 +5067 3407 +5067 4364 +5067 5434 +5067 5631 +5067 5632 +5067 5633 +5069 5623 +5058 85 +5058 153 +5058 919 +5058 1956 +5058 2112 +5058 2410 +5058 2414 +5058 4735 +5058 5196 +5058 5452 +5060 363 +5063 574 +5063 2006 +5063 2375 +5063 2704 +5063 3900 +5063 4114 +5063 5083 +5063 5301 +5063 5475 +5063 5619 +5065 21 +5065 503 +5065 997 +5065 3296 +5065 3931 +5065 4324 +5065 4801 +5065 4826 +5065 5621 +5065 5622 +5073 363 +5073 462 +5073 518 +5073 1047 +5073 2127 +5073 2612 +5073 3083 +5073 4408 +5073 5624 +5073 5625 +5074 311 +5074 1362 +5074 1539 +5074 2087 +5074 2204 +5074 2354 +5074 2579 +5074 3205 +5074 5546 +5075 462 +5075 1454 +5075 1587 +5075 1846 +5075 1903 +5075 2511 +5075 3570 +5075 3586 +5075 5626 +5075 5627 +5077 837 +5077 2842 +5077 3743 +5077 4270 +5077 5634 +5281 7 +5281 174 +5281 390 +5281 699 +5281 753 +5281 754 +5281 762 +5281 2064 +5281 2077 +5281 3118 +5510 122 +5510 175 +5510 247 +5510 249 +5510 250 +5510 251 +5510 367 +5510 390 +5510 422 +5510 667 +5657 667 +5657 1923 +5657 2005 +5657 3083 +5657 3200 +5657 4234 +5657 4324 +5657 5016 +5657 5922 +5083 211 +5083 581 +5083 599 +5083 605 +5083 1486 +5083 1855 +5083 2500 +5083 3251 +5083 3402 +5083 3982 +5078 531 +5078 605 +5078 810 +5078 813 +5078 924 +5078 1867 +5078 1868 +5078 2677 +5078 3336 +5078 5630 +5090 122 +5090 123 +5090 129 +5090 143 +5090 147 +5090 177 +5090 367 +5090 368 +5090 390 +5090 1245 +5102 23 +5102 1022 +5102 1044 +5102 1867 +5102 3414 +5102 3488 +5102 4039 +5102 5475 +5102 5637 +5102 5638 +5361 2035 +5361 4945 +5361 5115 +5361 5352 +5361 5789 +5361 5790 +5361 5791 +5361 5792 +5361 5793 +5361 5794 +5291 5660 +5291 5661 +5291 5662 +5291 5663 +5291 5664 +5291 5665 +5291 5666 +5291 5667 +5291 5668 +5291 5669 +5928 4 +5928 127 +5928 143 +5928 146 +5928 175 +5928 264 +5928 390 +5928 427 +5928 558 +5096 145 +5096 359 +5096 427 +5096 605 +5096 881 +5096 1861 +5096 3402 +5096 3550 +5096 5635 +5096 5636 +5104 23 +5104 689 +5104 910 +5104 967 +5104 1424 +5104 2552 +5104 2787 +5104 3487 +5104 4400 +5104 5277 +5110 38 +5110 2018 +5110 2148 +5110 2666 +5110 3895 +5110 3935 +5110 4838 +5110 4855 +5110 5642 +5110 5643 +5113 893 +5113 1407 +5113 1590 +5113 1772 +5113 1862 +5113 2269 +5113 3716 +5113 4432 +5113 5291 +5113 5641 +5129 848 +5129 1150 +5129 1956 +5129 2094 +5129 3283 +5129 3781 +5129 4256 +5129 4874 +5129 5293 +5129 5644 +5131 823 +5131 1787 +5131 2288 +5131 2566 +5131 3109 +5131 3797 +5131 4248 +5131 4895 +5131 5645 +5131 5646 +5120 626 +5147 123 +5147 1321 +5147 3052 +5147 4213 +5147 4929 +5147 4998 +5147 5301 +5147 5653 +5147 5654 +5147 5655 +5135 184 +5135 613 +5135 2973 +5135 4111 +5135 5647 +5135 5648 +5135 5649 +5135 5650 +5135 5651 +5135 5652 +5149 802 +5149 2125 +5149 2499 +5149 5656 +5149 5657 +5151 219 +5151 459 +5151 612 +5151 1102 +5151 2403 +5151 3017 +5151 5510 +5151 5658 +5151 5659 +5152 380 +5152 666 +5152 1540 +5152 1751 +5152 2577 +5152 3174 +5152 3658 +5152 4578 +5152 5199 +5152 5581 +5053 116 +5053 906 +5053 1250 +5053 1541 +5053 1859 +5053 3114 +5053 3319 +5053 3726 +5053 4189 +5156 3370 +5158 4402 +5160 201 +5160 400 +5160 459 +5160 1484 +5160 2023 +5160 2492 +5160 3594 +5160 3715 +5160 3849 +5160 4487 +5670 268 +5670 522 +5670 2538 +5670 2735 +5670 4969 +5670 5149 +5670 5887 +5670 5930 +5670 5931 +5670 5932 +5167 1886 +5167 1940 +5167 1980 +5167 2569 +5167 3069 +5167 3125 +5167 4125 +5167 5672 +5167 5673 +5167 5674 +5168 229 +5168 1039 +5168 1192 +5168 1458 +5168 2127 +5168 2974 +5168 4563 +5168 5678 +5168 5679 +5168 5680 +5183 363 +5183 1706 +5183 1711 +5183 2055 +5183 2481 +5183 4436 +5183 4559 +5183 5094 +5183 5494 +5183 5688 +5187 302 +5187 1184 +5187 1946 +5187 3023 +5187 3414 +5187 3988 +5187 5065 +5187 5184 +5187 5689 +5187 5690 +5190 1056 +5191 2693 +5191 4129 +5191 4809 +5191 5051 +5191 5508 +5191 5691 +5191 5692 +5191 5693 +5191 5694 +5195 521 +5195 1070 +5195 3782 +5195 3962 +5195 3977 +5195 4031 +5195 5434 +5195 5604 +5195 5700 +5195 5701 +5196 107 +5196 326 +5196 1928 +5196 2313 +5196 3598 +5196 4082 +5196 4423 +5196 5695 +5196 5696 +5196 5697 +5197 48 +5197 968 +5197 1814 +5197 2055 +5197 2164 +5197 3112 +5197 5441 +5197 5475 +5197 5698 +5197 5699 +5202 158 +5202 202 +5202 255 +5202 532 +5202 553 +5202 573 +5202 823 +5202 883 +5202 914 +5202 923 +5202 979 +5202 1047 +5202 1213 +5202 1615 +5202 1708 +5202 1789 +5202 1805 +5202 1808 +5202 1868 +5202 1881 +5202 2015 +5202 2035 +5202 2555 +5202 2664 +5202 2693 +5202 2721 +5202 2905 +5202 3153 +5202 3288 +5202 3351 +5202 3479 +5202 3511 +5202 3740 +5202 3861 +5202 4093 +5202 4333 +5202 4453 +5202 4563 +5202 4623 +5202 4873 +5202 4912 +5202 5029 +5202 5051 +5202 5321 +5202 5629 +5202 5702 +5200 605 +5200 1714 +5200 2017 +5200 3142 +5200 3402 +5200 4176 +5200 5710 +5200 5711 +5200 5712 +5200 5713 +5201 127 +5201 129 +5201 146 +5201 176 +5201 238 +5201 264 +5201 352 +5201 717 +5201 1245 +5201 2338 +5952 714 +5952 1627 +5952 2047 +5952 2475 +5952 3232 +5952 4012 +5952 5287 +5952 5508 +5952 5815 +5952 6080 +6163 491 +6163 744 +6163 851 +6163 2202 +6163 2583 +6163 3089 +6163 3601 +6163 5826 +6163 6041 +6163 6233 +6165 255 +6165 376 +6165 777 +6165 1229 +6165 3190 +6165 3683 +6165 4757 +6165 4885 +6165 5593 +6165 5801 +5529 345 +5529 2377 +5529 3285 +5529 3334 +5529 4160 +5529 4735 +5529 4986 +5529 5168 +5529 5866 +5529 5867 +5970 86 +5970 477 +5970 586 +5970 1240 +5970 1770 +5970 4756 +5970 4844 +5970 5627 +5970 6090 +6288 77 +6288 5097 +6288 5211 +6288 6287 +6288 6296 +5206 43 +5206 169 +5206 219 +5206 246 +5206 2652 +5206 3058 +5206 3601 +5206 3925 +5206 3944 +5206 5704 +5207 544 +5207 816 +5207 1504 +5207 1764 +5207 1765 +5207 2069 +5207 4846 +5207 5499 +5207 5708 +5207 5709 +5214 1193 +5214 1926 +5214 2236 +5214 2337 +5214 2847 +5214 4018 +5214 5081 +5214 5235 +5214 5714 +5220 1168 +5220 1480 +5220 2823 +5220 4137 +5220 4740 +5220 4929 +5220 5715 +5220 5716 +5220 5717 +5220 5718 +5221 96 +5221 292 +5221 334 +5221 400 +5221 1122 +5221 1177 +5221 1377 +5221 2322 +5221 3306 +5221 5719 +5226 748 +5226 1316 +5226 1326 +5226 1487 +5226 2414 +5226 2639 +5226 2901 +5226 3192 +5226 3849 +5226 4765 +5227 480 +5227 1039 +5227 1654 +5227 3348 +5227 5138 +5227 5427 +5227 5721 +5227 5722 +5227 5723 +5227 5724 +5228 136 +5222 3301 +5245 123 +5245 127 +5245 146 +5245 147 +5245 175 +5245 247 +5245 250 +5245 369 +5245 423 +5253 976 +5253 1787 +5253 1809 +5253 2156 +5253 2309 +5253 3185 +5253 4448 +5253 4641 +5253 4793 +5254 450 +5254 2308 +5254 3488 +5254 4426 +5254 4654 +5254 4998 +5254 5474 +5254 5594 +5254 5731 +5254 5732 +5255 147 +5255 248 +5255 422 +5255 427 +5255 2001 +5255 2018 +5255 2968 +5255 3804 +5255 5636 +5255 5730 +5257 76 +5257 726 +5257 3877 +5257 3903 +5257 5734 +5259 4540 +5251 5368 +5251 5738 +5251 5739 +5251 5740 +5251 5741 +5251 5742 +5251 5743 +5251 5744 +5251 5745 +5251 5746 +5263 124 +5263 143 +5263 147 +5263 247 +5263 390 +5263 422 +5263 423 +5263 427 +5263 2001 +5250 5733 +5270 2398 +5270 3350 +5270 3385 +5270 4375 +5270 5482 +5276 235 +5276 342 +5276 1591 +5276 3205 +5276 3428 +5276 4041 +5276 4740 +5276 5321 +5276 5747 +5276 5748 +5279 1402 +5279 2035 +5279 3080 +5279 4882 +5279 5749 +5273 680 +5273 1267 +5273 2268 +5273 2465 +5273 5757 +5290 3476 +5285 3440 +5285 5296 +5285 5748 +5285 5750 +5285 5751 +5285 5752 +5285 5753 +5285 5754 +5285 5755 +5285 5756 +5292 1240 +5292 3029 +5292 4641 +5292 5159 +5292 5766 +5294 64 +5294 2633 +5294 3205 +5294 3218 +5294 4205 +5294 4939 +5294 5759 +5294 5760 +5294 5761 +5294 5762 +5296 1001 +5296 1948 +5296 4735 +5296 4788 +5296 5073 +5296 5398 +5296 5504 +5296 5763 +5296 5764 +5296 5765 +5339 124 +5339 147 +5339 175 +5339 247 +5339 250 +5339 367 +5339 368 +5339 369 +5339 559 +5339 754 +5352 149 +5352 266 +5352 1317 +5352 1414 +5352 2197 +5352 2837 +5352 3614 +5352 4427 +5352 4844 +5352 5767 +5315 63 +5315 2927 +5315 3346 +5315 4771 +5315 5161 +5315 5578 +5315 5769 +5315 5770 +5315 5771 +5315 5772 +5318 346 +5318 1861 +5318 1922 +5318 2353 +5318 2360 +5318 2456 +5318 3190 +5318 3418 +5318 5773 +5318 5774 +5321 255 +5321 1115 +5321 1845 +5321 1928 +5321 3933 +5321 4074 +5321 4129 +5321 5510 +5321 5775 +5321 5776 +5763 2583 +5763 3359 +5763 3797 +5763 3992 +5763 5118 +5763 5719 +5763 5971 +5763 5972 +5332 121 +5332 129 +5332 352 +5332 424 +5332 5731 +6249 1402 +6249 4068 +6249 4281 +6249 4311 +6249 4540 +6249 4854 +6249 6151 +6249 6268 +6249 6269 +6249 6270 +6251 554 +6251 1524 +6251 1956 +6251 2023 +6251 2777 +6251 3038 +6251 4629 +6251 6102 +6251 6262 +6251 6263 +6252 2015 +6252 3509 +6252 3991 +6252 4691 +6252 5528 +6252 6098 +6252 6264 +6252 6265 +6252 6266 +6252 6267 +5347 20 +5347 54 +5347 146 +5347 534 +5347 749 +5347 1901 +5347 2616 +5347 3292 +5347 4051 +5347 5224 +5347 5348 +5347 5462 +5347 5542 +5347 5616 +5347 5632 +5347 5783 +5347 5784 +5356 685 +5356 2002 +5356 2036 +5356 3407 +5356 3455 +5357 1516 +5357 5474 +5357 5816 +5359 4 +5359 125 +5359 175 +5359 352 +5359 368 +5359 558 +5359 717 +5359 856 +5359 1317 +5359 2338 +5366 942 +5366 1456 +5366 2230 +5366 2366 +5366 2612 +5366 2841 +5366 2982 +5366 3707 +5366 5798 +5380 1001 +5372 2594 +5373 204 +5373 1049 +5373 1685 +5373 2088 +5373 4013 +5373 4317 +5373 4659 +5373 4909 +5373 5633 +5373 5799 +5378 296 +5378 352 +5378 1358 +5378 3221 +5378 3446 +5378 3519 +5378 5432 +5378 5612 +5378 5800 +5379 2579 +5386 5 +5386 125 +5386 129 +5386 174 +5386 238 +5386 248 +5386 250 +5386 252 +5386 1084 +5389 2634 +5385 309 +5385 1120 +5385 1511 +5385 2007 +5385 2090 +5385 5074 +5385 5636 +5385 5729 +5385 5801 +5385 5802 +5406 38 +5406 740 +5406 1956 +5406 2060 +5406 2391 +5406 4170 +5406 5096 +5406 5510 +5406 5803 +5406 5804 +5410 275 +5410 605 +5410 1123 +5410 1430 +5410 1818 +5410 2721 +5410 3919 +5410 5809 +5410 5810 +5410 5811 +5436 1956 +5413 1310 +5413 1883 +5413 3621 +5413 4694 +5413 4723 +5413 4727 +5413 5542 +5413 5820 +5413 5821 +5413 5822 +5421 2146 +5423 285 +5423 582 +5423 707 +5423 1044 +5423 3202 +5423 4368 +5423 4828 +5423 5100 +5423 5442 +5423 5685 +5425 415 +5425 1158 +5425 1383 +5425 2059 +5425 2677 +5425 2869 +5425 3213 +5425 3516 +5425 4377 +5425 5616 +5432 379 +5432 418 +5432 513 +5432 882 +5432 2354 +5432 2684 +5432 4779 +5432 5344 +5432 5734 +5432 5817 +5440 196 +5440 558 +5440 1021 +5440 1088 +5440 1447 +5440 3374 +5440 4885 +5440 5245 +5440 5818 +5440 5819 +5443 898 +5443 1115 +5443 1227 +5443 3217 +5443 4128 +5443 5823 +5443 5824 +5443 5825 +5443 5826 +5457 438 +5457 908 +5457 991 +5457 3767 +5457 4486 +5457 4487 +5457 5554 +5457 5829 +5457 5830 +5458 2719 +5459 385 +5459 870 +5459 1048 +5459 1980 +5459 4793 +5459 5831 +5459 5832 +5459 5833 +5459 5834 +5464 2005 +5464 2532 +5464 2862 +5464 3564 +5464 3860 +5464 4633 +5464 5155 +5464 5425 +5464 5823 +5464 5835 +5472 866 +5472 1288 +5472 1433 +5472 3061 +5472 3796 +5472 4166 +5472 4382 +5472 4866 +5472 5211 +5472 5839 +5486 1056 +5486 1160 +5486 1199 +5486 2709 +5486 3489 +5486 3977 +5486 4332 +5486 5836 +5486 5837 +5486 5838 +5492 163 +5492 1968 +5492 2648 +5492 4844 +5492 5475 +5492 5767 +5492 5841 +5492 5842 +5492 5843 +5492 5844 +5495 183 +5495 610 +5495 1848 +5495 2044 +5495 3471 +5495 3516 +5495 4940 +5495 5118 +5495 5211 +5495 5847 +5499 3635 +5499 4128 +5499 4462 +5499 4670 +5499 5828 +5500 2059 +5498 144 +5498 145 +5498 147 +5498 148 +5498 149 +5498 175 +5498 367 +5498 390 +5498 718 +5504 505 +5504 3293 +5504 3778 +5504 4293 +5504 4458 +5504 5121 +5504 5703 +5504 5792 +5504 5854 +5504 5855 +5505 295 +5509 1405 +5509 2218 +5509 3288 +5509 4501 +5509 4854 +5509 5859 +5509 5860 +5509 5861 +5509 5862 +5523 241 +5528 2716 +5528 4483 +5528 4660 +5528 4771 +5528 4929 +5528 4970 +5528 5863 +5528 5864 +5528 5865 +5531 1945 +5531 1955 +5531 2062 +5531 2399 +5531 2617 +5531 2850 +5531 2874 +5531 5405 +5531 5902 +5531 5903 +5532 8 +5532 17 +5532 126 +5532 129 +5532 147 +5532 250 +5532 422 +5532 424 +5532 3937 +5535 2499 +5535 2670 +5535 2958 +5535 3067 +5535 3629 +5535 3674 +5535 4276 +5535 4840 +5535 5811 +5535 5835 +5543 123 +5543 146 +5543 249 +5543 264 +5543 352 +5543 369 +5543 422 +5543 423 +5543 427 +5543 2338 +5545 63 +5545 629 +5545 1034 +5545 1384 +5545 2078 +5545 2249 +5545 2386 +5545 2698 +5545 2780 +5545 3110 +5545 3517 +5545 4503 +5545 4838 +5545 6292 +5545 6293 +5545 6294 +5545 6295 +5548 4453 +5548 5012 +5548 5634 +5548 5871 +5548 5872 +5568 894 +5568 1420 +5568 1575 +5568 4368 +5568 4804 +5565 705 +5565 1029 +5565 1084 +5565 3765 +5565 3818 +5565 5874 +5565 5875 +5565 5876 +5565 5877 +5565 5878 +6049 157 +6049 500 +6049 664 +6049 1017 +6049 1715 +6049 2991 +6049 3293 +6049 6140 +6049 6141 +6049 6142 +5585 106 +5585 1949 +5585 2593 +5585 2594 +5585 2595 +5585 2892 +5585 3343 +5585 4613 +5585 5887 +5585 5888 +5578 1511 +5578 1762 +5578 2090 +5578 5580 +5578 5883 +5580 2881 +5614 4415 +5587 5300 +5589 203 +5589 697 +5589 750 +5589 913 +5589 2716 +5589 4156 +5589 4189 +5589 5407 +5589 5449 +5590 706 +5590 800 +5590 1600 +5590 1766 +5590 5885 +5597 419 +5597 1025 +5597 1728 +5597 4779 +5597 5886 +6255 757 +5602 1085 +5602 1333 +5603 1094 +5603 1495 +5603 1597 +5603 1608 +5603 1788 +5603 2689 +5603 3053 +5603 4295 +5603 4702 +5603 5895 +5613 1454 +5613 2191 +5613 3328 +5613 3574 +5613 4885 +5613 5576 +5613 5704 +5613 5784 +5613 5887 +5613 5896 +5608 65 +5608 311 +5608 612 +5608 2308 +5608 2566 +5608 3539 +5608 5004 +5608 5897 +5608 5898 +5608 5899 +5615 1082 +5615 1923 +5615 2005 +5615 2207 +5615 2726 +5615 3125 +5615 3376 +5615 4854 +5615 5900 +5615 5901 +5616 133 +5616 813 +5616 1533 +5616 2215 +5616 2391 +5616 2625 +5616 2847 +5616 3836 +5616 4484 +5618 637 +5618 969 +5618 1039 +5618 1311 +5618 1541 +5618 2444 +5618 2646 +5618 4798 +5618 5904 +5618 5905 +5623 212 +5623 531 +5623 1094 +5623 1665 +5623 2298 +5623 2468 +5623 5378 +5623 5906 +5623 5907 +5623 5908 +5619 261 +5619 391 +5619 898 +5619 1212 +5619 1866 +5619 1867 +5619 2149 +5619 2973 +5619 3982 +5619 4237 +5625 686 +5625 1863 +5625 1940 +5625 2794 +5625 3193 +5625 3205 +5625 4891 +5625 5912 +5625 5913 +5626 584 +5626 1203 +5626 1509 +5626 3253 +5626 4037 +5626 4632 +5626 5837 +5626 5909 +5626 5910 +5626 5911 +5630 290 +5630 380 +5630 3299 +5630 5914 +5630 5915 +5792 3 +5792 123 +5792 126 +5792 127 +5792 129 +5792 144 +5792 179 +5792 351 +5792 353 +5792 1317 +5793 436 +5793 551 +5793 1458 +5793 1509 +5793 2804 +5793 3233 +5793 5837 +5793 5983 +5793 5984 +5793 5985 +5794 771 +5794 1637 +5794 1940 +5794 5429 +5794 5986 +5794 5987 +5794 5988 +5794 5989 +5794 5990 +5794 5991 +5643 5918 +5644 643 +5644 877 +5644 1316 +5644 1335 +5644 1928 +5644 3027 +5644 4101 +5644 5916 +5644 5917 +5654 3 +5654 123 +5654 124 +5654 127 +5654 247 +5654 369 +5654 390 +5654 666 +5654 667 +5654 856 +5650 5921 +5651 290 +5651 2379 +5651 2898 +5651 3367 +5651 3489 +5651 5288 +5651 5887 +5651 5919 +5651 5920 +5656 442 +5680 531 +5680 678 +5680 3124 +5680 3232 +5680 3571 +5680 4006 +5680 4193 +5680 4307 +5680 5589 +5680 5936 +5691 3481 +5701 603 +5701 1552 +5701 1720 +5701 2081 +5701 2177 +5701 2933 +5701 3224 +5701 3543 +5701 3743 +5701 5406 +5695 1384 +5695 2219 +5695 5254 +5695 5975 +5708 5943 +5703 789 +5707 823 +5716 206 +5716 941 +5716 2037 +5716 2823 +5716 4639 +5716 4694 +5716 4809 +5716 5944 +5716 5945 +5716 5946 +5740 2018 +5742 381 +5742 448 +5742 1311 +5742 1850 +5742 2663 +5742 3460 +5742 3801 +5742 4365 +5742 5677 +5742 5961 +5735 1120 +5735 1375 +5735 2027 +5735 3109 +5735 3335 +5735 3930 +5735 4986 +5735 5956 +5735 5957 +5757 4570 +5750 487 +5750 491 +5750 811 +5750 862 +5750 1509 +5750 1757 +5750 2127 +5750 4287 +5750 5962 +5750 5963 +5751 5168 +5753 244 +5753 835 +5753 1321 +5753 1890 +5753 3446 +5753 4639 +5753 4881 +5753 5368 +5753 5966 +5753 5967 +5754 870 +5754 1048 +5754 2537 +5754 3563 +5754 3993 +5754 4622 +5754 5729 +5754 5920 +5754 5964 +5754 5965 +5755 3509 +5759 704 +5759 837 +5759 1137 +5759 1928 +5759 4095 +5759 5230 +5759 5931 +5759 5968 +5759 5969 +5761 1388 +5761 2176 +5761 2385 +5761 3018 +5761 3516 +5761 4776 +5761 5050 +5761 5567 +5761 5826 +5761 5970 +5542 495 +5542 1194 +5542 1261 +5542 1587 +5542 2089 +5542 2384 +5542 2541 +5542 4782 +5542 4813 +5542 4945 +5783 351 +5783 996 +5783 3249 +5783 5779 +5783 5823 +5783 5976 +5783 5977 +5783 5978 +5783 5979 +5802 4273 +5804 1538 +5804 3345 +5804 3702 +5804 4939 +5804 5988 +5804 5992 +5804 5993 +5804 5994 +5804 5995 +5804 5996 +5809 4 +5809 7 +5809 8 +5809 126 +5809 129 +5809 144 +5809 175 +5809 179 +5809 1317 +5811 222 +5811 342 +5811 2324 +5811 2445 +5811 2475 +5811 2612 +5811 4131 +5811 4597 +5811 4885 +5820 1831 +5820 2472 +5820 2627 +5820 4060 +5820 5501 +5820 5657 +5820 6002 +5820 6003 +5820 6004 +5820 6005 +5821 491 +5821 858 +5821 983 +5821 1313 +5821 1458 +5821 3388 +5821 5534 +5821 5837 +5821 6006 +5821 6007 +5827 3077 +5827 3964 +5827 4614 +5827 5323 +5827 6059 +5827 6060 +5828 122 +5828 246 +5828 264 +5819 123 +5819 143 +5819 177 +5819 179 +5819 247 +5819 264 +5819 367 +5819 369 +5819 422 +5819 1246 +5824 1592 +5824 1993 +5824 2267 +5824 2650 +5824 2672 +5824 2720 +5824 4128 +5824 5771 +5824 5958 +5824 5974 +5829 3480 +5830 529 +5830 942 +5830 2622 +5830 2797 +5830 2798 +5830 4469 +5830 5593 +5830 6023 +5830 6024 +5830 6025 +5831 8 +5831 36 +5831 57 +5831 75 +5831 102 +5831 252 +5831 311 +5831 383 +5831 582 +5831 583 +5831 611 +5831 634 +5831 654 +5831 1157 +5831 1173 +5831 1477 +5831 1872 +5831 1890 +5831 1931 +5831 2248 +5831 2746 +5831 2767 +5831 2931 +5831 2941 +5831 3115 +5831 3161 +5831 3343 +5831 3981 +5831 4115 +5831 4159 +5831 4303 +5831 5184 +5831 5528 +5831 5872 +5831 5931 +5831 5932 +5831 6012 +5831 6013 +5831 6014 +5831 6015 +5831 6016 +5831 6017 +5831 6018 +5831 6019 +5831 6020 +5831 6021 +5831 6022 +5831 6023 +5834 124 +5834 177 +5834 248 +5834 249 +5834 1245 +5882 261 +5882 337 +5882 442 +5882 1530 +5882 1952 +5882 3732 +5882 3989 +5882 5086 +5882 5261 +5882 5546 +5847 518 +5847 1240 +5847 1691 +5847 5511 +5847 6026 +5847 6027 +5847 6028 +5847 6029 +5847 6030 +5854 1087 +5854 3084 +5854 4068 +5854 5556 +5854 5626 +5854 5976 +5854 5977 +5854 5979 +5854 6031 +5854 6032 +5855 171 +5855 788 +5855 3378 +5855 3385 +5855 5523 +5855 5735 +5855 5850 +5855 6033 +5855 6034 +5855 6035 +5866 2232 +5866 3481 +6293 117 +6293 274 +6293 788 +6293 1100 +6293 2249 +6293 2635 +6293 3344 +6293 5155 +6293 5685 +6293 6300 +5887 1240 +5887 2690 +5887 3946 +5887 6042 +5887 6043 +5887 6044 +5887 6045 +5887 6046 +5887 6047 +5887 6048 +5886 285 +5886 1592 +5886 1761 +5886 2563 +5886 2646 +5886 5487 +5886 5617 +5886 5941 +5886 6023 +5886 6041 +5897 758 +5897 918 +5897 919 +5897 1865 +5897 5562 +5897 5576 +5897 6050 +5897 6051 +5897 6052 +5897 6053 +5899 17 +5899 96 +5899 3376 +5899 4024 +5899 4987 +5899 5230 +5899 5341 +5899 6056 +5899 6057 +5899 6058 +5901 664 +5901 2663 +5901 3415 +5901 3906 +5901 5407 +5901 5415 +5901 5781 +5901 6054 +5901 6055 +5905 130 +5905 570 +5905 1261 +5905 1511 +5905 1921 +5905 3722 +5905 4485 +5905 4875 +5905 4979 +5905 5723 +5907 796 +5907 1380 +5907 1892 +5907 4131 +5907 4268 +5907 5442 +5907 6063 +5907 6064 +5907 6065 +5915 1255 +5915 1677 +5915 2161 +5915 2612 +5915 2622 +5915 3194 +5915 3954 +5915 4754 +5915 6066 +5915 6067 +5921 1064 +5921 2450 +5921 2552 +5921 3698 +5921 4109 +5921 4507 +5921 4793 +5921 5788 +5921 6068 +5921 6069 +5932 552 +5936 31 +5936 485 +5936 1127 +5936 2424 +5936 3214 +5936 3771 +5936 4016 +5936 4128 +5936 4526 +5936 5378 +5944 969 +5944 2090 +5944 3488 +5944 3903 +5944 5536 +5944 5607 +5944 6001 +5944 6005 +5944 6076 +5944 6077 +5950 9 +5950 147 +5950 149 +5950 238 +5950 252 +5950 266 +5950 426 +5950 666 +5950 717 +5950 2018 +5951 870 +5951 2348 +5951 3165 +5951 3550 +5951 3733 +5951 4093 +5951 5129 +5951 5644 +5951 6078 +5951 6079 +5961 1460 +5961 2881 +5961 2933 +5961 6108 +5956 503 +5956 2154 +5956 2373 +5956 2378 +5956 2385 +5956 4944 +5956 5429 +5956 6081 +5956 6082 +5956 6083 +5957 86 +5957 1246 +5957 2008 +5957 4353 +5957 4368 +5957 5504 +5957 5715 +5957 6084 +5957 6085 +5957 6086 +5962 249 +5962 266 +5962 367 +5962 422 +5962 559 +5962 695 +5962 736 +5962 754 +5962 3677 +5965 179 +5965 1335 +5965 2361 +5965 2487 +5965 3388 +5965 5514 +5965 5626 +5965 5989 +5965 6088 +5965 6089 +5971 6091 +5976 337 +5976 1541 +5976 1952 +5976 2417 +5976 3385 +5976 3732 +5976 4668 +5976 5086 +5976 5688 +5976 6092 +5977 243 +5977 424 +5977 1893 +5977 2448 +5977 3171 +5977 3344 +5977 3756 +5977 4213 +5977 6007 +5977 6093 +5987 529 +5987 981 +5987 2776 +5987 3140 +5987 4225 +5987 6100 +5987 6101 +5987 6102 +5987 6103 +5987 6104 +5988 5 +5988 9 +5988 126 +5988 175 +5988 180 +5988 252 +5988 266 +5988 368 +5988 3677 +5990 547 +5990 996 +5990 1451 +5990 1888 +5990 3039 +5990 5628 +5990 5913 +5990 6109 +5990 6110 +5990 6111 +5994 38 +5994 132 +5994 747 +5994 1130 +5994 2556 +5994 3460 +5994 5879 +5994 6105 +5994 6106 +5994 6107 +5995 122 +6004 583 +6004 1058 +6004 5292 +6004 5940 +6004 6112 +6004 6113 +6004 6114 +6004 6115 +6004 6116 +6006 230 +6006 1458 +6006 2649 +6006 3389 +6006 3794 +6006 6117 +6006 6118 +6006 6119 +6006 6120 +6059 683 +6060 174 +6060 179 +6060 251 +6060 351 +6060 983 +6023 78 +6023 350 +6023 1168 +6023 4303 +6023 4423 +6023 5350 +6023 6134 +6023 6135 +6023 6136 +6012 2023 +6012 2024 +6012 3988 +6012 4058 +6012 5469 +6012 5498 +6012 6123 +6012 6124 +6012 6125 +6012 6126 +6015 235 +6015 1402 +6015 1846 +6015 1860 +6015 2086 +6015 2325 +6015 3486 +6015 3820 +6015 4754 +6015 6127 +6016 1042 +6016 1203 +6016 1255 +6016 1430 +6016 2492 +6016 3630 +6016 6041 +6016 6128 +6016 6129 +6016 6130 +6018 443 +6031 4966 +5537 477 +5537 1194 +5537 1365 +5537 2345 +5537 2955 +5537 5538 +5537 5539 +5537 5540 +5537 5541 +5537 5542 +5538 162 +5538 223 +5538 477 +5538 2345 +5538 3081 +5538 3989 +5538 5058 +5538 5868 +5538 5869 +5538 5870 +5539 125 +6045 5338 +6046 73 +6046 177 +6046 1974 +6046 3022 +6046 3088 +6046 4465 +6046 4511 +6046 4580 +6046 5962 +6046 6139 +6047 5754 +6050 307 +6050 1173 +6050 2220 +6050 6143 +6050 6144 +6050 6145 +6050 6146 +6050 6147 +6050 6148 +6050 6149 +6057 3218 +6063 255 +6063 275 +6063 456 +6063 527 +6063 1375 +6063 2126 +6063 5216 +6063 5288 +6063 5406 +6063 5556 +6066 86 +6066 1246 +6066 2008 +6066 3138 +6066 3515 +6066 6071 +6066 6086 +6066 6154 +6066 6155 +6066 6156 +6067 17 +6067 123 +6067 175 +6067 249 +6067 390 +6067 423 +6067 695 +6067 697 +6067 856 +6070 1087 +6070 1512 +6070 2857 +6070 3593 +6070 3841 +6070 3948 +6070 4159 +6070 4844 +6070 5373 +6070 5436 +6069 158 +6069 490 +6069 650 +6069 1522 +6069 3205 +6069 5133 +6069 5469 +6069 6167 +6069 6168 +6077 9 +6077 125 +6077 148 +6077 174 +6077 179 +6077 352 +6077 353 +6077 424 +6077 736 +6077 753 +6078 14 +6078 36 +6078 1100 +6078 1291 +6078 1824 +6078 1859 +6078 2275 +6078 3035 +6078 4813 +6078 6169 +6079 458 +6079 944 +6079 983 +6079 3981 +6079 5016 +6079 5115 +6079 5790 +6079 5802 +6079 6170 +6081 129 +6081 219 +6081 864 +6081 1812 +6081 2079 +6081 4107 +6081 4319 +6081 6046 +6088 220 +6088 2181 +6088 2773 +6088 3858 +6088 3989 +6088 5815 +6088 6027 +6088 6099 +6088 6171 +6089 6237 +6092 4 +6092 8 +6092 126 +6092 129 +6092 144 +6092 179 +6092 1317 +6092 3022 +6092 5911 +6093 253 +6093 2292 +6093 2445 +6093 3963 +6093 4872 +6093 5269 +6093 6166 +6093 6172 +6093 6173 +6096 5254 +6094 1006 +6094 1323 +6094 1333 +6094 2026 +6094 4254 +6094 4297 +6094 6095 +6094 6174 +6094 6175 +6094 6176 +6095 380 +6095 2295 +6095 3021 +6095 3675 +6095 3804 +6095 4363 +6095 5449 +6095 5603 +6095 6177 +6095 6178 +6099 106 +6099 1637 +6099 1915 +6099 2015 +6099 4893 +6099 5714 +6099 5901 +6099 6166 +6099 6179 +6099 6180 +6102 570 +6102 1537 +6102 1838 +6102 1882 +6102 4227 +6102 5508 +6102 6096 +6102 6280 +6102 6281 +6110 1084 +6110 2117 +6110 2276 +6110 3252 +6110 3257 +6110 3531 +6110 5557 +6110 5600 +6110 6195 +6110 6196 +6111 554 +6111 839 +6111 967 +6111 1267 +6111 3227 +6111 3327 +6111 3481 +6111 4914 +6111 5601 +6105 6179 +6114 424 +6114 858 +6114 1629 +6114 5962 +6114 6189 +6114 6190 +6114 6191 +6114 6192 +6114 6193 +6114 6194 +6134 3960 +6123 523 +6123 524 +6123 1038 +6123 2046 +6123 2821 +6123 3331 +6123 4301 +6123 4383 +6123 5765 +6123 5844 +6124 311 +6124 510 +6124 962 +6124 2136 +6124 2151 +6124 4885 +6124 4915 +6124 4978 +6124 6176 +6124 6183 +6125 1377 +6125 3125 +6125 3264 +6125 3981 +6125 5535 +6125 6184 +6125 6185 +6125 6186 +6125 6187 +6125 6188 +6139 187 +6139 257 +6139 301 +6139 558 +6139 1017 +6139 1052 +6139 1797 +6139 3837 +6139 5765 +6139 6197 +6139 6198 +6139 6199 +6139 6200 +6139 6201 +6139 6202 +6139 6203 +6139 6204 +6139 6205 +6139 6206 +6139 6207 +6139 6208 +6139 6209 +6139 6210 +6139 6211 +6139 6212 +6139 6213 +6139 6214 +6139 6215 +6139 6216 +6139 6217 +6139 6218 +6139 6219 +6139 6220 +6139 6221 +6139 6222 +6139 6223 +6139 6224 +6139 6225 +6139 6226 +6139 6227 +6139 6228 +6141 213 +6141 1762 +6141 2179 +6141 2234 +6141 2272 +6141 2449 +6141 2797 +6141 3557 +6141 4815 +6141 6229 +6155 2394 +6155 2487 +6155 3768 +6155 4080 +6155 4503 +6155 4883 +6155 5086 +6155 6230 +6155 6231 +6169 83 +6169 969 +6169 1679 +6169 3190 +6169 3304 +6169 4654 +6169 4762 +6169 6065 +6169 6234 +6169 6235 +6170 717 +6170 803 +6170 1401 +6170 2621 +6170 3076 +6170 3477 +6170 3485 +6170 6238 +6170 6239 +6170 6240 +6171 311 +6171 809 +6171 1022 +6171 1694 +6171 3403 +6171 3677 +6171 4014 +6171 4518 +6171 5988 +6171 6236 +6174 5 +6174 7 +6174 8 +6174 121 +6174 149 +6174 247 +6174 353 +6174 424 +6174 754 +6174 1317 +6175 4 +6175 125 +6175 148 +6175 559 +6175 697 +6175 754 +6175 856 +6175 1317 +6175 5710 +6180 129 +6180 1351 +6180 2068 +6180 2360 +6180 3886 +6180 4009 +6180 5729 +6180 6243 +6180 6244 +6180 6245 +6196 124 +6196 1396 +6196 1845 +6196 1971 +6196 2235 +6196 5110 +6196 5204 +6196 5263 +6196 6247 +6196 6248 +6191 2237 +6193 1287 +6193 2403 +6193 2868 +6193 3448 +6193 3728 +6193 5101 +6193 5615 +6193 5975 +6193 6246 +6194 4934 +6194 5049 +6194 5850 +6194 6289 +6186 57 +6186 440 +6186 1221 +6186 1618 +6186 2823 +6186 4076 +6186 5261 +6186 5824 +6186 5988 +6186 6091 +6187 4170 +6229 983 +6229 1602 +6229 1719 +6229 2693 +6229 3798 +6229 4169 +6229 4235 +6229 6186 +6229 6253 +6229 6254 +6269 76 +6269 760 +6269 1611 +6269 1862 +6269 2416 +6269 3767 +6269 6282 +6269 6283 +6262 898 +6262 3501 +6262 3629 +6262 3846 +6262 3968 +6262 4141 +6262 4397 +6262 5369 +6262 5779 +6264 31 +6264 165 +6264 174 +6264 250 +6264 353 +6264 697 +6264 1379 +6264 3056 +6264 5615 +6264 5617 +6266 169 +6266 892 +6266 2378 +6266 2789 +6266 5633 +6266 5923 +6266 6039 +6266 6237 +6266 6274 +6266 6275 +6234 5552 +6239 2397 +6239 2854 +6239 5369 +6239 5475 +6239 5960 +6239 6118 +6239 6258 +6239 6259 +6239 6260 +6239 6261 +6243 3243 +6244 3270 +6244 3808 +6245 187 +6245 367 +6245 469 +6245 474 +6245 3227 +6245 4196 +6245 4503 +6245 4985 +6245 5788 +6245 5988 +6258 1531 +6258 1882 +6258 2500 +6258 2693 +6258 5253 +6258 5514 +6258 5529 +6258 6271 +6258 6272 +6258 6273 +6273 1437 +6273 2413 +6273 2984 +6273 3733 +6273 3981 +6273 5911 +6273 6276 +6273 6277 +6273 6278 +6282 3992 +6282 6291 +6276 810 +6276 3488 +6276 3632 +6276 4926 +6276 5395 +6276 5545 +6276 5627 +6276 5710 +6276 6159 +6276 6172 +6277 1798 +6277 5040 +6277 5791 +6277 5911 +6277 6290 +6296 798 +6296 849 +6296 1325 +6296 2058 +6296 5076 +6296 5236 +6296 6297 +6296 6298 +6296 6299 diff --git a/snap-python/source/dev/examples/demo.graph.dat b/snap-python/source/dev/examples/demo.graph.dat new file mode 100644 index 0000000000000000000000000000000000000000..b98435755e11bc5e9dd57a8d36b83ee1da5a12fe --- /dev/null +++ b/snap-python/source/dev/examples/demo.graph.dat @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f22e344dfa57b56e57ee72ed707c6591704686e6ca7368eb64dc3e49ca3b0e18 +size 3628690 diff --git a/snap-python/source/dev/examples/getstats.py b/snap-python/source/dev/examples/getstats.py new file mode 100644 index 0000000000000000000000000000000000000000..bb36741f390e18c3bc2eb30831e9d5d654c33251 --- /dev/null +++ b/snap-python/source/dev/examples/getstats.py @@ -0,0 +1,328 @@ +import os +import sys +import time +from random import randrange, choice +from socket import gethostname +import argparse + +sys.path.append("../swig-r") + +import snap + +min_nodes_exponent = 1 +max_nodes_exponent = 4 +NUM_ITERATIONS = 1 +PROPERTY_TYPES = [1, 10] # 1=Triads, 10=BFS +GRAPH_TYPES = [0, 3, 4] # Small World, Pref, R-MAT +DEGREE_TYPES = [0, 1] + +AVG_DEG = 3 +AVG_DEGREE_RANGE = range(2, 10) + +results_dir = '.' +combined_dir = 'public_html' +hostname = gethostname() +verbose = False + +def calc_stats(): + + for g in GRAPH_TYPES: + + for e in range(min_nodes_exponent,max_nodes_exponent+1): + + # Random number of nodes of degree i + NNodes = randrange(10**e,10**(e+1)) + + for avg in DEGREE_TYPES: + + if avg: + # Use average degree + NEdges = NNodes * AVG_DEG + + else: + # Random number of edges (from 1-3x nodes) + NEdges = NNodes * choice(AVG_DEGREE_RANGE) + + print "%s graph: NNodes=%.2e, %.2e" % \ + (snap.GetGraphDesc(g), NNodes, NEdges) + + fname = "%s%s" % (snap.GetGraphAbbr(g), + 'deg%d' % AVG_DEG if avg else '') + # Repeat for all graph types + for j in PROPERTY_TYPES: + print "Calculating %s..." % snap.GetAttributeDesc(j) + t = snap.GetStats(NNodes, NEdges, j, g) + f = open('%s/%s_%s.txt' % (results_dir, snap.GetAttributeAbbr(j), + fname), + 'a') + f.write("%d %d %.5f\n" % (NNodes, NEdges, t)) + + f_all = open('%s/%s_all.txt' % (results_dir, + snap.GetAttributeAbbr(j)), + 'a') + f_all.write("%d %d %.5f\n" % (NNodes, NEdges, t)) + + # For each characteristic: + # Write out test data to same file (linear fit using matlab?) + # NNodes NEdges Time + + print "-"*75 + +# --------------- Plotting --------------- +import matplotlib +matplotlib.use('Agg') + +from pylab import * +from numpy import sort,array,ones,linalg,column_stack,loadtxt,savetxt +from scipy import * +from scipy.optimize import leastsq +from scipy import linalg + +def plot_2d(property): + + # Plot average degree on 2d-graph + figure() + for g in GRAPH_TYPES: + + fname = '%s/%s_%sdeg%d.txt' % (results_dir, snap.GetAttributeAbbr(property), + snap.GetGraphAbbr(g), AVG_DEG) + A = loadtxt(fname) + A = sort(A,0) + Y = A[:,-1] # Last column + X = A[:,:-1] # Columns 0-(n-1) + + loglog(X[:,0], Y, 'o', label=snap.GetGraphDesc(g)) + + legend(loc='lower right') + xlabel('Num Nodes (d_avg = %.1f)' % AVG_DEG) + ylabel('time') + title('%s runtime (avg degree = %d)' % (snap.GetAttributeDesc(property), AVG_DEG)) + pname = '%s/plot2d_%s.png' % (results_dir, snap.GetAttributeAbbr(property)) + print "Saving figure %s" % pname + savefig(pname) + +# Plot using 3D-graph +def plot_3d(property): + + import mpl_toolkits.mplot3d.axes3d as p3 + fig3d = figure() + ax = fig3d.add_subplot(111, projection='3d') + + for g in GRAPH_TYPES: + fname = '%s/%s_%s.txt' % (results_dir, snap.GetAttributeAbbr(property), + snap.GetGraphAbbr(g)) + + if not os.path.exists(fname): + print "No such file: %s" % fname + return + + A = loadtxt(fname) + A = sort(A,0) + Y = A[:,-1] # Last column + X = A[:,:-1] # Columns 0-(n-1) + # savetxt(fname+'_sorted.txt', A) + + Nodes = X[:,0] + Edges = X[:,1] + ax.plot(Nodes,Edges,Y,'o', + label="%s-%s" % (snap.GetAttributeAbbr(property), + snap.GetGraphAbbr(g))) + + ax.set_xlabel('# of nodes', fontsize=9) + ax.set_ylabel('# of edges', fontsize=9) + ax.set_zlabel('Run time %s (sec)' % snap.GetAttributeAbbr(property), + fontsize=9) + ax.legend() + +# ax.set_xlim3d([0, 10**max_nodes_exponent]) +# ax.set_ylim3d([0, 10**max_nodes_exponent*AVG_DEGREE_RANGE[1]]) +# ax.set_zlim3d([0, max(Y)]) +# ax.set_xscale('log') +# ax.w_xaxis.set_scale('log') +# ax.w_yaxis.set_scale('log') +# ax.set_zscale('log') +# ax.auto_scale_xyz([0, max(Nodes)], [0, max(Edges)], [0, max(Y)]) +# ax.title("%s run time" % snap.GetAttributeAbbr(property)) + pname = '%s/plot3d_%s.png' % (results_dir, snap.GetAttributeAbbr(property)) + print "Saving figure %s" % pname + + fig3d.savefig(pname) + +# Fitting the data using given model and least squares +def plot_fit(Xdata, Ydata, labelstr, fit_type): + + X1 = Xdata[:,0] # Nodes + X2 = Xdata[:,1] # Edges + Y = Ydata + + best_r2 = 0 + + if "poly" in fit_type: + # Polynomial fit + fitfunc = lambda p, x1, x2: (p[0] + p[1] * x1 + p[2] * x2 + + p[3] * x1**2 + p[4] * x2**2) + pinit = [1.0 for i in range(5)] + + if "exp" in fit_type: + # Exponential fit + Y = log(Y) + fitfunc = lambda p, x1, x2: (p[0] + p[1] * x1 + p[3] * x2) + pinit = [1.0 for i in range(5)] + + if "log" in fit_type: + # Logarithmic fit + fitfunc = lambda p, x1, x2: (p[0] + p[1] * log10(x1) + p[2] * log10(x2)) + pinit = [1.0 for i in range(3)] + + # errfunc = lambda p, x, y, err: (y - fitfunc(p, x)) / err + errfunc = lambda p, y, x1, x2: (y - fitfunc(p, x1, x2)) + + pfinal,covar,infodict,mesg,ier = \ + leastsq(errfunc, pinit, args=(Y, X1, X2), full_output=1) + + print "pfinal = ", pfinal + # print "covar: \n", covar + # print "infodict['fvec']: ", infodict['fvec'] + + ss_err=(infodict['fvec']**2).sum() + ss_tot=((Y-Y.mean())**2).sum() + rsquared=1-(ss_err/ss_tot) + + labelstr = "%s (r2=%.3f)" % (fit_type, rsquared) + plot(X1, errfunc(pfinal, Y, X1, X2), '.', label=labelstr) + + return (rsquared, pfinal) + +# Calculate and Plot Residual Errors +def plot_residuals(property): + + # Calculate residuals for all graph types, and combined + figure() + + # All graphs + fname = '%s/%s_all.txt' % (results_dir, snap.GetAttributeAbbr(property)) + + A = loadtxt(fname) + A = sort(A,0) + Y = A[:,-1] # Last column + X = A[:,:-1] # Columns 0-(n-1) + # savetxt(fname+'_sorted.txt', A) + + best_r2 = 0.0 + best_model = None + best_p = None + + desc = 'all' + abbr = 'all' + + print "Fitting %s for %s" % (snap.GetAttributeDesc(property), desc) + + fname = '%s/coeff_%s.txt' % (results_dir, snap.GetAttributeAbbr(property)) + f = open(fname, 'w') + + cname = '%s/coeff_%s.txt' % (combined_dir, + snap.GetAttributeAbbr(property)) + combined_file = open(cname, 'a+') + + + for model in ['poly', 'exp', 'log']: + # Plot residuals with multiple fitting types + rsquared, pfinal = plot_fit(X, Y, desc, model) + + f.write("%s, model=%s r2=%.4f pfinal=%s\n" % + (abbr, model, rsquared, pfinal)) + + if (rsquared > best_r2): + best_r2 = rsquared + best_model = model + best_p = pfinal + + + title('Residual error for approx. of run-time, %s (%s)' % + (snap.GetAttributeDesc(property).title(), desc)) + xscale('log') + yscale('symlog') + grid(True) + xlabel('Number of Nodes') + ylabel('Residual') + legend(loc='lower right') + pname = '%s/residuals_%s_%s.png' % (results_dir, + snap.GetAttributeAbbr(property), + abbr) + print "Saving figure %s" % pname + savefig(pname) + print "Best model: %s, r2 = %.3f, pfinal: %s" % \ + (best_model, best_r2, repr(best_p)) + + # TODO: Get most recent date of data + print "Best results to %s" % cname + combined_file.write( + 'hostname=%s, model=%s, type=%s, n=%d, r2=%.4f, pfinal=%s\n' % \ + (hostname, best_model, abbr, len(X), best_r2, + ["%.4e" % p for p in best_p])) + +def plot_stats(): + + for type in PROPERTY_TYPES: + + plot_3d(type) + + plot_2d(type) + + plot_residuals(type) + + #end for loop - graph type + + #end for loop - plot type + +def main(): + + global results_dir, verbose, hostname, max_nodes_exponent + + parser = argparse.ArgumentParser() + parser.add_argument("-v", "--verbose", default=False, + action="store_true", dest="verbose", + help="increase output verbosity") + parser.add_argument("-m", "--max_nodes_exponent", type=int, + default=max_nodes_exponent, help="max nodes exponent (4->10^4") + parser.add_argument("-n", "--num_iterations", type=int, + default=NUM_ITERATIONS, help="number of iterations") + parser.add_argument("-i", "--hostname", help="hostname") + parser.add_argument("-p", "--plot", action="store_true", help="plot stats") + parser.add_argument("-r", "--run", action="store_true", help="run stats") + + parser.add_argument("results_dir", help="directory to save/store data") + args = parser.parse_args() + + results_dir = args.results_dir + verbose = args.verbose + + if not os.path.exists(results_dir): + os.mkdir(results_dir) + + if not os.path.exists(combined_dir): + os.mkdir(combined_dir) + + if args.max_nodes_exponent: + max_nodes_exponent = args.max_nodes_exponent + + if args.hostname: + hostname = args.hostname + print "Hostname: %s" % hostname + print "Results dir: %s" % results_dir + + if args.run: + for n in range(args.num_iterations): + if verbose: + print "Iteration: %d of %d" % (n+1, args.num_iterations) + calc_stats() + + if args.plot: + if verbose: + print "Plotting results" + plot_stats() + +if __name__ == "__main__": + main() + + diff --git a/snap-python/source/dev/examples/load.py b/snap-python/source/dev/examples/load.py new file mode 100644 index 0000000000000000000000000000000000000000..bb9c50f8a354d8b87e67e7a5ae8d2c172f131717 --- /dev/null +++ b/snap-python/source/dev/examples/load.py @@ -0,0 +1,11 @@ +import snap + +for item in dir(snap): + if item.find("Load") >= 0: + print item + +g = snap.LoadEdgeList_PNGraph(snap.TStr("soc-Epinions1.txt"), 0, 1) +print dir(g) +print g.GetNodes() +print g.GetEdges() + diff --git a/snap-python/source/dev/examples/plot_results.py b/snap-python/source/dev/examples/plot_results.py new file mode 100644 index 0000000000000000000000000000000000000000..d123b21b479cd45e377623ed357c98b279afed8c --- /dev/null +++ b/snap-python/source/dev/examples/plot_results.py @@ -0,0 +1,194 @@ +import os.path +import sys +from socket import gethostname +import argparse +from datetime import datetime + +sys.path.append("../swig") +import snap +from glob import glob + +NUM_ITERATIONS = 1 +PROPERTY_TYPES = [1, 10] # 1=Triads, 10=BFS +DEFAULT_TYPES = "rmat,rand_ngraph,rand_neanet,rand_negraph" # Comma separated + +# Random, Small World, Pref, R-MAT +# Graph types: +# 'rand_ungraph' - random undirected +# 'rand_ngraph' - random directed +# 'rmat' - R-MAT +# 'pref' - preferential attachment +# 'sw' - small world + +DEGREE_TYPES = [0, 1] +DEFAULT_RANGE = '5-7' # Exponent (e.g. 10^x to 10^y) +DEFAULT_NODES_MIN = 10**5 + +VERBOSE = False +DEFAULT_TIME_MIN = 0.0 + +AVG_DEG = 3 +AVG_DEGREE_RANGE = range(2, 10) +SW_REWIRE_PROB = 0.1 + +HOSTNAME = gethostname() + +# Where to build the table. +PUBLIC_DIR = 'public_html' +TABLE_FILE = os.path.join(PUBLIC_DIR, 'result_table_%s.html' % + datetime.now().strftime('%m%d-%H%M')) + +# Where to read-in/generate the graph. + +RESULTS_DIR = 'results' +RESULTS_FILE = os.path.join(RESULTS_DIR, 'results%s.txt' % \ + datetime.now().strftime('%m%d-%H%M')) + +def parse_file(f, results): + + import csv + print "Parsing %s" % f + + with open(f, 'rb') as csvfile: + spamreader = csv.reader(csvfile) + for row in spamreader: + result = {} + result["hostname"] = row[0] + result["model"] = row[1] + result["type"] = row[2] + result["num_nodes"] = int(row[3]) + result["num_edges"] = int(row[4]) + result["start_time"] = row[5] + result["time_generate"] = float(row[6]) + result["time_elapsed"] = float(row[7]) + + results.append(result) + +def write_stats(results): + + f = open(TABLE_FILE, 'w') + + f.write("\n"); + + f.write("\n"); + f.write("\n"); + + f.write(""); + f.write("\n"); + f.write("\n"); + f.write("\n"); + f.write("\n"); + f.write("\n"); + f.write("\n"); + f.write("\n"); + f.write("\n"); + f.write("\n"); + + for result in results: + + for model in graph_types: + + if result['time_elapsed'] > time_min \ + and model in result['model'] and \ + result['num_nodes'] >= DEFAULT_NODES_MIN: + + f.write("\n"); + f.write("" % result['hostname']); + f.write("" % result['model']); + f.write("" % result['type']); + f.write("" % result['num_nodes']); + f.write("" % result['num_edges']); + f.write("" % result['start_time']); + f.write("" % result['time_generate']); + f.write("" % result['time_elapsed']); + f.write("\n"); + + f.write("
HostnameModelTypeNodesEdgesStart TimeGen Time (sec)Run Time (sec)
%s%s%s%.3e%.3e%s%.4f%.4f
\n"); + + f.write(""); + f.write(""); + if verbose: + print "Writing to file ", TABLE_FILE + + f.close(); + +# --------------- Plotting --------------- +import matplotlib +matplotlib.use('Agg') + +from pylab import * +from numpy import sort,array,ones,linalg,column_stack,loadtxt,savetxt + +def plot_2d(property): + + # Plot average degree on 2d-graph + figure() + for g in GRAPH_TYPES: + + fname = '%s/%s_%sdeg%d.txt' % (results_dir, snap.GetAttributeAbbr(property), + snap.GetGraphAbbr(g), AVG_DEG) + A = loadtxt(fname) + A = sort(A,0) + Y = A[:,-1] # Last column + X = A[:,:-1] # Columns 0-(n-1) + + loglog(X[:,0], Y, 'o', label=snap.GetGraphDesc(g)) + + legend(loc='lower right') + xlabel('Num Nodes (d_avg = %.1f)' % AVG_DEG) + ylabel('time') + title('%s runtime (avg degree = %d)' % (snap.GetAttributeDesc(property), AVG_DEG)) + pname = '%s/plot2d_%s.png' % (results_dir, snap.GetAttributeAbbr(property)) + print "Saving figure %s" % pname + savefig(pname) + +def main(): + + global results_dir, verbose, time_min, graph_types + + parser = argparse.ArgumentParser() + parser.add_argument("-v", "--verbose", default=False, + action="store_true", dest="verbose", + help="increase output verbosity") + + parser.add_argument("-d", "--results_dir", help="results directory", + default=RESULTS_DIR) + + parser.add_argument("-m", "--time_min", type=float, + default=DEFAULT_TIME_MIN, + help="time minimum threshold") + + parser.add_argument("-t", "--graph_types", default=DEFAULT_TYPES, + help=''' + Graph types, comma separated. + Available: rand_ungraph, rand_ngraph, rand_neanet rmat, + pref, sw''') + + args = parser.parse_args() + + verbose = args.verbose + graph_types = args.graph_types.split(",") + + print "Hostname: %s" % HOSTNAME + + time_min = args.time_min + + if not os.path.exists(RESULTS_DIR): + os.makedirs(RESULTS_DIR) + + if not os.path.exists(PUBLIC_DIR): + os.makedirs(PUBLIC_DIR) + + if verbose: + print "Reading results %s" % args.results_dir + + results = [] + for f in glob("%s/result*.txt" % args.results_dir): + print "Parsing %s" % f + parse_file(f, results) + + write_stats(results) + +if __name__ == "__main__": + main() + diff --git a/snap-python/source/dev/examples/public_html/result_table.html b/snap-python/source/dev/examples/public_html/result_table.html new file mode 100644 index 0000000000000000000000000000000000000000..7ac89bdaaaa31e29b0ba292ee5eea39f6120c052 --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table.html @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
madmax.stanford.edurmatdirected1.000e+061.000e+0719.100016.9700
madmax.stanford.edurmatdirected1.000e+061.000e+0720.850017.3800
madmax.stanford.edurmatdirected1.000e+061.000e+0718.240015.6800
madmax.stanford.edurmatdirected1.000e+061.000e+0718.810016.1100
madmax.stanford.edurmatdirected1.000e+061.000e+0718.750016.4400
madmax.stanford.edurmatdirected1.000e+061.000e+0721.560018.6400
madmax.stanford.edurmatdirected1.000e+061.000e+0721.500019.1500
madmax2.stanford.edurmatdirected1.000e+061.000e+0718.850019.6100
madmax.stanford.edurmatdirected1.000e+061.000e+0720.440016.7600
sheridanrmatdirected1.000e+061.000e+0713.840815.5060
sheridanrmatdirected1.000e+051.000e+061.13281.0108
sheridanrmatdirected1.000e+061.000e+0713.799316.2093
sheridanrmatdirected1.000e+061.000e+0713.841514.4375
sheridanrmatdirected1.000e+061.000e+0714.014214.7885
sheridanrmatdirected1.000e+061.000e+0714.165114.9464
sheridanrmatdirected1.000e+061.000e+0713.876315.2115
sheridanrmatdirected1.000e+061.000e+0713.888814.3995
sheridanrmatdirected1.000e+061.000e+0713.728314.3290
sheridanrmatdirected1.000e+061.000e+0714.011915.7053
sheridanrmatdirected1.000e+061.000e+0714.111515.0208
sheridanrmatdirected1.000e+061.000e+0714.210015.1617
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0320-1403.html b/snap-python/source/dev/examples/public_html/result_table_0320-1403.html new file mode 100644 index 0000000000000000000000000000000000000000..913c6ccf104ec349c521249b3f128328678a363b --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0320-1403.html @@ -0,0 +1,47 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
madmax.stanford.edurmatdirected1.000e+041.000e+062.41321.7536
madmax.stanford.edurnd_ungraphundirected1.000e+051.000e+061.13661.0203
madmax.stanford.edurnd_ungraphundirected1.000e+051.000e+0723.76588.4573
madmax.stanford.edurnd_ngraphdirected1.000e+051.000e+061.61781.7030
madmax.stanford.edurnd_ngraphdirected1.000e+051.000e+0720.79805.9126
madmax.stanford.edurmatdirected1.000e+051.000e+062.87772.1940
madmax.stanford.edurmatdirected1.000e+051.000e+0740.009021.3967
madmax.stanford.edurnd_ungraphundirected1.000e+061.000e+0726.144421.8137
madmax.stanford.edurnd_ungraphundirected1.000e+061.000e+08383.3239157.0932
madmax.stanford.edurnd_ngraphdirected1.000e+061.000e+0724.311147.3226
madmax.stanford.edurnd_ngraphdirected1.000e+061.000e+08385.4147101.7317
madmax.stanford.edurmatdirected1.000e+061.000e+0739.766940.8386
madmax.stanford.edurmatdirected1.000e+061.000e+08798.9350921.3519
madmax.stanford.eduprefundirected1.000e+061.000e+071.35494.1890
madmax.stanford.eduprefundirected1.000e+061.000e+081.36294.7027
madmax.stanford.eduswundirected1.000e+061.000e+071.32494.6494
madmax.stanford.eduswundirected1.000e+061.000e+081.31944.5435
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0320-1417.html b/snap-python/source/dev/examples/public_html/result_table_0320-1417.html new file mode 100644 index 0000000000000000000000000000000000000000..913c6ccf104ec349c521249b3f128328678a363b --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0320-1417.html @@ -0,0 +1,47 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
madmax.stanford.edurmatdirected1.000e+041.000e+062.41321.7536
madmax.stanford.edurnd_ungraphundirected1.000e+051.000e+061.13661.0203
madmax.stanford.edurnd_ungraphundirected1.000e+051.000e+0723.76588.4573
madmax.stanford.edurnd_ngraphdirected1.000e+051.000e+061.61781.7030
madmax.stanford.edurnd_ngraphdirected1.000e+051.000e+0720.79805.9126
madmax.stanford.edurmatdirected1.000e+051.000e+062.87772.1940
madmax.stanford.edurmatdirected1.000e+051.000e+0740.009021.3967
madmax.stanford.edurnd_ungraphundirected1.000e+061.000e+0726.144421.8137
madmax.stanford.edurnd_ungraphundirected1.000e+061.000e+08383.3239157.0932
madmax.stanford.edurnd_ngraphdirected1.000e+061.000e+0724.311147.3226
madmax.stanford.edurnd_ngraphdirected1.000e+061.000e+08385.4147101.7317
madmax.stanford.edurmatdirected1.000e+061.000e+0739.766940.8386
madmax.stanford.edurmatdirected1.000e+061.000e+08798.9350921.3519
madmax.stanford.eduprefundirected1.000e+061.000e+071.35494.1890
madmax.stanford.eduprefundirected1.000e+061.000e+081.36294.7027
madmax.stanford.eduswundirected1.000e+061.000e+071.32494.6494
madmax.stanford.eduswundirected1.000e+061.000e+081.31944.5435
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0320-1420.html b/snap-python/source/dev/examples/public_html/result_table_0320-1420.html new file mode 100644 index 0000000000000000000000000000000000000000..5a2cb05c9fc0f3046e5e811987c367b3dab12b94 --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0320-1420.html @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
sheridanrnd_ungraphundirected1.000e+051.000e+079.49683.3481
sheridanrnd_ngraphdirected1.000e+051.000e+077.00612.0728
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0320-1421.html b/snap-python/source/dev/examples/public_html/result_table_0320-1421.html new file mode 100644 index 0000000000000000000000000000000000000000..3134ec6fd4532d632021d5c8ef9953ff0e944cbc --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0320-1421.html @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
sheridanrnd_ungraphundirected1.000e+051.000e+079.49683.3481
sheridanrnd_ngraphdirected1.000e+051.000e+077.00612.0728
sheridanrmatdirected1.000e+051.000e+0716.389212.9903
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0320-1423.html b/snap-python/source/dev/examples/public_html/result_table_0320-1423.html new file mode 100644 index 0000000000000000000000000000000000000000..3134ec6fd4532d632021d5c8ef9953ff0e944cbc --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0320-1423.html @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
sheridanrnd_ungraphundirected1.000e+051.000e+079.49683.3481
sheridanrnd_ngraphdirected1.000e+051.000e+077.00612.0728
sheridanrmatdirected1.000e+051.000e+0716.389212.9903
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0321-2331.html b/snap-python/source/dev/examples/public_html/result_table_0321-2331.html new file mode 100644 index 0000000000000000000000000000000000000000..eadfbcfd998ac527c7b530f84b3e2a4a29f7c94e --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0321-2331.html @@ -0,0 +1,13 @@ + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0321-2332.html b/snap-python/source/dev/examples/public_html/result_table_0321-2332.html new file mode 100644 index 0000000000000000000000000000000000000000..b57b21fb1809e31f1600f1fd054cd0a7be0b5aa7 --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0321-2332.html @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
madmax.stanford.edurmatdirected1.000e+041.000e+062.41321.7536
madmax.stanford.edurmatdirected1.000e+051.000e+062.87772.1940
madmax.stanford.edurmatdirected1.000e+051.000e+0740.009021.3967
madmax.stanford.edurmatdirected1.000e+061.000e+0739.766940.8386
madmax.stanford.edurmatdirected1.000e+061.000e+08798.9350921.3519
sheridanrmatdirected1.000e+051.000e+0716.389212.9903
sheridanrmatdirected1.000e+051.000e+0715.799413.0970
sheridanrmatdirected1.000e+051.000e+0715.958813.8366
sheridanrmatdirected1.000e+051.000e+0715.645614.1982
sheridanrmatdirected1.000e+051.000e+0716.087213.3833
sheridanrmatdirected1.000e+051.000e+0715.859012.8888
madmax.stanford.edurmatdirected1.000e+041.000e+063.70982.2293
madmax.stanford.edurmatdirected1.000e+051.000e+063.66052.5440
madmax.stanford.edurmatdirected1.000e+051.000e+0761.015977.0117
madmax.stanford.edurmatdirected1.000e+051.000e+063.66292.8650
madmax.stanford.edurmatdirected1.000e+041.000e+063.34482.0680
madmax.stanford.edurmatdirected1.000e+051.000e+064.16313.0476
madmax.stanford.edurmatdirected1.000e+051.000e+0769.759654.4046
madmax.stanford.edurmatdirected1.000e+061.000e+0760.961259.8299
madmax.stanford.edurmatdirected1.000e+041.000e+063.83242.3204
madmax.stanford.edurmatdirected1.000e+051.000e+064.34563.2776
madmax.stanford.edurmatdirected1.000e+051.000e+0772.984261.6619
madmax.stanford.edurmatdirected1.000e+061.000e+0774.744968.7944
madmax.stanford.edurmatdirected1.000e+061.000e+081031.9497928.5699
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0321-2339.html b/snap-python/source/dev/examples/public_html/result_table_0321-2339.html new file mode 100644 index 0000000000000000000000000000000000000000..b57b21fb1809e31f1600f1fd054cd0a7be0b5aa7 --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0321-2339.html @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
madmax.stanford.edurmatdirected1.000e+041.000e+062.41321.7536
madmax.stanford.edurmatdirected1.000e+051.000e+062.87772.1940
madmax.stanford.edurmatdirected1.000e+051.000e+0740.009021.3967
madmax.stanford.edurmatdirected1.000e+061.000e+0739.766940.8386
madmax.stanford.edurmatdirected1.000e+061.000e+08798.9350921.3519
sheridanrmatdirected1.000e+051.000e+0716.389212.9903
sheridanrmatdirected1.000e+051.000e+0715.799413.0970
sheridanrmatdirected1.000e+051.000e+0715.958813.8366
sheridanrmatdirected1.000e+051.000e+0715.645614.1982
sheridanrmatdirected1.000e+051.000e+0716.087213.3833
sheridanrmatdirected1.000e+051.000e+0715.859012.8888
madmax.stanford.edurmatdirected1.000e+041.000e+063.70982.2293
madmax.stanford.edurmatdirected1.000e+051.000e+063.66052.5440
madmax.stanford.edurmatdirected1.000e+051.000e+0761.015977.0117
madmax.stanford.edurmatdirected1.000e+051.000e+063.66292.8650
madmax.stanford.edurmatdirected1.000e+041.000e+063.34482.0680
madmax.stanford.edurmatdirected1.000e+051.000e+064.16313.0476
madmax.stanford.edurmatdirected1.000e+051.000e+0769.759654.4046
madmax.stanford.edurmatdirected1.000e+061.000e+0760.961259.8299
madmax.stanford.edurmatdirected1.000e+041.000e+063.83242.3204
madmax.stanford.edurmatdirected1.000e+051.000e+064.34563.2776
madmax.stanford.edurmatdirected1.000e+051.000e+0772.984261.6619
madmax.stanford.edurmatdirected1.000e+061.000e+0774.744968.7944
madmax.stanford.edurmatdirected1.000e+061.000e+081031.9497928.5699
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/result_table_0321-2340.html b/snap-python/source/dev/examples/public_html/result_table_0321-2340.html new file mode 100644 index 0000000000000000000000000000000000000000..b3ccc8774f054f7b567c81a28d5cd4d21af5ae1f --- /dev/null +++ b/snap-python/source/dev/examples/public_html/result_table_0321-2340.html @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HostnameModelTypeNodesEdgesGen Time (sec)Run Time (sec)
madmax.stanford.edurmatdirected1.000e+041.000e+062.41321.7536
madmax.stanford.edurmatdirected1.000e+051.000e+062.87772.1940
madmax.stanford.edurmatdirected1.000e+051.000e+0740.009021.3967
madmax.stanford.edurmatdirected1.000e+061.000e+0739.766940.8386
madmax.stanford.edurmatdirected1.000e+061.000e+08798.9350921.3519
madmax.stanford.edurmatdirected1.000e+041.000e+063.70982.2293
madmax.stanford.edurmatdirected1.000e+051.000e+063.66052.5440
madmax.stanford.edurmatdirected1.000e+051.000e+0761.015977.0117
madmax.stanford.edurmatdirected1.000e+051.000e+063.66292.8650
madmax.stanford.edurmatdirected1.000e+041.000e+063.34482.0680
madmax.stanford.edurmatdirected1.000e+051.000e+064.16313.0476
madmax.stanford.edurmatdirected1.000e+051.000e+0769.759654.4046
madmax.stanford.edurmatdirected1.000e+061.000e+0760.961259.8299
madmax.stanford.edurmatdirected1.000e+041.000e+063.83242.3204
madmax.stanford.edurmatdirected1.000e+051.000e+064.34563.2776
madmax.stanford.edurmatdirected1.000e+051.000e+0772.984261.6619
madmax.stanford.edurmatdirected1.000e+061.000e+0774.744968.7944
madmax.stanford.edurmatdirected1.000e+061.000e+081031.9497928.5699
sheridanrmatdirected1.000e+051.000e+0716.389212.9903
sheridanrmatdirected1.000e+051.000e+0715.799413.0970
sheridanrmatdirected1.000e+051.000e+0715.958813.8366
sheridanrmatdirected1.000e+051.000e+0715.645614.1982
sheridanrmatdirected1.000e+051.000e+0716.087213.3833
sheridanrmatdirected1.000e+051.000e+0715.859012.8888
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/public_html/results_0320-1303.html b/snap-python/source/dev/examples/public_html/results_0320-1303.html new file mode 100644 index 0000000000000000000000000000000000000000..d1c67b102d137666226beeeb3e8a5ddb04eef718 --- /dev/null +++ b/snap-python/source/dev/examples/public_html/results_0320-1303.html @@ -0,0 +1,215 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ModelTypeNodesEdgesGen Time (sec)Run Time (sec)Hostname
swundirected1.000e+041.000e+060.00190.0133
rnd_ungraphundirected1.000e+031.000e+040.00470.0033
rnd_ungraphundirected1.000e+031.000e+050.06130.0270
rnd_ngraphdirected1.000e+031.000e+040.00310.0024
rnd_ngraphdirected1.000e+031.000e+050.03750.0181
rmatdirected1.000e+031.000e+040.00680.0049
rmatdirected1.000e+031.000e+050.08710.0154
prefundirected1.000e+031.000e+040.00040.0013
prefundirected1.000e+031.000e+050.00020.0013
swundirected1.000e+031.000e+040.00030.0013
swundirected1.000e+031.000e+050.00030.0013
rnd_ungraphundirected1.000e+041.000e+050.05270.0443
rnd_ungraphundirected1.000e+041.000e+060.77150.2963
rnd_ngraphdirected1.000e+041.000e+050.03280.0549
rnd_ngraphdirected1.000e+041.000e+060.48930.1846
rmatdirected1.000e+041.000e+050.07770.0541
rmatdirected1.000e+041.000e+061.06130.7422
prefundirected1.000e+041.000e+050.00230.0220
prefundirected1.000e+041.000e+060.00170.0166
swundirected1.000e+041.000e+050.00270.0160
swundirected1.000e+041.000e+060.00180.0137
rnd_ungraphundirected1.000e+041.000e+050.04740.0373
rnd_ungraphundirected1.000e+041.000e+060.71190.3017
rnd_ngraphdirected1.000e+041.000e+050.03670.0277
rnd_ngraphdirected1.000e+041.000e+060.46880.1889
rmatdirected1.000e+041.000e+050.07820.0579
rmatdirected1.000e+041.000e+061.15700.7897
prefundirected1.000e+041.000e+050.00220.0140
prefundirected1.000e+041.000e+060.00160.0132
swundirected1.000e+041.000e+050.00200.0132
swundirected1.000e+041.000e+060.00190.0131
rnd_ungraphundirected1.000e+051.000e+060.62910.4348
rnd_ungraphundirected1.000e+051.000e+079.50323.4722
rnd_ngraphdirected1.000e+051.000e+060.58520.8645
rnd_ngraphdirected1.000e+051.000e+077.12512.0593
rmatdirected1.000e+051.000e+061.04430.8116
rmatdirected1.000e+051.000e+0716.094813.2966
prefundirected1.000e+051.000e+060.01670.1340
prefundirected1.000e+051.000e+070.01680.1430
swundirected1.000e+051.000e+060.02080.1472
swundirected1.000e+051.000e+070.02720.1418
rnd_ungraphundirected1.000e+041.000e+050.05220.0377
rnd_ungraphundirected1.000e+041.000e+060.70310.2983
rnd_ngraphdirected1.000e+041.000e+050.03640.0267
rnd_ngraphdirected1.000e+041.000e+060.47590.1864
rmatdirected1.000e+041.000e+050.07890.0584
rmatdirected1.000e+041.000e+061.15420.8002
prefundirected1.000e+041.000e+050.00170.0137
prefundirected1.000e+041.000e+060.00170.0132
swundirected1.000e+041.000e+050.00190.0131
swundirected1.000e+041.000e+060.00200.0135
rnd_ungraphundirected1.000e+051.000e+060.62800.4285
rnd_ungraphundirected1.000e+051.000e+079.87553.4552
rnd_ngraphdirected1.000e+051.000e+060.53720.8366
rnd_ngraphdirected1.000e+051.000e+077.30212.1303
rmatdirected1.000e+051.000e+061.06670.8308
rnd_ungraphundirected1.000e+031.000e+040.00490.0034
rnd_ungraphundirected1.000e+031.000e+050.06300.0277
rnd_ngraphdirected1.000e+031.000e+040.00310.0024
rnd_ngraphdirected1.000e+031.000e+050.03830.0191
rmatdirected1.000e+031.000e+040.00740.0059
rmatdirected1.000e+031.000e+050.08900.0165
prefundirected1.000e+031.000e+040.00040.0013
prefundirected1.000e+031.000e+050.00030.0013
swundirected1.000e+031.000e+040.00030.0013
swundirected1.000e+031.000e+050.00030.0013
rnd_ungraphundirected1.000e+041.000e+050.05170.0407
rnd_ungraphundirected1.000e+041.000e+060.80080.3120
rnd_ngraphdirected1.000e+041.000e+050.03730.0669
rnd_ngraphdirected1.000e+041.000e+060.53690.1978
rmatdirected1.000e+041.000e+050.08760.0672
rmatdirected1.000e+041.000e+061.17290.8125
prefundirected1.000e+041.000e+050.00220.0141
prefundirected1.000e+041.000e+060.00170.0181
swundirected1.000e+041.000e+050.00200.0138
swundirected1.000e+041.000e+060.00190.0184
rmatdirected1.000e+051.000e+0716.606813.4748
prefundirected1.000e+051.000e+060.01770.1335
prefundirected1.000e+051.000e+070.01610.1313
swundirected1.000e+051.000e+060.01850.1318
swundirected1.000e+051.000e+070.01870.1305
rnd_ungraphundirected1.000e+041.000e+050.04760.0382
rnd_ungraphundirected1.000e+041.000e+060.70230.2999
rnd_ngraphdirected1.000e+041.000e+050.03230.0276
rnd_ngraphdirected1.000e+041.000e+060.48460.1927
rmatdirected1.000e+041.000e+050.08110.0602
rmatdirected1.000e+041.000e+061.15220.7962
prefundirected1.000e+041.000e+050.00230.0162
prefundirected1.000e+041.000e+060.00180.0131
swundirected1.000e+041.000e+050.00190.0132
swundirected1.000e+041.000e+060.00210.0132
rnd_ungraphundirected1.000e+051.000e+060.62320.4392
rnd_ungraphundirected1.000e+051.000e+079.47083.5457
rnd_ngraphdirected1.000e+051.000e+060.53820.8661
rnd_ngraphdirected1.000e+051.000e+077.35672.1015
rmatdirected1.000e+051.000e+061.06460.9549
rmatdirected1.000e+051.000e+0716.326214.4413
prefundirected1.000e+051.000e+060.01940.1322
prefundirected1.000e+051.000e+070.02090.1333
swundirected1.000e+051.000e+060.01920.1376
swundirected1.000e+051.000e+070.01970.1349
+ \ No newline at end of file diff --git a/snap-python/source/dev/examples/result3.txt b/snap-python/source/dev/examples/result3.txt new file mode 100644 index 0000000000000000000000000000000000000000..f71bef44e0def85a771aeff435f7119f39d6b1c9 --- /dev/null +++ b/snap-python/source/dev/examples/result3.txt @@ -0,0 +1,5 @@ +Hostname: sheridan +Range = 10^1 to 10^0 +Running results from 1.000000e+00 to 0.000000e+00 +Non-deterministic mode +Iteration: 1 of 1 diff --git a/snap-python/source/dev/examples/results-madmax/BFS_all.txt b/snap-python/source/dev/examples/results-madmax/BFS_all.txt new file mode 100644 index 0000000000000000000000000000000000000000..423dfe968ba319bf325b7c6c8aff58f876d08a9a --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/BFS_all.txt @@ -0,0 +1,300 @@ +95 475 0.00000 +95 285 0.00000 +608 4864 0.04000 +608 1824 0.03000 +5631 22524 0.63000 +5631 16893 0.54000 +44 396 0.00000 +44 132 0.01000 +458 1832 0.02000 +458 1374 0.02000 +8514 51084 1.47000 +8514 25542 1.53000 +10 70 0.00000 +10 30 0.00000 +210 1050 0.01000 +210 630 0.01000 +7266 21798 0.70000 +7266 21798 0.66000 +80 640 0.01000 +80 240 0.00000 +693 5544 0.05000 +693 2079 0.03000 +7944 71496 1.66000 +7944 23832 0.81000 +27 54 0.00000 +27 81 0.01000 +840 7560 0.05000 +840 2520 0.05000 +7510 15020 1.10000 +7510 22530 0.81000 +19 114 0.00000 +19 57 0.00000 +699 3495 0.03000 +699 2097 0.02000 +9203 27609 0.54000 +9203 27609 0.53000 +24 168 0.00000 +24 72 0.00000 +625 4375 0.03000 +625 1875 0.02000 +9448 37792 0.96000 +9448 28344 0.82000 +40 280 0.00000 +40 120 0.01000 +686 2058 0.04000 +686 2058 0.03000 +8245 57715 1.03000 +8245 24735 1.06000 +94 658 0.01000 +94 282 0.00000 +474 2844 0.01000 +474 1422 0.01000 +8138 73242 1.29000 +8138 24414 0.51000 +49 245 0.00000 +49 147 0.00000 +266 798 0.01000 +266 798 0.01000 +7844 70596 1.30000 +7844 23532 0.55000 +88 704 0.01000 +88 264 0.00000 +192 768 0.01000 +192 576 0.00000 +9274 27822 1.25000 +9274 27822 1.25000 +13 91 0.00000 +13 39 0.00000 +899 7192 0.05000 +899 2697 0.03000 +4901 34307 0.53000 +4901 14703 0.22000 +13 52 0.00000 +13 39 0.00000 +653 5877 0.04000 +653 1959 0.02000 +1495 13455 0.11000 +1495 4485 0.07000 +88 440 0.00000 +88 264 0.01000 +412 3708 0.02000 +412 1236 0.02000 +2702 8106 0.23000 +2702 8106 0.22000 +59 354 0.00000 +59 177 0.00000 +640 2560 0.02000 +640 1920 0.03000 +9907 79256 1.49000 +9907 29721 0.77000 +13 91 0.00000 +13 39 0.00000 +485 1455 0.02000 +485 1455 0.02000 +2953 8859 0.30000 +2953 8859 0.30000 +70 560 0.00000 +70 210 0.01000 +161 1449 0.01000 +161 483 0.01000 +9470 28410 2.07000 +9470 28410 0.48000 +93 651 0.00000 +93 279 0.00000 +731 1462 0.01000 +731 2193 0.01000 +1408 4224 0.02000 +1408 4224 0.02000 +80 560 0.01000 +80 240 0.00000 +452 3164 0.01000 +452 1356 0.01000 +8695 26085 0.23000 +8695 26085 0.22000 +62 124 0.01000 +62 186 0.00000 +624 5616 0.02000 +624 1872 0.02000 +8037 40185 0.37000 +8037 24111 0.38000 +65 585 0.00000 +65 195 0.00000 +899 8091 0.03000 +899 2697 0.02000 +4652 32564 0.17000 +4652 13956 0.09000 +19 76 0.00000 +19 57 0.00000 +332 2656 0.02000 +332 996 0.01000 +4293 30051 0.17000 +4293 12879 0.10000 +70 280 0.00000 +70 210 0.01000 +217 1736 0.02000 +217 651 0.01000 +1330 5320 0.05000 +1330 3990 0.05000 +44 88 0.00000 +44 132 0.00000 +786 2358 0.02000 +786 2358 0.01000 +2300 6900 0.04000 +2300 6900 0.03000 +78 390 0.00000 +78 234 0.00000 +848 1696 0.02000 +848 2544 0.01000 +7091 14182 0.13000 +7091 21273 0.17000 +14 28 0.00000 +14 42 0.00000 +163 1467 0.01000 +163 489 0.01000 +9326 55956 1.48000 +9326 27978 1.47000 +35 140 0.00000 +35 105 0.00000 +821 4926 0.05000 +821 2463 0.03000 +2608 20864 0.27000 +2608 7824 0.14000 +39 78 0.00000 +39 117 0.00000 +783 1566 0.02000 +783 2349 0.03000 +7338 66042 1.26000 +7338 22014 0.64000 +38 114 0.00000 +38 114 0.00000 +425 2550 0.02000 +425 1275 0.02000 +1018 5090 0.06000 +1018 3054 0.06000 +62 124 0.00000 +62 186 0.00000 +126 378 0.00000 +126 378 0.01000 +4056 8112 0.14000 +4056 12168 0.21000 +17 136 0.00000 +17 51 0.00000 +584 1168 0.01000 +584 1752 0.02000 +3306 9918 0.18000 +3306 9918 0.18000 +19804 59412 2.74000 +19804 59412 3.02000 +42 168 0.00000 +42 126 0.00000 +387 2709 0.01000 +387 1161 0.01000 +3797 22782 0.36000 +3797 11391 0.36000 +34028 102084 12.56000 +34028 102084 13.10000 +97 291 0.00000 +97 291 0.00000 +741 2964 0.03000 +741 2223 0.02000 +7391 51737 1.08000 +7391 22173 0.57000 +67897 203691 14.37000 +67897 203691 7.04000 +95 285 0.00000 +95 285 0.01000 +547 1094 0.02000 +547 1641 0.02000 +8498 59486 1.14000 +8498 25494 0.71000 +72579 290316 50.46000 +72579 217737 18.71000 +81 162 0.00000 +81 243 0.01000 +409 3272 0.02000 +409 1227 0.02000 +8863 79767 1.26000 +8863 26589 1.93000 +89153 624071 96.92000 +89153 267459 85.52000 +83 581 0.01000 +83 249 0.00000 +686 6174 0.04000 +686 2058 0.03000 +5255 42040 0.67000 +5255 15765 0.26000 +65123 325615 26.67000 +65123 195369 15.17000 +85 510 0.00000 +85 255 0.00000 +574 4592 0.03000 +574 1722 0.02000 +8536 76824 1.53000 +8536 25608 0.75000 +81055 162110 14.32000 +81055 243165 41.29000 +57 285 0.01000 +57 171 0.00000 +794 4764 0.04000 +794 2382 0.04000 +9500 76000 1.15000 +9500 28500 1.00000 +37275 74550 15.67000 +37275 111825 13.68000 +78 312 0.00000 +78 234 0.00000 +594 4752 0.04000 +594 1782 0.02000 +6160 36960 0.61000 +6160 18480 0.32000 +41142 329136 3.86000 +41142 123426 2.90000 +81 486 0.00000 +81 243 0.01000 +918 1836 0.05000 +918 2754 0.06000 +3685 33165 0.67000 +3685 11055 0.37000 +78419 313676 71.96000 +78419 235257 53.10000 +89 267 0.01000 +89 267 0.00000 +560 1680 0.04000 +560 1680 0.04000 +6184 37104 1.07000 +6184 18552 1.06000 +44276 177104 17.07000 +44276 132828 21.02000 +71 213 0.00000 +71 213 0.00000 +729 5832 0.04000 +729 2187 0.02000 +7082 42492 0.72000 +7082 21246 0.37000 +11383 45532 0.98000 +11383 34149 0.86000 +56 392 0.00000 +56 168 0.00000 +200 800 0.01000 +200 600 0.01000 +9689 29067 0.94000 +9689 29067 0.95000 +16287 114009 3.56000 +16287 48861 1.84000 +13 104 0.00000 +13 39 0.00000 +348 1740 0.02000 +348 1044 0.02000 +6074 30370 0.74000 +6074 18222 0.72000 +96859 678013 89.74000 +96859 290577 106.46000 +51 255 0.00000 +51 153 0.00000 +654 5886 0.06000 +654 1962 0.04000 +9041 36164 1.10000 +9041 27123 0.75000 +18740 168660 7.29000 +18740 56220 2.52000 diff --git a/snap-python/source/dev/examples/results-madmax/BFS_pref.txt b/snap-python/source/dev/examples/results-madmax/BFS_pref.txt new file mode 100644 index 0000000000000000000000000000000000000000..64ec93d2f14ef3e6655bab73fd6d9feb9fe3be4e --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/BFS_pref.txt @@ -0,0 +1,50 @@ +44 396 0.00000 +458 1832 0.02000 +8514 51084 1.47000 +27 54 0.00000 +840 7560 0.05000 +7510 15020 1.10000 +40 280 0.00000 +686 2058 0.04000 +8245 57715 1.03000 +88 704 0.01000 +192 768 0.01000 +9274 27822 1.25000 +88 440 0.00000 +412 3708 0.02000 +2702 8106 0.23000 +70 560 0.00000 +161 1449 0.01000 +9470 28410 2.07000 +62 124 0.01000 +624 5616 0.02000 +8037 40185 0.37000 +70 280 0.00000 +217 1736 0.02000 +1330 5320 0.05000 +14 28 0.00000 +163 1467 0.01000 +9326 55956 1.48000 +38 114 0.00000 +425 2550 0.02000 +1018 5090 0.06000 +42 168 0.00000 +387 2709 0.01000 +3797 22782 0.36000 +34028 102084 12.56000 +81 162 0.00000 +409 3272 0.02000 +8863 79767 1.26000 +89153 624071 96.92000 +57 285 0.01000 +794 4764 0.04000 +9500 76000 1.15000 +37275 74550 15.67000 +89 267 0.01000 +560 1680 0.04000 +6184 37104 1.07000 +44276 177104 17.07000 +13 104 0.00000 +348 1740 0.02000 +6074 30370 0.74000 +96859 678013 89.74000 diff --git a/snap-python/source/dev/examples/results-madmax/BFS_prefdeg3.txt b/snap-python/source/dev/examples/results-madmax/BFS_prefdeg3.txt new file mode 100644 index 0000000000000000000000000000000000000000..3c9b8f3e452816d51aa0d5470cc8bb51b1be6ce4 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/BFS_prefdeg3.txt @@ -0,0 +1,50 @@ +44 132 0.01000 +458 1374 0.02000 +8514 25542 1.53000 +27 81 0.01000 +840 2520 0.05000 +7510 22530 0.81000 +40 120 0.01000 +686 2058 0.03000 +8245 24735 1.06000 +88 264 0.00000 +192 576 0.00000 +9274 27822 1.25000 +88 264 0.01000 +412 1236 0.02000 +2702 8106 0.22000 +70 210 0.01000 +161 483 0.01000 +9470 28410 0.48000 +62 186 0.00000 +624 1872 0.02000 +8037 24111 0.38000 +70 210 0.01000 +217 651 0.01000 +1330 3990 0.05000 +14 42 0.00000 +163 489 0.01000 +9326 27978 1.47000 +38 114 0.00000 +425 1275 0.02000 +1018 3054 0.06000 +42 126 0.00000 +387 1161 0.01000 +3797 11391 0.36000 +34028 102084 13.10000 +81 243 0.01000 +409 1227 0.02000 +8863 26589 1.93000 +89153 267459 85.52000 +57 171 0.00000 +794 2382 0.04000 +9500 28500 1.00000 +37275 111825 13.68000 +89 267 0.00000 +560 1680 0.04000 +6184 18552 1.06000 +44276 132828 21.02000 +13 39 0.00000 +348 1044 0.02000 +6074 18222 0.72000 +96859 290577 106.46000 diff --git a/snap-python/source/dev/examples/results-madmax/BFS_rmat.txt b/snap-python/source/dev/examples/results-madmax/BFS_rmat.txt new file mode 100644 index 0000000000000000000000000000000000000000..e7348e2e12de253fb0713c6845520df6eaf1caf8 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/BFS_rmat.txt @@ -0,0 +1,50 @@ +10 70 0.00000 +210 1050 0.01000 +7266 21798 0.70000 +19 114 0.00000 +699 3495 0.03000 +9203 27609 0.54000 +94 658 0.01000 +474 2844 0.01000 +8138 73242 1.29000 +13 91 0.00000 +899 7192 0.05000 +4901 34307 0.53000 +59 354 0.00000 +640 2560 0.02000 +9907 79256 1.49000 +93 651 0.00000 +731 1462 0.01000 +1408 4224 0.02000 +65 585 0.00000 +899 8091 0.03000 +4652 32564 0.17000 +44 88 0.00000 +786 2358 0.02000 +2300 6900 0.04000 +35 140 0.00000 +821 4926 0.05000 +2608 20864 0.27000 +62 124 0.00000 +126 378 0.00000 +4056 8112 0.14000 +97 291 0.00000 +741 2964 0.03000 +7391 51737 1.08000 +67897 203691 14.37000 +83 581 0.01000 +686 6174 0.04000 +5255 42040 0.67000 +65123 325615 26.67000 +78 312 0.00000 +594 4752 0.04000 +6160 36960 0.61000 +41142 329136 3.86000 +71 213 0.00000 +729 5832 0.04000 +7082 42492 0.72000 +11383 45532 0.98000 +51 255 0.00000 +654 5886 0.06000 +9041 36164 1.10000 +18740 168660 7.29000 diff --git a/snap-python/source/dev/examples/results-madmax/BFS_rmatdeg3.txt b/snap-python/source/dev/examples/results-madmax/BFS_rmatdeg3.txt new file mode 100644 index 0000000000000000000000000000000000000000..017dc076e82b991839e5928b2503bdc2a6bf38ec --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/BFS_rmatdeg3.txt @@ -0,0 +1,50 @@ +10 30 0.00000 +210 630 0.01000 +7266 21798 0.66000 +19 57 0.00000 +699 2097 0.02000 +9203 27609 0.53000 +94 282 0.00000 +474 1422 0.01000 +8138 24414 0.51000 +13 39 0.00000 +899 2697 0.03000 +4901 14703 0.22000 +59 177 0.00000 +640 1920 0.03000 +9907 29721 0.77000 +93 279 0.00000 +731 2193 0.01000 +1408 4224 0.02000 +65 195 0.00000 +899 2697 0.02000 +4652 13956 0.09000 +44 132 0.00000 +786 2358 0.01000 +2300 6900 0.03000 +35 105 0.00000 +821 2463 0.03000 +2608 7824 0.14000 +62 186 0.00000 +126 378 0.01000 +4056 12168 0.21000 +97 291 0.00000 +741 2223 0.02000 +7391 22173 0.57000 +67897 203691 7.04000 +83 249 0.00000 +686 2058 0.03000 +5255 15765 0.26000 +65123 195369 15.17000 +78 234 0.00000 +594 1782 0.02000 +6160 18480 0.32000 +41142 123426 2.90000 +71 213 0.00000 +729 2187 0.02000 +7082 21246 0.37000 +11383 34149 0.86000 +51 153 0.00000 +654 1962 0.04000 +9041 27123 0.75000 +18740 56220 2.52000 diff --git a/snap-python/source/dev/examples/results-madmax/BFS_sw.txt b/snap-python/source/dev/examples/results-madmax/BFS_sw.txt new file mode 100644 index 0000000000000000000000000000000000000000..16f2db9a1a264cca5ff804832d5394733e43ba44 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/BFS_sw.txt @@ -0,0 +1,50 @@ +95 475 0.00000 +608 4864 0.04000 +5631 22524 0.63000 +80 640 0.01000 +693 5544 0.05000 +7944 71496 1.66000 +24 168 0.00000 +625 4375 0.03000 +9448 37792 0.96000 +49 245 0.00000 +266 798 0.01000 +7844 70596 1.30000 +13 52 0.00000 +653 5877 0.04000 +1495 13455 0.11000 +13 91 0.00000 +485 1455 0.02000 +2953 8859 0.30000 +80 560 0.01000 +452 3164 0.01000 +8695 26085 0.23000 +19 76 0.00000 +332 2656 0.02000 +4293 30051 0.17000 +78 390 0.00000 +848 1696 0.02000 +7091 14182 0.13000 +39 78 0.00000 +783 1566 0.02000 +7338 66042 1.26000 +17 136 0.00000 +584 1168 0.01000 +3306 9918 0.18000 +19804 59412 2.74000 +95 285 0.00000 +547 1094 0.02000 +8498 59486 1.14000 +72579 290316 50.46000 +85 510 0.00000 +574 4592 0.03000 +8536 76824 1.53000 +81055 162110 14.32000 +81 486 0.00000 +918 1836 0.05000 +3685 33165 0.67000 +78419 313676 71.96000 +56 392 0.00000 +200 800 0.01000 +9689 29067 0.94000 +16287 114009 3.56000 diff --git a/snap-python/source/dev/examples/results-madmax/BFS_swdeg3.txt b/snap-python/source/dev/examples/results-madmax/BFS_swdeg3.txt new file mode 100644 index 0000000000000000000000000000000000000000..057739d571a7425e431a7422f6d2ec570f00d240 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/BFS_swdeg3.txt @@ -0,0 +1,50 @@ +95 285 0.00000 +608 1824 0.03000 +5631 16893 0.54000 +80 240 0.00000 +693 2079 0.03000 +7944 23832 0.81000 +24 72 0.00000 +625 1875 0.02000 +9448 28344 0.82000 +49 147 0.00000 +266 798 0.01000 +7844 23532 0.55000 +13 39 0.00000 +653 1959 0.02000 +1495 4485 0.07000 +13 39 0.00000 +485 1455 0.02000 +2953 8859 0.30000 +80 240 0.00000 +452 1356 0.01000 +8695 26085 0.22000 +19 57 0.00000 +332 996 0.01000 +4293 12879 0.10000 +78 234 0.00000 +848 2544 0.01000 +7091 21273 0.17000 +39 117 0.00000 +783 2349 0.03000 +7338 22014 0.64000 +17 51 0.00000 +584 1752 0.02000 +3306 9918 0.18000 +19804 59412 3.02000 +95 285 0.01000 +547 1641 0.02000 +8498 25494 0.71000 +72579 217737 18.71000 +85 255 0.00000 +574 1722 0.02000 +8536 25608 0.75000 +81055 243165 41.29000 +81 243 0.01000 +918 2754 0.06000 +3685 11055 0.37000 +78419 235257 53.10000 +56 168 0.00000 +200 600 0.01000 +9689 29067 0.95000 +16287 48861 1.84000 diff --git a/snap-python/source/dev/examples/results-madmax/triads_all.txt b/snap-python/source/dev/examples/results-madmax/triads_all.txt new file mode 100644 index 0000000000000000000000000000000000000000..4be9db5a7c2467109e5f704c67f5e89403340068 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/triads_all.txt @@ -0,0 +1,300 @@ +95 475 0.00000 +95 285 0.00000 +608 4864 0.01000 +608 1824 0.01000 +5631 22524 0.09000 +5631 16893 0.07000 +44 396 0.00000 +44 132 0.00000 +458 1832 0.00000 +458 1374 0.00000 +8514 51084 0.20000 +8514 25542 0.19000 +10 70 0.00000 +10 30 0.00000 +210 1050 0.00000 +210 630 0.00000 +7266 21798 0.15000 +7266 21798 0.14000 +80 640 0.00000 +80 240 0.00000 +693 5544 0.01000 +693 2079 0.00000 +7944 71496 0.40000 +7944 23832 0.11000 +27 54 0.00000 +27 81 0.00000 +840 7560 0.00000 +840 2520 0.01000 +7510 15020 0.15000 +7510 22530 0.14000 +19 114 0.00000 +19 57 0.00000 +699 3495 0.01000 +699 2097 0.01000 +9203 27609 0.13000 +9203 27609 0.14000 +24 168 0.00000 +24 72 0.00000 +625 4375 0.01000 +625 1875 0.00000 +9448 37792 0.12000 +9448 28344 0.08000 +40 280 0.00000 +40 120 0.00000 +686 2058 0.00000 +686 2058 0.01000 +8245 57715 0.12000 +8245 24735 0.13000 +94 658 0.00000 +94 282 0.00000 +474 2844 0.01000 +474 1422 0.01000 +8138 73242 0.52000 +8138 24414 0.12000 +49 245 0.00000 +49 147 0.00000 +266 798 0.00000 +266 798 0.01000 +7844 70596 0.32000 +7844 23532 0.07000 +88 704 0.00000 +88 264 0.00000 +192 768 0.00000 +192 576 0.00000 +9274 27822 0.14000 +9274 27822 0.16000 +13 91 0.00000 +13 39 0.00000 +899 7192 0.02000 +899 2697 0.01000 +4901 34307 0.18000 +4901 14703 0.07000 +13 52 0.00000 +13 39 0.00000 +653 5877 0.01000 +653 1959 0.00000 +1495 13455 0.04000 +1495 4485 0.00000 +88 440 0.00000 +88 264 0.00000 +412 3708 0.00000 +412 1236 0.00000 +2702 8106 0.03000 +2702 8106 0.03000 +59 354 0.00000 +59 177 0.00000 +640 2560 0.01000 +640 1920 0.00000 +9907 79256 0.66000 +9907 29721 0.14000 +13 91 0.00000 +13 39 0.00000 +485 1455 0.00000 +485 1455 0.00000 +2953 8859 0.04000 +2953 8859 0.04000 +70 560 0.01000 +70 210 0.00000 +161 1449 0.00000 +161 483 0.00000 +9470 28410 0.25000 +9470 28410 0.23000 +93 651 0.00000 +93 279 0.00000 +731 1462 0.00000 +731 2193 0.01000 +1408 4224 0.01000 +1408 4224 0.01000 +80 560 0.00000 +80 240 0.00000 +452 3164 0.00000 +452 1356 0.00000 +8695 26085 0.02000 +8695 26085 0.03000 +62 124 0.00000 +62 186 0.00000 +624 5616 0.00000 +624 1872 0.01000 +8037 40185 0.06000 +8037 24111 0.05000 +65 585 0.00000 +65 195 0.00000 +899 8091 0.03000 +899 2697 0.00000 +4652 32564 0.09000 +4652 13956 0.03000 +19 76 0.00000 +19 57 0.00000 +332 2656 0.01000 +332 996 0.00000 +4293 30051 0.04000 +4293 12879 0.01000 +70 280 0.00000 +70 210 0.00000 +217 1736 0.00000 +217 651 0.00000 +1330 5320 0.01000 +1330 3990 0.01000 +44 88 0.00000 +44 132 0.00000 +786 2358 0.01000 +786 2358 0.00000 +2300 6900 0.01000 +2300 6900 0.01000 +78 390 0.00000 +78 234 0.00000 +848 1696 0.01000 +848 2544 0.00000 +7091 14182 0.01000 +7091 21273 0.03000 +14 28 0.00000 +14 42 0.00000 +163 1467 0.00000 +163 489 0.00000 +9326 55956 0.16000 +9326 27978 0.18000 +35 140 0.00000 +35 105 0.00000 +821 4926 0.02000 +821 2463 0.00000 +2608 20864 0.12000 +2608 7824 0.03000 +39 78 0.00000 +39 117 0.00000 +783 1566 0.00000 +783 2349 0.00000 +7338 66042 0.31000 +7338 22014 0.07000 +38 114 0.01000 +38 114 0.00000 +425 2550 0.00000 +425 1275 0.01000 +1018 5090 0.01000 +1018 3054 0.01000 +62 124 0.00000 +62 186 0.00000 +126 378 0.00000 +126 378 0.00000 +4056 8112 0.03000 +4056 12168 0.06000 +17 136 0.00000 +17 51 0.00000 +584 1168 0.01000 +584 1752 0.01000 +3306 9918 0.02000 +3306 9918 0.02000 +19804 59412 0.19000 +19804 59412 0.25000 +42 168 0.00000 +42 126 0.00000 +387 2709 0.00000 +387 1161 0.01000 +3797 22782 0.05000 +3797 11391 0.05000 +34028 102084 0.81000 +34028 102084 0.77000 +97 291 0.00000 +97 291 0.00000 +741 2964 0.01000 +741 2223 0.01000 +7391 51737 0.37000 +7391 22173 0.12000 +67897 203691 1.64000 +67897 203691 0.45000 +95 285 0.00000 +95 285 0.00000 +547 1094 0.00000 +547 1641 0.00000 +8498 59486 0.22000 +8498 25494 0.08000 +72579 290316 1.22000 +72579 217737 1.08000 +81 162 0.00000 +81 243 0.00000 +409 3272 0.01000 +409 1227 0.00000 +8863 79767 0.07000 +8863 26589 0.23000 +89153 624071 3.67000 +89153 267459 2.19000 +83 581 0.00000 +83 249 0.00000 +686 6174 0.02000 +686 2058 0.00000 +5255 42040 0.31000 +5255 15765 0.07000 +65123 325615 3.05000 +65123 195369 1.27000 +85 510 0.01000 +85 255 0.00000 +574 4592 0.01000 +574 1722 0.00000 +8536 76824 0.35000 +8536 25608 0.08000 +81055 162110 0.83000 +81055 243165 0.92000 +57 285 0.00000 +57 171 0.00000 +794 4764 0.01000 +794 2382 0.00000 +9500 76000 0.15000 +9500 28500 0.13000 +37275 74550 0.64000 +37275 111825 0.91000 +78 312 0.01000 +78 234 0.00000 +594 4752 0.01000 +594 1782 0.00000 +6160 36960 0.17000 +6160 18480 0.07000 +41142 329136 3.20000 +41142 123426 0.22000 +81 486 0.00000 +81 243 0.00000 +918 1836 0.00000 +918 2754 0.00000 +3685 33165 0.21000 +3685 11055 0.05000 +78419 313676 2.33000 +78419 235257 1.67000 +89 267 0.00000 +89 267 0.00000 +560 1680 0.01000 +560 1680 0.00000 +6184 37104 0.14000 +6184 18552 0.14000 +44276 177104 1.51000 +44276 132828 0.33000 +71 213 0.00000 +71 213 0.00000 +729 5832 0.01000 +729 2187 0.01000 +7082 42492 0.31000 +7082 21246 0.09000 +11383 45532 0.27000 +11383 34149 0.19000 +56 392 0.01000 +56 168 0.00000 +200 800 0.00000 +200 600 0.00000 +9689 29067 0.09000 +9689 29067 0.10000 +16287 114009 0.52000 +16287 48861 0.18000 +13 104 0.00000 +13 39 0.00000 +348 1740 0.00000 +348 1044 0.00000 +6074 30370 0.09000 +6074 18222 0.09000 +96859 678013 2.70000 +96859 290577 2.71000 +51 255 0.00000 +51 153 0.00000 +654 5886 0.02000 +654 1962 0.00000 +9041 36164 0.28000 +9041 27123 0.21000 +18740 168660 2.01000 +18740 56220 0.50000 diff --git a/snap-python/source/dev/examples/results-madmax/triads_pref.txt b/snap-python/source/dev/examples/results-madmax/triads_pref.txt new file mode 100644 index 0000000000000000000000000000000000000000..940ee10e968dab7fa635e74d0164594032fbff8f --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/triads_pref.txt @@ -0,0 +1,50 @@ +44 396 0.00000 +458 1832 0.00000 +8514 51084 0.20000 +27 54 0.00000 +840 7560 0.00000 +7510 15020 0.15000 +40 280 0.00000 +686 2058 0.00000 +8245 57715 0.12000 +88 704 0.00000 +192 768 0.00000 +9274 27822 0.14000 +88 440 0.00000 +412 3708 0.00000 +2702 8106 0.03000 +70 560 0.01000 +161 1449 0.00000 +9470 28410 0.25000 +62 124 0.00000 +624 5616 0.00000 +8037 40185 0.06000 +70 280 0.00000 +217 1736 0.00000 +1330 5320 0.01000 +14 28 0.00000 +163 1467 0.00000 +9326 55956 0.16000 +38 114 0.01000 +425 2550 0.00000 +1018 5090 0.01000 +42 168 0.00000 +387 2709 0.00000 +3797 22782 0.05000 +34028 102084 0.81000 +81 162 0.00000 +409 3272 0.01000 +8863 79767 0.07000 +89153 624071 3.67000 +57 285 0.00000 +794 4764 0.01000 +9500 76000 0.15000 +37275 74550 0.64000 +89 267 0.00000 +560 1680 0.01000 +6184 37104 0.14000 +44276 177104 1.51000 +13 104 0.00000 +348 1740 0.00000 +6074 30370 0.09000 +96859 678013 2.70000 diff --git a/snap-python/source/dev/examples/results-madmax/triads_prefdeg3.txt b/snap-python/source/dev/examples/results-madmax/triads_prefdeg3.txt new file mode 100644 index 0000000000000000000000000000000000000000..9a3e4bacb401dc98f5f3709d73b590825fec2a23 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/triads_prefdeg3.txt @@ -0,0 +1,50 @@ +44 132 0.00000 +458 1374 0.00000 +8514 25542 0.19000 +27 81 0.00000 +840 2520 0.01000 +7510 22530 0.14000 +40 120 0.00000 +686 2058 0.01000 +8245 24735 0.13000 +88 264 0.00000 +192 576 0.00000 +9274 27822 0.16000 +88 264 0.00000 +412 1236 0.00000 +2702 8106 0.03000 +70 210 0.00000 +161 483 0.00000 +9470 28410 0.23000 +62 186 0.00000 +624 1872 0.01000 +8037 24111 0.05000 +70 210 0.00000 +217 651 0.00000 +1330 3990 0.01000 +14 42 0.00000 +163 489 0.00000 +9326 27978 0.18000 +38 114 0.00000 +425 1275 0.01000 +1018 3054 0.01000 +42 126 0.00000 +387 1161 0.01000 +3797 11391 0.05000 +34028 102084 0.77000 +81 243 0.00000 +409 1227 0.00000 +8863 26589 0.23000 +89153 267459 2.19000 +57 171 0.00000 +794 2382 0.00000 +9500 28500 0.13000 +37275 111825 0.91000 +89 267 0.00000 +560 1680 0.00000 +6184 18552 0.14000 +44276 132828 0.33000 +13 39 0.00000 +348 1044 0.00000 +6074 18222 0.09000 +96859 290577 2.71000 diff --git a/snap-python/source/dev/examples/results-madmax/triads_rmat.txt b/snap-python/source/dev/examples/results-madmax/triads_rmat.txt new file mode 100644 index 0000000000000000000000000000000000000000..8660a2f66a865474777e545081a4f266f563e656 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/triads_rmat.txt @@ -0,0 +1,50 @@ +10 70 0.00000 +210 1050 0.00000 +7266 21798 0.15000 +19 114 0.00000 +699 3495 0.01000 +9203 27609 0.13000 +94 658 0.00000 +474 2844 0.01000 +8138 73242 0.52000 +13 91 0.00000 +899 7192 0.02000 +4901 34307 0.18000 +59 354 0.00000 +640 2560 0.01000 +9907 79256 0.66000 +93 651 0.00000 +731 1462 0.00000 +1408 4224 0.01000 +65 585 0.00000 +899 8091 0.03000 +4652 32564 0.09000 +44 88 0.00000 +786 2358 0.01000 +2300 6900 0.01000 +35 140 0.00000 +821 4926 0.02000 +2608 20864 0.12000 +62 124 0.00000 +126 378 0.00000 +4056 8112 0.03000 +97 291 0.00000 +741 2964 0.01000 +7391 51737 0.37000 +67897 203691 1.64000 +83 581 0.00000 +686 6174 0.02000 +5255 42040 0.31000 +65123 325615 3.05000 +78 312 0.01000 +594 4752 0.01000 +6160 36960 0.17000 +41142 329136 3.20000 +71 213 0.00000 +729 5832 0.01000 +7082 42492 0.31000 +11383 45532 0.27000 +51 255 0.00000 +654 5886 0.02000 +9041 36164 0.28000 +18740 168660 2.01000 diff --git a/snap-python/source/dev/examples/results-madmax/triads_rmatdeg3.txt b/snap-python/source/dev/examples/results-madmax/triads_rmatdeg3.txt new file mode 100644 index 0000000000000000000000000000000000000000..a2a9a0041a19616194754a1a01c1cf0ad5ad0fab --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/triads_rmatdeg3.txt @@ -0,0 +1,50 @@ +10 30 0.00000 +210 630 0.00000 +7266 21798 0.14000 +19 57 0.00000 +699 2097 0.01000 +9203 27609 0.14000 +94 282 0.00000 +474 1422 0.01000 +8138 24414 0.12000 +13 39 0.00000 +899 2697 0.01000 +4901 14703 0.07000 +59 177 0.00000 +640 1920 0.00000 +9907 29721 0.14000 +93 279 0.00000 +731 2193 0.01000 +1408 4224 0.01000 +65 195 0.00000 +899 2697 0.00000 +4652 13956 0.03000 +44 132 0.00000 +786 2358 0.00000 +2300 6900 0.01000 +35 105 0.00000 +821 2463 0.00000 +2608 7824 0.03000 +62 186 0.00000 +126 378 0.00000 +4056 12168 0.06000 +97 291 0.00000 +741 2223 0.01000 +7391 22173 0.12000 +67897 203691 0.45000 +83 249 0.00000 +686 2058 0.00000 +5255 15765 0.07000 +65123 195369 1.27000 +78 234 0.00000 +594 1782 0.00000 +6160 18480 0.07000 +41142 123426 0.22000 +71 213 0.00000 +729 2187 0.01000 +7082 21246 0.09000 +11383 34149 0.19000 +51 153 0.00000 +654 1962 0.00000 +9041 27123 0.21000 +18740 56220 0.50000 diff --git a/snap-python/source/dev/examples/results-madmax/triads_sw.txt b/snap-python/source/dev/examples/results-madmax/triads_sw.txt new file mode 100644 index 0000000000000000000000000000000000000000..3e5bb265be3cf8bb69cd76de8b62f94f10670511 --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/triads_sw.txt @@ -0,0 +1,50 @@ +95 475 0.00000 +608 4864 0.01000 +5631 22524 0.09000 +80 640 0.00000 +693 5544 0.01000 +7944 71496 0.40000 +24 168 0.00000 +625 4375 0.01000 +9448 37792 0.12000 +49 245 0.00000 +266 798 0.00000 +7844 70596 0.32000 +13 52 0.00000 +653 5877 0.01000 +1495 13455 0.04000 +13 91 0.00000 +485 1455 0.00000 +2953 8859 0.04000 +80 560 0.00000 +452 3164 0.00000 +8695 26085 0.02000 +19 76 0.00000 +332 2656 0.01000 +4293 30051 0.04000 +78 390 0.00000 +848 1696 0.01000 +7091 14182 0.01000 +39 78 0.00000 +783 1566 0.00000 +7338 66042 0.31000 +17 136 0.00000 +584 1168 0.01000 +3306 9918 0.02000 +19804 59412 0.19000 +95 285 0.00000 +547 1094 0.00000 +8498 59486 0.22000 +72579 290316 1.22000 +85 510 0.01000 +574 4592 0.01000 +8536 76824 0.35000 +81055 162110 0.83000 +81 486 0.00000 +918 1836 0.00000 +3685 33165 0.21000 +78419 313676 2.33000 +56 392 0.01000 +200 800 0.00000 +9689 29067 0.09000 +16287 114009 0.52000 diff --git a/snap-python/source/dev/examples/results-madmax/triads_swdeg3.txt b/snap-python/source/dev/examples/results-madmax/triads_swdeg3.txt new file mode 100644 index 0000000000000000000000000000000000000000..865d91758112a396201f416f95d7ce56abd8722e --- /dev/null +++ b/snap-python/source/dev/examples/results-madmax/triads_swdeg3.txt @@ -0,0 +1,50 @@ +95 285 0.00000 +608 1824 0.01000 +5631 16893 0.07000 +80 240 0.00000 +693 2079 0.00000 +7944 23832 0.11000 +24 72 0.00000 +625 1875 0.00000 +9448 28344 0.08000 +49 147 0.00000 +266 798 0.01000 +7844 23532 0.07000 +13 39 0.00000 +653 1959 0.00000 +1495 4485 0.00000 +13 39 0.00000 +485 1455 0.00000 +2953 8859 0.04000 +80 240 0.00000 +452 1356 0.00000 +8695 26085 0.03000 +19 57 0.00000 +332 996 0.00000 +4293 12879 0.01000 +78 234 0.00000 +848 2544 0.00000 +7091 21273 0.03000 +39 117 0.00000 +783 2349 0.00000 +7338 22014 0.07000 +17 51 0.00000 +584 1752 0.01000 +3306 9918 0.02000 +19804 59412 0.25000 +95 285 0.00000 +547 1641 0.00000 +8498 25494 0.08000 +72579 217737 1.08000 +85 255 0.00000 +574 1722 0.00000 +8536 25608 0.08000 +81055 243165 0.92000 +81 243 0.00000 +918 2754 0.00000 +3685 11055 0.05000 +78419 235257 1.67000 +56 168 0.00000 +200 600 0.00000 +9689 29067 0.10000 +16287 48861 0.18000 diff --git a/snap-python/source/dev/examples/snapswig-check.py b/snap-python/source/dev/examples/snapswig-check.py new file mode 100644 index 0000000000000000000000000000000000000000..5c0f0daa4ef2683d88c31b72596dd0ccf6bc4d76 --- /dev/null +++ b/snap-python/source/dev/examples/snapswig-check.py @@ -0,0 +1,53 @@ +#!/usr/bin/python +# test-bfsdfs.py +# +# Author: Nick Shelly, Spring 2013 +# Description: +# - Loads SNAP as a Python module. +# - Performs mini unit tests for the following functions: +# - gviz (graph visualization, using Gnuplot) +# - bfsfdfs (Breadth First Search) + +import sys +sys.path.append("../swig-r") +import snap + +import os +import unittest + +def GVizTest(NNodes, NEdges): + + Graph = snap.GenRndGnm(NNodes, NEdges, 1) + FName = "test.png" + snap.DrawGViz(Graph, 1, snap.TStr(FName), + snap.TStr("Snap Ringo Dot"), 1) + + return os.path.exists(FName) + +def BfsDfsTest(NNodes, NEdges): + Graph = snap.GenRndGnm(NNodes, NEdges, 1) + + snap.GetBfsTree(Graph, False, False, 1) + + G2 = snap.GetBfsTree(Graph, False, False, 1) + + return G2 + +class GVizTests(unittest.TestCase): + + def testOne(self): + NNodes, NEdges = (15, 25) + self.failUnless(GVizTest(NNodes, NEdges)) + + def testTwo(self): + NNodes, NEdges = (8242, 12424) + G = BfsDfsTest(NNodes, NEdges) + self.assertEqual(NNodes == G.GetNodes(), NEdges == G.GetEdges()) + +def main(): + unittest.main() + +if __name__ == "__main__": + main() + + diff --git a/snap-python/source/dev/examples/tneanet-cpp.py b/snap-python/source/dev/examples/tneanet-cpp.py new file mode 100644 index 0000000000000000000000000000000000000000..688b3a04e95abf4360d7a5db3f733441b599a98c --- /dev/null +++ b/snap-python/source/dev/examples/tneanet-cpp.py @@ -0,0 +1,17 @@ +import sys +from socket import gethostname + +sys.path.append("../swig-r") +import snap + +def main(): + + # Run TNEAGraph demo + snap.DefaultConstructor() + + snap.ManipulateNodesEdges() + + snap.ManipulateNodeEdgeAttributes() + +if __name__ == "__main__": + main() diff --git a/snap-python/source/dev/examples/tneanet.py b/snap-python/source/dev/examples/tneanet.py new file mode 100644 index 0000000000000000000000000000000000000000..b33afe418322fcdb5df384c8dbfb88c8e59b60a4 --- /dev/null +++ b/snap-python/source/dev/examples/tneanet.py @@ -0,0 +1,334 @@ +import random +import sys +sys.path.append("../swig-r") +from snap import * + +def PrintGStats(s, Graph): + ''' + Print graph statistics + ''' + + print "graph %s, nodes %d, edges %d, empty %s" % ( + s, Graph.GetNodes(), Graph.GetEdges(), + "yes" if Graph.Empty() else "no") + +def DefaultConstructor(): + ''' + Test the default constructor + ''' + + Graph = TNEANet() + PrintGStats("DefaultConstructor:Graph", Graph) + +def ManipulateNodesEdges(): + ''' + Test node, edge creation + ''' + + NNodes = 10000 + NEdges = 100000 + FName = "test.graph" + + Graph = TNEANet() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1", Graph) + + # get all the nodes + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + # get all the edges for all the nodes + ECount1 = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + ECount1 += NI.GetOutDeg() + NI.Next() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0 + EI = Graph.BegEI() + while EI < Graph.EndEI(): + ECount2 += 1 + EI.Next() + + print "graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d"\ + % (NCount, ECount1, ECount2) + + # assignment + Graph1 = Graph + PrintGStats("ManipulateNodesEdges:Graph3", Graph1) + + # save the graph + print "graph type = ", type(Graph) + FOut = TFOut(TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + FIn = TFIn(TStr(FName)) + Graph2 = TNEANet(FIn) + PrintGStats("ManipulateNodesEdges:Graph4" , Graph2) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5" , Graph) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6" , Graph1) + +def ManipulateNodeEdgeAttributes(): + ''' + Test node attribute functionality + ''' + + NNodes = 1000 + NEdges = 1000 + + Graph = TNEANet() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + print "Added nodes" + + # create attributes and fill all nodes + attr1 = TStr("str") + attr2 = TStr("int") + attr3 = TStr("float") + attr4 = TStr("default") + + # Test verticaliterator for node 3, 50, 700, 900 + # Check if we can set defaults to 0 fordata. + Graph.AddIntAttrN(attr2, 0) + Graph.AddIntAttrDatN(3, 3*2, attr2) + Graph.AddIntAttrDatN(50, 50*2, attr2) + Graph.AddIntAttrDatN(700, 700*2, attr2) + Graph.AddIntAttrDatN(900, 900*2, attr2) + + print "Added attributes" + + NodeId = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + if NI.GetDat() != 0: + print "Attribute: %s, Node: %i, Val: %d" % (attr2(), NodeId, NI.GetDat()) + NodeId += 1 + NI.Next() + + # Test vertical flt iterator for node 3, 50, 700, 900 + Graph.AddFltAttrDatN(5, 3.41, attr3) + Graph.AddFltAttrDatN(50, 2.718, attr3) + Graph.AddFltAttrDatN(300, 150.0, attr3) + + Graph.AddFltAttrDatN(653, 653, attr3) + NodeId = 0 + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + NI = Graph.BegNAFltI(attr3) + NodeId = 0 + while NI < Graph.EndNAFltI(attr3): + if NI.GetDat() != TFlt.Mn: + print "Attribute: %s, Node: %i, Val: %f" % (attr3(), NodeId, NI.GetDat()) + NodeId += 1 + NI.Next() + + # Test vertical str iterator for node 3, 50, 700, 900 + Graph.AddStrAttrDatN(10, TStr("abc"), attr1) + Graph.AddStrAttrDatN(20, TStr("def"), attr1) + Graph.AddStrAttrDatN(400, TStr("ghi"), attr1) + # this does not show since ""=null + Graph.AddStrAttrDatN(455, TStr(""), attr1) + NodeId = 0 + + NI = Graph.BegNAStrI(attr1) + NodeId = 0 + while NI < Graph.EndNAStrI(attr1): + if NI.GetDat() != TStr.GetNullStr(): + print "Attribute: %s, Node: %i, Val: %s" % (attr1(), NodeId, NI.GetDat()) + NodeId += 1 + NI.Next() + + # Test vertical iterator over many types (must skip default/deleted attr) + NId = 55 + Graph.AddStrAttrDatN(NId, TStr("aaa"), attr1) + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.AddFltAttrDatN(NId, 3.41, attr3) + Graph.AddStrAttrDatN(80, TStr("dont appear"), attr4) # should not show up + NIdAttrName = TStrV() + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Node: %i, Attr: %s" % (NId, NIdAttrName.GetI(i)()) + + Graph.DelAttrDatN(NId, attr2) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Node (no int) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)()) + + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.DelAttrN(attr1) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Node (no str) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)()) + + NIdAttrValue = TStrV() + Graph.AttrValueNI(NId, NIdAttrValue) + AttrLen = NIdAttrValue.Len() + for i in range(AttrLen): + print "Vertical Node (no str) : %i, Attr_Val: %s" % (NId, NIdAttrName.GetI(i)()) + + for i in range(NNodes): + Graph.AddIntAttrDatN(i, 70, attr2) + + total = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + total += NI.GetDat() + NI.Next() + + print "Average: %i (should be 70)" % (total/NNodes) + + # Test verticaliterator for edge + Graph.AddIntAttrDatE(3, 3*2, attr2) + Graph.AddIntAttrDatE(55, 55*2, attr2) + Graph.AddIntAttrDatE(705, 705*2, attr2) + Graph.AddIntAttrDatE(905, 905*2, attr2) + EdgeId = 0 + EI = Graph.BegEAIntI(attr2) + while EI < Graph.EndEAIntI(attr2): + if EI.GetDat() != TInt.Mn: + print "E Attribute: %s, Edge: %i, Val: %i"\ + % (attr2(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test vertical flt iterator for edge + Graph.AddFltAttrE(attr3, 0.00) + Graph.AddFltAttrDatE(5, 4.41, attr3) + Graph.AddFltAttrDatE(50, 3.718, attr3) + Graph.AddFltAttrDatE(300, 151.0, attr3) + Graph.AddFltAttrDatE(653, 654, attr3) + EdgeId = 0 + EI = Graph.BegEAFltI(attr3) + while EI < Graph.EndEAFltI(attr3): + # Check if defaults are set to 0. + if EI.GetDat() != 0: + print "E Attribute: %s, Edge: %i, Val: %f" % \ + (attr3(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test vertical str iterator for edge + Graph.AddStrAttrDatE(10, TStr("abc"), attr1) + Graph.AddStrAttrDatE(20, TStr("def"), attr1) + Graph.AddStrAttrDatE(400, TStr("ghi"), attr1) + # this does not show since ""=null + Graph.AddStrAttrDatE(455, TStr(""), attr1) + EdgeId = 0 + EI = Graph.BegEAStrI(attr1) + while EI < Graph.EndEAStrI(attr1): + if EI.GetDat() != TStr.GetNullStr(): + print "E Attribute: %s, Edge: %i, Val: %s" %\ + (attr1(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test vertical iterator over many types (must skip default/deleted attr) + EId = 55 + Graph.AddStrAttrDatE(EId, TStr("aaa"), attr1) + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.AddFltAttrDatE(EId, 3.41, attr3) + Graph.AddStrAttrDatE(80, TStr("dont appear"), attr4) # should not show up + EIdAttrName = TStrV() +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Edge: %i, Attr: %s" % (EId, EIdAttrName.GetI(i)) + + Graph.DelAttrDatE(EId, attr2) +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Edge (no int) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i)) + + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.DelAttrE(attr1) +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Edge (no str) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i)()) + + EIdAttrValue = TStrV() + Graph.AttrValueEI(TInt(EId), EIdAttrValue) + AttrLen = EIdAttrValue.Len() + for i in range(AttrLen): + print "Vertical Edge (no str) : %i, Attr_Val: %s" % (EId, EIdAttrValue.GetI(i)()) + + for i in range(NEdges): + Graph.AddIntAttrDatE(i, 70, attr2) + + total = 0 + EI = Graph.BegNAIntI(attr2) + while EI < Graph.EndNAIntI(attr2): + total += EI.GetDat() + EI.Next() + + print "Average: %i (should be 70)" % (total/NEdges) + + Graph.Clr() + +if __name__ == '__main__': + print "----- DefaultConstructor -----" + DefaultConstructor() + print "----- ManipulateNodesEdges -----" + ManipulateNodesEdges() + print "----- ManipulateNodesEdgesAttributes -----" + ManipulateNodeEdgeAttributes() + diff --git a/snap-python/source/dev/examples/tnodei.py b/snap-python/source/dev/examples/tnodei.py new file mode 100644 index 0000000000000000000000000000000000000000..3455cd53649856fd9bcd24349eacf98602ee6d16 --- /dev/null +++ b/snap-python/source/dev/examples/tnodei.py @@ -0,0 +1,7 @@ +import snap +g = snap.TNGraph() +g.AddNode() +NI = g.BegNI() +print NI +dir(NI) + diff --git a/snap-python/source/dev/examples/tungraph.py b/snap-python/source/dev/examples/tungraph.py new file mode 100644 index 0000000000000000000000000000000000000000..788d68479fe04280827b76769dc0786af1cc14a6 --- /dev/null +++ b/snap-python/source/dev/examples/tungraph.py @@ -0,0 +1,122 @@ +import random +import sys + +sys.path.append("../swig-r") + +import snap + +def PrintGStats(s, Graph): + ''' + Print graph statistics + ''' + + print "graph %s, nodes %d, edges %d, empty %s" % ( + s, Graph.GetNodes(), Graph.GetEdges(), + "yes" if Graph.Empty() else "no") + +def DefaultConstructor(): + ''' + Test the default constructor + ''' + + Graph = snap.TUNGraph() + PrintGStats("DefaultConstructor:Graph",Graph) + +def ManipulateNodesEdges(): + ''' + Test node, edge creation + ''' + + NNodes = 10000 + NEdges = 100000 + FName = "test.graph" + + Graph = snap.TUNGraph() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1",Graph) + + # get all the nodes + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + # get all the edges for all the nodes + ECount1 = 0; + NI = Graph.BegNI() + while NI < Graph.EndNI(): + ECount1 += NI.GetOutDeg() + NI.Next() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0; + EI = Graph.BegEI() + while EI < Graph.EndEI(): + ECount2 += 1 + EI.Next() + + print "graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d" % ( + NCount, ECount1, ECount2) + + # assignment + Graph1 = Graph; + PrintGStats("ManipulateNodesEdges:Graph3",Graph1) + + # save the graph + FOut = snap.TFOut(snap.TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + FIn = snap.TFIn(snap.TStr(FName)) + Graph2 = snap.TUNGraph(FIn) + PrintGStats("ManipulateNodesEdges:Graph4",Graph2) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5",Graph) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6",Graph1) + +def GetSmallGraph(): + ''' + Test small graph + ''' + + Graph = snap.TUNGraph() + Graph.GetSmallGraph() + PrintGStats("GetSmallGraph:Graph",Graph) + +if __name__ == '__main__': + print "----- DefaultConstructor -----" + DefaultConstructor() + print "----- ManipulateNodesEdges -----" + ManipulateNodesEdges() + print "----- GetSmallGraph -----" + GetSmallGraph() + diff --git a/snap-python/source/dev/examples/vector_comp.py b/snap-python/source/dev/examples/vector_comp.py new file mode 100644 index 0000000000000000000000000000000000000000..88099f00d529744a4500bfd304c7a2e5802dc11a --- /dev/null +++ b/snap-python/source/dev/examples/vector_comp.py @@ -0,0 +1,69 @@ +#!/usr/bin/python +# vector_comp.py +# +# Author: Nick Shelly, Spring 2013 +# Description: +# - Loads SNAP as a Python module. +# - Randomly generates Python types +# - Compares conversion of Python types to SNAP types: +# 1. Python instantiation of SNAP type +# 2. Passing Python objects to SWIG C++ and convertion to SNAP type + +import sys +sys.path.append("../swig-r") +import snap +import timeit +import cProfile + +# Python conversion of Python list to SNAP vector +def PyListToTIntV(pylist): + + v = snap.TIntV() + for i in pylist: + v.Add(i) + + return v + +# C++ conversion of Python list to SNAP vector +def SwigPyList(pylist): + v = snap.PyToTIntV(pylist) + return v + +def main(): + + n = 10**8 + + pylist = range(n) + + # Basic verification that both methods have the same effect. + #v1 = PyListToTIntV(pylist) + #assert v1.Len() == n + + #v2 = SwigPyList(pylist) + #assert v2.Len() == n + #assert v1 == v2 # Doesn't appear to check + #print "Converted %d values\n" % v2.Len() + + setup = """\ +import snap +from __main__ import PyListToTIntV, SwigPyList +pylist = range(%d) +""" % n + + print "Method 1: Python-to-SNAP conversion:" + print "-" * 50 + s1 = "v1 = PyListToTIntV(pylist)" +# print timeit.timeit(setup=setup, stmt=s1, number=5)/5.0 + cProfile.run(setup + s1) + + print "Method 2: Python-to-SNAP conversion:" + print "-" * 50 + + s2 = "v2 = SwigPyList(pylist)" +# print timeit.timeit(setup=setup, stmt=s2, number=5)/5.0 + cProfile.run(setup + s2) + +if __name__ == "__main__": + main() + + diff --git a/snap-python/source/dev/snap-python.xcodeproj/project.pbxproj b/snap-python/source/dev/snap-python.xcodeproj/project.pbxproj new file mode 100644 index 0000000000000000000000000000000000000000..bc65fe84688586e73b46fc101ab9a5f508f67190 --- /dev/null +++ b/snap-python/source/dev/snap-python.xcodeproj/project.pbxproj @@ -0,0 +1,3477 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + 841A46031758649000CDFE82 /* snap_types.i in Sources */ = {isa = PBXBuildFile; fileRef = 848838791755941700F3BBD7 /* snap_types.i */; }; + 841A46041758649000CDFE82 /* pneanet.i in Sources */ = {isa = PBXBuildFile; fileRef = 845FBA6417458DE40068CC0C /* pneanet.i */; }; + 841E00C516DC449900B86980 /* getassessment.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 849766F416D32A8B00EE1E91 /* getassessment.cpp */; }; + 8456FCEA16E2E28D00ECCD5F /* goodgraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8456FCE916E2E28D00ECCD5F /* goodgraph.cpp */; }; + 8488019416D20FF300C789B8 /* printgraph.h in Sources */ = {isa = PBXBuildFile; fileRef = 8474830916CD86B300AF3EF4 /* printgraph.h */; }; + 8488019616D20FF300C789B8 /* snapswig.h in Sources */ = {isa = PBXBuildFile; fileRef = 8474831016CD86B300AF3EF4 /* snapswig.h */; }; + 84ACCF0E1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB2A1761173B004ABE58 /* Makefile */; }; + 84ACCF0F1761173E004ABE58 /* agmfitmain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB301761173B004ABE58 /* agmfitmain.cpp */; }; + 84ACCF101761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB331761173B004ABE58 /* Makefile */; }; + 84ACCF111761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB361761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF121761173E004ABE58 /* agmgen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB3B1761173B004ABE58 /* agmgen.cpp */; }; + 84ACCF131761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB3F1761173B004ABE58 /* Makefile */; }; + 84ACCF141761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB421761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF151761173E004ABE58 /* bigclam.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB481761173B004ABE58 /* bigclam.cpp */; }; + 84ACCF161761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB4A1761173B004ABE58 /* Makefile */; }; + 84ACCF171761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB4D1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF181761173E004ABE58 /* cascades.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB521761173B004ABE58 /* cascades.cpp */; }; + 84ACCF191761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB551761173B004ABE58 /* Makefile */; }; + 84ACCF1A1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB581761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF1B1761173E004ABE58 /* centrality.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB5D1761173B004ABE58 /* centrality.cpp */; }; + 84ACCF1C1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB601761173B004ABE58 /* Makefile */; }; + 84ACCF1D1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB631761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF1E1761173E004ABE58 /* circles.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB681761173B004ABE58 /* circles.cpp */; }; + 84ACCF1F1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB6C1761173B004ABE58 /* Makefile */; }; + 84ACCF201761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB6E1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF211761173E004ABE58 /* cliquesmain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB751761173B004ABE58 /* cliquesmain.cpp */; }; + 84ACCF221761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB761761173B004ABE58 /* Makefile */; }; + 84ACCF231761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB791761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF241761173E004ABE58 /* community.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB7E1761173B004ABE58 /* community.cpp */; }; + 84ACCF251761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB811761173B004ABE58 /* Makefile */; }; + 84ACCF261761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB841761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF271761173E004ABE58 /* concomp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB891761173B004ABE58 /* concomp.cpp */; }; + 84ACCF281761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB8C1761173B004ABE58 /* Makefile */; }; + 84ACCF291761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB8F1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF2A1761173E004ABE58 /* forestfire.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB941761173B004ABE58 /* forestfire.cpp */; }; + 84ACCF2B1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB971761173B004ABE58 /* Makefile */; }; + 84ACCF2C1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB9A1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF2D1761173E004ABE58 /* graphgen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCB9F1761173B004ABE58 /* graphgen.cpp */; }; + 84ACCF2E1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBA21761173B004ABE58 /* Makefile */; }; + 84ACCF2F1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBA51761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF301761173E004ABE58 /* graphhash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBAA1761173B004ABE58 /* graphhash.cpp */; }; + 84ACCF311761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBAD1761173B004ABE58 /* Makefile */; }; + 84ACCF321761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBB01761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF331761173E004ABE58 /* generate_nets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBB61761173B004ABE58 /* generate_nets.cpp */; }; + 84ACCF341761173E004ABE58 /* infopath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBB81761173B004ABE58 /* infopath.cpp */; }; + 84ACCF351761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBBB1761173B004ABE58 /* Makefile */; }; + 84ACCF361761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBBE1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF371761173E004ABE58 /* kcores.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBC31761173B004ABE58 /* kcores.cpp */; }; + 84ACCF381761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBC61761173B004ABE58 /* Makefile */; }; + 84ACCF391761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBC91761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF3A1761173E004ABE58 /* kronem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBCE1761173B004ABE58 /* kronem.cpp */; }; + 84ACCF3B1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBD11761173B004ABE58 /* Makefile */; }; + 84ACCF3C1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBD41761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF3D1761173E004ABE58 /* kronfit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBD91761173B004ABE58 /* kronfit.cpp */; }; + 84ACCF3E1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBDC1761173B004ABE58 /* Makefile */; }; + 84ACCF3F1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBDF1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF401761173E004ABE58 /* krongen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBE41761173B004ABE58 /* krongen.cpp */; }; + 84ACCF411761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBE71761173B004ABE58 /* Makefile */; }; + 84ACCF421761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBEA1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF431761173E004ABE58 /* magfit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBF01761173B004ABE58 /* magfit.cpp */; }; + 84ACCF441761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBF31761173B004ABE58 /* Makefile */; }; + 84ACCF451761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBF61761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF461761173E004ABE58 /* maggen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBFC1761173B004ABE58 /* maggen.cpp */; }; + 84ACCF471761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCBFF1761173B004ABE58 /* Makefile */; }; + 84ACCF481761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC021761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF491761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC051761173B004ABE58 /* Makefile */; }; + 84ACCF4A1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC081761173B004ABE58 /* Makefile */; }; + 84ACCF4B1761173E004ABE58 /* mkdatasets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC0B1761173B004ABE58 /* mkdatasets.cpp */; }; + 84ACCF4C1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC0F1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF4D1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC131761173B004ABE58 /* Makefile */; }; + 84ACCF4E1761173E004ABE58 /* motifs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC161761173B004ABE58 /* motifs.cpp */; }; + 84ACCF4F1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC1A1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF501761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC1E1761173B004ABE58 /* Makefile */; }; + 84ACCF511761173E004ABE58 /* ncpplot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC211761173B004ABE58 /* ncpplot.cpp */; }; + 84ACCF521761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC251761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF531761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC291761173B004ABE58 /* Makefile */; }; + 84ACCF541761173E004ABE58 /* netevol.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC2C1761173B004ABE58 /* netevol.cpp */; }; + 84ACCF551761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC301761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF561761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC361761173B004ABE58 /* Makefile */; }; + 84ACCF571761173E004ABE58 /* netinf.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC391761173B004ABE58 /* netinf.cpp */; }; + 84ACCF581761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC3F1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF591761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC431761173B004ABE58 /* Makefile */; }; + 84ACCF5A1761173E004ABE58 /* netstat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC461761173B004ABE58 /* netstat.cpp */; }; + 84ACCF5B1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC4A1761173B004ABE58 /* stdafx.cpp */; }; + 84ACCF5C1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC551761173C004ABE58 /* Makefile */; }; + 84ACCF5D1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC581761173C004ABE58 /* stdafx.cpp */; }; + 84ACCF5E1761173E004ABE58 /* testgraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC5C1761173C004ABE58 /* testgraph.cpp */; }; + 84ACCF5F1761173E004ABE58 /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC611761173C004ABE58 /* main.cpp */; }; + 84ACCF601761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC671761173C004ABE58 /* Makefile */; }; + 84ACCF611761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC6A1761173C004ABE58 /* stdafx.cpp */; }; + 84ACCF621761173E004ABE58 /* zydemo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC6D1761173C004ABE58 /* zydemo.cpp */; }; + 84ACCF631761173E004ABE58 /* acquis.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC6F1761173C004ABE58 /* acquis.cpp */; }; + 84ACCF641761173E004ABE58 /* adox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC711761173C004ABE58 /* adox.cpp */; }; + 84ACCF651761173E004ABE58 /* aest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC731761173C004ABE58 /* aest.cpp */; }; + 84ACCF661761173E004ABE58 /* amazon.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC751761173C004ABE58 /* amazon.cpp */; }; + 84ACCF671761173E004ABE58 /* appsrv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC771761173C004ABE58 /* appsrv.cpp */; }; + 84ACCF681761173E004ABE58 /* bde.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC791761173C004ABE58 /* bde.cpp */; }; + 84ACCF691761173E004ABE58 /* biling.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC7B1761173C004ABE58 /* biling.cpp */; }; + 84ACCF6A1761173E004ABE58 /* bix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC7D1761173C004ABE58 /* bix.cpp */; }; + 84ACCF6B1761173E004ABE58 /* book.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC7F1761173C004ABE58 /* book.cpp */; }; + 84ACCF6C1761173E004ABE58 /* bowactlearn.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC811761173C004ABE58 /* bowactlearn.cpp */; }; + 84ACCF6D1761173E004ABE58 /* bowbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC831761173C004ABE58 /* bowbs.cpp */; }; + 84ACCF6E1761173E004ABE58 /* bowclust.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC851761173C004ABE58 /* bowclust.cpp */; }; + 84ACCF6F1761173E004ABE58 /* bowfl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC871761173C004ABE58 /* bowfl.cpp */; }; + 84ACCF701761173E004ABE58 /* bowflx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC891761173C004ABE58 /* bowflx.cpp */; }; + 84ACCF711761173E004ABE58 /* bowlearn.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC8B1761173C004ABE58 /* bowlearn.cpp */; }; + 84ACCF721761173E004ABE58 /* bowlinalg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC8D1761173C004ABE58 /* bowlinalg.cpp */; }; + 84ACCF731761173E004ABE58 /* bowmatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC8F1761173C004ABE58 /* bowmatrix.cpp */; }; + 84ACCF741761173E004ABE58 /* bowmd.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC911761173C004ABE58 /* bowmd.cpp */; }; + 84ACCF751761173E004ABE58 /* btalarms.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC931761173C004ABE58 /* btalarms.cpp */; }; + 84ACCF761761173E004ABE58 /* btaserver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC951761173C004ABE58 /* btaserver.cpp */; }; + 84ACCF771761173E004ABE58 /* casino.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC981761173C004ABE58 /* casino.cpp */; }; + 84ACCF781761173E004ABE58 /* ccar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC9A1761173C004ABE58 /* ccar.cpp */; }; + 84ACCF791761173E004ABE58 /* cfyres.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC9C1761173C004ABE58 /* cfyres.cpp */; }; + 84ACCF7A1761173E004ABE58 /* cgi.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCC9E1761173C004ABE58 /* cgi.cpp */; }; + 84ACCF7B1761173E004ABE58 /* ciawfb.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCA01761173C004ABE58 /* ciawfb.cpp */; }; + 84ACCF7C1761173E004ABE58 /* cordis.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCA31761173C004ABE58 /* cordis.cpp */; }; + 84ACCF7D1761173E004ABE58 /* corrgr.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCA51761173C004ABE58 /* corrgr.cpp */; }; + 84ACCF7E1761173E004ABE58 /* cpdoc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCA71761173C004ABE58 /* cpdoc.cpp */; }; + 84ACCF7F1761173E004ABE58 /* crawler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCA91761173C004ABE58 /* crawler.cpp */; }; + 84ACCF801761173E004ABE58 /* cyc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCAB1761173C004ABE58 /* cyc.cpp */; }; + 84ACCF811761173E004ABE58 /* dm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCAD1761173C004ABE58 /* dm.cpp */; }; + 84ACCF821761173E004ABE58 /* dmhd.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCAF1761173C004ABE58 /* dmhd.cpp */; }; + 84ACCF831761173E004ABE58 /* dmine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCB11761173C004ABE58 /* dmine.cpp */; }; + 84ACCF841761173E004ABE58 /* dmoz.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCB31761173C004ABE58 /* dmoz.cpp */; }; + 84ACCF851761173E004ABE58 /* dnet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCB51761173C004ABE58 /* dnet.cpp */; }; + 84ACCF861761173E004ABE58 /* dzs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCB71761173C004ABE58 /* dzs.cpp */; }; + 84ACCF871761173E004ABE58 /* email.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCB91761173C004ABE58 /* email.cpp */; }; + 84ACCF881761173E004ABE58 /* euproj.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCBB1761173C004ABE58 /* euproj.cpp */; }; + 84ACCF891761173E004ABE58 /* exset.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCBD1761173C004ABE58 /* exset.cpp */; }; + 84ACCF8A1761173E004ABE58 /* fa.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCBF1761173C004ABE58 /* fa.cpp */; }; + 84ACCF8B1761173E004ABE58 /* flx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCC11761173C004ABE58 /* flx.cpp */; }; + 84ACCF8C1761173E004ABE58 /* ftrgen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCC31761173C004ABE58 /* ftrgen.cpp */; }; + 84ACCF8D1761173E004ABE58 /* geoip.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCC51761173C004ABE58 /* geoip.cpp */; }; + 84ACCF8E1761173E004ABE58 /* gix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCC71761173C004ABE58 /* gix.cpp */; }; + 84ACCF8F1761173E004ABE58 /* gks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCC91761173C004ABE58 /* gks.cpp */; }; + 84ACCF901761173E004ABE58 /* gksmfc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCCB1761173C004ABE58 /* gksmfc.cpp */; }; + 84ACCF911761173E004ABE58 /* gksvcl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCCD1761173C004ABE58 /* gksvcl.cpp */; }; + 84ACCF921761173E004ABE58 /* gksvml.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCCF1761173C004ABE58 /* gksvml.cpp */; }; + 84ACCF931761173E004ABE58 /* gkswf.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCD11761173C004ABE58 /* gkswf.cpp */; }; + 84ACCF941761173E004ABE58 /* google.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCD31761173C004ABE58 /* google.cpp */; }; + 84ACCF951761173E004ABE58 /* googlex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCD51761173C004ABE58 /* googlex.cpp */; }; + 84ACCF961761173E004ABE58 /* graph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCD71761173C004ABE58 /* graph.cpp */; }; + 84ACCF971761173E004ABE58 /* gridvcl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCD91761173C004ABE58 /* gridvcl.cpp */; }; + 84ACCF981761173E004ABE58 /* gsearch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCDB1761173C004ABE58 /* gsearch.cpp */; }; + 84ACCF991761173E004ABE58 /* guid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCDD1761173C004ABE58 /* guid.cpp */; }; + 84ACCF9A1761173E004ABE58 /* hc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCDF1761173C004ABE58 /* hc.cpp */; }; + 84ACCF9B1761173E004ABE58 /* hldoc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCE11761173C004ABE58 /* hldoc.cpp */; }; + 84ACCF9C1761173E004ABE58 /* infonet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCE31761173C004ABE58 /* infonet.cpp */; }; + 84ACCF9D1761173E004ABE58 /* kernelmethods.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCE51761173C004ABE58 /* kernelmethods.cpp */; }; + 84ACCF9E1761173E004ABE58 /* logreg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCE71761173C004ABE58 /* logreg.cpp */; }; + 84ACCF9F1761173E004ABE58 /* lsionto.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCE91761173C004ABE58 /* lsionto.cpp */; }; + 84ACCFA01761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCEB1761173C004ABE58 /* Makefile */; }; + 84ACCFA11761173E004ABE58 /* md.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCEC1761173C004ABE58 /* md.cpp */; }; + 84ACCFA21761173E004ABE58 /* mdtr.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCEE1761173C004ABE58 /* mdtr.cpp */; }; + 84ACCFA31761173E004ABE58 /* medline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCF01761173C004ABE58 /* medline.cpp */; }; + 84ACCFA41761173E004ABE58 /* mg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCF21761173C004ABE58 /* mg.cpp */; }; + 84ACCFA51761173E004ABE58 /* mine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCF51761173C004ABE58 /* mine.cpp */; }; + 84ACCFA61761173E004ABE58 /* mkcca.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCF71761173C004ABE58 /* mkcca.cpp */; }; + 84ACCFA71761173E004ABE58 /* mte.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCF91761173C004ABE58 /* mte.cpp */; }; + 84ACCFA81761173E004ABE58 /* mtr.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCFB1761173C004ABE58 /* mtr.cpp */; }; + 84ACCFA91761173E004ABE58 /* net.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCFD1761173C004ABE58 /* net.cpp */; }; + 84ACCFAA1761173E004ABE58 /* netobj.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCCFF1761173C004ABE58 /* netobj.cpp */; }; + 84ACCFAB1761173E004ABE58 /* nlpwinlf.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD011761173C004ABE58 /* nlpwinlf.cpp */; }; + 84ACCFAC1761173E004ABE58 /* nmen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD031761173C004ABE58 /* nmen.cpp */; }; + 84ACCFAD1761173E004ABE58 /* nmobj.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD051761173C004ABE58 /* nmobj.cpp */; }; + 84ACCFAE1761173E004ABE58 /* nntp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD071761173C004ABE58 /* nntp.cpp */; }; + 84ACCFAF1761173E004ABE58 /* nyta.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD091761173C004ABE58 /* nyta.cpp */; }; + 84ACCFB01761173E004ABE58 /* nytngrams.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD0B1761173C004ABE58 /* nytngrams.cpp */; }; + 84ACCFB11761173E004ABE58 /* odbc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD0D1761173C004ABE58 /* odbc.cpp */; }; + 84ACCFB21761173E004ABE58 /* ontolight.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD0F1761173C004ABE58 /* ontolight.cpp */; }; + 84ACCFB31761173E004ABE58 /* pest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD111761173C004ABE58 /* pest.cpp */; }; + 84ACCFB41761173E004ABE58 /* phrase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD131761173C004ABE58 /* phrase.cpp */; }; + 84ACCFB51761173E004ABE58 /* pi.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD151761173C004ABE58 /* pi.cpp */; }; + 84ACCFB61761173E004ABE58 /* postag.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD171761173C004ABE58 /* postag.cpp */; }; + 84ACCFB71761173E004ABE58 /* prolog.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD191761173C004ABE58 /* prolog.cpp */; }; + 84ACCFB81761173E004ABE58 /* prologparser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD1B1761173C004ABE58 /* prologparser.cpp */; }; + 84ACCFB91761173E004ABE58 /* proxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD1D1761173C004ABE58 /* proxy.cpp */; }; + 84ACCFBA1761173E004ABE58 /* pww.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD1F1761173C004ABE58 /* pww.cpp */; }; + 84ACCFBB1761173E004ABE58 /* rdbms.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD201761173C004ABE58 /* rdbms.cpp */; }; + 84ACCFBC1761173E004ABE58 /* roget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD221761173C004ABE58 /* roget.cpp */; }; + 84ACCFBD1761173E004ABE58 /* sappsrv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD241761173C004ABE58 /* sappsrv.cpp */; }; + 84ACCFBE1761173E004ABE58 /* sch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD261761173C004ABE58 /* sch.cpp */; }; + 84ACCFBF1761173E004ABE58 /* semspace.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD281761173C004ABE58 /* semspace.cpp */; }; + 84ACCFC01761173E004ABE58 /* sgraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD2A1761173C004ABE58 /* sgraph.cpp */; }; + 84ACCFC11761173E004ABE58 /* skygrid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD2C1761173C004ABE58 /* skygrid.cpp */; }; + 84ACCFC21761173E004ABE58 /* smtp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD2E1761173C004ABE58 /* smtp.cpp */; }; + 84ACCFC31761173E004ABE58 /* soap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD301761173C004ABE58 /* soap.cpp */; }; + 84ACCFC41761173E004ABE58 /* sock-new.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD321761173C004ABE58 /* sock-new.cpp */; }; + 84ACCFC51761173E004ABE58 /* sock.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD341761173C004ABE58 /* sock.cpp */; }; + 84ACCFC61761173E004ABE58 /* sqlite3.c in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD361761173C004ABE58 /* sqlite3.c */; }; + 84ACCFC71761173E004ABE58 /* sqlitedb.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD381761173C004ABE58 /* sqlitedb.cpp */; }; + 84ACCFC81761173E004ABE58 /* ssch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD3A1761173C004ABE58 /* ssch.cpp */; }; + 84ACCFC91761173E004ABE58 /* sskj.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD3C1761173C004ABE58 /* sskj.cpp */; }; + 84ACCFCA1761173E004ABE58 /* ssql.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD3E1761173C004ABE58 /* ssql.cpp */; }; + 84ACCFCB1761173E004ABE58 /* ssqldm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD401761173C004ABE58 /* ssqldm.cpp */; }; + 84ACCFCC1761173E004ABE58 /* stemming.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD421761173C004ABE58 /* stemming.cpp */; }; + 84ACCFCD1761173E004ABE58 /* stopword.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD441761173C004ABE58 /* stopword.cpp */; }; + 84ACCFCE1761173E004ABE58 /* strkernel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD461761173C004ABE58 /* strkernel.cpp */; }; + 84ACCFCF1761173E004ABE58 /* strut.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD481761173C004ABE58 /* strut.cpp */; }; + 84ACCFD01761173E004ABE58 /* subprocess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD4A1761173C004ABE58 /* subprocess.cpp */; }; + 84ACCFD11761173E004ABE58 /* svmbasic.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD4C1761173C004ABE58 /* svmbasic.cpp */; }; + 84ACCFD21761173E004ABE58 /* svmmodels.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD4E1761173C004ABE58 /* svmmodels.cpp */; }; + 84ACCFD31761173E004ABE58 /* svmPrLoqo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD501761173C004ABE58 /* svmPrLoqo.cpp */; }; + 84ACCFD41761173E004ABE58 /* tagcloud.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD521761173C004ABE58 /* tagcloud.cpp */; }; + 84ACCFD51761173E004ABE58 /* tb.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD541761173C004ABE58 /* tb.cpp */; }; + 84ACCFD61761173E004ABE58 /* tbhc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD561761173C004ABE58 /* tbhc.cpp */; }; + 84ACCFD71761173E004ABE58 /* tbval.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD581761173C004ABE58 /* tbval.cpp */; }; + 84ACCFD81761173E004ABE58 /* term.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD5A1761173C004ABE58 /* term.cpp */; }; + 84ACCFD91761173E004ABE58 /* testBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD5C1761173C004ABE58 /* testBase.cpp */; }; + 84ACCFDA1761173E004ABE58 /* tmine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD5D1761173C004ABE58 /* tmine.cpp */; }; + 84ACCFDB1761173E004ABE58 /* tnt.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD5F1761173C004ABE58 /* tnt.cpp */; }; + 84ACCFDC1761173E004ABE58 /* tql.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD611761173C004ABE58 /* tql.cpp */; }; + 84ACCFDD1761173E004ABE58 /* ts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD631761173C004ABE58 /* ts.cpp */; }; + 84ACCFDE1761173E004ABE58 /* txtbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD651761173C004ABE58 /* txtbs.cpp */; }; + 84ACCFDF1761173E004ABE58 /* ultra.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD671761173C004ABE58 /* ultra.cpp */; }; + 84ACCFE01761173E004ABE58 /* valds.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD691761173C004ABE58 /* valds.cpp */; }; + 84ACCFE11761173E004ABE58 /* valret.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD6B1761173C004ABE58 /* valret.cpp */; }; + 84ACCFE21761173E004ABE58 /* vizmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD6D1761173C004ABE58 /* vizmap.cpp */; }; + 84ACCFE31761173E004ABE58 /* vizmapgks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD6F1761173C004ABE58 /* vizmapgks.cpp */; }; + 84ACCFE41761173E004ABE58 /* wbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD711761173C004ABE58 /* wbmp.cpp */; }; + 84ACCFE51761173E004ABE58 /* webbsfetch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD731761173C004ABE58 /* webbsfetch.cpp */; }; + 84ACCFE61761173E004ABE58 /* webmb.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD751761173C004ABE58 /* webmb.cpp */; }; + 84ACCFE71761173E004ABE58 /* webnetobj.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD771761173C004ABE58 /* webnetobj.cpp */; }; + 84ACCFE81761173E004ABE58 /* webold.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD791761173C004ABE58 /* webold.cpp */; }; + 84ACCFE91761173E004ABE58 /* webpgfetch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD7B1761173C004ABE58 /* webpgfetch.cpp */; }; + 84ACCFEA1761173E004ABE58 /* websrv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD7D1761173C004ABE58 /* websrv.cpp */; }; + 84ACCFEB1761173E004ABE58 /* webtrv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD7F1761173D004ABE58 /* webtrv.cpp */; }; + 84ACCFEC1761173E004ABE58 /* webtxtbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD811761173D004ABE58 /* webtxtbs.cpp */; }; + 84ACCFED1761173E004ABE58 /* wikipedia.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD831761173D004ABE58 /* wikipedia.cpp */; }; + 84ACCFEE1761173E004ABE58 /* wix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD851761173D004ABE58 /* wix.cpp */; }; + 84ACCFEF1761173E004ABE58 /* wixexp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD871761173D004ABE58 /* wixexp.cpp */; }; + 84ACCFF01761173E004ABE58 /* wmine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD891761173D004ABE58 /* wmine.cpp */; }; + 84ACCFF11761173E004ABE58 /* wordco.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD8B1761173D004ABE58 /* wordco.cpp */; }; + 84ACCFF21761173E004ABE58 /* wordnet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD8D1761173D004ABE58 /* wordnet.cpp */; }; + 84ACCFF31761173E004ABE58 /* xql.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD8F1761173D004ABE58 /* xql.cpp */; }; + 84ACCFF41761173E004ABE58 /* yahoobs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD911761173D004ABE58 /* yahoobs.cpp */; }; + 84ACCFF51761173E004ABE58 /* yahoodm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD931761173D004ABE58 /* yahoodm.cpp */; }; + 84ACCFF61761173E004ABE58 /* yahooex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD951761173D004ABE58 /* yahooex.cpp */; }; + 84ACCFF71761173E004ABE58 /* zipcode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD971761173D004ABE58 /* zipcode.cpp */; }; + 84ACCFF81761173E004ABE58 /* app.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD9A1761173D004ABE58 /* app.cpp */; }; + 84ACCFF91761173E004ABE58 /* base.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD9C1761173D004ABE58 /* base.cpp */; }; + 84ACCFFA1761173E004ABE58 /* bd.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCD9E1761173D004ABE58 /* bd.cpp */; }; + 84ACCFFB1761173E004ABE58 /* bits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDA01761173D004ABE58 /* bits.cpp */; }; + 84ACCFFC1761173E004ABE58 /* blobbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDA21761173D004ABE58 /* blobbs.cpp */; }; + 84ACCFFD1761173E004ABE58 /* console.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDA41761173D004ABE58 /* console.cpp */; }; + 84ACCFFE1761173E004ABE58 /* dt.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDAB1761173D004ABE58 /* dt.cpp */; }; + 84ACCFFF1761173E004ABE58 /* env.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDAD1761173D004ABE58 /* env.cpp */; }; + 84ACD0001761173E004ABE58 /* exp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDAF1761173D004ABE58 /* exp.cpp */; }; + 84ACD0011761173E004ABE58 /* fl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDB21761173D004ABE58 /* fl.cpp */; }; + 84ACD0021761173E004ABE58 /* gnuplot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDB41761173D004ABE58 /* gnuplot.cpp */; }; + 84ACD0031761173E004ABE58 /* hash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDB61761173D004ABE58 /* hash.cpp */; }; + 84ACD0041761173E004ABE58 /* html.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDB81761173D004ABE58 /* html.cpp */; }; + 84ACD0051761173E004ABE58 /* http.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDBA1761173D004ABE58 /* http.cpp */; }; + 84ACD0061761173E004ABE58 /* json.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDBC1761173D004ABE58 /* json.cpp */; }; + 84ACD0071761173E004ABE58 /* linalg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDBE1761173D004ABE58 /* linalg.cpp */; }; + 84ACD0081761173E004ABE58 /* lx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDC01761173D004ABE58 /* lx.cpp */; }; + 84ACD0091761173E004ABE58 /* macro.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDC21761173D004ABE58 /* macro.cpp */; }; + 84ACD00A1761173E004ABE58 /* md5.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDC41761173D004ABE58 /* md5.cpp */; }; + 84ACD00B1761173E004ABE58 /* os.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDC61761173D004ABE58 /* os.cpp */; }; + 84ACD00C1761173E004ABE58 /* pp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDC81761173D004ABE58 /* pp.cpp */; }; + 84ACD00D1761173E004ABE58 /* ss.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDCB1761173D004ABE58 /* ss.cpp */; }; + 84ACD00E1761173E004ABE58 /* tm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDCE1761173D004ABE58 /* tm.cpp */; }; + 84ACD00F1761173E004ABE58 /* unicode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDD01761173D004ABE58 /* unicode.cpp */; }; + 84ACD0101761173E004ABE58 /* unicodestring.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDD21761173D004ABE58 /* unicodestring.cpp */; }; + 84ACD0111761173E004ABE58 /* url.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDD41761173D004ABE58 /* url.cpp */; }; + 84ACD0121761173E004ABE58 /* ut.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDD61761173D004ABE58 /* ut.cpp */; }; + 84ACD0131761173E004ABE58 /* wch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDD81761173D004ABE58 /* wch.cpp */; }; + 84ACD0141761173E004ABE58 /* xdt.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDDA1761173D004ABE58 /* xdt.cpp */; }; + 84ACD0151761173E004ABE58 /* xfl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDDC1761173D004ABE58 /* xfl.cpp */; }; + 84ACD0161761173E004ABE58 /* xmath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDDE1761173D004ABE58 /* xmath.cpp */; }; + 84ACD0171761173E004ABE58 /* xml.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDE01761173D004ABE58 /* xml.cpp */; }; + 84ACD0181761173E004ABE58 /* zipfl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDE31761173D004ABE58 /* zipfl.cpp */; }; + 84ACD0191761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDE51761173D004ABE58 /* Makefile */; }; + 84ACD01A1761173E004ABE58 /* agm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDEA1761173D004ABE58 /* agm.cpp */; }; + 84ACD01B1761173E004ABE58 /* agmfast.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDEC1761173D004ABE58 /* agmfast.cpp */; }; + 84ACD01C1761173E004ABE58 /* agmfit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDEE1761173D004ABE58 /* agmfit.cpp */; }; + 84ACD01D1761173E004ABE58 /* cascdynetinf.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDF01761173D004ABE58 /* cascdynetinf.cpp */; }; + 84ACD01E1761173E004ABE58 /* cascnetinf.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDF21761173D004ABE58 /* cascnetinf.cpp */; }; + 84ACD01F1761173E004ABE58 /* cliques.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDF51761173D004ABE58 /* cliques.cpp */; }; + 84ACD0201761173E004ABE58 /* graphcounter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDF91761173D004ABE58 /* graphcounter.cpp */; }; + 84ACD0211761173E004ABE58 /* kronecker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDFB1761173D004ABE58 /* kronecker.cpp */; }; + 84ACD0221761173E004ABE58 /* mag.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDFD1761173D004ABE58 /* mag.cpp */; }; + 84ACD0231761173E004ABE58 /* ncp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCDFF1761173D004ABE58 /* ncp.cpp */; }; + 84ACD0241761173E004ABE58 /* subgraphenum.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE011761173D004ABE58 /* subgraphenum.cpp */; }; + 84ACD0251761173E004ABE58 /* alg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE041761173D004ABE58 /* alg.cpp */; }; + 84ACD0261761173E004ABE58 /* anf.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE061761173D004ABE58 /* anf.cpp */; }; + 84ACD0271761173E004ABE58 /* centr.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE0A1761173D004ABE58 /* centr.cpp */; }; + 84ACD0281761173E004ABE58 /* cmty.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE0C1761173D004ABE58 /* cmty.cpp */; }; + 84ACD0291761173E004ABE58 /* cncom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE0E1761173D004ABE58 /* cncom.cpp */; }; + 84ACD02A1761173E004ABE58 /* ff.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE1D1761173D004ABE58 /* ff.cpp */; }; + 84ACD02B1761173E004ABE58 /* gbase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE1F1761173D004ABE58 /* gbase.cpp */; }; + 84ACD02C1761173E004ABE58 /* ggen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE211761173D004ABE58 /* ggen.cpp */; }; + 84ACD02D1761173E004ABE58 /* ghash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE231761173D004ABE58 /* ghash.cpp */; }; + 84ACD02E1761173E004ABE58 /* gio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE251761173D004ABE58 /* gio.cpp */; }; + 84ACD02F1761173E004ABE58 /* graph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE271761173D004ABE58 /* graph.cpp */; }; + 84ACD0301761173E004ABE58 /* gstat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE2A1761173D004ABE58 /* gstat.cpp */; }; + 84ACD0311761173E004ABE58 /* gsvd.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE2C1761173D004ABE58 /* gsvd.cpp */; }; + 84ACD0321761173E004ABE58 /* gviz.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE2E1761173D004ABE58 /* gviz.cpp */; }; + 84ACD0331761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE311761173D004ABE58 /* Makefile */; }; + 84ACD0341761173E004ABE58 /* network.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE321761173D004ABE58 /* network.cpp */; }; + 84ACD0351761173E004ABE58 /* Snap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE371761173D004ABE58 /* Snap.cpp */; }; + 84ACD0361761173E004ABE58 /* Snap.o in Frameworks */ = {isa = PBXBuildFile; fileRef = 84ACCE391761173D004ABE58 /* Snap.o */; }; + 84ACD0371761173E004ABE58 /* statplot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE3A1761173D004ABE58 /* statplot.cpp */; }; + 84ACD0381761173E004ABE58 /* subgraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE3D1761173D004ABE58 /* subgraph.cpp */; }; + 84ACD0391761173E004ABE58 /* testSnap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE401761173D004ABE58 /* testSnap.cpp */; }; + 84ACD03A1761173E004ABE58 /* timenet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE411761173D004ABE58 /* timenet.cpp */; }; + 84ACD03B1761173E004ABE58 /* util.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE441761173D004ABE58 /* util.cpp */; }; + 84ACD03C1761173E004ABE58 /* arxiv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE471761173D004ABE58 /* arxiv.cpp */; }; + 84ACD03D1761173E004ABE58 /* circles.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE4A1761173D004ABE58 /* circles.cpp */; }; + 84ACD03E1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE4E1761173D004ABE58 /* Makefile */; }; + 84ACD03F1761173E004ABE58 /* stdafx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE501761173D004ABE58 /* stdafx.cpp */; }; + 84ACD0401761173E004ABE58 /* dblp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE531761173D004ABE58 /* dblp.cpp */; }; + 84ACD0411761173E004ABE58 /* imdbnet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE551761173D004ABE58 /* imdbnet.cpp */; }; + 84ACD0421761173E004ABE58 /* linkpred.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE571761173D004ABE58 /* linkpred.cpp */; }; + 84ACD0431761173E004ABE58 /* memenet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE591761173D004ABE58 /* memenet.cpp */; }; + 84ACD0441761173E004ABE58 /* memes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE5B1761173D004ABE58 /* memes.cpp */; }; + 84ACD0451761173E004ABE58 /* mxdag.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE5D1761173D004ABE58 /* mxdag.cpp */; }; + 84ACD0461761173E004ABE58 /* signnet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE5F1761173D004ABE58 /* signnet.cpp */; }; + 84ACD0471761173E004ABE58 /* sir.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE611761173D004ABE58 /* sir.cpp */; }; + 84ACD0481761173E004ABE58 /* spinn3r.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE631761173D004ABE58 /* spinn3r.cpp */; }; + 84ACD0491761173E004ABE58 /* trawling.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE651761173D004ABE58 /* trawling.cpp */; }; + 84ACD04A1761173E004ABE58 /* wgtnet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE671761173D004ABE58 /* wgtnet.cpp */; }; + 84ACD04B1761173E004ABE58 /* wikinet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCE691761173D004ABE58 /* wikinet.cpp */; }; + 84ACD04C1761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEB71761173D004ABE58 /* Makefile */; }; + 84ACD04D1761173E004ABE58 /* run-all-tests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEB81761173D004ABE58 /* run-all-tests.cpp */; }; + 84ACD04E1761173E004ABE58 /* test-alg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEBE1761173D004ABE58 /* test-alg.cpp */; }; + 84ACD04F1761173E004ABE58 /* test-bfsdfs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEBF1761173D004ABE58 /* test-bfsdfs.cpp */; }; + 84ACD0501761173E004ABE58 /* test-cncom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC01761173D004ABE58 /* test-cncom.cpp */; }; + 84ACD0511761173E004ABE58 /* test-file.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC11761173D004ABE58 /* test-file.cpp */; }; + 84ACD0521761173E004ABE58 /* test-ggen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC21761173D004ABE58 /* test-ggen.cpp */; }; + 84ACD0531761173E004ABE58 /* test-gio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC31761173D004ABE58 /* test-gio.cpp */; }; + 84ACD0541761173E004ABE58 /* test-gviz.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC41761173D004ABE58 /* test-gviz.cpp */; }; + 84ACD0551761173E004ABE58 /* test-helper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC51761173D004ABE58 /* test-helper.cpp */; }; + 84ACD0561761173E004ABE58 /* test-subgraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC71761173D004ABE58 /* test-subgraph.cpp */; }; + 84ACD0571761173E004ABE58 /* test-THash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC81761173D004ABE58 /* test-THash.cpp */; }; + 84ACD0581761173E004ABE58 /* test-THashSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEC91761173D004ABE58 /* test-THashSet.cpp */; }; + 84ACD0591761173E004ABE58 /* test-TNEANet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCECA1761173D004ABE58 /* test-TNEANet.cpp */; }; + 84ACD05A1761173E004ABE58 /* test-TNEGraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCECB1761173D004ABE58 /* test-TNEGraph.cpp */; }; + 84ACD05B1761173E004ABE58 /* test-TNGraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCECC1761173D004ABE58 /* test-TNGraph.cpp */; }; + 84ACD05C1761173E004ABE58 /* test-TNodeEDatNet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCECD1761173D004ABE58 /* test-TNodeEDatNet.cpp */; }; + 84ACD05D1761173E004ABE58 /* test-TNodeEdgeNet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCECE1761173D004ABE58 /* test-TNodeEdgeNet.cpp */; }; + 84ACD05E1761173E004ABE58 /* test-TNodeNet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCECF1761173D004ABE58 /* test-TNodeNet.cpp */; }; + 84ACD05F1761173E004ABE58 /* test-triad.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCED01761173D004ABE58 /* test-triad.cpp */; }; + 84ACD0601761173E004ABE58 /* test-TStrPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCED11761173D004ABE58 /* test-TStrPool.cpp */; }; + 84ACD0611761173E004ABE58 /* test-TSysTm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCED21761173E004ABE58 /* test-TSysTm.cpp */; }; + 84ACD0621761173E004ABE58 /* test-TUNGraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCED31761173E004ABE58 /* test-TUNGraph.cpp */; }; + 84ACD0631761173E004ABE58 /* demo-bfsdfs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCED81761173E004ABE58 /* demo-bfsdfs.cpp */; }; + 84ACD0641761173E004ABE58 /* demo-cncom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCED91761173E004ABE58 /* demo-cncom.cpp */; }; + 84ACD0651761173E004ABE58 /* demo-ggen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEDA1761173E004ABE58 /* demo-ggen.cpp */; }; + 84ACD0661761173E004ABE58 /* demo-gio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEDB1761173E004ABE58 /* demo-gio.cpp */; }; + 84ACD0671761173E004ABE58 /* demo-gviz.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEDC1761173E004ABE58 /* demo-gviz.cpp */; }; + 84ACD0681761173E004ABE58 /* demo-hashvec-benchmark.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEDD1761173E004ABE58 /* demo-hashvec-benchmark.cpp */; }; + 84ACD0691761173E004ABE58 /* demo-subgraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEDE1761173E004ABE58 /* demo-subgraph.cpp */; }; + 84ACD06A1761173E004ABE58 /* demo-THash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEDF1761173E004ABE58 /* demo-THash.cpp */; }; + 84ACD06B1761173E004ABE58 /* demo-TNEANet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE01761173E004ABE58 /* demo-TNEANet.cpp */; }; + 84ACD06C1761173E004ABE58 /* demo-TNEGraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE11761173E004ABE58 /* demo-TNEGraph.cpp */; }; + 84ACD06D1761173E004ABE58 /* demo-TNGraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE21761173E004ABE58 /* demo-TNGraph.cpp */; }; + 84ACD06E1761173E004ABE58 /* demo-TNodeEDatNet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE31761173E004ABE58 /* demo-TNodeEDatNet.cpp */; }; + 84ACD06F1761173E004ABE58 /* demo-TNodeEdgeNet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE41761173E004ABE58 /* demo-TNodeEdgeNet.cpp */; }; + 84ACD0701761173E004ABE58 /* demo-TNodeNet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE51761173E004ABE58 /* demo-TNodeNet.cpp */; }; + 84ACD0711761173E004ABE58 /* demo-topology-benchmark.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE61761173E004ABE58 /* demo-topology-benchmark.cpp */; }; + 84ACD0721761173E004ABE58 /* demo-triad.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE71761173E004ABE58 /* demo-triad.cpp */; }; + 84ACD0731761173E004ABE58 /* demo-TUNGraph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCEE81761173E004ABE58 /* demo-TUNGraph.cpp */; }; + 84ACD0741761173E004ABE58 /* Makefile in Sources */ = {isa = PBXBuildFile; fileRef = 84ACCF0A1761173E004ABE58 /* Makefile */; }; + 84FE870C1720A8920099963A /* snap.i in Sources */ = {isa = PBXBuildFile; fileRef = 8474830A16CD86B300AF3EF4 /* snap.i */; }; + 84FF218717555FE400D11D81 /* snap_types.h in Sources */ = {isa = PBXBuildFile; fileRef = 84FF218617555ACD00D11D81 /* snap_types.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 84ACD0781761173E004ABE58 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 84ACCE341761173D004ABE58 /* snap-core.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 848A6F9516D062F800E6F7D3; + remoteInfo = testSnap; + }; + 84ACD07A1761173E004ABE58 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 84ACCE341761173D004ABE58 /* snap-core.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 848A6FA316D068FB00E6F7D3; + remoteInfo = docs; + }; + 84ACD0981761173E004ABE58 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 84ACCC4E1761173B004ABE58 /* snap-examples.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 848A722A16D1A36700E6F7D3; + remoteInfo = docs; + }; + 84ACD09E1761173E004ABE58 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 84ACCEB91761173D004ABE58 /* snap-test.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 849666DC163BC32500A299D8; + remoteInfo = docs; + }; + 84ACD0A11761173E004ABE58 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 84ACCC631761173C004ABE58 /* XcodeTest.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 841E03F216DFE4E200B86980; + remoteInfo = XcodeTest; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 8488FEA916D20F8400C789B8 /* CopyFiles */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = /usr/share/man/man1/; + dstSubfolderSpec = 0; + files = ( + ); + runOnlyForDeploymentPostprocessing = 1; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 8456FCE916E2E28D00ECCD5F /* goodgraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = goodgraph.cpp; sourceTree = ""; }; + 845FBA6417458DE40068CC0C /* pneanet.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = pneanet.i; sourceTree = ""; }; + 847482E016CD863500AF3EF4 /* Makefile */ = {isa = PBXFileReference; explicitFileType = sourcecode.make; fileEncoding = 4; name = Makefile; path = ../Makefile; sourceTree = ""; }; + 847482E516CD863500AF3EF4 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = README.md; path = ../README.md; sourceTree = ""; }; + 8474830816CD86B300AF3EF4 /* Makefile */ = {isa = PBXFileReference; explicitFileType = sourcecode.make; fileEncoding = 4; path = Makefile; sourceTree = ""; }; + 8474830916CD86B300AF3EF4 /* printgraph.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; path = printgraph.h; sourceTree = ""; }; + 8474830A16CD86B300AF3EF4 /* snap.i */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; path = snap.i; sourceTree = ""; }; + 8474831016CD86B300AF3EF4 /* snapswig.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; path = snapswig.h; sourceTree = ""; }; + 848838791755941700F3BBD7 /* snap_types.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = snap_types.i; sourceTree = ""; }; + 8488FEAB16D20F8400C789B8 /* docs */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = docs; sourceTree = BUILT_PRODUCTS_DIR; }; + 849766F416D32A8B00EE1E91 /* getassessment.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = getassessment.cpp; sourceTree = ""; }; + 84ACCB241761173B004ABE58 /* .gitignore */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = .gitignore; sourceTree = ""; }; + 84ACCB251761173B004ABE58 /* CREDITS.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CREDITS.txt; sourceTree = ""; }; + 84ACCB271761173B004ABE58 /* doxyblock.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = doxyblock.py; sourceTree = ""; }; + 84ACCB281761173B004ABE58 /* Doxyfile-dev */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "Doxyfile-dev"; sourceTree = ""; }; + 84ACCB291761173B004ABE58 /* Doxyfile-user */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "Doxyfile-user"; sourceTree = ""; }; + 84ACCB2A1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB2C1761173B004ABE58 /* .gitignore */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = .gitignore; sourceTree = ""; }; + 84ACCB2E1761173B004ABE58 /* agmfit.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = agmfit.vcxproj; sourceTree = ""; }; + 84ACCB2F1761173B004ABE58 /* agmfitmain */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = agmfitmain; sourceTree = ""; }; + 84ACCB301761173B004ABE58 /* agmfitmain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = agmfitmain.cpp; sourceTree = ""; }; + 84ACCB311761173B004ABE58 /* football.edgelist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = football.edgelist; sourceTree = ""; }; + 84ACCB321761173B004ABE58 /* football.labels */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = football.labels; sourceTree = ""; }; + 84ACCB331761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB341761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB351761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB361761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB371761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB381761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB3A1761173B004ABE58 /* agmgen */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = agmgen; sourceTree = ""; }; + 84ACCB3B1761173B004ABE58 /* agmgen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = agmgen.cpp; sourceTree = ""; }; + 84ACCB3C1761173B004ABE58 /* agmgen.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = agmgen.vcproj; sourceTree = ""; }; + 84ACCB3D1761173B004ABE58 /* agmgen.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = agmgen.vcxproj; sourceTree = ""; }; + 84ACCB3E1761173B004ABE58 /* community_affiliations.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = community_affiliations.txt; sourceTree = ""; }; + 84ACCB3F1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB401761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB411761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB421761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB431761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB441761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB451761173B004ABE58 /* as20graph.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = as20graph.txt; sourceTree = ""; }; + 84ACCB471761173B004ABE58 /* bigclam */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = bigclam; sourceTree = ""; }; + 84ACCB481761173B004ABE58 /* bigclam.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bigclam.cpp; sourceTree = ""; }; + 84ACCB491761173B004ABE58 /* bigclam.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = bigclam.vcxproj; sourceTree = ""; }; + 84ACCB4A1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB4B1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB4C1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB4D1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB4E1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB4F1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB511761173B004ABE58 /* cascades */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = cascades; sourceTree = ""; }; + 84ACCB521761173B004ABE58 /* cascades.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cascades.cpp; sourceTree = ""; }; + 84ACCB531761173B004ABE58 /* cascades.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = cascades.vcproj; sourceTree = ""; }; + 84ACCB541761173B004ABE58 /* cascades.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = cascades.vcxproj; sourceTree = ""; }; + 84ACCB551761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB561761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB571761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB581761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB591761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB5A1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB5C1761173B004ABE58 /* centrality */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = centrality; sourceTree = ""; }; + 84ACCB5D1761173B004ABE58 /* centrality.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = centrality.cpp; sourceTree = ""; }; + 84ACCB5E1761173B004ABE58 /* centrality.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = centrality.vcproj; sourceTree = ""; }; + 84ACCB5F1761173B004ABE58 /* centrality.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = centrality.vcxproj; sourceTree = ""; }; + 84ACCB601761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB611761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB621761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB631761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB641761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB651761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB671761173B004ABE58 /* circles */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = circles; sourceTree = ""; }; + 84ACCB681761173B004ABE58 /* circles.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = circles.cpp; sourceTree = ""; }; + 84ACCB691761173B004ABE58 /* fb1.circles */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = fb1.circles; sourceTree = ""; }; + 84ACCB6A1761173B004ABE58 /* fb1.edges */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = fb1.edges; sourceTree = ""; }; + 84ACCB6B1761173B004ABE58 /* fb1.feat */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = fb1.feat; sourceTree = ""; }; + 84ACCB6C1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB6D1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB6E1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB6F1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB701761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB721761173B004ABE58 /* cliques.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = cliques.vcproj; sourceTree = ""; }; + 84ACCB731761173B004ABE58 /* cliques.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = cliques.vcxproj; sourceTree = ""; }; + 84ACCB741761173B004ABE58 /* cliquesmain */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = cliquesmain; sourceTree = ""; }; + 84ACCB751761173B004ABE58 /* cliquesmain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cliquesmain.cpp; sourceTree = ""; }; + 84ACCB761761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB771761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB781761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB791761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB7A1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB7B1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB7D1761173B004ABE58 /* community */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = community; sourceTree = ""; }; + 84ACCB7E1761173B004ABE58 /* community.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = community.cpp; sourceTree = ""; }; + 84ACCB7F1761173B004ABE58 /* community.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = community.vcproj; sourceTree = ""; }; + 84ACCB801761173B004ABE58 /* community.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = community.vcxproj; sourceTree = ""; }; + 84ACCB811761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB821761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB831761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB841761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB851761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB861761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB881761173B004ABE58 /* concomp */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = concomp; sourceTree = ""; }; + 84ACCB891761173B004ABE58 /* concomp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = concomp.cpp; sourceTree = ""; }; + 84ACCB8A1761173B004ABE58 /* concomp.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = concomp.vcproj; sourceTree = ""; }; + 84ACCB8B1761173B004ABE58 /* concomp.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = concomp.vcxproj; sourceTree = ""; }; + 84ACCB8C1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB8D1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB8E1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB8F1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB901761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB911761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB931761173B004ABE58 /* forestfire */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = forestfire; sourceTree = ""; }; + 84ACCB941761173B004ABE58 /* forestfire.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = forestfire.cpp; sourceTree = ""; }; + 84ACCB951761173B004ABE58 /* forestfire.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = forestfire.vcproj; sourceTree = ""; }; + 84ACCB961761173B004ABE58 /* forestfire.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = forestfire.vcxproj; sourceTree = ""; }; + 84ACCB971761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCB981761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCB991761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCB9A1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCB9B1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCB9C1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCB9E1761173B004ABE58 /* graphgen */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = graphgen; sourceTree = ""; }; + 84ACCB9F1761173B004ABE58 /* graphgen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = graphgen.cpp; sourceTree = ""; }; + 84ACCBA01761173B004ABE58 /* graphgen.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = graphgen.vcproj; sourceTree = ""; }; + 84ACCBA11761173B004ABE58 /* graphgen.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = graphgen.vcxproj; sourceTree = ""; }; + 84ACCBA21761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBA31761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBA41761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBA51761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBA61761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBA71761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBA91761173B004ABE58 /* graphhash */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = graphhash; sourceTree = ""; }; + 84ACCBAA1761173B004ABE58 /* graphhash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = graphhash.cpp; sourceTree = ""; }; + 84ACCBAB1761173B004ABE58 /* graphhash.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = graphhash.vcproj; sourceTree = ""; }; + 84ACCBAC1761173B004ABE58 /* graphhash.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = graphhash.vcxproj; sourceTree = ""; }; + 84ACCBAD1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBAE1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBAF1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBB01761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBB11761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBB21761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBB41761173B004ABE58 /* example-cascades.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "example-cascades.txt"; sourceTree = ""; }; + 84ACCBB51761173B004ABE58 /* example-network.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "example-network.txt"; sourceTree = ""; }; + 84ACCBB61761173B004ABE58 /* generate_nets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = generate_nets.cpp; sourceTree = ""; }; + 84ACCBB71761173B004ABE58 /* infopath */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = infopath; sourceTree = ""; }; + 84ACCBB81761173B004ABE58 /* infopath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = infopath.cpp; sourceTree = ""; }; + 84ACCBB91761173B004ABE58 /* infopath.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = infopath.vcproj; sourceTree = ""; }; + 84ACCBBA1761173B004ABE58 /* infopath.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = infopath.vcxproj; sourceTree = ""; }; + 84ACCBBB1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBBC1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBBD1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBBE1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBBF1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBC01761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBC21761173B004ABE58 /* kcores */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = kcores; sourceTree = ""; }; + 84ACCBC31761173B004ABE58 /* kcores.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = kcores.cpp; sourceTree = ""; }; + 84ACCBC41761173B004ABE58 /* kcores.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = kcores.vcproj; sourceTree = ""; }; + 84ACCBC51761173B004ABE58 /* kcores.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = kcores.vcxproj; sourceTree = ""; }; + 84ACCBC61761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBC71761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBC81761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBC91761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBCA1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBCB1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBCD1761173B004ABE58 /* kronem */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = kronem; sourceTree = ""; }; + 84ACCBCE1761173B004ABE58 /* kronem.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = kronem.cpp; sourceTree = ""; }; + 84ACCBCF1761173B004ABE58 /* kronem.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = kronem.vcproj; sourceTree = ""; }; + 84ACCBD01761173B004ABE58 /* kronem.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = kronem.vcxproj; sourceTree = ""; }; + 84ACCBD11761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBD21761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBD31761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBD41761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBD51761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBD61761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBD81761173B004ABE58 /* kronfit */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = kronfit; sourceTree = ""; }; + 84ACCBD91761173B004ABE58 /* kronfit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = kronfit.cpp; sourceTree = ""; }; + 84ACCBDA1761173B004ABE58 /* kronfit.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = kronfit.vcproj; sourceTree = ""; }; + 84ACCBDB1761173B004ABE58 /* kronfit.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = kronfit.vcxproj; sourceTree = ""; }; + 84ACCBDC1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBDD1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBDE1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBDF1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBE01761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBE11761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBE31761173B004ABE58 /* krongen */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = krongen; sourceTree = ""; }; + 84ACCBE41761173B004ABE58 /* krongen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = krongen.cpp; sourceTree = ""; }; + 84ACCBE51761173B004ABE58 /* krongen.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = krongen.vcproj; sourceTree = ""; }; + 84ACCBE61761173B004ABE58 /* krongen.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = krongen.vcxproj; sourceTree = ""; }; + 84ACCBE71761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBE81761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBE91761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBEA1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBEB1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBEC1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBEE1761173B004ABE58 /* init.config */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = init.config; sourceTree = ""; }; + 84ACCBEF1761173B004ABE58 /* magfit */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = magfit; sourceTree = ""; }; + 84ACCBF01761173B004ABE58 /* magfit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = magfit.cpp; sourceTree = ""; }; + 84ACCBF11761173B004ABE58 /* magfit.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = magfit.vcproj; sourceTree = ""; }; + 84ACCBF21761173B004ABE58 /* magfit.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = magfit.vcxproj; sourceTree = ""; }; + 84ACCBF31761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCBF41761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCBF51761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCBF61761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCBF71761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCBF81761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCBFA1761173B004ABE58 /* mag.config */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = mag.config; sourceTree = ""; }; + 84ACCBFB1761173B004ABE58 /* maggen */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = maggen; sourceTree = ""; }; + 84ACCBFC1761173B004ABE58 /* maggen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = maggen.cpp; sourceTree = ""; }; + 84ACCBFD1761173B004ABE58 /* maggen.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = maggen.vcproj; sourceTree = ""; }; + 84ACCBFE1761173B004ABE58 /* maggen.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = maggen.vcxproj; sourceTree = ""; }; + 84ACCBFF1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC001761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC011761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC021761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC031761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC041761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC051761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC061761173B004ABE58 /* Makefile.exmain */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.exmain; sourceTree = ""; }; + 84ACCC081761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC091761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC0A1761173B004ABE58 /* mkdatasets */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = mkdatasets; sourceTree = ""; }; + 84ACCC0B1761173B004ABE58 /* mkdatasets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mkdatasets.cpp; sourceTree = ""; }; + 84ACCC0C1761173B004ABE58 /* mkdatasets.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = mkdatasets.vcproj; sourceTree = ""; }; + 84ACCC0D1761173B004ABE58 /* mkdatasets.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = mkdatasets.vcxproj; sourceTree = ""; }; + 84ACCC0E1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC0F1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC101761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC111761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC131761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC141761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC151761173B004ABE58 /* motifs */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = motifs; sourceTree = ""; }; + 84ACCC161761173B004ABE58 /* motifs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = motifs.cpp; sourceTree = ""; }; + 84ACCC171761173B004ABE58 /* motifs.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = motifs.vcproj; sourceTree = ""; }; + 84ACCC181761173B004ABE58 /* motifs.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = motifs.vcxproj; sourceTree = ""; }; + 84ACCC191761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC1A1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC1B1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC1C1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC1E1761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC1F1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC201761173B004ABE58 /* ncpplot */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = ncpplot; sourceTree = ""; }; + 84ACCC211761173B004ABE58 /* ncpplot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ncpplot.cpp; sourceTree = ""; }; + 84ACCC221761173B004ABE58 /* ncpplot.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = ncpplot.vcproj; sourceTree = ""; }; + 84ACCC231761173B004ABE58 /* ncpplot.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = ncpplot.vcxproj; sourceTree = ""; }; + 84ACCC241761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC251761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC261761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC271761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC291761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC2A1761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC2B1761173B004ABE58 /* netevol */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = netevol; sourceTree = ""; }; + 84ACCC2C1761173B004ABE58 /* netevol.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = netevol.cpp; sourceTree = ""; }; + 84ACCC2D1761173B004ABE58 /* netevol.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = netevol.vcproj; sourceTree = ""; }; + 84ACCC2E1761173B004ABE58 /* netevol.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = netevol.vcxproj; sourceTree = ""; }; + 84ACCC2F1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC301761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC311761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC321761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC341761173B004ABE58 /* example-cascades.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "example-cascades.txt"; sourceTree = ""; }; + 84ACCC351761173B004ABE58 /* example-network.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "example-network.txt"; sourceTree = ""; }; + 84ACCC361761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC371761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC381761173B004ABE58 /* netinf */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = netinf; sourceTree = ""; }; + 84ACCC391761173B004ABE58 /* netinf.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = netinf.cpp; sourceTree = ""; }; + 84ACCC3A1761173B004ABE58 /* netinf.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = netinf.vcproj; sourceTree = ""; }; + 84ACCC3B1761173B004ABE58 /* netinf.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = netinf.vcxproj; sourceTree = ""; }; + 84ACCC3C1761173B004ABE58 /* network-edge.info */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "network-edge.info"; sourceTree = ""; }; + 84ACCC3D1761173B004ABE58 /* network.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = network.txt; sourceTree = ""; }; + 84ACCC3E1761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC3F1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC401761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC411761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC431761173B004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC441761173B004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC451761173B004ABE58 /* netstat */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = netstat; sourceTree = ""; }; + 84ACCC461761173B004ABE58 /* netstat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = netstat.cpp; sourceTree = ""; }; + 84ACCC471761173B004ABE58 /* netstat.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = netstat.vcproj; sourceTree = ""; }; + 84ACCC481761173B004ABE58 /* netstat.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = netstat.vcxproj; sourceTree = ""; }; + 84ACCC491761173B004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC4A1761173B004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC4B1761173B004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC4C1761173B004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC4D1761173B004ABE58 /* README */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = README; sourceTree = ""; }; + 84ACCC4E1761173B004ABE58 /* snap-examples.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = "snap-examples.xcodeproj"; sourceTree = ""; }; + 84ACCC521761173C004ABE58 /* SnapExamples-VS08.sln */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "SnapExamples-VS08.sln"; sourceTree = ""; }; + 84ACCC531761173C004ABE58 /* SnapExamples-VS10.sln */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "SnapExamples-VS10.sln"; sourceTree = ""; }; + 84ACCC551761173C004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC561761173C004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC571761173C004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC581761173C004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC591761173C004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC5A1761173C004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC5B1761173C004ABE58 /* testgraph */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = testgraph; sourceTree = ""; }; + 84ACCC5C1761173C004ABE58 /* testgraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = testgraph.cpp; sourceTree = ""; }; + 84ACCC5D1761173C004ABE58 /* testgraph.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = testgraph.vcproj; sourceTree = ""; }; + 84ACCC5E1761173C004ABE58 /* testgraph.vcxproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = testgraph.vcxproj; sourceTree = ""; }; + 84ACCC611761173C004ABE58 /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = main.cpp; sourceTree = ""; }; + 84ACCC621761173C004ABE58 /* sample.1 */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.man; path = sample.1; sourceTree = ""; }; + 84ACCC631761173C004ABE58 /* XcodeTest.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = XcodeTest.xcodeproj; sourceTree = ""; }; + 84ACCC671761173C004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCC681761173C004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCC691761173C004ABE58 /* ReadMe.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ReadMe.txt; sourceTree = ""; }; + 84ACCC6A1761173C004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCC6B1761173C004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCC6C1761173C004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCC6D1761173C004ABE58 /* zydemo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = zydemo.cpp; sourceTree = ""; }; + 84ACCC6F1761173C004ABE58 /* acquis.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = acquis.cpp; sourceTree = ""; }; + 84ACCC701761173C004ABE58 /* acquis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = acquis.h; sourceTree = ""; }; + 84ACCC711761173C004ABE58 /* adox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = adox.cpp; sourceTree = ""; }; + 84ACCC721761173C004ABE58 /* adox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adox.h; sourceTree = ""; }; + 84ACCC731761173C004ABE58 /* aest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = aest.cpp; sourceTree = ""; }; + 84ACCC741761173C004ABE58 /* aest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aest.h; sourceTree = ""; }; + 84ACCC751761173C004ABE58 /* amazon.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = amazon.cpp; sourceTree = ""; }; + 84ACCC761761173C004ABE58 /* amazon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = amazon.h; sourceTree = ""; }; + 84ACCC771761173C004ABE58 /* appsrv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = appsrv.cpp; sourceTree = ""; }; + 84ACCC781761173C004ABE58 /* appsrv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = appsrv.h; sourceTree = ""; }; + 84ACCC791761173C004ABE58 /* bde.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bde.cpp; sourceTree = ""; }; + 84ACCC7A1761173C004ABE58 /* bde.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bde.h; sourceTree = ""; }; + 84ACCC7B1761173C004ABE58 /* biling.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = biling.cpp; sourceTree = ""; }; + 84ACCC7C1761173C004ABE58 /* biling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = biling.h; sourceTree = ""; }; + 84ACCC7D1761173C004ABE58 /* bix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bix.cpp; sourceTree = ""; }; + 84ACCC7E1761173C004ABE58 /* bix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bix.h; sourceTree = ""; }; + 84ACCC7F1761173C004ABE58 /* book.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = book.cpp; sourceTree = ""; }; + 84ACCC801761173C004ABE58 /* book.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = book.h; sourceTree = ""; }; + 84ACCC811761173C004ABE58 /* bowactlearn.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowactlearn.cpp; sourceTree = ""; }; + 84ACCC821761173C004ABE58 /* bowactlearn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowactlearn.h; sourceTree = ""; }; + 84ACCC831761173C004ABE58 /* bowbs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowbs.cpp; sourceTree = ""; }; + 84ACCC841761173C004ABE58 /* bowbs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowbs.h; sourceTree = ""; }; + 84ACCC851761173C004ABE58 /* bowclust.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowclust.cpp; sourceTree = ""; }; + 84ACCC861761173C004ABE58 /* bowclust.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowclust.h; sourceTree = ""; }; + 84ACCC871761173C004ABE58 /* bowfl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowfl.cpp; sourceTree = ""; }; + 84ACCC881761173C004ABE58 /* bowfl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowfl.h; sourceTree = ""; }; + 84ACCC891761173C004ABE58 /* bowflx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowflx.cpp; sourceTree = ""; }; + 84ACCC8A1761173C004ABE58 /* bowflx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowflx.h; sourceTree = ""; }; + 84ACCC8B1761173C004ABE58 /* bowlearn.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowlearn.cpp; sourceTree = ""; }; + 84ACCC8C1761173C004ABE58 /* bowlearn.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowlearn.h; sourceTree = ""; }; + 84ACCC8D1761173C004ABE58 /* bowlinalg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowlinalg.cpp; sourceTree = ""; }; + 84ACCC8E1761173C004ABE58 /* bowlinalg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowlinalg.h; sourceTree = ""; }; + 84ACCC8F1761173C004ABE58 /* bowmatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowmatrix.cpp; sourceTree = ""; }; + 84ACCC901761173C004ABE58 /* bowmatrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowmatrix.h; sourceTree = ""; }; + 84ACCC911761173C004ABE58 /* bowmd.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bowmd.cpp; sourceTree = ""; }; + 84ACCC921761173C004ABE58 /* bowmd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bowmd.h; sourceTree = ""; }; + 84ACCC931761173C004ABE58 /* btalarms.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = btalarms.cpp; sourceTree = ""; }; + 84ACCC941761173C004ABE58 /* btalarms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = btalarms.h; sourceTree = ""; }; + 84ACCC951761173C004ABE58 /* btaserver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = btaserver.cpp; sourceTree = ""; }; + 84ACCC961761173C004ABE58 /* btaServer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = btaServer.h; sourceTree = ""; }; + 84ACCC971761173C004ABE58 /* cache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cache.h; sourceTree = ""; }; + 84ACCC981761173C004ABE58 /* casino.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = casino.cpp; sourceTree = ""; }; + 84ACCC991761173C004ABE58 /* casino.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = casino.h; sourceTree = ""; }; + 84ACCC9A1761173C004ABE58 /* ccar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ccar.cpp; sourceTree = ""; }; + 84ACCC9B1761173C004ABE58 /* ccar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ccar.h; sourceTree = ""; }; + 84ACCC9C1761173C004ABE58 /* cfyres.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cfyres.cpp; sourceTree = ""; }; + 84ACCC9D1761173C004ABE58 /* cfyres.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cfyres.h; sourceTree = ""; }; + 84ACCC9E1761173C004ABE58 /* cgi.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cgi.cpp; sourceTree = ""; }; + 84ACCC9F1761173C004ABE58 /* cgi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cgi.h; sourceTree = ""; }; + 84ACCCA01761173C004ABE58 /* ciawfb.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ciawfb.cpp; sourceTree = ""; }; + 84ACCCA11761173C004ABE58 /* ciawfb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ciawfb.h; sourceTree = ""; }; + 84ACCCA21761173C004ABE58 /* conjgrad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = conjgrad.h; sourceTree = ""; }; + 84ACCCA31761173C004ABE58 /* cordis.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cordis.cpp; sourceTree = ""; }; + 84ACCCA41761173C004ABE58 /* cordis.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cordis.h; sourceTree = ""; }; + 84ACCCA51761173C004ABE58 /* corrgr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = corrgr.cpp; sourceTree = ""; }; + 84ACCCA61761173C004ABE58 /* corrgr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = corrgr.h; sourceTree = ""; }; + 84ACCCA71761173C004ABE58 /* cpdoc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cpdoc.cpp; sourceTree = ""; }; + 84ACCCA81761173C004ABE58 /* cpdoc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpdoc.h; sourceTree = ""; }; + 84ACCCA91761173C004ABE58 /* crawler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = crawler.cpp; sourceTree = ""; }; + 84ACCCAA1761173C004ABE58 /* crawler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = crawler.h; sourceTree = ""; }; + 84ACCCAB1761173C004ABE58 /* cyc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cyc.cpp; sourceTree = ""; }; + 84ACCCAC1761173C004ABE58 /* cyc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cyc.h; sourceTree = ""; }; + 84ACCCAD1761173C004ABE58 /* dm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dm.cpp; sourceTree = ""; }; + 84ACCCAE1761173C004ABE58 /* dm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dm.h; sourceTree = ""; }; + 84ACCCAF1761173C004ABE58 /* dmhd.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dmhd.cpp; sourceTree = ""; }; + 84ACCCB01761173C004ABE58 /* dmhd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dmhd.h; sourceTree = ""; }; + 84ACCCB11761173C004ABE58 /* dmine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dmine.cpp; sourceTree = ""; }; + 84ACCCB21761173C004ABE58 /* dmine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dmine.h; sourceTree = ""; }; + 84ACCCB31761173C004ABE58 /* dmoz.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dmoz.cpp; sourceTree = ""; }; + 84ACCCB41761173C004ABE58 /* dmoz.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dmoz.h; sourceTree = ""; }; + 84ACCCB51761173C004ABE58 /* dnet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dnet.cpp; sourceTree = ""; }; + 84ACCCB61761173C004ABE58 /* dnet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dnet.h; sourceTree = ""; }; + 84ACCCB71761173C004ABE58 /* dzs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dzs.cpp; sourceTree = ""; }; + 84ACCCB81761173C004ABE58 /* dzs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dzs.h; sourceTree = ""; }; + 84ACCCB91761173C004ABE58 /* email.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = email.cpp; sourceTree = ""; }; + 84ACCCBA1761173C004ABE58 /* email.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = email.h; sourceTree = ""; }; + 84ACCCBB1761173C004ABE58 /* euproj.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = euproj.cpp; sourceTree = ""; }; + 84ACCCBC1761173C004ABE58 /* euproj.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = euproj.h; sourceTree = ""; }; + 84ACCCBD1761173C004ABE58 /* exset.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = exset.cpp; sourceTree = ""; }; + 84ACCCBE1761173C004ABE58 /* exset.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = exset.h; sourceTree = ""; }; + 84ACCCBF1761173C004ABE58 /* fa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = fa.cpp; sourceTree = ""; }; + 84ACCCC01761173C004ABE58 /* fa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fa.h; sourceTree = ""; }; + 84ACCCC11761173C004ABE58 /* flx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = flx.cpp; sourceTree = ""; }; + 84ACCCC21761173C004ABE58 /* flx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = flx.h; sourceTree = ""; }; + 84ACCCC31761173C004ABE58 /* ftrgen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ftrgen.cpp; sourceTree = ""; }; + 84ACCCC41761173C004ABE58 /* ftrgen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ftrgen.h; sourceTree = ""; }; + 84ACCCC51761173C004ABE58 /* geoip.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = geoip.cpp; sourceTree = ""; }; + 84ACCCC61761173C004ABE58 /* geoip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = geoip.h; sourceTree = ""; }; + 84ACCCC71761173C004ABE58 /* gix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gix.cpp; sourceTree = ""; }; + 84ACCCC81761173C004ABE58 /* gix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gix.h; sourceTree = ""; }; + 84ACCCC91761173C004ABE58 /* gks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gks.cpp; sourceTree = ""; }; + 84ACCCCA1761173C004ABE58 /* gks.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gks.h; sourceTree = ""; }; + 84ACCCCB1761173C004ABE58 /* gksmfc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gksmfc.cpp; sourceTree = ""; }; + 84ACCCCC1761173C004ABE58 /* gksmfc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gksmfc.h; sourceTree = ""; }; + 84ACCCCD1761173C004ABE58 /* gksvcl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gksvcl.cpp; sourceTree = ""; }; + 84ACCCCE1761173C004ABE58 /* gksvcl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gksvcl.h; sourceTree = ""; }; + 84ACCCCF1761173C004ABE58 /* gksvml.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gksvml.cpp; sourceTree = ""; }; + 84ACCCD01761173C004ABE58 /* gksvml.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gksvml.h; sourceTree = ""; }; + 84ACCCD11761173C004ABE58 /* gkswf.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gkswf.cpp; sourceTree = ""; }; + 84ACCCD21761173C004ABE58 /* gkswf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gkswf.h; sourceTree = ""; }; + 84ACCCD31761173C004ABE58 /* google.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = google.cpp; sourceTree = ""; }; + 84ACCCD41761173C004ABE58 /* google.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = google.h; sourceTree = ""; }; + 84ACCCD51761173C004ABE58 /* googlex.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = googlex.cpp; sourceTree = ""; }; + 84ACCCD61761173C004ABE58 /* googlex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = googlex.h; sourceTree = ""; }; + 84ACCCD71761173C004ABE58 /* graph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = graph.cpp; sourceTree = ""; }; + 84ACCCD81761173C004ABE58 /* graph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph.h; sourceTree = ""; }; + 84ACCCD91761173C004ABE58 /* gridvcl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gridvcl.cpp; sourceTree = ""; }; + 84ACCCDA1761173C004ABE58 /* gridvcl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gridvcl.h; sourceTree = ""; }; + 84ACCCDB1761173C004ABE58 /* gsearch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gsearch.cpp; sourceTree = ""; }; + 84ACCCDC1761173C004ABE58 /* gsearch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gsearch.h; sourceTree = ""; }; + 84ACCCDD1761173C004ABE58 /* guid.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = guid.cpp; sourceTree = ""; }; + 84ACCCDE1761173C004ABE58 /* guid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = guid.h; sourceTree = ""; }; + 84ACCCDF1761173C004ABE58 /* hc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = hc.cpp; sourceTree = ""; }; + 84ACCCE01761173C004ABE58 /* hc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hc.h; sourceTree = ""; }; + 84ACCCE11761173C004ABE58 /* hldoc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = hldoc.cpp; sourceTree = ""; }; + 84ACCCE21761173C004ABE58 /* hldoc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hldoc.h; sourceTree = ""; }; + 84ACCCE31761173C004ABE58 /* infonet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = infonet.cpp; sourceTree = ""; }; + 84ACCCE41761173C004ABE58 /* infonet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = infonet.h; sourceTree = ""; }; + 84ACCCE51761173C004ABE58 /* kernelmethods.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = kernelmethods.cpp; sourceTree = ""; }; + 84ACCCE61761173C004ABE58 /* kernelmethods.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kernelmethods.h; sourceTree = ""; }; + 84ACCCE71761173C004ABE58 /* logreg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = logreg.cpp; sourceTree = ""; }; + 84ACCCE81761173C004ABE58 /* logreg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = logreg.h; sourceTree = ""; }; + 84ACCCE91761173C004ABE58 /* lsionto.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = lsionto.cpp; sourceTree = ""; }; + 84ACCCEA1761173C004ABE58 /* lsionto.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lsionto.h; sourceTree = ""; }; + 84ACCCEB1761173C004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCCEC1761173C004ABE58 /* md.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = md.cpp; sourceTree = ""; }; + 84ACCCED1761173C004ABE58 /* md.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = md.h; sourceTree = ""; }; + 84ACCCEE1761173C004ABE58 /* mdtr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mdtr.cpp; sourceTree = ""; }; + 84ACCCEF1761173C004ABE58 /* mdtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mdtr.h; sourceTree = ""; }; + 84ACCCF01761173C004ABE58 /* medline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = medline.cpp; sourceTree = ""; }; + 84ACCCF11761173C004ABE58 /* medline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = medline.h; sourceTree = ""; }; + 84ACCCF21761173C004ABE58 /* mg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mg.cpp; sourceTree = ""; }; + 84ACCCF31761173C004ABE58 /* mg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mg.h; sourceTree = ""; }; + 84ACCCF41761173C004ABE58 /* mindset.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mindset.h; sourceTree = ""; }; + 84ACCCF51761173C004ABE58 /* mine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mine.cpp; sourceTree = ""; }; + 84ACCCF61761173C004ABE58 /* mine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mine.h; sourceTree = ""; }; + 84ACCCF71761173C004ABE58 /* mkcca.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mkcca.cpp; sourceTree = ""; }; + 84ACCCF81761173C004ABE58 /* mkcca.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mkcca.h; sourceTree = ""; }; + 84ACCCF91761173C004ABE58 /* mte.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mte.cpp; sourceTree = ""; }; + 84ACCCFA1761173C004ABE58 /* mte.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mte.h; sourceTree = ""; }; + 84ACCCFB1761173C004ABE58 /* mtr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mtr.cpp; sourceTree = ""; }; + 84ACCCFC1761173C004ABE58 /* mtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mtr.h; sourceTree = ""; }; + 84ACCCFD1761173C004ABE58 /* net.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = net.cpp; sourceTree = ""; }; + 84ACCCFE1761173C004ABE58 /* net.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = net.h; sourceTree = ""; }; + 84ACCCFF1761173C004ABE58 /* netobj.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = netobj.cpp; sourceTree = ""; }; + 84ACCD001761173C004ABE58 /* netobj.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = netobj.h; sourceTree = ""; }; + 84ACCD011761173C004ABE58 /* nlpwinlf.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = nlpwinlf.cpp; sourceTree = ""; }; + 84ACCD021761173C004ABE58 /* nlpwinlf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nlpwinlf.h; sourceTree = ""; }; + 84ACCD031761173C004ABE58 /* nmen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = nmen.cpp; sourceTree = ""; }; + 84ACCD041761173C004ABE58 /* nmen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nmen.h; sourceTree = ""; }; + 84ACCD051761173C004ABE58 /* nmobj.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = nmobj.cpp; sourceTree = ""; }; + 84ACCD061761173C004ABE58 /* nmobj.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nmobj.h; sourceTree = ""; }; + 84ACCD071761173C004ABE58 /* nntp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = nntp.cpp; sourceTree = ""; }; + 84ACCD081761173C004ABE58 /* nntp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nntp.h; sourceTree = ""; }; + 84ACCD091761173C004ABE58 /* nyta.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = nyta.cpp; sourceTree = ""; }; + 84ACCD0A1761173C004ABE58 /* nyta.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nyta.h; sourceTree = ""; }; + 84ACCD0B1761173C004ABE58 /* nytngrams.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = nytngrams.cpp; sourceTree = ""; }; + 84ACCD0C1761173C004ABE58 /* nytngrams.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = nytngrams.h; sourceTree = ""; }; + 84ACCD0D1761173C004ABE58 /* odbc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = odbc.cpp; sourceTree = ""; }; + 84ACCD0E1761173C004ABE58 /* odbc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = odbc.h; sourceTree = ""; }; + 84ACCD0F1761173C004ABE58 /* ontolight.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ontolight.cpp; sourceTree = ""; }; + 84ACCD101761173C004ABE58 /* ontolight.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ontolight.h; sourceTree = ""; }; + 84ACCD111761173C004ABE58 /* pest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pest.cpp; sourceTree = ""; }; + 84ACCD121761173C004ABE58 /* pest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pest.h; sourceTree = ""; }; + 84ACCD131761173C004ABE58 /* phrase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = phrase.cpp; sourceTree = ""; }; + 84ACCD141761173C004ABE58 /* phrase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = phrase.h; sourceTree = ""; }; + 84ACCD151761173C004ABE58 /* pi.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pi.cpp; sourceTree = ""; }; + 84ACCD161761173C004ABE58 /* pi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pi.h; sourceTree = ""; }; + 84ACCD171761173C004ABE58 /* postag.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = postag.cpp; sourceTree = ""; }; + 84ACCD181761173C004ABE58 /* postag.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = postag.h; sourceTree = ""; }; + 84ACCD191761173C004ABE58 /* prolog.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = prolog.cpp; sourceTree = ""; }; + 84ACCD1A1761173C004ABE58 /* prolog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prolog.h; sourceTree = ""; }; + 84ACCD1B1761173C004ABE58 /* prologparser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = prologparser.cpp; sourceTree = ""; }; + 84ACCD1C1761173C004ABE58 /* prologparser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = prologparser.h; sourceTree = ""; }; + 84ACCD1D1761173C004ABE58 /* proxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = proxy.cpp; sourceTree = ""; }; + 84ACCD1E1761173C004ABE58 /* proxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = proxy.h; sourceTree = ""; }; + 84ACCD1F1761173C004ABE58 /* pww.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pww.cpp; sourceTree = ""; }; + 84ACCD201761173C004ABE58 /* rdbms.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = rdbms.cpp; sourceTree = ""; }; + 84ACCD211761173C004ABE58 /* rdbms.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = rdbms.h; sourceTree = ""; }; + 84ACCD221761173C004ABE58 /* roget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = roget.cpp; sourceTree = ""; }; + 84ACCD231761173C004ABE58 /* roget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = roget.h; sourceTree = ""; }; + 84ACCD241761173C004ABE58 /* sappsrv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sappsrv.cpp; sourceTree = ""; }; + 84ACCD251761173C004ABE58 /* sappsrv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sappsrv.h; sourceTree = ""; }; + 84ACCD261761173C004ABE58 /* sch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sch.cpp; sourceTree = ""; }; + 84ACCD271761173C004ABE58 /* sch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sch.h; sourceTree = ""; }; + 84ACCD281761173C004ABE58 /* semspace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = semspace.cpp; sourceTree = ""; }; + 84ACCD291761173C004ABE58 /* semspace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = semspace.h; sourceTree = ""; }; + 84ACCD2A1761173C004ABE58 /* sgraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sgraph.cpp; sourceTree = ""; }; + 84ACCD2B1761173C004ABE58 /* sgraph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sgraph.h; sourceTree = ""; }; + 84ACCD2C1761173C004ABE58 /* skygrid.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = skygrid.cpp; sourceTree = ""; }; + 84ACCD2D1761173C004ABE58 /* skygrid.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = skygrid.h; sourceTree = ""; }; + 84ACCD2E1761173C004ABE58 /* smtp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = smtp.cpp; sourceTree = ""; }; + 84ACCD2F1761173C004ABE58 /* smtp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = smtp.h; sourceTree = ""; }; + 84ACCD301761173C004ABE58 /* soap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = soap.cpp; sourceTree = ""; }; + 84ACCD311761173C004ABE58 /* soap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = soap.h; sourceTree = ""; }; + 84ACCD321761173C004ABE58 /* sock-new.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "sock-new.cpp"; sourceTree = ""; }; + 84ACCD331761173C004ABE58 /* sock-new.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "sock-new.h"; sourceTree = ""; }; + 84ACCD341761173C004ABE58 /* sock.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sock.cpp; sourceTree = ""; }; + 84ACCD351761173C004ABE58 /* sock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sock.h; sourceTree = ""; }; + 84ACCD361761173C004ABE58 /* sqlite3.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = sqlite3.c; sourceTree = ""; }; + 84ACCD371761173C004ABE58 /* sqlite3.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sqlite3.h; sourceTree = ""; }; + 84ACCD381761173C004ABE58 /* sqlitedb.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sqlitedb.cpp; sourceTree = ""; }; + 84ACCD391761173C004ABE58 /* sqlitedb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sqlitedb.h; sourceTree = ""; }; + 84ACCD3A1761173C004ABE58 /* ssch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ssch.cpp; sourceTree = ""; }; + 84ACCD3B1761173C004ABE58 /* ssch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ssch.h; sourceTree = ""; }; + 84ACCD3C1761173C004ABE58 /* sskj.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sskj.cpp; sourceTree = ""; }; + 84ACCD3D1761173C004ABE58 /* sskj.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sskj.h; sourceTree = ""; }; + 84ACCD3E1761173C004ABE58 /* ssql.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ssql.cpp; sourceTree = ""; }; + 84ACCD3F1761173C004ABE58 /* ssql.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ssql.h; sourceTree = ""; }; + 84ACCD401761173C004ABE58 /* ssqldm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ssqldm.cpp; sourceTree = ""; }; + 84ACCD411761173C004ABE58 /* ssqldm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ssqldm.h; sourceTree = ""; }; + 84ACCD421761173C004ABE58 /* stemming.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stemming.cpp; sourceTree = ""; }; + 84ACCD431761173C004ABE58 /* stemming.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stemming.h; sourceTree = ""; }; + 84ACCD441761173C004ABE58 /* stopword.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stopword.cpp; sourceTree = ""; }; + 84ACCD451761173C004ABE58 /* stopword.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stopword.h; sourceTree = ""; }; + 84ACCD461761173C004ABE58 /* strkernel.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = strkernel.cpp; sourceTree = ""; }; + 84ACCD471761173C004ABE58 /* strkernel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = strkernel.h; sourceTree = ""; }; + 84ACCD481761173C004ABE58 /* strut.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = strut.cpp; sourceTree = ""; }; + 84ACCD491761173C004ABE58 /* strut.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = strut.h; sourceTree = ""; }; + 84ACCD4A1761173C004ABE58 /* subprocess.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = subprocess.cpp; sourceTree = ""; }; + 84ACCD4B1761173C004ABE58 /* subprocess.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = subprocess.h; sourceTree = ""; }; + 84ACCD4C1761173C004ABE58 /* svmbasic.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = svmbasic.cpp; sourceTree = ""; }; + 84ACCD4D1761173C004ABE58 /* svmbasic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = svmbasic.h; sourceTree = ""; }; + 84ACCD4E1761173C004ABE58 /* svmmodels.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = svmmodels.cpp; sourceTree = ""; }; + 84ACCD4F1761173C004ABE58 /* svmmodels.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = svmmodels.h; sourceTree = ""; }; + 84ACCD501761173C004ABE58 /* svmPrLoqo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = svmPrLoqo.cpp; sourceTree = ""; }; + 84ACCD511761173C004ABE58 /* svmPrLoqo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = svmPrLoqo.h; sourceTree = ""; }; + 84ACCD521761173C004ABE58 /* tagcloud.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tagcloud.cpp; sourceTree = ""; }; + 84ACCD531761173C004ABE58 /* tagcloud.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tagcloud.h; sourceTree = ""; }; + 84ACCD541761173C004ABE58 /* tb.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tb.cpp; sourceTree = ""; }; + 84ACCD551761173C004ABE58 /* tb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tb.h; sourceTree = ""; }; + 84ACCD561761173C004ABE58 /* tbhc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tbhc.cpp; sourceTree = ""; }; + 84ACCD571761173C004ABE58 /* tbhc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tbhc.h; sourceTree = ""; }; + 84ACCD581761173C004ABE58 /* tbval.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tbval.cpp; sourceTree = ""; }; + 84ACCD591761173C004ABE58 /* tbval.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tbval.h; sourceTree = ""; }; + 84ACCD5A1761173C004ABE58 /* term.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = term.cpp; sourceTree = ""; }; + 84ACCD5B1761173C004ABE58 /* term.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = term.h; sourceTree = ""; }; + 84ACCD5C1761173C004ABE58 /* testBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = testBase.cpp; sourceTree = ""; }; + 84ACCD5D1761173C004ABE58 /* tmine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tmine.cpp; sourceTree = ""; }; + 84ACCD5E1761173C004ABE58 /* tmine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tmine.h; sourceTree = ""; }; + 84ACCD5F1761173C004ABE58 /* tnt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tnt.cpp; sourceTree = ""; }; + 84ACCD601761173C004ABE58 /* tnt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tnt.h; sourceTree = ""; }; + 84ACCD611761173C004ABE58 /* tql.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tql.cpp; sourceTree = ""; }; + 84ACCD621761173C004ABE58 /* tql.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tql.h; sourceTree = ""; }; + 84ACCD631761173C004ABE58 /* ts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ts.cpp; sourceTree = ""; }; + 84ACCD641761173C004ABE58 /* ts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ts.h; sourceTree = ""; }; + 84ACCD651761173C004ABE58 /* txtbs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = txtbs.cpp; sourceTree = ""; }; + 84ACCD661761173C004ABE58 /* txtbs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = txtbs.h; sourceTree = ""; }; + 84ACCD671761173C004ABE58 /* ultra.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ultra.cpp; sourceTree = ""; }; + 84ACCD681761173C004ABE58 /* ultra.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ultra.h; sourceTree = ""; }; + 84ACCD691761173C004ABE58 /* valds.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = valds.cpp; sourceTree = ""; }; + 84ACCD6A1761173C004ABE58 /* valds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = valds.h; sourceTree = ""; }; + 84ACCD6B1761173C004ABE58 /* valret.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = valret.cpp; sourceTree = ""; }; + 84ACCD6C1761173C004ABE58 /* valret.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = valret.h; sourceTree = ""; }; + 84ACCD6D1761173C004ABE58 /* vizmap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vizmap.cpp; sourceTree = ""; }; + 84ACCD6E1761173C004ABE58 /* vizmap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vizmap.h; sourceTree = ""; }; + 84ACCD6F1761173C004ABE58 /* vizmapgks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vizmapgks.cpp; sourceTree = ""; }; + 84ACCD701761173C004ABE58 /* vizmapgks.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vizmapgks.h; sourceTree = ""; }; + 84ACCD711761173C004ABE58 /* wbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wbmp.cpp; sourceTree = ""; }; + 84ACCD721761173C004ABE58 /* wbmp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wbmp.h; sourceTree = ""; }; + 84ACCD731761173C004ABE58 /* webbsfetch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webbsfetch.cpp; sourceTree = ""; }; + 84ACCD741761173C004ABE58 /* webbsfetch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = webbsfetch.h; sourceTree = ""; }; + 84ACCD751761173C004ABE58 /* webmb.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webmb.cpp; sourceTree = ""; }; + 84ACCD761761173C004ABE58 /* webmb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = webmb.h; sourceTree = ""; }; + 84ACCD771761173C004ABE58 /* webnetobj.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webnetobj.cpp; sourceTree = ""; }; + 84ACCD781761173C004ABE58 /* webnetobj.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = webnetobj.h; sourceTree = ""; }; + 84ACCD791761173C004ABE58 /* webold.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webold.cpp; sourceTree = ""; }; + 84ACCD7A1761173C004ABE58 /* webold.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = webold.h; sourceTree = ""; }; + 84ACCD7B1761173C004ABE58 /* webpgfetch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webpgfetch.cpp; sourceTree = ""; }; + 84ACCD7C1761173C004ABE58 /* webpgfetch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = webpgfetch.h; sourceTree = ""; }; + 84ACCD7D1761173C004ABE58 /* websrv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = websrv.cpp; sourceTree = ""; }; + 84ACCD7E1761173C004ABE58 /* websrv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = websrv.h; sourceTree = ""; }; + 84ACCD7F1761173D004ABE58 /* webtrv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webtrv.cpp; sourceTree = ""; }; + 84ACCD801761173D004ABE58 /* webtrv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = webtrv.h; sourceTree = ""; }; + 84ACCD811761173D004ABE58 /* webtxtbs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webtxtbs.cpp; sourceTree = ""; }; + 84ACCD821761173D004ABE58 /* webtxtbs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = webtxtbs.h; sourceTree = ""; }; + 84ACCD831761173D004ABE58 /* wikipedia.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wikipedia.cpp; sourceTree = ""; }; + 84ACCD841761173D004ABE58 /* wikipedia.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wikipedia.h; sourceTree = ""; }; + 84ACCD851761173D004ABE58 /* wix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wix.cpp; sourceTree = ""; }; + 84ACCD861761173D004ABE58 /* wix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wix.h; sourceTree = ""; }; + 84ACCD871761173D004ABE58 /* wixexp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wixexp.cpp; sourceTree = ""; }; + 84ACCD881761173D004ABE58 /* wixexp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wixexp.h; sourceTree = ""; }; + 84ACCD891761173D004ABE58 /* wmine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wmine.cpp; sourceTree = ""; }; + 84ACCD8A1761173D004ABE58 /* wmine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wmine.h; sourceTree = ""; }; + 84ACCD8B1761173D004ABE58 /* wordco.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wordco.cpp; sourceTree = ""; }; + 84ACCD8C1761173D004ABE58 /* wordco.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wordco.h; sourceTree = ""; }; + 84ACCD8D1761173D004ABE58 /* wordnet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wordnet.cpp; sourceTree = ""; }; + 84ACCD8E1761173D004ABE58 /* wordnet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wordnet.h; sourceTree = ""; }; + 84ACCD8F1761173D004ABE58 /* xql.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = xql.cpp; sourceTree = ""; }; + 84ACCD901761173D004ABE58 /* xql.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xql.h; sourceTree = ""; }; + 84ACCD911761173D004ABE58 /* yahoobs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = yahoobs.cpp; sourceTree = ""; }; + 84ACCD921761173D004ABE58 /* yahoobs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = yahoobs.h; sourceTree = ""; }; + 84ACCD931761173D004ABE58 /* yahoodm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = yahoodm.cpp; sourceTree = ""; }; + 84ACCD941761173D004ABE58 /* yahoodm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = yahoodm.h; sourceTree = ""; }; + 84ACCD951761173D004ABE58 /* yahooex.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = yahooex.cpp; sourceTree = ""; }; + 84ACCD961761173D004ABE58 /* yahooex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = yahooex.h; sourceTree = ""; }; + 84ACCD971761173D004ABE58 /* zipcode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = zipcode.cpp; sourceTree = ""; }; + 84ACCD981761173D004ABE58 /* zipcode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = zipcode.h; sourceTree = ""; }; + 84ACCD9A1761173D004ABE58 /* app.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = app.cpp; sourceTree = ""; }; + 84ACCD9B1761173D004ABE58 /* app.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = app.h; sourceTree = ""; }; + 84ACCD9C1761173D004ABE58 /* base.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = base.cpp; sourceTree = ""; }; + 84ACCD9D1761173D004ABE58 /* base.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = base.h; sourceTree = ""; }; + 84ACCD9E1761173D004ABE58 /* bd.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bd.cpp; sourceTree = ""; }; + 84ACCD9F1761173D004ABE58 /* bd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bd.h; sourceTree = ""; }; + 84ACCDA01761173D004ABE58 /* bits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bits.cpp; sourceTree = ""; }; + 84ACCDA11761173D004ABE58 /* bits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bits.h; sourceTree = ""; }; + 84ACCDA21761173D004ABE58 /* blobbs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = blobbs.cpp; sourceTree = ""; }; + 84ACCDA31761173D004ABE58 /* blobbs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = blobbs.h; sourceTree = ""; }; + 84ACCDA41761173D004ABE58 /* console.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = console.cpp; sourceTree = ""; }; + 84ACCDA51761173D004ABE58 /* console.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = console.h; sourceTree = ""; }; + 84ACCDA71761173D004ABE58 /* bd.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = bd.h.txt; sourceTree = ""; }; + 84ACCDA81761173D004ABE58 /* ds.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ds.h.txt; sourceTree = ""; }; + 84ACCDA91761173D004ABE58 /* ss.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ss.h.txt; sourceTree = ""; }; + 84ACCDAA1761173D004ABE58 /* ds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ds.h; sourceTree = ""; }; + 84ACCDAB1761173D004ABE58 /* dt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dt.cpp; sourceTree = ""; }; + 84ACCDAC1761173D004ABE58 /* dt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dt.h; sourceTree = ""; }; + 84ACCDAD1761173D004ABE58 /* env.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = env.cpp; sourceTree = ""; }; + 84ACCDAE1761173D004ABE58 /* env.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = env.h; sourceTree = ""; }; + 84ACCDAF1761173D004ABE58 /* exp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = exp.cpp; sourceTree = ""; }; + 84ACCDB01761173D004ABE58 /* exp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = exp.h; sourceTree = ""; }; + 84ACCDB11761173D004ABE58 /* fds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fds.h; sourceTree = ""; }; + 84ACCDB21761173D004ABE58 /* fl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = fl.cpp; sourceTree = ""; }; + 84ACCDB31761173D004ABE58 /* fl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = fl.h; sourceTree = ""; }; + 84ACCDB41761173D004ABE58 /* gnuplot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gnuplot.cpp; sourceTree = ""; }; + 84ACCDB51761173D004ABE58 /* gnuplot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gnuplot.h; sourceTree = ""; }; + 84ACCDB61761173D004ABE58 /* hash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = hash.cpp; sourceTree = ""; }; + 84ACCDB71761173D004ABE58 /* hash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hash.h; sourceTree = ""; }; + 84ACCDB81761173D004ABE58 /* html.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = html.cpp; sourceTree = ""; }; + 84ACCDB91761173D004ABE58 /* html.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = html.h; sourceTree = ""; }; + 84ACCDBA1761173D004ABE58 /* http.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = http.cpp; sourceTree = ""; }; + 84ACCDBB1761173D004ABE58 /* http.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = http.h; sourceTree = ""; }; + 84ACCDBC1761173D004ABE58 /* json.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = json.cpp; sourceTree = ""; }; + 84ACCDBD1761173D004ABE58 /* json.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = json.h; sourceTree = ""; }; + 84ACCDBE1761173D004ABE58 /* linalg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = linalg.cpp; sourceTree = ""; }; + 84ACCDBF1761173D004ABE58 /* linalg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = linalg.h; sourceTree = ""; }; + 84ACCDC01761173D004ABE58 /* lx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = lx.cpp; sourceTree = ""; }; + 84ACCDC11761173D004ABE58 /* lx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lx.h; sourceTree = ""; }; + 84ACCDC21761173D004ABE58 /* macro.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = macro.cpp; sourceTree = ""; }; + 84ACCDC31761173D004ABE58 /* macro.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macro.h; sourceTree = ""; }; + 84ACCDC41761173D004ABE58 /* md5.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = md5.cpp; sourceTree = ""; }; + 84ACCDC51761173D004ABE58 /* md5.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = md5.h; sourceTree = ""; }; + 84ACCDC61761173D004ABE58 /* os.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = os.cpp; sourceTree = ""; }; + 84ACCDC71761173D004ABE58 /* os.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = os.h; sourceTree = ""; }; + 84ACCDC81761173D004ABE58 /* pp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pp.cpp; sourceTree = ""; }; + 84ACCDC91761173D004ABE58 /* pp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pp.h; sourceTree = ""; }; + 84ACCDCA1761173D004ABE58 /* shash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = shash.h; sourceTree = ""; }; + 84ACCDCB1761173D004ABE58 /* ss.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ss.cpp; sourceTree = ""; }; + 84ACCDCC1761173D004ABE58 /* ss.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ss.h; sourceTree = ""; }; + 84ACCDCD1761173D004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCDCE1761173D004ABE58 /* tm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tm.cpp; sourceTree = ""; }; + 84ACCDCF1761173D004ABE58 /* tm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tm.h; sourceTree = ""; }; + 84ACCDD01761173D004ABE58 /* unicode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = unicode.cpp; sourceTree = ""; }; + 84ACCDD11761173D004ABE58 /* unicode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unicode.h; sourceTree = ""; }; + 84ACCDD21761173D004ABE58 /* unicodestring.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = unicodestring.cpp; sourceTree = ""; }; + 84ACCDD31761173D004ABE58 /* unicodestring.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = unicodestring.h; sourceTree = ""; }; + 84ACCDD41761173D004ABE58 /* url.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = url.cpp; sourceTree = ""; }; + 84ACCDD51761173D004ABE58 /* url.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = url.h; sourceTree = ""; }; + 84ACCDD61761173D004ABE58 /* ut.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ut.cpp; sourceTree = ""; }; + 84ACCDD71761173D004ABE58 /* ut.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ut.h; sourceTree = ""; }; + 84ACCDD81761173D004ABE58 /* wch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wch.cpp; sourceTree = ""; }; + 84ACCDD91761173D004ABE58 /* wch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wch.h; sourceTree = ""; }; + 84ACCDDA1761173D004ABE58 /* xdt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = xdt.cpp; sourceTree = ""; }; + 84ACCDDB1761173D004ABE58 /* xdt.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xdt.h; sourceTree = ""; }; + 84ACCDDC1761173D004ABE58 /* xfl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = xfl.cpp; sourceTree = ""; }; + 84ACCDDD1761173D004ABE58 /* xfl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xfl.h; sourceTree = ""; }; + 84ACCDDE1761173D004ABE58 /* xmath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = xmath.cpp; sourceTree = ""; }; + 84ACCDDF1761173D004ABE58 /* xmath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xmath.h; sourceTree = ""; }; + 84ACCDE01761173D004ABE58 /* xml.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = xml.cpp; sourceTree = ""; }; + 84ACCDE11761173D004ABE58 /* xml.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xml.h; sourceTree = ""; }; + 84ACCDE21761173D004ABE58 /* xmlser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xmlser.h; sourceTree = ""; }; + 84ACCDE31761173D004ABE58 /* zipfl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = zipfl.cpp; sourceTree = ""; }; + 84ACCDE41761173D004ABE58 /* zipfl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = zipfl.h; sourceTree = ""; }; + 84ACCDE51761173D004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCDE61761173D004ABE58 /* Makefile.config */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.config; sourceTree = ""; }; + 84ACCDE71761173D004ABE58 /* README.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = README.txt; sourceTree = ""; }; + 84ACCDE81761173D004ABE58 /* RELEASE.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RELEASE.txt; sourceTree = ""; }; + 84ACCDEA1761173D004ABE58 /* agm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = agm.cpp; sourceTree = ""; }; + 84ACCDEB1761173D004ABE58 /* agm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = agm.h; sourceTree = ""; }; + 84ACCDEC1761173D004ABE58 /* agmfast.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = agmfast.cpp; sourceTree = ""; }; + 84ACCDED1761173D004ABE58 /* agmfast.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = agmfast.h; sourceTree = ""; }; + 84ACCDEE1761173D004ABE58 /* agmfit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = agmfit.cpp; sourceTree = ""; }; + 84ACCDEF1761173D004ABE58 /* agmfit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = agmfit.h; sourceTree = ""; }; + 84ACCDF01761173D004ABE58 /* cascdynetinf.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cascdynetinf.cpp; sourceTree = ""; }; + 84ACCDF11761173D004ABE58 /* cascdynetinf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cascdynetinf.h; sourceTree = ""; }; + 84ACCDF21761173D004ABE58 /* cascnetinf.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cascnetinf.cpp; sourceTree = ""; }; + 84ACCDF31761173D004ABE58 /* cascnetinf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cascnetinf.h; sourceTree = ""; }; + 84ACCDF41761173D004ABE58 /* circles.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = circles.h; sourceTree = ""; }; + 84ACCDF51761173D004ABE58 /* cliques.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cliques.cpp; sourceTree = ""; }; + 84ACCDF61761173D004ABE58 /* cliques.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cliques.h; sourceTree = ""; }; + 84ACCDF81761173D004ABE58 /* ncp.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ncp.h.txt; sourceTree = ""; }; + 84ACCDF91761173D004ABE58 /* graphcounter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = graphcounter.cpp; sourceTree = ""; }; + 84ACCDFA1761173D004ABE58 /* graphcounter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graphcounter.h; sourceTree = ""; }; + 84ACCDFB1761173D004ABE58 /* kronecker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = kronecker.cpp; sourceTree = ""; }; + 84ACCDFC1761173D004ABE58 /* kronecker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kronecker.h; sourceTree = ""; }; + 84ACCDFD1761173D004ABE58 /* mag.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mag.cpp; sourceTree = ""; }; + 84ACCDFE1761173D004ABE58 /* mag.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mag.h; sourceTree = ""; }; + 84ACCDFF1761173D004ABE58 /* ncp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ncp.cpp; sourceTree = ""; }; + 84ACCE001761173D004ABE58 /* ncp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ncp.h; sourceTree = ""; }; + 84ACCE011761173D004ABE58 /* subgraphenum.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = subgraphenum.cpp; sourceTree = ""; }; + 84ACCE021761173D004ABE58 /* subgraphenum.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = subgraphenum.h; sourceTree = ""; }; + 84ACCE041761173D004ABE58 /* alg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = alg.cpp; sourceTree = ""; }; + 84ACCE051761173D004ABE58 /* alg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = alg.h; sourceTree = ""; }; + 84ACCE061761173D004ABE58 /* anf.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = anf.cpp; sourceTree = ""; }; + 84ACCE071761173D004ABE58 /* anf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = anf.h; sourceTree = ""; }; + 84ACCE081761173D004ABE58 /* bfsdfs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bfsdfs.h; sourceTree = ""; }; + 84ACCE091761173D004ABE58 /* bignet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bignet.h; sourceTree = ""; }; + 84ACCE0A1761173D004ABE58 /* centr.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = centr.cpp; sourceTree = ""; }; + 84ACCE0B1761173D004ABE58 /* centr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = centr.h; sourceTree = ""; }; + 84ACCE0C1761173D004ABE58 /* cmty.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cmty.cpp; sourceTree = ""; }; + 84ACCE0D1761173D004ABE58 /* cmty.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cmty.h; sourceTree = ""; }; + 84ACCE0E1761173D004ABE58 /* cncom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cncom.cpp; sourceTree = ""; }; + 84ACCE0F1761173D004ABE58 /* cncom.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cncom.h; sourceTree = ""; }; + 84ACCE111761173D004ABE58 /* bfsdfs.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = bfsdfs.h.txt; sourceTree = ""; }; + 84ACCE121761173D004ABE58 /* bignet.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = bignet.h.txt; sourceTree = ""; }; + 84ACCE131761173D004ABE58 /* cncom.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = cncom.h.txt; sourceTree = ""; }; + 84ACCE141761173D004ABE58 /* gbase.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = gbase.h.txt; sourceTree = ""; }; + 84ACCE151761173D004ABE58 /* ghash.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = ghash.h.txt; sourceTree = ""; }; + 84ACCE161761173D004ABE58 /* gio.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = gio.h.txt; sourceTree = ""; }; + 84ACCE171761173D004ABE58 /* graph.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = graph.h.txt; sourceTree = ""; }; + 84ACCE181761173D004ABE58 /* gviz.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = gviz.h.txt; sourceTree = ""; }; + 84ACCE191761173D004ABE58 /* network.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = network.h.txt; sourceTree = ""; }; + 84ACCE1A1761173D004ABE58 /* Snap.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Snap.h.txt; sourceTree = ""; }; + 84ACCE1B1761173D004ABE58 /* subgraph.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = subgraph.h.txt; sourceTree = ""; }; + 84ACCE1C1761173D004ABE58 /* triad.h.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = triad.h.txt; sourceTree = ""; }; + 84ACCE1D1761173D004ABE58 /* ff.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ff.cpp; sourceTree = ""; }; + 84ACCE1E1761173D004ABE58 /* ff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ff.h; sourceTree = ""; }; + 84ACCE1F1761173D004ABE58 /* gbase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gbase.cpp; sourceTree = ""; }; + 84ACCE201761173D004ABE58 /* gbase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gbase.h; sourceTree = ""; }; + 84ACCE211761173D004ABE58 /* ggen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ggen.cpp; sourceTree = ""; }; + 84ACCE221761173D004ABE58 /* ggen.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ggen.h; sourceTree = ""; }; + 84ACCE231761173D004ABE58 /* ghash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ghash.cpp; sourceTree = ""; }; + 84ACCE241761173D004ABE58 /* ghash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ghash.h; sourceTree = ""; }; + 84ACCE251761173D004ABE58 /* gio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gio.cpp; sourceTree = ""; }; + 84ACCE261761173D004ABE58 /* gio.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gio.h; sourceTree = ""; }; + 84ACCE271761173D004ABE58 /* graph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = graph.cpp; sourceTree = ""; }; + 84ACCE281761173D004ABE58 /* graph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = graph.h; sourceTree = ""; }; + 84ACCE291761173D004ABE58 /* graph.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = graph.txt; sourceTree = ""; }; + 84ACCE2A1761173D004ABE58 /* gstat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gstat.cpp; sourceTree = ""; }; + 84ACCE2B1761173D004ABE58 /* gstat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gstat.h; sourceTree = ""; }; + 84ACCE2C1761173D004ABE58 /* gsvd.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gsvd.cpp; sourceTree = ""; }; + 84ACCE2D1761173D004ABE58 /* gsvd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gsvd.h; sourceTree = ""; }; + 84ACCE2E1761173D004ABE58 /* gviz.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gviz.cpp; sourceTree = ""; }; + 84ACCE2F1761173D004ABE58 /* gviz.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gviz.h; sourceTree = ""; }; + 84ACCE301761173D004ABE58 /* kcore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = kcore.h; sourceTree = ""; }; + 84ACCE311761173D004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCE321761173D004ABE58 /* network.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = network.cpp; sourceTree = ""; }; + 84ACCE331761173D004ABE58 /* network.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = network.h; sourceTree = ""; }; + 84ACCE341761173D004ABE58 /* snap-core.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = "snap-core.xcodeproj"; sourceTree = ""; }; + 84ACCE371761173D004ABE58 /* Snap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Snap.cpp; sourceTree = ""; }; + 84ACCE381761173D004ABE58 /* Snap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Snap.h; sourceTree = ""; }; + 84ACCE391761173D004ABE58 /* Snap.o */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.objfile"; path = Snap.o; sourceTree = ""; }; + 84ACCE3A1761173D004ABE58 /* statplot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = statplot.cpp; sourceTree = ""; }; + 84ACCE3B1761173D004ABE58 /* statplot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = statplot.h; sourceTree = ""; }; + 84ACCE3C1761173D004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCE3D1761173D004ABE58 /* subgraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = subgraph.cpp; sourceTree = ""; }; + 84ACCE3E1761173D004ABE58 /* subgraph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = subgraph.h; sourceTree = ""; }; + 84ACCE3F1761173D004ABE58 /* testSnap */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = testSnap; sourceTree = ""; }; + 84ACCE401761173D004ABE58 /* testSnap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = testSnap.cpp; sourceTree = ""; }; + 84ACCE411761173D004ABE58 /* timenet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = timenet.cpp; sourceTree = ""; }; + 84ACCE421761173D004ABE58 /* timenet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = timenet.h; sourceTree = ""; }; + 84ACCE431761173D004ABE58 /* triad.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = triad.h; sourceTree = ""; }; + 84ACCE441761173D004ABE58 /* util.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = util.cpp; sourceTree = ""; }; + 84ACCE451761173D004ABE58 /* util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = util.h; sourceTree = ""; }; + 84ACCE471761173D004ABE58 /* arxiv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = arxiv.cpp; sourceTree = ""; }; + 84ACCE481761173D004ABE58 /* arxiv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = arxiv.h; sourceTree = ""; }; + 84ACCE4A1761173D004ABE58 /* circles.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = circles.cpp; sourceTree = ""; }; + 84ACCE4B1761173D004ABE58 /* circles.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = circles.h; sourceTree = ""; }; + 84ACCE4C1761173D004ABE58 /* fb1.edges */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = fb1.edges; sourceTree = ""; }; + 84ACCE4D1761173D004ABE58 /* fb1.features */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = fb1.features; sourceTree = ""; }; + 84ACCE4E1761173D004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCE4F1761173D004ABE58 /* Makefile.ex */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Makefile.ex; sourceTree = ""; }; + 84ACCE501761173D004ABE58 /* stdafx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stdafx.cpp; sourceTree = ""; }; + 84ACCE511761173D004ABE58 /* stdafx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdafx.h; sourceTree = ""; }; + 84ACCE521761173D004ABE58 /* targetver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = targetver.h; sourceTree = ""; }; + 84ACCE531761173D004ABE58 /* dblp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dblp.cpp; sourceTree = ""; }; + 84ACCE541761173D004ABE58 /* dblp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dblp.h; sourceTree = ""; }; + 84ACCE551761173D004ABE58 /* imdbnet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = imdbnet.cpp; sourceTree = ""; }; + 84ACCE561761173D004ABE58 /* imdbnet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = imdbnet.h; sourceTree = ""; }; + 84ACCE571761173D004ABE58 /* linkpred.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = linkpred.cpp; sourceTree = ""; }; + 84ACCE581761173D004ABE58 /* linkpred.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = linkpred.h; sourceTree = ""; }; + 84ACCE591761173D004ABE58 /* memenet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = memenet.cpp; sourceTree = ""; }; + 84ACCE5A1761173D004ABE58 /* memenet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = memenet.h; sourceTree = ""; }; + 84ACCE5B1761173D004ABE58 /* memes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = memes.cpp; sourceTree = ""; }; + 84ACCE5C1761173D004ABE58 /* memes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = memes.h; sourceTree = ""; }; + 84ACCE5D1761173D004ABE58 /* mxdag.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = mxdag.cpp; sourceTree = ""; }; + 84ACCE5E1761173D004ABE58 /* mxdag.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mxdag.h; sourceTree = ""; }; + 84ACCE5F1761173D004ABE58 /* signnet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = signnet.cpp; sourceTree = ""; }; + 84ACCE601761173D004ABE58 /* signnet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = signnet.h; sourceTree = ""; }; + 84ACCE611761173D004ABE58 /* sir.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sir.cpp; sourceTree = ""; }; + 84ACCE621761173D004ABE58 /* sir.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sir.h; sourceTree = ""; }; + 84ACCE631761173D004ABE58 /* spinn3r.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = spinn3r.cpp; sourceTree = ""; }; + 84ACCE641761173D004ABE58 /* spinn3r.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = spinn3r.h; sourceTree = ""; }; + 84ACCE651761173D004ABE58 /* trawling.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = trawling.cpp; sourceTree = ""; }; + 84ACCE661761173D004ABE58 /* trawling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = trawling.h; sourceTree = ""; }; + 84ACCE671761173D004ABE58 /* wgtnet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wgtnet.cpp; sourceTree = ""; }; + 84ACCE681761173D004ABE58 /* wgtnet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wgtnet.h; sourceTree = ""; }; + 84ACCE691761173D004ABE58 /* wikinet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = wikinet.cpp; sourceTree = ""; }; + 84ACCE6A1761173D004ABE58 /* wikinet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = wikinet.h; sourceTree = ""; }; + 84ACCE6D1761173D004ABE58 /* sample_bfsdfs_ngraph.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_bfsdfs_ngraph.txt; sourceTree = ""; }; + 84ACCE6E1761173D004ABE58 /* sample_bfsdfs_power.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_bfsdfs_power.txt; sourceTree = ""; }; + 84ACCE6F1761173D004ABE58 /* sample_bfsdfs_unpower.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_bfsdfs_unpower.txt; sourceTree = ""; }; + 84ACCE711761173D004ABE58 /* sample_cncom_ngraph.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_cncom_ngraph.txt; sourceTree = ""; }; + 84ACCE721761173D004ABE58 /* sample_cncom_unpower.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_cncom_unpower.txt; sourceTree = ""; }; + 84ACCE741761173D004ABE58 /* base_ngraph_Circo.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Circo.dot; sourceTree = ""; }; + 84ACCE751761173D004ABE58 /* base_ngraph_Circo.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Circo.gif; sourceTree = ""; }; + 84ACCE761761173D004ABE58 /* base_ngraph_Circo.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Circo.png; sourceTree = ""; }; + 84ACCE771761173D004ABE58 /* base_ngraph_Circo.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Circo.ps; sourceTree = ""; }; + 84ACCE781761173D004ABE58 /* base_ngraph_Circo_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Circo_col.dot; sourceTree = ""; }; + 84ACCE791761173D004ABE58 /* base_ngraph_Circo_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Circo_col.gif; sourceTree = ""; }; + 84ACCE7A1761173D004ABE58 /* base_ngraph_Circo_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Circo_col.png; sourceTree = ""; }; + 84ACCE7B1761173D004ABE58 /* base_ngraph_Circo_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Circo_col.ps; sourceTree = ""; }; + 84ACCE7C1761173D004ABE58 /* base_ngraph_Dot.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Dot.dot; sourceTree = ""; }; + 84ACCE7D1761173D004ABE58 /* base_ngraph_Dot.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Dot.gif; sourceTree = ""; }; + 84ACCE7E1761173D004ABE58 /* base_ngraph_Dot.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Dot.png; sourceTree = ""; }; + 84ACCE7F1761173D004ABE58 /* base_ngraph_Dot.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Dot.ps; sourceTree = ""; }; + 84ACCE801761173D004ABE58 /* base_ngraph_Dot_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Dot_col.dot; sourceTree = ""; }; + 84ACCE811761173D004ABE58 /* base_ngraph_Dot_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Dot_col.gif; sourceTree = ""; }; + 84ACCE821761173D004ABE58 /* base_ngraph_Dot_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Dot_col.png; sourceTree = ""; }; + 84ACCE831761173D004ABE58 /* base_ngraph_Dot_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Dot_col.ps; sourceTree = ""; }; + 84ACCE841761173D004ABE58 /* base_ngraph_Neato.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Neato.dot; sourceTree = ""; }; + 84ACCE851761173D004ABE58 /* base_ngraph_Neato.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Neato.gif; sourceTree = ""; }; + 84ACCE861761173D004ABE58 /* base_ngraph_Neato.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Neato.png; sourceTree = ""; }; + 84ACCE871761173D004ABE58 /* base_ngraph_Neato.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Neato.ps; sourceTree = ""; }; + 84ACCE881761173D004ABE58 /* base_ngraph_Neato_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Neato_col.dot; sourceTree = ""; }; + 84ACCE891761173D004ABE58 /* base_ngraph_Neato_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Neato_col.gif; sourceTree = ""; }; + 84ACCE8A1761173D004ABE58 /* base_ngraph_Neato_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Neato_col.png; sourceTree = ""; }; + 84ACCE8B1761173D004ABE58 /* base_ngraph_Neato_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Neato_col.ps; sourceTree = ""; }; + 84ACCE8C1761173D004ABE58 /* base_ngraph_Twopi.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Twopi.dot; sourceTree = ""; }; + 84ACCE8D1761173D004ABE58 /* base_ngraph_Twopi.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Twopi.gif; sourceTree = ""; }; + 84ACCE8E1761173D004ABE58 /* base_ngraph_Twopi.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Twopi.png; sourceTree = ""; }; + 84ACCE8F1761173D004ABE58 /* base_ngraph_Twopi.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Twopi.ps; sourceTree = ""; }; + 84ACCE901761173D004ABE58 /* base_ngraph_Twopi_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Twopi_col.dot; sourceTree = ""; }; + 84ACCE911761173D004ABE58 /* base_ngraph_Twopi_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ngraph_Twopi_col.gif; sourceTree = ""; }; + 84ACCE921761173D004ABE58 /* base_ngraph_Twopi_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ngraph_Twopi_col.png; sourceTree = ""; }; + 84ACCE931761173D004ABE58 /* base_ngraph_Twopi_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ngraph_Twopi_col.ps; sourceTree = ""; }; + 84ACCE941761173D004ABE58 /* base_ungraph_Circo.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Circo.dot; sourceTree = ""; }; + 84ACCE951761173D004ABE58 /* base_ungraph_Circo.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Circo.gif; sourceTree = ""; }; + 84ACCE961761173D004ABE58 /* base_ungraph_Circo.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Circo.png; sourceTree = ""; }; + 84ACCE971761173D004ABE58 /* base_ungraph_Circo.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Circo.ps; sourceTree = ""; }; + 84ACCE981761173D004ABE58 /* base_ungraph_Circo_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Circo_col.dot; sourceTree = ""; }; + 84ACCE991761173D004ABE58 /* base_ungraph_Circo_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Circo_col.gif; sourceTree = ""; }; + 84ACCE9A1761173D004ABE58 /* base_ungraph_Circo_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Circo_col.png; sourceTree = ""; }; + 84ACCE9B1761173D004ABE58 /* base_ungraph_Circo_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Circo_col.ps; sourceTree = ""; }; + 84ACCE9C1761173D004ABE58 /* base_ungraph_Dot.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Dot.dot; sourceTree = ""; }; + 84ACCE9D1761173D004ABE58 /* base_ungraph_Dot.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Dot.gif; sourceTree = ""; }; + 84ACCE9E1761173D004ABE58 /* base_ungraph_Dot.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Dot.png; sourceTree = ""; }; + 84ACCE9F1761173D004ABE58 /* base_ungraph_Dot.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Dot.ps; sourceTree = ""; }; + 84ACCEA01761173D004ABE58 /* base_ungraph_Dot_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Dot_col.dot; sourceTree = ""; }; + 84ACCEA11761173D004ABE58 /* base_ungraph_Dot_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Dot_col.gif; sourceTree = ""; }; + 84ACCEA21761173D004ABE58 /* base_ungraph_Dot_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Dot_col.png; sourceTree = ""; }; + 84ACCEA31761173D004ABE58 /* base_ungraph_Dot_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Dot_col.ps; sourceTree = ""; }; + 84ACCEA41761173D004ABE58 /* base_ungraph_Neato.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Neato.dot; sourceTree = ""; }; + 84ACCEA51761173D004ABE58 /* base_ungraph_Neato.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Neato.gif; sourceTree = ""; }; + 84ACCEA61761173D004ABE58 /* base_ungraph_Neato.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Neato.png; sourceTree = ""; }; + 84ACCEA71761173D004ABE58 /* base_ungraph_Neato.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Neato.ps; sourceTree = ""; }; + 84ACCEA81761173D004ABE58 /* base_ungraph_Neato_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Neato_col.dot; sourceTree = ""; }; + 84ACCEA91761173D004ABE58 /* base_ungraph_Neato_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Neato_col.gif; sourceTree = ""; }; + 84ACCEAA1761173D004ABE58 /* base_ungraph_Neato_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Neato_col.png; sourceTree = ""; }; + 84ACCEAB1761173D004ABE58 /* base_ungraph_Neato_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Neato_col.ps; sourceTree = ""; }; + 84ACCEAC1761173D004ABE58 /* base_ungraph_Twopi.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Twopi.dot; sourceTree = ""; }; + 84ACCEAD1761173D004ABE58 /* base_ungraph_Twopi.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Twopi.gif; sourceTree = ""; }; + 84ACCEAE1761173D004ABE58 /* base_ungraph_Twopi.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Twopi.png; sourceTree = ""; }; + 84ACCEAF1761173D004ABE58 /* base_ungraph_Twopi.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Twopi.ps; sourceTree = ""; }; + 84ACCEB01761173D004ABE58 /* base_ungraph_Twopi_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Twopi_col.dot; sourceTree = ""; }; + 84ACCEB11761173D004ABE58 /* base_ungraph_Twopi_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = base_ungraph_Twopi_col.gif; sourceTree = ""; }; + 84ACCEB21761173D004ABE58 /* base_ungraph_Twopi_col.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = base_ungraph_Twopi_col.png; sourceTree = ""; }; + 84ACCEB31761173D004ABE58 /* base_ungraph_Twopi_col.ps */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = base_ungraph_Twopi_col.ps; sourceTree = ""; }; + 84ACCEB41761173D004ABE58 /* node_colors.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = node_colors.txt; sourceTree = ""; }; + 84ACCEB51761173D004ABE58 /* sample_ngraph1.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_ngraph1.txt; sourceTree = ""; }; + 84ACCEB61761173D004ABE58 /* sample_ungraph1.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_ungraph1.txt; sourceTree = ""; }; + 84ACCEB71761173D004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCEB81761173D004ABE58 /* run-all-tests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "run-all-tests.cpp"; sourceTree = ""; }; + 84ACCEB91761173D004ABE58 /* snap-test.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = "snap-test.xcodeproj"; sourceTree = ""; }; + 84ACCEBE1761173D004ABE58 /* test-alg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-alg.cpp"; sourceTree = ""; }; + 84ACCEBF1761173D004ABE58 /* test-bfsdfs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-bfsdfs.cpp"; sourceTree = ""; }; + 84ACCEC01761173D004ABE58 /* test-cncom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-cncom.cpp"; sourceTree = ""; }; + 84ACCEC11761173D004ABE58 /* test-file.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-file.cpp"; sourceTree = ""; }; + 84ACCEC21761173D004ABE58 /* test-ggen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-ggen.cpp"; sourceTree = ""; }; + 84ACCEC31761173D004ABE58 /* test-gio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-gio.cpp"; sourceTree = ""; }; + 84ACCEC41761173D004ABE58 /* test-gviz.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-gviz.cpp"; sourceTree = ""; }; + 84ACCEC51761173D004ABE58 /* test-helper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-helper.cpp"; sourceTree = ""; }; + 84ACCEC61761173D004ABE58 /* test-helper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "test-helper.h"; sourceTree = ""; }; + 84ACCEC71761173D004ABE58 /* test-subgraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-subgraph.cpp"; sourceTree = ""; }; + 84ACCEC81761173D004ABE58 /* test-THash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-THash.cpp"; sourceTree = ""; }; + 84ACCEC91761173D004ABE58 /* test-THashSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-THashSet.cpp"; sourceTree = ""; }; + 84ACCECA1761173D004ABE58 /* test-TNEANet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TNEANet.cpp"; sourceTree = ""; }; + 84ACCECB1761173D004ABE58 /* test-TNEGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TNEGraph.cpp"; sourceTree = ""; }; + 84ACCECC1761173D004ABE58 /* test-TNGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TNGraph.cpp"; sourceTree = ""; }; + 84ACCECD1761173D004ABE58 /* test-TNodeEDatNet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TNodeEDatNet.cpp"; sourceTree = ""; }; + 84ACCECE1761173D004ABE58 /* test-TNodeEdgeNet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TNodeEdgeNet.cpp"; sourceTree = ""; }; + 84ACCECF1761173D004ABE58 /* test-TNodeNet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TNodeNet.cpp"; sourceTree = ""; }; + 84ACCED01761173D004ABE58 /* test-triad.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-triad.cpp"; sourceTree = ""; }; + 84ACCED11761173D004ABE58 /* test-TStrPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TStrPool.cpp"; sourceTree = ""; }; + 84ACCED21761173E004ABE58 /* test-TSysTm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TSysTm.cpp"; sourceTree = ""; }; + 84ACCED31761173E004ABE58 /* test-TUNGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "test-TUNGraph.cpp"; sourceTree = ""; }; + 84ACCED61761173E004ABE58 /* sample_cncom_ngraph.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_cncom_ngraph.dot; sourceTree = ""; }; + 84ACCED71761173E004ABE58 /* sample_cncom_unpower.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = sample_cncom_unpower.dot; sourceTree = ""; }; + 84ACCED81761173E004ABE58 /* demo-bfsdfs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-bfsdfs.cpp"; sourceTree = ""; }; + 84ACCED91761173E004ABE58 /* demo-cncom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-cncom.cpp"; sourceTree = ""; }; + 84ACCEDA1761173E004ABE58 /* demo-ggen.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-ggen.cpp"; sourceTree = ""; }; + 84ACCEDB1761173E004ABE58 /* demo-gio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-gio.cpp"; sourceTree = ""; }; + 84ACCEDC1761173E004ABE58 /* demo-gviz.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-gviz.cpp"; sourceTree = ""; }; + 84ACCEDD1761173E004ABE58 /* demo-hashvec-benchmark.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-hashvec-benchmark.cpp"; sourceTree = ""; }; + 84ACCEDE1761173E004ABE58 /* demo-subgraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-subgraph.cpp"; sourceTree = ""; }; + 84ACCEDF1761173E004ABE58 /* demo-THash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-THash.cpp"; sourceTree = ""; }; + 84ACCEE01761173E004ABE58 /* demo-TNEANet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-TNEANet.cpp"; sourceTree = ""; }; + 84ACCEE11761173E004ABE58 /* demo-TNEGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-TNEGraph.cpp"; sourceTree = ""; }; + 84ACCEE21761173E004ABE58 /* demo-TNGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-TNGraph.cpp"; sourceTree = ""; }; + 84ACCEE31761173E004ABE58 /* demo-TNodeEDatNet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-TNodeEDatNet.cpp"; sourceTree = ""; }; + 84ACCEE41761173E004ABE58 /* demo-TNodeEdgeNet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-TNodeEdgeNet.cpp"; sourceTree = ""; }; + 84ACCEE51761173E004ABE58 /* demo-TNodeNet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-TNodeNet.cpp"; sourceTree = ""; }; + 84ACCEE61761173E004ABE58 /* demo-topology-benchmark.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-topology-benchmark.cpp"; sourceTree = ""; }; + 84ACCEE71761173E004ABE58 /* demo-triad.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-triad.cpp"; sourceTree = ""; }; + 84ACCEE81761173E004ABE58 /* demo-TUNGraph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "demo-TUNGraph.cpp"; sourceTree = ""; }; + 84ACCEEA1761173E004ABE58 /* demo_ngraph_Circo.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Circo.dot; sourceTree = ""; }; + 84ACCEEB1761173E004ABE58 /* demo_ngraph_Circo.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Circo.gif; sourceTree = ""; }; + 84ACCEEC1761173E004ABE58 /* demo_ngraph_Circo_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Circo_col.dot; sourceTree = ""; }; + 84ACCEED1761173E004ABE58 /* demo_ngraph_Circo_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Circo_col.gif; sourceTree = ""; }; + 84ACCEEE1761173E004ABE58 /* demo_ngraph_Dot.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Dot.dot; sourceTree = ""; }; + 84ACCEEF1761173E004ABE58 /* demo_ngraph_Dot.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Dot.gif; sourceTree = ""; }; + 84ACCEF01761173E004ABE58 /* demo_ngraph_Dot_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Dot_col.dot; sourceTree = ""; }; + 84ACCEF11761173E004ABE58 /* demo_ngraph_Dot_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Dot_col.gif; sourceTree = ""; }; + 84ACCEF21761173E004ABE58 /* demo_ngraph_Neato.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Neato.dot; sourceTree = ""; }; + 84ACCEF31761173E004ABE58 /* demo_ngraph_Neato.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Neato.gif; sourceTree = ""; }; + 84ACCEF41761173E004ABE58 /* demo_ngraph_Neato_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Neato_col.dot; sourceTree = ""; }; + 84ACCEF51761173E004ABE58 /* demo_ngraph_Neato_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Neato_col.gif; sourceTree = ""; }; + 84ACCEF61761173E004ABE58 /* demo_ngraph_Twopi.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Twopi.dot; sourceTree = ""; }; + 84ACCEF71761173E004ABE58 /* demo_ngraph_Twopi.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Twopi.gif; sourceTree = ""; }; + 84ACCEF81761173E004ABE58 /* demo_ngraph_Twopi_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ngraph_Twopi_col.dot; sourceTree = ""; }; + 84ACCEF91761173E004ABE58 /* demo_ngraph_Twopi_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ngraph_Twopi_col.gif; sourceTree = ""; }; + 84ACCEFA1761173E004ABE58 /* demo_ungraph_Circo.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Circo.dot; sourceTree = ""; }; + 84ACCEFB1761173E004ABE58 /* demo_ungraph_Circo.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Circo.gif; sourceTree = ""; }; + 84ACCEFC1761173E004ABE58 /* demo_ungraph_Circo_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Circo_col.dot; sourceTree = ""; }; + 84ACCEFD1761173E004ABE58 /* demo_ungraph_Circo_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Circo_col.gif; sourceTree = ""; }; + 84ACCEFE1761173E004ABE58 /* demo_ungraph_Dot.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Dot.dot; sourceTree = ""; }; + 84ACCEFF1761173E004ABE58 /* demo_ungraph_Dot.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Dot.gif; sourceTree = ""; }; + 84ACCF001761173E004ABE58 /* demo_ungraph_Dot_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Dot_col.dot; sourceTree = ""; }; + 84ACCF011761173E004ABE58 /* demo_ungraph_Dot_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Dot_col.gif; sourceTree = ""; }; + 84ACCF021761173E004ABE58 /* demo_ungraph_Neato.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Neato.dot; sourceTree = ""; }; + 84ACCF031761173E004ABE58 /* demo_ungraph_Neato.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Neato.gif; sourceTree = ""; }; + 84ACCF041761173E004ABE58 /* demo_ungraph_Neato_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Neato_col.dot; sourceTree = ""; }; + 84ACCF051761173E004ABE58 /* demo_ungraph_Neato_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Neato_col.gif; sourceTree = ""; }; + 84ACCF061761173E004ABE58 /* demo_ungraph_Twopi.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Twopi.dot; sourceTree = ""; }; + 84ACCF071761173E004ABE58 /* demo_ungraph_Twopi.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Twopi.gif; sourceTree = ""; }; + 84ACCF081761173E004ABE58 /* demo_ungraph_Twopi_col.dot */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = demo_ungraph_Twopi_col.dot; sourceTree = ""; }; + 84ACCF091761173E004ABE58 /* demo_ungraph_Twopi_col.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = demo_ungraph_Twopi_col.gif; sourceTree = ""; }; + 84ACCF0A1761173E004ABE58 /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = ""; }; + 84ACCF0B1761173E004ABE58 /* tutorials.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = tutorials.xcodeproj; sourceTree = ""; }; + 84FF218617555ACD00D11D81 /* snap_types.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.cpp; fileEncoding = 4; path = snap_types.h; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 8488FEA816D20F8400C789B8 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 84ACD0361761173E004ABE58 /* Snap.o in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 847482A916CD85D200AF3EF4 = { + isa = PBXGroup; + children = ( + 847482E516CD863500AF3EF4 /* README.md */, + 847482E016CD863500AF3EF4 /* Makefile */, + 8474830616CD86B300AF3EF4 /* swig */, + 84ACCB231761173B004ABE58 /* snap */, + 8488FEAC16D20F8400C789B8 /* Products */, + ); + sourceTree = ""; + }; + 8474830616CD86B300AF3EF4 /* swig */ = { + isa = PBXGroup; + children = ( + 8474830816CD86B300AF3EF4 /* Makefile */, + 8474830A16CD86B300AF3EF4 /* snap.i */, + 84FF218617555ACD00D11D81 /* snap_types.h */, + 848838791755941700F3BBD7 /* snap_types.i */, + 8474831016CD86B300AF3EF4 /* snapswig.h */, + 845FBA6417458DE40068CC0C /* pneanet.i */, + 8474830916CD86B300AF3EF4 /* printgraph.h */, + 849766F416D32A8B00EE1E91 /* getassessment.cpp */, + 8456FCE916E2E28D00ECCD5F /* goodgraph.cpp */, + ); + name = swig; + path = ../swig; + sourceTree = ""; + }; + 8488FEAC16D20F8400C789B8 /* Products */ = { + isa = PBXGroup; + children = ( + 8488FEAB16D20F8400C789B8 /* docs */, + ); + name = Products; + sourceTree = ""; + }; + 84ACCB231761173B004ABE58 /* snap */ = { + isa = PBXGroup; + children = ( + 84ACCB241761173B004ABE58 /* .gitignore */, + 84ACCB251761173B004ABE58 /* CREDITS.txt */, + 84ACCB261761173B004ABE58 /* doxygen */, + 84ACCB2B1761173B004ABE58 /* examples */, + 84ACCC6E1761173C004ABE58 /* glib-adv */, + 84ACCD991761173D004ABE58 /* glib-core */, + 84ACCDE51761173D004ABE58 /* Makefile */, + 84ACCDE61761173D004ABE58 /* Makefile.config */, + 84ACCDE71761173D004ABE58 /* README.txt */, + 84ACCDE81761173D004ABE58 /* RELEASE.txt */, + 84ACCDE91761173D004ABE58 /* snap-adv */, + 84ACCE031761173D004ABE58 /* snap-core */, + 84ACCE461761173D004ABE58 /* snap-exp */, + 84ACCE6B1761173D004ABE58 /* test */, + 84ACCED41761173E004ABE58 /* tutorials */, + ); + name = snap; + path = ../../snap; + sourceTree = ""; + }; + 84ACCB261761173B004ABE58 /* doxygen */ = { + isa = PBXGroup; + children = ( + 84ACCB271761173B004ABE58 /* doxyblock.py */, + 84ACCB281761173B004ABE58 /* Doxyfile-dev */, + 84ACCB291761173B004ABE58 /* Doxyfile-user */, + 84ACCB2A1761173B004ABE58 /* Makefile */, + ); + path = doxygen; + sourceTree = ""; + }; + 84ACCB2B1761173B004ABE58 /* examples */ = { + isa = PBXGroup; + children = ( + 84ACCB2C1761173B004ABE58 /* .gitignore */, + 84ACCB2D1761173B004ABE58 /* agmfit */, + 84ACCB391761173B004ABE58 /* agmgen */, + 84ACCB451761173B004ABE58 /* as20graph.txt */, + 84ACCB461761173B004ABE58 /* bigclam */, + 84ACCB501761173B004ABE58 /* cascades */, + 84ACCB5B1761173B004ABE58 /* centrality */, + 84ACCB661761173B004ABE58 /* circles */, + 84ACCB711761173B004ABE58 /* cliques */, + 84ACCB7C1761173B004ABE58 /* community */, + 84ACCB871761173B004ABE58 /* concomp */, + 84ACCB921761173B004ABE58 /* forestfire */, + 84ACCB9D1761173B004ABE58 /* graphgen */, + 84ACCBA81761173B004ABE58 /* graphhash */, + 84ACCBB31761173B004ABE58 /* infopath */, + 84ACCBC11761173B004ABE58 /* kcores */, + 84ACCBCC1761173B004ABE58 /* kronem */, + 84ACCBD71761173B004ABE58 /* kronfit */, + 84ACCBE21761173B004ABE58 /* krongen */, + 84ACCBED1761173B004ABE58 /* magfit */, + 84ACCBF91761173B004ABE58 /* maggen */, + 84ACCC051761173B004ABE58 /* Makefile */, + 84ACCC061761173B004ABE58 /* Makefile.exmain */, + 84ACCC071761173B004ABE58 /* mkdatasets */, + 84ACCC121761173B004ABE58 /* motifs */, + 84ACCC1D1761173B004ABE58 /* ncpplot */, + 84ACCC281761173B004ABE58 /* netevol */, + 84ACCC331761173B004ABE58 /* netinf */, + 84ACCC421761173B004ABE58 /* netstat */, + 84ACCC4D1761173B004ABE58 /* README */, + 84ACCC4E1761173B004ABE58 /* snap-examples.xcodeproj */, + 84ACCC521761173C004ABE58 /* SnapExamples-VS08.sln */, + 84ACCC531761173C004ABE58 /* SnapExamples-VS10.sln */, + 84ACCC541761173C004ABE58 /* testgraph */, + 84ACCC5F1761173C004ABE58 /* XcodeTest */, + 84ACCC661761173C004ABE58 /* zygote */, + ); + path = examples; + sourceTree = ""; + }; + 84ACCB2D1761173B004ABE58 /* agmfit */ = { + isa = PBXGroup; + children = ( + 84ACCB2E1761173B004ABE58 /* agmfit.vcxproj */, + 84ACCB2F1761173B004ABE58 /* agmfitmain */, + 84ACCB301761173B004ABE58 /* agmfitmain.cpp */, + 84ACCB311761173B004ABE58 /* football.edgelist */, + 84ACCB321761173B004ABE58 /* football.labels */, + 84ACCB331761173B004ABE58 /* Makefile */, + 84ACCB341761173B004ABE58 /* Makefile.ex */, + 84ACCB351761173B004ABE58 /* ReadMe.txt */, + 84ACCB361761173B004ABE58 /* stdafx.cpp */, + 84ACCB371761173B004ABE58 /* stdafx.h */, + 84ACCB381761173B004ABE58 /* targetver.h */, + ); + path = agmfit; + sourceTree = ""; + }; + 84ACCB391761173B004ABE58 /* agmgen */ = { + isa = PBXGroup; + children = ( + 84ACCB3A1761173B004ABE58 /* agmgen */, + 84ACCB3B1761173B004ABE58 /* agmgen.cpp */, + 84ACCB3C1761173B004ABE58 /* agmgen.vcproj */, + 84ACCB3D1761173B004ABE58 /* agmgen.vcxproj */, + 84ACCB3E1761173B004ABE58 /* community_affiliations.txt */, + 84ACCB3F1761173B004ABE58 /* Makefile */, + 84ACCB401761173B004ABE58 /* Makefile.ex */, + 84ACCB411761173B004ABE58 /* ReadMe.txt */, + 84ACCB421761173B004ABE58 /* stdafx.cpp */, + 84ACCB431761173B004ABE58 /* stdafx.h */, + 84ACCB441761173B004ABE58 /* targetver.h */, + ); + path = agmgen; + sourceTree = ""; + }; + 84ACCB461761173B004ABE58 /* bigclam */ = { + isa = PBXGroup; + children = ( + 84ACCB471761173B004ABE58 /* bigclam */, + 84ACCB481761173B004ABE58 /* bigclam.cpp */, + 84ACCB491761173B004ABE58 /* bigclam.vcxproj */, + 84ACCB4A1761173B004ABE58 /* Makefile */, + 84ACCB4B1761173B004ABE58 /* Makefile.ex */, + 84ACCB4C1761173B004ABE58 /* ReadMe.txt */, + 84ACCB4D1761173B004ABE58 /* stdafx.cpp */, + 84ACCB4E1761173B004ABE58 /* stdafx.h */, + 84ACCB4F1761173B004ABE58 /* targetver.h */, + ); + path = bigclam; + sourceTree = ""; + }; + 84ACCB501761173B004ABE58 /* cascades */ = { + isa = PBXGroup; + children = ( + 84ACCB511761173B004ABE58 /* cascades */, + 84ACCB521761173B004ABE58 /* cascades.cpp */, + 84ACCB531761173B004ABE58 /* cascades.vcproj */, + 84ACCB541761173B004ABE58 /* cascades.vcxproj */, + 84ACCB551761173B004ABE58 /* Makefile */, + 84ACCB561761173B004ABE58 /* Makefile.ex */, + 84ACCB571761173B004ABE58 /* ReadMe.txt */, + 84ACCB581761173B004ABE58 /* stdafx.cpp */, + 84ACCB591761173B004ABE58 /* stdafx.h */, + 84ACCB5A1761173B004ABE58 /* targetver.h */, + ); + path = cascades; + sourceTree = ""; + }; + 84ACCB5B1761173B004ABE58 /* centrality */ = { + isa = PBXGroup; + children = ( + 84ACCB5C1761173B004ABE58 /* centrality */, + 84ACCB5D1761173B004ABE58 /* centrality.cpp */, + 84ACCB5E1761173B004ABE58 /* centrality.vcproj */, + 84ACCB5F1761173B004ABE58 /* centrality.vcxproj */, + 84ACCB601761173B004ABE58 /* Makefile */, + 84ACCB611761173B004ABE58 /* Makefile.ex */, + 84ACCB621761173B004ABE58 /* ReadMe.txt */, + 84ACCB631761173B004ABE58 /* stdafx.cpp */, + 84ACCB641761173B004ABE58 /* stdafx.h */, + 84ACCB651761173B004ABE58 /* targetver.h */, + ); + path = centrality; + sourceTree = ""; + }; + 84ACCB661761173B004ABE58 /* circles */ = { + isa = PBXGroup; + children = ( + 84ACCB671761173B004ABE58 /* circles */, + 84ACCB681761173B004ABE58 /* circles.cpp */, + 84ACCB691761173B004ABE58 /* fb1.circles */, + 84ACCB6A1761173B004ABE58 /* fb1.edges */, + 84ACCB6B1761173B004ABE58 /* fb1.feat */, + 84ACCB6C1761173B004ABE58 /* Makefile */, + 84ACCB6D1761173B004ABE58 /* Makefile.ex */, + 84ACCB6E1761173B004ABE58 /* stdafx.cpp */, + 84ACCB6F1761173B004ABE58 /* stdafx.h */, + 84ACCB701761173B004ABE58 /* targetver.h */, + ); + path = circles; + sourceTree = ""; + }; + 84ACCB711761173B004ABE58 /* cliques */ = { + isa = PBXGroup; + children = ( + 84ACCB721761173B004ABE58 /* cliques.vcproj */, + 84ACCB731761173B004ABE58 /* cliques.vcxproj */, + 84ACCB741761173B004ABE58 /* cliquesmain */, + 84ACCB751761173B004ABE58 /* cliquesmain.cpp */, + 84ACCB761761173B004ABE58 /* Makefile */, + 84ACCB771761173B004ABE58 /* Makefile.ex */, + 84ACCB781761173B004ABE58 /* ReadMe.txt */, + 84ACCB791761173B004ABE58 /* stdafx.cpp */, + 84ACCB7A1761173B004ABE58 /* stdafx.h */, + 84ACCB7B1761173B004ABE58 /* targetver.h */, + ); + path = cliques; + sourceTree = ""; + }; + 84ACCB7C1761173B004ABE58 /* community */ = { + isa = PBXGroup; + children = ( + 84ACCB7D1761173B004ABE58 /* community */, + 84ACCB7E1761173B004ABE58 /* community.cpp */, + 84ACCB7F1761173B004ABE58 /* community.vcproj */, + 84ACCB801761173B004ABE58 /* community.vcxproj */, + 84ACCB811761173B004ABE58 /* Makefile */, + 84ACCB821761173B004ABE58 /* Makefile.ex */, + 84ACCB831761173B004ABE58 /* ReadMe.txt */, + 84ACCB841761173B004ABE58 /* stdafx.cpp */, + 84ACCB851761173B004ABE58 /* stdafx.h */, + 84ACCB861761173B004ABE58 /* targetver.h */, + ); + path = community; + sourceTree = ""; + }; + 84ACCB871761173B004ABE58 /* concomp */ = { + isa = PBXGroup; + children = ( + 84ACCB881761173B004ABE58 /* concomp */, + 84ACCB891761173B004ABE58 /* concomp.cpp */, + 84ACCB8A1761173B004ABE58 /* concomp.vcproj */, + 84ACCB8B1761173B004ABE58 /* concomp.vcxproj */, + 84ACCB8C1761173B004ABE58 /* Makefile */, + 84ACCB8D1761173B004ABE58 /* Makefile.ex */, + 84ACCB8E1761173B004ABE58 /* ReadMe.txt */, + 84ACCB8F1761173B004ABE58 /* stdafx.cpp */, + 84ACCB901761173B004ABE58 /* stdafx.h */, + 84ACCB911761173B004ABE58 /* targetver.h */, + ); + path = concomp; + sourceTree = ""; + }; + 84ACCB921761173B004ABE58 /* forestfire */ = { + isa = PBXGroup; + children = ( + 84ACCB931761173B004ABE58 /* forestfire */, + 84ACCB941761173B004ABE58 /* forestfire.cpp */, + 84ACCB951761173B004ABE58 /* forestfire.vcproj */, + 84ACCB961761173B004ABE58 /* forestfire.vcxproj */, + 84ACCB971761173B004ABE58 /* Makefile */, + 84ACCB981761173B004ABE58 /* Makefile.ex */, + 84ACCB991761173B004ABE58 /* ReadMe.txt */, + 84ACCB9A1761173B004ABE58 /* stdafx.cpp */, + 84ACCB9B1761173B004ABE58 /* stdafx.h */, + 84ACCB9C1761173B004ABE58 /* targetver.h */, + ); + path = forestfire; + sourceTree = ""; + }; + 84ACCB9D1761173B004ABE58 /* graphgen */ = { + isa = PBXGroup; + children = ( + 84ACCB9E1761173B004ABE58 /* graphgen */, + 84ACCB9F1761173B004ABE58 /* graphgen.cpp */, + 84ACCBA01761173B004ABE58 /* graphgen.vcproj */, + 84ACCBA11761173B004ABE58 /* graphgen.vcxproj */, + 84ACCBA21761173B004ABE58 /* Makefile */, + 84ACCBA31761173B004ABE58 /* Makefile.ex */, + 84ACCBA41761173B004ABE58 /* ReadMe.txt */, + 84ACCBA51761173B004ABE58 /* stdafx.cpp */, + 84ACCBA61761173B004ABE58 /* stdafx.h */, + 84ACCBA71761173B004ABE58 /* targetver.h */, + ); + path = graphgen; + sourceTree = ""; + }; + 84ACCBA81761173B004ABE58 /* graphhash */ = { + isa = PBXGroup; + children = ( + 84ACCBA91761173B004ABE58 /* graphhash */, + 84ACCBAA1761173B004ABE58 /* graphhash.cpp */, + 84ACCBAB1761173B004ABE58 /* graphhash.vcproj */, + 84ACCBAC1761173B004ABE58 /* graphhash.vcxproj */, + 84ACCBAD1761173B004ABE58 /* Makefile */, + 84ACCBAE1761173B004ABE58 /* Makefile.ex */, + 84ACCBAF1761173B004ABE58 /* ReadMe.txt */, + 84ACCBB01761173B004ABE58 /* stdafx.cpp */, + 84ACCBB11761173B004ABE58 /* stdafx.h */, + 84ACCBB21761173B004ABE58 /* targetver.h */, + ); + path = graphhash; + sourceTree = ""; + }; + 84ACCBB31761173B004ABE58 /* infopath */ = { + isa = PBXGroup; + children = ( + 84ACCBB41761173B004ABE58 /* example-cascades.txt */, + 84ACCBB51761173B004ABE58 /* example-network.txt */, + 84ACCBB61761173B004ABE58 /* generate_nets.cpp */, + 84ACCBB71761173B004ABE58 /* infopath */, + 84ACCBB81761173B004ABE58 /* infopath.cpp */, + 84ACCBB91761173B004ABE58 /* infopath.vcproj */, + 84ACCBBA1761173B004ABE58 /* infopath.vcxproj */, + 84ACCBBB1761173B004ABE58 /* Makefile */, + 84ACCBBC1761173B004ABE58 /* Makefile.ex */, + 84ACCBBD1761173B004ABE58 /* ReadMe.txt */, + 84ACCBBE1761173B004ABE58 /* stdafx.cpp */, + 84ACCBBF1761173B004ABE58 /* stdafx.h */, + 84ACCBC01761173B004ABE58 /* targetver.h */, + ); + path = infopath; + sourceTree = ""; + }; + 84ACCBC11761173B004ABE58 /* kcores */ = { + isa = PBXGroup; + children = ( + 84ACCBC21761173B004ABE58 /* kcores */, + 84ACCBC31761173B004ABE58 /* kcores.cpp */, + 84ACCBC41761173B004ABE58 /* kcores.vcproj */, + 84ACCBC51761173B004ABE58 /* kcores.vcxproj */, + 84ACCBC61761173B004ABE58 /* Makefile */, + 84ACCBC71761173B004ABE58 /* Makefile.ex */, + 84ACCBC81761173B004ABE58 /* ReadMe.txt */, + 84ACCBC91761173B004ABE58 /* stdafx.cpp */, + 84ACCBCA1761173B004ABE58 /* stdafx.h */, + 84ACCBCB1761173B004ABE58 /* targetver.h */, + ); + path = kcores; + sourceTree = ""; + }; + 84ACCBCC1761173B004ABE58 /* kronem */ = { + isa = PBXGroup; + children = ( + 84ACCBCD1761173B004ABE58 /* kronem */, + 84ACCBCE1761173B004ABE58 /* kronem.cpp */, + 84ACCBCF1761173B004ABE58 /* kronem.vcproj */, + 84ACCBD01761173B004ABE58 /* kronem.vcxproj */, + 84ACCBD11761173B004ABE58 /* Makefile */, + 84ACCBD21761173B004ABE58 /* Makefile.ex */, + 84ACCBD31761173B004ABE58 /* ReadMe.txt */, + 84ACCBD41761173B004ABE58 /* stdafx.cpp */, + 84ACCBD51761173B004ABE58 /* stdafx.h */, + 84ACCBD61761173B004ABE58 /* targetver.h */, + ); + path = kronem; + sourceTree = ""; + }; + 84ACCBD71761173B004ABE58 /* kronfit */ = { + isa = PBXGroup; + children = ( + 84ACCBD81761173B004ABE58 /* kronfit */, + 84ACCBD91761173B004ABE58 /* kronfit.cpp */, + 84ACCBDA1761173B004ABE58 /* kronfit.vcproj */, + 84ACCBDB1761173B004ABE58 /* kronfit.vcxproj */, + 84ACCBDC1761173B004ABE58 /* Makefile */, + 84ACCBDD1761173B004ABE58 /* Makefile.ex */, + 84ACCBDE1761173B004ABE58 /* ReadMe.txt */, + 84ACCBDF1761173B004ABE58 /* stdafx.cpp */, + 84ACCBE01761173B004ABE58 /* stdafx.h */, + 84ACCBE11761173B004ABE58 /* targetver.h */, + ); + path = kronfit; + sourceTree = ""; + }; + 84ACCBE21761173B004ABE58 /* krongen */ = { + isa = PBXGroup; + children = ( + 84ACCBE31761173B004ABE58 /* krongen */, + 84ACCBE41761173B004ABE58 /* krongen.cpp */, + 84ACCBE51761173B004ABE58 /* krongen.vcproj */, + 84ACCBE61761173B004ABE58 /* krongen.vcxproj */, + 84ACCBE71761173B004ABE58 /* Makefile */, + 84ACCBE81761173B004ABE58 /* Makefile.ex */, + 84ACCBE91761173B004ABE58 /* ReadMe.txt */, + 84ACCBEA1761173B004ABE58 /* stdafx.cpp */, + 84ACCBEB1761173B004ABE58 /* stdafx.h */, + 84ACCBEC1761173B004ABE58 /* targetver.h */, + ); + path = krongen; + sourceTree = ""; + }; + 84ACCBED1761173B004ABE58 /* magfit */ = { + isa = PBXGroup; + children = ( + 84ACCBEE1761173B004ABE58 /* init.config */, + 84ACCBEF1761173B004ABE58 /* magfit */, + 84ACCBF01761173B004ABE58 /* magfit.cpp */, + 84ACCBF11761173B004ABE58 /* magfit.vcproj */, + 84ACCBF21761173B004ABE58 /* magfit.vcxproj */, + 84ACCBF31761173B004ABE58 /* Makefile */, + 84ACCBF41761173B004ABE58 /* Makefile.ex */, + 84ACCBF51761173B004ABE58 /* ReadMe.txt */, + 84ACCBF61761173B004ABE58 /* stdafx.cpp */, + 84ACCBF71761173B004ABE58 /* stdafx.h */, + 84ACCBF81761173B004ABE58 /* targetver.h */, + ); + path = magfit; + sourceTree = ""; + }; + 84ACCBF91761173B004ABE58 /* maggen */ = { + isa = PBXGroup; + children = ( + 84ACCBFA1761173B004ABE58 /* mag.config */, + 84ACCBFB1761173B004ABE58 /* maggen */, + 84ACCBFC1761173B004ABE58 /* maggen.cpp */, + 84ACCBFD1761173B004ABE58 /* maggen.vcproj */, + 84ACCBFE1761173B004ABE58 /* maggen.vcxproj */, + 84ACCBFF1761173B004ABE58 /* Makefile */, + 84ACCC001761173B004ABE58 /* Makefile.ex */, + 84ACCC011761173B004ABE58 /* ReadMe.txt */, + 84ACCC021761173B004ABE58 /* stdafx.cpp */, + 84ACCC031761173B004ABE58 /* stdafx.h */, + 84ACCC041761173B004ABE58 /* targetver.h */, + ); + path = maggen; + sourceTree = ""; + }; + 84ACCC071761173B004ABE58 /* mkdatasets */ = { + isa = PBXGroup; + children = ( + 84ACCC081761173B004ABE58 /* Makefile */, + 84ACCC091761173B004ABE58 /* Makefile.ex */, + 84ACCC0A1761173B004ABE58 /* mkdatasets */, + 84ACCC0B1761173B004ABE58 /* mkdatasets.cpp */, + 84ACCC0C1761173B004ABE58 /* mkdatasets.vcproj */, + 84ACCC0D1761173B004ABE58 /* mkdatasets.vcxproj */, + 84ACCC0E1761173B004ABE58 /* ReadMe.txt */, + 84ACCC0F1761173B004ABE58 /* stdafx.cpp */, + 84ACCC101761173B004ABE58 /* stdafx.h */, + 84ACCC111761173B004ABE58 /* targetver.h */, + ); + path = mkdatasets; + sourceTree = ""; + }; + 84ACCC121761173B004ABE58 /* motifs */ = { + isa = PBXGroup; + children = ( + 84ACCC131761173B004ABE58 /* Makefile */, + 84ACCC141761173B004ABE58 /* Makefile.ex */, + 84ACCC151761173B004ABE58 /* motifs */, + 84ACCC161761173B004ABE58 /* motifs.cpp */, + 84ACCC171761173B004ABE58 /* motifs.vcproj */, + 84ACCC181761173B004ABE58 /* motifs.vcxproj */, + 84ACCC191761173B004ABE58 /* ReadMe.txt */, + 84ACCC1A1761173B004ABE58 /* stdafx.cpp */, + 84ACCC1B1761173B004ABE58 /* stdafx.h */, + 84ACCC1C1761173B004ABE58 /* targetver.h */, + ); + path = motifs; + sourceTree = ""; + }; + 84ACCC1D1761173B004ABE58 /* ncpplot */ = { + isa = PBXGroup; + children = ( + 84ACCC1E1761173B004ABE58 /* Makefile */, + 84ACCC1F1761173B004ABE58 /* Makefile.ex */, + 84ACCC201761173B004ABE58 /* ncpplot */, + 84ACCC211761173B004ABE58 /* ncpplot.cpp */, + 84ACCC221761173B004ABE58 /* ncpplot.vcproj */, + 84ACCC231761173B004ABE58 /* ncpplot.vcxproj */, + 84ACCC241761173B004ABE58 /* ReadMe.txt */, + 84ACCC251761173B004ABE58 /* stdafx.cpp */, + 84ACCC261761173B004ABE58 /* stdafx.h */, + 84ACCC271761173B004ABE58 /* targetver.h */, + ); + path = ncpplot; + sourceTree = ""; + }; + 84ACCC281761173B004ABE58 /* netevol */ = { + isa = PBXGroup; + children = ( + 84ACCC291761173B004ABE58 /* Makefile */, + 84ACCC2A1761173B004ABE58 /* Makefile.ex */, + 84ACCC2B1761173B004ABE58 /* netevol */, + 84ACCC2C1761173B004ABE58 /* netevol.cpp */, + 84ACCC2D1761173B004ABE58 /* netevol.vcproj */, + 84ACCC2E1761173B004ABE58 /* netevol.vcxproj */, + 84ACCC2F1761173B004ABE58 /* ReadMe.txt */, + 84ACCC301761173B004ABE58 /* stdafx.cpp */, + 84ACCC311761173B004ABE58 /* stdafx.h */, + 84ACCC321761173B004ABE58 /* targetver.h */, + ); + path = netevol; + sourceTree = ""; + }; + 84ACCC331761173B004ABE58 /* netinf */ = { + isa = PBXGroup; + children = ( + 84ACCC341761173B004ABE58 /* example-cascades.txt */, + 84ACCC351761173B004ABE58 /* example-network.txt */, + 84ACCC361761173B004ABE58 /* Makefile */, + 84ACCC371761173B004ABE58 /* Makefile.ex */, + 84ACCC381761173B004ABE58 /* netinf */, + 84ACCC391761173B004ABE58 /* netinf.cpp */, + 84ACCC3A1761173B004ABE58 /* netinf.vcproj */, + 84ACCC3B1761173B004ABE58 /* netinf.vcxproj */, + 84ACCC3C1761173B004ABE58 /* network-edge.info */, + 84ACCC3D1761173B004ABE58 /* network.txt */, + 84ACCC3E1761173B004ABE58 /* ReadMe.txt */, + 84ACCC3F1761173B004ABE58 /* stdafx.cpp */, + 84ACCC401761173B004ABE58 /* stdafx.h */, + 84ACCC411761173B004ABE58 /* targetver.h */, + ); + path = netinf; + sourceTree = ""; + }; + 84ACCC421761173B004ABE58 /* netstat */ = { + isa = PBXGroup; + children = ( + 84ACCC431761173B004ABE58 /* Makefile */, + 84ACCC441761173B004ABE58 /* Makefile.ex */, + 84ACCC451761173B004ABE58 /* netstat */, + 84ACCC461761173B004ABE58 /* netstat.cpp */, + 84ACCC471761173B004ABE58 /* netstat.vcproj */, + 84ACCC481761173B004ABE58 /* netstat.vcxproj */, + 84ACCC491761173B004ABE58 /* ReadMe.txt */, + 84ACCC4A1761173B004ABE58 /* stdafx.cpp */, + 84ACCC4B1761173B004ABE58 /* stdafx.h */, + 84ACCC4C1761173B004ABE58 /* targetver.h */, + ); + path = netstat; + sourceTree = ""; + }; + 84ACCC4F1761173B004ABE58 /* Products */ = { + isa = PBXGroup; + children = ( + 84ACD0991761173E004ABE58 /* docs */, + ); + name = Products; + sourceTree = ""; + }; + 84ACCC541761173C004ABE58 /* testgraph */ = { + isa = PBXGroup; + children = ( + 84ACCC551761173C004ABE58 /* Makefile */, + 84ACCC561761173C004ABE58 /* Makefile.ex */, + 84ACCC571761173C004ABE58 /* ReadMe.txt */, + 84ACCC581761173C004ABE58 /* stdafx.cpp */, + 84ACCC591761173C004ABE58 /* stdafx.h */, + 84ACCC5A1761173C004ABE58 /* targetver.h */, + 84ACCC5B1761173C004ABE58 /* testgraph */, + 84ACCC5C1761173C004ABE58 /* testgraph.cpp */, + 84ACCC5D1761173C004ABE58 /* testgraph.vcproj */, + 84ACCC5E1761173C004ABE58 /* testgraph.vcxproj */, + ); + path = testgraph; + sourceTree = ""; + }; + 84ACCC5F1761173C004ABE58 /* XcodeTest */ = { + isa = PBXGroup; + children = ( + 84ACCC601761173C004ABE58 /* XcodeTest */, + 84ACCC631761173C004ABE58 /* XcodeTest.xcodeproj */, + ); + path = XcodeTest; + sourceTree = ""; + }; + 84ACCC601761173C004ABE58 /* XcodeTest */ = { + isa = PBXGroup; + children = ( + 84ACCC611761173C004ABE58 /* main.cpp */, + 84ACCC621761173C004ABE58 /* sample.1 */, + ); + path = XcodeTest; + sourceTree = ""; + }; + 84ACCC641761173C004ABE58 /* Products */ = { + isa = PBXGroup; + children = ( + 84ACD0A21761173E004ABE58 /* XcodeTest */, + ); + name = Products; + sourceTree = ""; + }; + 84ACCC661761173C004ABE58 /* zygote */ = { + isa = PBXGroup; + children = ( + 84ACCC671761173C004ABE58 /* Makefile */, + 84ACCC681761173C004ABE58 /* Makefile.ex */, + 84ACCC691761173C004ABE58 /* ReadMe.txt */, + 84ACCC6A1761173C004ABE58 /* stdafx.cpp */, + 84ACCC6B1761173C004ABE58 /* stdafx.h */, + 84ACCC6C1761173C004ABE58 /* targetver.h */, + 84ACCC6D1761173C004ABE58 /* zydemo.cpp */, + ); + path = zygote; + sourceTree = ""; + }; + 84ACCC6E1761173C004ABE58 /* glib-adv */ = { + isa = PBXGroup; + children = ( + 84ACCC6F1761173C004ABE58 /* acquis.cpp */, + 84ACCC701761173C004ABE58 /* acquis.h */, + 84ACCC711761173C004ABE58 /* adox.cpp */, + 84ACCC721761173C004ABE58 /* adox.h */, + 84ACCC731761173C004ABE58 /* aest.cpp */, + 84ACCC741761173C004ABE58 /* aest.h */, + 84ACCC751761173C004ABE58 /* amazon.cpp */, + 84ACCC761761173C004ABE58 /* amazon.h */, + 84ACCC771761173C004ABE58 /* appsrv.cpp */, + 84ACCC781761173C004ABE58 /* appsrv.h */, + 84ACCC791761173C004ABE58 /* bde.cpp */, + 84ACCC7A1761173C004ABE58 /* bde.h */, + 84ACCC7B1761173C004ABE58 /* biling.cpp */, + 84ACCC7C1761173C004ABE58 /* biling.h */, + 84ACCC7D1761173C004ABE58 /* bix.cpp */, + 84ACCC7E1761173C004ABE58 /* bix.h */, + 84ACCC7F1761173C004ABE58 /* book.cpp */, + 84ACCC801761173C004ABE58 /* book.h */, + 84ACCC811761173C004ABE58 /* bowactlearn.cpp */, + 84ACCC821761173C004ABE58 /* bowactlearn.h */, + 84ACCC831761173C004ABE58 /* bowbs.cpp */, + 84ACCC841761173C004ABE58 /* bowbs.h */, + 84ACCC851761173C004ABE58 /* bowclust.cpp */, + 84ACCC861761173C004ABE58 /* bowclust.h */, + 84ACCC871761173C004ABE58 /* bowfl.cpp */, + 84ACCC881761173C004ABE58 /* bowfl.h */, + 84ACCC891761173C004ABE58 /* bowflx.cpp */, + 84ACCC8A1761173C004ABE58 /* bowflx.h */, + 84ACCC8B1761173C004ABE58 /* bowlearn.cpp */, + 84ACCC8C1761173C004ABE58 /* bowlearn.h */, + 84ACCC8D1761173C004ABE58 /* bowlinalg.cpp */, + 84ACCC8E1761173C004ABE58 /* bowlinalg.h */, + 84ACCC8F1761173C004ABE58 /* bowmatrix.cpp */, + 84ACCC901761173C004ABE58 /* bowmatrix.h */, + 84ACCC911761173C004ABE58 /* bowmd.cpp */, + 84ACCC921761173C004ABE58 /* bowmd.h */, + 84ACCC931761173C004ABE58 /* btalarms.cpp */, + 84ACCC941761173C004ABE58 /* btalarms.h */, + 84ACCC951761173C004ABE58 /* btaserver.cpp */, + 84ACCC961761173C004ABE58 /* btaServer.h */, + 84ACCC971761173C004ABE58 /* cache.h */, + 84ACCC981761173C004ABE58 /* casino.cpp */, + 84ACCC991761173C004ABE58 /* casino.h */, + 84ACCC9A1761173C004ABE58 /* ccar.cpp */, + 84ACCC9B1761173C004ABE58 /* ccar.h */, + 84ACCC9C1761173C004ABE58 /* cfyres.cpp */, + 84ACCC9D1761173C004ABE58 /* cfyres.h */, + 84ACCC9E1761173C004ABE58 /* cgi.cpp */, + 84ACCC9F1761173C004ABE58 /* cgi.h */, + 84ACCCA01761173C004ABE58 /* ciawfb.cpp */, + 84ACCCA11761173C004ABE58 /* ciawfb.h */, + 84ACCCA21761173C004ABE58 /* conjgrad.h */, + 84ACCCA31761173C004ABE58 /* cordis.cpp */, + 84ACCCA41761173C004ABE58 /* cordis.h */, + 84ACCCA51761173C004ABE58 /* corrgr.cpp */, + 84ACCCA61761173C004ABE58 /* corrgr.h */, + 84ACCCA71761173C004ABE58 /* cpdoc.cpp */, + 84ACCCA81761173C004ABE58 /* cpdoc.h */, + 84ACCCA91761173C004ABE58 /* crawler.cpp */, + 84ACCCAA1761173C004ABE58 /* crawler.h */, + 84ACCCAB1761173C004ABE58 /* cyc.cpp */, + 84ACCCAC1761173C004ABE58 /* cyc.h */, + 84ACCCAD1761173C004ABE58 /* dm.cpp */, + 84ACCCAE1761173C004ABE58 /* dm.h */, + 84ACCCAF1761173C004ABE58 /* dmhd.cpp */, + 84ACCCB01761173C004ABE58 /* dmhd.h */, + 84ACCCB11761173C004ABE58 /* dmine.cpp */, + 84ACCCB21761173C004ABE58 /* dmine.h */, + 84ACCCB31761173C004ABE58 /* dmoz.cpp */, + 84ACCCB41761173C004ABE58 /* dmoz.h */, + 84ACCCB51761173C004ABE58 /* dnet.cpp */, + 84ACCCB61761173C004ABE58 /* dnet.h */, + 84ACCCB71761173C004ABE58 /* dzs.cpp */, + 84ACCCB81761173C004ABE58 /* dzs.h */, + 84ACCCB91761173C004ABE58 /* email.cpp */, + 84ACCCBA1761173C004ABE58 /* email.h */, + 84ACCCBB1761173C004ABE58 /* euproj.cpp */, + 84ACCCBC1761173C004ABE58 /* euproj.h */, + 84ACCCBD1761173C004ABE58 /* exset.cpp */, + 84ACCCBE1761173C004ABE58 /* exset.h */, + 84ACCCBF1761173C004ABE58 /* fa.cpp */, + 84ACCCC01761173C004ABE58 /* fa.h */, + 84ACCCC11761173C004ABE58 /* flx.cpp */, + 84ACCCC21761173C004ABE58 /* flx.h */, + 84ACCCC31761173C004ABE58 /* ftrgen.cpp */, + 84ACCCC41761173C004ABE58 /* ftrgen.h */, + 84ACCCC51761173C004ABE58 /* geoip.cpp */, + 84ACCCC61761173C004ABE58 /* geoip.h */, + 84ACCCC71761173C004ABE58 /* gix.cpp */, + 84ACCCC81761173C004ABE58 /* gix.h */, + 84ACCCC91761173C004ABE58 /* gks.cpp */, + 84ACCCCA1761173C004ABE58 /* gks.h */, + 84ACCCCB1761173C004ABE58 /* gksmfc.cpp */, + 84ACCCCC1761173C004ABE58 /* gksmfc.h */, + 84ACCCCD1761173C004ABE58 /* gksvcl.cpp */, + 84ACCCCE1761173C004ABE58 /* gksvcl.h */, + 84ACCCCF1761173C004ABE58 /* gksvml.cpp */, + 84ACCCD01761173C004ABE58 /* gksvml.h */, + 84ACCCD11761173C004ABE58 /* gkswf.cpp */, + 84ACCCD21761173C004ABE58 /* gkswf.h */, + 84ACCCD31761173C004ABE58 /* google.cpp */, + 84ACCCD41761173C004ABE58 /* google.h */, + 84ACCCD51761173C004ABE58 /* googlex.cpp */, + 84ACCCD61761173C004ABE58 /* googlex.h */, + 84ACCCD71761173C004ABE58 /* graph.cpp */, + 84ACCCD81761173C004ABE58 /* graph.h */, + 84ACCCD91761173C004ABE58 /* gridvcl.cpp */, + 84ACCCDA1761173C004ABE58 /* gridvcl.h */, + 84ACCCDB1761173C004ABE58 /* gsearch.cpp */, + 84ACCCDC1761173C004ABE58 /* gsearch.h */, + 84ACCCDD1761173C004ABE58 /* guid.cpp */, + 84ACCCDE1761173C004ABE58 /* guid.h */, + 84ACCCDF1761173C004ABE58 /* hc.cpp */, + 84ACCCE01761173C004ABE58 /* hc.h */, + 84ACCCE11761173C004ABE58 /* hldoc.cpp */, + 84ACCCE21761173C004ABE58 /* hldoc.h */, + 84ACCCE31761173C004ABE58 /* infonet.cpp */, + 84ACCCE41761173C004ABE58 /* infonet.h */, + 84ACCCE51761173C004ABE58 /* kernelmethods.cpp */, + 84ACCCE61761173C004ABE58 /* kernelmethods.h */, + 84ACCCE71761173C004ABE58 /* logreg.cpp */, + 84ACCCE81761173C004ABE58 /* logreg.h */, + 84ACCCE91761173C004ABE58 /* lsionto.cpp */, + 84ACCCEA1761173C004ABE58 /* lsionto.h */, + 84ACCCEB1761173C004ABE58 /* Makefile */, + 84ACCCEC1761173C004ABE58 /* md.cpp */, + 84ACCCED1761173C004ABE58 /* md.h */, + 84ACCCEE1761173C004ABE58 /* mdtr.cpp */, + 84ACCCEF1761173C004ABE58 /* mdtr.h */, + 84ACCCF01761173C004ABE58 /* medline.cpp */, + 84ACCCF11761173C004ABE58 /* medline.h */, + 84ACCCF21761173C004ABE58 /* mg.cpp */, + 84ACCCF31761173C004ABE58 /* mg.h */, + 84ACCCF41761173C004ABE58 /* mindset.h */, + 84ACCCF51761173C004ABE58 /* mine.cpp */, + 84ACCCF61761173C004ABE58 /* mine.h */, + 84ACCCF71761173C004ABE58 /* mkcca.cpp */, + 84ACCCF81761173C004ABE58 /* mkcca.h */, + 84ACCCF91761173C004ABE58 /* mte.cpp */, + 84ACCCFA1761173C004ABE58 /* mte.h */, + 84ACCCFB1761173C004ABE58 /* mtr.cpp */, + 84ACCCFC1761173C004ABE58 /* mtr.h */, + 84ACCCFD1761173C004ABE58 /* net.cpp */, + 84ACCCFE1761173C004ABE58 /* net.h */, + 84ACCCFF1761173C004ABE58 /* netobj.cpp */, + 84ACCD001761173C004ABE58 /* netobj.h */, + 84ACCD011761173C004ABE58 /* nlpwinlf.cpp */, + 84ACCD021761173C004ABE58 /* nlpwinlf.h */, + 84ACCD031761173C004ABE58 /* nmen.cpp */, + 84ACCD041761173C004ABE58 /* nmen.h */, + 84ACCD051761173C004ABE58 /* nmobj.cpp */, + 84ACCD061761173C004ABE58 /* nmobj.h */, + 84ACCD071761173C004ABE58 /* nntp.cpp */, + 84ACCD081761173C004ABE58 /* nntp.h */, + 84ACCD091761173C004ABE58 /* nyta.cpp */, + 84ACCD0A1761173C004ABE58 /* nyta.h */, + 84ACCD0B1761173C004ABE58 /* nytngrams.cpp */, + 84ACCD0C1761173C004ABE58 /* nytngrams.h */, + 84ACCD0D1761173C004ABE58 /* odbc.cpp */, + 84ACCD0E1761173C004ABE58 /* odbc.h */, + 84ACCD0F1761173C004ABE58 /* ontolight.cpp */, + 84ACCD101761173C004ABE58 /* ontolight.h */, + 84ACCD111761173C004ABE58 /* pest.cpp */, + 84ACCD121761173C004ABE58 /* pest.h */, + 84ACCD131761173C004ABE58 /* phrase.cpp */, + 84ACCD141761173C004ABE58 /* phrase.h */, + 84ACCD151761173C004ABE58 /* pi.cpp */, + 84ACCD161761173C004ABE58 /* pi.h */, + 84ACCD171761173C004ABE58 /* postag.cpp */, + 84ACCD181761173C004ABE58 /* postag.h */, + 84ACCD191761173C004ABE58 /* prolog.cpp */, + 84ACCD1A1761173C004ABE58 /* prolog.h */, + 84ACCD1B1761173C004ABE58 /* prologparser.cpp */, + 84ACCD1C1761173C004ABE58 /* prologparser.h */, + 84ACCD1D1761173C004ABE58 /* proxy.cpp */, + 84ACCD1E1761173C004ABE58 /* proxy.h */, + 84ACCD1F1761173C004ABE58 /* pww.cpp */, + 84ACCD201761173C004ABE58 /* rdbms.cpp */, + 84ACCD211761173C004ABE58 /* rdbms.h */, + 84ACCD221761173C004ABE58 /* roget.cpp */, + 84ACCD231761173C004ABE58 /* roget.h */, + 84ACCD241761173C004ABE58 /* sappsrv.cpp */, + 84ACCD251761173C004ABE58 /* sappsrv.h */, + 84ACCD261761173C004ABE58 /* sch.cpp */, + 84ACCD271761173C004ABE58 /* sch.h */, + 84ACCD281761173C004ABE58 /* semspace.cpp */, + 84ACCD291761173C004ABE58 /* semspace.h */, + 84ACCD2A1761173C004ABE58 /* sgraph.cpp */, + 84ACCD2B1761173C004ABE58 /* sgraph.h */, + 84ACCD2C1761173C004ABE58 /* skygrid.cpp */, + 84ACCD2D1761173C004ABE58 /* skygrid.h */, + 84ACCD2E1761173C004ABE58 /* smtp.cpp */, + 84ACCD2F1761173C004ABE58 /* smtp.h */, + 84ACCD301761173C004ABE58 /* soap.cpp */, + 84ACCD311761173C004ABE58 /* soap.h */, + 84ACCD321761173C004ABE58 /* sock-new.cpp */, + 84ACCD331761173C004ABE58 /* sock-new.h */, + 84ACCD341761173C004ABE58 /* sock.cpp */, + 84ACCD351761173C004ABE58 /* sock.h */, + 84ACCD361761173C004ABE58 /* sqlite3.c */, + 84ACCD371761173C004ABE58 /* sqlite3.h */, + 84ACCD381761173C004ABE58 /* sqlitedb.cpp */, + 84ACCD391761173C004ABE58 /* sqlitedb.h */, + 84ACCD3A1761173C004ABE58 /* ssch.cpp */, + 84ACCD3B1761173C004ABE58 /* ssch.h */, + 84ACCD3C1761173C004ABE58 /* sskj.cpp */, + 84ACCD3D1761173C004ABE58 /* sskj.h */, + 84ACCD3E1761173C004ABE58 /* ssql.cpp */, + 84ACCD3F1761173C004ABE58 /* ssql.h */, + 84ACCD401761173C004ABE58 /* ssqldm.cpp */, + 84ACCD411761173C004ABE58 /* ssqldm.h */, + 84ACCD421761173C004ABE58 /* stemming.cpp */, + 84ACCD431761173C004ABE58 /* stemming.h */, + 84ACCD441761173C004ABE58 /* stopword.cpp */, + 84ACCD451761173C004ABE58 /* stopword.h */, + 84ACCD461761173C004ABE58 /* strkernel.cpp */, + 84ACCD471761173C004ABE58 /* strkernel.h */, + 84ACCD481761173C004ABE58 /* strut.cpp */, + 84ACCD491761173C004ABE58 /* strut.h */, + 84ACCD4A1761173C004ABE58 /* subprocess.cpp */, + 84ACCD4B1761173C004ABE58 /* subprocess.h */, + 84ACCD4C1761173C004ABE58 /* svmbasic.cpp */, + 84ACCD4D1761173C004ABE58 /* svmbasic.h */, + 84ACCD4E1761173C004ABE58 /* svmmodels.cpp */, + 84ACCD4F1761173C004ABE58 /* svmmodels.h */, + 84ACCD501761173C004ABE58 /* svmPrLoqo.cpp */, + 84ACCD511761173C004ABE58 /* svmPrLoqo.h */, + 84ACCD521761173C004ABE58 /* tagcloud.cpp */, + 84ACCD531761173C004ABE58 /* tagcloud.h */, + 84ACCD541761173C004ABE58 /* tb.cpp */, + 84ACCD551761173C004ABE58 /* tb.h */, + 84ACCD561761173C004ABE58 /* tbhc.cpp */, + 84ACCD571761173C004ABE58 /* tbhc.h */, + 84ACCD581761173C004ABE58 /* tbval.cpp */, + 84ACCD591761173C004ABE58 /* tbval.h */, + 84ACCD5A1761173C004ABE58 /* term.cpp */, + 84ACCD5B1761173C004ABE58 /* term.h */, + 84ACCD5C1761173C004ABE58 /* testBase.cpp */, + 84ACCD5D1761173C004ABE58 /* tmine.cpp */, + 84ACCD5E1761173C004ABE58 /* tmine.h */, + 84ACCD5F1761173C004ABE58 /* tnt.cpp */, + 84ACCD601761173C004ABE58 /* tnt.h */, + 84ACCD611761173C004ABE58 /* tql.cpp */, + 84ACCD621761173C004ABE58 /* tql.h */, + 84ACCD631761173C004ABE58 /* ts.cpp */, + 84ACCD641761173C004ABE58 /* ts.h */, + 84ACCD651761173C004ABE58 /* txtbs.cpp */, + 84ACCD661761173C004ABE58 /* txtbs.h */, + 84ACCD671761173C004ABE58 /* ultra.cpp */, + 84ACCD681761173C004ABE58 /* ultra.h */, + 84ACCD691761173C004ABE58 /* valds.cpp */, + 84ACCD6A1761173C004ABE58 /* valds.h */, + 84ACCD6B1761173C004ABE58 /* valret.cpp */, + 84ACCD6C1761173C004ABE58 /* valret.h */, + 84ACCD6D1761173C004ABE58 /* vizmap.cpp */, + 84ACCD6E1761173C004ABE58 /* vizmap.h */, + 84ACCD6F1761173C004ABE58 /* vizmapgks.cpp */, + 84ACCD701761173C004ABE58 /* vizmapgks.h */, + 84ACCD711761173C004ABE58 /* wbmp.cpp */, + 84ACCD721761173C004ABE58 /* wbmp.h */, + 84ACCD731761173C004ABE58 /* webbsfetch.cpp */, + 84ACCD741761173C004ABE58 /* webbsfetch.h */, + 84ACCD751761173C004ABE58 /* webmb.cpp */, + 84ACCD761761173C004ABE58 /* webmb.h */, + 84ACCD771761173C004ABE58 /* webnetobj.cpp */, + 84ACCD781761173C004ABE58 /* webnetobj.h */, + 84ACCD791761173C004ABE58 /* webold.cpp */, + 84ACCD7A1761173C004ABE58 /* webold.h */, + 84ACCD7B1761173C004ABE58 /* webpgfetch.cpp */, + 84ACCD7C1761173C004ABE58 /* webpgfetch.h */, + 84ACCD7D1761173C004ABE58 /* websrv.cpp */, + 84ACCD7E1761173C004ABE58 /* websrv.h */, + 84ACCD7F1761173D004ABE58 /* webtrv.cpp */, + 84ACCD801761173D004ABE58 /* webtrv.h */, + 84ACCD811761173D004ABE58 /* webtxtbs.cpp */, + 84ACCD821761173D004ABE58 /* webtxtbs.h */, + 84ACCD831761173D004ABE58 /* wikipedia.cpp */, + 84ACCD841761173D004ABE58 /* wikipedia.h */, + 84ACCD851761173D004ABE58 /* wix.cpp */, + 84ACCD861761173D004ABE58 /* wix.h */, + 84ACCD871761173D004ABE58 /* wixexp.cpp */, + 84ACCD881761173D004ABE58 /* wixexp.h */, + 84ACCD891761173D004ABE58 /* wmine.cpp */, + 84ACCD8A1761173D004ABE58 /* wmine.h */, + 84ACCD8B1761173D004ABE58 /* wordco.cpp */, + 84ACCD8C1761173D004ABE58 /* wordco.h */, + 84ACCD8D1761173D004ABE58 /* wordnet.cpp */, + 84ACCD8E1761173D004ABE58 /* wordnet.h */, + 84ACCD8F1761173D004ABE58 /* xql.cpp */, + 84ACCD901761173D004ABE58 /* xql.h */, + 84ACCD911761173D004ABE58 /* yahoobs.cpp */, + 84ACCD921761173D004ABE58 /* yahoobs.h */, + 84ACCD931761173D004ABE58 /* yahoodm.cpp */, + 84ACCD941761173D004ABE58 /* yahoodm.h */, + 84ACCD951761173D004ABE58 /* yahooex.cpp */, + 84ACCD961761173D004ABE58 /* yahooex.h */, + 84ACCD971761173D004ABE58 /* zipcode.cpp */, + 84ACCD981761173D004ABE58 /* zipcode.h */, + ); + path = "glib-adv"; + sourceTree = ""; + }; + 84ACCD991761173D004ABE58 /* glib-core */ = { + isa = PBXGroup; + children = ( + 84ACCD9A1761173D004ABE58 /* app.cpp */, + 84ACCD9B1761173D004ABE58 /* app.h */, + 84ACCD9C1761173D004ABE58 /* base.cpp */, + 84ACCD9D1761173D004ABE58 /* base.h */, + 84ACCD9E1761173D004ABE58 /* bd.cpp */, + 84ACCD9F1761173D004ABE58 /* bd.h */, + 84ACCDA01761173D004ABE58 /* bits.cpp */, + 84ACCDA11761173D004ABE58 /* bits.h */, + 84ACCDA21761173D004ABE58 /* blobbs.cpp */, + 84ACCDA31761173D004ABE58 /* blobbs.h */, + 84ACCDA41761173D004ABE58 /* console.cpp */, + 84ACCDA51761173D004ABE58 /* console.h */, + 84ACCDA61761173D004ABE58 /* doc */, + 84ACCDAA1761173D004ABE58 /* ds.h */, + 84ACCDAB1761173D004ABE58 /* dt.cpp */, + 84ACCDAC1761173D004ABE58 /* dt.h */, + 84ACCDAD1761173D004ABE58 /* env.cpp */, + 84ACCDAE1761173D004ABE58 /* env.h */, + 84ACCDAF1761173D004ABE58 /* exp.cpp */, + 84ACCDB01761173D004ABE58 /* exp.h */, + 84ACCDB11761173D004ABE58 /* fds.h */, + 84ACCDB21761173D004ABE58 /* fl.cpp */, + 84ACCDB31761173D004ABE58 /* fl.h */, + 84ACCDB41761173D004ABE58 /* gnuplot.cpp */, + 84ACCDB51761173D004ABE58 /* gnuplot.h */, + 84ACCDB61761173D004ABE58 /* hash.cpp */, + 84ACCDB71761173D004ABE58 /* hash.h */, + 84ACCDB81761173D004ABE58 /* html.cpp */, + 84ACCDB91761173D004ABE58 /* html.h */, + 84ACCDBA1761173D004ABE58 /* http.cpp */, + 84ACCDBB1761173D004ABE58 /* http.h */, + 84ACCDBC1761173D004ABE58 /* json.cpp */, + 84ACCDBD1761173D004ABE58 /* json.h */, + 84ACCDBE1761173D004ABE58 /* linalg.cpp */, + 84ACCDBF1761173D004ABE58 /* linalg.h */, + 84ACCDC01761173D004ABE58 /* lx.cpp */, + 84ACCDC11761173D004ABE58 /* lx.h */, + 84ACCDC21761173D004ABE58 /* macro.cpp */, + 84ACCDC31761173D004ABE58 /* macro.h */, + 84ACCDC41761173D004ABE58 /* md5.cpp */, + 84ACCDC51761173D004ABE58 /* md5.h */, + 84ACCDC61761173D004ABE58 /* os.cpp */, + 84ACCDC71761173D004ABE58 /* os.h */, + 84ACCDC81761173D004ABE58 /* pp.cpp */, + 84ACCDC91761173D004ABE58 /* pp.h */, + 84ACCDCA1761173D004ABE58 /* shash.h */, + 84ACCDCB1761173D004ABE58 /* ss.cpp */, + 84ACCDCC1761173D004ABE58 /* ss.h */, + 84ACCDCD1761173D004ABE58 /* stdafx.h */, + 84ACCDCE1761173D004ABE58 /* tm.cpp */, + 84ACCDCF1761173D004ABE58 /* tm.h */, + 84ACCDD01761173D004ABE58 /* unicode.cpp */, + 84ACCDD11761173D004ABE58 /* unicode.h */, + 84ACCDD21761173D004ABE58 /* unicodestring.cpp */, + 84ACCDD31761173D004ABE58 /* unicodestring.h */, + 84ACCDD41761173D004ABE58 /* url.cpp */, + 84ACCDD51761173D004ABE58 /* url.h */, + 84ACCDD61761173D004ABE58 /* ut.cpp */, + 84ACCDD71761173D004ABE58 /* ut.h */, + 84ACCDD81761173D004ABE58 /* wch.cpp */, + 84ACCDD91761173D004ABE58 /* wch.h */, + 84ACCDDA1761173D004ABE58 /* xdt.cpp */, + 84ACCDDB1761173D004ABE58 /* xdt.h */, + 84ACCDDC1761173D004ABE58 /* xfl.cpp */, + 84ACCDDD1761173D004ABE58 /* xfl.h */, + 84ACCDDE1761173D004ABE58 /* xmath.cpp */, + 84ACCDDF1761173D004ABE58 /* xmath.h */, + 84ACCDE01761173D004ABE58 /* xml.cpp */, + 84ACCDE11761173D004ABE58 /* xml.h */, + 84ACCDE21761173D004ABE58 /* xmlser.h */, + 84ACCDE31761173D004ABE58 /* zipfl.cpp */, + 84ACCDE41761173D004ABE58 /* zipfl.h */, + ); + path = "glib-core"; + sourceTree = ""; + }; + 84ACCDA61761173D004ABE58 /* doc */ = { + isa = PBXGroup; + children = ( + 84ACCDA71761173D004ABE58 /* bd.h.txt */, + 84ACCDA81761173D004ABE58 /* ds.h.txt */, + 84ACCDA91761173D004ABE58 /* ss.h.txt */, + ); + path = doc; + sourceTree = ""; + }; + 84ACCDE91761173D004ABE58 /* snap-adv */ = { + isa = PBXGroup; + children = ( + 84ACCDEA1761173D004ABE58 /* agm.cpp */, + 84ACCDEB1761173D004ABE58 /* agm.h */, + 84ACCDEC1761173D004ABE58 /* agmfast.cpp */, + 84ACCDED1761173D004ABE58 /* agmfast.h */, + 84ACCDEE1761173D004ABE58 /* agmfit.cpp */, + 84ACCDEF1761173D004ABE58 /* agmfit.h */, + 84ACCDF01761173D004ABE58 /* cascdynetinf.cpp */, + 84ACCDF11761173D004ABE58 /* cascdynetinf.h */, + 84ACCDF21761173D004ABE58 /* cascnetinf.cpp */, + 84ACCDF31761173D004ABE58 /* cascnetinf.h */, + 84ACCDF41761173D004ABE58 /* circles.h */, + 84ACCDF51761173D004ABE58 /* cliques.cpp */, + 84ACCDF61761173D004ABE58 /* cliques.h */, + 84ACCDF71761173D004ABE58 /* doc */, + 84ACCDF91761173D004ABE58 /* graphcounter.cpp */, + 84ACCDFA1761173D004ABE58 /* graphcounter.h */, + 84ACCDFB1761173D004ABE58 /* kronecker.cpp */, + 84ACCDFC1761173D004ABE58 /* kronecker.h */, + 84ACCDFD1761173D004ABE58 /* mag.cpp */, + 84ACCDFE1761173D004ABE58 /* mag.h */, + 84ACCDFF1761173D004ABE58 /* ncp.cpp */, + 84ACCE001761173D004ABE58 /* ncp.h */, + 84ACCE011761173D004ABE58 /* subgraphenum.cpp */, + 84ACCE021761173D004ABE58 /* subgraphenum.h */, + ); + path = "snap-adv"; + sourceTree = ""; + }; + 84ACCDF71761173D004ABE58 /* doc */ = { + isa = PBXGroup; + children = ( + 84ACCDF81761173D004ABE58 /* ncp.h.txt */, + ); + path = doc; + sourceTree = ""; + }; + 84ACCE031761173D004ABE58 /* snap-core */ = { + isa = PBXGroup; + children = ( + 84ACCE041761173D004ABE58 /* alg.cpp */, + 84ACCE051761173D004ABE58 /* alg.h */, + 84ACCE061761173D004ABE58 /* anf.cpp */, + 84ACCE071761173D004ABE58 /* anf.h */, + 84ACCE081761173D004ABE58 /* bfsdfs.h */, + 84ACCE091761173D004ABE58 /* bignet.h */, + 84ACCE0A1761173D004ABE58 /* centr.cpp */, + 84ACCE0B1761173D004ABE58 /* centr.h */, + 84ACCE0C1761173D004ABE58 /* cmty.cpp */, + 84ACCE0D1761173D004ABE58 /* cmty.h */, + 84ACCE0E1761173D004ABE58 /* cncom.cpp */, + 84ACCE0F1761173D004ABE58 /* cncom.h */, + 84ACCE101761173D004ABE58 /* doc */, + 84ACCE1D1761173D004ABE58 /* ff.cpp */, + 84ACCE1E1761173D004ABE58 /* ff.h */, + 84ACCE1F1761173D004ABE58 /* gbase.cpp */, + 84ACCE201761173D004ABE58 /* gbase.h */, + 84ACCE211761173D004ABE58 /* ggen.cpp */, + 84ACCE221761173D004ABE58 /* ggen.h */, + 84ACCE231761173D004ABE58 /* ghash.cpp */, + 84ACCE241761173D004ABE58 /* ghash.h */, + 84ACCE251761173D004ABE58 /* gio.cpp */, + 84ACCE261761173D004ABE58 /* gio.h */, + 84ACCE271761173D004ABE58 /* graph.cpp */, + 84ACCE281761173D004ABE58 /* graph.h */, + 84ACCE291761173D004ABE58 /* graph.txt */, + 84ACCE2A1761173D004ABE58 /* gstat.cpp */, + 84ACCE2B1761173D004ABE58 /* gstat.h */, + 84ACCE2C1761173D004ABE58 /* gsvd.cpp */, + 84ACCE2D1761173D004ABE58 /* gsvd.h */, + 84ACCE2E1761173D004ABE58 /* gviz.cpp */, + 84ACCE2F1761173D004ABE58 /* gviz.h */, + 84ACCE301761173D004ABE58 /* kcore.h */, + 84ACCE311761173D004ABE58 /* Makefile */, + 84ACCE321761173D004ABE58 /* network.cpp */, + 84ACCE331761173D004ABE58 /* network.h */, + 84ACCE341761173D004ABE58 /* snap-core.xcodeproj */, + 84ACCE371761173D004ABE58 /* Snap.cpp */, + 84ACCE381761173D004ABE58 /* Snap.h */, + 84ACCE391761173D004ABE58 /* Snap.o */, + 84ACCE3A1761173D004ABE58 /* statplot.cpp */, + 84ACCE3B1761173D004ABE58 /* statplot.h */, + 84ACCE3C1761173D004ABE58 /* stdafx.h */, + 84ACCE3D1761173D004ABE58 /* subgraph.cpp */, + 84ACCE3E1761173D004ABE58 /* subgraph.h */, + 84ACCE3F1761173D004ABE58 /* testSnap */, + 84ACCE401761173D004ABE58 /* testSnap.cpp */, + 84ACCE411761173D004ABE58 /* timenet.cpp */, + 84ACCE421761173D004ABE58 /* timenet.h */, + 84ACCE431761173D004ABE58 /* triad.h */, + 84ACCE441761173D004ABE58 /* util.cpp */, + 84ACCE451761173D004ABE58 /* util.h */, + ); + path = "snap-core"; + sourceTree = ""; + }; + 84ACCE101761173D004ABE58 /* doc */ = { + isa = PBXGroup; + children = ( + 84ACCE111761173D004ABE58 /* bfsdfs.h.txt */, + 84ACCE121761173D004ABE58 /* bignet.h.txt */, + 84ACCE131761173D004ABE58 /* cncom.h.txt */, + 84ACCE141761173D004ABE58 /* gbase.h.txt */, + 84ACCE151761173D004ABE58 /* ghash.h.txt */, + 84ACCE161761173D004ABE58 /* gio.h.txt */, + 84ACCE171761173D004ABE58 /* graph.h.txt */, + 84ACCE181761173D004ABE58 /* gviz.h.txt */, + 84ACCE191761173D004ABE58 /* network.h.txt */, + 84ACCE1A1761173D004ABE58 /* Snap.h.txt */, + 84ACCE1B1761173D004ABE58 /* subgraph.h.txt */, + 84ACCE1C1761173D004ABE58 /* triad.h.txt */, + ); + path = doc; + sourceTree = ""; + }; + 84ACCE351761173D004ABE58 /* Products */ = { + isa = PBXGroup; + children = ( + 84ACD0791761173E004ABE58 /* testSnap */, + 84ACD07B1761173E004ABE58 /* docs.app */, + ); + name = Products; + sourceTree = ""; + }; + 84ACCE461761173D004ABE58 /* snap-exp */ = { + isa = PBXGroup; + children = ( + 84ACCE471761173D004ABE58 /* arxiv.cpp */, + 84ACCE481761173D004ABE58 /* arxiv.h */, + 84ACCE491761173D004ABE58 /* circles */, + 84ACCE531761173D004ABE58 /* dblp.cpp */, + 84ACCE541761173D004ABE58 /* dblp.h */, + 84ACCE551761173D004ABE58 /* imdbnet.cpp */, + 84ACCE561761173D004ABE58 /* imdbnet.h */, + 84ACCE571761173D004ABE58 /* linkpred.cpp */, + 84ACCE581761173D004ABE58 /* linkpred.h */, + 84ACCE591761173D004ABE58 /* memenet.cpp */, + 84ACCE5A1761173D004ABE58 /* memenet.h */, + 84ACCE5B1761173D004ABE58 /* memes.cpp */, + 84ACCE5C1761173D004ABE58 /* memes.h */, + 84ACCE5D1761173D004ABE58 /* mxdag.cpp */, + 84ACCE5E1761173D004ABE58 /* mxdag.h */, + 84ACCE5F1761173D004ABE58 /* signnet.cpp */, + 84ACCE601761173D004ABE58 /* signnet.h */, + 84ACCE611761173D004ABE58 /* sir.cpp */, + 84ACCE621761173D004ABE58 /* sir.h */, + 84ACCE631761173D004ABE58 /* spinn3r.cpp */, + 84ACCE641761173D004ABE58 /* spinn3r.h */, + 84ACCE651761173D004ABE58 /* trawling.cpp */, + 84ACCE661761173D004ABE58 /* trawling.h */, + 84ACCE671761173D004ABE58 /* wgtnet.cpp */, + 84ACCE681761173D004ABE58 /* wgtnet.h */, + 84ACCE691761173D004ABE58 /* wikinet.cpp */, + 84ACCE6A1761173D004ABE58 /* wikinet.h */, + ); + path = "snap-exp"; + sourceTree = ""; + }; + 84ACCE491761173D004ABE58 /* circles */ = { + isa = PBXGroup; + children = ( + 84ACCE4A1761173D004ABE58 /* circles.cpp */, + 84ACCE4B1761173D004ABE58 /* circles.h */, + 84ACCE4C1761173D004ABE58 /* fb1.edges */, + 84ACCE4D1761173D004ABE58 /* fb1.features */, + 84ACCE4E1761173D004ABE58 /* Makefile */, + 84ACCE4F1761173D004ABE58 /* Makefile.ex */, + 84ACCE501761173D004ABE58 /* stdafx.cpp */, + 84ACCE511761173D004ABE58 /* stdafx.h */, + 84ACCE521761173D004ABE58 /* targetver.h */, + ); + path = circles; + sourceTree = ""; + }; + 84ACCE6B1761173D004ABE58 /* test */ = { + isa = PBXGroup; + children = ( + 84ACCE6C1761173D004ABE58 /* bfsdfs */, + 84ACCE701761173D004ABE58 /* cncom */, + 84ACCE731761173D004ABE58 /* graphviz */, + 84ACCEB71761173D004ABE58 /* Makefile */, + 84ACCEB81761173D004ABE58 /* run-all-tests.cpp */, + 84ACCEB91761173D004ABE58 /* snap-test.xcodeproj */, + 84ACCEBE1761173D004ABE58 /* test-alg.cpp */, + 84ACCEBF1761173D004ABE58 /* test-bfsdfs.cpp */, + 84ACCEC01761173D004ABE58 /* test-cncom.cpp */, + 84ACCEC11761173D004ABE58 /* test-file.cpp */, + 84ACCEC21761173D004ABE58 /* test-ggen.cpp */, + 84ACCEC31761173D004ABE58 /* test-gio.cpp */, + 84ACCEC41761173D004ABE58 /* test-gviz.cpp */, + 84ACCEC51761173D004ABE58 /* test-helper.cpp */, + 84ACCEC61761173D004ABE58 /* test-helper.h */, + 84ACCEC71761173D004ABE58 /* test-subgraph.cpp */, + 84ACCEC81761173D004ABE58 /* test-THash.cpp */, + 84ACCEC91761173D004ABE58 /* test-THashSet.cpp */, + 84ACCECA1761173D004ABE58 /* test-TNEANet.cpp */, + 84ACCECB1761173D004ABE58 /* test-TNEGraph.cpp */, + 84ACCECC1761173D004ABE58 /* test-TNGraph.cpp */, + 84ACCECD1761173D004ABE58 /* test-TNodeEDatNet.cpp */, + 84ACCECE1761173D004ABE58 /* test-TNodeEdgeNet.cpp */, + 84ACCECF1761173D004ABE58 /* test-TNodeNet.cpp */, + 84ACCED01761173D004ABE58 /* test-triad.cpp */, + 84ACCED11761173D004ABE58 /* test-TStrPool.cpp */, + 84ACCED21761173E004ABE58 /* test-TSysTm.cpp */, + 84ACCED31761173E004ABE58 /* test-TUNGraph.cpp */, + ); + path = test; + sourceTree = ""; + }; + 84ACCE6C1761173D004ABE58 /* bfsdfs */ = { + isa = PBXGroup; + children = ( + 84ACCE6D1761173D004ABE58 /* sample_bfsdfs_ngraph.txt */, + 84ACCE6E1761173D004ABE58 /* sample_bfsdfs_power.txt */, + 84ACCE6F1761173D004ABE58 /* sample_bfsdfs_unpower.txt */, + ); + path = bfsdfs; + sourceTree = ""; + }; + 84ACCE701761173D004ABE58 /* cncom */ = { + isa = PBXGroup; + children = ( + 84ACCE711761173D004ABE58 /* sample_cncom_ngraph.txt */, + 84ACCE721761173D004ABE58 /* sample_cncom_unpower.txt */, + ); + path = cncom; + sourceTree = ""; + }; + 84ACCE731761173D004ABE58 /* graphviz */ = { + isa = PBXGroup; + children = ( + 84ACCE741761173D004ABE58 /* base_ngraph_Circo.dot */, + 84ACCE751761173D004ABE58 /* base_ngraph_Circo.gif */, + 84ACCE761761173D004ABE58 /* base_ngraph_Circo.png */, + 84ACCE771761173D004ABE58 /* base_ngraph_Circo.ps */, + 84ACCE781761173D004ABE58 /* base_ngraph_Circo_col.dot */, + 84ACCE791761173D004ABE58 /* base_ngraph_Circo_col.gif */, + 84ACCE7A1761173D004ABE58 /* base_ngraph_Circo_col.png */, + 84ACCE7B1761173D004ABE58 /* base_ngraph_Circo_col.ps */, + 84ACCE7C1761173D004ABE58 /* base_ngraph_Dot.dot */, + 84ACCE7D1761173D004ABE58 /* base_ngraph_Dot.gif */, + 84ACCE7E1761173D004ABE58 /* base_ngraph_Dot.png */, + 84ACCE7F1761173D004ABE58 /* base_ngraph_Dot.ps */, + 84ACCE801761173D004ABE58 /* base_ngraph_Dot_col.dot */, + 84ACCE811761173D004ABE58 /* base_ngraph_Dot_col.gif */, + 84ACCE821761173D004ABE58 /* base_ngraph_Dot_col.png */, + 84ACCE831761173D004ABE58 /* base_ngraph_Dot_col.ps */, + 84ACCE841761173D004ABE58 /* base_ngraph_Neato.dot */, + 84ACCE851761173D004ABE58 /* base_ngraph_Neato.gif */, + 84ACCE861761173D004ABE58 /* base_ngraph_Neato.png */, + 84ACCE871761173D004ABE58 /* base_ngraph_Neato.ps */, + 84ACCE881761173D004ABE58 /* base_ngraph_Neato_col.dot */, + 84ACCE891761173D004ABE58 /* base_ngraph_Neato_col.gif */, + 84ACCE8A1761173D004ABE58 /* base_ngraph_Neato_col.png */, + 84ACCE8B1761173D004ABE58 /* base_ngraph_Neato_col.ps */, + 84ACCE8C1761173D004ABE58 /* base_ngraph_Twopi.dot */, + 84ACCE8D1761173D004ABE58 /* base_ngraph_Twopi.gif */, + 84ACCE8E1761173D004ABE58 /* base_ngraph_Twopi.png */, + 84ACCE8F1761173D004ABE58 /* base_ngraph_Twopi.ps */, + 84ACCE901761173D004ABE58 /* base_ngraph_Twopi_col.dot */, + 84ACCE911761173D004ABE58 /* base_ngraph_Twopi_col.gif */, + 84ACCE921761173D004ABE58 /* base_ngraph_Twopi_col.png */, + 84ACCE931761173D004ABE58 /* base_ngraph_Twopi_col.ps */, + 84ACCE941761173D004ABE58 /* base_ungraph_Circo.dot */, + 84ACCE951761173D004ABE58 /* base_ungraph_Circo.gif */, + 84ACCE961761173D004ABE58 /* base_ungraph_Circo.png */, + 84ACCE971761173D004ABE58 /* base_ungraph_Circo.ps */, + 84ACCE981761173D004ABE58 /* base_ungraph_Circo_col.dot */, + 84ACCE991761173D004ABE58 /* base_ungraph_Circo_col.gif */, + 84ACCE9A1761173D004ABE58 /* base_ungraph_Circo_col.png */, + 84ACCE9B1761173D004ABE58 /* base_ungraph_Circo_col.ps */, + 84ACCE9C1761173D004ABE58 /* base_ungraph_Dot.dot */, + 84ACCE9D1761173D004ABE58 /* base_ungraph_Dot.gif */, + 84ACCE9E1761173D004ABE58 /* base_ungraph_Dot.png */, + 84ACCE9F1761173D004ABE58 /* base_ungraph_Dot.ps */, + 84ACCEA01761173D004ABE58 /* base_ungraph_Dot_col.dot */, + 84ACCEA11761173D004ABE58 /* base_ungraph_Dot_col.gif */, + 84ACCEA21761173D004ABE58 /* base_ungraph_Dot_col.png */, + 84ACCEA31761173D004ABE58 /* base_ungraph_Dot_col.ps */, + 84ACCEA41761173D004ABE58 /* base_ungraph_Neato.dot */, + 84ACCEA51761173D004ABE58 /* base_ungraph_Neato.gif */, + 84ACCEA61761173D004ABE58 /* base_ungraph_Neato.png */, + 84ACCEA71761173D004ABE58 /* base_ungraph_Neato.ps */, + 84ACCEA81761173D004ABE58 /* base_ungraph_Neato_col.dot */, + 84ACCEA91761173D004ABE58 /* base_ungraph_Neato_col.gif */, + 84ACCEAA1761173D004ABE58 /* base_ungraph_Neato_col.png */, + 84ACCEAB1761173D004ABE58 /* base_ungraph_Neato_col.ps */, + 84ACCEAC1761173D004ABE58 /* base_ungraph_Twopi.dot */, + 84ACCEAD1761173D004ABE58 /* base_ungraph_Twopi.gif */, + 84ACCEAE1761173D004ABE58 /* base_ungraph_Twopi.png */, + 84ACCEAF1761173D004ABE58 /* base_ungraph_Twopi.ps */, + 84ACCEB01761173D004ABE58 /* base_ungraph_Twopi_col.dot */, + 84ACCEB11761173D004ABE58 /* base_ungraph_Twopi_col.gif */, + 84ACCEB21761173D004ABE58 /* base_ungraph_Twopi_col.png */, + 84ACCEB31761173D004ABE58 /* base_ungraph_Twopi_col.ps */, + 84ACCEB41761173D004ABE58 /* node_colors.txt */, + 84ACCEB51761173D004ABE58 /* sample_ngraph1.txt */, + 84ACCEB61761173D004ABE58 /* sample_ungraph1.txt */, + ); + path = graphviz; + sourceTree = ""; + }; + 84ACCEBA1761173D004ABE58 /* Products */ = { + isa = PBXGroup; + children = ( + 84ACD09F1761173E004ABE58 /* docs */, + ); + name = Products; + sourceTree = ""; + }; + 84ACCED41761173E004ABE58 /* tutorials */ = { + isa = PBXGroup; + children = ( + 84ACCED51761173E004ABE58 /* cncom */, + 84ACCED81761173E004ABE58 /* demo-bfsdfs.cpp */, + 84ACCED91761173E004ABE58 /* demo-cncom.cpp */, + 84ACCEDA1761173E004ABE58 /* demo-ggen.cpp */, + 84ACCEDB1761173E004ABE58 /* demo-gio.cpp */, + 84ACCEDC1761173E004ABE58 /* demo-gviz.cpp */, + 84ACCEDD1761173E004ABE58 /* demo-hashvec-benchmark.cpp */, + 84ACCEDE1761173E004ABE58 /* demo-subgraph.cpp */, + 84ACCEDF1761173E004ABE58 /* demo-THash.cpp */, + 84ACCEE01761173E004ABE58 /* demo-TNEANet.cpp */, + 84ACCEE11761173E004ABE58 /* demo-TNEGraph.cpp */, + 84ACCEE21761173E004ABE58 /* demo-TNGraph.cpp */, + 84ACCEE31761173E004ABE58 /* demo-TNodeEDatNet.cpp */, + 84ACCEE41761173E004ABE58 /* demo-TNodeEdgeNet.cpp */, + 84ACCEE51761173E004ABE58 /* demo-TNodeNet.cpp */, + 84ACCEE61761173E004ABE58 /* demo-topology-benchmark.cpp */, + 84ACCEE71761173E004ABE58 /* demo-triad.cpp */, + 84ACCEE81761173E004ABE58 /* demo-TUNGraph.cpp */, + 84ACCEE91761173E004ABE58 /* graphviz */, + 84ACCF0A1761173E004ABE58 /* Makefile */, + 84ACCF0B1761173E004ABE58 /* tutorials.xcodeproj */, + ); + path = tutorials; + sourceTree = ""; + }; + 84ACCED51761173E004ABE58 /* cncom */ = { + isa = PBXGroup; + children = ( + 84ACCED61761173E004ABE58 /* sample_cncom_ngraph.dot */, + 84ACCED71761173E004ABE58 /* sample_cncom_unpower.dot */, + ); + path = cncom; + sourceTree = ""; + }; + 84ACCEE91761173E004ABE58 /* graphviz */ = { + isa = PBXGroup; + children = ( + 84ACCEEA1761173E004ABE58 /* demo_ngraph_Circo.dot */, + 84ACCEEB1761173E004ABE58 /* demo_ngraph_Circo.gif */, + 84ACCEEC1761173E004ABE58 /* demo_ngraph_Circo_col.dot */, + 84ACCEED1761173E004ABE58 /* demo_ngraph_Circo_col.gif */, + 84ACCEEE1761173E004ABE58 /* demo_ngraph_Dot.dot */, + 84ACCEEF1761173E004ABE58 /* demo_ngraph_Dot.gif */, + 84ACCEF01761173E004ABE58 /* demo_ngraph_Dot_col.dot */, + 84ACCEF11761173E004ABE58 /* demo_ngraph_Dot_col.gif */, + 84ACCEF21761173E004ABE58 /* demo_ngraph_Neato.dot */, + 84ACCEF31761173E004ABE58 /* demo_ngraph_Neato.gif */, + 84ACCEF41761173E004ABE58 /* demo_ngraph_Neato_col.dot */, + 84ACCEF51761173E004ABE58 /* demo_ngraph_Neato_col.gif */, + 84ACCEF61761173E004ABE58 /* demo_ngraph_Twopi.dot */, + 84ACCEF71761173E004ABE58 /* demo_ngraph_Twopi.gif */, + 84ACCEF81761173E004ABE58 /* demo_ngraph_Twopi_col.dot */, + 84ACCEF91761173E004ABE58 /* demo_ngraph_Twopi_col.gif */, + 84ACCEFA1761173E004ABE58 /* demo_ungraph_Circo.dot */, + 84ACCEFB1761173E004ABE58 /* demo_ungraph_Circo.gif */, + 84ACCEFC1761173E004ABE58 /* demo_ungraph_Circo_col.dot */, + 84ACCEFD1761173E004ABE58 /* demo_ungraph_Circo_col.gif */, + 84ACCEFE1761173E004ABE58 /* demo_ungraph_Dot.dot */, + 84ACCEFF1761173E004ABE58 /* demo_ungraph_Dot.gif */, + 84ACCF001761173E004ABE58 /* demo_ungraph_Dot_col.dot */, + 84ACCF011761173E004ABE58 /* demo_ungraph_Dot_col.gif */, + 84ACCF021761173E004ABE58 /* demo_ungraph_Neato.dot */, + 84ACCF031761173E004ABE58 /* demo_ungraph_Neato.gif */, + 84ACCF041761173E004ABE58 /* demo_ungraph_Neato_col.dot */, + 84ACCF051761173E004ABE58 /* demo_ungraph_Neato_col.gif */, + 84ACCF061761173E004ABE58 /* demo_ungraph_Twopi.dot */, + 84ACCF071761173E004ABE58 /* demo_ungraph_Twopi.gif */, + 84ACCF081761173E004ABE58 /* demo_ungraph_Twopi_col.dot */, + 84ACCF091761173E004ABE58 /* demo_ungraph_Twopi_col.gif */, + ); + path = graphviz; + sourceTree = ""; + }; + 84ACCF0C1761173E004ABE58 /* Products */ = { + isa = PBXGroup; + name = Products; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXLegacyTarget section */ + 847482B016CD85D200AF3EF4 /* snap-python */ = { + isa = PBXLegacyTarget; + buildArgumentsString = "$(ACTION)"; + buildConfigurationList = 847482B316CD85D200AF3EF4 /* Build configuration list for PBXLegacyTarget "snap-python" */; + buildPhases = ( + ); + buildToolPath = /usr/bin/make; + buildWorkingDirectory = .; + dependencies = ( + ); + name = "snap-python"; + passBuildSettingsInEnvironment = 1; + productName = "snap-python"; + }; + 84FE86FA17209EC20099963A /* swig-r */ = { + isa = PBXLegacyTarget; + buildArgumentsString = "$(ACTION)"; + buildConfigurationList = 84FE870317209EC30099963A /* Build configuration list for PBXLegacyTarget "swig-r" */; + buildPhases = ( + ); + buildToolPath = /usr/bin/make; + buildWorkingDirectory = "swig-r"; + dependencies = ( + ); + name = "swig-r"; + passBuildSettingsInEnvironment = 1; + productName = "swig-r"; + }; +/* End PBXLegacyTarget section */ + +/* Begin PBXNativeTarget section */ + 8488FEAA16D20F8400C789B8 /* docs */ = { + isa = PBXNativeTarget; + buildConfigurationList = 8488FEB316D20F8400C789B8 /* Build configuration list for PBXNativeTarget "docs" */; + buildPhases = ( + 8488FEA716D20F8400C789B8 /* Sources */, + 8488FEA816D20F8400C789B8 /* Frameworks */, + 8488FEA916D20F8400C789B8 /* CopyFiles */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = docs; + productName = docs; + productReference = 8488FEAB16D20F8400C789B8 /* docs */; + productType = "com.apple.product-type.tool"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 847482AB16CD85D200AF3EF4 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 0450; + ORGANIZATIONNAME = infolab; + }; + buildConfigurationList = 847482AE16CD85D200AF3EF4 /* Build configuration list for PBXProject "snap-python" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + ); + mainGroup = 847482A916CD85D200AF3EF4; + productRefGroup = 8488FEAC16D20F8400C789B8 /* Products */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 84ACCE351761173D004ABE58 /* Products */; + ProjectRef = 84ACCE341761173D004ABE58 /* snap-core.xcodeproj */; + }, + { + ProductGroup = 84ACCC4F1761173B004ABE58 /* Products */; + ProjectRef = 84ACCC4E1761173B004ABE58 /* snap-examples.xcodeproj */; + }, + { + ProductGroup = 84ACCEBA1761173D004ABE58 /* Products */; + ProjectRef = 84ACCEB91761173D004ABE58 /* snap-test.xcodeproj */; + }, + { + ProductGroup = 84ACCF0C1761173E004ABE58 /* Products */; + ProjectRef = 84ACCF0B1761173E004ABE58 /* tutorials.xcodeproj */; + }, + { + ProductGroup = 84ACCC641761173C004ABE58 /* Products */; + ProjectRef = 84ACCC631761173C004ABE58 /* XcodeTest.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 847482B016CD85D200AF3EF4 /* snap-python */, + 84FE86FA17209EC20099963A /* swig-r */, + 8488FEAA16D20F8400C789B8 /* docs */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 84ACD0791761173E004ABE58 /* testSnap */ = { + isa = PBXReferenceProxy; + fileType = "compiled.mach-o.executable"; + path = testSnap; + remoteRef = 84ACD0781761173E004ABE58 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 84ACD07B1761173E004ABE58 /* docs.app */ = { + isa = PBXReferenceProxy; + fileType = wrapper.application; + path = docs.app; + remoteRef = 84ACD07A1761173E004ABE58 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 84ACD0991761173E004ABE58 /* docs */ = { + isa = PBXReferenceProxy; + fileType = "compiled.mach-o.executable"; + path = docs; + remoteRef = 84ACD0981761173E004ABE58 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 84ACD09F1761173E004ABE58 /* docs */ = { + isa = PBXReferenceProxy; + fileType = "compiled.mach-o.executable"; + path = docs; + remoteRef = 84ACD09E1761173E004ABE58 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 84ACD0A21761173E004ABE58 /* XcodeTest */ = { + isa = PBXReferenceProxy; + fileType = "compiled.mach-o.executable"; + path = XcodeTest; + remoteRef = 84ACD0A11761173E004ABE58 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXSourcesBuildPhase section */ + 8488FEA716D20F8400C789B8 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 84FE870C1720A8920099963A /* snap.i in Sources */, + 84FF218717555FE400D11D81 /* snap_types.h in Sources */, + 841A46031758649000CDFE82 /* snap_types.i in Sources */, + 8488019616D20FF300C789B8 /* snapswig.h in Sources */, + 841A46041758649000CDFE82 /* pneanet.i in Sources */, + 8488019416D20FF300C789B8 /* printgraph.h in Sources */, + 841E00C516DC449900B86980 /* getassessment.cpp in Sources */, + 8456FCEA16E2E28D00ECCD5F /* goodgraph.cpp in Sources */, + 84ACCF0E1761173E004ABE58 /* Makefile in Sources */, + 84ACCF0F1761173E004ABE58 /* agmfitmain.cpp in Sources */, + 84ACCF101761173E004ABE58 /* Makefile in Sources */, + 84ACCF111761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF121761173E004ABE58 /* agmgen.cpp in Sources */, + 84ACCF131761173E004ABE58 /* Makefile in Sources */, + 84ACCF141761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF151761173E004ABE58 /* bigclam.cpp in Sources */, + 84ACCF161761173E004ABE58 /* Makefile in Sources */, + 84ACCF171761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF181761173E004ABE58 /* cascades.cpp in Sources */, + 84ACCF191761173E004ABE58 /* Makefile in Sources */, + 84ACCF1A1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF1B1761173E004ABE58 /* centrality.cpp in Sources */, + 84ACCF1C1761173E004ABE58 /* Makefile in Sources */, + 84ACCF1D1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF1E1761173E004ABE58 /* circles.cpp in Sources */, + 84ACCF1F1761173E004ABE58 /* Makefile in Sources */, + 84ACCF201761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF211761173E004ABE58 /* cliquesmain.cpp in Sources */, + 84ACCF221761173E004ABE58 /* Makefile in Sources */, + 84ACCF231761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF241761173E004ABE58 /* community.cpp in Sources */, + 84ACCF251761173E004ABE58 /* Makefile in Sources */, + 84ACCF261761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF271761173E004ABE58 /* concomp.cpp in Sources */, + 84ACCF281761173E004ABE58 /* Makefile in Sources */, + 84ACCF291761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF2A1761173E004ABE58 /* forestfire.cpp in Sources */, + 84ACCF2B1761173E004ABE58 /* Makefile in Sources */, + 84ACCF2C1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF2D1761173E004ABE58 /* graphgen.cpp in Sources */, + 84ACCF2E1761173E004ABE58 /* Makefile in Sources */, + 84ACCF2F1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF301761173E004ABE58 /* graphhash.cpp in Sources */, + 84ACCF311761173E004ABE58 /* Makefile in Sources */, + 84ACCF321761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF331761173E004ABE58 /* generate_nets.cpp in Sources */, + 84ACCF341761173E004ABE58 /* infopath.cpp in Sources */, + 84ACCF351761173E004ABE58 /* Makefile in Sources */, + 84ACCF361761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF371761173E004ABE58 /* kcores.cpp in Sources */, + 84ACCF381761173E004ABE58 /* Makefile in Sources */, + 84ACCF391761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF3A1761173E004ABE58 /* kronem.cpp in Sources */, + 84ACCF3B1761173E004ABE58 /* Makefile in Sources */, + 84ACCF3C1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF3D1761173E004ABE58 /* kronfit.cpp in Sources */, + 84ACCF3E1761173E004ABE58 /* Makefile in Sources */, + 84ACCF3F1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF401761173E004ABE58 /* krongen.cpp in Sources */, + 84ACCF411761173E004ABE58 /* Makefile in Sources */, + 84ACCF421761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF431761173E004ABE58 /* magfit.cpp in Sources */, + 84ACCF441761173E004ABE58 /* Makefile in Sources */, + 84ACCF451761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF461761173E004ABE58 /* maggen.cpp in Sources */, + 84ACCF471761173E004ABE58 /* Makefile in Sources */, + 84ACCF481761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF491761173E004ABE58 /* Makefile in Sources */, + 84ACCF4A1761173E004ABE58 /* Makefile in Sources */, + 84ACCF4B1761173E004ABE58 /* mkdatasets.cpp in Sources */, + 84ACCF4C1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF4D1761173E004ABE58 /* Makefile in Sources */, + 84ACCF4E1761173E004ABE58 /* motifs.cpp in Sources */, + 84ACCF4F1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF501761173E004ABE58 /* Makefile in Sources */, + 84ACCF511761173E004ABE58 /* ncpplot.cpp in Sources */, + 84ACCF521761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF531761173E004ABE58 /* Makefile in Sources */, + 84ACCF541761173E004ABE58 /* netevol.cpp in Sources */, + 84ACCF551761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF561761173E004ABE58 /* Makefile in Sources */, + 84ACCF571761173E004ABE58 /* netinf.cpp in Sources */, + 84ACCF581761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF591761173E004ABE58 /* Makefile in Sources */, + 84ACCF5A1761173E004ABE58 /* netstat.cpp in Sources */, + 84ACCF5B1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF5C1761173E004ABE58 /* Makefile in Sources */, + 84ACCF5D1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF5E1761173E004ABE58 /* testgraph.cpp in Sources */, + 84ACCF5F1761173E004ABE58 /* main.cpp in Sources */, + 84ACCF601761173E004ABE58 /* Makefile in Sources */, + 84ACCF611761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACCF621761173E004ABE58 /* zydemo.cpp in Sources */, + 84ACCF631761173E004ABE58 /* acquis.cpp in Sources */, + 84ACCF641761173E004ABE58 /* adox.cpp in Sources */, + 84ACCF651761173E004ABE58 /* aest.cpp in Sources */, + 84ACCF661761173E004ABE58 /* amazon.cpp in Sources */, + 84ACCF671761173E004ABE58 /* appsrv.cpp in Sources */, + 84ACCF681761173E004ABE58 /* bde.cpp in Sources */, + 84ACCF691761173E004ABE58 /* biling.cpp in Sources */, + 84ACCF6A1761173E004ABE58 /* bix.cpp in Sources */, + 84ACCF6B1761173E004ABE58 /* book.cpp in Sources */, + 84ACCF6C1761173E004ABE58 /* bowactlearn.cpp in Sources */, + 84ACCF6D1761173E004ABE58 /* bowbs.cpp in Sources */, + 84ACCF6E1761173E004ABE58 /* bowclust.cpp in Sources */, + 84ACCF6F1761173E004ABE58 /* bowfl.cpp in Sources */, + 84ACCF701761173E004ABE58 /* bowflx.cpp in Sources */, + 84ACCF711761173E004ABE58 /* bowlearn.cpp in Sources */, + 84ACCF721761173E004ABE58 /* bowlinalg.cpp in Sources */, + 84ACCF731761173E004ABE58 /* bowmatrix.cpp in Sources */, + 84ACCF741761173E004ABE58 /* bowmd.cpp in Sources */, + 84ACCF751761173E004ABE58 /* btalarms.cpp in Sources */, + 84ACCF761761173E004ABE58 /* btaserver.cpp in Sources */, + 84ACCF771761173E004ABE58 /* casino.cpp in Sources */, + 84ACCF781761173E004ABE58 /* ccar.cpp in Sources */, + 84ACCF791761173E004ABE58 /* cfyres.cpp in Sources */, + 84ACCF7A1761173E004ABE58 /* cgi.cpp in Sources */, + 84ACCF7B1761173E004ABE58 /* ciawfb.cpp in Sources */, + 84ACCF7C1761173E004ABE58 /* cordis.cpp in Sources */, + 84ACCF7D1761173E004ABE58 /* corrgr.cpp in Sources */, + 84ACCF7E1761173E004ABE58 /* cpdoc.cpp in Sources */, + 84ACCF7F1761173E004ABE58 /* crawler.cpp in Sources */, + 84ACCF801761173E004ABE58 /* cyc.cpp in Sources */, + 84ACCF811761173E004ABE58 /* dm.cpp in Sources */, + 84ACCF821761173E004ABE58 /* dmhd.cpp in Sources */, + 84ACCF831761173E004ABE58 /* dmine.cpp in Sources */, + 84ACCF841761173E004ABE58 /* dmoz.cpp in Sources */, + 84ACCF851761173E004ABE58 /* dnet.cpp in Sources */, + 84ACCF861761173E004ABE58 /* dzs.cpp in Sources */, + 84ACCF871761173E004ABE58 /* email.cpp in Sources */, + 84ACCF881761173E004ABE58 /* euproj.cpp in Sources */, + 84ACCF891761173E004ABE58 /* exset.cpp in Sources */, + 84ACCF8A1761173E004ABE58 /* fa.cpp in Sources */, + 84ACCF8B1761173E004ABE58 /* flx.cpp in Sources */, + 84ACCF8C1761173E004ABE58 /* ftrgen.cpp in Sources */, + 84ACCF8D1761173E004ABE58 /* geoip.cpp in Sources */, + 84ACCF8E1761173E004ABE58 /* gix.cpp in Sources */, + 84ACCF8F1761173E004ABE58 /* gks.cpp in Sources */, + 84ACCF901761173E004ABE58 /* gksmfc.cpp in Sources */, + 84ACCF911761173E004ABE58 /* gksvcl.cpp in Sources */, + 84ACCF921761173E004ABE58 /* gksvml.cpp in Sources */, + 84ACCF931761173E004ABE58 /* gkswf.cpp in Sources */, + 84ACCF941761173E004ABE58 /* google.cpp in Sources */, + 84ACCF951761173E004ABE58 /* googlex.cpp in Sources */, + 84ACCF961761173E004ABE58 /* graph.cpp in Sources */, + 84ACCF971761173E004ABE58 /* gridvcl.cpp in Sources */, + 84ACCF981761173E004ABE58 /* gsearch.cpp in Sources */, + 84ACCF991761173E004ABE58 /* guid.cpp in Sources */, + 84ACCF9A1761173E004ABE58 /* hc.cpp in Sources */, + 84ACCF9B1761173E004ABE58 /* hldoc.cpp in Sources */, + 84ACCF9C1761173E004ABE58 /* infonet.cpp in Sources */, + 84ACCF9D1761173E004ABE58 /* kernelmethods.cpp in Sources */, + 84ACCF9E1761173E004ABE58 /* logreg.cpp in Sources */, + 84ACCF9F1761173E004ABE58 /* lsionto.cpp in Sources */, + 84ACCFA01761173E004ABE58 /* Makefile in Sources */, + 84ACCFA11761173E004ABE58 /* md.cpp in Sources */, + 84ACCFA21761173E004ABE58 /* mdtr.cpp in Sources */, + 84ACCFA31761173E004ABE58 /* medline.cpp in Sources */, + 84ACCFA41761173E004ABE58 /* mg.cpp in Sources */, + 84ACCFA51761173E004ABE58 /* mine.cpp in Sources */, + 84ACCFA61761173E004ABE58 /* mkcca.cpp in Sources */, + 84ACCFA71761173E004ABE58 /* mte.cpp in Sources */, + 84ACCFA81761173E004ABE58 /* mtr.cpp in Sources */, + 84ACCFA91761173E004ABE58 /* net.cpp in Sources */, + 84ACCFAA1761173E004ABE58 /* netobj.cpp in Sources */, + 84ACCFAB1761173E004ABE58 /* nlpwinlf.cpp in Sources */, + 84ACCFAC1761173E004ABE58 /* nmen.cpp in Sources */, + 84ACCFAD1761173E004ABE58 /* nmobj.cpp in Sources */, + 84ACCFAE1761173E004ABE58 /* nntp.cpp in Sources */, + 84ACCFAF1761173E004ABE58 /* nyta.cpp in Sources */, + 84ACCFB01761173E004ABE58 /* nytngrams.cpp in Sources */, + 84ACCFB11761173E004ABE58 /* odbc.cpp in Sources */, + 84ACCFB21761173E004ABE58 /* ontolight.cpp in Sources */, + 84ACCFB31761173E004ABE58 /* pest.cpp in Sources */, + 84ACCFB41761173E004ABE58 /* phrase.cpp in Sources */, + 84ACCFB51761173E004ABE58 /* pi.cpp in Sources */, + 84ACCFB61761173E004ABE58 /* postag.cpp in Sources */, + 84ACCFB71761173E004ABE58 /* prolog.cpp in Sources */, + 84ACCFB81761173E004ABE58 /* prologparser.cpp in Sources */, + 84ACCFB91761173E004ABE58 /* proxy.cpp in Sources */, + 84ACCFBA1761173E004ABE58 /* pww.cpp in Sources */, + 84ACCFBB1761173E004ABE58 /* rdbms.cpp in Sources */, + 84ACCFBC1761173E004ABE58 /* roget.cpp in Sources */, + 84ACCFBD1761173E004ABE58 /* sappsrv.cpp in Sources */, + 84ACCFBE1761173E004ABE58 /* sch.cpp in Sources */, + 84ACCFBF1761173E004ABE58 /* semspace.cpp in Sources */, + 84ACCFC01761173E004ABE58 /* sgraph.cpp in Sources */, + 84ACCFC11761173E004ABE58 /* skygrid.cpp in Sources */, + 84ACCFC21761173E004ABE58 /* smtp.cpp in Sources */, + 84ACCFC31761173E004ABE58 /* soap.cpp in Sources */, + 84ACCFC41761173E004ABE58 /* sock-new.cpp in Sources */, + 84ACCFC51761173E004ABE58 /* sock.cpp in Sources */, + 84ACCFC61761173E004ABE58 /* sqlite3.c in Sources */, + 84ACCFC71761173E004ABE58 /* sqlitedb.cpp in Sources */, + 84ACCFC81761173E004ABE58 /* ssch.cpp in Sources */, + 84ACCFC91761173E004ABE58 /* sskj.cpp in Sources */, + 84ACCFCA1761173E004ABE58 /* ssql.cpp in Sources */, + 84ACCFCB1761173E004ABE58 /* ssqldm.cpp in Sources */, + 84ACCFCC1761173E004ABE58 /* stemming.cpp in Sources */, + 84ACCFCD1761173E004ABE58 /* stopword.cpp in Sources */, + 84ACCFCE1761173E004ABE58 /* strkernel.cpp in Sources */, + 84ACCFCF1761173E004ABE58 /* strut.cpp in Sources */, + 84ACCFD01761173E004ABE58 /* subprocess.cpp in Sources */, + 84ACCFD11761173E004ABE58 /* svmbasic.cpp in Sources */, + 84ACCFD21761173E004ABE58 /* svmmodels.cpp in Sources */, + 84ACCFD31761173E004ABE58 /* svmPrLoqo.cpp in Sources */, + 84ACCFD41761173E004ABE58 /* tagcloud.cpp in Sources */, + 84ACCFD51761173E004ABE58 /* tb.cpp in Sources */, + 84ACCFD61761173E004ABE58 /* tbhc.cpp in Sources */, + 84ACCFD71761173E004ABE58 /* tbval.cpp in Sources */, + 84ACCFD81761173E004ABE58 /* term.cpp in Sources */, + 84ACCFD91761173E004ABE58 /* testBase.cpp in Sources */, + 84ACCFDA1761173E004ABE58 /* tmine.cpp in Sources */, + 84ACCFDB1761173E004ABE58 /* tnt.cpp in Sources */, + 84ACCFDC1761173E004ABE58 /* tql.cpp in Sources */, + 84ACCFDD1761173E004ABE58 /* ts.cpp in Sources */, + 84ACCFDE1761173E004ABE58 /* txtbs.cpp in Sources */, + 84ACCFDF1761173E004ABE58 /* ultra.cpp in Sources */, + 84ACCFE01761173E004ABE58 /* valds.cpp in Sources */, + 84ACCFE11761173E004ABE58 /* valret.cpp in Sources */, + 84ACCFE21761173E004ABE58 /* vizmap.cpp in Sources */, + 84ACCFE31761173E004ABE58 /* vizmapgks.cpp in Sources */, + 84ACCFE41761173E004ABE58 /* wbmp.cpp in Sources */, + 84ACCFE51761173E004ABE58 /* webbsfetch.cpp in Sources */, + 84ACCFE61761173E004ABE58 /* webmb.cpp in Sources */, + 84ACCFE71761173E004ABE58 /* webnetobj.cpp in Sources */, + 84ACCFE81761173E004ABE58 /* webold.cpp in Sources */, + 84ACCFE91761173E004ABE58 /* webpgfetch.cpp in Sources */, + 84ACCFEA1761173E004ABE58 /* websrv.cpp in Sources */, + 84ACCFEB1761173E004ABE58 /* webtrv.cpp in Sources */, + 84ACCFEC1761173E004ABE58 /* webtxtbs.cpp in Sources */, + 84ACCFED1761173E004ABE58 /* wikipedia.cpp in Sources */, + 84ACCFEE1761173E004ABE58 /* wix.cpp in Sources */, + 84ACCFEF1761173E004ABE58 /* wixexp.cpp in Sources */, + 84ACCFF01761173E004ABE58 /* wmine.cpp in Sources */, + 84ACCFF11761173E004ABE58 /* wordco.cpp in Sources */, + 84ACCFF21761173E004ABE58 /* wordnet.cpp in Sources */, + 84ACCFF31761173E004ABE58 /* xql.cpp in Sources */, + 84ACCFF41761173E004ABE58 /* yahoobs.cpp in Sources */, + 84ACCFF51761173E004ABE58 /* yahoodm.cpp in Sources */, + 84ACCFF61761173E004ABE58 /* yahooex.cpp in Sources */, + 84ACCFF71761173E004ABE58 /* zipcode.cpp in Sources */, + 84ACCFF81761173E004ABE58 /* app.cpp in Sources */, + 84ACCFF91761173E004ABE58 /* base.cpp in Sources */, + 84ACCFFA1761173E004ABE58 /* bd.cpp in Sources */, + 84ACCFFB1761173E004ABE58 /* bits.cpp in Sources */, + 84ACCFFC1761173E004ABE58 /* blobbs.cpp in Sources */, + 84ACCFFD1761173E004ABE58 /* console.cpp in Sources */, + 84ACCFFE1761173E004ABE58 /* dt.cpp in Sources */, + 84ACCFFF1761173E004ABE58 /* env.cpp in Sources */, + 84ACD0001761173E004ABE58 /* exp.cpp in Sources */, + 84ACD0011761173E004ABE58 /* fl.cpp in Sources */, + 84ACD0021761173E004ABE58 /* gnuplot.cpp in Sources */, + 84ACD0031761173E004ABE58 /* hash.cpp in Sources */, + 84ACD0041761173E004ABE58 /* html.cpp in Sources */, + 84ACD0051761173E004ABE58 /* http.cpp in Sources */, + 84ACD0061761173E004ABE58 /* json.cpp in Sources */, + 84ACD0071761173E004ABE58 /* linalg.cpp in Sources */, + 84ACD0081761173E004ABE58 /* lx.cpp in Sources */, + 84ACD0091761173E004ABE58 /* macro.cpp in Sources */, + 84ACD00A1761173E004ABE58 /* md5.cpp in Sources */, + 84ACD00B1761173E004ABE58 /* os.cpp in Sources */, + 84ACD00C1761173E004ABE58 /* pp.cpp in Sources */, + 84ACD00D1761173E004ABE58 /* ss.cpp in Sources */, + 84ACD00E1761173E004ABE58 /* tm.cpp in Sources */, + 84ACD00F1761173E004ABE58 /* unicode.cpp in Sources */, + 84ACD0101761173E004ABE58 /* unicodestring.cpp in Sources */, + 84ACD0111761173E004ABE58 /* url.cpp in Sources */, + 84ACD0121761173E004ABE58 /* ut.cpp in Sources */, + 84ACD0131761173E004ABE58 /* wch.cpp in Sources */, + 84ACD0141761173E004ABE58 /* xdt.cpp in Sources */, + 84ACD0151761173E004ABE58 /* xfl.cpp in Sources */, + 84ACD0161761173E004ABE58 /* xmath.cpp in Sources */, + 84ACD0171761173E004ABE58 /* xml.cpp in Sources */, + 84ACD0181761173E004ABE58 /* zipfl.cpp in Sources */, + 84ACD0191761173E004ABE58 /* Makefile in Sources */, + 84ACD01A1761173E004ABE58 /* agm.cpp in Sources */, + 84ACD01B1761173E004ABE58 /* agmfast.cpp in Sources */, + 84ACD01C1761173E004ABE58 /* agmfit.cpp in Sources */, + 84ACD01D1761173E004ABE58 /* cascdynetinf.cpp in Sources */, + 84ACD01E1761173E004ABE58 /* cascnetinf.cpp in Sources */, + 84ACD01F1761173E004ABE58 /* cliques.cpp in Sources */, + 84ACD0201761173E004ABE58 /* graphcounter.cpp in Sources */, + 84ACD0211761173E004ABE58 /* kronecker.cpp in Sources */, + 84ACD0221761173E004ABE58 /* mag.cpp in Sources */, + 84ACD0231761173E004ABE58 /* ncp.cpp in Sources */, + 84ACD0241761173E004ABE58 /* subgraphenum.cpp in Sources */, + 84ACD0251761173E004ABE58 /* alg.cpp in Sources */, + 84ACD0261761173E004ABE58 /* anf.cpp in Sources */, + 84ACD0271761173E004ABE58 /* centr.cpp in Sources */, + 84ACD0281761173E004ABE58 /* cmty.cpp in Sources */, + 84ACD0291761173E004ABE58 /* cncom.cpp in Sources */, + 84ACD02A1761173E004ABE58 /* ff.cpp in Sources */, + 84ACD02B1761173E004ABE58 /* gbase.cpp in Sources */, + 84ACD02C1761173E004ABE58 /* ggen.cpp in Sources */, + 84ACD02D1761173E004ABE58 /* ghash.cpp in Sources */, + 84ACD02E1761173E004ABE58 /* gio.cpp in Sources */, + 84ACD02F1761173E004ABE58 /* graph.cpp in Sources */, + 84ACD0301761173E004ABE58 /* gstat.cpp in Sources */, + 84ACD0311761173E004ABE58 /* gsvd.cpp in Sources */, + 84ACD0321761173E004ABE58 /* gviz.cpp in Sources */, + 84ACD0331761173E004ABE58 /* Makefile in Sources */, + 84ACD0341761173E004ABE58 /* network.cpp in Sources */, + 84ACD0351761173E004ABE58 /* Snap.cpp in Sources */, + 84ACD0371761173E004ABE58 /* statplot.cpp in Sources */, + 84ACD0381761173E004ABE58 /* subgraph.cpp in Sources */, + 84ACD0391761173E004ABE58 /* testSnap.cpp in Sources */, + 84ACD03A1761173E004ABE58 /* timenet.cpp in Sources */, + 84ACD03B1761173E004ABE58 /* util.cpp in Sources */, + 84ACD03C1761173E004ABE58 /* arxiv.cpp in Sources */, + 84ACD03D1761173E004ABE58 /* circles.cpp in Sources */, + 84ACD03E1761173E004ABE58 /* Makefile in Sources */, + 84ACD03F1761173E004ABE58 /* stdafx.cpp in Sources */, + 84ACD0401761173E004ABE58 /* dblp.cpp in Sources */, + 84ACD0411761173E004ABE58 /* imdbnet.cpp in Sources */, + 84ACD0421761173E004ABE58 /* linkpred.cpp in Sources */, + 84ACD0431761173E004ABE58 /* memenet.cpp in Sources */, + 84ACD0441761173E004ABE58 /* memes.cpp in Sources */, + 84ACD0451761173E004ABE58 /* mxdag.cpp in Sources */, + 84ACD0461761173E004ABE58 /* signnet.cpp in Sources */, + 84ACD0471761173E004ABE58 /* sir.cpp in Sources */, + 84ACD0481761173E004ABE58 /* spinn3r.cpp in Sources */, + 84ACD0491761173E004ABE58 /* trawling.cpp in Sources */, + 84ACD04A1761173E004ABE58 /* wgtnet.cpp in Sources */, + 84ACD04B1761173E004ABE58 /* wikinet.cpp in Sources */, + 84ACD04C1761173E004ABE58 /* Makefile in Sources */, + 84ACD04D1761173E004ABE58 /* run-all-tests.cpp in Sources */, + 84ACD04E1761173E004ABE58 /* test-alg.cpp in Sources */, + 84ACD04F1761173E004ABE58 /* test-bfsdfs.cpp in Sources */, + 84ACD0501761173E004ABE58 /* test-cncom.cpp in Sources */, + 84ACD0511761173E004ABE58 /* test-file.cpp in Sources */, + 84ACD0521761173E004ABE58 /* test-ggen.cpp in Sources */, + 84ACD0531761173E004ABE58 /* test-gio.cpp in Sources */, + 84ACD0541761173E004ABE58 /* test-gviz.cpp in Sources */, + 84ACD0551761173E004ABE58 /* test-helper.cpp in Sources */, + 84ACD0561761173E004ABE58 /* test-subgraph.cpp in Sources */, + 84ACD0571761173E004ABE58 /* test-THash.cpp in Sources */, + 84ACD0581761173E004ABE58 /* test-THashSet.cpp in Sources */, + 84ACD0591761173E004ABE58 /* test-TNEANet.cpp in Sources */, + 84ACD05A1761173E004ABE58 /* test-TNEGraph.cpp in Sources */, + 84ACD05B1761173E004ABE58 /* test-TNGraph.cpp in Sources */, + 84ACD05C1761173E004ABE58 /* test-TNodeEDatNet.cpp in Sources */, + 84ACD05D1761173E004ABE58 /* test-TNodeEdgeNet.cpp in Sources */, + 84ACD05E1761173E004ABE58 /* test-TNodeNet.cpp in Sources */, + 84ACD05F1761173E004ABE58 /* test-triad.cpp in Sources */, + 84ACD0601761173E004ABE58 /* test-TStrPool.cpp in Sources */, + 84ACD0611761173E004ABE58 /* test-TSysTm.cpp in Sources */, + 84ACD0621761173E004ABE58 /* test-TUNGraph.cpp in Sources */, + 84ACD0631761173E004ABE58 /* demo-bfsdfs.cpp in Sources */, + 84ACD0641761173E004ABE58 /* demo-cncom.cpp in Sources */, + 84ACD0651761173E004ABE58 /* demo-ggen.cpp in Sources */, + 84ACD0661761173E004ABE58 /* demo-gio.cpp in Sources */, + 84ACD0671761173E004ABE58 /* demo-gviz.cpp in Sources */, + 84ACD0681761173E004ABE58 /* demo-hashvec-benchmark.cpp in Sources */, + 84ACD0691761173E004ABE58 /* demo-subgraph.cpp in Sources */, + 84ACD06A1761173E004ABE58 /* demo-THash.cpp in Sources */, + 84ACD06B1761173E004ABE58 /* demo-TNEANet.cpp in Sources */, + 84ACD06C1761173E004ABE58 /* demo-TNEGraph.cpp in Sources */, + 84ACD06D1761173E004ABE58 /* demo-TNGraph.cpp in Sources */, + 84ACD06E1761173E004ABE58 /* demo-TNodeEDatNet.cpp in Sources */, + 84ACD06F1761173E004ABE58 /* demo-TNodeEdgeNet.cpp in Sources */, + 84ACD0701761173E004ABE58 /* demo-TNodeNet.cpp in Sources */, + 84ACD0711761173E004ABE58 /* demo-topology-benchmark.cpp in Sources */, + 84ACD0721761173E004ABE58 /* demo-triad.cpp in Sources */, + 84ACD0731761173E004ABE58 /* demo-TUNGraph.cpp in Sources */, + 84ACD0741761173E004ABE58 /* Makefile in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 847482B116CD85D200AF3EF4 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + ARCHS = "$(ARCHS_STANDARD_64_BIT)"; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_SYMBOLS_PRIVATE_EXTERN = NO; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "${PROJECT_DIR}/swig-r"; + MACOSX_DEPLOYMENT_TARGET = 10.8; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + USER_HEADER_SEARCH_PATHS = "${PROJECT_DIR}/swig-r"; + }; + name = Debug; + }; + 847482B216CD85D200AF3EF4 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + ARCHS = "$(ARCHS_STANDARD_64_BIT)"; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "${PROJECT_DIR}/swig-r"; + MACOSX_DEPLOYMENT_TARGET = 10.8; + SDKROOT = macosx; + USER_HEADER_SEARCH_PATHS = "${PROJECT_DIR}/swig-r"; + }; + name = Release; + }; + 847482B416CD85D200AF3EF4 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEBUGGING_SYMBOLS = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 847482B516CD85D200AF3EF4 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; + 8488FEB416D20F8400C789B8 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 8488FEB516D20F8400C789B8 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; + 84FE86FB17209EC30099963A /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + DEBUGGING_SYMBOLS = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 84FE86FC17209EC30099963A /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 847482AE16CD85D200AF3EF4 /* Build configuration list for PBXProject "snap-python" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 847482B116CD85D200AF3EF4 /* Debug */, + 847482B216CD85D200AF3EF4 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 847482B316CD85D200AF3EF4 /* Build configuration list for PBXLegacyTarget "snap-python" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 847482B416CD85D200AF3EF4 /* Debug */, + 847482B516CD85D200AF3EF4 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 8488FEB316D20F8400C789B8 /* Build configuration list for PBXNativeTarget "docs" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 8488FEB416D20F8400C789B8 /* Debug */, + 8488FEB516D20F8400C789B8 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 84FE870317209EC30099963A /* Build configuration list for PBXLegacyTarget "swig-r" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 84FE86FB17209EC30099963A /* Debug */, + 84FE86FC17209EC30099963A /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 847482AB16CD85D200AF3EF4 /* Project object */; +} diff --git a/snap-python/source/dev/swig-r/Makefile b/snap-python/source/dev/swig-r/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..1abe19ed3341bb02a5e26b7d2cf89e02551d273a --- /dev/null +++ b/snap-python/source/dev/swig-r/Makefile @@ -0,0 +1,47 @@ +# +# Makefile for SWIG processing of SNAP +# + +# set the path to your SNAP directory here +SNAPROOT = ../../../snap + +include $(SNAPROOT)/Makefile.config + +SNAPDIR = $(SNAPROOT)/$(SNAP) +GLIBDIR = $(SNAPROOT)/$(GLIB) + +RINGODIR = ../../ringo/ringo-engine + +UNAME := $(shell uname) + +ifeq ($(UNAME), Linux) + # Linux flags + CXXFLAGS += -fPIC -shared -D__STDC_LIMIT_MACROS + LDFLAGS += -lrt +else ifeq ($(UNAME), Darwin) + # OS X flags + LDFLAGS += -lpython -dynamiclib +else ifeq ($(shell uname -o), Cygwin) + # Cygwin flags +endif + +#SWIGFILES = getassessment.cpp + +all: python + +python: Snap.o Engine.o jusnap.i + swig -python -c++ -w302,312,317,325,362,383,384,389,401,503,508,509 -O -D_CMPWARN -I$(SNAPDIR) -I$(GLIBDIR) -I$(RINGODIR) snap.i + g++ $(CXXFLAGS) -c snap_wrap.cxx $(SWIGFILES) -I$(SNAPDIR) -I$(GLIBDIR) -I$(RINGODIR) -I/usr/include/python2.6 -I/usr/include/python2.7 + g++ $(LDFLAGS) $(CXXFLAGS) snap_wrap.o Snap.o -o _snap.so + +#Engine.o: $(HEADER) $(CPP) $(CSNAP)/Snap.o +# $(CC) -c $(CXXFLAGS) Engine.cpp -I$(CSNAP) -I$(CGLIB) +# +#lib: Engine.o +# rm -f libengine.a +# ar -cvq libengine.a Engine.o + +Snap.o: + $(CC) $(CXXFLAGS) -c $(SNAPDIR)/Snap.cpp -I$(SNAPDIR) -I$(GLIBDIR) +clean: + rm -f *.o *_wrap.cxx _*.so *.pyc diff --git a/snap-python/source/dev/swig-r/getassessment.cpp b/snap-python/source/dev/swig-r/getassessment.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1330253eb0e04ed33f77646478b7606babda6f57 --- /dev/null +++ b/snap-python/source/dev/swig-r/getassessment.cpp @@ -0,0 +1,264 @@ +#include "Snap.h" + +// Graph type for random generation +typedef enum { + SmallWorld, /* Generates an Erdos-Renyi random graph. */ + BiPart, /* Bipartitite graph type. */ + PowerLaw, /* Power law graph. */ + PrefAttach, /* Scale-free graph using preferential model. */ + RMat, /* R-MAT */ + GraphMx +} GraphType; + +const char* const GraphAbbr[] = { + "sw", /* Generates an Erdos-Renyi random graph. */ + "bi", /* Bipartitite graph type. */ + "pow", /* Power law graph. */ + "pref", /* Scale-free graph using preferential model. */ + "rmat", /* R-MAT */ +}; + +const char* const GraphDesc[] = { + "Small World", /* Generates an Erdos-Renyi random graph. */ + "Bipartite", /* Bipartitite graph type. */ + "Power Law", /* Power law graph. */ + "Preferential Attach", /* Scale-free graph using preferential model. */ + "R-MAT", /* R-MAT */ +}; + +typedef enum { + Iteration, /* graph info */ + Triads, /* get triads */ + PlotDD, /* degree distribution */ + PlotCDD, /* cumulative degree */ + PlotHop, /* hop plot (diameter) */ + PlotWcc, /* distribution of weakly connected components */ + PlotScc, /* distribution of strongly connected components */ + PlotClustCoef, /* clustering coefficient */ + PlotSVal, /* singular values */ + PlotSVec, /* left and right singular vector */ + BFS, /* BFS Subset. */ + PlotMx +} PlotType; + +const char* const PlotAbbr[] = { + "iterations", /* basic graph info (e.g. iteration, triads) */ + "triads", /* triads */ + "DD", /* degree distribution */ + "CDD", /* cumulative degree */ + "HOP", /* hop plot (diameter) */ + "Wcc", /* distribution of weakly connected components */ + "Scc", /* distribution of strongly connected components */ + "ClustCoef", /* clustering coefficient */ + "SVal", /* singular values */ + "SVec", /* left and right singular vector */ + "BFS", /* BFS Subset. */ +}; + +const char* const PlotDesc[] = { + "node/edge iteration", + "triads", + "dgree distribution", + "cumulative degree", + "hop plot (diameter)", + "distribution of weakly connected components", + "distribution of strongly connected components", + "clustering coefficient", + "singular values", + "left and right singular vector", + "Breadth First Search (subset)", +}; + +#define NUM_NODES_BFS 10 + +using namespace TSnap; + +typedef TVec TIntV; +typedef TVec TIntIntVV; + +template +PGraph GenSyntheticGraph(const int& Nodes, const int Deg, const int Delta) { + PGraph Graph = PGraph::TObj::New(); + Graph->Reserve(Nodes, Nodes*Deg); + for (int n = 0; n < Nodes; n++) { + Graph->AddNode(n); } + for (int n1 = 0; n1 < Nodes; n1++) { + for (int d = 0; d < Deg; d++) { + // When Delta=10 and Deg=3, create edges from n1 to n1+10, n1+11, n1+12 + int n2 = (n1+d+Delta)%Nodes; + if (n1 != n2) { Graph->AddEdge(n1, n2); } + } + } + return Graph; +} + + +template +void RunBasicInfo(const PGraph& Graph, const TStr& Desc, const TStr& OutFNm) { + int BiDirEdges=0, ZeroNodes=0, ZeroInNodes=0, ZeroOutNodes=0, SelfEdges=0, NonZIODegNodes=0; + THash UniqDirE, UniqUnDirE; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { + if (NI.GetDeg()==0) ZeroNodes++; + if (NI.GetInDeg()==0) ZeroInNodes++; + if (NI.GetOutDeg()==0) ZeroOutNodes++; + if (NI.GetInDeg()!=0 && NI.GetOutDeg()!=0) NonZIODegNodes++; + const int NId = NI.GetId(); + for (int edge = 0; edge < NI.GetOutDeg(); edge++) { + const int DstNId = NI.GetOutNId(edge); + if (Graph->IsEdge(DstNId, NId)) BiDirEdges++; + if (NId == DstNId) SelfEdges++; + UniqDirE.AddKey(TIntPr(NId, DstNId)); + UniqUnDirE.AddKey(TIntPr(TInt::GetMn(NId, DstNId), TInt::GetMx(NId, DstNId))); + } + } +} + +template +void RunTriads(const PGraph& Graph) { + int64 Closed=0, Open=0; + GetTriads(Graph, Closed, Open); +} + +template +void RunClustCf(const PGraph& Graph) { + TFltPrV DegToCCfV; + int64 ClosedTriads, OpenTriads; + const double CCF = GetClustCf(Graph, DegToCCfV, ClosedTriads, OpenTriads); + #pragma unused(CCF) +} + +template +void RunBFS(const PGraph& Graph) { + + // Get BFS tree + for (int i=0; i < NUM_NODES_BFS; i++) { + int StartNId = Graph->GetRndNId(); + GetBfsTree(Graph, StartNId, true, true); + } +} + +template +void RunCalculations(const PGraph& Graph, PlotType PType) { + + TStr OutFNm = PlotAbbr[PType], Desc = PlotDesc[PType]; + const int SingularVals = Graph->GetNodes()/2 > 200 ? 200 : + Graph->GetNodes()/2; +// printf("Calculating '%s'\n", PlotDesc[PType]); + switch (PType) { + case Iteration: + RunBasicInfo(Graph, Desc, OutFNm); + break; + + case Triads: + RunTriads(Graph); + break; + + case PlotDD: + PlotOutDegDistr(Graph, OutFNm, Desc, false, false); + PlotInDegDistr(Graph, OutFNm, Desc, false, false); + break; + + case PlotCDD: + PlotOutDegDistr(Graph, OutFNm, Desc, true, false); + PlotInDegDistr(Graph, OutFNm, Desc, true, false); + break; + + case PlotHop: + PlotHops(Graph, OutFNm, Desc, false, 32); + break; + + case PlotWcc: + PlotWccDistr(Graph, OutFNm, Desc); + break; + + case PlotScc: + PlotSccDistr(Graph, OutFNm, Desc); + break; + + case PlotClustCoef: + RunClustCf(Graph); + break; + + case PlotSVal: + PlotSngValRank(ConvertGraph(Graph, true), SingularVals, + OutFNm, Desc); + break; + + case PlotSVec: + PlotSngVec(ConvertGraph(Graph, true), OutFNm, Desc); + break; + + case BFS: + RunBFS(Graph); + break; + + default: + break; + } +} + +double GetStats(int NNodes, int NEdges, PlotType PType, GraphType RType) { + + TExeTm ExeTm; + printf("Timing '%s'\n", PlotDesc[PType]); + + int StartTime = clock(); + + PNGraph GN; + PUNGraph GUn; + + switch (RType) { + case SmallWorld: + GN = GenRndGnm(NNodes, NEdges); + RunCalculations(GN, PType); + break; + + case BiPart: + break; + + case PowerLaw: + break; + + case PrefAttach: +// printf("Generating preferential attachment graph for %d nodes, %d edges\n", NNodes, 5); + GUn = GenPrefAttach(NNodes, 5); + RunCalculations(GUn, PType); + break; + + case RMat: +// printf("Generating R-MAT for %d nodes, %d edges\n", +// NNodes, NEdges); + GN = GenRMat(NNodes, NEdges, 0.40, 0.25, 0.2); + RunCalculations(GN, PType); + break; + + default: + break; + } + + double Elapsed = double(clock() - StartTime) / double(CLOCKS_PER_SEC); +// printf("\nrun time: %s (%s)\n", ExeTm.GetTmStr(), TSecTm::GetCurTm().GetTmStr().CStr()); +// printf("Elapsed = %.3f\n", Elapsed); + return Elapsed; +} + +//template +//PGraph GenerateGraph(const int NNodes, const int NEdges) { +// +//} + +const char * GetAttributeDesc(PlotType PType) { + return PlotDesc[PType]; +} + +const char * GetAttributeAbbr(PlotType PType) { + return PlotAbbr[PType]; +} + +const char * GetGraphDesc(GraphType GType) { + return GraphDesc[GType]; +} + +const char * GetGraphAbbr(GraphType GType) { + return GraphAbbr[GType]; +} diff --git a/snap-python/source/dev/swig-r/goodgraph.cpp b/snap-python/source/dev/swig-r/goodgraph.cpp new file mode 100644 index 0000000000000000000000000000000000000000..19735088ca1d4dc620842baba6f4821e597e9923 --- /dev/null +++ b/snap-python/source/dev/swig-r/goodgraph.cpp @@ -0,0 +1,82 @@ +#include "Python.h" +#include "Snap.h" + +using namespace TSnap; + +typedef TVec TIntV; +typedef TVec TIntIntVV; + +TUNGraph TPrGraph(PUNGraph G) { + return *G; +}; + +int accept_array(int array[]) { + + for (int i=0; i < 10; i++) + printf("array[%d] = %d\n", i, array[i]); + + return 0; +} + +template +double PercentDegree(const PGraph& Graph, const int Threshold=0) { + + int Cnt = 0; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) + { + if (NI.GetDeg() >= Threshold) Cnt++; + } + + return (double)Cnt / (double) Graph->GetNodes(); +} + +template +int NodesGTEDegree(const PGraph& Graph, const int Threshold=0) { + + int Cnt = 0; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); + NI++) + { + if (NI.GetDeg() >= Threshold) Cnt++; + } + + return Cnt; +} + +template +int MxDegree(const PGraph& Graph) { + + int MaxDeg = 0; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { + if (NI.GetDeg() > MaxDeg) { + MaxDeg = NI.GetDeg(); + } + } + + return MaxDeg; +} + +//template +//bool WriteGraph(const PGraph& Graph, const TStr &OutFNm) { +// +// TFOut FOut(OutFNm); +// FOut.Save(GetNodes()); +//} +// +//template +//PGraph LoadGraph(const TStr& FName) { +//} + +template +double PercentMxWcc(const PGraph& Graph) { + + return GetMxWccSz(Graph); +} + +template +double PercentMxScc(const PGraph& Graph) { + + PGraph MxSccSz = GetMxScc(Graph); + + return (double) MxSccSz->GetNodes() / (double) Graph->GetNodes(); +} diff --git a/snap-python/source/dev/swig-r/pneanet.i b/snap-python/source/dev/swig-r/pneanet.i new file mode 100644 index 0000000000000000000000000000000000000000..3e728953434306fddea4a5509dd682165115a0c2 --- /dev/null +++ b/snap-python/source/dev/swig-r/pneanet.i @@ -0,0 +1,174 @@ +// pneanet.i +// Templates for SNAP Ringo +// + +/* + Instanstiates templates from SNAP for inclusion in RINGO. + Note in Vim, this replaces SNAP Template headers: + + :%s#^template.* \S* \([^(]*\).*#%template(\1) TSnap::\1;#gc + :%s#^///.*\n:##g +*/ + +%extend TNEANet { + TNEANetNodeI BegNI() { + return TNEANetNodeI($self->BegNI()); + } + TNEANetNodeI EndNI() { + return TNEANetNodeI($self->EndNI()); + } + + TNEANetEdgeI BegEI() { + return TNEANetEdgeI($self->BegEI()); + } + TNEANetEdgeI EndEI() { + return TNEANetEdgeI($self->EndEI()); + } + + TNEANetAIntI BegNAIntI(const TStr& attr) { + return TNEANetAIntI($self->BegNAIntI(attr)); + } + TNEANetAIntI EndNAIntI(const TStr& attr) { + return TNEANetAIntI($self->EndNAIntI(attr)); + } + + TNEANetAStrI BegNAStrI(const TStr& attr) { + return TNEANetAStrI($self->BegNAStrI(attr)); + } + TNEANetAStrI EndNAStrI(const TStr& attr) { + return TNEANetAStrI($self->EndNAStrI(attr)); + } + + TNEANetAFltI BegNAFltI(const TStr& attr) { + return TNEANetAFltI($self->BegNAFltI(attr)); + } + TNEANetAFltI EndNAFltI(const TStr& attr) { + return TNEANetAFltI($self->EndNAFltI(attr)); + } + + TNEANetAIntI BegEAIntI(const TStr& attr) { + return TNEANetAIntI($self->BegEAIntI(attr)); + } + TNEANetAIntI EndEAIntI(const TStr& attr) { + return TNEANetAIntI($self->EndEAIntI(attr)); + } + + TNEANetAStrI BegEAStrI(const TStr& attr) { + return TNEANetAStrI($self->BegEAStrI(attr)); + } + TNEANetAStrI EndEAStrI(const TStr& attr) { + return TNEANetAStrI($self->EndEAStrI(attr)); + } + + TNEANetAFltI BegEAFltI(const TStr& attr) { + return TNEANetAFltI($self->BegEAFltI(attr)); + } + TNEANetAFltI EndEAFltI(const TStr& attr) { + return TNEANetAFltI($self->EndEAFltI(attr)); + } + +}; + +// Convert a directed graph to a multi-edge attribute graph +//%template(ConvertGraphToPNEANet) ConvertGraph; + +// Use PNEANet as default function name. +%template(PercentDegree) PercentDegree; +%template(PercentMxWcc) PercentMxWcc; +%template(PercentMxScc) PercentMxScc; + +%template(LoadEdgeList) TSnap::LoadEdgeList; +%template(PrintGraphStatTable) PrintGraphStatTable; +%template(GenRndGnm) TSnap::GenRndGnm; + +%template(NodesGTEDegree) NodesGTEDegree; +%template(MxDegree) MxDegree; +%template(MxSccSz) TSnap::GetMxScc; +%template(MxWccSz) TSnap::GetMxWccSz; +%template(MxDegree) MxDegree; +// End Basic Directed Graphs + + +// Basic PNEANets +%template(PNEANet) TPt< TNEANet >; +%template(GenRndGnm) TSnap::GenRndGnm; +%template(NodesGTEDegree) NodesGTEDegree; +%template(MxDegree) MxDegree; + + +// cncom.h - PNEANet +%template(GetNodeWcc) TSnap::GetNodeWcc; +%template(IsConnected) TSnap::IsConnected; +%template(IsWeaklyConn) TSnap::IsWeaklyConn; +%template(GetWccSzCnt) TSnap::GetWccSzCnt; +%template(GetWccs) TSnap::GetWccs; +%template(GetSccSzCnt) TSnap::GetSccSzCnt; +%template(GetSccs) TSnap::GetSccs; +%template(GetMxWccSz) TSnap::GetMxWccSz; + +%template(GetMxWcc) TSnap::GetMxWcc; +%template(GetMxScc) TSnap::GetMxScc; +%template(GetMxBiCon) TSnap::GetMxBiCon; + + +// alg.h - PNEANet +%template(CntInDegNodes) TSnap::CntInDegNodes; +%template(CntOutDegNodes) TSnap::CntOutDegNodes; +%template(CntDegNodes) TSnap::CntDegNodes; +%template(CntNonZNodes) TSnap::CntNonZNodes; +%template(CntEdgesToSet) TSnap::CntEdgesToSet; + +%template(GetMxDegNId) TSnap::GetMxDegNId; +%template(GetMxInDegNId) TSnap::GetMxInDegNId; +%template(GetMxOutDegNId) TSnap::GetMxOutDegNId; + +%template(GetInDegCnt) TSnap::GetInDegCnt; +%template(GetOutDegCnt) TSnap::GetOutDegCnt; +%template(GetDegCnt) TSnap::GetDegCnt; +%template(GetDegSeqV) TSnap::GetDegSeqV; + +%template(GetNodeInDegV) TSnap::GetNodeInDegV; +%template(GetNodeOutDegV) TSnap::GetNodeOutDegV; + +%template(CntUniqUndirEdges) TSnap::CntUniqUndirEdges; +%template(CntUniqDirEdges) TSnap::CntUniqDirEdges; +%template(CntUniqBiDirEdges) TSnap::CntUniqBiDirEdges; +%template(CntSelfEdges) TSnap::CntSelfEdges; + + +// bfsdfs.h - PNEANet +%template(GetBfsTree) TSnap::GetBfsTree; +%template(GetSubTreeSz) TSnap::GetSubTreeSz; +%template(GetNodesAtHop) TSnap::GetNodesAtHop; +%template(GetNodesAtHops) TSnap::GetNodesAtHops; +// Shortest paths +%template(GetShortPath) TSnap::GetShortPath; +// Diameter +%template(GetBfsFullDiam) TSnap::GetBfsFullDiam; +%template(GetBfsEffDiam) TSnap::GetBfsEffDiam; + + +// drawgviz.h +%template(DrawGViz) TSnap::DrawGViz; + +// triad.h - PNEANet +%template(GetClustCf) TSnap::GetClustCf; +%template(GetNodeClustCf) TSnap::GetNodeClustCf; + +%template(GetTriads) TSnap::GetTriads; +%template(GetTriadEdges) TSnap::GetTriadEdges; +//%template(GetNodeTriads) TSnap::GetNodeTriads; +%template(GetTriadParticip) TSnap::GetTriadParticip; + +%template(GetCmnNbrs) TSnap::GetCmnNbrs; +//%template(GetLen2Paths) TSnap::GetLen2Paths; + + +// cmty.h - PNEANet +%template(GetModularity) TSnap::GetModularity; +%template(GetEdgesInOut) TSnap::GetEdgesInOut; + + +// anf.h - PNEANet +%template(GetAnf) TSnap::GetAnf; +%template(GetAnfEffDiam) TSnap::GetAnfEffDiam; diff --git a/snap-python/source/dev/swig-r/pngraph.i b/snap-python/source/dev/swig-r/pngraph.i new file mode 100644 index 0000000000000000000000000000000000000000..55b844295eb6592681d9e1416b7c6504f36dd66d --- /dev/null +++ b/snap-python/source/dev/swig-r/pngraph.i @@ -0,0 +1,61 @@ +// pngraph.i +// Templates for SNAP + +// Note: This file does not include all SNAP templates. + +%extend TNGraph { + TNGraphNodeI BegNI() { + return TNGraphNodeI($self->BegNI()); + } + TNGraphNodeI EndNI() { + return TNGraphNodeI($self->EndNI()); + } + TNGraphEdgeI BegEI() { + return TNGraphEdgeI($self->BegEI()); + } + TNGraphEdgeI EndEI() { + return TNGraphEdgeI($self->EndEI()); + } +}; + +%template(PercentDegree_PNGraph) PercentDegree; +%template(PercentMxWcc_PNGraph) PercentMxWcc; +%template(PercentMxScc_PNGraph) PercentMxScc; + +%template(LoadEdgeList_PNGraph) TSnap::LoadEdgeList; +%template(PrintGraphStatTable_PNGraph) PrintGraphStatTable; +%template(GenRndGnm_PNGraph) TSnap::GenRndGnm; + +%template(NodesGTEDegree_PNGraph) NodesGTEDegree; +%template(MxDegree_PNGraph) MxDegree; +%template(MxSccSz_PNGraph) TSnap::GetMxScc; +%template(MxWccSz_PNGraph) TSnap::GetMxWccSz; +%template(MxDegree_PNGraph) MxDegree; + +// cncom.h - PNGraph +%template(GetNodeWcc_PNGraph) TSnap::GetNodeWcc; +%template(IsConnected_PNGraph) TSnap::IsConnected; +%template(IsWeaklyConn_PNGraph) TSnap::IsWeaklyConn; +%template(GetWccSzCnt_PNGraph) TSnap::GetWccSzCnt; +%template(GetWccs_PNGraph) TSnap::GetWccs; +%template(GetSccSzCnt_PNGraph) TSnap::GetSccSzCnt; +%template(GetSccs_PNGraph) TSnap::GetSccs; +%template(GetMxWccSz_PNGraph) TSnap::GetMxWccSz; + +%template(GetMxWcc_PNGraph) TSnap::GetMxWcc; +%template(GetMxScc_PNGraph) TSnap::GetMxScc; +%template(GetMxBiCon_PNGraph) TSnap::GetMxBiCon; + +// bfsdfs.h - PNGraph +%template(GetBfsTree_PNGraph) TSnap::GetBfsTree; +%template(GetSubTreeSz_PNGraph) TSnap::GetSubTreeSz; +%template(GetNodesAtHop_PNGraph) TSnap::GetNodesAtHop; +%template(GetNodesAtHops_PNGraph) TSnap::GetNodesAtHops; +// Shortest paths +%template(GetShortPath_PNGraph) TSnap::GetShortPath; +// Diameter +%template(GetBfsFullDiam_PNGraph) TSnap::GetBfsFullDiam; +%template(GetBfsEffDiam_PNGraph) TSnap::GetBfsEffDiam; + +// drawgviz.h +%template(DrawGViz_PNGraph) TSnap::DrawGViz; diff --git a/snap-python/source/dev/swig-r/printgraph.h b/snap-python/source/dev/swig-r/printgraph.h new file mode 100644 index 0000000000000000000000000000000000000000..1f24daa60d20ea19926070f81827c834bf4b1240 --- /dev/null +++ b/snap-python/source/dev/swig-r/printgraph.h @@ -0,0 +1,51 @@ + +template +void PrintGraphStatTable(const PGraph& G, TStr OutFNm, TStr Desc="") { + TFltPrV DegCCfV; + int64 ClosedTriads, OpenTriads; + int FullDiam; + double EffDiam; + TSnap::PrintInfo(G, OutFNm); + TExeTm ExeTm; printf("C"); + const double CCF = TSnap::GetClustCf(G, DegCCfV, ClosedTriads, OpenTriads); + printf("[%s]D", ExeTm.GetStr()); + TSnap::GetBfsEffDiam(G, 1000, false, EffDiam, FullDiam); + printf("[%s]CC", ExeTm.GetStr()); + PGraph WCC = TSnap::GetMxWcc(G); + PGraph SCC = TSnap::GetMxScc(G); + printf("[%s]\n", ExeTm.GetStr()); + FILE* F = stdout; + if (! OutFNm.Empty()) { + F = fopen(TStr::Fmt("%s.html", OutFNm.CStr()).CStr(), "wt"); } + fprintf(F, "\n"); + fprintf(F, "\n"); + fprintf(F, " \n"); + fprintf(F, " \n", G->GetNodes()); + fprintf(F, " \n", G->GetEdges()); + fprintf(F, " \n", WCC->GetNodes(), WCC->GetNodes()/double(G->GetNodes())); + fprintf(F, " \n", WCC->GetEdges(), WCC->GetEdges()/double(G->GetEdges())); + fprintf(F, " \n", SCC->GetNodes(), SCC->GetNodes()/double(G->GetNodes())); + fprintf(F, " \n", SCC->GetEdges(), SCC->GetEdges()/double(G->GetEdges())); + fprintf(F, " \n", CCF); + fprintf(F, " \n", TUInt64(ClosedTriads).GetStr().CStr()); + fprintf(F, " \n", ClosedTriads/double(ClosedTriads+OpenTriads)); + fprintf(F, " \n", FullDiam); + fprintf(F, " \n", EffDiam); + fprintf(F, "
Dataset statistics
Nodes %d
Edges %d
Nodes in largest WCC %d (%.3f)
Edges in largest WCC %d (%.3f)
Nodes in largest SCC %d (%.3f)
Edges in largest SCC %d (%.3f)
Average clustering coefficient %.4f
Number of triangles %s
Fraction of closed triangles %.4g
Diameter (longest shortest path) %d
90-percentile effective diameter %.2g
\n"); + fprintf(F, "
\n"); + if (! OutFNm.Empty()) { + fprintf(F, "\n\n"); + fprintf(F, "\n"); + fprintf(F, " \n"); + fprintf(F, " \n"); + fprintf(F, "\n"); + fprintf(F, "\n"); + fprintf(F, " \n", OutFNm.CStr(), OutFNm.CStr()); + fprintf(F, " \n", Desc.CStr()); + fprintf(F, "\n"); + fprintf(F, "
FileDescription
%s.txt.gz%s
\n"); + fclose(F); + TSnap::SaveEdgeList(G, OutFNm+".txt", Desc); + } +} + diff --git a/snap-python/source/dev/swig-r/pungraph.i b/snap-python/source/dev/swig-r/pungraph.i new file mode 100644 index 0000000000000000000000000000000000000000..b911b5ecb327a1f69c8d648b77f028efad4644ae --- /dev/null +++ b/snap-python/source/dev/swig-r/pungraph.i @@ -0,0 +1,33 @@ +// pungraph.i +// Templates for SNAP + +// Note: This file does not include all SNAP templates. + +%extend TUNGraph { + TUNGraphNodeI BegNI() { + return TUNGraphNodeI($self->BegNI()); + } + TUNGraphNodeI EndNI() { + return TUNGraphNodeI($self->EndNI()); + } + TUNGraphEdgeI BegEI() { + return TUNGraphEdgeI($self->BegEI()); + } + TUNGraphEdgeI EndEI() { + return TUNGraphEdgeI($self->EndEI()); + } +}; + +// Basic Undirected Graphs +%template(PUNGraph) TPt< TUNGraph >; + +%template(LoadEdgeList_PUNGraph) TSnap::LoadEdgeList; +%template(PrintGraphStatTable_PUNGraph) PrintGraphStatTable; + +%template(NodesGTEDegree_PUNGraph) NodesGTEDegree; +%template(GenRndGnm_PUNGraph) TSnap::GenRndGnm; +%template(MxSccSz_PUNGraph) TSnap::GetMxScc; +%template(MxWccSz_PUNGraph) TSnap::GetMxWccSz; +%template(MxDegree_PUNGraph) MxDegree; +// End Basic Undirected Graphs + diff --git a/snap-python/source/dev/swig-r/snap.i b/snap-python/source/dev/swig-r/snap.i new file mode 100644 index 0000000000000000000000000000000000000000..a135ff1c5229b846f0aa9d9f84d89181509ae81e --- /dev/null +++ b/snap-python/source/dev/swig-r/snap.i @@ -0,0 +1,151 @@ +// snap.i + +// The multi-attribute network graph type, PNEANet is instantiated, along +// with standard SNAP functions. + +%module snap +%{ + +#include "Snap.h" + +#include "Engine.h" +#include "snapswig.h" + +#include "printgraph.h" +#include "snap_types.h" +#include "goodgraph.cpp" + +%} + +%module test + +%feature("autodoc", "3"); + +%ignore TOnExeStop; +%ignore TPt::TPt; +%ignore TPt::LoadXml; +%ignore TPt::SaveXml; +%ignore TPt::operator==; +%ignore TPt::operator!=; +%ignore TPt::operator<; +%ignore TPt::GetPrimHashCd; +%ignore TPt::GetSecHashCd; +%ignore TPt::Clone; + +%ignore TChA::LoadXml; +%ignore TMem::LoadXml; + +%ignore GetStr; + +%ignore TFInOut; +%ignore TFRnd; +%ignore TFile::Copy; +%ignore TFile::GetLastAccessTm; +%ignore TFile::GetLastWriteTm; +%ignore TFile::GetCreateTm; +%ignore TFile::GetSize; + +%ignore TBPGraph::HasFlag(const TGraphFlag& Flag) const; +%ignore TNEGraph::GetSmallGraph(); +%ignore TNEANet::GetSmallGraph(); +%ignore TBPGraph::GetEI(int const&) const; + +%ignore TNGraph::GetEI(int const&) const; +%ignore TUNGraph::GetEI(int const&) const; +%ignore TNEANet::GetEI(int const&) const; + +%ignore TVec, int>::Add; +%ignore TVec, int>::AddMerged; + +%ignore TVec::Add; +%ignore TVec::AddMerged; + + +%ignore THash< TInt, TVec< TInt, int > >::AddDat; +%ignore THash< TInt, TVec< TInt, int > >::HashPrimeT; +%ignore THash< TInt, TVec< TInt, int > >::AddDatId; + +%ignore THash< TInt, TInt, TDefaultHashFunc >::HashPrimeT; +%ignore THash< TInt, TInt, TDefaultHashFunc >::AddDatId; +%ignore THash< TInt, TInt>::HashPrimeT; + +// SNAP Library +// snap-core +%include "alg.h" +%include "anf.h" +%include "bfsdfs.h" +%include "bd.h" +%include "centr.h" +%include "cmty.h" +%include "cncom.h" +%include "ff.h" +%include "fl.h" +%include "graph.h" +%include "gsvd.h" +%include "gio.h" +%include "gviz.h" +%include "hash.h" +%include "kcore.h" +%include "ggen.h" +%include "subgraph.h" +%include "util.h" +%include "triad.h" + +#define GLib_UNIX +// glib-core +%include "ds.h" +%include "dt.h" + +%include "Engine.h" + +%extend TVec { + + TSizeTy Add(int Val) { + return $self->Add(TInt(Val)); + } + + TSizeTy AddMerged(int Val) { + return $self->AddMerged(TInt(Val)); + } +}; + +%extend THash { + int AddKey(int Val) { + return $self->AddKey(TInt(Val)); + } + int IsKey(int Val) { + return $self->IsKey(TInt(Val)); + } + TDat& GetDat(int Val) { + return $self->GetDat(TInt(Val)); + } + TDat& AddDat(int Key, int Val) { + return $self->AddDat(TInt(Key),TInt(Val)); + } +} + +//%extend TAFltI { +// TFlt GetDat(int val) { const { return HI[0]; } +// +// +//} + +%template(TIntV) TVec< TInt, int >; +%template(TIntIntVV) TVec< TVec< TInt, int >, int >; +%template(TIntIntVH) THash< TInt, TVec< TInt, int > >; +%template(TIntH) THash; +%template(TIntHI) THashKeyDatI < TInt, TInt >; + +%template(TStrV) TVec< TStr, int >; + +// Python-SNAP conversion typemaps +%include "snapswig.h" +%include "goodgraph.cpp" +%include "printgraph.h" +%include "snap_types.i" + +// For TNEANet +%include "network.h" + +/* Graph templates - include other SWIG interface types here. */ +%include "pneanet.i" diff --git a/snap-python/source/dev/swig-r/snap_types.h b/snap-python/source/dev/swig-r/snap_types.h new file mode 100644 index 0000000000000000000000000000000000000000..d35c5ae62c5dd688300b2233a18963ea91b67888 --- /dev/null +++ b/snap-python/source/dev/swig-r/snap_types.h @@ -0,0 +1,46 @@ +#include "Snap.h" + +void print_array(int *x, int length) { + for (int i = 0; i < length; i++) + printf("x[%d] = %d\n", i, x[i]); +} + +TFltV PyTFltV(double x[10]) { + + TFltV V; + for (int i = 0; i < 10; i++) { + V.Add(x[i]); + } + + return V; +} + +TIntV PyToTIntV (int *array, int length) { + + TIntV V; + for (int i = 0; i < length; i++) { + //printf("Adding array[%d] = %d\n", i, array[i]); + V.Add(array[i]); + } + + return V; +} + +int count(char *str, int len, char c) { + int sum = 0; + for (int i = 0; i < len; i++) { + if (str[i] == c) + sum++; + } + return sum; +} + +//void TIntVToPy (TIntV originalList, TIntV snapList, int& len) { +void TIntVToPy (TIntV originalList, TIntV *OutValue) { + + printf("BEFORE: Original TIntV list size to %d\n", originalList.Len()); + *OutValue = originalList; + printf("BEFORE: New TIntV list size = %d\n", OutValue->Len()); + +} + diff --git a/snap-python/source/dev/swig-r/snap_types.i b/snap-python/source/dev/swig-r/snap_types.i new file mode 100644 index 0000000000000000000000000000000000000000..9ccf613a3d2b5bb7fbe38306644119f24a129b8a --- /dev/null +++ b/snap-python/source/dev/swig-r/snap_types.i @@ -0,0 +1,156 @@ +// snap_types.i +// +// Provides an interface between Python types (lists, strings) and SNAP. +// +%typemap(in) (char *str, int len) { + $1 = PyString_AsString($input); /* char *str */ + $2 = PyString_Size($input); /* int len */ +} + +// Create type for fixed-size Python lists of doubles. +%typemap(in) double [ANY] (double temp[$1_dim0]) { + int i; + if (!PySequence_Check($input)) { + PyErr_SetString(PyExc_ValueError,"Expected a sequence"); + return NULL; + } + if (PySequence_Length($input) != $1_dim0) { + PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements"); + return NULL; + } + for (i = 0; i < $1_dim0; i++) { + PyObject *o = PySequence_GetItem($input,i); + if (PyNumber_Check(o)) { + temp[i] = (double) PyFloat_AsDouble(o); + } else { + PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); + return NULL; + } + } + $1 = temp; +} + +// Create type for Python fixed-size lists of integers. +%typemap(in) int[ANY] (int temp[$1_dim0]) { + int i; + if (!PySequence_Check($input)) { + PyErr_SetString(PyExc_ValueError,"Expected a sequence"); + return NULL; + } + if (PySequence_Length($input) != $1_dim0) { + PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements"); + return NULL; + } + for (i = 0; i < $1_dim0; i++) { + PyObject *o = PySequence_GetItem($input,i); + if (PyNumber_Check(o)) { + temp[i] = (int) PyInt_AsLong(o); + } else { + PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); + return NULL; + } + } + $1 = temp; +} + +// Translate Python strings to SNAP TStr +//%typemap(in) const TStr& attr { +// printf("Converting %s\n", PyString_AsString($input)); +// TStr S(PyString_AsString($input)); +// $1 = &S; +//} + +%typemap(in) TStr defaultValue { + TStr S(PyString_AsString($input)); + $1 = S; +} + +// Translate Python ints to TInt +%typemap(in) const TInt& value { + TInt I = PyInt_AsLong($input); + $1 = &I; +} + +%typemap(in) TInt defaultValue { + TInt I = PyInt_AsLong($input); + $1 = I; +} + +%typemap(in) TInt& NId { + TInt I = PyInt_AsLong($input); + $1 = &I; +} + +// Translate Python floats to TInt +%typemap(in) const TFlt &value { + TFlt F = PyFloat_AsDouble($input); + $1 = &F; +} + +%typemap(in) TFlt defaultValue { + TFlt F = PyFloat_AsDouble($input); + $1 = F; +} + +// Slow but safe. Create type for Python variable-size lists of integers (must keep argument name or create typemap. +%typemap(in) (int *arraySlow, int lengthSlow) { + int i; + int length = PySequence_Length($input); + int *temp = (int *) malloc(length*sizeof(int)); + if (!PySequence_Check($input)) { + PyErr_SetString(PyExc_ValueError,"Expected a sequence"); + return NULL; + } + for (i = 0; i < length; i++) { + PyObject *o = PySequence_GetItem($input,i); + if (PyNumber_Check(o)) { + temp[i] = (int) PyInt_AsLong(o); + } else { + PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); + return NULL; + } + } + $1 = temp; + $2 = length; +} + +// Fast. Create type for Python variable-size lists of integers (must keep argument name or create typemap. +%typemap(in) (int *array, int length) { + int i; + PyObject* seq = PySequence_Fast($input, "expected a sequence"); + int length = PySequence_Size($input); + int *temp = (int *) malloc(length*sizeof(int)); + for (i = 0; i < length; i++) { + temp[i] = (int) PyInt_AsLong(PySequence_Fast_GET_ITEM(seq, i)); + } + Py_DECREF(seq); + $1 = temp; + $2 = length; +} +%typemap(freearg) (int *array, int length) { + if ($1) free($1); +} + + +// Convert an TIntV to a Python list + +%module outarg + +%typemap(argout) TIntV *OutValue { + $result = PyList_New($1->Len()); + for (int i = 0; i < $1->Len(); ++i) { + PyList_SetItem($result, i, PyInt_FromLong((*$1)[i])); + } + delete $1; // Avoid a leak since you called new +} + +%typemap(in,numinputs=0) TIntV *OutValue(TIntV temp) { + $1 = &temp; +} + + +// Rename argument example. +%typemap(in) (char *buffer, int size) = (char *str, int len); + +%include "snap_types.h" + diff --git a/snap-python/source/dev/swig-r/snappy.py b/snap-python/source/dev/swig-r/snappy.py new file mode 100644 index 0000000000000000000000000000000000000000..e96d836a7c26c61de96e14c517fdcfba52f79191 --- /dev/null +++ b/snap-python/source/dev/swig-r/snappy.py @@ -0,0 +1,59 @@ +#!/usr/bin/python +# snappy.py +# +# Author: Nick Shelly, Spring 2013 +# Description: +# - Loads SNAP as a Python module. +# - Wraps SNAP functions to make it easier to implement +# - User-friendly SNAP framework, which allows basic Python primitives. +# +# Note: Uses Python format when possible (lower-case 'open'), SNAP-otherise. + +import os +import sys +import unittest + +sys.path.append("../swig-r") + +from snap import * + +# Pass snap type through +def AddIntAttrN(attr, defaultValue=0): + + TNEANet.AddIntAttrN(TStr(attr), defaultValue) + +TNEANet.AddIntAttrN = AddIntAttrN + + +def FIn(FName): + + return TFIn(TStr(FName)) + +def FOut(FName): + + return TFOut(TStr(FName)) + +def Load(FName): + """ + Opens graph file and returns graph. + """ + + print "In load of snappy" + f = TFIn(TStr(FName)) + return snap.Load(f) + + +def Save(Graph, FName): + """ + Saves graph file (as directed, undirected or multi-edge). + """ + + FOut = FOut(FName) + Graph.__ref__().Save(FOut) + FOut.Flush() + +# Convert from Python vector to Snap int + +def GetWccs(G, V): + + G = snap.PNGraph() \ No newline at end of file diff --git a/snap-python/source/dev/swig-r/snapswig.h b/snap-python/source/dev/swig-r/snapswig.h new file mode 100644 index 0000000000000000000000000000000000000000..ca43681470194e7566e15f8da7b48fc46af646f0 --- /dev/null +++ b/snap-python/source/dev/swig-r/snapswig.h @@ -0,0 +1,243 @@ +class TNGraphNodeI { +private: + TNGraph::TNodeI NI; +public: + TNGraphNodeI() : NI() { } + TNGraphNodeI(const TNGraph::TNodeI& NodeI) : NI(NodeI) { } + TNGraphNodeI& operator = (const TNGraph::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TNGraphNodeI& operator++ (int) { NI++; return *this; } + TNGraphNodeI& Next() { NI++; return *this; } + bool operator < (const TNGraphNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TNGraphNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TNGraph::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TNGraph::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TNGraph::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TNGraphEdgeI { +private: + TNGraph::TEdgeI EI; +public: + TNGraphEdgeI() : EI() { } + TNGraphEdgeI(const TNGraph::TEdgeI& EdgeI) : EI(EdgeI) { } + TNGraphEdgeI& operator = (const TNGraph::TEdgeI& EdgeI) { EI = EdgeI; return *this; } + /// Increment iterator. + TNGraphEdgeI& operator++ (int) { EI++; return *this; } + TNGraphEdgeI& Next() { EI++; return *this; } + bool operator < (const TNGraphEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TNGraphEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +class TUNGraphNodeI { +private: + TUNGraph::TNodeI NI; +public: + TUNGraphNodeI() : NI() { } + TUNGraphNodeI(const TUNGraph::TNodeI& NodeI) : NI(NodeI) { } + TUNGraphNodeI& operator = (const TUNGraph::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TUNGraphNodeI& operator++ (int) { NI++; return *this; } + TUNGraphNodeI& Next() { NI++; return *this; } + bool operator < (const TUNGraphNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TUNGraphNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TUNGraph::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TUNGraph::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TUNGraph::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TUNGraphEdgeI { +private: + TUNGraph::TEdgeI EI; +public: + TUNGraphEdgeI() : EI() { } + TUNGraphEdgeI(const TUNGraph::TEdgeI& EdgeI) : EI(EdgeI) { } + TUNGraphEdgeI& operator = (const TUNGraph::TEdgeI& EdgeI) { EI = EdgeI; return *this; } + /// Increment iterator. + TUNGraphEdgeI& operator++ (int) { EI++; return *this; } + TUNGraphEdgeI& Next() { EI++; return *this; } + bool operator < (const TUNGraphEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TUNGraphEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +class TNEANetNodeI { +private: + TNEANet::TNodeI NI; +public: + TNEANetNodeI() : NI() { } + TNEANetNodeI(const TNEANet::TNodeI& NodeI) : NI(NodeI) { } + TNEANetNodeI& operator = (const TNEANet::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TNEANetNodeI& operator++ (int) { NI++; return *this; } + TNEANetNodeI& Next() { NI++; return *this; } + bool operator < (const TNEANetNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TNEANetNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TNEANet::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TNEANet::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TNEANet::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TNEANetEdgeI { +private: + TNEANet::TEdgeI EI; +public: + TNEANetEdgeI() : EI() { } + TNEANetEdgeI(const TNEANet::TEdgeI& EdgeI) : EI(EdgeI) { } + TNEANetEdgeI& operator = (const TNEANet::TEdgeI& EdgeI) + { EI = EdgeI; return *this; } + /// Increment iterator. + TNEANetEdgeI& operator++ (int) { EI++; return *this; } + TNEANetEdgeI& Next() { EI++; return *this; } + bool operator < (const TNEANetEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TNEANetEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +typedef TIntV::TIter TIntVecIter; + +/// Node/Edge Attr iterator. Iterate through all node for one attr value. +class TNEANetAIntI { +private: + TNEANet::TAIntI IntAI; +public: + TNEANetAIntI() : IntAI() { } + TNEANetAIntI(const TIntVecIter& HIter, TStr attribute, bool isEdgeIter, + const TNEANet* GraphPt) : + IntAI(HIter, attribute, isEdgeIter, GraphPt) { } + TNEANetAIntI(const TNEANet::TAIntI& I) : IntAI(I) { } + TNEANetAIntI& operator = (const TNEANetAIntI& I) + { IntAI = I.IntAI; return *this; } + TNEANetAIntI& Next() { IntAI++; return *this; } + bool operator < (const TNEANetAIntI& I) const { return IntAI < I.IntAI; } + bool operator == (const TNEANetAIntI& I) const { return IntAI == I.IntAI; } + /// Returns an attribute of the node. + int GetDat() const { return IntAI.GetDat().Val; } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return IntAI.IsDeleted(); }; + TNEANetAIntI& operator++(int) { IntAI++; return *this; } +// friend class TNEANet; +}; + +typedef TStrV::TIter TStrVecIter; + +/// Node/Edge Attr iterator. Iterate through all node for one attr value. +class TNEANetAStrI { +private: + TNEANet::TAStrI StrAI; +public: + TNEANetAStrI() : StrAI() { } + TNEANetAStrI(const TStrVecIter& HIter, TStr attribute, bool isEdgeIter, + const TNEANet* GraphPt) : + StrAI(HIter, attribute, isEdgeIter, GraphPt) { } + TNEANetAStrI(const TNEANet::TAStrI& I) : StrAI(I) { } + TNEANetAStrI& operator = (const TNEANetAStrI& I) + { StrAI = I.StrAI; return *this; } + TNEANetAStrI& Next() { StrAI++; return *this; } + bool operator < (const TNEANetAStrI& I) const { return StrAI < I.StrAI; } + bool operator == (const TNEANetAStrI& I) const { return StrAI == I.StrAI; } + /// Returns an attribute of the node. + char * GetDat() const { return StrAI.GetDat().CStr(); } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return StrAI.IsDeleted(); }; + TNEANetAStrI& operator++(int) { StrAI++; return *this; } + // friend class TNEANet; +}; + + +typedef TFltV::TIter TFltVecIter; + +/// Node/Edge Attr iterator. Iterate through all node for one attr value. +class TNEANetAFltI { +private: + TNEANet::TAFltI FltAI; +public: + TNEANetAFltI() : FltAI() { } + TNEANetAFltI(const TFltVecIter& HIter, TStr attribute, bool isEdgeIter, + const TNEANet* GraphPt) : + FltAI(HIter, attribute, isEdgeIter, GraphPt) { } + TNEANetAFltI(const TNEANet::TAFltI& I) : FltAI(I) { } + TNEANetAFltI& operator = (const TNEANetAFltI& I) + { FltAI = I.FltAI; return *this; } + TNEANetAFltI& Next() { FltAI++; return *this; } + bool operator < (const TNEANetAFltI& I) const { return FltAI < I.FltAI; } + bool operator == (const TNEANetAFltI& I) const { return FltAI == I.FltAI; } + /// Returns an attribute of the node. + double GetDat() const { return FltAI.GetDat().Val; } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return FltAI.IsDeleted(); }; + TNEANetAFltI& operator++(int) { FltAI++; return *this; } + // friend class TNEANet; +}; + + diff --git a/snap-python/source/dev/swig-r/swig-TNEANet.cpp b/snap-python/source/dev/swig-r/swig-TNEANet.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e8a96d7d95e24c739a28a817dbb73e60880c1b42 --- /dev/null +++ b/snap-python/source/dev/swig-r/swig-TNEANet.cpp @@ -0,0 +1,345 @@ +#include "Snap.h" + +// Print graph statistics +void PrintGStats(const char s[], PNEANet Graph) { + printf("graph %s, nodes %d, edges %d, empty %s\n", + s, Graph->GetNodes(), Graph->GetEdges(), + Graph->Empty() ? "yes" : "no"); +} + +// Test the default constructor +void DefaultConstructor() { + PNEANet Graph; + + Graph = TNEANet::New(); + PrintGStats("DefaultConstructor:Graph",Graph); +} + +// Test node, edge creation +void ManipulateNodesEdges() { + int NNodes = 1000; + int NEdges = 100000; + const char *FName = "demo.graph.dat"; + + PNEANet Graph; + PNEANet Graph1; + PNEANet Graph2; + int i; + int n; + int NCount; + int ECount1; + int ECount2; + int x,y; + bool t; + + Graph = TNEANet::New(); + t = Graph->Empty(); + + // create the nodes + for (i = 0; i < NNodes; i++) { + Graph->AddNode(i); + } + t = Graph->Empty(); + n = Graph->GetNodes(); + + // create random edges + NCount = NEdges; + while (NCount > 0) { + x = (long) (drand48() * NNodes); + y = (long) (drand48() * NNodes); + n = Graph->AddEdge(x, y); + NCount--; + } + PrintGStats("ManipulateNodesEdges:Graph",Graph); + + // get all the nodes + NCount = 0; + for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { + NCount++; + } + + // get all the edges for all the nodes + ECount1 = 0; + for (TNEANet::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { + for (int e = 0; e < NI.GetOutDeg(); e++) { + ECount1++; + } + } + + // get all the edges directly + ECount2 = 0; + for (TNEANet::TEdgeI EI = Graph->BegEI(); EI < Graph->EndEI(); EI++) { + ECount2++; + } + printf("graph ManipulateNodesEdges:Graph, nodes %d, edges1 %d, edges2 %d\n", + NCount, ECount1, ECount2); + + // assignment + Graph1 = TNEANet::New(); + *Graph1 = *Graph; + PrintGStats("ManipulateNodesEdges:Graph1",Graph1); + + // save the graph + { + TFOut FOut(FName); + Graph->Save(FOut); + FOut.Flush(); + } + + // load the graph + { + TFIn FIn(FName); + Graph2 = TNEANet::Load(FIn); + } + PrintGStats("ManipulateNodesEdges:Graph2",Graph2); + + // remove all the nodes and edges + for (i = 0; i < NNodes; i++) { + n = Graph->GetRndNId(); + Graph->DelNode(n); + } + + PrintGStats("ManipulateNodesEdges:Graph",Graph); + + Graph1->Clr(); + PrintGStats("ManipulateNodesEdges:Graph1",Graph1); +} + +// Test node attribute functionality +void ManipulateNodeEdgeAttributes() { + int NNodes = 1000; + int NEdges = 1000; + + PNEANet Graph; + int i; + int x, y; + bool t; + + Graph = TNEANet::New(); + t = Graph->Empty(); + + // create the nodes + for (i = 0; i < NNodes; i++) { + Graph->AddNode(i); + } + + // create the edges + for (i = 0; i < NEdges; i++) { + x = (long) (drand48() * NNodes); + y = (long) (drand48() * NNodes); + Graph->AddEdge(x, y, i); + } + + // create attributes and fill all nodes + TStr attr1 = "str"; + TStr attr2 = "int"; + TStr attr3 = "float"; + TStr attr4 = "default"; + + // Test vertical int iterator for node 3, 50, 700, 900 + // Check if we can set defaults to 0 for Int data. + Graph->AddIntAttrN(attr2, 0); + Graph->AddIntAttrDatN(3, 3*2, attr2); + Graph->AddIntAttrDatN(50, 50*2, attr2); + Graph->AddIntAttrDatN(700, 700*2, attr2); + Graph->AddIntAttrDatN(900, 900*2, attr2); + int NodeId = 0; + for (TNEANet::TAIntI NI = Graph->BegNAIntI(attr2); + NI < Graph->EndNAIntI(attr2); NI++) { + // Check if defaults are now 0. + if (NI.GetDat()() != 0) { + printf("Attribute: %s, Node: %i, Val: %i\n", attr2(), NodeId, NI.GetDat()()); + NodeId++; + } + } + + // Test vertical flt iterator for node 3, 50, 700, 900 + Graph->AddFltAttrDatN(5, 3.41, attr3); + Graph->AddFltAttrDatN(50, 2.718, attr3); + Graph->AddFltAttrDatN(300, 150.0, attr3); + Graph->AddFltAttrDatN(653, 653, attr3); + NodeId = 0; + for (TNEANet::TAFltI NI = Graph->BegNAFltI(attr3); + NI < Graph->EndNAFltI(attr3); NI++) { + if (NI.GetDat() != TFlt::Mn) { + printf("Attribute: %s, Node: %i, Val: %f\n", attr3(), NodeId, NI.GetDat()()); + NodeId++; + } + } + + // Test vertical str iterator for node 3, 50, 700, 900 + Graph->AddStrAttrDatN(10, "abc", attr1); + Graph->AddStrAttrDatN(20, "def", attr1); + Graph->AddStrAttrDatN(400, "ghi", attr1); + // this does not show since ""=null + Graph->AddStrAttrDatN(455, "", attr1); + NodeId = 0; + + for (TNEANet::TAStrI NI = Graph->BegNAStrI(attr1); + NI < Graph->EndNAStrI(attr1); NI++) { + if (NI.GetDat() != TStr::GetNullStr()) { + printf("Attribute: %s, Node: %i, Val: %s\n", attr1(), NodeId, NI.GetDat()()); + NodeId++; + } + } + + // Test vertical iterator over many types (must skip default/deleted attr) + int NId = 55; + Graph->AddStrAttrDatN(NId, "aaa", attr1); + Graph->AddIntAttrDatN(NId, 3*2, attr2); + Graph->AddFltAttrDatN(NId, 3.41, attr3); + Graph->AddStrAttrDatN(80, "dont appear", attr4); // should not show up + TStrV NIdAttrName; + Graph->AttrNameNI(NId, NIdAttrName); + int AttrLen = NIdAttrName.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Node: %i, Attr: %s\n", NId, NIdAttrName[i]()); + } + + Graph->DelAttrDatN(NId, attr2); + Graph->AttrNameNI(NId, NIdAttrName); + AttrLen = NIdAttrName.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Node (no int) : %i, Attr: %s\n", NId, NIdAttrName[i]()); + } + + Graph->AddIntAttrDatN(NId, 3*2, attr2); + Graph->DelAttrN(attr1); + Graph->AttrNameNI(NId, NIdAttrName); + AttrLen = NIdAttrName.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Node (no str) : %i, Attr: %s\n", NId, NIdAttrName[i]()); + } + + TStrV NIdAttrValue; + Graph->AttrValueNI(NId, NIdAttrValue); + AttrLen = NIdAttrValue.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Node (no str) : %i, Attr_Val: %s\n", NId, NIdAttrValue[i]()); + } + + for (i = 0; i AddIntAttrDatN(i, 70, attr2); + } + + int total = 0; + for (TNEANet::TAIntI NI = Graph->BegNAIntI(attr2); + NI < Graph->EndNAIntI(attr2); NI++) { + total += NI.GetDat(); + } + + printf("Average: %i (should be 70)\n", total/NNodes); + + // Test vertical int iterator for edge + Graph->AddIntAttrDatE(3, 3*2, attr2); + Graph->AddIntAttrDatE(55, 55*2, attr2); + Graph->AddIntAttrDatE(705, 705*2, attr2); + Graph->AddIntAttrDatE(905, 905*2, attr2); + int EdgeId = 0; + for (TNEANet::TAIntI EI = Graph->BegEAIntI(attr2); + EI < Graph->EndEAIntI(attr2); EI++) { + if (EI.GetDat() != TInt::Mn) { + printf("E Attribute: %s, Edge: %i, Val: %i\n", attr2(), EdgeId, EI.GetDat()()); + EdgeId++; + } + } + + // Test vertical flt iterator for edge + Graph->AddFltAttrE(attr3, 0.00); + Graph->AddFltAttrDatE(5, 4.41, attr3); + Graph->AddFltAttrDatE(50, 3.718, attr3); + Graph->AddFltAttrDatE(300, 151.0, attr3); + Graph->AddFltAttrDatE(653, 654, attr3); + EdgeId = 0; + for (TNEANet::TAFltI EI = Graph->BegEAFltI(attr3); + EI < Graph->EndEAFltI(attr3); EI++) { + // Check if defaults are set to 0. + if (EI.GetDat() != 0.00) { + printf("E Attribute: %s, Edge: %i, Val: %f\n", attr3(), EdgeId, EI.GetDat()()); + EdgeId++; + } + } + + // Test vertical str iterator for edge + Graph->AddStrAttrDatE(10, "abc", attr1); + Graph->AddStrAttrDatE(20, "def", attr1); + Graph->AddStrAttrDatE(400, "ghi", attr1); + // this does not show since ""=null + Graph->AddStrAttrDatE(455, "", attr1); + EdgeId = 0; + for (TNEANet::TAStrI EI = Graph->BegEAStrI(attr1); + EI < Graph->EndEAStrI(attr1); EI++) { + if (EI.GetDat() != TStr::GetNullStr()) { + printf("E Attribute: %s, Edge: %i, Val: %s\n", attr1(), EdgeId, EI.GetDat()()); + EdgeId++; + } + } + + + // Test vertical iterator over many types (must skip default/deleted attr) + int EId = 55; + Graph->AddStrAttrDatE(EId, "aaa", attr1); + Graph->AddIntAttrDatE(EId, 3*2, attr2); + Graph->AddFltAttrDatE(EId, 3.41, attr3); + Graph->AddStrAttrDatE(80, "dont appear", attr4); // should not show up + TStrV EIdAttrName; + Graph->AttrNameEI(EId, EIdAttrName); + AttrLen = EIdAttrName.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Edge: %i, Attr: %s\n", EId, EIdAttrName[i]()); + } + + Graph->DelAttrDatE(EId, attr2); + Graph->AttrNameEI(EId, EIdAttrName); + AttrLen = EIdAttrName.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Edge (no int) : %i, Attr: %s\n", EId, EIdAttrName[i]()); + } + + Graph->AddIntAttrDatE(EId, 3*2, attr2); + Graph->DelAttrE(attr1); + Graph->AttrNameEI(EId, EIdAttrName); + AttrLen = EIdAttrName.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Edge (no str) : %i, Attr: %s\n", EId, EIdAttrName[i]()); + } + + TStrV EIdAttrValue; + Graph->AttrValueEI(EId, EIdAttrValue); + AttrLen = EIdAttrValue.Len(); + for (int i = 0; i < AttrLen; i++) { + printf("Vertical Edge (no str) : %i, Attr_Val: %s\n", EId, EIdAttrValue[i]()); + } + + for (i = 0; i AddIntAttrDatE(i, 70, attr2); + } + + total = 0; + for (TNEANet::TAIntI EI = Graph->BegNAIntI(attr2); + EI < Graph->EndNAIntI(attr2); EI++) { + total += EI.GetDat(); + } + + printf("Average: %i (should be 70)\n", total/NEdges); + + Graph->Clr(); +} + +// Test small graph +void GetSmallGraph() { + PNEANet Graph; + + return; + + //Graph = TNEANet::GetSmallGraph(); + PrintGStats("GetSmallGraph:Graph",Graph); +} + +//int main(int argc, char* argv[]) { +// DefaultConstructor(); +// ManipulateNodesEdges(); +// ManipulateNodeEdgeAttributes(); +// GetSmallGraph(); +//} + diff --git a/snap-python/source/dev/swig-sw/Makefile b/snap-python/source/dev/swig-sw/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..22b240fd5f4c88a3b233c2888318548d9b44ae12 --- /dev/null +++ b/snap-python/source/dev/swig-sw/Makefile @@ -0,0 +1,42 @@ +# +# Makefile for SWIG processing of SNAP +# + +# set the path to your SNAP directory here +SNAPROOT = ../../../snap + +include $(SNAPROOT)/Makefile.config + +SNAPDIR = $(SNAPROOT)/$(SNAP) +GLIBDIR = $(SNAPROOT)/$(GLIB) + +UNAME := $(shell uname) + +ifeq ($(UNAME), Linux) + # Linux flags + CXXFLAGS += -fPIC -shared -D__STDC_LIMIT_MACROS + LDFLAGS += -lrt + #SWIGFLAGS += -DSWIG_SW -DSW_WRITEN + SWIGFLAGS += -DSWIG_SW -DSW_WRITEN +else ifeq ($(UNAME), Darwin) + # OS X flags + # LDFLAGS += -lpython -dynamiclib -undefined dynamic_lookup + LDFLAGS += -lpython -dynamiclib + SWIGFLAGS += -DSWIG_SW -DSW_WRITEN +else ifeq ($(shell uname -o), Cygwin) + # Cygwin flags +endif + +#SWIGFILES = getassessment.cpp + +all: python + +python: Snap.o snap.i + swig -python -c++ -w302,312,317,325,362,383,384,389,401,503,508,509 -O -D_CMPWARN $(SWIGFLAGS) -I$(SNAPDIR) -I$(GLIBDIR) snap.i + g++ $(CXXFLAGS) $(SWIGFLAGS) -c snap_wrap.cxx $(SWIGFILES) -I$(SNAPDIR) -I$(GLIBDIR) -I/usr/include/python2.6 -I/usr/include/python2.7 + g++ $(LDFLAGS) $(CXXFLAGS) snap_wrap.o Snap.o -o _snap.so + +Snap.o: + $(CC) $(CXXFLAGS) $(SWIGFLAGS) -c $(SNAPDIR)/Snap.cpp -I$(SNAPDIR) -I$(GLIBDIR) +clean: + rm -f *.o *_wrap.cxx _*.so *.pyc diff --git a/snap-python/source/dev/swig-sw/printgraph.h b/snap-python/source/dev/swig-sw/printgraph.h new file mode 100644 index 0000000000000000000000000000000000000000..1f24daa60d20ea19926070f81827c834bf4b1240 --- /dev/null +++ b/snap-python/source/dev/swig-sw/printgraph.h @@ -0,0 +1,51 @@ + +template +void PrintGraphStatTable(const PGraph& G, TStr OutFNm, TStr Desc="") { + TFltPrV DegCCfV; + int64 ClosedTriads, OpenTriads; + int FullDiam; + double EffDiam; + TSnap::PrintInfo(G, OutFNm); + TExeTm ExeTm; printf("C"); + const double CCF = TSnap::GetClustCf(G, DegCCfV, ClosedTriads, OpenTriads); + printf("[%s]D", ExeTm.GetStr()); + TSnap::GetBfsEffDiam(G, 1000, false, EffDiam, FullDiam); + printf("[%s]CC", ExeTm.GetStr()); + PGraph WCC = TSnap::GetMxWcc(G); + PGraph SCC = TSnap::GetMxScc(G); + printf("[%s]\n", ExeTm.GetStr()); + FILE* F = stdout; + if (! OutFNm.Empty()) { + F = fopen(TStr::Fmt("%s.html", OutFNm.CStr()).CStr(), "wt"); } + fprintf(F, "\n"); + fprintf(F, "\n"); + fprintf(F, " \n"); + fprintf(F, " \n", G->GetNodes()); + fprintf(F, " \n", G->GetEdges()); + fprintf(F, " \n", WCC->GetNodes(), WCC->GetNodes()/double(G->GetNodes())); + fprintf(F, " \n", WCC->GetEdges(), WCC->GetEdges()/double(G->GetEdges())); + fprintf(F, " \n", SCC->GetNodes(), SCC->GetNodes()/double(G->GetNodes())); + fprintf(F, " \n", SCC->GetEdges(), SCC->GetEdges()/double(G->GetEdges())); + fprintf(F, " \n", CCF); + fprintf(F, " \n", TUInt64(ClosedTriads).GetStr().CStr()); + fprintf(F, " \n", ClosedTriads/double(ClosedTriads+OpenTriads)); + fprintf(F, " \n", FullDiam); + fprintf(F, " \n", EffDiam); + fprintf(F, "
Dataset statistics
Nodes %d
Edges %d
Nodes in largest WCC %d (%.3f)
Edges in largest WCC %d (%.3f)
Nodes in largest SCC %d (%.3f)
Edges in largest SCC %d (%.3f)
Average clustering coefficient %.4f
Number of triangles %s
Fraction of closed triangles %.4g
Diameter (longest shortest path) %d
90-percentile effective diameter %.2g
\n"); + fprintf(F, "
\n"); + if (! OutFNm.Empty()) { + fprintf(F, "\n\n"); + fprintf(F, "\n"); + fprintf(F, " \n"); + fprintf(F, " \n"); + fprintf(F, "\n"); + fprintf(F, "\n"); + fprintf(F, " \n", OutFNm.CStr(), OutFNm.CStr()); + fprintf(F, " \n", Desc.CStr()); + fprintf(F, "\n"); + fprintf(F, "
FileDescription
%s.txt.gz%s
\n"); + fclose(F); + TSnap::SaveEdgeList(G, OutFNm+".txt", Desc); + } +} + diff --git a/snap-python/source/dev/swig-sw/snap.i b/snap-python/source/dev/swig-sw/snap.i new file mode 100644 index 0000000000000000000000000000000000000000..d6b97860d8ae5175803efca6eea6dfba14b0ebe8 --- /dev/null +++ b/snap-python/source/dev/swig-sw/snap.i @@ -0,0 +1,152 @@ +// snap.i +%module snap +%{ +#include "Snap.h" +#include "snapsw.h" +#include "printgraph.h" +#include "snapswig.h" +%} + +%ignore TOnExeStop; +%ignore TPt::TPt; +%ignore TPt::LoadXml; +%ignore TPt::SaveXml; +%ignore TPt::operator==; +%ignore TPt::operator!=; +%ignore TPt::operator<; +%ignore TPt::GetPrimHashCd; +%ignore TPt::GetSecHashCd; +%ignore TPt::Clone; + +%ignore TChA::LoadXml; +%ignore TMem::LoadXml; + +%ignore GetStr; + +%ignore TUInt::IsIpv6Str; + +%ignore TFInOut; +%ignore TFRnd; +%ignore TFile::GetLastAccessTm; +%ignore TMOut::AppendBf; +%ignore TMIn::New; + +%ignore TNGraph::GetEI(int const&) const; +%ignore TBPGraph::HasFlag(const TGraphFlag& Flag) const; +%ignore TNEGraph::GetSmallGraph(); +%ignore TBPGraph::GetEI(int const&) const; +%ignore TUNGraph::GetEI(int const&) const; + +//%ignore TNGraphNodeI::TNGNodeI; + +%ignore TVec, int>::Add; //TIntIntVV +%ignore TVec, int>::AddMerged; + +%ignore TVec< TVec< TVec< TInt, int >, int >, int>::Add; //TIntVVV +%ignore TVec< TVec< TVec< TInt, int >, int >, int>::AddMerged; + +%ignore THash< TInt, TVec< TInt, int > >::AddDat; //TIntIntVH +%ignore THash< TInt, TVec< TInt, int > >::HashPrimeT; +%ignore THash< TInt, TVec< TInt, int > >::AddDatId; + +%ignore THash< TInt, TVec< TVec< TInt, int >, int > >::AddDat; //TIntVVH +%ignore THash< TInt, TVec< TVec< TInt, int >, int > >::HashPrimeT; +%ignore THash< TInt, TVec< TVec< TInt, int >, int > >::AddDatId; + +%ignore THash< TInt, TInt, TDefaultHashFunc >::HashPrimeT; +%ignore THash< TInt, TInt, TDefaultHashFunc >::AddDatId; +%ignore THash< TInt, TInt>::HashPrimeT; + +#define GLib_UNIX +%include "bd.h" +%include "dt.h" +%include "ds.h" +%include "fl.h" +%include "graph.h" +%include "gio.h" +%include "hash.h" +%include "ggen.h" +%include "util.h" + +%include "snapsw.h" +%include "printgraph.h" +%include "snapswig.h" + +// TODO can BegNI() be renamed? + +%extend TNGraph { + TNGraphNodeI BegNI() { + return TNGraphNodeI($self->BegNI()); + } + TNGraphNodeI EndNI() { + return TNGraphNodeI($self->EndNI()); + } + TNGraphEdgeI BegEI() { + return TNGraphEdgeI($self->BegEI()); + } + TNGraphEdgeI EndEI() { + return TNGraphEdgeI($self->EndEI()); + } +}; + +%extend TUNGraph { + TUNGraphNodeI BegNI() { + return TUNGraphNodeI($self->BegNI()); + } + TUNGraphNodeI EndNI() { + return TUNGraphNodeI($self->EndNI()); + } + TUNGraphEdgeI BegEI() { + return TUNGraphEdgeI($self->BegEI()); + } + TUNGraphEdgeI EndEI() { + return TUNGraphEdgeI($self->EndEI()); + } +}; + +%extend TVec { + + TSizeTy Add(int Val) { + return $self->Add(TInt(Val)); + } + + TSizeTy AddMerged(int Val) { + return $self->AddMerged(TInt(Val)); + } +}; + +%extend THash { + int AddKey(int Val) { + return $self->AddKey(TInt(Val)); + } + int IsKey(int Val) { + return $self->IsKey(TInt(Val)); + } + TDat& GetDat(int Val) { + return $self->GetDat(TInt(Val)); + } + TDat& AddDat(int Key, int Val) { + return $self->AddDat(TInt(Key),TInt(Val)); + } +}; + +%template(TIntV) TVec< TInt, int >; + +%template(TIntIntVV) TVec< TVec< TInt, int >, int >; +%template(TIntVVV) TVec< TVec< TVec< TInt, int >, int >, int>; + +%template(TIntIntVH) THash< TInt, TVec< TInt, int > >; +%template(TIntVVH) THash< TInt, TVec< TVec< TInt, int >, int > >; + +%template(TIntH) THash; +%template(TIntHI) THashKeyDatI < TInt, TInt >; + +//%template(SendVec_TIntV) TSnap::SendVec< TVec< TInt, int > >; +%template(SendVec_TIntV) SendVec< TInt, int >; +%template(SendVec_TIntIntVV) SendVec64< TInt, int >; + +%template(PNGraph) TPt< TNGraph >; +%template(LoadEdgeList_PNGraph) TSnap::LoadEdgeList; +%template(GenRndGnm_PNGraph) TSnap::GenRndGnm; +%template(PrintGraphStatTable_PNGraph) PrintGraphStatTable; + diff --git a/snap-python/source/dev/swig-sw/snapsw.h b/snap-python/source/dev/swig-sw/snapsw.h new file mode 100644 index 0000000000000000000000000000000000000000..e7d5d2db6abe3be280e4d87ee8d517ade3f6e998 --- /dev/null +++ b/snap-python/source/dev/swig-sw/snapsw.h @@ -0,0 +1,599 @@ +#include +#include +#include +#include + +namespace TSnap { + +typedef TVec TIntV; +typedef TVec TIntIntVV; +typedef TVec TIntVVV; + +typedef THash > TIntIntVH; +typedef THash TIntVVH; + +// vector of hashes +typedef TVec, int> TIntIntHV; + + +// TODO (smacke): It makes a whole lot of sense to define +// types for offset'd and segment'd containers + +void SeedRandom() { + long int ITime; + long int IPid; + long int RSeed; + + ITime = (long int) time(NULL); + IPid = (long int) getpid(); + + RSeed = ITime * IPid; + srand48(RSeed); +} + +void Randomize(TIntV& Vec) { + int Pos; + int Last = Vec.Len() - 1; + for (int ValN = Last; ValN > 0; ValN--) { + Pos = (long) (drand48() * ValN); + Vec.Swap(ValN, Pos); + } +} + +int StdDist(double Mean, double Dev) { + int i; + double x; + + x = -6.0; + for (i = 0; i < 12; i++) { + x += drand48(); + } + + x *= Dev; + x += Mean; + + return int(x + 0.5); +} + +#if 0 +void GetDegrees(TIntV* Nodes, double Mean, double Dev) { + int i; + int d; + int Len; + printf("GetDegrees\n"); + printf("Nodes Len %d\n",Nodes->Len()); + + Len = Nodes->Len(); + for (i = 0; i < Len; i++) { + d = StdDist(Mean, Dev); + printf("degree1 %d %d\n", i, d); + (*Nodes)[i] = d; + } + + for (i = 0; i < Len; i++) { + printf("degree2 %d %d\n", i, Nodes->GetVal(i).Val); + } +} +#endif + + +int bitcount(unsigned int n) { + int v=0; + while (n) { + n &= (n-1); + v++; + } + return v; +} + +unsigned int nextPowerOf2(unsigned int v) { + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v++; + return v; +} + +int leading(int64 val, int seg_bits) { + return val >> seg_bits; +} + +int trailing(int64 val, int seg_bits) { + return int(val & ((1< +void ensureCapacity(TVec &vec, unsigned int size) { + size++; // make sure we will actually be able to index vec at size + int cap = vec.Reserved(); + + // if this is the first time we add something to this entry + // then reserve some memory + if (vec.Len()==0) { + unsigned int newSize = nextPowerOf2(size); + cap = max(newSize, cap); + vec.Reserve(newSize, cap); + } else { + // otherwise, check to see if we still don't have enough space + // if not, make more + unsigned int x = vec.Len(); + if (x < size) { + while (x < size) x *= 2; + cap = max(x, cap); + vec.Reserve(x, cap); + } + } +} + +// helper function for debugging +// converts a segmented vector into a nonsegmented one +TIntV desegment(TIntIntVV& segmented, int seg_bits) { + TIntV desegmented; + for (int64 seg=0; seg 0); + int64 randomStubIndex; + + // if we need a ton of random bits + if (totalStubsRemaining > INT_MAX) { + // split random calc into low order and high order portions + randomStubIndex = randRange64(totalStubsRemaining, seg_bits); + } else { + randomStubIndex = int64(drand48() * totalStubsRemaining); + } + + totalStubsRemaining--; + int64 stubsSeen=0; + for (int64 i=0; i randomStubIndex) { + int stubIndexWithinSegment = (int)(randomStubIndex - prevSeen); + int stub = stubs[i][stubIndexWithinSegment].Val; + // now move this stub to the end so that it won't be selected again + stubsRemainingInSegment[i]--; + stubs[i].Swap(stubIndexWithinSegment, stubsRemainingInSegment[i].Val); // this isn't prone to off-by-one errors at all! + return (i< 1) { +// printf("%d remaining\n", totalStubsRemaining); +// printf("about to get random stubs\n"); + int64 stubA = GetRandomStub64(stubs, stubsRemainingInSegment, totalStubsRemaining, seg_bits); + int64 stubB = GetRandomStub64(stubs, stubsRemainingInSegment, totalStubsRemaining, seg_bits); +// printf("done getting random stubs\n"); + + int taskId = (int)(stubA / tsize); + // make sure we have enough room there +// printf("about to ensure capacity\n"); + ensureCapacity(Tasks[taskId], leading(stubB, seg_bits)); +// printf("done ensuring capacity\n"); + + /* + * This next part is kind of weird. We need to keep the two stubs together, + * even though they could have very different high order bits. The thing is, + * whichever task gets (stubA, stubB) should be able to infer the high-order + * bits of stubA based on the id of the task, since certain tasks are only + * responsible for certain neighbor lists. For this to work properly we need + * the segment size to be a multiple of "range". + */ + +// printf("about to add stubs\n"); + Tasks[taskId][leading(stubB, seg_bits)].Add(trailing(stubA, seg_bits)); + Tasks[taskId][leading(stubB, seg_bits)].Add(trailing(stubB, seg_bits)); +// printf("done adding stubs\n"); + + taskId = (int)(stubB / tsize); + ensureCapacity(Tasks[taskId], leading(stubA, seg_bits)); + + // again, the weird part +// printf("about to add stubs round 2\n"); + Tasks[taskId][leading(stubA, seg_bits)].Add(trailing(stubB, seg_bits)); + Tasks[taskId][leading(stubA, seg_bits)].Add(trailing(stubA, seg_bits)); +// printf("done adding stubs round 2\n"); + } +} + +void AssignEdges(const TIntV& Pairs, TIntIntVV& Tasks, int tsize) { + int i; + int NumStubs; + int NumTasks; + int TaskId; + int Node1; + int Node2; + + //printf("AssignEdges\n"); + //printf("Pairs Len %d\n",Pairs.Len()); + //printf("Tasks Len %d\n",Tasks.Len()); + + NumStubs = Pairs.Len(); + NumTasks = Tasks.Len(); + + // distribute edges to tasks + for (i = 0; i < NumStubs-1; i += 2) { + + Node1 = Pairs.GetVal(i).Val; + Node2 = Pairs.GetVal(i+1).Val; + + // add an edge twice, once for each end node + TaskId = Node1 / tsize; + Tasks[TaskId].Add(Node1); + Tasks[TaskId].Add(Node2); + + TaskId = Node2 / tsize; + Tasks[TaskId].Add(Node2); + Tasks[TaskId].Add(Node1); + } +} + +void GetAdjLists(const TIntV& Edges, TIntIntVH& AdjLists) { + int i; + int NumStubs; + int Node1; + int Node2; + + //printf("GetAdjLists\n"); + //printf("Edges1 Len %d\n",Edges.Len()); + + NumStubs = Edges.Len(); + + // distribute node pairs to adjacency lists + for (i = 0; i < NumStubs-1; i += 2) { + Node1 = Edges.GetVal(i).Val; + Node2 = Edges.GetVal(i+1).Val; + + AdjLists.AddKey(Node1); + AdjLists(Node1).AddMerged(Node2); + } +} + +/* + * Creates an adjacency list out of segmented edge table. + * NOTE: the reason this works is that the leading bits of the + * first node in the edge (Node1) are determined by this task. + */ +void GetAdjLists64(const TIntIntVV &Edges, TIntVVH &AdjLists) { + for (int seg=0; seg p2p-Gnutella08.txt + +clean: + rm -f test.graph *.txt *.html + diff --git a/snap-python/source/dev/test/PType b/snap-python/source/dev/test/PType new file mode 100644 index 0000000000000000000000000000000000000000..412898d9bd223d741438f6fe907e7d37b46274f1 --- /dev/null +++ b/snap-python/source/dev/test/PType @@ -0,0 +1,14 @@ +graph info: Directed + Nodes: 1000000 + Edges: 2000000 + Zero Deg Nodes: 18352 + Zero InDeg Nodes: 135540 + Zero OutDeg Nodes: 134880 + NonZero In-Out Deg Nodes: 747932 + Unique directed edges: 2000000 + Unique undirected edges: 2000000 + Self Edges: 0 + BiDir Edges: 0 + Closed triangles 13 + Open triangles 7995588 + Frac. of closed triads 0.000002 diff --git a/snap-python/source/dev/test/adjlist.py b/snap-python/source/dev/test/adjlist.py new file mode 100644 index 0000000000000000000000000000000000000000..d49d837437e15b18a9798611ebdf8592f1e69353 --- /dev/null +++ b/snap-python/source/dev/test/adjlist.py @@ -0,0 +1,104 @@ +import random +import os +import sys +import time + +sys.path.append("../swig") +import snap + +numnodes = 100 +valrange = numnodes / 10 + +Edges = snap.TIntV() + +for i in range(0,numnodes): + Edges.Add(int(random.random() * valrange)) + +d = {} +for i in range(0,numnodes,2): + print "Edges", i/2, Edges.GetVal(i).Val, Edges.GetVal(i+1).Val + d[(Edges.GetVal(i).Val,Edges.GetVal(i+1).Val)] = 1 + +Hash = snap.TIntH() +print "type", type(Edges), type(Hash) +snap.Edge2Hash(Edges,Hash) + +for i in range(0,valrange): + Vec2 = Hash.GetDat(i) + print i, Vec2.Val + +AdjLists = snap.TIntIntVH() +print "type", type(Edges), type(AdjLists) +snap.GetAdjLists(Edges, AdjLists) + +size = 0 +for i in range(0,valrange): + Vec2 = AdjLists.GetDat(i) + size += Vec2.Len() + + for j in range(0,Vec2.Len()): + print i, Vec2.GetVal(j).Val + +print "done", Edges.Len(), AdjLists.Len(), size, len(d) + + +sys.exit(0) + +#print "dir(snap.TIntV)", dir(snap.TIntV) +Vec1 = snap.TIntV(numnodes) +#print "dir(Vec1)", dir(Vec1) +print "Len Vec1", Vec1.Len() + +#print "dir(snap.TIntIntVV)", dir(snap.TIntIntVV) +Vec2 = snap.TIntIntVV(numtask) +#print "dir(Vec2)", dir(Vec2) +print "Len Vec2", Vec2.Len() + +print "Vec1", type(Vec1) + +snap.GetDegrees(Vec1, 10.0, 1.5) + +for i in range(0,Vec1.Len()): + print "Vec1", i, Vec1.GetVal(i).Val + +snap.AssignRndTask(Vec1, Vec2) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print "Vec3", i, Vec3.Len() + + for j in range(0,Vec3.Len()): + print "Vec4", i, j, Vec3.GetVal(j).Val + +sys.exit(0) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print "Vec3", i, Vec3.Len() + + h = httplib.HTTPConnection("rokl1.stanford.edu",8100) + #h.request("POST","/msg/GenStubs-0/GenTasks-2","12345",{"User-agent": "007"}) + h.connect() + url = "/msg/GenStubs-0/GenTasks-%d" % (i) + h.putrequest("POST",url) + h.putheader("User-Agent", "007") + #h.putheader("Content-Length", "9") + h.putheader("Content-Length", str(Vec3.GetMemSize())) + h.endheaders() + + fileno = h.sock.fileno() + print "fileno", fileno + + n = Vec3.Send(fileno) + #n = os.write(fileno,"123abcdef") + print n + + #h.send("abc123") + + res = h.getresponse() + print res.status, res.reason + data = res.read() + print len(data) + print data + + diff --git a/snap-python/source/dev/test/data/p2p-Gnutella08.html b/snap-python/source/dev/test/data/p2p-Gnutella08.html new file mode 100644 index 0000000000000000000000000000000000000000..c472d0114751184fdf92bb426554e35f0c650fc4 --- /dev/null +++ b/snap-python/source/dev/test/data/p2p-Gnutella08.html @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + +
Dataset statistics
Nodes 6301
Edges 20777
Nodes in largest WCC 6299 (1.000)
Edges in largest WCC 20776 (1.000)
Nodes in largest SCC 2068 (0.328)
Edges in largest SCC 9313 (0.448)
Average clustering coefficient 0.0109
Number of triangles 2383
Fraction of closed triangles 0.006983
Diameter (longest shortest path) 9
90-percentile effective diameter 5.5
+
+ + + + + + + + + + +
FileDescription
p2p-Gnutella08.txt.gzepinions
diff --git a/snap-python/source/dev/test/data/p2p-Gnutella08.txt b/snap-python/source/dev/test/data/p2p-Gnutella08.txt new file mode 100644 index 0000000000000000000000000000000000000000..5471a13c6eb978cd5b47b8e1d1ee225a6dc4789e --- /dev/null +++ b/snap-python/source/dev/test/data/p2p-Gnutella08.txt @@ -0,0 +1,20781 @@ +# Directed graph: p2p-Gnutella08.txt +# epinions +# Nodes: 6301 Edges: 20777 +# FromNodeId ToNodeId +0 1 +0 2 +0 3 +0 4 +0 5 +0 6 +0 7 +0 8 +0 9 +0 10 +3 703 +3 826 +3 1097 +3 1287 +3 1591 +3 1895 +3 1896 +3 1897 +3 1898 +3 1899 +4 144 +4 258 +4 491 +4 1021 +4 1418 +4 1669 +4 1900 +4 1901 +4 1902 +4 1903 +5 121 +5 127 +5 128 +5 179 +5 247 +5 249 +5 264 +5 353 +5 424 +5 426 +7 145 +7 176 +7 177 +7 353 +7 753 +7 754 +7 762 +7 2064 +7 3002 +8 520 +8 665 +8 852 +8 1394 +8 1786 +8 1842 +8 1904 +8 1905 +8 1906 +8 1907 +9 124 +9 147 +9 177 +9 246 +9 247 +9 248 +9 249 +9 250 +9 251 +9 252 +703 898 +703 1581 +703 1620 +703 2634 +703 2635 +703 2636 +703 2637 +703 2638 +703 2639 +703 2640 +1287 38 +1287 331 +1287 626 +1287 1945 +1287 2690 +1287 3137 +1287 3138 +1287 3139 +1287 3140 +1287 3141 +1895 1860 +1896 1118 +1896 1227 +1896 1334 +1896 1556 +1896 1980 +1896 2333 +1896 3672 +1896 3677 +1896 3678 +1896 3679 +144 8 +144 121 +144 122 +144 125 +144 146 +144 246 +144 249 +144 264 +144 367 +1669 1573 +1669 3023 +1669 3216 +1669 3413 +1669 3414 +1669 3415 +1669 3416 +1669 3417 +1669 3418 +127 9 +127 144 +127 175 +127 177 +127 247 +127 427 +127 698 +127 762 +127 1246 +127 2076 +179 4 +179 9 +179 17 +179 31 +179 123 +179 125 +179 250 +179 559 +179 2018 +247 776 +247 900 +247 1067 +247 1068 +247 1069 +247 1070 +247 1071 +247 1072 +247 1073 +247 1074 +249 123 +249 250 +249 251 +249 351 +249 753 +249 755 +249 762 +249 983 +264 249 +264 697 +264 1787 +264 2193 +264 2194 +264 2224 +264 2225 +264 2226 +264 2227 +264 2228 +353 122 +353 123 +353 127 +353 249 +353 251 +353 367 +353 368 +353 666 +353 754 +353 856 +424 940 +424 960 +424 2409 +424 2410 +424 2411 +424 2412 +424 2413 +424 2414 +424 2415 +145 149 +145 246 +145 265 +145 367 +145 390 +145 667 +145 717 +145 1317 +145 2098 +176 5 +176 248 +176 369 +176 697 +176 700 +176 946 +176 947 +176 2001 +176 2122 +177 143 +177 145 +177 149 +177 266 +177 367 +177 368 +177 559 +177 856 +177 1245 +753 9 +753 121 +753 122 +753 127 +753 128 +753 129 +753 145 +753 177 +753 367 +762 3 +762 175 +762 176 +762 251 +762 264 +762 266 +762 559 +762 754 +762 2001 +762 2018 +665 4 +665 5 +665 9 +665 126 +665 148 +665 252 +665 352 +665 353 +665 666 +665 667 +852 250 +852 938 +852 1097 +852 1556 +852 1990 +852 2748 +852 2749 +852 2750 +852 2751 +852 2752 +1394 9 +1394 126 +1394 129 +1394 177 +1394 248 +1394 266 +1394 353 +1394 754 +1394 1317 +1394 2018 +1786 122 +1786 125 +1786 142 +1786 146 +1786 248 +1786 249 +1786 264 +1786 367 +1786 1245 +1842 628 +1842 1342 +1842 1383 +1842 2494 +1842 3577 +1842 3578 +1842 3579 +1842 3580 +1842 3581 +1842 3582 +1904 7 +1904 129 +1904 144 +1904 149 +1904 174 +1904 247 +1904 248 +1904 252 +1904 353 +1907 4 +1907 7 +1907 129 +1907 145 +1907 149 +1907 174 +1907 266 +1907 666 +124 122 +124 123 +124 145 +124 147 +124 176 +124 248 +124 390 +124 762 +124 2063 +124 2064 +147 8 +147 128 +147 176 +147 177 +147 264 +147 367 +147 424 +147 427 +147 1246 +248 326 +248 914 +248 915 +248 916 +248 917 +248 918 +248 919 +248 920 +248 921 +248 922 +250 51 +250 64 +250 114 +250 1349 +250 1389 +250 1644 +250 1726 +250 2018 +250 4180 +250 4181 +251 513 +251 586 +251 873 +251 1064 +251 1412 +251 2206 +251 2207 +251 2208 +251 2209 +251 2210 +252 62 +252 808 +252 1475 +252 2211 +252 2212 +252 2213 +252 2214 +252 2215 +252 2216 +898 1620 +898 2785 +1620 112 +1620 342 +1620 1658 +1620 2262 +1620 2612 +1620 2634 +1620 2706 +1620 3027 +1620 3382 +1620 3383 +2634 106 +2634 510 +2634 558 +2634 1817 +2634 2595 +2634 2635 +2634 3409 +2634 3897 +2634 4229 +2635 955 +2635 1265 +2635 1427 +2635 1584 +2635 1602 +2635 1699 +2635 2269 +2635 3310 +2635 4238 +2635 4239 +2638 179 +2638 1061 +2638 1317 +2638 2720 +2638 2721 +2638 3821 +2638 4230 +2638 4231 +2638 4232 +2638 4233 +2639 71 +2639 296 +2639 527 +2639 804 +2639 1017 +2639 2051 +2639 3215 +2639 3362 +2639 4234 +2639 4235 +38 725 +38 1376 +38 1915 +38 2002 +38 2007 +38 2167 +38 2168 +38 2169 +38 2170 +331 100 +331 332 +331 333 +331 334 +331 335 +331 336 +331 337 +331 338 +331 339 +1945 151 +1945 178 +1945 814 +1945 1144 +1945 1228 +1945 1653 +1945 2288 +1945 3722 +1945 3723 +1945 3724 +2690 581 +2690 1493 +2690 1636 +2690 1936 +2690 2234 +2690 2823 +2690 4258 +2690 4259 +2690 4260 +2690 4261 +3137 102 +3137 264 +3137 753 +3137 755 +3137 1212 +3137 3146 +3137 3849 +3137 4455 +3137 4546 +3137 4547 +3138 127 +3138 143 +3138 252 +3138 369 +3138 390 +3138 754 +3138 1387 +3138 1912 +3138 2050 +3138 4487 +3140 477 +3140 2593 +3140 2746 +3140 3364 +3140 3687 +3140 4159 +3140 4437 +3140 5629 +3140 5931 +3140 6071 +1118 560 +1118 813 +1118 2011 +1118 2625 +1118 2996 +1118 2997 +1118 2998 +1118 2999 +1118 3000 +1118 3001 +1556 123 +1556 700 +1556 792 +1556 859 +1556 1491 +1556 2184 +1556 3373 +1556 3374 +1556 3375 +1556 3376 +2333 126 +2333 529 +2333 1334 +2333 1706 +2333 1891 +2333 2344 +2333 3096 +2333 3672 +2333 3822 +2333 4030 +122 578 +122 658 +122 1428 +122 1451 +122 2057 +122 2058 +122 2059 +122 2060 +122 2061 +122 2062 +125 132 +125 222 +125 503 +125 1535 +125 2070 +125 2071 +125 2072 +125 2073 +125 2074 +125 2075 +146 7 +146 285 +146 3337 +146 5048 +146 5171 +146 5338 +146 5940 +146 5941 +146 5942 +367 4 +367 5 +367 7 +367 264 +367 266 +367 559 +367 666 +367 1317 +1573 224 +1573 490 +1573 491 +1573 496 +1573 1123 +1573 1140 +1573 2221 +1573 2222 +1573 2705 +1573 2953 +1573 2973 +1573 3376 +1573 3408 +3023 144 +3023 148 +3023 149 +3023 420 +3023 551 +3023 559 +3023 1184 +3023 1994 +3023 4425 +3023 4459 +3415 17 +3415 125 +3415 148 +3415 266 +3415 559 +3415 697 +3415 753 +3415 1317 +3415 1920 +3417 122 +3417 129 +3417 143 +3417 177 +3417 246 +3417 251 +3417 367 +3417 390 +3417 666 +175 1575 +175 3066 +175 3344 +175 3715 +175 3849 +175 4539 +175 5209 +175 5325 +175 5483 +175 5584 +427 4 +427 124 +427 251 +427 265 +427 353 +427 369 +427 695 +427 700 +427 946 +427 947 +17 1050 +17 2254 +17 2761 +17 3147 +17 3169 +17 3619 +17 3893 +17 4408 +17 4953 +31 124 +31 637 +31 870 +31 1219 +31 1954 +31 2237 +31 2524 +31 2630 +31 3637 +31 3874 +123 3 +123 7 +123 143 +123 145 +123 146 +123 147 +123 252 +123 367 +123 390 +123 423 +559 119 +559 756 +559 759 +559 818 +559 819 +559 820 +559 821 +559 822 +559 823 +559 824 +1067 969 +1067 1570 +1067 2976 +1067 2977 +1068 1688 +1068 2493 +1068 2972 +1068 2973 +1068 2974 +1070 2975 +351 121 +351 176 +351 352 +351 353 +351 354 +351 355 +351 356 +351 357 +351 358 +351 359 +697 870 +697 1441 +697 1589 +697 2034 +697 2214 +697 2597 +697 2598 +697 2599 +697 2600 +697 2601 +1787 549 +1787 802 +1787 1115 +1787 1574 +1787 1788 +1787 3563 +1787 3700 +1787 3701 +1787 3702 +2193 5 +2193 124 +2193 144 +2193 147 +2193 176 +2193 248 +2193 427 +2193 629 +2193 3914 +2193 3915 +2224 122 +2224 127 +2224 175 +2224 249 +2224 266 +2224 367 +2224 390 +2224 423 +2224 697 +2225 604 +2225 1054 +2225 1129 +2225 2278 +2225 2476 +2225 2600 +2225 2733 +2225 3235 +2225 3931 +2225 3932 +2226 260 +2226 282 +2226 822 +2226 889 +2226 1143 +2226 1975 +2226 2042 +2226 2414 +2226 2867 +2226 3933 +2228 222 +2228 1173 +2228 1374 +2228 2358 +2228 2552 +2228 3354 +2228 3934 +2228 3935 +2228 3936 +2228 3937 +856 5 +856 7 +856 145 +856 149 +856 174 +856 179 +856 180 +856 1317 +856 2018 +2411 246 +2411 351 +2411 503 +2411 944 +2411 2077 +2411 2593 +2411 3229 +2411 4089 +2411 4090 +2411 4091 +149 5 +149 10 +149 128 +149 148 +149 238 +149 250 +149 252 +149 265 +149 353 +149 1317 +390 108 +390 261 +390 391 +390 392 +390 393 +390 394 +390 395 +390 396 +390 397 +390 398 +667 152 +667 459 +667 468 +667 1350 +667 1956 +667 2578 +667 2579 +667 2580 +667 2581 +717 124 +717 175 +717 265 +717 369 +717 390 +717 426 +717 427 +717 554 +717 695 +717 754 +1317 1036 +1317 1534 +1317 2362 +1317 3109 +1317 3163 +1317 3164 +1317 3165 +1317 3166 +1317 3167 +1317 3168 +369 9 +369 145 +369 174 +369 246 +369 264 +369 266 +369 422 +369 559 +369 666 +700 584 +700 1056 +700 1517 +700 2614 +700 2615 +700 2616 +700 2617 +700 2618 +700 2619 +700 2620 +2001 253 +2001 261 +2001 924 +2001 1606 +2001 1867 +2001 2071 +2001 2281 +2001 3336 +2001 3771 +2001 3772 +143 122 +143 124 +143 128 +143 146 +143 246 +143 249 +143 367 +143 426 +143 427 +143 2098 +1245 5 +1245 126 +1245 146 +1245 147 +1245 149 +1245 175 +1245 180 +1245 368 +1245 422 +1245 2018 +129 133 +129 219 +129 778 +129 864 +129 2078 +129 2079 +129 2080 +129 2081 +129 2082 +129 2083 +126 127 +126 369 +126 696 +126 698 +126 754 +126 755 +126 946 +126 947 +126 2001 +126 2077 +148 121 +148 122 +148 123 +148 124 +148 176 +148 246 +148 248 +148 367 +148 422 +148 1245 +352 4 +352 146 +352 176 +352 249 +352 266 +352 367 +352 368 +352 422 +352 2001 +938 253 +938 534 +938 547 +938 939 +938 940 +938 941 +938 942 +938 943 +938 944 +938 945 +2748 165 +2748 1066 +2748 1140 +2748 3096 +2748 3801 +2748 3946 +2748 4153 +2748 4300 +2748 4301 +2748 4302 +2750 7 +2750 8 +2750 125 +2750 128 +2750 174 +2750 238 +2750 368 +2750 424 +2750 717 +2750 856 +2751 4 +2751 147 +2751 180 +2751 249 +2751 367 +2751 368 +2751 369 +2751 390 +2751 422 +2751 856 +628 9 +628 144 +628 145 +628 147 +628 149 +628 175 +628 176 +628 369 +628 629 +628 630 +1383 327 +1383 782 +1383 815 +1383 2359 +1383 2451 +1383 2964 +1383 3211 +1383 3227 +1383 3228 +1383 3229 +2494 1433 +2494 1978 +2494 2032 +2494 3530 +2494 4129 +3577 3 +3577 9 +3577 123 +3577 124 +3577 149 +3577 247 +3577 249 +3577 352 +3577 369 +3577 427 +3579 7 +3579 149 +3579 252 +3579 715 +3579 1481 +3579 2001 +3579 4172 +3579 4586 +3579 4679 +3579 4794 +3581 3750 +174 3 +174 5 +174 7 +174 122 +174 126 +174 142 +174 145 +174 249 +174 427 +174 667 +326 922 +326 1004 +326 2277 +326 2278 +326 2279 +326 2280 +326 2281 +326 2282 +326 2283 +326 2284 +914 2042 +918 451 +918 1047 +918 1213 +918 1376 +918 1708 +918 2624 +918 2818 +918 2819 +918 2820 +919 121 +919 122 +919 123 +919 126 +919 145 +919 149 +919 180 +919 250 +919 559 +922 2809 +922 2810 +922 2811 +922 2812 +922 2813 +922 2814 +922 2815 +922 2816 +922 2817 +64 91 +64 102 +64 106 +64 1946 +64 1947 +64 1948 +64 1949 +64 1950 +64 1951 +64 1952 +1389 143 +1389 732 +1389 1390 +1389 1391 +1389 1392 +1389 1393 +1389 1394 +1389 1395 +1389 1396 +1389 1397 +1644 424 +1644 823 +1644 1414 +1644 2040 +1644 2125 +1644 2399 +1644 2880 +1644 3162 +1644 3394 +1644 3395 +4180 143 +4180 476 +4180 693 +4180 911 +4180 1272 +4180 1273 +4180 2808 +4180 5126 +4180 5127 +4180 5128 +586 8 +586 126 +586 128 +586 149 +586 175 +586 247 +586 248 +586 666 +586 717 +586 754 +873 1227 +873 1336 +873 2392 +873 2433 +873 2581 +873 2756 +873 2757 +873 2758 +873 2759 +873 2760 +1412 9 +1412 127 +1412 145 +1412 149 +1412 174 +1412 179 +1412 264 +1412 422 +1412 427 +1412 1317 +62 1064 +62 1194 +62 1196 +62 1198 +62 1959 +62 1960 +62 1961 +62 1962 +62 1963 +112 1064 +112 1160 +112 2044 +112 2045 +112 2046 +112 2047 +112 2048 +112 2049 +112 2050 +1658 92 +1658 860 +1658 963 +1658 1767 +1658 2015 +1658 2880 +1658 2953 +1658 3409 +1658 3410 +1658 3411 +2262 2354 +2262 2385 +2262 2687 +2262 2881 +2262 3951 +2612 726 +2612 1571 +2612 1789 +2612 2274 +2612 2630 +2612 3423 +2612 3570 +2612 3951 +2612 4210 +2612 4211 +3027 29 +3027 38 +3027 576 +3027 1208 +3027 2018 +3027 2291 +3027 2396 +3027 4468 +3027 4469 +3027 4470 +3382 1547 +3382 2331 +3382 2348 +3382 3194 +3382 3617 +3382 4665 +3382 4719 +3382 4720 +3382 4721 +3383 835 +3383 1003 +3383 1288 +3383 2788 +3383 2867 +3383 4625 +3383 4722 +3383 4723 +3383 4724 +558 7 +558 17 +558 122 +558 144 +558 146 +558 250 +558 353 +558 698 +558 5570 +558 5571 +3409 288 +3409 325 +3409 707 +3409 1120 +3409 1211 +3409 1904 +3409 3439 +3409 3849 +3409 4369 +3409 4754 +3897 1223 +3897 3695 +3897 3981 +3897 4059 +3897 4371 +955 690 +955 711 +955 781 +955 908 +955 1337 +955 1541 +955 1901 +955 2214 +955 2422 +955 2428 +955 2805 +955 2837 +955 2838 +955 2839 +955 2840 +955 2841 +955 2842 +955 2843 +1265 2377 +1427 2377 +1584 1036 +1602 121 +1602 122 +1602 123 +1602 143 +1602 246 +1602 247 +1602 249 +1602 264 +1602 352 +1602 1245 +1699 813 +1699 1064 +1699 2207 +1699 3241 +1699 3463 +1699 3464 +1699 3465 +1699 3466 +1699 3467 +2269 738 +2269 2500 +2269 3798 +2269 3855 +2269 3952 +2269 3953 +2269 3954 +2269 3955 +2269 3956 +2269 3957 +3310 296 +3310 1444 +3310 1529 +3310 2453 +3310 3211 +3310 4664 +3310 4665 +3310 4666 +3310 4667 +3310 4668 +4239 2184 +2721 959 +2721 1526 +2721 2341 +2721 2397 +2721 2524 +2721 3215 +2721 3441 +2721 3695 +2721 4290 +4230 781 +4230 1106 +4230 3119 +4230 3344 +4230 3683 +4230 4156 +4230 5000 +4230 5151 +4230 5152 +4230 5153 +4232 962 +4232 2338 +4232 2361 +4232 2885 +4232 5053 +527 1020 +527 1171 +527 1342 +527 2671 +527 2837 +527 2935 +527 3786 +527 3840 +527 4248 +527 4455 +527 4876 +527 4979 +527 4980 +804 778 +804 805 +804 806 +804 807 +804 808 +804 809 +804 810 +804 811 +804 812 +804 813 +804 814 +804 815 +804 816 +804 817 +4234 146 +4234 177 +4234 238 +4234 264 +4234 352 +4234 424 +4234 427 +4234 2098 +4235 1516 +4235 1698 +4235 1786 +4235 1804 +4235 2218 +4235 2400 +4235 3129 +4235 3362 +4235 3473 +4235 5154 +2007 199 +2007 203 +2007 527 +2007 3581 +2007 3680 +2007 3785 +2007 3786 +2007 3787 +2007 3788 +2007 3789 +100 2017 +334 268 +334 376 +334 843 +334 1587 +334 1888 +334 2053 +334 2285 +334 2286 +334 2287 +335 81 +335 141 +335 494 +335 1052 +335 2023 +335 2319 +335 3590 +335 4152 +335 4153 +335 4154 +339 4 +339 5 +339 7 +339 148 +339 264 +339 364 +339 559 +339 1317 +339 1755 +339 2278 +151 152 +151 153 +151 154 +151 155 +151 156 +151 157 +151 158 +151 159 +151 160 +151 161 +178 255 +178 256 +178 554 +178 871 +178 1947 +178 2125 +178 2126 +178 2127 +178 2128 +178 2129 +1144 17 +1144 31 +1144 126 +1144 143 +1144 144 +1144 145 +1144 149 +1144 266 +1144 422 +1144 754 +1228 23 +1228 123 +1228 126 +1228 173 +1228 1896 +1228 3323 +1228 4906 +1228 4907 +1653 69 +1653 485 +1653 1246 +1653 1563 +1653 3403 +2288 3453 +2288 3791 +2288 3971 +2288 3972 +2288 3973 +2288 3974 +2288 3975 +2288 3976 +2288 3977 +2288 3978 +581 2538 +1493 1227 +1636 197 +1636 1553 +1636 1672 +1636 2629 +1636 3033 +1636 3389 +1636 3390 +1636 3391 +1636 3392 +1636 3393 +2823 1089 +2823 1915 +2823 2021 +2823 2884 +2823 3119 +2823 4165 +2823 4321 +2823 4322 +2823 4323 +2823 4324 +4260 3 +4260 9 +4260 123 +4260 124 +4260 149 +4260 238 +4260 249 +4260 352 +4260 367 +4260 369 +102 1928 +102 1968 +102 2026 +102 2027 +102 2028 +1212 665 +1212 777 +1212 840 +1212 1385 +1212 1402 +1212 1724 +1212 2790 +1212 3079 +1212 3080 +3849 8 +3849 123 +3849 129 +3849 174 +3849 248 +3849 352 +3849 369 +3849 424 +3849 1317 +3849 2338 +1387 860 +1387 1454 +1387 1457 +1387 1509 +1387 3220 +1387 3221 +1387 3280 +2050 136 +2050 458 +2050 1414 +2050 1661 +2050 1747 +2050 2630 +2050 3822 +2050 3823 +2050 3824 +2050 3825 +4487 842 +4487 1103 +4487 1141 +4487 1481 +4487 2201 +4487 2453 +4487 3207 +4487 3327 +4487 3714 +4487 4111 +2593 866 +2593 932 +2593 1303 +2593 1377 +2593 1492 +2593 4190 +2593 4191 +2593 4192 +2593 4193 +3364 135 +3364 840 +3364 968 +3364 1740 +3364 1741 +3364 3132 +3364 3334 +3364 4705 +3364 4706 +4159 230 +4159 1425 +4159 2058 +4159 2869 +4159 3759 +4159 3786 +4159 4068 +4159 4270 +4159 5361 +4159 5788 +5629 92 +5629 133 +5629 177 +5629 731 +5629 2443 +5629 2779 +5629 4111 +5629 4646 +5629 5775 +5931 731 +5931 1129 +5931 5228 +5931 5686 +5931 5999 +6071 364 +6071 3298 +6071 5014 +6071 5081 +6071 5179 +6071 5980 +6071 6249 +6071 6250 +6071 6251 +6071 6252 +560 561 +560 562 +560 563 +560 564 +560 565 +560 566 +560 567 +560 568 +560 569 +560 570 +2997 738 +2997 1635 +2997 1650 +2997 2312 +2997 2337 +2997 2414 +2997 2554 +2997 2858 +2997 3772 +2997 4444 +3001 200 +859 671 +859 860 +859 861 +859 862 +859 863 +859 864 +859 865 +859 866 +859 867 +859 868 +2184 3923 +2184 3924 +2184 3925 +2184 3926 +2184 3927 +3373 4 +3373 9 +3373 251 +3373 698 +3373 2599 +3373 4250 +3373 4710 +3373 4711 +3373 4712 +3373 4713 +3374 1090 +3374 1528 +3374 1816 +3374 2474 +3374 2524 +3374 3067 +3374 3108 +3374 3233 +3374 3755 +3374 4210 +1706 8 +1706 121 +1706 123 +1706 128 +1706 179 +1706 238 +1706 247 +1706 248 +1706 264 +1706 353 +1891 199 +1891 538 +1891 725 +1891 852 +1891 1397 +1891 2914 +1891 3166 +1891 3670 +1891 3671 +1891 3672 +3096 654 +3096 1289 +3096 1860 +3096 4459 +3096 4512 +3096 4517 +3096 4518 +3096 4519 +3096 4520 +3822 78 +3822 886 +3822 1423 +3822 2642 +3822 2982 +3822 3779 +3822 4623 +3822 4746 +3822 4939 +2060 3551 +132 5 +132 9 +132 147 +132 250 +132 353 +132 629 +132 753 +132 856 +132 1317 +132 2077 +1535 261 +1535 694 +1535 1608 +1535 1631 +1535 1940 +1535 2179 +1535 2724 +1535 3334 +1535 3335 +1535 3336 +2070 45 +2070 658 +2070 1425 +2070 2167 +2070 2595 +2070 2966 +2070 3834 +2070 3835 +2070 3836 +2070 3837 +2075 219 +2075 668 +2075 1575 +2075 1647 +2075 1786 +2075 1913 +2075 2229 +2075 2418 +2075 3586 +2075 3838 +285 134 +285 311 +285 712 +285 873 +285 955 +285 1197 +285 1227 +285 2218 +285 2219 +285 2243 +3337 32 +3337 1018 +3337 1061 +3337 1675 +3337 2723 +3337 3617 +3337 4286 +3337 4679 +3337 4680 +3337 4681 +5048 5566 +5171 795 +5171 1180 +5171 1338 +5171 2348 +5171 3453 +5171 3801 +5171 5642 +5171 5675 +5171 5676 +5171 5677 +5338 4 +5338 122 +5338 143 +5338 180 +5338 252 +5338 266 +5338 368 +5338 369 +5338 427 +5338 754 +5940 376 +5941 110 +5941 858 +5941 1169 +5941 1509 +5941 2111 +5941 3249 +5941 5978 +5941 6073 +5941 6074 +5941 6075 +490 356 +490 520 +490 852 +490 2069 +490 2167 +490 2214 +490 2403 +490 2464 +490 2465 +490 2466 +496 164 +496 418 +496 633 +496 762 +496 1471 +496 2358 +496 2376 +496 2472 +496 2473 +496 2474 +2221 152 +2221 219 +2221 976 +2221 1044 +2221 1235 +2221 2248 +2221 2673 +2221 3589 +2221 3929 +3408 462 +3408 582 +3408 940 +3408 1530 +3408 2795 +3408 3717 +3408 4237 +3408 4519 +3408 4752 +3408 4753 +551 586 +551 765 +551 955 +551 982 +551 1288 +551 1311 +551 2336 +551 2516 +551 2517 +551 2518 +1184 2259 +1994 664 +1994 788 +1994 1022 +1994 1195 +1994 1371 +1994 1688 +1994 1762 +1994 1954 +1994 2001 +1994 2226 +1994 2255 +1994 2366 +1994 2377 +1994 2384 +1994 2490 +1994 2597 +1994 3429 +1994 3778 +1994 3779 +1994 3780 +1994 3781 +1994 3782 +1994 3783 +1994 3784 +4459 2139 +4459 2425 +4459 2431 +4459 2570 +4459 4507 +4459 5017 +4459 5116 +4459 5150 +4459 5302 +4459 5303 +1920 255 +1920 1005 +1920 1048 +1920 1548 +1920 1772 +1920 1956 +1920 2709 +1920 3685 +1920 3686 +1920 3687 +3066 816 +3066 926 +3066 1568 +3066 1671 +3066 4640 +3066 4714 +3066 5001 +3066 5403 +3066 5404 +3066 5405 +3344 455 +3344 1317 +3344 3894 +3344 4688 +3344 4689 +3715 116 +3715 429 +3715 2287 +3715 4002 +3715 4476 +3715 4839 +3715 4894 +3715 4895 +3715 4896 +3715 4897 +3715 4898 +4539 1651 +4539 2166 +4539 3352 +4539 3781 +4539 4553 +4539 5068 +4539 5085 +4539 5572 +4539 5868 +4539 5884 +695 106 +695 290 +695 1690 +695 1956 +695 2385 +695 2593 +695 2594 +695 2595 +695 2596 +2761 222 +2761 1780 +2761 2008 +2761 2048 +2761 2086 +2761 3484 +2761 3981 +2761 4093 +2761 4298 +2761 4299 +3147 240 +3147 534 +3147 4270 +3147 4653 +3893 126 +3893 145 +3893 147 +3893 252 +3893 667 +3893 732 +3893 754 +3893 1909 +3893 3349 +637 796 +637 869 +637 870 +637 871 +637 872 +637 873 +637 874 +637 875 +637 876 +637 877 +2237 1402 +2237 1454 +2237 1458 +2237 1728 +2237 1866 +2237 2658 +2237 2719 +2237 2789 +2237 3220 +2237 3357 +2524 38 +2524 103 +2524 289 +2524 1252 +2524 2551 +2524 2764 +2524 3114 +2524 3926 +2524 5653 +2524 5840 +423 4 +423 127 +423 390 +423 427 +423 2403 +423 2404 +423 2405 +423 2406 +423 2407 +423 2408 +756 127 +756 262 +756 531 +756 757 +756 758 +756 759 +756 760 +756 761 +756 762 +756 763 +759 77 +759 464 +759 568 +759 1454 +759 2707 +759 2708 +759 2709 +759 2710 +759 2711 +759 2712 +820 3 +820 5 +820 7 +820 125 +820 126 +820 128 +820 145 +820 369 +820 424 +820 1317 +821 32 +821 928 +821 1223 +821 1224 +821 1231 +821 1873 +821 2734 +821 2735 +821 2736 +821 2737 +823 563 +823 894 +823 1264 +823 1322 +823 1323 +823 1324 +823 1325 +823 1326 +823 1327 +823 1328 +2974 50 +2974 892 +2974 1077 +2974 1203 +2974 2089 +2974 2562 +2974 2861 +2974 3749 +2974 4436 +2974 4437 +355 49 +355 117 +355 968 +355 2308 +355 2309 +355 2310 +355 2311 +355 2312 +355 2313 +355 2314 +356 572 +356 980 +356 1212 +356 2321 +356 2322 +356 2323 +356 2324 +356 2325 +356 2326 +356 2327 +359 520 +359 633 +359 1334 +359 1451 +359 2332 +359 2333 +359 2334 +359 2335 +359 2336 +359 2337 +1441 567 +1441 1957 +1441 2493 +1441 3093 +1441 3187 +1441 3298 +1441 3299 +1441 3300 +1441 3301 +1589 156 +1589 1056 +1589 1203 +1589 1327 +1589 2304 +1589 3364 +1589 3365 +1589 3366 +1589 3367 +1589 3368 +2597 21 +2597 352 +2597 476 +2597 505 +2597 621 +2597 1347 +2597 2964 +2597 3607 +2597 3687 +2597 3871 +2599 665 +2599 1175 +2599 1866 +2599 1867 +2599 2563 +2599 3033 +2599 3980 +2599 4199 +2599 4200 +3700 803 +3700 1050 +3700 1317 +3700 1396 +3700 1437 +3700 1481 +3700 2054 +3700 2114 +3700 4017 +3700 4899 +629 323 +629 336 +629 1067 +629 1426 +629 1427 +629 1428 +629 1429 +629 1430 +629 1431 +629 1432 +1129 5 +1129 7 +1129 145 +1129 248 +1129 353 +1129 426 +1129 629 +1129 753 +1129 2077 +1129 3002 +2278 152 +2278 1313 +2278 1901 +2278 1997 +2278 2200 +2278 2602 +2278 2975 +2278 3968 +2278 3969 +2278 3970 +2733 3 +2733 8 +2733 177 +2733 238 +2733 249 +2733 368 +2733 369 +2733 427 +2733 667 +2733 717 +3235 255 +3235 542 +3235 884 +3235 1313 +3235 1538 +3235 2726 +3235 2758 +3235 4620 +3235 4621 +3235 4622 +3931 566 +3931 3212 +3931 3352 +3931 5051 +889 2547 +889 2951 +1143 172 +1143 1556 +1143 1766 +1143 1852 +1143 1890 +1143 2384 +1143 2544 +1143 2666 +1143 3032 +1143 3033 +3933 45 +3933 219 +3933 425 +3933 1056 +3933 2344 +3933 2781 +3933 3995 +3933 4361 +3933 4720 +3933 5008 +1173 412 +1173 1001 +1173 1060 +1173 1441 +1173 2683 +1173 2746 +1173 3781 +1173 3865 +1173 5009 +2358 215 +2358 1522 +2358 2443 +2358 4056 +2358 4281 +2358 4844 +2358 6168 +2358 6232 +3934 15 +3934 855 +3934 1212 +3934 2563 +3934 4629 +3934 4950 +3934 5088 +3934 5414 +3934 5889 +3934 5890 +3937 4 +3937 125 +3937 143 +3937 144 +3937 146 +3937 147 +3937 175 +3937 179 +3937 180 +3937 558 +180 3 +180 1489 +180 1490 +180 1524 +180 1766 +180 2130 +180 2131 +180 2132 +180 2133 +180 2134 +238 9 +238 143 +238 146 +238 174 +238 667 +238 2181 +238 2182 +238 2183 +238 2184 +238 2185 +108 324 +108 365 +108 1486 +108 2037 +108 2038 +108 2039 +108 2040 +108 2041 +108 2042 +108 2043 +391 122 +391 124 +391 146 +391 248 +391 353 +391 422 +391 427 +391 717 +391 718 +391 2338 +392 814 +392 944 +392 1846 +392 2381 +392 2382 +392 2383 +392 2384 +392 2385 +392 2386 +392 2387 +398 176 +398 977 +398 1947 +398 2374 +398 2375 +398 2376 +398 2377 +398 2378 +398 2379 +398 2380 +2578 490 +2578 1775 +2578 2096 +2578 3405 +2578 3616 +2578 3967 +2578 4129 +2578 4222 +2578 4223 +2578 4224 +2581 129 +2581 171 +2581 889 +2581 2553 +2581 3109 +2581 4009 +2581 4201 +2581 4202 +2581 4203 +2581 4204 +554 1547 +554 2148 +554 2472 +554 3141 +554 3283 +554 3312 +554 4477 +554 4515 +554 4516 +1534 303 +1534 424 +1534 771 +1534 804 +1534 1457 +1534 2288 +1534 3170 +1534 3282 +1534 4172 +1534 4301 +1534 4359 +1534 4793 +1534 4818 +1534 4891 +1534 5414 +1534 5895 +1534 5916 +1534 6061 +1534 6062 +2362 327 +2362 684 +2362 1954 +2362 2360 +2362 2666 +2362 4045 +2362 4046 +2362 4047 +2362 4048 +2362 4049 +3163 1021 +3163 2048 +3163 2476 +3163 2787 +3163 3617 +3163 4291 +3163 4566 +3163 4567 +3163 4568 +422 1911 +422 2394 +422 2395 +422 2396 +422 2397 +422 2398 +422 2399 +422 2400 +422 2401 +422 2402 +584 585 +584 586 +584 587 +2614 548 +2614 1165 +2614 1217 +2614 1342 +2614 1985 +2614 2018 +2614 2022 +2614 2343 +2614 2384 +2614 2465 +2614 3232 +2614 3385 +2614 3488 +2614 3903 +2614 4159 +2614 4212 +2614 4213 +2614 4214 +2614 4215 +2614 4216 +2614 4217 +2614 4218 +2615 453 +2615 1273 +2615 1656 +2615 2787 +2615 3053 +2615 3509 +2615 4143 +2615 4219 +2615 4220 +2615 4221 +2617 215 +2617 1313 +2617 1803 +2617 2443 +2617 2643 +2617 2654 +2617 3558 +2617 4037 +253 219 +253 254 +253 255 +253 256 +253 257 +253 258 +253 259 +253 260 +253 261 +253 262 +924 5 +924 7 +924 122 +924 123 +924 149 +924 176 +924 179 +924 249 +924 264 +924 717 +1867 665 +1867 810 +1867 1607 +1867 1849 +1867 2105 +1867 2787 +1867 3615 +1867 3616 +1867 3617 +1867 3618 +2281 344 +2281 930 +2281 1744 +2281 2275 +2281 2292 +2281 2498 +2281 3296 +2281 3569 +2281 3962 +2281 3963 +3771 184 +3771 215 +3771 286 +3771 1979 +3771 2748 +3771 4301 +3771 4840 +3771 4926 +3771 4927 +3771 4928 +3772 2414 +133 110 +133 253 +133 1193 +133 1531 +133 1896 +133 2084 +133 2085 +133 2086 +133 2087 +133 2088 +864 198 +864 290 +864 837 +864 894 +864 1333 +864 2517 +864 2744 +864 2745 +864 2746 +864 2747 +2079 295 +2079 864 +2079 1029 +2079 1850 +2079 2114 +2079 3228 +2079 3851 +2079 3852 +2079 3853 +2079 3854 +2080 71 +2080 1027 +2080 2424 +2080 2602 +2080 2653 +2080 3055 +2080 3448 +2080 3839 +2080 3840 +2080 3841 +547 117 +547 335 +547 824 +547 1790 +547 2078 +547 2151 +547 2240 +547 2418 +547 2514 +547 2515 +941 6087 +945 336 +945 660 +945 801 +945 940 +945 1095 +945 2846 +945 3777 +945 4409 +945 4410 +945 4411 +165 102 +165 108 +165 531 +165 703 +165 1165 +165 1390 +165 1561 +165 1865 +165 2123 +165 2124 +3801 235 +3801 342 +3801 1120 +3801 1591 +3801 1592 +3801 2476 +3801 2612 +3801 3096 +3801 4131 +3946 124 +3946 249 +3946 251 +3946 264 +3946 367 +3946 422 +3946 667 +3946 718 +3946 856 +4300 11 +4300 133 +4300 1492 +4300 2119 +4300 2479 +4300 3699 +4300 5202 +4300 5203 +4300 5204 +4301 165 +4301 1800 +4301 1868 +4301 2324 +4301 3462 +327 8 +327 96 +327 627 +327 681 +327 822 +327 2179 +327 2273 +327 2274 +327 2275 +327 2276 +2451 81 +2451 892 +2451 2345 +2451 3205 +2451 3442 +2451 3719 +2451 3735 +2451 4121 +2451 4122 +2451 4123 +3228 294 +3228 1511 +3228 2024 +3228 2677 +3228 2935 +3228 2936 +3228 3908 +3228 4614 +3228 4615 +3228 4616 +1433 121 +1433 124 +1433 129 +1433 143 +1433 146 +1433 147 +1433 183 +1433 266 +1433 559 +1433 718 +2032 3 +2032 121 +2032 125 +2032 179 +2032 249 +2032 251 +2032 264 +2032 423 +2032 427 +2032 717 +715 638 +715 834 +715 1068 +715 1195 +715 2472 +715 2645 +715 2646 +715 2647 +715 2648 +715 2649 +1004 106 +1004 693 +1004 1591 +1004 1760 +1004 2212 +1004 2552 +1004 2903 +1004 2904 +1004 2905 +1004 2906 +2279 401 +2279 1273 +2279 1337 +2279 1587 +2279 1797 +2279 3397 +2279 3964 +2279 3965 +2279 3966 +2279 3967 +2284 4105 +2819 5 +2819 144 +2819 148 +2819 149 +2819 252 +2819 266 +2819 422 +2819 559 +2819 856 +2819 2098 +91 243 +91 1923 +91 2194 +1946 440 +1946 984 +1946 2486 +1946 2600 +1946 3058 +1946 3070 +1946 3310 +1946 3725 +1947 208 +1947 1934 +1947 2456 +1947 3419 +1947 3727 +1947 3728 +1947 3729 +1947 3730 +1947 3731 +1947 3732 +1948 121 +1948 126 +1948 128 +1948 144 +1948 145 +1948 148 +1948 265 +1948 368 +1948 559 +1948 1626 +1950 1528 +1950 2089 +1950 2462 +1950 2652 +1950 2931 +1951 3113 +732 309 +732 928 +732 1071 +732 1233 +732 1246 +732 1435 +732 2228 +732 2650 +732 2651 +732 2652 +1390 313 +1390 387 +1390 1942 +1390 2322 +1390 2904 +1390 3230 +1390 3231 +1390 3232 +1390 3233 +1390 3234 +1393 4 +1393 5 +1393 145 +1393 147 +1393 149 +1393 183 +1393 252 +1393 390 +1393 423 +1393 667 +1396 266 +1396 437 +1396 459 +1396 1178 +1396 1409 +1396 1504 +1396 1800 +1396 1842 +1396 2871 +1396 3281 +1397 279 +1397 665 +1397 822 +1397 1143 +1397 1890 +1397 2160 +1397 2384 +1397 3194 +1397 3288 +1397 3289 +1414 9 +1414 17 +1414 31 +1414 126 +1414 180 +1414 266 +1414 424 +1414 666 +1414 697 +1414 2018 +2399 59 +2399 730 +2399 1904 +2399 2395 +2399 2398 +2399 2551 +2399 3328 +2399 3921 +2399 4085 +2399 4086 +3394 1724 +3394 2066 +3394 2275 +3394 3660 +3394 4603 +3394 4727 +3394 4728 +3394 4729 +3394 4730 +693 1628 +693 2602 +693 2603 +693 2604 +693 2605 +693 2606 +693 2607 +693 2608 +693 2609 +693 2610 +1273 330 +1273 2868 +1273 3120 +1273 3121 +1273 3122 +1273 3123 +1273 3124 +1273 3125 +1273 3126 +1273 3127 +2808 102 +2808 552 +2808 667 +2808 677 +2808 1056 +2808 1956 +2808 2719 +2808 4189 +2808 4316 +2808 4317 +1336 260 +2392 21 +2392 503 +2392 804 +2392 808 +2392 1339 +2392 1547 +2392 2839 +2392 3346 +2392 4080 +2392 4081 +2757 1829 +2757 3882 +2757 4405 +2757 4406 +1198 338 +1198 1158 +1198 1382 +1198 1383 +1198 3059 +1198 3060 +1198 3061 +1198 3062 +1198 3063 +1198 3064 +2046 7 +2046 9 +2046 122 +2046 127 +2046 145 +2046 248 +2046 249 +2046 251 +2046 353 +2046 369 +2047 5 +2047 145 +2047 149 +2047 175 +2047 177 +2047 180 +2047 266 +2047 353 +2047 424 +2047 1246 +2048 659 +2048 1801 +2048 1817 +2048 2305 +2048 2327 +2048 2764 +2048 2852 +2048 3149 +2048 3812 +2048 3813 +2049 740 +2049 1299 +2049 2684 +2049 2768 +2049 2903 +2049 3004 +2049 3039 +2049 3814 +2049 3815 +2049 3816 +92 2015 +92 2016 +963 1054 +963 1124 +963 1831 +963 2287 +963 2291 +963 2686 +963 2851 +963 2852 +963 2853 +963 2854 +1767 1084 +1767 1768 +1767 1769 +1767 1770 +1767 1771 +1767 1772 +1767 1773 +1767 1774 +1767 1775 +1767 1776 +3411 440 +3411 793 +3411 892 +3411 1120 +3411 1439 +3411 1507 +3411 2769 +3411 4750 +3411 4751 +2881 4 +2881 144 +2881 148 +2881 175 +2881 180 +2881 266 +2881 424 +2881 666 +2881 886 +2881 2018 +726 152 +726 406 +726 540 +726 3459 +726 3654 +726 3726 +726 4072 +726 5137 +726 5138 +726 5139 +4211 4 +4211 10 +4211 122 +4211 251 +4211 265 +4211 369 +4211 426 +4211 427 +4211 698 +4211 946 +29 962 +29 1656 +29 2201 +576 1827 +576 2481 +576 2953 +576 3171 +576 4846 +576 5235 +576 5236 +576 5237 +576 5238 +576 5239 +2396 20 +2396 1162 +2396 1670 +2396 2173 +2396 3059 +2396 4004 +2396 4082 +2396 4083 +2396 4084 +4469 548 +4469 1160 +4469 2126 +4469 2499 +4469 2690 +4469 3574 +4469 3917 +4469 5308 +4469 5309 +4469 5310 +4470 4 +4470 7 +4470 126 +4470 143 +4470 147 +4470 266 +4470 422 +4470 558 +4470 754 +4470 856 +1547 1023 +1547 1339 +1547 1636 +1547 2499 +1547 3169 +1547 3342 +1547 3343 +1547 3344 +1547 3345 +1547 3346 +2331 5437 +2348 1087 +3194 4587 +4665 110 +4665 566 +4665 928 +4665 2254 +4665 2666 +4665 2744 +4665 2859 +4665 3097 +4665 5159 +4665 5412 +4720 131 +4720 133 +4720 400 +4720 883 +4720 4031 +4720 4373 +4720 4400 +4720 4871 +4720 4951 +4720 5438 +4721 51 +4721 472 +4721 1411 +4721 1926 +4721 3552 +4721 4160 +4721 5159 +4721 5439 +4721 5440 +4721 5441 +4723 529 +4723 649 +4723 2358 +4723 3220 +4723 4670 +4723 4676 +4723 4844 +4723 5241 +4723 5428 +4723 5442 +4724 63 +4724 514 +4724 1694 +4724 4296 +4724 5155 +4724 5443 +4724 5444 +4724 5445 +4724 5446 +288 92 +288 209 +288 1917 +288 1946 +288 1957 +288 2015 +288 2244 +288 2245 +288 2246 +325 82 +325 1507 +325 1669 +325 2159 +325 2187 +325 2268 +325 2269 +325 2270 +325 2271 +325 2272 +707 115 +707 1047 +707 1107 +707 1503 +707 1656 +707 1803 +707 2641 +707 2642 +707 2643 +707 2644 +1211 1800 +4369 3694 +4369 5186 +4369 5252 +4369 5253 +4369 5254 +4369 5255 +4369 5256 +4369 5257 +4369 5258 +4369 5259 +4754 115 +4754 124 +4754 483 +4754 521 +4754 1413 +4754 1654 +4754 1768 +4754 4113 +4754 4914 +4754 5467 +1223 651 +1223 751 +1223 1800 +1223 1827 +1223 3156 +1223 3905 +1223 3981 +1223 5192 +1223 5311 +1223 5312 +3981 127 +3981 878 +3981 1007 +3981 1540 +3981 2592 +3981 3557 +3981 4793 +3981 5496 +3981 6241 +3981 6242 +4059 3789 +908 648 +908 697 +908 942 +908 1512 +908 1842 +908 2786 +908 2787 +908 2788 +908 2789 +908 2790 +1337 38 +1337 143 +1337 266 +1337 693 +1337 911 +1337 1221 +1337 1724 +1337 1725 +1337 1726 +1337 1727 +1541 3 +1541 122 +1541 325 +1541 548 +1541 679 +1541 1245 +1541 2039 +1541 3096 +1541 3323 +1541 3347 +2428 451 +2428 532 +2428 1766 +2428 2068 +2428 2069 +2428 2193 +2428 4028 +2428 4095 +2428 4096 +2428 4097 +2377 227 +2377 432 +2377 500 +2377 561 +2377 2392 +2377 2646 +2377 2798 +2377 3172 +2377 4063 +2377 4064 +3463 257 +3463 478 +3463 786 +3463 1129 +3463 2261 +3463 2330 +3463 3417 +3463 4767 +3463 4768 +3465 7 +3465 8 +3465 126 +3465 149 +3465 427 +3465 1246 +3465 1388 +3465 2538 +3465 4551 +3465 4769 +3466 50 +3466 51 +3466 732 +3466 1313 +3466 1325 +3466 1980 +3466 2309 +3466 2984 +3466 3141 +3466 3405 +2500 297 +2500 660 +2500 1573 +2500 2221 +2500 3057 +2500 3705 +2500 4148 +2500 4149 +2500 4150 +2500 4151 +3798 1313 +3798 2375 +3798 2378 +3798 2612 +3798 3211 +3798 3479 +3798 3563 +3798 4209 +3798 4534 +3798 4931 +3952 4706 +3956 1030 +3956 2254 +3956 3822 +3956 5016 +3956 5017 +1444 5490 +1444 5491 +1529 541 +1529 892 +1529 1385 +1529 2347 +1529 2854 +1529 2886 +1529 3330 +1529 3331 +1529 3332 +1529 3333 +2453 125 +2453 126 +2453 128 +2453 145 +2453 179 +2453 180 +2453 250 +2453 856 +2453 2001 +4664 3635 +4664 5434 +4664 5435 +4664 5436 +4666 15 +4666 1158 +4666 1278 +4666 1383 +4666 2558 +4666 3062 +4666 4296 +4666 4297 +4666 4988 +4666 5413 +4667 458 +4667 1482 +4667 1524 +4667 1599 +4667 2887 +4667 3046 +4667 3675 +4667 5101 +4667 5373 +3441 803 +3441 1750 +3441 2299 +3441 2646 +3441 3024 +3441 3439 +3441 3440 +3441 3654 +3441 4838 +3441 4839 +3441 4840 +3441 4841 +3441 4842 +3441 4843 +5151 219 +5151 459 +5151 612 +5151 1102 +5151 2403 +5151 3017 +5151 5510 +5151 5658 +5151 5659 +5152 380 +5152 666 +5152 1540 +5152 1751 +5152 2577 +5152 3174 +5152 3658 +5152 4578 +5152 5199 +5152 5581 +962 867 +962 1228 +962 1777 +962 1778 +962 1779 +962 1780 +962 1781 +962 1782 +962 1783 +962 1784 +2338 256 +2338 840 +2338 1031 +2338 1457 +2338 1509 +2338 2785 +2338 3006 +2338 3743 +2338 5056 +2338 5645 +2361 325 +2361 2662 +2361 2911 +2361 3384 +2361 4088 +2885 129 +2885 176 +2885 177 +2885 180 +2885 266 +2885 368 +2885 390 +2885 427 +2885 667 +2885 856 +5053 116 +5053 906 +5053 1250 +5053 1541 +5053 1859 +5053 3114 +5053 3319 +5053 3726 +5053 4189 +805 57 +805 106 +805 528 +805 637 +805 686 +805 769 +805 770 +805 1644 +805 2738 +805 2739 +811 643 +811 712 +811 965 +811 1151 +811 2176 +811 2729 +811 2730 +811 2731 +811 2732 +811 2733 +816 1048 +816 1129 +816 2237 +816 2548 +816 4695 +816 4844 +816 4878 +816 5224 +816 5628 +816 5629 +1698 2026 +1698 2551 +1698 2850 +1698 2980 +1698 3220 +1698 3450 +1698 3451 +1698 3452 +1698 3453 +1698 3454 +3129 334 +3129 2360 +3129 3634 +3129 3962 +3129 4548 +5154 49 +5154 803 +5154 1219 +5154 1255 +5154 2285 +5154 3017 +5154 3133 +5154 5023 +5154 5463 +5154 5670 +203 5973 +203 5974 +2017 96 +2017 1914 +2017 2750 +2017 2794 +2017 3713 +2017 3807 +2017 3808 +2017 3809 +2017 3810 +2017 3811 +1888 345 +1888 846 +1888 1251 +1888 1826 +1888 1889 +1888 1890 +1888 1891 +1888 1892 +1888 1893 +1888 1894 +2053 252 +2053 368 +2053 369 +2053 390 +2053 423 +2053 1208 +2053 2621 +2053 3675 +2053 3826 +2053 3827 +2285 309 +2285 1019 +2285 1176 +2285 2848 +2285 3164 +2285 3457 +2285 3977 +2285 3979 +2285 3980 +2285 3981 +2286 123 +2286 124 +2286 179 +2286 238 +2286 367 +2286 423 +2286 427 +2286 853 +2286 2059 +2286 3764 +81 1067 +81 1916 +81 1984 +81 1985 +81 1986 +81 1987 +81 1988 +81 1989 +81 1990 +81 1991 +141 7 +141 142 +141 143 +141 144 +141 145 +141 146 +141 147 +141 148 +141 149 +141 150 +494 658 +494 892 +494 924 +494 1372 +494 1787 +494 2475 +494 2476 +494 2477 +494 2478 +494 2479 +2023 38 +2023 281 +2023 369 +2023 2152 +2023 2728 +2023 3487 +2023 3489 +2023 3595 +2023 3797 +2023 3798 +3590 4845 +4152 468 +4152 1655 +4152 2011 +4152 2645 +4152 3016 +4152 4197 +4152 4275 +4152 4438 +4152 4472 +4152 5092 +4154 586 +4154 1085 +4154 1859 +4154 2387 +4154 2894 +4154 4202 +4154 4628 +4154 5093 +4154 5094 +4154 5095 +155 5 +155 121 +155 126 +155 128 +155 129 +155 175 +155 238 +155 353 +155 1317 +158 411 +158 813 +158 1688 +158 2104 +158 2105 +158 2106 +158 2107 +158 2108 +160 13 +160 2053 +160 2056 +160 2109 +160 2110 +160 2111 +160 2112 +160 2113 +160 2114 +160 2115 +173 124 +173 128 +173 144 +173 174 +173 175 +173 176 +173 177 +173 178 +173 179 +173 180 +3323 122 +3323 127 +3323 145 +3323 148 +3323 176 +3323 177 +3323 249 +3323 424 +3323 427 +3323 1246 +485 8 +485 121 +485 123 +485 148 +485 179 +485 249 +485 251 +485 353 +485 369 +485 1317 +3403 7 +3403 123 +3403 125 +3403 144 +3403 149 +3403 248 +3403 251 +3403 367 +3403 424 +3403 1317 +3791 174 +3791 823 +3791 2032 +3791 2971 +3791 3185 +3791 4419 +3791 4526 +3791 4894 +3791 4928 +3791 4929 +3975 57 +3976 149 +3976 266 +3976 368 +3976 423 +3976 424 +3976 559 +3976 718 +3976 856 +3976 1245 +197 198 +197 199 +197 200 +197 201 +197 202 +197 203 +197 204 +197 205 +197 206 +197 207 +1672 1673 +2629 127 +2629 128 +2629 129 +2629 176 +2629 229 +2629 353 +2629 1317 +2629 2115 +2629 3102 +2629 4228 +3033 1476 +3033 1894 +3033 2361 +3033 2532 +3033 3173 +3033 3806 +3033 3833 +3033 3918 +3033 4464 +3033 4465 +3390 661 +3390 976 +3390 1023 +3390 1313 +3390 1530 +3390 1802 +3390 2981 +3390 3727 +3390 4725 +3390 4726 +3393 646 +3393 1251 +3393 1487 +3393 1618 +3393 3223 +3393 3463 +3393 4731 +3393 4732 +1089 96 +1089 727 +1089 944 +1089 1313 +1089 2523 +1089 2872 +1089 3109 +4324 92 +4324 315 +4324 2200 +4324 3095 +4324 3136 +4324 3843 +4324 4721 +4324 5214 +4324 5215 +4324 5216 +1968 476 +1968 955 +1968 1054 +1968 1773 +1968 2625 +1968 3733 +1968 3734 +1968 3735 +1968 3736 +777 352 +777 778 +777 779 +777 780 +777 781 +777 782 +777 783 +777 784 +777 785 +777 786 +1385 69 +1385 191 +1385 616 +1385 3213 +1385 3248 +1385 3249 +1385 3250 +1385 3251 +1385 3252 +1385 3253 +1402 55 +1402 96 +1402 1444 +1402 2186 +1402 2662 +1402 3137 +1402 3258 +1402 3259 +1402 3260 +1402 3261 +1724 493 +1724 837 +1724 1677 +1724 1726 +1724 2038 +1724 3275 +1724 3487 +1724 3488 +1724 3489 +1724 3490 +2790 8 +2790 121 +2790 128 +2790 144 +2790 147 +2790 266 +2790 352 +2790 424 +2790 559 +2790 1317 +3080 38 +3080 706 +3080 1904 +3080 3334 +3080 3409 +3080 3679 +3080 3698 +3080 3849 +3080 4501 +3080 4502 +1454 3 +1454 629 +1454 691 +1454 937 +1454 1989 +1454 2089 +1454 3232 +1454 3307 +1454 3308 +1454 3309 +3220 152 +3220 503 +3220 507 +3220 548 +3220 2345 +3220 2575 +3220 4600 +3220 4601 +3220 4602 +136 57 +136 470 +136 852 +136 2480 +136 2984 +136 3219 +136 4463 +136 4944 +136 4945 +458 459 +458 460 +458 461 +458 462 +458 463 +458 464 +458 465 +458 466 +458 467 +458 468 +3823 1085 +3823 1089 +3823 1794 +3823 1888 +3823 2625 +3823 3829 +3823 4940 +3823 4941 +3823 4942 +3823 4943 +3824 3149 +1141 162 +1141 490 +1141 1122 +1141 1949 +1141 2353 +1141 3023 +1141 3024 +1141 3025 +1141 3026 +1141 3027 +2201 1511 +2201 1815 +2201 1944 +2201 2090 +2201 2416 +2201 2943 +2201 2981 +2201 3205 +2201 3319 +2201 3928 +3207 54 +3207 219 +3207 318 +3207 554 +3207 883 +3207 1935 +3207 3209 +3207 3995 +3207 4591 +3327 124 +3327 151 +3327 368 +3327 424 +3327 1317 +3327 1903 +3327 2086 +3327 3243 +3327 3994 +3327 4368 +3714 1056 +4111 5 +4111 31 +4111 149 +4111 177 +4111 179 +4111 250 +4111 352 +4111 558 +4111 697 +4111 1317 +866 162 +866 416 +866 635 +866 1351 +866 1408 +866 1860 +866 2326 +866 2763 +866 2764 +866 2765 +1377 247 +1377 963 +1377 1135 +1377 2006 +1377 2237 +1377 3082 +1377 3105 +1377 3224 +1377 3225 +1377 3226 +4191 370 +4191 432 +4191 495 +4191 503 +4191 2537 +4191 3004 +4191 3808 +4191 4293 +4191 4617 +4191 5121 +4193 365 +4193 787 +4193 995 +4193 1447 +4193 2601 +4193 2746 +4193 3499 +4193 3840 +4193 3896 +4193 4332 +135 34 +135 132 +135 786 +135 1150 +135 1274 +135 2099 +135 2100 +135 2101 +135 2102 +135 2103 +968 739 +968 828 +968 889 +968 969 +968 970 +968 971 +968 972 +968 973 +968 974 +1740 38 +1740 106 +1740 605 +1740 1133 +1740 1209 +1740 1631 +1740 3273 +1740 3497 +1740 3498 +1740 3499 +4705 5 +4705 144 +4705 148 +4705 249 +4705 252 +4705 264 +4705 266 +4705 367 +4705 666 +4705 1245 +3759 1217 +4068 113 +4068 363 +4068 828 +4068 2414 +4068 4885 +4068 4904 +4068 4953 +4068 5060 +4068 5061 +4068 5062 +5361 2035 +5361 4945 +5361 5115 +5361 5352 +5361 5789 +5361 5790 +5361 5791 +5361 5792 +5361 5793 +5361 5794 +5788 1173 +5788 1487 +5788 1544 +5788 3531 +5788 4885 +5788 5546 +5788 5655 +5788 5980 +5788 5981 +5788 5982 +731 649 +731 982 +731 1156 +731 1258 +731 2053 +731 2176 +731 2655 +731 2656 +731 2657 +731 2658 +2779 7 +2779 124 +2779 125 +2779 144 +2779 148 +2779 149 +2779 248 +2779 249 +2779 251 +2779 367 +5775 376 +5775 710 +5775 779 +5775 1122 +5775 1272 +5775 1375 +5775 2015 +5775 2422 +5775 2634 +5775 3335 +5775 4316 +5775 5850 +5775 5879 +5775 6008 +5775 6009 +5775 6010 +5775 6011 +5228 136 +5014 124 +5014 129 +5014 146 +5014 247 +5014 249 +5014 353 +5014 368 +5014 369 +5014 390 +5014 1245 +5980 563 +5980 762 +5980 789 +5980 835 +5980 977 +5980 1122 +5980 1903 +5980 1913 +5980 3956 +5980 6096 +6249 1402 +6249 4068 +6249 4281 +6249 4311 +6249 4540 +6249 4854 +6249 6151 +6249 6268 +6249 6269 +6249 6270 +6251 554 +6251 1524 +6251 1956 +6251 2023 +6251 2777 +6251 3038 +6251 4629 +6251 6102 +6251 6262 +6251 6263 +6252 2015 +6252 3509 +6252 3991 +6252 4691 +6252 5528 +6252 6098 +6252 6264 +6252 6265 +6252 6266 +6252 6267 +563 1575 +563 2582 +563 2583 +563 2584 +1650 526 +1650 876 +1650 1135 +1650 1565 +1650 1651 +1650 1652 +1650 1653 +1650 1654 +1650 1655 +1650 1656 +2312 148 +2312 174 +2312 251 +2312 264 +2312 367 +2312 368 +2312 390 +2312 422 +2312 718 +2312 1317 +2337 450 +2337 452 +2337 532 +2337 1239 +2337 1741 +2337 2381 +2337 2923 +2337 3102 +2337 3728 +2554 534 +2554 1400 +2554 2843 +2554 3684 +2554 3781 +2554 4166 +2554 4167 +2554 4168 +2554 4169 +4444 769 +4444 770 +4444 1528 +4444 1744 +4444 3852 +4444 4062 +4444 4551 +4444 5182 +4444 5285 +4444 5286 +863 202 +863 513 +863 649 +863 1481 +863 1775 +863 2125 +863 2740 +863 2741 +863 2742 +863 2743 +867 53 +867 470 +867 1734 +867 1738 +867 2527 +867 2766 +867 2767 +867 2768 +867 2769 +867 2770 +868 732 +868 1145 +868 1146 +868 1147 +868 1148 +868 1149 +868 1150 +868 1151 +868 1152 +868 1153 +3926 2349 +3926 2362 +3926 2596 +3926 2925 +3926 3098 +3926 3358 +3926 4413 +3926 4534 +3926 5002 +3926 5003 +1090 1374 +1090 1516 +1090 1568 +1090 1861 +1090 2078 +1090 2222 +1090 2430 +1090 3110 +1090 3111 +1816 628 +1816 820 +1816 1258 +1816 2873 +1816 2975 +1816 3262 +1816 3446 +1816 3551 +1816 3552 +1816 3553 +2474 330 +2474 534 +2474 970 +2474 1511 +2474 1764 +2474 1845 +2474 2300 +2474 5449 +2474 5450 +3067 318 +3067 908 +3067 1267 +3067 1412 +3067 2162 +3067 3487 +3067 3767 +3067 4489 +3067 4490 +3067 4491 +3233 8 +3233 122 +3233 144 +3233 148 +3233 174 +3233 179 +3233 424 +3233 427 +3233 1317 +3233 2338 +3670 406 +3670 933 +3670 1787 +3670 2344 +3670 2595 +3670 3699 +3670 3922 +3670 4540 +3670 4870 +3670 4882 +654 798 +654 1023 +654 1365 +654 2475 +654 2516 +654 2559 +654 2568 +654 2569 +654 2570 +654 2571 +1289 1043 +1289 1916 +1289 2944 +1289 2966 +1289 3142 +1289 3143 +1289 3144 +1289 3145 +1289 3146 +78 725 +78 898 +78 1157 +78 1894 +78 2203 +78 2204 +78 2205 +886 329 +886 887 +886 888 +886 889 +886 890 +886 891 +886 892 +886 893 +886 894 +886 895 +2642 813 +2642 4315 +4746 798 +4746 2443 +4746 2635 +4746 2639 +4746 3071 +4746 3854 +4746 4811 +4746 5369 +4746 5462 +4746 5463 +3551 3 +3551 122 +3551 125 +3551 126 +3551 144 +3551 145 +3551 174 +3551 248 +3551 264 +3551 367 +694 174 +694 175 +694 265 +694 351 +694 695 +694 696 +694 697 +694 698 +694 699 +694 700 +668 669 +668 670 +668 671 +668 672 +668 673 +668 674 +668 675 +668 676 +668 677 +668 678 +1647 5 +1647 147 +1647 149 +1647 175 +1647 252 +1647 667 +1647 856 +1647 1245 +1647 2018 +3838 606 +3838 814 +3838 1701 +3838 2285 +3838 3371 +3838 4132 +3838 4954 +3838 4955 +3838 4956 +3838 4957 +311 127 +311 143 +311 251 +311 252 +311 264 +311 369 +311 753 +311 1245 +311 3677 +2243 9 +2243 123 +2243 125 +2243 126 +2243 129 +2243 144 +2243 176 +2243 352 +2243 367 +2243 427 +32 957 +32 1028 +32 1199 +32 1459 +32 1699 +32 1700 +32 1701 +32 1702 +32 1703 +1675 214 +1675 281 +1675 322 +1675 402 +1675 554 +1675 776 +1675 829 +1675 858 +1675 898 +1675 1026 +1675 1087 +1675 1139 +1675 1575 +1675 1647 +1675 1671 +1675 1706 +1675 1787 +1675 1812 +1675 1952 +1675 2069 +1675 2278 +1675 2548 +1675 2585 +1675 2643 +1675 2964 +1675 3006 +1675 3170 +1675 3419 +1675 3420 +1675 3421 +1675 3422 +1675 3423 +1675 3424 +1675 3425 +1675 3426 +1675 3427 +1675 3428 +1675 3429 +1675 3430 +1675 3431 +1675 3432 +1675 3433 +1675 3434 +1675 3435 +1675 3436 +1675 3437 +1675 3438 +2723 661 +2723 814 +2723 1025 +2723 2038 +2723 2943 +2723 3613 +2723 4082 +2723 4284 +2723 4285 +2723 4286 +4680 1900 +4680 2477 +4680 3590 +4680 4080 +4680 4625 +1338 178 +1338 725 +1338 892 +1338 1530 +1338 2057 +1338 2570 +1338 2671 +1338 2786 +1338 3178 +1338 3179 +5675 2302 +5675 5474 +5675 5729 +5675 5933 +5675 5934 +5677 2625 +5677 3046 +5677 3292 +5677 4295 +5677 4806 +5677 5237 +5677 5315 +5677 5468 +5677 5935 +110 1332 +110 1361 +110 2029 +110 2030 +110 2031 +110 2032 +110 2033 +110 2034 +110 2035 +110 2036 +858 38 +858 263 +858 307 +858 412 +858 1704 +858 1705 +858 1706 +858 1707 +858 1708 +858 1709 +5978 124 +5978 238 +5978 266 +5978 353 +5978 367 +5978 422 +5978 423 +5978 427 +5978 559 +5978 717 +2069 347 +2069 1840 +2069 2051 +2069 2658 +2069 3357 +2069 3463 +2069 3637 +2069 3988 +2069 3989 +2069 3990 +2464 182 +2464 652 +2464 892 +2464 1988 +2464 2448 +2464 2982 +2464 4116 +2464 4117 +2464 4118 +2464 4119 +2465 3 +2465 31 +2465 124 +2465 146 +2465 175 +2465 180 +2465 247 +2465 266 +2465 367 +2465 2001 +418 763 +418 1541 +418 1944 +418 2467 +418 2468 +418 2469 +418 2470 +418 2471 +2376 94 +2376 522 +2376 802 +2376 1332 +2376 1738 +2376 2658 +2376 2906 +2376 3357 +2376 4065 +1235 123 +1235 143 +1235 176 +1235 264 +1235 352 +1235 353 +1235 390 +1235 423 +1235 718 +1235 2338 +2248 117 +2248 485 +2248 820 +2248 2353 +2248 3671 +2248 4067 +2248 5114 +2248 5115 +2248 5116 +2248 5117 +3929 76 +3929 513 +3929 550 +3929 604 +3929 712 +3929 1940 +3929 1955 +3929 1969 +3929 3022 +3929 3509 +582 412 +582 715 +582 1068 +582 1541 +582 1854 +582 2354 +582 2414 +582 2535 +582 2536 +582 2537 +4752 2 +4752 5 +4752 8 +4752 174 +4752 699 +4752 753 +4752 762 +4752 946 +4752 2063 +4752 4257 +982 3028 +982 3029 +982 3030 +982 3031 +2336 158 +2336 1227 +2336 1892 +2336 2099 +2336 2528 +2336 2538 +2336 2799 +2336 2805 +2336 3136 +2336 4041 +1022 1023 +1022 1024 +1022 1025 +1022 1026 +1022 1027 +1022 1028 +1022 1029 +1022 1030 +1022 1031 +1022 1032 +2384 187 +2384 503 +2384 1797 +2384 2350 +2384 2420 +2384 2563 +2384 4069 +2384 4070 +2384 4071 +2490 3 +2490 147 +2490 176 +2490 251 +2490 264 +2490 367 +2490 427 +2490 559 +2490 718 +2490 2018 +3429 1447 +3429 2292 +3429 2413 +3429 2918 +3429 4020 +3781 327 +3781 1059 +3781 1086 +3781 1123 +3781 2519 +3781 3850 +3781 4031 +3781 4923 +3781 4924 +3781 4925 +2425 108 +2425 354 +2425 1968 +2425 2155 +2425 2964 +2425 3046 +2425 4098 +2425 4099 +2425 4100 +2425 4101 +1005 174 +1005 227 +1005 1490 +1005 1624 +1005 2287 +1005 2330 +1005 2908 +1005 2909 +1005 2910 +1005 2911 +1048 844 +1048 973 +1048 1049 +1048 1050 +1048 1051 +1048 1052 +1048 1053 +1048 1054 +1048 1055 +1048 1056 +1548 169 +1548 880 +1548 1084 +1548 1947 +1548 2269 +1548 2822 +1548 3360 +1548 3361 +1548 3362 +1548 3363 +1772 255 +1772 815 +1772 1168 +1772 2265 +1772 2552 +1772 2736 +1772 2756 +1772 2943 +1772 2993 +1772 3530 +2709 23 +2709 518 +2709 2138 +2709 2360 +2709 2794 +2709 3992 +2709 4172 +2709 4287 +2709 4288 +2709 4289 +926 241 +926 347 +926 356 +926 478 +926 572 +926 2300 +926 2337 +926 2821 +926 2822 +926 2823 +5404 1143 +5404 2583 +5404 2658 +5404 2885 +5404 2961 +5404 5749 +5404 5763 +5404 5764 +5404 5805 +455 2038 +455 2188 +455 2241 +455 2441 +455 2442 +4689 924 +4689 1199 +4689 1288 +4689 1424 +4689 1866 +4689 1867 +4689 1868 +4689 2558 +4689 5423 +4689 5424 +116 510 +116 1089 +116 2013 +116 2030 +116 2051 +116 2052 +116 2053 +116 2054 +116 2055 +116 2056 +4002 3 +4002 121 +4002 123 +4002 124 +4002 128 +4002 247 +4002 367 +4002 717 +4002 1246 +4002 2098 +4839 356 +4839 572 +4839 1137 +4839 1287 +4839 1671 +4839 2324 +4839 2475 +4839 2648 +4839 2822 +4839 4754 +4896 263 +4896 733 +4896 878 +4896 1031 +4896 2449 +4896 2779 +4896 3553 +4896 5080 +4896 5568 +4896 5569 +1651 129 +1651 262 +1651 855 +1651 1318 +1651 1974 +1651 2974 +1651 3399 +1651 3400 +1651 3401 +1651 3402 +4553 3 +4553 124 +4553 146 +4553 251 +4553 266 +4553 422 +4553 667 +4553 856 +4553 2001 +4553 2018 +5572 56 +5572 206 +5572 787 +5572 788 +5572 4293 +5572 4676 +5572 5063 +5572 5879 +5572 5880 +5572 5881 +5884 6040 +2596 1491 +2596 1689 +2596 2083 +2596 3681 +2596 3953 +2596 4194 +2596 4195 +2596 4196 +2596 4197 +2596 4198 +1780 1666 +1780 2049 +1780 3533 +1780 3534 +1780 3535 +2086 381 +2086 1070 +2086 1587 +2086 1688 +2086 2720 +2086 2783 +2086 3842 +2086 3843 +2086 3844 +2086 3845 +3484 121 +3484 127 +3484 128 +3484 129 +3484 146 +3484 176 +3484 238 +3484 266 +3484 423 +3484 427 +4093 656 +4093 1156 +4093 1546 +4093 2207 +4093 2254 +4093 4039 +4093 4502 +4093 5049 +4093 5074 +4093 5075 +4298 911 +4298 1726 +4298 2789 +4298 3149 +4298 4371 +4298 4487 +4298 4770 +4298 5200 +4298 5201 +869 586 +869 833 +869 1195 +869 1367 +869 1762 +869 2354 +869 2380 +869 2753 +869 2754 +869 2755 +874 149 +874 177 +874 307 +874 652 +874 1003 +874 1022 +874 1655 +874 2495 +874 2761 +874 2762 +876 541 +1458 4 +1458 5 +1458 125 +1458 144 +1458 148 +1458 149 +1458 353 +1458 422 +1458 666 +1458 856 +1866 4 +1866 123 +1866 127 +1866 368 +1866 390 +1866 1245 +1866 2572 +1866 3675 +1866 3676 +2719 92 +2719 182 +2719 835 +2719 1209 +2719 1255 +2719 1442 +2719 3117 +2719 4278 +2719 4279 +2719 4280 +289 290 +289 291 +289 292 +289 293 +289 294 +289 295 +289 296 +289 297 +289 298 +289 299 +2551 962 +5653 538 +5653 614 +5653 675 +5653 2481 +5653 4655 +5653 5291 +5653 5601 +5653 5927 +5653 5928 +5653 5929 +2407 96 +2407 122 +2407 123 +2407 143 +2407 249 +2407 368 +2407 856 +2407 2001 +2407 2196 +2407 2563 +531 80 +531 343 +531 346 +531 571 +531 572 +531 573 +531 574 +531 575 +531 576 +760 38 +760 528 +760 536 +760 1688 +760 2026 +760 2152 +760 2517 +760 2687 +760 2688 +760 2689 +2710 163 +2710 464 +2710 919 +2710 2911 +2710 2948 +2710 3196 +2710 4272 +2710 4273 +2712 8 +2712 17 +2712 31 +2712 126 +2712 144 +2712 145 +2712 149 +2712 174 +2712 559 +2712 717 +928 2652 +2735 92 +2735 487 +2735 892 +2735 1718 +2735 2952 +2735 3163 +2735 3169 +2735 3471 +2735 4291 +2735 4292 +1323 137 +1323 557 +1323 1039 +1323 1728 +1323 2646 +1323 3079 +1323 3199 +1323 3200 +1323 3201 +1325 731 +1326 335 +1326 2722 +1326 3192 +1326 3193 +1326 3194 +1328 1249 +1328 2377 +1328 2413 +1328 2448 +1328 3169 +1328 3170 +1328 3171 +1328 3172 +1328 3173 +1328 3174 +892 2200 +892 2959 +892 2960 +892 2961 +1077 1022 +2562 529 +2562 541 +2562 1787 +2562 1892 +2562 3280 +2562 3489 +2562 3779 +2562 4182 +2562 4183 +2562 4184 +2861 7 +2861 143 +2861 147 +2861 174 +2861 175 +2861 368 +2861 559 +2861 666 +2861 754 +2861 2018 +49 101 +49 338 +49 2366 +49 2893 +49 3065 +49 3593 +49 3840 +49 3998 +49 3999 +2309 1333 +2309 2017 +2309 2138 +2309 2667 +2309 3124 +2309 3841 +2309 4004 +2309 4005 +2309 4006 +2309 4007 +2313 3 +2313 121 +2313 129 +2313 143 +2313 179 +2313 264 +2313 353 +2313 367 +2313 390 +2313 717 +2314 750 +2314 2067 +2314 2950 +2314 3097 +2314 4172 +2314 4373 +2314 5162 +2314 5163 +2314 5164 +2314 5165 +572 584 +572 818 +572 979 +572 1353 +572 2119 +572 2306 +572 2337 +572 2892 +572 4318 +572 4319 +2322 376 +2322 2303 +2322 2528 +2322 4014 +2322 4015 +2322 4016 +2322 4017 +2322 4018 +2322 4019 +2322 4020 +2324 240 +2324 566 +2324 810 +2324 968 +2324 1245 +2324 3230 +2324 3257 +2324 3475 +2324 3538 +2324 3752 +2325 3144 +2325 3894 +2325 3963 +2325 4021 +2325 4022 +2325 4023 +2325 4024 +2325 4025 +2325 4026 +2326 3343 +2326 4130 +2332 714 +2332 859 +2332 2515 +2332 2646 +2332 2729 +2332 2965 +2332 4031 +2332 4032 +2332 4033 +2304 1327 +2304 1347 +2304 2189 +21 92 +21 1702 +21 1711 +21 1833 +21 1916 +21 1917 +21 1918 +21 1919 +21 1920 +21 1921 +505 5 +505 125 +505 145 +505 148 +505 174 +505 264 +505 368 +505 422 +505 1317 +505 2018 +3607 852 +3607 1457 +3607 2752 +3607 2820 +3607 4866 +4200 429 +4200 432 +4200 1288 +4200 1564 +4200 1573 +4200 1652 +4200 2202 +4200 3813 +2114 979 +2114 1569 +2114 1581 +2114 1637 +2114 1770 +2114 1873 +2114 2409 +2114 2449 +2114 2547 +2114 3779 +1426 92 +1426 368 +1426 425 +1426 799 +1426 1339 +1426 2015 +1426 2588 +1426 3951 +1426 4635 +1426 4970 +1429 336 +1429 1546 +1429 2203 +1429 2319 +1429 2405 +1429 3266 +1429 3295 +1429 3296 +1429 3297 +1430 125 +1430 126 +1430 144 +1430 149 +1430 250 +1430 422 +1430 423 +1430 718 +1430 754 +1430 856 +1431 123 +1431 127 +1431 238 +1431 247 +1431 249 +1431 251 +1431 367 +1431 717 +1431 1245 +1431 3290 +4620 2645 +172 127 +172 128 +172 129 +172 145 +172 174 +172 177 +172 247 +172 353 +172 1246 +172 1317 +1766 2218 +1766 2370 +1766 3680 +1766 3681 +1890 39 +1890 158 +1890 1047 +1890 3341 +1890 3639 +1890 3640 +1890 3641 +1890 3642 +1890 3643 +1890 3644 +1890 3645 +1890 3646 +1890 3647 +1890 3648 +1890 3649 +1890 3650 +1890 3651 +1890 3652 +1890 3653 +1890 3654 +1890 3655 +1890 3656 +1890 3657 +1890 3658 +1890 3659 +1890 3660 +1890 3661 +1890 3662 +1890 3663 +1890 3664 +1890 3665 +1890 3666 +1890 3667 +1890 3668 +2544 8 +2544 282 +2544 837 +2544 1048 +2544 2086 +2544 3032 +2544 4163 +2544 4164 +2544 4165 +2666 8 +2666 1036 +2666 1482 +2666 1485 +2666 2035 +2666 4868 +2666 5154 +2666 5806 +2666 5807 +2666 5808 +3032 125 +3032 128 +3032 148 +3032 248 +3032 353 +3032 424 +3032 559 +3032 1317 +3032 2001 +425 8 +425 121 +425 122 +425 128 +425 147 +425 177 +425 251 +425 422 +425 426 +425 427 +2781 1980 +5008 31 +5008 123 +5008 176 +5008 250 +5008 1317 +5008 1518 +5008 3781 +5008 3934 +5008 4754 +5008 5599 +412 769 +412 2253 +412 2532 +412 3029 +412 3215 +412 3485 +412 4254 +412 5484 +412 5501 +412 5502 +1001 614 +1001 788 +1001 1071 +1001 1100 +1001 1291 +1001 2198 +1001 2931 +1001 2932 +1001 2933 +1001 2934 +1001 2935 +1001 2936 +2683 152 +2683 1695 +2683 2354 +2683 2385 +2683 3109 +2683 3343 +2683 3710 +2683 3879 +2683 3981 +2683 4170 +3865 23 +3865 1235 +3865 2036 +3865 4173 +3865 4904 +3865 4963 +3865 4964 +3865 4965 +3865 4966 +3865 4967 +1522 140 +1522 609 +1522 693 +1522 730 +1522 1249 +1522 1313 +1522 1349 +1522 2032 +1522 3328 +1522 3329 +15 3 +15 123 +15 129 +15 143 +15 251 +15 264 +15 367 +15 426 +15 427 +15 718 +855 249 +855 251 +855 266 +855 322 +855 367 +855 558 +855 667 +855 856 +855 857 +855 858 +4629 151 +4629 281 +4629 491 +4629 2360 +4629 2781 +4629 3576 +4629 3891 +4629 5328 +4629 5391 +5414 855 +5890 285 +2133 86 +2133 433 +2133 1378 +2133 2451 +2133 2637 +2133 3185 +2133 3862 +2133 3880 +2133 3881 +2133 3882 +2134 710 +2134 712 +2134 2847 +2134 3166 +2134 3410 +2134 3756 +2134 3863 +2134 3883 +2134 3884 +2134 3885 +2181 63 +2181 291 +2181 307 +2181 1873 +2181 2546 +2181 2554 +2181 2646 +2181 2697 +2181 3204 +2181 3335 +324 568 +2037 148 +2037 176 +2037 179 +2037 238 +2037 265 +2037 369 +2037 424 +2037 426 +2037 1317 +2037 2098 +2038 266 +2038 390 +2038 422 +2038 423 +2038 559 +2038 736 +2038 754 +2038 856 +2038 886 +2038 2018 +2039 348 +2039 1033 +2039 3465 +2039 4438 +2039 5170 +2039 5171 +2039 5172 +2039 5173 +2039 5174 +2039 5175 +2043 125 +2043 191 +2043 449 +2043 2621 +2043 3010 +2043 3817 +2043 3818 +2043 3819 +2043 3820 +2043 3821 +718 167 +718 243 +718 326 +718 404 +718 942 +718 1885 +718 1886 +718 1887 +2381 193 +2381 924 +2381 1243 +2381 1297 +2381 1515 +2381 1868 +2381 2213 +2381 4066 +2381 4067 +2381 4068 +977 295 +977 2093 +977 2517 +977 2840 +977 2865 +977 2866 +977 2867 +977 2868 +977 2869 +977 2870 +2374 5 +2374 125 +2374 129 +2374 145 +2374 247 +2374 249 +2374 367 +2374 424 +2374 427 +2374 1317 +2375 2035 +2375 2298 +2375 3112 +2375 3695 +2375 4057 +2375 4058 +2375 4059 +2375 4060 +2375 4061 +2375 4062 +2096 7 +2096 147 +2096 248 +2096 250 +2096 289 +2096 353 +2096 390 +2096 753 +2096 754 +2096 762 +3405 732 +3405 1947 +3405 2751 +3405 3232 +3405 3237 +3405 4223 +3405 4735 +3405 4736 +3405 4737 +3405 4738 +3616 321 +3616 699 +3616 3115 +3616 3934 +3616 4858 +3616 4859 +3616 4860 +3616 4861 +3616 4862 +3616 4863 +3967 1123 +3967 1195 +3967 1288 +3967 1833 +3967 2035 +3967 2529 +3967 2755 +3967 4330 +3967 5019 +3967 5020 +4222 156 +4222 582 +4222 726 +4222 892 +4222 894 +4222 904 +4222 1203 +4222 1559 +4222 1670 +4222 2536 +4203 875 +4203 1675 +4203 4118 +4203 4277 +4203 4917 +4203 5129 +4203 5130 +4204 202 +4204 989 +4204 2337 +4204 3367 +4204 3931 +4204 4248 +4204 5047 +4204 5131 +4204 5132 +2148 1048 +2148 2067 +2148 2179 +2148 3134 +2148 3196 +2148 3891 +2148 3892 +2148 3893 +2148 3894 +2148 3895 +3312 29 +3312 513 +3312 532 +3312 1784 +3312 2143 +3312 2695 +3312 2955 +3312 3997 +3312 4669 +3312 4670 +4516 282 +4516 665 +4516 1143 +4516 1988 +4516 2961 +4516 3777 +4516 5333 +4516 5334 +4516 5335 +303 309 +303 341 +303 764 +303 909 +303 1061 +303 1093 +303 1095 +303 2253 +303 2254 +303 2255 +771 507 +771 838 +771 1003 +771 1402 +771 1717 +771 1896 +771 1968 +771 2689 +771 2705 +771 2706 +4359 113 +4359 190 +4359 363 +4359 1056 +4359 1805 +4359 2984 +4359 3275 +4359 4018 +4359 4589 +4359 5004 +4793 105 +4793 127 +4793 423 +4793 442 +4793 918 +4793 1540 +4793 2445 +4793 4664 +4793 5497 +4891 249 +4891 290 +4891 1456 +4891 2149 +4891 2949 +4891 4639 +4891 5106 +4891 5550 +4891 5551 +4891 5552 +5895 122 +5895 123 +5895 128 +5895 129 +5895 249 +5895 251 +5895 266 +5895 368 +5895 427 +5895 718 +6061 6150 +6062 1956 +6062 2761 +6062 3587 +6062 4577 +6062 4818 +6062 5554 +6062 6013 +6062 6151 +6062 6152 +6062 6153 +684 93 +684 1376 +684 1955 +684 2227 +684 2300 +684 2421 +684 2630 +684 2631 +684 2632 +684 2633 +2360 740 +2360 925 +2360 1062 +2360 1245 +2360 3550 +2360 3626 +2360 4053 +2360 4054 +2360 4055 +2360 4056 +4291 5017 +4566 92 +4566 163 +4566 1129 +4566 1808 +4566 3524 +4566 3636 +4566 4431 +4566 4776 +4566 5277 +4566 5353 +4567 149 +4567 261 +4567 649 +4567 1042 +4567 1060 +4567 1867 +4567 1922 +4567 5350 +4567 5351 +4567 5352 +4568 202 +4568 1330 +4568 2791 +4568 5354 +4568 5355 +4568 5356 +4568 5357 +4568 5358 +2398 2792 +2398 3019 +2398 3721 +2398 3813 +2398 4087 +548 469 +548 549 +548 550 +548 551 +548 552 +548 553 +548 554 +548 555 +548 556 +1165 535 +1165 1163 +1165 2089 +1165 2204 +1165 2561 +1165 2795 +1165 3055 +1165 3056 +1165 3057 +1165 3058 +1217 554 +1217 1424 +1217 1670 +1217 1749 +1217 2341 +1217 2672 +1217 2839 +1217 3081 +1217 3082 +1217 3083 +2022 2344 +2343 338 +2343 1196 +2343 1198 +2343 1766 +2343 2320 +2343 2889 +2343 3113 +2343 3301 +2343 3565 +2343 3566 +3232 56 +3232 811 +3232 2489 +3232 2524 +3232 3460 +3232 3994 +3232 4010 +3232 4617 +3232 4618 +3232 4619 +3903 690 +3903 902 +3903 2325 +3903 2942 +3903 3106 +3903 3563 +3903 4847 +3903 4981 +3903 4982 +3903 4983 +4213 477 +4213 579 +4213 856 +4213 1824 +4213 2214 +4213 2366 +4213 2463 +4213 4293 +4213 4894 +4213 5140 +4215 532 +4215 620 +4215 1067 +4215 1089 +4215 1799 +4215 3526 +4215 3682 +4215 4583 +4215 5149 +4216 11 +4216 325 +4216 649 +4216 1300 +4216 1592 +4216 2475 +4216 2928 +4216 4166 +4216 5141 +4216 5142 +4217 5 +4217 265 +4217 823 +4217 1947 +4217 4711 +4217 4712 +4217 4861 +4217 5143 +4217 5144 +4217 5145 +1656 2729 +1656 5140 +4143 685 +4143 1036 +4143 1797 +4143 2334 +4143 3562 +4220 143 +4220 146 +4220 248 +4220 249 +4220 367 +4220 390 +4220 423 +4220 427 +4220 717 +4220 1245 +2654 836 +2654 908 +2654 1412 +2654 2076 +2654 2461 +2654 2660 +2654 3767 +2654 3995 +2654 4243 +2654 4244 +3558 307 +3558 690 +3558 983 +3558 1367 +3558 3266 +3558 3737 +3558 3856 +3558 4686 +3558 4827 +257 69 +257 1137 +257 1233 +257 1300 +257 1301 +257 1302 +257 1303 +257 1304 +257 1305 +257 1306 +3615 155 +3615 2324 +3615 2502 +3615 2504 +3615 3345 +3615 4145 +3615 4864 +3615 4865 +344 881 +930 5 +930 7 +930 147 +930 148 +930 367 +930 368 +930 422 +930 559 +930 1317 +2275 587 +2275 989 +2275 1435 +2275 2412 +2275 2726 +2275 3768 +2275 3958 +2275 3959 +2275 3960 +2275 3961 +2292 298 +2292 667 +2292 1044 +2292 1259 +2292 1762 +2292 2497 +2292 3329 +2292 3982 +2292 3983 +2292 3984 +2498 819 +2498 2502 +2498 3129 +2498 3489 +2498 4107 +2498 4143 +2498 4144 +2498 4145 +2498 4146 +2498 4147 +3296 918 +3296 2027 +3296 2067 +3296 3714 +3296 4204 +3296 4657 +3296 4658 +3296 4659 +3296 4660 +3296 4661 +3962 1122 +3962 1557 +3962 1992 +3962 2380 +3962 2383 +3962 3350 +3962 3981 +3962 4434 +3962 4693 +3962 5018 +3963 23 +3963 96 +3963 350 +3963 1322 +3963 1664 +3963 1798 +3963 3144 +3963 4022 +3963 4890 +1193 5 +1193 250 +1193 265 +1193 4711 +1193 5518 +1193 5519 +1193 5520 +1531 125 +1531 1257 +1531 1532 +1531 1533 +1531 1534 +1531 1535 +1531 1536 +1531 1537 +1531 1538 +1531 1539 +2084 3 +2084 8 +2084 128 +2084 176 +2084 238 +2084 247 +2084 266 +2084 390 +2084 424 +2084 856 +2087 30 +2087 364 +2087 1034 +2087 2681 +2087 3350 +2087 3376 +2087 3847 +2087 3848 +2087 3849 +2087 3850 +2088 131 +2088 267 +2088 532 +2088 1431 +2088 2066 +2088 2819 +2088 2966 +2088 3280 +2088 3516 +2088 3846 +198 412 +198 604 +198 870 +198 1466 +198 1556 +198 2147 +198 2148 +198 2149 +198 2150 +198 2151 +1333 386 +1333 604 +1333 837 +1333 2011 +1333 2093 +1333 2776 +1333 2871 +1333 3175 +1333 3176 +1333 3177 +1029 121 +1029 122 +1029 125 +1029 127 +1029 147 +1029 249 +1029 251 +1029 367 +1029 718 +1029 2098 +1850 21 +1850 191 +1850 585 +1850 2041 +1850 3039 +1850 3595 +1850 3596 +1850 3597 +1850 3598 +1850 3599 +3851 850 +1027 1221 +1027 1316 +1027 1750 +1027 2471 +1027 2612 +1027 2849 +1027 2859 +1027 2952 +1027 2953 +1027 2954 +2424 8 +2424 63 +2424 1691 +2424 1901 +2424 1956 +2424 2231 +2424 2838 +2424 2842 +2653 2403 +2653 2764 +2653 2973 +2653 3576 +2653 4237 +2653 4426 +2653 5289 +2653 5417 +2653 5418 +3448 123 +3448 127 +3448 129 +3448 143 +3448 146 +3448 176 +3448 247 +3448 249 +3448 352 +3448 717 +3839 4063 +801 940 +801 1866 +801 1867 +801 2036 +801 2200 +801 2724 +801 2725 +801 2726 +801 2727 +801 2728 +1561 122 +1561 127 +1561 129 +1561 176 +1561 177 +1561 238 +1561 251 +1561 352 +1561 353 +1561 1245 +11 12 +11 13 +11 14 +11 15 +11 16 +11 17 +11 18 +11 19 +11 20 +11 21 +3699 195 +3699 1903 +3699 2479 +3699 2650 +3699 2768 +3699 3822 +3699 4180 +3699 4888 +3699 4889 +3699 4890 +5202 158 +5202 202 +5202 255 +5202 532 +5202 553 +5202 573 +5202 823 +5202 883 +5202 914 +5202 923 +5202 979 +5202 1047 +5202 1213 +5202 1615 +5202 1708 +5202 1789 +5202 1805 +5202 1808 +5202 1868 +5202 1881 +5202 2015 +5202 2035 +5202 2555 +5202 2664 +5202 2693 +5202 2721 +5202 2905 +5202 3153 +5202 3288 +5202 3351 +5202 3479 +5202 3511 +5202 3740 +5202 3861 +5202 4093 +5202 4333 +5202 4453 +5202 4563 +5202 4623 +5202 4873 +5202 4912 +5202 5029 +5202 5051 +5202 5321 +5202 5629 +5202 5702 +1868 146 +1868 148 +1868 149 +1868 174 +1868 251 +1868 252 +1868 367 +1868 390 +1868 718 +1868 1317 +3462 2115 +3462 2568 +3462 4393 +3462 4395 +3462 4761 +3462 4762 +3462 4763 +3462 4764 +3462 4765 +3462 4766 +2345 510 +2345 881 +2345 3034 +2345 3184 +2345 3547 +2345 4001 +2345 4002 +2345 4042 +2345 4043 +2345 4044 +3719 113 +3719 180 +3719 795 +3719 2186 +3719 2341 +3719 3523 +3719 3740 +3719 4884 +3719 4904 +3719 4905 +4121 732 +4121 960 +4121 1430 +4121 2259 +4121 2655 +4121 3937 +4121 4348 +4121 5083 +4121 5084 +4121 5085 +4122 77 +4122 1030 +4122 1721 +4122 1947 +4122 1982 +4122 2377 +4122 2448 +4122 2523 +4122 3153 +4122 3171 +2024 29 +2024 53 +2024 56 +2024 1034 +2024 1230 +2024 1556 +2024 3489 +2024 3794 +2024 3795 +2024 3796 +2936 534 +2936 2414 +2936 3772 +2936 4412 +2936 4413 +2936 4414 +2646 1544 +2646 1854 +2646 1936 +2646 3105 +2646 3608 +2646 3731 +2646 4236 +2646 4237 +2903 117 +2903 380 +2903 716 +2903 1043 +2903 1706 +2903 1780 +2903 2761 +2903 3146 +2903 4387 +2903 4388 +2904 531 +2904 820 +2904 930 +2904 1608 +2904 1845 +2904 1956 +2904 4156 +2904 4399 +2904 4400 +2904 4401 +2906 301 +2906 692 +2906 2106 +2906 2670 +2906 2916 +2906 3188 +2906 4334 +2906 4402 +2906 4403 +2906 4404 +401 122 +401 124 +401 127 +401 146 +401 247 +401 264 +401 422 +401 423 +401 427 +401 559 +3397 4304 +3966 788 +3966 944 +3966 1163 +3966 1313 +3966 2068 +3966 3524 +3966 4371 +3966 4694 +3966 4801 +3966 5021 +243 1564 +243 2189 +243 2190 +243 2191 +243 2192 +243 2193 +243 2194 +243 2195 +243 2196 +1923 60 +1923 82 +1923 586 +1923 835 +1923 1749 +1923 1969 +1923 2317 +1923 3693 +1923 3694 +1923 3695 +440 261 +440 1607 +440 1868 +440 2312 +440 2399 +440 2492 +440 2784 +440 3617 +440 4781 +440 5476 +984 257 +984 440 +984 859 +984 985 +984 986 +984 987 +984 988 +984 989 +984 990 +984 991 +2486 133 +2486 309 +2486 478 +2486 691 +2486 1019 +2486 1235 +2486 1317 +2486 2196 +2486 4127 +2486 4128 +3058 122 +3058 124 +3058 143 +3058 247 +3058 252 +3058 264 +3058 367 +3058 369 +3058 559 +208 209 +208 210 +208 211 +208 212 +208 213 +208 214 +208 215 +208 216 +208 217 +1934 4 +1934 5 +1934 144 +1934 145 +1934 175 +1934 367 +1934 390 +1934 559 +1934 718 +2456 942 +3728 73 +3728 2923 +3728 3495 +3728 4908 +3728 4909 +3732 1454 +3732 1509 +3732 1568 +3732 1946 +3732 2276 +3732 5688 +3732 5796 +3732 5823 +3732 6138 +1626 340 +1626 637 +1626 860 +1626 2075 +1626 2410 +1626 2570 +1626 3110 +1626 3379 +1626 3380 +1626 3381 +387 825 +387 1733 +387 1961 +387 2001 +387 2353 +387 2354 +387 2355 +387 2356 +1942 2255 +1942 2272 +1942 2853 +1942 2932 +1942 3027 +1942 3718 +1942 3719 +1942 3720 +1942 3721 +3234 4709 +437 1090 +437 1486 +437 2500 +1409 5 +1409 127 +1409 148 +1409 183 +1409 252 +1409 264 +1409 559 +1409 666 +1409 1317 +1504 127 +1504 128 +1504 179 +1504 249 +1504 353 +1504 424 +1504 426 +1504 1354 +1504 3326 +1504 3327 +2871 13 +2871 554 +2871 1756 +2871 3247 +2871 3485 +2871 3489 +2871 3959 +2871 4342 +2871 4343 +3281 3070 +3281 3122 +3281 3326 +3281 4581 +3281 4641 +3281 4648 +3281 4649 +3281 4650 +3281 4651 +3281 4652 +279 8 +279 280 +279 281 +279 282 +279 283 +279 284 +279 285 +279 286 +279 287 +279 288 +3921 312 +3921 837 +3921 894 +3921 897 +3921 942 +3921 1016 +3921 1267 +3921 1524 +3921 3612 +3921 4889 +2066 4 +2066 17 +2066 144 +2066 145 +2066 148 +2066 149 +2066 179 +2066 424 +2066 559 +2066 856 +3660 3 +3660 122 +3660 459 +3660 1252 +3660 1849 +3660 2077 +3660 3178 +3660 4170 +3660 4772 +3660 4881 +4603 5381 +4728 102 +4728 126 +4728 144 +4728 145 +4728 179 +4728 266 +4728 483 +4728 1827 +4728 3290 +4728 4643 +4729 4986 +4730 2519 +4730 2776 +4730 2844 +4730 4273 +4730 4438 +4730 4441 +4730 4664 +4730 4944 +4730 5231 +4730 5453 +2604 4166 +2606 7 +2606 123 +2606 125 +2606 145 +2606 148 +2606 177 +2606 179 +2606 247 +2606 559 +2606 2018 +2607 357 +2607 1092 +2607 1866 +2607 2279 +2607 4150 +2607 4205 +2607 4206 +2607 4207 +2607 4208 +2607 4209 +2868 167 +2868 1232 +2868 1451 +2868 2266 +2868 2723 +2868 2931 +2868 2941 +2868 3375 +2868 3981 +2868 4341 +3120 178 +3120 253 +3120 263 +3120 553 +3120 2325 +3120 2497 +3120 3826 +3120 3942 +3120 4542 +3120 4543 +3126 113 +3127 2157 +3127 2422 +3127 3185 +3127 4573 +3127 4640 +3127 4641 +4189 107 +4189 298 +4189 1396 +4189 1718 +4189 1890 +4189 3543 +4189 4094 +4189 5118 +4189 5119 +4189 5120 +4317 1511 +1339 377 +3346 75 +3346 759 +3346 1583 +3346 2248 +3346 2490 +3346 3966 +3346 4281 +3346 4464 +3346 4683 +3346 4684 +4081 541 +4081 760 +4081 937 +4081 1022 +4081 1929 +4081 1940 +4081 3738 +4081 4402 +4081 5076 +4405 3 +4405 124 +4405 177 +4405 249 +4405 251 +4405 252 +4405 264 +4405 368 +4405 559 +4405 2018 +1158 552 +1158 1017 +1158 1316 +1158 2146 +1158 2844 +1158 3039 +1158 3040 +1158 3041 +1158 3042 +1158 3043 +1382 130 +1382 208 +1382 476 +1382 849 +1382 874 +1382 1022 +1382 1384 +1382 1411 +1382 1671 +1382 1955 +1382 2226 +1382 2414 +1382 2612 +1382 2658 +1382 2819 +1382 3335 +1382 3552 +1382 4132 +1382 4170 +1382 4825 +1382 5241 +1382 5428 +1382 5487 +1382 5494 +1382 5717 +1382 5785 +1382 5786 +1382 5787 +1382 5788 +3059 7 +3059 8 +3059 123 +3059 129 +3059 144 +3059 149 +3059 174 +3059 248 +3059 367 +3059 717 +3060 92 +3060 268 +3060 393 +3060 1720 +3060 2114 +3060 2451 +3060 2500 +3060 3609 +3060 3959 +3060 4295 +3061 4 +3061 126 +3061 144 +3061 689 +3061 4428 +3061 4451 +3061 4486 +3061 4487 +3061 4488 +3063 707 +3063 926 +3063 3016 +3063 3570 +3063 4492 +659 123 +659 143 +659 667 +659 1084 +659 1814 +659 1870 +659 2244 +659 2295 +659 2576 +659 2577 +2852 159 +2852 288 +2852 422 +2852 554 +2852 576 +2852 837 +2852 1199 +2852 1429 +2852 1583 +2852 1591 +2852 1980 +2852 2547 +2852 2918 +2852 3105 +2852 3139 +2852 3921 +2852 4344 +2852 4345 +2852 4346 +2852 4347 +2852 4348 +2852 4349 +2852 4350 +2852 4351 +2852 4352 +2852 4353 +2852 4354 +2852 4355 +3149 1258 +3149 2007 +3149 2039 +3149 2067 +3149 2197 +3149 2218 +3149 2888 +3149 4380 +3149 4549 +3149 4550 +3813 491 +3813 637 +3813 1150 +3813 1338 +3813 1540 +3813 1947 +3813 4789 +3813 4895 +3813 4934 +3813 4935 +740 124 +740 174 +740 1255 +740 1487 +740 1531 +740 1557 +740 1609 +740 2385 +740 2663 +740 4539 +3004 1900 +3004 1983 +3004 3463 +3004 4584 +3039 584 +3039 4599 +3815 178 +3815 1377 +3815 1614 +3815 2200 +3815 2901 +3815 3217 +3815 3225 +3815 3619 +3815 4207 +3815 4733 +1124 360 +1124 1061 +1124 1064 +1124 1125 +1124 1126 +1124 1127 +1124 1128 +1124 1129 +1124 1130 +1124 1131 +1124 1132 +1124 1133 +1831 3568 +1084 49 +1084 184 +1084 505 +1084 725 +1084 1085 +1084 1086 +1084 1087 +1084 1088 +1084 1089 +1084 1090 +1770 2322 +4751 8 +4751 122 +4751 129 +4751 177 +4751 249 +4751 251 +4751 352 +4751 353 +4751 367 +4751 856 +406 1999 +3459 3 +3459 124 +3459 127 +3459 129 +3459 177 +3459 251 +3459 266 +3459 367 +3459 368 +3459 422 +3654 586 +3654 1089 +3654 1280 +3654 1923 +3654 2723 +3654 4009 +3654 4124 +3654 4584 +3654 4877 +3654 4878 +3726 30 +3726 152 +3726 1917 +3726 2186 +3726 2646 +3726 2922 +3726 3259 +3726 3411 +3726 4913 +3726 4914 +4072 4854 +5137 125 +5137 129 +5137 144 +5137 147 +5137 148 +5137 179 +5137 352 +5137 1246 +5137 1317 +5137 2001 +5138 2383 +1827 434 +1827 979 +1827 1697 +1827 1828 +1827 1829 +1827 1830 +1827 1831 +1827 1832 +1827 1833 +3171 113 +3171 870 +3171 997 +3171 3995 +3171 4017 +3171 4120 +3171 4206 +3171 4402 +3171 4569 +3171 4570 +4846 926 +4846 1258 +4846 1382 +4846 1706 +4846 3062 +4846 3064 +4846 4170 +4846 4339 +4846 5881 +5236 125 +5236 143 +5236 145 +5236 146 +5236 147 +5236 367 +5236 368 +5236 422 +5236 559 +5236 754 +5238 208 +5238 347 +5238 724 +5238 3129 +5238 3823 +5238 4764 +5238 5726 +5238 5727 +5238 5728 +5238 5729 +20 121 +20 147 +20 368 +20 427 +20 717 +20 856 +20 975 +20 1908 +20 1909 +20 1910 +1162 452 +1162 453 +1162 460 +1162 563 +1162 803 +1162 847 +1162 1163 +1162 1164 +1162 1165 +1162 1166 +1670 113 +1670 473 +1670 1049 +1670 1321 +1670 1540 +1670 2298 +1670 2896 +1670 3014 +1670 3166 +1670 3572 +2173 2569 +4004 682 +4004 2149 +4004 2442 +4004 5029 +4004 5030 +4004 5031 +4004 5032 +4004 5033 +4004 5034 +4004 5035 +4083 4317 +4587 462 +4587 1359 +4587 1457 +4587 1688 +4587 2875 +4587 3038 +4587 3858 +4587 4880 +4587 5367 +4587 5368 +2859 571 +2859 609 +2859 695 +2859 802 +2859 864 +2859 870 +2859 2638 +2859 3109 +2859 4334 +2859 4356 +131 93 +131 1466 +131 1831 +131 1994 +131 2092 +131 2093 +131 2094 +131 2095 +131 2096 +131 2097 +4400 762 +4400 1647 +4400 2170 +4400 2579 +4400 2599 +4400 4097 +4400 4867 +4400 5260 +4400 5261 +4400 5262 +4951 748 +4951 780 +4951 803 +4951 1280 +4951 2236 +4951 2285 +4951 2568 +4951 2583 +4951 4641 +4951 4799 +472 347 +472 1267 +472 1485 +472 1486 +472 1487 +472 1488 +472 1489 +472 1490 +472 1491 +472 1492 +1411 558 +1411 576 +1411 1412 +1411 1413 +1411 1414 +1411 1415 +1411 1416 +1411 1417 +1411 1418 +1926 982 +1926 1929 +1926 2090 +1926 2317 +1926 2407 +1926 3107 +1926 3696 +1926 3697 +1926 3698 +1926 3699 +3552 2 +3552 123 +3552 147 +3552 177 +3552 250 +3552 251 +3552 351 +3552 946 +3552 983 +3552 2077 +4160 3 +4160 7 +4160 9 +4160 124 +4160 125 +4160 126 +4160 128 +4160 176 +4160 247 +4160 424 +5440 196 +5440 558 +5440 1021 +5440 1088 +5440 1447 +5440 3374 +5440 4885 +5440 5245 +5440 5818 +5440 5819 +4676 524 +4676 3050 +4676 3780 +4676 4109 +5241 198 +5241 1192 +5241 1969 +5241 2776 +5241 2888 +5241 3395 +5241 4251 +5241 4641 +5241 4992 +5241 5725 +63 1364 +63 1950 +63 1977 +63 1978 +63 1979 +63 1980 +63 1981 +63 1982 +63 1983 +1694 246 +1694 942 +1694 3032 +1694 3443 +1694 3444 +1694 3445 +1694 3446 +1694 3447 +5443 898 +5443 1115 +5443 1227 +5443 3217 +5443 4128 +5443 5823 +5443 5824 +5443 5825 +5443 5826 +209 976 +209 1903 +209 1940 +209 2103 +209 2429 +209 2430 +209 2431 +209 2432 +1917 1601 +1917 1711 +1917 1845 +1917 1985 +1917 2181 +1917 2619 +1917 3052 +1917 3056 +1917 3683 +1917 3684 +2244 532 +2244 1219 +2244 1354 +2244 1776 +2244 1842 +2244 2650 +2244 2995 +2244 3943 +2244 3944 +2244 3945 +2245 4092 +1107 998 +3694 1280 +5253 976 +5253 1787 +5253 1809 +5253 2156 +5253 2309 +5253 3185 +5253 4448 +5253 4641 +5253 4793 +5254 450 +5254 2308 +5254 3488 +5254 4426 +5254 4654 +5254 4998 +5254 5474 +5254 5594 +5254 5731 +5254 5732 +5255 147 +5255 248 +5255 422 +5255 427 +5255 2001 +5255 2018 +5255 2968 +5255 3804 +5255 5636 +5255 5730 +5257 76 +5257 726 +5257 3877 +5257 3903 +5257 5734 +5259 4540 +483 1812 +521 27 +521 117 +521 325 +521 577 +521 578 +521 579 +521 580 +521 581 +521 582 +521 583 +1413 1171 +1413 2575 +1413 2582 +1413 2640 +1413 2672 +1413 2828 +1413 2960 +1413 3035 +1413 3269 +1413 3270 +1654 997 +1654 1023 +1654 2552 +1654 2825 +1654 2876 +1654 3282 +1654 3404 +1654 3405 +1654 3406 +1654 3407 +4113 123 +4113 127 +4113 176 +4113 179 +4113 248 +4113 249 +4113 352 +4113 422 +4113 427 +4113 667 +4914 125 +4914 498 +4914 1211 +4914 2798 +4914 3249 +4914 3819 +4914 4006 +4914 4474 +4914 5566 +4914 5567 +751 31 +751 124 +751 146 +751 266 +751 367 +751 427 +751 559 +751 667 +751 856 +751 2001 +3156 477 +3156 710 +3156 2347 +3156 2540 +3156 3489 +3156 4344 +3156 4563 +3156 4564 +3156 4565 +5312 5278 +878 59 +878 202 +878 510 +878 879 +878 880 +878 881 +878 882 +878 883 +878 884 +878 885 +1540 111 +1540 676 +1540 1023 +1540 1050 +1540 1167 +1540 1541 +1540 1542 +1540 1543 +1540 1544 +1540 1545 +3557 23 +3557 113 +3557 1123 +3557 1227 +3557 1501 +3557 2214 +3557 2276 +3557 4371 +3557 4816 +3557 4817 +6241 424 +6241 1800 +6241 3712 +6241 5128 +6241 5182 +6241 6119 +6241 6120 +6241 6255 +6241 6256 +6241 6257 +679 270 +679 680 +679 681 +679 682 +679 683 +679 684 +679 685 +679 686 +679 687 +679 688 +532 1329 +532 1330 +2068 119 +2068 1240 +2068 1415 +2068 1709 +2068 2664 +2068 3741 +2068 3879 +4095 38 +4095 257 +4095 573 +4095 2274 +4095 3299 +4095 3409 +4095 4164 +4095 4230 +4095 4695 +4095 5077 +4096 1772 +500 59 +500 1475 +500 1476 +2798 177 +2798 261 +2798 266 +2798 1134 +2798 1529 +2798 3304 +2798 3590 +2798 4307 +2798 4308 +2798 4309 +478 479 +478 480 +478 481 +478 482 +478 483 +478 484 +478 485 +478 486 +478 487 +478 488 +786 15 +786 331 +786 1300 +786 1326 +786 2091 +786 2714 +786 2715 +786 2716 +786 2717 +786 2718 +2261 122 +2261 124 +2261 128 +2261 129 +2261 176 +2261 249 +2261 264 +2261 367 +2261 368 +2261 369 +4768 989 +4768 5477 +1388 122 +1388 123 +1388 147 +1388 176 +1388 177 +1388 246 +1388 264 +1388 422 +1388 1245 +4551 63 +4551 260 +4551 562 +4551 870 +4551 2236 +4551 3397 +4551 4407 +4551 4970 +4551 5348 +4551 5349 +4769 983 +4769 2670 +4769 2986 +4769 3038 +4769 3337 +4769 4203 +4769 5085 +4769 5140 +4769 5471 +4769 5472 +3705 276 +3705 552 +3705 995 +3705 1947 +3705 1972 +3705 2430 +3705 3594 +3705 4891 +3705 4892 +4149 5105 +4151 5091 +3479 572 +3479 1085 +3479 1456 +3479 3015 +3479 3392 +3479 3634 +3479 3781 +3479 4405 +3479 4780 +1030 791 +1030 2651 +1030 2693 +1030 2944 +1030 2945 +1030 2946 +1030 2947 +1030 2948 +1030 2949 +1030 2950 +5016 133 +5016 241 +5016 582 +5016 965 +5016 1316 +5016 1541 +5016 1882 +5016 2090 +5016 5178 +5016 5601 +541 200 +541 710 +541 2534 +2347 38 +2347 540 +2347 554 +2347 584 +2347 1424 +2347 1940 +2347 2086 +2347 2653 +2347 4034 +2886 121 +2886 125 +2886 129 +2886 146 +2886 176 +2886 238 +2886 248 +2886 264 +2886 352 +2886 427 +3333 211 +3333 331 +3333 651 +3333 2125 +3333 2129 +3333 2377 +3333 3951 +3333 4249 +3333 4676 +3333 4677 +3635 1144 +3635 2170 +3635 2332 +3635 3860 +3635 4136 +3635 4872 +3635 4873 +3635 4874 +3635 4875 +3635 4876 +5436 1956 +1278 412 +1278 1299 +1278 1947 +1278 1974 +1278 2035 +1278 2228 +1278 2547 +1278 3709 +1278 3841 +1278 5199 +4297 4 +4297 9 +4297 125 +4297 143 +4297 145 +4297 148 +4297 264 +4297 368 +4297 1317 +4988 5 +4988 9 +4988 126 +4988 148 +4988 174 +4988 264 +4988 390 +4988 558 +4988 559 +5413 1310 +5413 1883 +5413 3621 +5413 4694 +5413 4723 +5413 4727 +5413 5542 +5413 5820 +5413 5821 +5413 5822 +2887 177 +2887 411 +2887 586 +2887 706 +2887 1588 +2887 3363 +2887 4369 +2887 4370 +2887 4371 +3046 715 +3046 1762 +3046 1865 +3046 2358 +3046 2563 +3046 2700 +3046 3109 +3046 4012 +3046 4658 +3046 5634 +5373 204 +5373 1049 +5373 1685 +5373 2088 +5373 4013 +5373 4317 +5373 4659 +5373 4909 +5373 5633 +5373 5799 +1750 158 +1750 231 +1750 1216 +1750 1217 +1750 1424 +1750 1717 +1750 2385 +1750 3510 +1750 3511 +1750 3512 +2299 424 +2299 2127 +2299 2330 +2299 2898 +2299 2907 +2299 2911 +2299 3991 +2299 3992 +2299 3993 +2299 3994 +3024 352 +3024 1139 +3024 1721 +3024 2790 +3024 3995 +3024 4460 +3024 4461 +3024 4462 +3024 4463 +4842 249 +5510 122 +5510 175 +5510 247 +5510 249 +5510 250 +5510 251 +5510 367 +5510 390 +5510 422 +5510 667 +380 218 +380 1030 +380 1230 +380 1231 +380 1232 +380 1233 +380 1234 +380 1235 +380 1236 +1751 103 +1751 123 +1751 3513 +1751 3514 +1751 3515 +2577 330 +2577 388 +2577 553 +2577 962 +2577 1306 +2577 2010 +2577 3179 +2577 4177 +2577 4178 +2577 4179 +3174 262 +3174 344 +3174 2613 +3174 2994 +3174 4571 +3658 520 +3658 1036 +3658 1587 +3658 1797 +3658 2334 +3658 3094 +3658 3473 +3658 4879 +3658 4880 +1782 503 +1782 1103 +1782 1224 +1782 1301 +1782 1585 +1782 2272 +1782 2766 +1782 3105 +1782 3531 +1782 3532 +1784 3 +1784 4 +1784 122 +1784 143 +1784 422 +1784 423 +1784 427 +1784 666 +1784 667 +5645 57 +5645 271 +5645 2249 +5645 3675 +5645 4077 +5645 5923 +5645 5924 +5645 5925 +5645 5926 +2662 4250 +906 303 +906 518 +906 907 +906 908 +906 909 +906 910 +906 911 +906 912 +906 913 +1250 193 +1250 308 +1250 878 +1250 935 +1250 1415 +1250 1524 +1250 2157 +1250 2179 +1250 3112 +1250 3113 +1859 23 +1859 56 +1859 125 +1859 1137 +1859 3093 +1859 3605 +1859 3606 +1859 3607 +1859 3608 +528 17 +528 241 +528 529 +528 530 +528 531 +528 532 +528 533 +528 534 +528 535 +528 536 +686 1162 +686 1309 +686 1573 +686 1958 +686 2587 +686 2588 +686 2589 +686 2590 +686 2591 +686 2592 +769 1024 +769 1335 +769 2547 +769 2579 +769 2670 +769 2700 +769 2701 +769 2702 +769 2703 +769 2704 +965 583 +965 1208 +965 1390 +965 1728 +965 2871 +965 2872 +965 2873 +965 2874 +965 2875 +965 2876 +2176 3 +2176 175 +2176 266 +2176 368 +2176 390 +2176 423 +2176 427 +2176 697 +2176 1245 +2732 227 +2732 717 +2732 1735 +2732 1749 +2732 1862 +2732 2497 +2732 3009 +2732 4293 +2732 4294 +2732 4295 +2548 17 +2548 146 +2548 175 +2548 266 +2548 423 +2548 558 +2548 559 +2548 667 +2548 697 +2548 1245 +4695 131 +4695 190 +4695 697 +4695 942 +4695 1730 +4695 1922 +4695 2423 +4695 5189 +4695 5428 +4695 5429 +5224 391 +5224 717 +5224 1542 +5224 1787 +5224 1881 +5224 2892 +5224 4490 +5224 4741 +5224 5720 +3451 833 +3451 1599 +3451 1845 +3451 1881 +3451 1889 +3451 3218 +3451 3446 +3451 4541 +3451 4759 +3451 4760 +3452 9 +3452 17 +3452 143 +3452 144 +3452 147 +3452 149 +3452 179 +3452 424 +3452 559 +3452 2018 +3634 1052 +3634 1067 +3634 2479 +3634 2528 +3634 3524 +3634 3677 +3634 4371 +3634 4641 +3634 4870 +3634 4871 +1255 148 +1255 150 +1255 179 +1255 352 +1255 390 +1255 906 +1255 1317 +1255 3115 +1255 3116 +1255 3117 +5670 268 +5670 522 +5670 2538 +5670 2735 +5670 4969 +5670 5149 +5670 5887 +5670 5930 +5670 5931 +5670 5932 +2794 513 +2794 1042 +2794 1509 +2794 2001 +2794 2292 +2794 2615 +2794 3215 +2794 3907 +2794 4306 +3810 1471 +3810 1591 +3810 2037 +3810 2038 +3810 2625 +3810 3822 +3810 4213 +3810 4932 +3810 4933 +345 126 +345 149 +345 177 +345 179 +345 248 +345 266 +345 424 +345 754 +345 2001 +846 152 +846 602 +846 847 +846 848 +846 849 +846 850 +846 851 +846 852 +846 853 +846 854 +1251 262 +1251 416 +1251 1057 +1251 1252 +1251 1253 +1251 1254 +1251 1255 +1251 1256 +1251 1257 +1251 1258 +1889 58 +1889 351 +1889 829 +1889 832 +1889 835 +1889 1306 +1889 1327 +1889 3636 +1889 3637 +1889 3638 +1893 1023 +1893 3136 +2621 4 +2621 146 +2621 368 +2621 390 +2621 422 +2621 423 +2621 856 +2621 1245 +2621 1317 +2621 2001 +1019 551 +1019 898 +1019 945 +1019 1533 +1019 2018 +1019 2926 +1019 2927 +1019 2928 +1019 2929 +1019 2930 +1176 124 +1176 147 +1176 251 +1176 266 +1176 367 +1176 368 +1176 422 +1176 2001 +1176 2018 +3979 8 +3979 9 +3979 125 +3979 128 +3979 175 +3979 250 +3979 353 +3979 424 +3979 754 +1984 255 +1984 361 +1984 2113 +1984 2721 +1984 3554 +1986 1103 +1987 227 +1987 2292 +1987 2528 +1987 2914 +1987 3709 +1987 5541 +1987 5584 +1987 5795 +1987 5796 +1987 5797 +1988 3768 +1989 848 +1989 1792 +1989 1845 +1989 2354 +1989 5177 +2728 121 +2728 129 +2728 174 +2728 183 +2728 238 +2728 353 +2728 424 +2728 427 +2728 717 +2728 2338 +3797 788 +3797 1954 +3797 2127 +3797 3017 +3797 3600 +3797 5089 +3797 5891 +3797 5892 +3797 5893 +3797 5894 +3016 995 +3016 1034 +3016 2148 +3016 3070 +3016 3740 +3016 4532 +3016 5179 +3016 5324 +3016 5325 +3016 5326 +4197 5 +4197 31 +4197 126 +4197 143 +4197 180 +4197 250 +4197 368 +4197 697 +4197 856 +4197 1245 +4275 4 +4275 122 +4275 143 +4275 146 +4275 266 +4275 367 +4275 666 +4275 667 +4275 754 +4275 856 +4438 631 +4438 769 +4438 812 +4438 1317 +4438 1374 +4438 2906 +4438 3617 +4438 3635 +4438 4873 +4438 5275 +4472 5 +4472 123 +4472 125 +4472 144 +4472 177 +4472 247 +4472 248 +4472 249 +4472 717 +4472 1317 +4628 68 +4628 831 +4628 1787 +4628 2355 +4628 2862 +4628 3304 +4628 3470 +4628 4889 +4628 5384 +4628 5385 +5093 2031 +411 96 +411 835 +411 1256 +411 1814 +411 2266 +411 2839 +411 3306 +411 5013 +411 5014 +411 5015 +13 2074 +2056 10 +2056 127 +2056 145 +2056 175 +2056 176 +2056 247 +2056 353 +2056 369 +2056 629 +2056 993 +2112 463 +2112 803 +2112 1492 +2112 2091 +2112 2111 +2112 2115 +2112 2287 +2112 2818 +2112 2941 +2112 3868 +2115 123 +2115 199 +2115 751 +2115 1506 +2115 2474 +2115 2805 +2115 3365 +2115 3595 +2115 3886 +2115 3887 +4419 8 +4419 31 +4419 126 +4419 144 +4419 148 +4419 175 +4419 179 +4419 247 +4419 558 +4419 697 +201 714 +201 2152 +201 2153 +201 2154 +201 2155 +201 2156 +201 2157 +201 2158 +201 2159 +201 2160 +1673 389 +1673 503 +1673 1513 +1673 1940 +1673 2216 +1673 2359 +1673 2634 +1673 2636 +1673 3448 +1673 3449 +229 840 +229 1123 +229 1194 +229 1726 +229 2217 +229 2218 +229 2219 +229 2220 +229 2221 +229 2222 +3102 815 +3102 1066 +3102 2067 +3102 2234 +3102 3916 +3102 4017 +3102 4257 +3102 4478 +3102 4535 +3102 4536 +4228 20 +4228 179 +4228 238 +4228 346 +4228 347 +4228 2337 +4228 3229 +4228 3480 +4228 4132 +4228 5150 +1476 686 +1476 1390 +1476 3017 +1476 3077 +1476 3317 +1476 3318 +1476 3319 +1476 3320 +1476 3321 +1476 3322 +2532 665 +2532 774 +2532 924 +2532 1709 +2532 1859 +2532 2767 +2532 3136 +2532 3682 +2532 3698 +2532 4160 +3833 414 +3833 1168 +3833 1415 +3833 2257 +3833 4037 +3833 4948 +3833 4949 +3833 4950 +3833 4951 +3833 4952 +4465 143 +4465 175 +4465 176 +4465 252 +4465 367 +4465 368 +4465 422 +4465 2001 +4465 2018 +4725 255 +4725 381 +4725 2226 +4725 3181 +4725 5456 +4726 804 +4726 1507 +4726 2292 +4726 2697 +4726 3496 +4726 3516 +4726 3949 +4726 4042 +4726 5261 +646 9 +646 126 +646 145 +646 147 +646 179 +646 252 +646 265 +646 368 +646 426 +1487 3 +1487 127 +1487 177 +1487 183 +1487 247 +1487 249 +1487 367 +1487 427 +1487 718 +1487 2338 +3223 1327 +3223 2265 +3223 3720 +3223 4609 +3223 4610 +4731 2554 +4731 3120 +4731 4770 +4731 5155 +4732 132 +4732 433 +4732 459 +4732 2060 +4732 2097 +4732 2332 +4732 2408 +4732 3312 +4732 3635 +4732 4667 +727 152 +2523 257 +2523 469 +2523 586 +2523 693 +2523 1356 +2523 1454 +2523 2500 +2523 3995 +2523 4158 +2523 4159 +3095 369 +3095 493 +3095 553 +3095 1599 +3095 1796 +3095 2211 +3095 3220 +3095 4521 +3095 4522 +3095 4523 +3095 4524 +3095 4525 +3095 4526 +3095 4527 +3095 4528 +3095 4529 +3095 4530 +3095 4531 +3843 17 +3843 143 +3843 148 +3843 175 +3843 250 +3843 266 +3843 423 +3843 697 +3843 754 +3843 1245 +5214 1193 +5214 1926 +5214 2236 +5214 2337 +5214 2847 +5214 4018 +5214 5081 +5214 5235 +5214 5714 +3733 118 +3733 241 +3733 1086 +3733 2119 +3733 2364 +3733 2502 +3733 3260 +3733 4910 +3733 4911 +3733 4912 +3734 5 +3734 125 +3734 145 +3734 179 +3734 390 +3734 422 +3734 424 +3734 558 +3734 667 +3734 856 +191 77 +191 2190 +191 2365 +191 2366 +191 2367 +191 2368 +191 2369 +191 2370 +191 2371 +191 2372 +3213 3 +3213 5 +3213 7 +3213 8 +3213 124 +3213 174 +3213 249 +3213 251 +3213 369 +3213 427 +3250 1903 +55 56 +55 57 +55 58 +55 59 +55 60 +55 61 +55 62 +55 63 +55 64 +55 65 +3258 124 +3258 127 +3258 128 +3258 143 +3258 147 +3258 247 +3258 251 +3258 266 +3258 369 +3258 1245 +3259 1090 +3259 2049 +3259 2050 +3259 2566 +3259 3014 +3259 3815 +3259 4282 +3259 4633 +3259 4634 +3259 4635 +3260 1212 +3260 1830 +3260 1845 +3260 1936 +3260 2108 +3260 2470 +3260 2563 +3260 2729 +3260 3601 +3490 4781 +706 3501 +706 4623 +706 4624 +4502 125 +4502 174 +4502 424 +4502 503 +4502 1142 +4502 1516 +4502 2537 +4502 4170 +4502 5331 +4502 5332 +937 5 +937 7 +937 143 +937 145 +937 146 +937 249 +937 251 +937 367 +937 666 +937 1317 +3309 9 +3309 97 +3309 413 +3309 581 +3309 1023 +3309 1026 +3309 1533 +3309 3460 +3309 3786 +3309 3822 +507 3 +507 127 +507 143 +507 249 +507 251 +507 252 +507 427 +507 2491 +507 2492 +2575 484 +2575 548 +2575 568 +2575 690 +2575 756 +2575 872 +2575 1025 +2575 2897 +2575 4173 +2575 4174 +4463 81 +4463 637 +4463 697 +4463 2875 +4463 3813 +4463 5100 +4463 5306 +4463 5307 +4944 390 +4944 427 +4944 777 +4944 1842 +4944 2269 +4944 2862 +4944 3658 +4944 4578 +4944 5581 +4944 5582 +466 2447 +466 2448 +466 2449 +466 2450 +466 2451 +1794 271 +1794 458 +1794 818 +1794 1250 +1794 1538 +1794 1766 +1794 1795 +1794 1796 +1794 1797 +1794 1798 +4940 988 +4940 1273 +4940 1480 +4940 2148 +4940 2201 +4940 2787 +4940 3169 +4940 3636 +4940 5579 +4940 5580 +162 163 +162 164 +162 165 +162 166 +162 167 +162 168 +162 169 +162 170 +162 171 +162 172 +3025 3221 +3025 3271 +3025 3335 +3025 4473 +3025 4474 +3026 3 +3026 123 +3026 128 +3026 129 +3026 143 +3026 146 +3026 177 +3026 251 +3026 367 +3026 1245 +1815 459 +1815 801 +1815 808 +1815 892 +1815 1794 +1815 1816 +1815 1817 +1815 1818 +1815 1819 +1815 1820 +416 640 +416 1002 +416 1477 +416 2013 +416 2327 +416 2434 +416 2435 +416 2436 +416 2437 +416 2438 +635 367 +635 404 +635 474 +635 668 +635 746 +635 747 +635 748 +635 749 +635 750 +635 751 +1135 4 +1135 147 +1135 176 +1135 246 +1135 249 +1135 251 +1135 252 +1135 264 +1135 266 +1135 718 +3224 2516 +3225 108 +3225 756 +3225 763 +3225 2911 +3225 3438 +3225 3679 +3225 3748 +3225 4611 +3225 4612 +3225 4613 +370 371 +370 372 +370 373 +370 374 +370 375 +370 376 +370 377 +370 378 +370 379 +370 380 +4293 54 +4293 2253 +4293 4062 +4293 4636 +4293 5193 +4293 5194 +4293 5195 +4293 5196 +4293 5197 +4293 5198 +4617 3716 +4617 3949 +4617 4783 +4617 5175 +4617 5211 +4617 5386 +4617 5387 +4617 5388 +4617 5389 +4617 5390 +787 276 +787 788 +787 789 +787 790 +787 791 +787 792 +787 793 +787 794 +787 795 +787 796 +3499 788 +4332 435 +4332 1219 +4332 2006 +4332 2042 +4332 2197 +4332 2776 +4332 3329 +4332 5217 +4332 5218 +4332 5219 +2102 1766 +2102 1956 +2102 2218 +2102 2841 +2102 3786 +2102 3869 +2102 3870 +2102 3871 +2102 3872 +2102 3873 +739 1380 +739 1609 +739 2664 +739 2665 +739 2666 +972 469 +972 2229 +972 2862 +972 2863 +972 2864 +605 8 +605 121 +605 127 +605 147 +605 176 +605 238 +605 352 +605 353 +605 422 +605 424 +1133 3158 +1209 325 +1209 583 +1209 1210 +1209 1211 +1209 1212 +1209 1213 +1209 1214 +1209 1215 +1209 1216 +1209 1217 +3273 623 +3273 962 +3273 1177 +3273 2337 +3273 2427 +3273 3981 +3273 4645 +3273 4646 +3273 4647 +113 17 +113 143 +113 144 +113 145 +113 179 +113 368 +113 424 +113 754 +113 1317 +113 2018 +5060 363 +5352 149 +5352 266 +5352 1317 +5352 1414 +5352 2197 +5352 2837 +5352 3614 +5352 4427 +5352 4844 +5352 5767 +5792 3 +5792 123 +5792 126 +5792 127 +5792 129 +5792 144 +5792 179 +5792 351 +5792 353 +5792 1317 +5793 436 +5793 551 +5793 1458 +5793 1509 +5793 2804 +5793 3233 +5793 5837 +5793 5983 +5793 5984 +5793 5985 +5794 771 +5794 1637 +5794 1940 +5794 5429 +5794 5986 +5794 5987 +5794 5988 +5794 5989 +5794 5990 +5794 5991 +1544 3337 +1544 3338 +1544 3339 +1544 3340 +3531 38 +3531 412 +3531 2266 +3531 2583 +3531 3441 +3531 3619 +3531 3671 +3531 3674 +3531 3868 +3531 4033 +5655 1608 +5981 111 +5981 830 +5981 1811 +5981 2163 +5981 2193 +5981 3861 +5981 3953 +5981 4332 +5981 6094 +5981 6095 +5982 243 +5982 2260 +5982 3093 +5982 3231 +5982 4592 +5982 5569 +5982 5645 +5982 6097 +5982 6098 +5982 6099 +1258 145 +1258 149 +1258 177 +1258 247 +1258 699 +1258 856 +1258 1317 +1258 2063 +1258 3002 +1258 3118 +2657 1245 +2657 2687 +2657 2866 +2657 3488 +2657 3680 +2657 3886 +2657 4074 +2657 4240 +2657 4241 +2657 4242 +6096 5254 +6269 76 +6269 760 +6269 1611 +6269 1862 +6269 2416 +6269 3767 +6269 6282 +6269 6283 +2777 1103 +2777 3292 +2777 5452 +2777 6039 +2777 6279 +3038 308 +3038 1001 +3038 1239 +3038 1766 +3038 2490 +3038 3516 +3038 3564 +3038 3781 +3038 4471 +3038 4472 +6102 570 +6102 1537 +6102 1838 +6102 1882 +6102 4227 +6102 5508 +6102 6096 +6102 6280 +6102 6281 +6262 898 +6262 3501 +6262 3629 +6262 3846 +6262 3968 +6262 4141 +6262 4397 +6262 5369 +6262 5779 +3991 289 +3991 1846 +3991 2330 +3991 3479 +3991 3632 +3991 4242 +3991 4503 +3991 4587 +3991 5036 +3991 5037 +5528 2716 +5528 4483 +5528 4660 +5528 4771 +5528 4929 +5528 4970 +5528 5863 +5528 5864 +5528 5865 +6264 31 +6264 165 +6264 174 +6264 250 +6264 353 +6264 697 +6264 1379 +6264 3056 +6264 5615 +6264 5617 +6266 169 +6266 892 +6266 2378 +6266 2789 +6266 5633 +6266 5923 +6266 6039 +6266 6237 +6266 6274 +6266 6275 +526 56 +526 527 +450 38 +450 203 +450 451 +450 452 +450 453 +450 454 +450 455 +450 456 +450 457 +1400 326 +1400 657 +1400 922 +1400 3262 +1400 3263 +1400 3264 +1400 3265 +1400 3266 +1400 3267 +1400 3268 +4167 1026 +4167 1898 +4167 2784 +4167 2826 +4167 2886 +4167 3001 +4167 3220 +4167 3858 +4167 4102 +4167 5104 +4062 1787 +4062 2901 +4062 3058 +4062 3334 +4062 3672 +4062 4871 +4062 4880 +4062 5058 +4062 5059 +5285 3440 +5285 5296 +5285 5748 +5285 5750 +5285 5751 +5285 5752 +5285 5753 +5285 5754 +5285 5755 +5285 5756 +2743 14 +2743 1022 +2743 1278 +2743 1352 +2743 2726 +2743 2974 +2743 3312 +2743 4151 +2743 4296 +2743 4297 +1734 157 +1734 351 +1734 554 +1734 814 +1734 1137 +1734 1808 +1734 2870 +1734 3566 +1734 5176 +2767 8 +2767 9 +2767 127 +2767 128 +2767 238 +2767 248 +2767 352 +2767 427 +2767 1317 +2767 4303 +2770 5 +2770 8 +2770 123 +2770 145 +2770 148 +2770 238 +2770 353 +2770 424 +2770 427 +2770 2338 +1146 2430 +1146 3180 +3098 308 +3098 480 +3098 1376 +3098 2199 +3098 2362 +3098 2995 +3098 3273 +3098 4355 +3098 4533 +3098 4534 +3358 132 +3358 1801 +3358 1900 +3358 2224 +3358 3039 +3358 3606 +3358 4533 +3358 4697 +3358 4698 +3358 4699 +5003 2916 +5003 2964 +5003 2981 +5003 3629 +5003 4247 +5003 5220 +5003 5507 +5003 5591 +5003 5592 +5003 5593 +2873 3 +2873 124 +2873 143 +2873 176 +2873 248 +2873 264 +2873 352 +2873 367 +2873 369 +2873 856 +3553 5 +3553 121 +3553 125 +3553 126 +3553 148 +3553 179 +3553 265 +3553 352 +3553 422 +3553 666 +2300 136 +2300 388 +2300 1456 +2300 1457 +2300 1677 +2300 1936 +2300 3995 +2300 3996 +2300 3997 +1267 251 +1267 459 +1267 1268 +1267 1269 +1267 1270 +1267 1271 +1267 1272 +1267 1273 +1267 1274 +3767 863 +3767 864 +3767 1239 +3767 1339 +3767 1711 +3767 2254 +3767 3299 +3767 4846 +3767 4920 +3767 4921 +4489 3813 +4489 5392 +4490 810 +4490 981 +4490 1199 +4490 1297 +4490 1342 +4490 1607 +4490 1608 +4490 1867 +4490 3617 +4490 5320 +3922 21 +3922 3144 +3922 3963 +3922 4022 +1365 1087 +1365 1361 +1365 1477 +1365 2082 +1365 3209 +1365 3210 +1365 3211 +1365 3212 +1365 3213 +2559 43 +2559 788 +2559 2069 +2559 4170 +2559 4171 +2569 79 +2569 164 +2569 243 +2569 296 +2569 455 +2569 1289 +2569 2641 +2569 2740 +2569 3735 +2569 4172 +1043 3146 +1043 4264 +2944 1240 +2944 1425 +2944 1731 +2944 4537 +2944 4538 +3142 124 +3142 129 +3142 177 +3142 248 +3142 249 +3142 266 +3142 667 +3142 717 +3142 856 +3142 1245 +2205 938 +2205 1608 +2205 1849 +2205 3109 +2205 4080 +2205 5310 +2205 5724 +2205 6000 +2205 6001 +887 1671 +887 1688 +887 1786 +887 1805 +887 2361 +887 2662 +887 2775 +887 2776 +887 2777 +887 2778 +4811 3003 +699 529 +699 693 +699 1027 +699 1653 +699 1702 +699 2289 +699 2546 +699 2611 +699 2612 +699 2613 +606 87 +606 820 +606 1040 +606 1097 +606 1439 +606 1644 +606 1730 +606 2555 +606 2556 +606 2557 +1701 612 +1701 1659 +1701 1805 +1701 1939 +1701 2188 +1701 3459 +1701 3460 +1701 3461 +1701 3462 +3371 265 +3371 385 +3371 4707 +3371 4708 +1028 251 +1028 813 +1028 815 +1028 982 +1028 1798 +1028 2733 +1028 2940 +1028 2941 +1028 2942 +1028 2943 +1199 3 +1199 121 +1199 123 +1199 125 +1199 127 +1199 128 +1199 238 +1199 264 +1199 390 +1199 426 +1459 554 +1459 910 +1459 1179 +1459 1275 +1459 1491 +1459 1511 +1459 2494 +1459 3310 +1459 3311 +1459 3312 +1700 23 +1700 436 +1700 451 +1700 2165 +1700 2324 +1700 3455 +1700 3456 +1700 3457 +1700 3458 +1703 78 +1703 889 +1703 1358 +1703 2423 +1703 2906 +1703 3468 +1703 3469 +1703 3470 +1703 3471 +1026 129 +1026 177 +1026 251 +1026 1246 +1026 2199 +1026 2366 +1026 2791 +1026 2937 +1026 2938 +1026 2939 +1139 83 +1139 229 +1139 645 +1139 2359 +1139 3009 +1139 3010 +1139 3011 +1139 3012 +1139 3013 +1139 3014 +3428 1235 +3428 1539 +3428 1776 +3428 1947 +3428 3136 +3428 4373 +3428 4675 +3428 4755 +3428 4756 +3428 4757 +3430 4758 +3431 2077 +3431 2411 +3431 4824 +3433 105 +3433 231 +3433 424 +3433 833 +3433 921 +3433 2911 +3433 3170 +3433 3497 +3433 4461 +3433 4472 +1025 99 +1025 584 +1025 689 +1025 902 +1025 2916 +1025 3191 +1025 3462 +1025 5106 +1025 5107 +1025 5108 +3613 944 +3613 2269 +3613 2621 +3613 3412 +3613 3904 +3613 4553 +3613 4856 +3613 4857 +4285 92 +4285 158 +4285 1645 +4285 1815 +4285 1929 +4285 3551 +4285 4007 +4285 4081 +4285 5183 +4285 5184 +4285 5185 +4285 5186 +4285 5187 +4285 5188 +4285 5189 +4285 5190 +4285 5191 +3178 1948 +3178 2119 +3178 3325 +3178 3457 +3178 4419 +3178 4572 +3178 4573 +3178 4574 +3178 4575 +3178 4576 +3179 282 +3179 303 +3179 728 +3179 822 +3179 1143 +3179 1505 +3179 2528 +3179 2885 +3179 3769 +3179 4075 +5729 586 +5729 898 +5729 2198 +5729 2227 +5729 2789 +5729 3275 +5729 4280 +5729 5756 +5729 5952 +5729 5953 +4295 96 +4295 346 +4295 509 +4295 1632 +4295 1942 +4295 2175 +4295 3292 +4295 4032 +4295 4286 +4295 4533 +4806 5451 +5315 63 +5315 2927 +5315 3346 +5315 4771 +5315 5161 +5315 5578 +5315 5769 +5315 5770 +5315 5771 +5315 5772 +1361 62 +1361 706 +1361 710 +1361 1814 +1361 2209 +1361 3237 +1361 3238 +1361 3239 +1361 3240 +1361 3241 +263 4 +263 126 +263 146 +263 147 +263 264 +263 265 +263 266 +263 267 +263 268 +263 269 +307 711 +307 883 +307 1018 +307 2260 +307 2261 +307 2262 +307 2263 +307 2264 +307 2265 +307 2266 +1704 9 +1704 121 +1704 126 +1704 149 +1704 176 +1704 352 +1704 423 +1704 424 +1704 427 +1704 667 +1707 1956 +1707 2246 +1707 2465 +1707 3477 +1707 3478 +1707 3479 +1707 3480 +1707 3481 +1707 3482 +1707 3483 +1709 248 +1709 587 +1709 1306 +1709 1476 +1709 1509 +1709 1591 +1709 2291 +1709 2429 +1709 3007 +1709 3459 +3988 712 +3988 2209 +3988 2391 +3988 2523 +3988 3119 +3988 3362 +3988 4838 +3988 5024 +3988 5025 +3989 2705 +3989 3908 +3989 4103 +3989 4677 +3989 5028 +652 175 +652 389 +652 424 +652 732 +652 1326 +652 2199 +652 2572 +652 2573 +652 2574 +652 2575 +4117 5086 +2471 57 +2471 272 +2471 274 +2471 834 +2471 1583 +2471 2102 +2471 2141 +2471 2635 +2471 4120 +76 77 +76 78 +76 79 +76 80 +76 81 +76 82 +76 83 +76 84 +76 85 +76 86 +1969 1541 +1969 1548 +1969 2878 +1969 3179 +1969 3519 +1969 3549 +1969 3754 +1969 3755 +1969 3756 +1969 3757 +1854 575 +1854 1290 +1854 1291 +1854 1731 +1854 2049 +1854 2394 +1854 3599 +1854 3602 +1854 3603 +1854 3604 +2536 2254 +4257 9 +4257 123 +4257 126 +4257 145 +4257 148 +4257 149 +4257 248 +4257 369 +4257 1245 +4257 1317 +4041 924 +4041 1199 +4041 1213 +4041 1608 +4041 1867 +4041 1868 +4041 1915 +4041 3336 +4041 4412 +4041 5052 +2350 4 +2350 5 +2350 17 +2350 121 +2350 122 +2350 126 +2350 180 +2350 247 +2350 250 +2350 424 +2420 503 +2420 614 +2420 1763 +2420 2298 +2420 3014 +2420 3071 +2420 3439 +2420 3860 +2420 4093 +2420 4094 +4070 633 +4070 989 +4070 1726 +4070 2207 +4070 2615 +4070 2641 +4070 5059 +4070 5063 +4070 5064 +4070 5065 +1059 3 +1059 8 +1059 121 +1059 125 +1059 128 +1059 174 +1059 179 +1059 247 +1059 424 +1059 717 +1086 152 +1086 219 +1086 424 +1086 1457 +1086 1824 +1086 2124 +1086 2984 +1086 2985 +1086 2986 +3850 125 +3850 129 +3850 146 +3850 249 +3850 251 +4923 5428 +4098 762 +4098 2593 +4098 3956 +4098 4118 +4098 4871 +1055 257 +1055 1347 +1055 2207 +1055 2411 +1055 2802 +1055 2968 +1055 2969 +1055 2970 +1055 2971 +169 818 +169 872 +169 1264 +169 1539 +169 2116 +169 2117 +169 2118 +169 2119 +169 2120 +169 2121 +2822 3 +2822 4 +2822 7 +2822 144 +2822 183 +2822 264 +2822 265 +2822 266 +2822 423 +2822 667 +3360 418 +3363 990 +3363 2444 +3363 2689 +3363 3293 +3363 4221 +3363 4700 +3363 4701 +3363 4702 +3363 4703 +3363 4704 +1168 1909 +1168 1912 +1168 2574 +1168 2791 +1168 2797 +1168 3045 +1168 3046 +1168 3047 +1168 3048 +1168 3049 +241 2010 +241 2186 +241 2187 +241 2188 +2821 73 +2821 176 +2821 353 +2821 354 +2821 367 +2821 667 +2821 823 +2821 1091 +2821 1267 +2821 4320 +2961 345 +2961 415 +2961 937 +2961 1001 +2961 2377 +2961 3242 +2961 3906 +2961 4192 +2961 4433 +2961 4434 +5763 2583 +5763 3359 +5763 3797 +5763 3992 +5763 5118 +5763 5719 +5763 5971 +5763 5972 +2241 3 +2241 163 +2241 1056 +2241 1362 +2241 1539 +2241 2097 +2241 2579 +2241 3946 +2241 3947 +2241 3948 +1424 200 +1424 621 +1424 2261 +1424 2858 +1424 3282 +1424 3283 +1424 3284 +1424 3285 +1424 3286 +1424 3287 +5423 285 +5423 582 +5423 707 +5423 1044 +5423 3202 +5423 4368 +5423 4828 +5423 5100 +5423 5442 +5423 5685 +2052 7 +2052 143 +2052 145 +2052 367 +2052 390 +2052 558 +2052 856 +2052 1040 +2052 1245 +2055 31 +2055 489 +2055 2065 +2055 3290 +2055 3828 +2055 3829 +2055 3830 +2055 3831 +2055 3832 +2055 3833 +1137 83 +1137 2086 +1137 2657 +1137 2966 +1137 3003 +1137 3004 +1137 3005 +1137 3006 +1137 3007 +1137 3008 +5568 894 +5568 1420 +5568 1575 +5568 4368 +5568 4804 +1318 756 +1318 1272 +1318 1273 +1318 1541 +1318 1955 +1318 2758 +1318 3159 +1318 3160 +1318 3161 +1318 3162 +1974 694 +1974 1590 +1974 2368 +1974 3050 +1974 3530 +1974 3744 +1974 3745 +1974 3746 +1974 3747 +1974 3748 +5063 574 +5063 2006 +5063 2375 +5063 2704 +5063 3900 +5063 4114 +5063 5083 +5063 5301 +5063 5475 +5063 5619 +5881 6039 +4194 180 +4194 870 +4194 2432 +4194 3328 +4194 4589 +4196 127 +4196 248 +4196 423 +4196 559 +4196 667 +4196 717 +4196 856 +4196 1041 +4196 4638 +4196 5122 +4198 345 +4198 1318 +4198 1424 +4198 1814 +4198 3033 +4198 3205 +4198 4035 +4198 4960 +4198 5123 +1666 325 +1666 633 +1666 1339 +1666 2275 +1666 3228 +1666 3385 +1666 4109 +1666 4499 +1666 4803 +3535 32 +381 30 +381 279 +381 382 +381 383 +381 384 +381 385 +381 386 +381 387 +381 388 +381 389 +3844 14 +3844 50 +3844 102 +3844 199 +3844 814 +3844 1749 +3844 2344 +3844 2486 +3844 2563 +3844 4958 +656 514 +656 568 +656 657 +656 658 +656 659 +656 660 +656 661 +656 662 +656 663 +656 664 +1546 1547 +1546 1548 +1546 1549 +1546 1550 +1546 1551 +1546 1552 +1546 1553 +1546 1554 +1546 1555 +1546 1556 +5074 311 +5074 1362 +5074 1539 +5074 2087 +5074 2204 +5074 2354 +5074 2579 +5074 3205 +5074 5546 +5075 462 +5075 1454 +5075 1587 +5075 1846 +5075 1903 +5075 2511 +5075 3570 +5075 3586 +5075 5626 +5075 5627 +5200 605 +5200 1714 +5200 2017 +5200 3142 +5200 3402 +5200 4176 +5200 5710 +5200 5711 +5200 5712 +5200 5713 +5201 127 +5201 129 +5201 146 +5201 176 +5201 238 +5201 264 +5201 352 +5201 717 +5201 1245 +5201 2338 +1367 3218 +3676 102 +3676 327 +3676 551 +3676 707 +3676 825 +3676 979 +3676 1010 +3676 1115 +3676 3423 +3676 4295 +1442 575 +3117 308 +3117 860 +3117 1376 +3117 1457 +3117 1767 +3117 2305 +3117 2419 +3117 2712 +3117 2898 +3117 4545 +4279 5 +4279 121 +4279 125 +4279 129 +4279 148 +4279 174 +4279 176 +4279 369 +4279 424 +4279 717 +4280 464 +4280 759 +4280 828 +4280 2709 +4280 2948 +4280 3081 +4280 3859 +4280 4133 +4280 4584 +4280 5181 +298 7 +298 8 +298 121 +298 144 +298 252 +298 266 +298 352 +298 424 +298 666 +299 175 +299 378 +299 443 +299 774 +299 1573 +299 1704 +299 2035 +299 2250 +299 2251 +299 2252 +5291 5660 +5291 5661 +5291 5662 +5291 5663 +5291 5664 +5291 5665 +5291 5666 +5291 5667 +5291 5668 +5291 5669 +5928 4 +5928 127 +5928 143 +5928 146 +5928 175 +5928 264 +5928 390 +5928 427 +5928 558 +80 2014 +343 122 +343 127 +343 176 +343 249 +343 251 +343 558 +343 666 +343 667 +343 754 +343 1245 +346 238 +346 343 +346 1018 +346 2301 +346 2302 +346 2303 +346 2304 +346 2305 +346 2306 +346 2307 +571 721 +571 765 +571 804 +571 1913 +571 2358 +571 2474 +571 2521 +571 2522 +571 2523 +571 2524 +573 228 +573 2520 +574 31 +574 125 +574 175 +574 179 +574 180 +574 250 +574 266 +574 390 +574 424 +536 1132 +2948 355 +2948 607 +2948 823 +2948 1466 +2948 3855 +2948 4424 +2948 4425 +2948 4426 +2948 4427 +2948 4428 +2952 1374 +2952 1507 +2952 2035 +2952 2916 +2952 2953 +2952 3017 +2952 3134 +2952 3629 +2952 4422 +2952 4423 +3471 714 +3471 2425 +3471 2517 +3471 3386 +3471 4854 +4292 103 +4292 1061 +4292 1425 +4292 1827 +4292 1923 +4292 2480 +4292 3021 +4292 3055 +4292 4075 +4292 5192 +137 1728 +557 124 +557 127 +557 147 +557 248 +557 251 +557 252 +557 390 +557 423 +557 558 +557 559 +1039 1176 +1039 1651 +1039 1956 +1039 2271 +1039 2787 +1039 2955 +1039 2956 +1039 2957 +1039 2958 +3200 924 +3200 1517 +3200 2773 +3200 2916 +3200 2943 +3200 3516 +3200 4289 +3200 4478 +3200 4585 +3200 4586 +3192 2 +3192 8 +3192 248 +3192 390 +3192 554 +3192 697 +3192 946 +3192 1317 +3192 2001 +3192 2077 +3193 1983 +4183 463 +4183 1235 +4183 2500 +4183 2823 +4183 4321 +4183 5109 +4183 5110 +4183 5111 +4183 5112 +4183 5113 +101 143 +101 147 +101 249 +101 251 +101 264 +101 369 +101 422 +101 559 +101 718 +101 2018 +3998 255 +3998 1332 +3998 1730 +3998 1936 +3998 3213 +3998 3625 +3998 4704 +3998 5039 +3998 5040 +3998 5041 +4005 1228 +4005 1537 +4005 1587 +4005 2291 +4005 2547 +4005 2563 +4005 3846 +4005 5048 +4005 5049 +4005 5050 +750 385 +750 817 +750 1417 +750 2127 +750 2294 +750 2397 +750 2674 +750 2675 +750 2676 +750 2677 +2950 4435 +5163 1002 +5163 3595 +5163 3822 +5163 4607 +5163 4628 +5163 4734 +5163 4880 +5163 5036 +5163 5272 +5163 5671 +5165 5407 +979 35 +979 119 +979 612 +979 762 +979 866 +979 1023 +979 1318 +979 1319 +979 1320 +979 1321 +2892 763 +2892 2052 +2892 2628 +2892 2773 +2892 4219 +2892 4372 +2892 4373 +2892 4374 +2892 4375 +2892 4376 +4319 720 +4319 866 +4319 1425 +4319 1719 +4319 2546 +4319 4251 +4319 5210 +4319 5211 +4319 5212 +4319 5213 +4016 9 +4016 124 +4016 125 +4016 144 +4016 145 +4016 148 +4016 247 +4016 352 +4016 353 +4016 424 +3257 235 +3257 364 +3257 422 +3257 962 +3257 1565 +3257 2699 +3257 2965 +3257 3605 +3257 4380 +3475 18 +3475 498 +3475 1476 +3475 1554 +3475 2383 +3475 3219 +3475 3717 +3475 4778 +3475 4779 +4021 156 +4021 476 +4021 802 +4021 921 +4021 1336 +4021 2347 +4021 2806 +4021 3053 +4021 3343 +4021 3866 +4026 1330 +4026 5124 +4026 5125 +4032 144 +4032 147 +4032 149 +4032 177 +4032 266 +4032 353 +4032 424 +4032 558 +4032 856 +4032 2338 +4033 21 +4033 385 +4033 1084 +4033 1137 +4033 1167 +4033 1342 +4033 2690 +4033 3829 +4033 4876 +4033 4915 +1711 2707 +1564 3 +1564 127 +1564 144 +1564 146 +1564 149 +1564 176 +1564 177 +1564 238 +1564 247 +1564 367 +1569 65 +1569 373 +1569 1153 +1569 1570 +1569 1571 +1569 1572 +1569 1573 +1569 1574 +1569 1575 +1569 1576 +1637 363 +1637 779 +1637 998 +1637 1503 +1637 1538 +1637 1976 +1637 2299 +1637 3386 +1637 3387 +1637 3388 +4635 443 +4635 664 +4635 828 +4635 942 +4635 2772 +4635 4066 +4635 4333 +4635 4439 +4635 5396 +3266 651 +3266 1935 +3266 2032 +3266 2724 +3266 2948 +3266 3066 +3266 4638 +3266 4639 +3295 925 +3295 1387 +3295 1451 +3295 1587 +3295 2322 +3295 2430 +3295 2790 +3295 3586 +3295 4288 +3295 4663 +3297 921 +39 614 +39 1378 +39 1922 +39 1923 +39 1924 +39 1925 +39 1926 +39 1927 +39 1928 +39 1929 +3341 18 +3341 551 +3341 952 +3341 1388 +3341 3421 +3341 3852 +3341 4043 +3341 4685 +3341 4686 +3341 4687 +4164 8 +4164 121 +4164 127 +4164 146 +4164 177 +4164 353 +4164 369 +4164 422 +4164 427 +4164 717 +1485 8 +1485 9 +1485 121 +1485 125 +1485 128 +1485 129 +1485 144 +1485 352 +1485 427 +1485 1246 +5807 648 +5807 1845 +5807 2264 +5807 3205 +5807 4170 +5807 5403 +5807 5992 +5807 5997 +5807 5998 +5807 5999 +1518 1519 +2253 113 +2253 222 +2253 382 +2253 411 +2253 1157 +2253 2169 +2253 2552 +2253 3949 +2253 3950 +3710 3335 +3710 3708 +3710 4959 +4967 1303 +4967 1989 +4967 2769 +4967 3245 +4967 4330 +4967 4337 +4967 5074 +4967 5507 +4967 5587 +433 20 +433 1370 +433 1565 +433 1824 +433 2433 +3881 528 +3881 756 +3881 874 +3881 3023 +3881 3205 +3881 3271 +3881 3488 +3881 4841 +3881 4975 +3881 4976 +2847 244 +2847 498 +2847 510 +2847 527 +2847 747 +2847 1817 +2847 2535 +2847 3912 +2847 4335 +2847 4336 +3863 804 +3863 2399 +3863 3489 +3863 3543 +3863 3813 +3863 4333 +3863 4395 +3863 5229 +3863 5264 +3863 5337 +3883 8 +3883 123 +3883 146 +3883 247 +3883 248 +3883 249 +3883 266 +3883 369 +3883 427 +3883 667 +3885 2051 +3885 2164 +3885 2708 +3885 3362 +3885 3587 +2546 2 +2546 3 +2546 8 +2546 147 +2546 247 +2546 351 +2546 1317 +2546 2064 +2546 4161 +2546 4162 +736 443 +736 737 +736 738 +736 739 +736 740 +736 741 +736 742 +736 743 +736 744 +736 745 +348 751 +348 930 +348 1322 +348 1364 +348 1366 +348 2004 +348 2292 +348 2293 +348 2294 +348 2295 +1033 281 +1033 554 +1033 659 +1033 1034 +1033 1035 +1033 1036 +1033 1037 +1033 1038 +1033 1039 +1033 1040 +5175 804 +5175 1770 +5175 2004 +5175 2214 +5175 3109 +5175 3596 +5175 3846 +5175 4912 +5175 5633 +5175 5638 +449 4 +449 126 +449 129 +449 145 +449 147 +449 238 +449 266 +449 368 +449 1246 +3010 31 +3010 709 +3010 845 +3010 1544 +3010 3056 +3010 4425 +3010 4449 +3010 4450 +3010 4451 +3010 4452 +3817 909 +3818 953 +3818 1021 +3818 1392 +3818 1798 +3818 2035 +3818 2285 +3818 4103 +3818 4936 +3818 4937 +3818 4938 +3819 432 +3819 514 +3819 730 +3819 1441 +3819 1538 +3819 2785 +3819 3249 +3819 3916 +3819 4484 +3819 4520 +3820 3 +3820 8 +3820 122 +3820 127 +3820 129 +3820 143 +3820 146 +3820 147 +3820 369 +3820 1245 +167 8 +167 17 +167 121 +167 129 +167 175 +167 238 +167 266 +167 353 +167 424 +167 2018 +1885 5 +1885 143 +1885 144 +1885 147 +1885 174 +1885 252 +1885 264 +1885 390 +1885 423 +1885 558 +193 2062 +193 2222 +193 2388 +193 2389 +193 2390 +193 2391 +1243 138 +1243 982 +1243 988 +1243 1787 +1243 2465 +1243 2663 +1243 3106 +1243 3107 +1243 3108 +1297 289 +1297 435 +1297 753 +1297 901 +1297 1199 +1297 1504 +1297 1763 +1297 1764 +1297 1765 +1297 1766 +2093 427 +2093 484 +2093 958 +2093 1426 +2093 1529 +2093 1688 +2093 2244 +2093 3046 +2093 3769 +2093 3863 +2866 364 +2866 619 +2866 706 +2866 1620 +2866 1787 +2866 2089 +2866 3017 +2866 3156 +2866 3930 +2866 4368 +2870 23 +2870 1431 +2870 1754 +2870 2344 +2870 2778 +2870 4360 +2870 4361 +2870 4362 +2870 4363 +2870 4364 +4057 459 +4057 1034 +4057 1054 +4057 1374 +4057 2833 +4057 5066 +4057 5067 +4057 5068 +4057 5069 +4058 550 +4058 628 +4058 1750 +4058 2649 +4058 5056 +4058 5057 +4060 1571 +4060 1918 +4060 2543 +4060 2571 +4060 2745 +4060 2935 +4060 3153 +4060 4172 +4060 4492 +4060 4919 +4735 606 +4735 2249 +4735 3993 +4735 5473 +4735 5474 +4735 5475 +4738 77 +4738 586 +4738 672 +4738 1980 +4738 2147 +4738 3138 +4738 5016 +4738 5303 +4738 5451 +4738 5452 +321 32 +321 322 +321 323 +321 324 +321 325 +321 326 +321 327 +321 328 +321 329 +321 330 +3115 262 +3115 1100 +3115 1415 +3115 1845 +3115 1889 +3115 2113 +3115 3699 +3115 4539 +3115 4540 +3115 4541 +2529 11 +2529 1904 +2529 2061 +2529 3080 +2529 3487 +2529 3849 +2529 4263 +2529 4980 +2529 5159 +2529 5600 +4330 31 +4330 126 +4330 146 +4330 148 +4330 174 +4330 250 +4330 559 +4330 856 +4330 1245 +4330 3779 +904 492 +904 749 +904 1790 +904 2737 +904 2791 +904 2792 +904 2793 +904 2794 +904 2795 +904 2796 +1559 144 +1559 145 +1559 147 +1559 251 +1559 252 +1559 264 +1559 266 +1559 368 +1559 667 +4277 227 +4277 1698 +4277 1787 +4277 2115 +4277 3058 +4277 4026 +4277 4275 +4277 5179 +4277 5180 +5129 848 +5129 1150 +5129 1956 +5129 2094 +5129 3283 +5129 3781 +5129 4256 +5129 4874 +5129 5293 +5129 5644 +989 8 +989 49 +989 53 +989 108 +989 751 +989 756 +989 986 +989 990 +989 991 +989 1047 +989 1383 +989 1424 +989 2054 +989 2375 +989 2399 +989 2525 +989 2606 +989 2890 +989 2891 +989 2892 +989 2893 +989 2894 +989 2895 +989 2896 +989 2897 +5131 823 +5131 1787 +5131 2288 +5131 2566 +5131 3109 +5131 3797 +5131 4248 +5131 4895 +5131 5645 +5131 5646 +2143 494 +2143 1068 +2143 1402 +2143 1545 +2143 2165 +2143 2166 +2143 2215 +2143 2646 +2143 3889 +2143 3890 +2695 3 +2695 124 +2695 127 +2695 264 +2695 353 +2695 718 +2695 1245 +2695 1670 +2695 1878 +2695 1989 +3997 28 +3997 714 +3997 1861 +3997 2425 +3997 3343 +3997 3386 +3997 3471 +3997 3702 +3997 4189 +3997 4854 +4669 141 +4669 289 +4669 2227 +4669 2353 +4669 2625 +4669 3162 +4669 3562 +4669 5414 +4669 5415 +4669 5416 +341 370 +341 862 +341 1591 +341 1805 +341 1891 +341 2177 +341 2288 +341 2289 +341 2290 +341 2291 +764 765 +764 766 +764 767 +764 768 +764 769 +764 770 +764 771 +764 772 +764 773 +764 774 +909 124 +909 127 +909 175 +909 180 +909 251 +909 367 +909 368 +909 390 +909 718 +1717 257 +1717 541 +1717 852 +1717 1441 +1717 1702 +1717 2356 +1717 2553 +1717 3484 +1717 3485 +1717 3486 +1805 871 +1805 1806 +1805 1807 +1805 1808 +1805 1809 +1805 1810 +1805 1811 +1805 1812 +1805 1813 +1805 1814 +105 363 +105 820 +105 1041 +105 1240 +105 2019 +105 2020 +105 2021 +105 2022 +105 2023 +105 2024 +5497 41 +5497 143 +5497 266 +5497 491 +5497 911 +5497 2202 +5497 3599 +5497 4652 +5497 5845 +5497 5846 +2949 163 +2949 264 +2949 667 +2949 708 +2949 1903 +2949 1926 +2949 2035 +2949 3365 +2949 4402 +2949 4421 +4639 472 +4639 576 +4639 2060 +4639 4158 +4639 5406 +5106 1027 +5106 1940 +5106 2005 +5106 2429 +5106 2497 +5106 3238 +5106 4934 +5106 5244 +5106 5639 +5106 5640 +5552 353 +5552 785 +5552 849 +5552 918 +5552 1103 +5552 3618 +5552 4812 +5552 5040 +5552 5405 +5552 5873 +3587 94 +3587 352 +3587 2628 +3587 3109 +3587 3469 +3587 4141 +3587 4170 +3587 4455 +3587 4784 +3587 4844 +4577 8 +4577 282 +4577 822 +4577 1143 +4577 1780 +4577 2016 +4577 3081 +4577 5128 +4577 5365 +6152 371 +6152 762 +6152 1330 +6152 1797 +6152 2531 +6152 3305 +6152 3503 +6152 3900 +6152 4981 +6152 6171 +3550 748 +3550 813 +3550 1587 +3550 1766 +3550 2198 +3550 2744 +3550 2859 +3550 3080 +3550 4280 +3550 4815 +3626 102 +3626 1262 +3626 1647 +3626 3615 +3626 4412 +3524 330 +3524 945 +3524 1047 +3524 1797 +3524 2397 +3524 2705 +3524 3017 +3524 3235 +3524 3583 +3524 4802 +4431 296 +4431 1434 +4431 2427 +4431 2643 +4431 5276 +5277 25 +5277 228 +5277 1227 +5277 3096 +5277 5758 +1922 873 +1922 1359 +1922 1526 +1922 2941 +1922 3612 +1922 3688 +1922 3689 +1922 3690 +1922 3691 +1922 3692 +5356 685 +5356 2002 +5356 2036 +5356 3407 +5356 3455 +5357 1516 +5357 5474 +5357 5816 +469 41 +469 102 +469 470 +469 471 +469 472 +469 473 +469 474 +469 475 +469 476 +469 477 +553 2 +553 4 +553 175 +553 251 +553 554 +553 695 +553 696 +553 697 +553 946 +553 2077 +1163 632 +1163 1882 +1163 2593 +1163 3617 +1163 4494 +1163 4495 +1163 4496 +1163 4497 +1163 4498 +1163 4499 +3056 290 +3056 520 +3056 1493 +3056 2150 +3056 2334 +3056 3833 +3056 4481 +3056 4482 +3056 4483 +1749 863 +1749 1094 +1749 1555 +1749 2722 +1749 2743 +1749 2996 +1749 3506 +1749 3507 +1749 3508 +1749 3509 +3081 9 +3081 549 +3081 1480 +3081 2089 +3081 2385 +3081 2719 +3081 3039 +3081 4278 +3081 4503 +3081 4504 +3566 828 +3566 1289 +3566 1491 +3566 2826 +3566 3928 +3566 4104 +3566 4655 +3566 4751 +3566 4825 +3566 4826 +2489 2661 +4010 110 +4010 2795 +4010 3003 +4010 3404 +4010 4533 +4010 4904 +4010 5045 +4010 5046 +4010 5047 +4619 381 +4619 778 +4619 1592 +4619 1900 +4619 2166 +4619 2234 +4619 2646 +4619 2875 +4619 3327 +4619 4812 +902 1272 +902 2409 +902 2626 +902 2663 +902 2779 +902 2780 +902 2781 +902 2782 +902 2783 +902 2784 +2942 21 +2942 132 +2942 924 +2942 1335 +2942 1417 +2942 1842 +2942 1890 +2942 4415 +2942 4416 +2942 4417 +3106 2543 +4847 350 +4847 1040 +4847 1054 +4847 1512 +4847 2752 +4847 3417 +4847 4080 +4847 4251 +4847 4551 +4847 5526 +579 231 +579 893 +579 1476 +579 1629 +579 1682 +579 2529 +579 2530 +579 2531 +579 2532 +579 2533 +2463 5 +2463 933 +2463 2592 +2463 2797 +2463 2798 +2463 3105 +2463 3927 +2463 4084 +2463 4114 +2463 4115 +620 396 +620 409 +620 469 +620 534 +620 1583 +620 2272 +620 2385 +620 2552 +620 2553 +620 2554 +1799 554 +1799 655 +1799 661 +1799 853 +1799 1026 +1799 1800 +1799 1801 +1799 1802 +1799 1803 +1799 1804 +3526 3 +3526 8 +3526 121 +3526 122 +3526 123 +3526 129 +3526 367 +3526 422 +3526 424 +3526 667 +4583 1068 +4583 1227 +4583 2036 +4583 3087 +4583 4194 +4583 4793 +4583 5281 +4583 5285 +4583 5382 +4583 5383 +5149 802 +5149 2125 +5149 2499 +5149 5656 +5149 5657 +836 837 +836 838 +836 839 +836 840 +836 841 +836 842 +836 843 +836 844 +836 845 +2461 559 +2461 1005 +2461 1081 +2461 1425 +2461 1549 +2461 2791 +2461 2796 +2461 4044 +2461 4112 +2461 4113 +2660 1840 +4244 904 +4244 918 +4244 986 +4244 1157 +4244 1547 +4244 3006 +4244 4628 +4244 4966 +4244 5157 +4244 5158 +3737 660 +3856 4 +3856 7 +3856 144 +3856 149 +3856 238 +3856 247 +3856 353 +3856 717 +3856 1317 +3856 2018 +4686 315 +4686 337 +4686 353 +4686 629 +4686 1491 +4686 3571 +4686 4915 +4686 5300 +4686 5421 +4686 5422 +1301 866 +1301 1305 +1301 1345 +1301 1346 +1301 1347 +1301 1348 +1301 1349 +1301 1350 +1301 1351 +1305 67 +1305 124 +1305 176 +1305 339 +1305 427 +1305 1669 +1305 1749 +1305 3150 +1305 3151 +1305 3152 +2504 894 +2504 1248 +2504 2653 +2504 3555 +2504 3775 +2504 4131 +2504 4132 +2504 4133 +2504 4134 +2504 4135 +4864 141 +4864 279 +4864 1143 +4864 1443 +4864 2961 +4864 3452 +4864 5533 +4864 5534 +4864 5535 +4864 5536 +881 260 +881 667 +881 837 +881 1511 +881 2579 +881 2593 +881 2594 +881 2595 +881 2771 +881 2772 +1259 5 +1259 126 +1259 148 +1259 149 +1259 174 +1259 176 +1259 249 +1259 251 +1259 265 +1259 352 +3982 108 +3982 503 +3982 534 +3982 1511 +3982 1805 +3982 2090 +3982 3461 +3982 4658 +3982 5022 +4107 652 +4107 816 +4107 1097 +4107 3714 +4107 3904 +4107 4012 +4107 4122 +4107 5078 +4107 5079 +4107 5080 +4144 322 +4144 462 +4144 1447 +4144 1481 +4144 1615 +4144 4214 +4144 4307 +4144 4955 +4144 5097 +4144 5098 +4146 621 +4146 2347 +4146 2537 +4146 3372 +4146 3485 +4146 3498 +4146 3608 +4146 4397 +4146 5103 +4658 1973 +1557 367 +1557 562 +1557 931 +1557 943 +1557 1122 +1557 1177 +1557 1558 +1557 1559 +1557 1560 +1557 1561 +1992 126 +1992 128 +1992 144 +1992 145 +1992 147 +1992 424 +1992 2018 +1992 2614 +1992 3466 +1992 3764 +3350 648 +3350 1454 +3350 1812 +3350 2177 +3350 2825 +3350 3363 +3350 4657 +3350 4690 +3350 4691 +3350 4692 +4434 352 +4434 777 +4434 926 +4434 2086 +4434 3932 +4434 3983 +4434 4757 +4434 4980 +4434 5273 +4434 5274 +4693 416 +4693 705 +4693 1651 +4693 1968 +4693 2399 +4693 2848 +4693 3733 +4693 4640 +4693 5426 +4693 5427 +350 329 +350 378 +350 432 +350 558 +350 1734 +350 2264 +350 2328 +350 2329 +350 2330 +350 2331 +4890 223 +4890 1029 +4890 1524 +4890 1695 +4890 1956 +4890 2911 +4890 3489 +4890 3590 +4890 3695 +4890 5553 +1533 85 +1533 279 +1533 529 +1533 1255 +1533 1401 +1533 1822 +1533 1920 +1533 2332 +1533 2884 +1533 2891 +1536 1050 +1537 5 +1537 9 +1537 128 +1537 145 +1537 148 +1537 176 +1537 179 +1537 248 +1537 352 +1537 424 +30 3 +30 5 +30 8 +30 121 +30 124 +30 126 +30 145 +30 174 +30 249 +30 424 +2681 222 +2681 325 +2681 1022 +2681 1064 +2681 1109 +2681 2885 +2681 3217 +2681 3252 +2681 3572 +2681 3848 +3848 3212 +267 414 +267 813 +267 1050 +267 1749 +267 2229 +267 2230 +267 2231 +267 2232 +267 2233 +267 2234 +3846 491 +3846 4241 +3846 4625 +3846 4893 +3846 5155 +3846 5229 +3846 5267 +3846 5937 +3846 5938 +3846 5939 +1466 132 +1466 214 +1466 451 +1466 1162 +1466 2013 +1466 2524 +1466 3313 +1466 3314 +1466 3315 +1466 3316 +386 389 +386 609 +386 1077 +386 1451 +386 2035 +386 2360 +386 2361 +386 2362 +386 2363 +386 2364 +3176 3 +3176 8 +3176 127 +3176 129 +3176 146 +3176 176 +3176 246 +3176 426 +3176 1245 +3176 2098 +3599 693 +3599 2916 +3599 3682 +3599 4852 +3599 4853 +1691 3669 +2231 132 +2231 686 +2231 970 +2231 1598 +2231 2802 +2231 3938 +2231 3939 +2231 3940 +2231 3941 +2231 3942 +5417 892 +5417 1107 +5417 1330 +5417 1617 +5417 1757 +5417 2112 +5417 3926 +5417 5415 +5417 5812 +5417 5813 +5418 7 +5418 124 +5418 144 +5418 146 +5418 148 +5418 266 +5418 698 +5418 754 +5418 1297 +5418 2803 +14 809 +195 4 +195 124 +195 143 +195 176 +195 368 +195 422 +195 558 +195 736 +195 1245 +923 451 +923 494 +923 685 +923 922 +923 924 +923 925 +923 926 +923 927 +923 928 +1881 263 +1881 1085 +1881 1456 +1881 2397 +1881 3392 +1881 3479 +1881 3632 +1881 3633 +1881 3634 +1881 3635 +2693 82 +2693 1536 +2693 1734 +2693 2039 +2693 2433 +2693 2820 +2693 4262 +2693 4263 +2693 4264 +2693 4265 +5029 146 +5029 177 +5029 353 +5029 1047 +5029 1135 +5029 2130 +5029 2338 +5029 3503 +5029 4453 +5029 5617 +5321 255 +5321 1115 +5321 1845 +5321 1928 +5321 3933 +5321 4074 +5321 4129 +5321 5510 +5321 5775 +5321 5776 +4761 159 +4761 813 +4761 2494 +4761 3306 +4761 4759 +4762 3497 +4766 21 +4766 892 +4766 940 +4766 1116 +4766 1658 +4766 1872 +4766 4754 +4766 5348 +4766 5469 +4766 5470 +3034 127 +3034 289 +3034 1223 +3034 3035 +3034 3795 +3034 4292 +3034 4388 +3034 4466 +3034 4467 +3547 711 +4043 744 +4043 749 +4043 946 +4043 2040 +4043 2286 +4043 2912 +4043 4432 +4043 4675 +4043 5054 +4043 5055 +5083 211 +5083 581 +5083 599 +5083 605 +5083 1486 +5083 1855 +5083 2500 +5083 3251 +5083 3402 +5083 3982 +1721 211 +1721 706 +1721 1104 +1721 2127 +1721 2373 +1721 2430 +1721 2720 +1721 3006 +1721 3476 +1982 2086 +1230 586 +1230 862 +1230 1061 +1230 1900 +1230 1923 +1230 2723 +1230 3670 +1230 4540 +3796 110 +3796 563 +3796 884 +3796 1313 +3796 2170 +3796 2216 +3796 3269 +3796 4930 +4236 1505 +4236 1645 +4236 5105 +4236 5155 +4236 5156 +716 124 +716 128 +716 174 +716 176 +716 177 +716 179 +716 353 +716 390 +716 717 +716 718 +4388 213 +4388 265 +4388 369 +4388 427 +4388 554 +4388 695 +4388 754 +4388 2914 +4388 3028 +4388 5247 +4399 5 +4399 125 +4399 127 +4399 179 +4399 248 +4399 250 +4399 559 +4399 667 +4399 717 +4399 2018 +2670 4 +2670 121 +2670 145 +2670 148 +2670 174 +2670 252 +2670 265 +2670 422 +2670 559 +2670 666 +4334 57 +4334 3756 +4334 4036 +4334 4242 +4334 4397 +4334 4684 +4334 4814 +4334 5116 +4334 5220 +4334 5221 +4402 190 +4402 3895 +4402 5220 +4402 5345 +4403 202 +4403 280 +4403 1021 +4403 2251 +4403 2296 +4403 4117 +4403 4382 +4403 5263 +4403 5264 +4304 5157 +4694 1047 +4694 2449 +4694 3293 +4694 3929 +4694 4164 +4694 5430 +4694 5431 +4694 5432 +4694 5433 +5021 5604 +2195 244 +2195 1087 +2195 2697 +2195 2981 +2195 3205 +2195 3319 +2195 3916 +2195 3917 +2195 3918 +60 1937 +60 1938 +60 1939 +60 1940 +60 1941 +60 1942 +60 1943 +60 1944 +60 1945 +3693 3 +3693 123 +3693 126 +3693 144 +3693 149 +3693 179 +3693 251 +3693 367 +3693 424 +3693 717 +2492 64 +2492 813 +2492 852 +2492 1608 +2492 1868 +2492 3196 +2492 3421 +2492 3617 +2492 4040 +4781 679 +4781 963 +4781 1359 +4781 5478 +4781 5479 +4781 5480 +4781 5481 +4781 5482 +4781 5483 +4781 5484 +986 145 +986 146 +986 251 +986 264 +986 367 +986 559 +986 666 +986 667 +986 1245 +988 138 +988 163 +988 870 +988 1610 +988 2474 +988 2630 +988 2767 +988 2887 +988 2888 +988 2889 +990 127 +990 148 +990 183 +990 249 +990 252 +990 264 +990 265 +990 266 +990 368 +990 666 +211 494 +211 621 +211 1358 +211 1412 +211 2161 +211 2162 +211 2163 +211 2164 +211 2165 +211 2166 +73 717 +73 1022 +73 1969 +73 1970 +73 1971 +73 1972 +73 1973 +73 1974 +73 1975 +73 1976 +3495 3 +3495 145 +3495 174 +3495 176 +3495 177 +3495 249 +3495 251 +3495 353 +3495 1317 +3495 3995 +4908 424 +4908 5314 +4908 5563 +4908 5564 +4908 5565 +6138 129 +6138 143 +6138 146 +6138 177 +6138 249 +6138 367 +6138 369 +6138 423 +6138 424 +6138 2338 +340 341 +340 342 +340 343 +340 344 +340 345 +340 346 +340 347 +340 348 +340 349 +340 350 +3380 248 +3380 487 +3380 910 +3380 1801 +3380 2002 +3380 3350 +3380 4716 +3380 4717 +3380 4718 +825 826 +825 827 +825 828 +825 829 +825 830 +825 831 +825 832 +825 833 +825 834 +825 835 +1733 73 +1733 407 +1733 830 +1733 2350 +1733 3491 +1733 3492 +1733 3493 +1733 3494 +1733 3495 +1733 3496 +2356 38 +2356 215 +2356 962 +2356 1522 +2356 2007 +2356 4035 +2356 4036 +2356 4037 +2356 4038 +1354 163 +1354 1642 +1354 1741 +1354 2134 +1354 2329 +1354 2683 +1354 2880 +1354 3202 +1354 3203 +3326 418 +3326 1021 +3326 1030 +3326 1240 +3326 3478 +3326 3499 +3326 4430 +3326 4583 +3326 4673 +3326 4674 +3247 321 +3247 452 +3247 453 +3247 531 +3247 736 +3247 1947 +3247 2035 +3247 2689 +3247 3095 +3247 4625 +4343 169 +4343 1050 +4343 1317 +4343 1437 +4343 3223 +4343 3362 +4343 4731 +4343 5200 +4343 5231 +4650 605 +4650 835 +4650 1430 +4650 2970 +4650 3369 +4650 5407 +4650 5408 +4650 5409 +4650 5410 +280 318 +280 552 +280 790 +280 967 +280 1202 +280 1259 +280 1412 +280 1620 +280 1933 +280 2235 +283 552 +283 632 +283 779 +283 838 +283 1321 +283 1371 +283 1571 +283 1891 +283 1892 +283 2236 +284 32 +284 503 +284 1699 +284 1789 +284 2237 +284 2238 +284 2239 +284 2240 +284 2241 +284 2242 +3612 4855 +4881 5672 +4643 538 +4643 1575 +4643 1731 +4643 2214 +4643 2784 +4643 3566 +4643 4336 +4643 5342 +4643 5343 +4986 200 +4986 1038 +4986 1044 +4986 2036 +4986 2425 +4986 3566 +4986 3794 +4986 4262 +4986 5588 +4986 5589 +4441 76 +4441 1087 +4441 1726 +4441 2583 +4441 2762 +4441 3487 +4441 3511 +4441 3823 +4441 5287 +4205 1501 +4206 123 +4206 369 +4206 504 +4206 1442 +4206 1487 +4206 2060 +4206 3304 +4206 5146 +4206 5147 +4206 5148 +4207 97 +4207 706 +4207 1685 +4207 1903 +4207 4231 +4208 252 +4208 1068 +4208 2564 +4208 3620 +4208 4071 +4208 5022 +4208 5133 +4208 5134 +4208 5135 +4208 5136 +1232 263 +1232 1854 +1232 1881 +1232 2493 +1232 3089 +1232 3090 +1232 3091 +1232 3092 +1232 3093 +1232 3094 +5120 626 +377 127 +377 129 +377 176 +377 369 +377 423 +377 718 +377 856 +377 2018 +377 2338 +75 190 +75 219 +75 262 +75 1142 +75 1337 +75 1964 +75 1965 +75 1966 +75 1967 +75 1968 +4684 970 +4684 1731 +4684 3837 +4684 4176 +4684 4735 +4684 5343 +4684 5419 +4684 5420 +1929 126 +1929 128 +1929 145 +1929 149 +1929 174 +1929 177 +1929 179 +1929 266 +1929 2001 +1929 2018 +3738 587 +3738 1216 +3738 1424 +3738 1792 +3738 2010 +3738 3084 +3738 4788 +3738 4915 +3738 4916 +2146 4 +2146 5 +2146 9 +2146 10 +2146 147 +2146 266 +2146 368 +2146 423 +2146 1245 +3040 4 +3040 5 +3040 122 +3040 123 +3040 128 +3040 144 +3040 175 +3040 176 +3040 424 +3041 134 +3041 365 +3041 1061 +3041 3207 +3041 3819 +3041 3867 +3041 4136 +3041 4193 +3041 4484 +3041 4485 +3042 3 +3042 124 +3042 175 +3042 249 +3042 250 +3042 266 +3042 367 +3042 558 +3042 697 +3042 754 +3043 9 +3043 126 +3043 145 +3043 147 +3043 148 +3043 252 +3043 266 +3043 352 +3043 559 +3043 856 +130 131 +130 132 +130 133 +130 134 +130 135 +130 136 +130 137 +130 138 +130 139 +130 140 +4825 838 +4825 839 +4825 1716 +4825 2211 +4825 2226 +4825 4388 +4825 4915 +4825 5513 +4825 5514 +4825 5515 +5487 5858 +5785 121 +5785 123 +5785 144 +5785 149 +5785 176 +5785 180 +5785 352 +5785 754 +5785 1317 +689 609 +689 690 +689 691 +689 692 +689 693 +4428 179 +4428 247 +4428 251 +4428 266 +4428 368 +4428 422 +4428 423 +4428 424 +4428 667 +4428 717 +4492 573 +4492 1138 +4492 1177 +4492 1212 +4492 1940 +4492 3343 +4492 3860 +4492 4254 +4492 5321 +4492 5322 +1814 442 +1814 1328 +1814 1817 +1814 2193 +1814 3204 +1814 3546 +1814 3547 +1814 3548 +1814 3549 +1814 3550 +1870 71 +1870 642 +1870 706 +1870 1705 +1870 1714 +1870 1871 +1870 1872 +1870 1873 +1870 1874 +1870 1875 +2295 76 +2295 612 +2295 1512 +2295 2348 +2295 2403 +2295 2868 +2295 3082 +2295 3127 +2295 3794 +2576 111 +2576 3699 +2576 4004 +2576 4175 +2576 4176 +4344 684 +4344 1943 +4344 3861 +4344 4766 +4344 4973 +4344 5226 +4344 5227 +4344 5228 +4344 5229 +4344 5230 +4353 4 +4353 5 +4353 123 +4353 125 +4353 126 +4353 144 +4353 177 +4353 180 +4353 754 +4353 1317 +4355 202 +4355 472 +4355 867 +4355 1213 +4355 1929 +4355 4081 +4355 5185 +4355 5186 +4355 5240 +4355 5241 +2888 527 +2888 652 +2888 1738 +2888 2304 +2888 3017 +2888 4327 +2888 4393 +2888 4394 +2888 4395 +2888 4396 +4935 1136 +4935 2151 +4935 2785 +4935 3849 +4935 3856 +4935 4103 +4935 5388 +4935 5448 +4935 5585 +4935 5586 +2663 107 +2663 325 +2663 1412 +2663 1504 +2663 2862 +2663 3204 +2663 3292 +2663 4247 +2663 4248 +2663 4249 +2901 3 +2901 8 +2901 123 +2901 128 +2901 146 +2901 177 +2901 179 +2901 248 +2901 390 +2901 1245 +4733 178 +4733 983 +4733 1679 +4733 2569 +4733 3590 +4733 3730 +4733 4526 +4733 4876 +4733 5447 +4733 5448 +360 65 +360 361 +360 362 +360 363 +360 364 +360 365 +1126 3147 +1126 3148 +1130 2938 +3568 43 +3568 221 +3568 918 +3568 1311 +3568 1934 +3568 2862 +3568 3614 +3568 4802 +3568 4836 +3568 4837 +1999 209 +1999 924 +1999 1199 +1999 1297 +1999 1606 +1999 1608 +1999 1867 +1999 1868 +1999 3336 +1999 3769 +4124 1208 +4124 2474 +4124 2636 +4124 3404 +4124 3733 +4124 3806 +4124 4687 +4124 5087 +4124 5088 +4124 5089 +2922 178 +2922 252 +2922 264 +2922 367 +2922 390 +2922 422 +2922 423 +2922 559 +2922 754 +2922 2001 +434 4 +434 5 +434 7 +434 127 +434 145 +434 148 +434 266 +434 559 +434 1317 +434 2018 +1832 604 +1832 1154 +1832 1408 +1832 1754 +1832 1888 +1832 1967 +1832 1984 +1832 1985 +1832 3583 +1832 3584 +997 522 +997 1332 +997 1829 +997 2061 +997 2383 +997 2507 +997 2902 +4569 581 +4569 1026 +4569 2965 +4569 4455 +4569 4516 +4569 4821 +4569 4844 +4569 5359 +4569 5360 +4569 5361 +724 152 +724 215 +724 725 +724 1313 +724 1424 +724 1434 +724 2443 +724 2653 +724 2654 +5726 4 +5726 9 +5726 17 +5726 126 +5726 149 +5726 175 +5726 422 +5726 559 +5726 754 +5727 1531 +5727 2241 +5727 2804 +5727 3334 +5727 5844 +5727 5947 +5727 5948 +5727 5949 +5727 5950 +5727 5951 +975 906 +975 940 +975 976 +975 977 +975 978 +975 979 +975 980 +975 981 +975 982 +975 983 +1910 271 +1910 549 +1910 659 +1910 711 +1910 1180 +1910 1583 +1910 2288 +1910 2634 +1910 2833 +1910 3682 +473 1193 +473 1509 +473 3205 +473 3309 +473 4207 +473 4282 +473 4828 +473 4829 +473 4830 +3014 274 +3014 937 +3014 1016 +3014 1305 +3014 1503 +3014 1608 +3014 1800 +3014 1947 +3014 3706 +3014 4458 +682 309 +682 690 +682 712 +682 851 +682 1337 +682 1347 +682 2411 +682 2585 +682 2586 +5030 281 +5030 1168 +5030 1447 +5030 1451 +5030 1590 +5030 2353 +5030 2885 +5030 3069 +5030 4687 +5030 4877 +5034 3029 +5035 2857 +5035 3681 +5035 3727 +5035 3772 +5035 4663 +5035 5606 +5035 5607 +5035 5608 +5035 5609 +5035 5610 +1359 626 +1359 913 +1359 1741 +1359 1958 +1359 1980 +1359 2194 +1359 2617 +1359 3206 +1359 3207 +1359 3208 +2875 141 +2875 396 +2875 848 +2875 2313 +2875 3327 +2875 3894 +2875 4051 +2875 4357 +2875 4358 +2875 4359 +3858 2081 +3858 2519 +3858 2762 +3858 3247 +3858 4439 +3858 4441 +3858 4828 +3858 4877 +4880 1598 +4880 4333 +4880 4395 +4880 5295 +4880 5545 +4880 5546 +4880 5547 +4880 5548 +4880 5549 +4356 2927 +4356 3376 +4356 3916 +4356 4940 +4356 5323 +2092 133 +2092 266 +2092 666 +2092 1531 +2092 1866 +2092 3124 +2092 3855 +2092 3856 +2092 3857 +2092 3858 +2094 629 +2094 685 +2094 2317 +2094 2494 +2094 2540 +2094 2776 +2094 3594 +2094 3859 +2094 3860 +2094 3861 +2095 3862 +4867 493 +4867 600 +4867 725 +4867 1034 +4867 2347 +4867 3968 +4867 5283 +4867 5543 +4867 5544 +4799 1456 +4799 1618 +4799 2234 +4799 2896 +4799 4876 +4799 4883 +4799 5463 +4799 5498 +1415 17 +1415 455 +1415 747 +1415 2119 +1415 2311 +1415 2897 +1415 2975 +1415 3271 +1415 3272 +1415 3273 +1417 8 +1417 121 +1417 122 +1417 123 +1417 127 +1417 147 +1417 177 +1417 246 +1417 251 +1417 353 +196 246 +196 424 +196 659 +196 809 +196 2120 +196 2142 +196 2143 +196 2144 +196 2145 +196 2146 +5245 123 +5245 127 +5245 146 +5245 147 +5245 175 +5245 247 +5245 250 +5245 369 +5245 423 +5819 123 +5819 143 +5819 177 +5819 179 +5819 247 +5819 264 +5819 367 +5819 369 +5819 422 +5819 1246 +4109 795 +4109 843 +4109 979 +4109 1172 +4109 2085 +4109 2561 +4109 3925 +4109 4075 +4109 4183 +4109 5082 +1192 338 +1192 834 +1192 900 +1192 1193 +1192 1194 +1192 1195 +1192 1196 +1192 1197 +1192 1198 +1981 451 +1981 1724 +1981 2255 +1981 2524 +1981 3758 +1981 3759 +1981 3760 +1981 3761 +1981 3762 +1981 3763 +5824 1592 +5824 1993 +5824 2267 +5824 2650 +5824 2672 +5824 2720 +5824 4128 +5824 5771 +5824 5958 +5824 5974 +1601 125 +1601 126 +1601 129 +1601 148 +1601 149 +1601 179 +1601 247 +1601 248 +1601 717 +1601 754 +3943 2539 +3943 2744 +3943 2747 +3943 2859 +3943 2898 +3943 3779 +3943 4613 +3943 5010 +3943 5011 +3943 5012 +3945 122 +3945 123 +3945 124 +3945 126 +3945 149 +3945 177 +3945 247 +3945 698 +998 181 +998 668 +998 1536 +998 1735 +998 2023 +998 2451 +998 2898 +998 2899 +998 2900 +998 2901 +2156 1016 +2156 2309 +2156 2354 +2156 3300 +2156 3431 +2156 5343 +2156 5468 +2156 5958 +2156 5959 +2156 5960 +4654 1137 +4654 1239 +4654 1509 +4654 1616 +4654 1803 +4654 3141 +4654 3699 +4654 3807 +4654 4655 +4654 5852 +4654 5954 +4654 5955 +3877 478 +27 901 +27 960 +27 1511 +27 1624 +27 1836 +27 1911 +27 1912 +27 1913 +27 1914 +27 1915 +577 164 +577 584 +577 642 +577 977 +577 1610 +577 2506 +577 2525 +577 2526 +577 2527 +577 2528 +580 3 +580 910 +580 1275 +580 1427 +580 1782 +580 1792 +580 2539 +580 2540 +580 2541 +580 2542 +2828 113 +2828 256 +2828 518 +2828 2196 +2828 2322 +2828 2992 +2828 3963 +2828 4124 +2828 4325 +3269 5 +3269 17 +3269 126 +3269 143 +3269 149 +3269 250 +3269 266 +3269 423 +3269 424 +3269 559 +3270 522 +3270 4150 +3270 4365 +3270 4642 +3270 4643 +3406 1367 +3406 3292 +3406 3991 +3406 4739 +3406 4740 +3407 1246 +3407 1503 +3407 1650 +3407 1845 +3407 2343 +3407 3303 +3407 4206 +3407 4264 +3407 4741 +3407 4742 +882 2774 +885 2773 +111 1419 +111 1561 +111 1670 +111 1787 +111 1846 +111 2065 +111 2066 +111 2067 +111 2068 +111 2069 +1167 274 +1167 1168 +1167 1169 +1167 1170 +1167 1171 +1545 1837 +6255 757 +270 190 +270 271 +270 272 +270 273 +270 274 +270 275 +270 276 +270 277 +270 278 +680 144 +680 145 +680 251 +680 630 +680 1841 +680 1842 +680 1843 +680 1844 +680 1845 +680 1846 +5077 837 +5077 2842 +5077 3743 +5077 4270 +5077 5634 +1134 164 +3304 125 +3304 174 +3304 180 +3304 252 +3304 264 +3304 266 +3304 368 +3304 390 +3304 422 +3304 559 +4308 1299 +4308 1533 +4308 1609 +4308 1872 +4308 1926 +4308 1955 +4308 3455 +4308 4078 +4308 4485 +4308 5205 +479 2452 +479 2453 +479 2454 +479 2455 +479 2456 +479 2457 +479 2458 +479 2459 +479 2460 +479 2461 +480 382 +480 507 +480 722 +480 726 +480 1048 +480 2319 +480 2358 +480 2462 +480 2463 +481 4 +481 124 +481 265 +481 353 +481 368 +481 369 +481 695 +481 700 +481 946 +481 947 +484 337 +484 532 +484 786 +484 1352 +484 1764 +484 2493 +484 2494 +484 2495 +484 2496 +484 2497 +2091 681 +2091 979 +2091 1212 +2091 2326 +2091 2385 +2091 2395 +2091 3460 +2091 3864 +2091 3865 +2091 3866 +2715 285 +2715 693 +2715 1310 +2715 1592 +2715 1792 +2715 2476 +2715 2595 +2715 2891 +2715 3335 +2715 4061 +2716 196 +2716 524 +2716 1765 +2716 2452 +2716 3058 +2716 3138 +2716 4274 +2716 4275 +2716 4276 +2716 4277 +2718 748 +2718 2127 +2718 2293 +2718 2614 +2718 3558 +2718 3913 +2718 4052 +2718 4281 +2718 4282 +2718 4283 +4407 169 +4407 1342 +4407 2001 +4407 2046 +4407 3362 +4407 5265 +4407 5266 +4407 5267 +4407 5268 +2986 3 +2986 121 +2986 128 +2986 143 +2986 147 +2986 176 +2986 177 +2986 264 +2986 422 +2986 718 +5472 866 +5472 1288 +5472 1433 +5472 3061 +5472 3796 +5472 4166 +5472 4382 +5472 4866 +5472 5211 +5472 5839 +276 272 +276 274 +276 600 +276 1583 +276 1800 +276 2247 +276 2248 +276 2249 +1972 170 +1972 252 +1972 1615 +1972 2279 +1972 3563 +1972 3749 +1972 3750 +1972 3751 +1972 3752 +1972 3753 +3594 363 +3594 1138 +3594 2498 +3594 2747 +3594 4846 +3594 4847 +3594 4848 +3594 4849 +3594 4850 +3594 4851 +4892 212 +4892 458 +4892 2272 +4892 3054 +4892 3931 +4892 4074 +4892 4563 +4892 5554 +4892 5555 +2946 1787 +2946 1939 +2946 2190 +2946 4005 +2946 4007 +2946 4354 +2946 4429 +2946 4430 +2946 4431 +2946 4432 +1882 486 +1882 1531 +1882 1862 +1882 1930 +1882 2337 +1882 3624 +1882 3625 +1882 3626 +1882 3627 +1882 3628 +4874 123 +4874 249 +4874 250 +4874 251 +4874 264 +4874 422 +4874 427 +4874 1245 +4874 2001 +4875 107 +4875 1229 +4875 2093 +4875 2350 +4875 2408 +4875 2890 +4875 3395 +4875 3542 +4875 4158 +4875 5333 +1310 9 +1310 122 +1310 123 +1310 124 +1310 128 +1310 179 +1310 367 +1310 369 +1310 427 +1310 1317 +1883 534 +1883 621 +1883 944 +1883 1060 +1883 1261 +1883 2252 +1883 2789 +1883 3188 +1883 3673 +1883 3674 +3621 4159 +5542 495 +5542 1194 +5542 1261 +5542 1587 +5542 2089 +5542 2384 +5542 2541 +5542 4782 +5542 4813 +5542 4945 +5820 1831 +5820 2472 +5820 2627 +5820 4060 +5820 5501 +5820 5657 +5820 6002 +5820 6003 +5820 6004 +5820 6005 +5821 491 +5821 858 +5821 983 +5821 1313 +5821 1458 +5821 3388 +5821 5534 +5821 5837 +5821 6006 +5821 6007 +4012 1010 +4012 1300 +4012 1571 +4012 2230 +4012 2377 +4012 2887 +4012 3185 +4012 3781 +4012 4655 +4012 4847 +1685 222 +1685 521 +1685 779 +1685 1652 +1685 1686 +1685 1687 +1685 1688 +1685 1689 +1685 1690 +1685 1691 +1216 1591 +1216 1749 +2898 932 +2898 1305 +2898 2353 +2898 2694 +2898 2770 +2898 3138 +2898 4058 +2898 4381 +2898 4382 +2898 4383 +2907 112 +2907 117 +2907 841 +2907 2154 +2907 3526 +2907 4082 +2907 4389 +2907 4390 +2907 4391 +2907 4392 +218 219 +218 220 +218 221 +218 222 +218 223 +218 224 +218 225 +218 226 +218 227 +1234 228 +1234 342 +1234 1023 +1234 2093 +1234 2612 +1234 2678 +1234 2871 +1234 3095 +1234 3096 +1234 3097 +3514 921 +3514 1160 +3514 1429 +3514 1898 +3514 2479 +3514 2555 +3514 3574 +3514 4600 +3514 4791 +3514 4792 +3515 3 +3515 4 +3515 127 +3515 147 +3515 176 +3515 264 +3515 427 +3515 666 +3515 667 +4179 3 +4179 123 +4179 127 +4179 144 +4179 145 +4179 238 +4179 251 +4179 352 +4179 369 +4179 2338 +1585 281 +1585 562 +1585 1586 +1585 1587 +1585 1588 +1585 1589 +1585 1590 +1585 1591 +1585 1592 +1585 1593 +5924 276 +5924 619 +5924 1568 +5924 1983 +5924 2276 +5924 3173 +5924 3891 +5924 4052 +5924 5911 +5924 6071 +5925 125 +5925 229 +5925 3257 +5925 3852 +5925 4882 +5925 4894 +5925 5086 +5925 5128 +5925 5229 +5925 6070 +907 64 +907 1292 +907 1397 +907 2099 +907 2778 +907 2804 +907 2805 +907 2806 +907 2807 +907 2808 +910 518 +910 869 +910 2322 +910 2797 +910 2798 +910 2799 +910 2800 +910 2801 +910 2802 +910 2803 +3605 731 +533 1482 +533 1512 +533 1607 +533 2498 +533 2499 +533 2500 +533 2501 +533 2502 +533 2503 +533 2504 +1958 58 +1958 172 +1958 582 +1958 583 +1958 1250 +1958 1541 +1958 2394 +1958 2758 +1958 3159 +1958 3726 +2589 4185 +2590 57 +2590 1376 +2590 2248 +2590 4186 +2591 1162 +2591 2463 +2591 3677 +2591 4082 +2591 4083 +2591 4133 +2591 4187 +2591 4188 +2591 4189 +2702 351 +2702 2419 +2702 2566 +2702 3007 +2702 3797 +2702 3953 +2702 4266 +2702 4267 +2702 4268 +2702 4269 +2704 837 +1735 103 +1735 298 +1735 982 +1735 1332 +1735 1736 +1735 1737 +1735 1738 +1735 1739 +1735 1740 +1735 1741 +1862 748 +1862 1377 +1862 3799 +1862 3800 +1862 3801 +1862 3802 +1862 3803 +1862 3804 +1862 3805 +1862 3806 +3009 17 +3009 144 +3009 175 +3009 1245 +3009 1317 +3009 1667 +3009 2018 +3009 2627 +3009 4457 +5429 651 +5429 1534 +5429 1720 +5429 2690 +5429 4306 +5429 4439 +5429 4961 +5429 5040 +5429 5827 +5429 5828 +4741 1658 +4741 1974 +4741 2358 +4741 3127 +4741 3224 +4741 3860 +4741 4303 +4741 4306 +4741 5459 +4741 5460 +5720 5890 +4541 495 +4541 1213 +4541 1214 +4541 1577 +4541 2661 +4541 3721 +4541 4038 +4541 4158 +4541 4735 +4541 5344 +5887 1240 +5887 2690 +5887 3946 +5887 6042 +5887 6043 +5887 6044 +5887 6045 +5887 6046 +5887 6047 +5887 6048 +5932 552 +4306 4 +4306 143 +4306 175 +4306 249 +4306 251 +4306 264 +4306 369 +4306 422 +4306 856 +4932 1943 +4932 2276 +4932 2723 +4932 3786 +4932 4623 +4932 5572 +4932 5573 +4932 5574 +4932 5575 +4932 5576 +848 448 +1057 164 +1057 1058 +1057 1059 +1057 1060 +1057 1061 +1057 1062 +1057 1063 +1057 1064 +1057 1065 +1057 1066 +1253 13 +1253 750 +1253 2359 +1253 3119 +1254 813 +1254 1890 +1254 2207 +1254 2997 +1254 3007 +1256 3114 +2926 664 +2927 868 +2927 963 +2927 1749 +2927 2298 +2927 3717 +2927 4265 +2927 5777 +2927 5778 +2927 5779 +2927 5780 +2930 2158 +1792 1001 +1792 1203 +1792 2377 +1792 3000 +1792 3104 +1792 3536 +1792 3537 +1792 3538 +1792 3539 +1792 3540 +5177 1438 +5177 3109 +5177 4930 +5177 5681 +5177 5682 +5177 5683 +5177 5684 +5177 5685 +5177 5686 +5177 5687 +5089 3981 +5892 6049 +5893 8 +5893 124 +5893 238 +5893 248 +5893 249 +5893 251 +5893 352 +5893 422 +5893 423 +5893 667 +4532 4 +4532 127 +4532 143 +4532 248 +4532 266 +4532 390 +4532 422 +4532 423 +4532 667 +5326 701 +5326 703 +5326 1430 +5326 2149 +5326 3017 +5326 3027 +5326 4297 +5326 5268 +5326 5339 +5326 5352 +631 15 +631 632 +631 633 +631 634 +631 635 +68 152 +68 219 +68 346 +68 965 +68 1953 +68 1954 +68 1955 +68 1956 +68 1957 +68 1958 +2862 455 +2862 633 +2862 1931 +2862 2407 +2862 3594 +2862 4280 +2862 4337 +2862 4338 +2862 4339 +2862 4340 +3470 583 +3470 1947 +3470 2360 +3470 2528 +3470 2636 +3470 4155 +3470 4775 +3470 4776 +3470 4777 +5385 309 +5385 1120 +5385 1511 +5385 2007 +5385 2090 +5385 5074 +5385 5636 +5385 5729 +5385 5801 +5385 5802 +1506 1090 +1506 1507 +1506 1508 +1506 1509 +1506 1510 +1506 1511 +1506 1512 +1506 1513 +1506 1514 +1506 1515 +3886 451 +3886 478 +3886 677 +3886 1020 +3886 1230 +3886 2215 +3886 3275 +3886 4126 +3886 4977 +3886 4978 +3887 690 +3887 744 +3887 1300 +3887 1730 +3887 3053 +3887 4373 +3887 4984 +3887 4985 +3887 4986 +3887 4987 +2153 1219 +2153 2847 +2153 3804 +2153 3856 +2153 3908 +2153 3909 +2153 3910 +2153 3911 +2153 3912 +2153 3913 +2158 262 +2158 1021 +2158 1115 +2158 2002 +2158 3433 +2158 3467 +2158 3896 +2158 3897 +2158 3898 +2158 3899 +389 693 +389 882 +389 951 +389 1383 +389 1538 +389 1792 +389 2271 +389 2357 +389 2358 +389 2359 +2217 5 +2217 9 +2217 149 +2217 177 +2217 238 +2217 247 +2217 249 +2217 369 +2217 424 +2217 1317 +4478 1052 +4478 1146 +4478 1961 +4478 3418 +4478 4009 +4478 4364 +4478 5313 +4478 5314 +4478 5315 +4478 5316 +4536 56 +4536 158 +4536 1199 +4536 1341 +4536 2304 +4536 4096 +4536 5081 +4536 5340 +4536 5341 +3480 341 +3480 343 +3480 347 +3480 2306 +3480 2307 +3480 2337 +3480 3343 +3480 4170 +3480 4628 +3480 4663 +3077 3 +3077 127 +3077 147 +3077 264 +3077 352 +3077 368 +3077 390 +3077 423 +3077 427 +3077 1245 +3317 4678 +3321 1913 +3321 1926 +3321 2433 +3321 4014 +3321 4675 +4948 5583 +4949 31 +4949 127 +4949 143 +4949 368 +4949 422 +4949 427 +4949 558 +4949 856 +4949 2001 +3496 566 +3496 645 +3496 674 +3496 884 +3496 1926 +3496 2302 +3496 2857 +3496 3768 +3496 4655 +1356 48 +1356 270 +1356 281 +1356 472 +1356 1357 +1356 1358 +1356 1359 +1356 1360 +1356 1361 +4158 584 +4158 770 +4158 2229 +4158 3982 +4158 4739 +4158 4783 +4158 5099 +4158 5100 +4158 5101 +4158 5102 +2364 1999 +2364 4050 +2364 4051 +2364 4052 +61 907 +61 1922 +61 1992 +61 1993 +61 1994 +61 1995 +61 1996 +61 1997 +61 1998 +61 1999 +65 86 +65 1954 +65 2002 +65 2003 +65 2004 +65 2005 +65 2006 +65 2007 +65 2008 +65 2009 +4282 125 +4282 824 +4282 1088 +4282 2220 +4282 3138 +4282 3468 +4282 4339 +4282 4414 +4282 4502 +4282 5182 +4633 199 +4633 474 +4633 476 +4633 637 +4633 2269 +4633 3105 +4633 3227 +4633 4646 +4633 5397 +4633 5398 +5332 121 +5332 129 +5332 352 +5332 424 +5332 5731 +413 2393 +2897 262 +2897 396 +2897 1397 +2897 4307 +2897 4366 +2897 4377 +2897 4378 +2897 4379 +2897 4380 +4174 8 +4174 122 +4174 143 +4174 146 +4174 174 +4174 196 +4174 352 +4174 353 +4174 369 +4174 424 +5306 129 +5306 1509 +5306 1912 +5306 3566 +5306 5156 +5306 5369 +5306 5747 +5306 5767 +5306 5768 +5580 2881 +1818 18 +1818 270 +1818 725 +1818 1157 +1818 1575 +1818 3174 +1818 3413 +1818 3554 +1818 3555 +1818 3556 +1819 996 +1819 1492 +1819 2486 +1819 2869 +1819 3327 +1819 3563 +1819 3564 +1819 3565 +1819 3566 +1819 3567 +1820 894 +1820 1022 +1820 1139 +1820 2358 +1820 3557 +1820 3558 +1820 3559 +1820 3560 +1820 3561 +1820 3562 +1002 20 +1002 95 +1002 341 +1002 478 +1002 798 +1002 892 +1002 1408 +1002 1439 +1002 1440 +1002 1441 +1477 3 +1477 4 +1477 17 +1477 122 +1477 176 +1477 264 +1477 422 +1477 666 +1477 856 +747 2051 +747 2427 +747 2648 +747 2667 +747 2668 +747 2669 +747 2670 +747 2671 +747 2672 +747 2673 +371 4 +371 7 +371 9 +371 148 +371 251 +371 264 +371 265 +371 367 +371 422 +371 1245 +372 231 +372 295 +372 1928 +372 2177 +372 2315 +372 2316 +372 2317 +372 2318 +372 2319 +372 2320 +378 121 +378 122 +378 123 +378 127 +378 143 +378 251 +378 390 +378 667 +378 717 +378 1245 +379 2373 +4636 5 +4636 9 +4636 148 +4636 179 +4636 390 +4636 422 +4636 558 +4636 697 +4636 754 +4636 856 +5195 521 +5195 1070 +5195 3782 +5195 3962 +5195 3977 +5195 4031 +5195 5434 +5195 5604 +5195 5700 +5195 5701 +5196 107 +5196 326 +5196 1928 +5196 2313 +5196 3598 +5196 4082 +5196 4423 +5196 5695 +5196 5696 +5196 5697 +5197 48 +5197 968 +5197 1814 +5197 2055 +5197 2164 +5197 3112 +5197 5441 +5197 5475 +5197 5698 +5197 5699 +3716 977 +3716 3119 +3716 3301 +3716 3376 +3716 3890 +3716 4655 +3716 4900 +3716 4901 +3716 4902 +3716 4903 +4783 51 +4783 651 +4783 1563 +4783 2186 +4783 2377 +4783 2452 +4783 2579 +4783 3418 +4783 3917 +4783 4293 +5211 115 +5211 279 +5211 1597 +5211 2547 +5211 2594 +5211 3021 +5211 3912 +5211 4894 +5211 5121 +5211 5703 +5386 5 +5386 125 +5386 129 +5386 174 +5386 238 +5386 248 +5386 250 +5386 252 +5386 1084 +5389 2634 +435 127 +1380 41 +1380 385 +1380 1437 +1380 1899 +1380 2054 +1380 2272 +1380 3076 +1380 3156 +1380 3235 +1380 3236 +2864 352 +2804 470 +2804 604 +2804 1325 +2804 1451 +2804 2422 +2804 2733 +2804 2768 +2804 3276 +2804 3772 +2804 4311 +5987 529 +5987 981 +5987 2776 +5987 3140 +5987 4225 +5987 6100 +5987 6101 +5987 6102 +5987 6103 +5987 6104 +5988 5 +5988 9 +5988 126 +5988 175 +5988 180 +5988 252 +5988 266 +5988 368 +5988 3677 +5990 547 +5990 996 +5990 1451 +5990 1888 +5990 3039 +5990 5628 +5990 5913 +5990 6109 +5990 6110 +5990 6111 +3338 133 +3338 1808 +3338 2971 +3338 3808 +3338 4281 +3338 4356 +3338 4412 +3338 4682 +830 4 +830 31 +830 148 +830 179 +830 180 +830 368 +830 666 +830 736 +830 886 +830 2018 +1811 117 +1811 522 +1811 711 +1811 1636 +1811 1650 +1811 2792 +1811 3542 +1811 3543 +1811 3544 +1811 3545 +6094 1006 +6094 1323 +6094 1333 +6094 2026 +6094 4254 +6094 4297 +6094 6095 +6094 6174 +6094 6175 +6094 6176 +6095 380 +6095 2295 +6095 3021 +6095 3675 +6095 3804 +6095 4363 +6095 5449 +6095 5603 +6095 6177 +6095 6178 +2260 38 +2260 1688 +2260 2191 +2260 2941 +2260 3804 +2260 4501 +2260 4894 +2260 5909 +2260 6108 +2260 6181 +4592 5380 +6099 106 +6099 1637 +6099 1915 +6099 2015 +6099 4893 +6099 5714 +6099 5901 +6099 6166 +6099 6179 +6099 6180 +4242 407 +4242 651 +4242 1194 +4242 1369 +4242 1575 +4242 3250 +4242 3491 +4242 4072 +4242 4603 +4242 5161 +6282 3992 +6282 6291 +5452 8 +5452 122 +5452 126 +5452 145 +5452 149 +5452 174 +5452 179 +5452 424 +5452 427 +5452 1317 +6039 202 +6039 503 +6039 810 +6039 814 +6039 1915 +6039 2149 +6039 2719 +6039 2755 +6039 2978 +6039 3275 +6039 3293 +6039 3325 +6039 3488 +6039 5049 +6039 5395 +6039 5554 +6039 5816 +6039 5888 +6039 5952 +6039 5966 +6039 6022 +6039 6157 +6039 6158 +6039 6159 +6039 6160 +6039 6161 +6039 6162 +6039 6163 +6039 6164 +6039 6165 +6039 6166 +6279 115 +6279 1845 +6279 5529 +6279 5970 +6279 6011 +6279 6284 +6279 6285 +6279 6286 +6279 6287 +6279 6288 +3564 854 +3564 1123 +3564 1573 +3564 3409 +3564 4158 +3564 4339 +3564 4718 +3564 4823 +4227 123 +4227 127 +4227 176 +4227 238 +4227 367 +4227 422 +4227 427 +4227 667 +4227 717 +4227 2338 +5508 547 +5508 1301 +5508 2376 +5508 3813 +5508 4067 +5508 4382 +5508 5856 +5508 5857 +5037 2765 +5037 5611 +4771 804 +4771 1090 +4771 1426 +4771 3951 +4771 4422 +1379 602 +1379 1274 +1379 1380 +1379 1381 +1379 1382 +1379 1383 +1379 1384 +1379 1385 +1379 1386 +1379 1387 +5615 1082 +5615 1923 +5615 2005 +5615 2207 +5615 2726 +5615 3125 +5615 3376 +5615 4854 +5615 5900 +5615 5901 +2826 249 +2826 1400 +2826 2287 +2826 2541 +2826 2558 +2826 2923 +2826 4336 +2826 5277 +2826 5516 +2826 5517 +4102 50 +4102 2557 +5104 23 +5104 689 +5104 910 +5104 967 +5104 1424 +5104 2552 +5104 2787 +5104 3487 +5104 4400 +5104 5277 +5058 85 +5058 153 +5058 919 +5058 1956 +5058 2112 +5058 2410 +5058 2414 +5058 4735 +5058 5196 +5058 5452 +5296 1001 +5296 1948 +5296 4735 +5296 4788 +5296 5073 +5296 5398 +5296 5504 +5296 5763 +5296 5764 +5296 5765 +5750 487 +5750 491 +5750 811 +5750 862 +5750 1509 +5750 1757 +5750 2127 +5750 4287 +5750 5962 +5750 5963 +5751 5168 +5753 244 +5753 835 +5753 1321 +5753 1890 +5753 3446 +5753 4639 +5753 4881 +5753 5368 +5753 5966 +5753 5967 +5754 870 +5754 1048 +5754 2537 +5754 3563 +5754 3993 +5754 4622 +5754 5729 +5754 5920 +5754 5964 +5754 5965 +5755 3509 +1352 124 +1352 126 +1352 145 +1352 174 +1352 179 +1352 423 +1352 667 +1352 1353 +1352 1354 +1352 1355 +4303 31 +4303 121 +4303 124 +4303 148 +4303 177 +4303 180 +4303 352 +4303 427 +4303 736 +4303 2001 +2199 322 +2199 412 +2199 527 +2199 2940 +2199 3593 +2199 3697 +2199 3919 +2199 3920 +2199 3921 +2199 3922 +4533 103 +4533 112 +4533 1382 +4533 1541 +4533 1741 +4533 2201 +4533 2312 +4533 2758 +4533 5338 +4533 5339 +5220 1168 +5220 1480 +5220 2823 +5220 4137 +5220 4740 +5220 4929 +5220 5715 +5220 5716 +5220 5717 +5220 5718 +4921 219 +4921 1798 +4921 2129 +4921 2235 +4921 4468 +981 8 +981 448 +981 731 +981 822 +981 1143 +981 1974 +981 2883 +981 2884 +981 2885 +981 2886 +3210 691 +3210 2055 +3210 2691 +3210 2935 +3210 3221 +3210 4594 +3210 4595 +3210 4596 +3210 4597 +3210 4598 +43 1604 +43 1679 +43 1903 +43 1930 +43 1931 +43 1932 +43 1933 +43 1934 +43 1935 +43 1936 +4264 1157 +5724 3 +5724 7 +5724 122 +5724 123 +5724 124 +5724 125 +5724 145 +5724 177 +5724 352 +5724 427 +2778 3497 +3003 219 +3003 1087 +3003 1761 +3003 1930 +3003 2645 +3003 2787 +3003 2871 +3003 3207 +3003 4082 +3003 4445 +2611 1956 +87 88 +87 89 +87 90 +87 91 +87 92 +87 93 +87 94 +87 95 +87 96 +87 97 +1040 1023 +1040 1055 +1040 2254 +1040 2962 +1040 2963 +1040 2964 +1040 2965 +1040 2966 +1040 2967 +1659 143 +1659 522 +1659 1791 +1659 2285 +1659 2349 +1659 2862 +1659 3121 +1659 3175 +1659 3300 +1659 3412 +1939 840 +385 23 +385 314 +385 1741 +385 2162 +385 2339 +385 2340 +385 2341 +385 2342 +385 2343 +385 2344 +1275 1276 +1275 1277 +1275 1278 +1275 1279 +1275 1280 +1275 1281 +1275 1282 +1275 1283 +1275 1284 +1275 1285 +3311 493 +3311 498 +3311 560 +3311 767 +3311 2293 +3468 740 +3468 997 +3468 1565 +3468 3968 +3468 4206 +3468 4239 +3468 4355 +3468 4770 +3468 4771 +3468 4772 +3469 123 +3469 266 +3469 570 +3469 1630 +3469 2236 +3469 2752 +3469 2948 +3469 3247 +3469 4773 +3469 4774 +2938 486 +2938 494 +2938 534 +2938 924 +2938 1297 +2938 1559 +2938 1940 +2938 2650 +2938 4124 +2939 802 +2939 1866 +2939 2275 +2939 2412 +2939 2948 +2939 3636 +2939 4170 +2939 4418 +2939 4419 +2939 4420 +83 7 +83 8 +83 9 +83 148 +83 351 +83 426 +83 762 +83 946 +83 2000 +83 2001 +645 330 +645 2223 +645 2430 +645 2563 +645 2564 +3011 94 +3011 352 +3011 466 +3011 1022 +3011 2628 +3011 3587 +3011 4453 +3011 4454 +3011 4455 +3011 4456 +4755 5 +4755 7 +4755 121 +4755 125 +4755 127 +4755 148 +4755 174 +4755 177 +4755 251 +4755 427 +4758 365 +4758 1321 +4758 1808 +4758 2304 +4758 3092 +4758 4031 +4758 4063 +4758 5451 +4758 5468 +3191 101 +3191 1171 +3191 1235 +3191 2335 +3191 2575 +3191 3134 +3191 3140 +3191 3339 +3191 4580 +3191 4581 +3412 112 +3412 1636 +3412 2430 +3412 3760 +3412 4002 +3412 4402 +3412 4746 +3412 4747 +3412 4748 +3412 4749 +3904 312 +3904 1656 +3904 2175 +3904 3489 +3904 4091 +3904 4718 +3904 4998 +3904 4999 +3904 5000 +3904 5001 +4856 508 +4856 5393 +4856 5531 +4856 5532 +4857 114 +4857 387 +4857 473 +4857 531 +4857 588 +4857 1821 +4857 3511 +4857 4215 +4857 5530 +5183 363 +5183 1706 +5183 1711 +5183 2055 +5183 2481 +5183 4436 +5183 4559 +5183 5094 +5183 5494 +5183 5688 +5187 302 +5187 1184 +5187 1946 +5187 3023 +5187 3414 +5187 3988 +5187 5065 +5187 5184 +5187 5689 +5187 5690 +5190 1056 +5191 2693 +5191 4129 +5191 4809 +5191 5051 +5191 5508 +5191 5691 +5191 5692 +5191 5693 +5191 5694 +4572 5376 +4574 392 +4574 617 +4574 1616 +4574 1937 +4574 1987 +4574 3446 +4574 4960 +4574 5362 +4574 5363 +4574 5364 +728 45 +728 89 +728 298 +728 729 +728 730 +728 731 +728 732 +728 733 +728 734 +728 735 +5952 714 +5952 1627 +5952 2047 +5952 2475 +5952 3232 +5952 4012 +5952 5287 +5952 5508 +5952 5815 +5952 6080 +509 14 +509 193 +509 363 +509 503 +509 828 +509 840 +509 2447 +509 2488 +509 2489 +509 2490 +1632 1481 +5578 1511 +5578 1762 +5578 2090 +5578 5580 +5578 5883 +3478 1539 +2391 478 +2391 986 +2391 1370 +2391 3457 +2391 3487 +2391 4075 +2391 4076 +2391 4077 +2391 4078 +2391 4079 +5024 114 +4103 9 +4103 17 +4103 175 +4103 252 +4103 390 +4103 422 +4103 559 +4103 856 +4103 1245 +4103 1770 +5028 156 +5028 1037 +5028 1129 +5028 1203 +5028 2752 +5028 3064 +5028 3797 +5028 5353 +5028 5605 +3519 648 +3519 895 +3519 1227 +3519 4872 +3519 4883 +3549 190 +3549 227 +3549 260 +3549 412 +3549 637 +3549 979 +3549 1689 +3549 1702 +3549 2984 +3549 3136 +3757 123 +3757 127 +3757 147 +3757 249 +3757 251 +3757 368 +3757 423 +3757 718 +3757 1245 +1290 176 +1290 177 +1290 179 +1290 248 +1290 249 +1290 352 +1290 422 +1290 427 +1290 717 +1290 1317 +5052 198 +5052 356 +5052 558 +5052 2234 +5052 2285 +5052 2354 +5052 3035 +5052 3133 +5052 4892 +5052 5618 +5065 21 +5065 503 +5065 997 +5065 3296 +5065 3931 +5065 4324 +5065 4801 +5065 4826 +5065 5621 +5065 5622 +2116 510 +2116 1018 +2116 1633 +2116 2069 +2116 2130 +2116 3724 +2116 3875 +2116 3876 +2116 3877 +2116 3878 +2444 478 +2444 2288 +2444 2420 +2444 2657 +2444 2690 +2444 3698 +2444 3700 +2444 4102 +2444 4103 +2444 4104 +2797 5 +2797 17 +2797 125 +2797 126 +2797 143 +2797 149 +2797 175 +2797 754 +2797 856 +3045 42 +3045 125 +3045 219 +3045 550 +3045 614 +3045 2004 +3045 2499 +3045 3104 +3045 4475 +3045 4476 +1091 95 +1091 309 +1091 434 +1091 909 +1091 1092 +1091 1093 +1091 1094 +1091 1095 +1091 1096 +1091 1097 +415 156 +415 427 +415 676 +415 799 +415 803 +415 1018 +415 1019 +415 1020 +415 1021 +4433 8 +4433 1345 +4433 1890 +4433 3362 +4433 3677 +3359 997 +5971 6091 +1362 1026 +1362 1061 +1362 1348 +1362 1363 +1362 1364 +1362 1365 +1362 1366 +1362 1367 +1362 1368 +1362 1369 +3948 124 +3948 127 +3948 143 +3948 247 +3948 251 +3948 264 +3948 367 +3948 390 +3948 718 +3948 1245 +3284 452 +3284 453 +3284 1688 +3284 2354 +3284 2653 +3284 3408 +3284 4288 +3284 4654 +3284 4655 +3284 4656 +3285 17 +3285 1768 +3285 1827 +3285 1972 +3285 2244 +3285 3047 +3285 5638 +3285 6036 +3285 6037 +3285 6038 +3202 267 +3202 1466 +3202 2869 +3202 3488 +3202 3708 +3202 3796 +3202 3818 +3202 4165 +3202 4322 +3202 4590 +489 224 +489 490 +489 491 +489 492 +489 493 +489 494 +489 495 +489 496 +489 497 +489 498 +2065 585 +3831 33 +3831 1729 +3831 2357 +3831 3258 +3831 3259 +3831 4072 +3831 4363 +3831 4655 +3831 4946 +3831 4947 +3160 2734 +3160 3138 +3160 4510 +3160 4556 +3160 4557 +3160 4558 +3160 4559 +3160 4560 +3160 4561 +3160 4562 +1590 710 +1590 894 +1590 1179 +1590 1688 +1590 1886 +1590 2643 +1590 3104 +1590 3369 +1590 3370 +3744 3149 +3747 496 +3747 621 +3747 678 +3747 2875 +3747 2973 +3747 3993 +3747 4641 +3747 4877 +3747 4917 +3900 158 +3900 1243 +3900 1331 +3900 2024 +3900 3416 +3900 4752 +3900 4916 +3900 4988 +3900 4989 +3900 4990 +4114 124 +4114 127 +4114 251 +4114 264 +4114 390 +4114 427 +4114 559 +4114 667 +4114 1245 +4114 2018 +5619 261 +5619 391 +5619 898 +5619 1212 +5619 1866 +5619 1867 +5619 2149 +5619 2973 +5619 3982 +5619 4237 +1041 69 +1041 529 +1041 621 +1041 789 +1041 1042 +1041 1043 +1041 1044 +1041 1045 +1041 1046 +1041 1047 +4638 159 +4638 828 +4638 1604 +4638 2886 +4638 5357 +4638 5399 +4638 5400 +4638 5401 +4638 5402 +4803 495 +4803 2497 +4803 3088 +4803 3422 +4803 4036 +4803 4187 +4803 4882 +4803 5043 +4803 5507 +4803 5508 +382 996 +382 1969 +382 2345 +382 2346 +382 2347 +382 2348 +382 2349 +382 2350 +382 2351 +382 2352 +1549 130 +1549 1009 +1549 1629 +1549 2230 +1549 2587 +1549 2673 +1549 3341 +1550 126 +1550 145 +1550 149 +1550 183 +1550 246 +1550 390 +1550 423 +1550 667 +1550 718 +1550 856 +5626 584 +5626 1203 +5626 1509 +5626 3253 +5626 4037 +5626 4632 +5626 5837 +5626 5909 +5626 5910 +5626 5911 +1714 824 +1714 1034 +1714 1037 +1714 1715 +1714 1716 +1714 1717 +1714 1718 +1714 1719 +1714 1720 +1714 1721 +4176 2205 +4176 2222 +4176 3318 +4176 3418 +4176 3563 +4176 4006 +4176 5494 +4176 5814 +4176 5815 +1010 1191 +1010 1517 +1010 2411 +1010 2538 +1010 2920 +1010 2921 +1010 2922 +1010 2923 +1010 2924 +1010 2925 +3859 133 +3859 391 +3859 855 +3859 2676 +3859 3618 +3859 4285 +3859 4297 +3859 4960 +3859 4961 +3859 4962 +2252 3 +2252 7 +2252 8 +2252 123 +2252 128 +2252 148 +2252 176 +2252 179 +2252 424 +2252 717 +2014 21 +2014 2304 +2014 3038 +2014 3052 +2014 3377 +2014 3574 +2014 3790 +2014 3791 +2014 3792 +2014 3793 +228 176 +228 182 +228 229 +228 230 +228 231 +228 232 +228 233 +228 234 +228 235 +607 608 +607 609 +607 610 +607 611 +607 612 +607 613 +607 614 +607 615 +607 616 +4424 110 +4424 498 +4424 1804 +4424 2708 +4424 4885 +4424 5279 +4424 5280 +4424 5281 +4424 5282 +4424 5283 +4423 8 +4423 77 +4423 282 +4423 1143 +4423 1571 +4423 1765 +4423 2961 +4423 3138 +4423 4801 +4423 5282 +2958 458 +2958 669 +2958 852 +2958 1115 +2958 1786 +2958 1798 +2958 2255 +2958 2571 +2958 4136 +2773 557 +2773 583 +2773 810 +2773 832 +2773 1728 +2773 1866 +2773 2974 +2773 4304 +2773 4305 +4585 158 +4585 229 +4585 1591 +4585 2893 +4585 3316 +4585 3906 +4585 4098 +4585 4784 +4585 4839 +4585 5366 +5110 38 +5110 2018 +5110 2148 +5110 2666 +5110 3895 +5110 3935 +5110 4838 +5110 4855 +5110 5642 +5110 5643 +5113 893 +5113 1407 +5113 1590 +5113 1772 +5113 1862 +5113 2269 +5113 3716 +5113 4432 +5113 5291 +5113 5641 +5040 1010 +5040 2304 +5040 2392 +5040 2443 +5040 2853 +5040 3081 +5040 4507 +5040 5437 +5040 5612 +5040 5613 +2676 63 +4734 43 +5272 203 +5272 852 +5272 1614 +5272 1797 +5272 2652 +5272 2706 +5272 5735 +5272 5736 +5272 5737 +1319 121 +1319 147 +1319 248 +1319 252 +1319 264 +1319 390 +1319 423 +1319 559 +1319 667 +1319 1245 +720 4 +720 5 +720 8 +720 126 +720 145 +720 149 +720 353 +720 424 +720 2001 +720 2018 +5213 253 +5213 2330 +5213 2552 +5213 3883 +5213 5501 +5213 5705 +5213 5706 +5213 5707 +2699 3 +2699 122 +2699 127 +2699 143 +2699 146 +2699 177 +2699 238 +2699 249 +2699 352 +2699 856 +4778 712 +4778 1034 +4778 1345 +4778 1743 +4778 1807 +4778 2391 +4778 3110 +4778 4003 +4778 5485 +4778 5486 +3866 1549 +3866 2305 +3866 2310 +3866 2493 +3866 2806 +3866 3355 +3866 3960 +3866 4302 +3866 4968 +3866 4969 +1572 1127 +1572 1273 +1572 1550 +1572 1961 +1572 2400 +1572 2465 +1572 3356 +1572 3357 +1572 3358 +1572 3359 +1924 524 +1924 2451 +1924 2908 +1924 3051 +1924 3219 +1924 3867 +952 749 +952 796 +952 953 +952 954 +952 955 +952 956 +952 957 +952 958 +952 959 +952 960 +1519 561 +1519 725 +1519 756 +1519 982 +1519 1061 +1519 1120 +1519 1422 +1519 3348 +1519 3349 +1519 3350 +4337 165 +4337 1787 +4337 2539 +4337 4895 +4337 5222 +5587 5300 +1370 825 +1370 1371 +1370 1372 +1370 1373 +1370 1374 +1370 1375 +1370 1376 +1370 1377 +1370 1378 +244 338 +244 612 +244 1264 +244 1284 +244 2197 +244 2198 +244 2199 +244 2200 +244 2201 +244 2202 +3912 889 +3912 1367 +3912 3266 +3912 3856 +3912 4735 +3912 4894 +3912 4991 +3912 4992 +3912 4993 +3912 4994 +4336 4491 +2164 57 +2164 453 +2164 851 +2164 1049 +2164 2423 +2164 2648 +2164 2669 +2164 2906 +2164 3468 +2164 3906 +737 898 +737 1539 +737 2516 +737 2659 +737 2660 +737 2661 +737 2662 +737 2663 +741 31 +741 538 +741 1575 +741 2272 +741 2538 +741 2719 +741 2720 +741 2721 +741 2722 +741 2723 +742 1476 +742 1975 +742 2412 +742 2453 +742 2678 +742 2679 +742 2680 +742 2681 +742 2682 +742 2683 +1366 1152 +1366 2093 +1366 2215 +1366 2561 +1366 2789 +1366 3214 +1366 3215 +1366 3216 +1366 3217 +2293 118 +2293 717 +2293 771 +2293 1364 +2293 1365 +2293 1366 +2293 1946 +2293 2581 +2293 3985 +2293 3986 +709 200 +709 205 +709 541 +709 552 +709 710 +709 711 +709 712 +709 713 +709 714 +709 715 +845 127 +845 144 +845 145 +845 176 +845 177 +845 247 +845 265 +845 630 +845 698 +845 762 +4449 162 +4449 199 +4449 290 +4449 757 +4449 2151 +4449 5292 +4449 5293 +4449 5294 +4449 5295 +4449 5296 +4452 228 +4452 554 +4452 789 +4452 1957 +4452 2153 +4452 2612 +4452 3083 +4452 3539 +4452 3919 +4452 5297 +4937 1412 +4937 2162 +4937 2500 +4937 4012 +4937 4589 +4937 4811 +4937 4825 +4937 4889 +4937 5349 +4937 5578 +2388 261 +2388 937 +2388 1229 +2388 2225 +2388 2595 +2388 2948 +2388 3205 +2388 4072 +2388 4073 +2388 4074 +138 23 +138 446 +138 842 +138 1096 +138 1598 +138 1752 +138 2089 +138 2090 +138 2091 +1765 839 +1765 2420 +1765 2477 +1765 3086 +1765 3185 +1765 3193 +1765 3197 +1765 3301 +1765 3527 +958 180 +958 558 +958 584 +958 1249 +958 1540 +958 3491 +958 4123 +958 4892 +958 4973 +958 4974 +3930 1228 +3930 1777 +3930 1928 +3930 2933 +3930 3331 +3930 4461 +3930 5004 +3930 5005 +3930 5006 +3930 5007 +4360 381 +4360 1239 +4360 2568 +4360 3212 +4360 3566 +4360 4828 +4360 5232 +4360 5233 +4360 5234 +4362 437 +4362 906 +4362 2779 +4362 3687 +4362 3886 +4362 4286 +4362 5242 +4362 5243 +4362 5244 +4362 5245 +5066 164 +5066 523 +5066 815 +5066 2155 +5066 2237 +5066 2548 +5066 3407 +5066 4319 +5066 5159 +5066 5620 +5067 804 +5067 940 +5067 1710 +5067 2844 +5067 3407 +5067 4364 +5067 5434 +5067 5631 +5067 5632 +5067 5633 +5069 5623 +4263 11 +4263 20 +4263 1389 +4263 2628 +4263 2668 +4263 3080 +4263 3177 +4263 3945 +4263 4876 +4263 4980 +5600 4943 +2796 3 +2796 5 +2796 7 +2796 8 +2796 125 +2796 126 +2796 149 +2796 247 +2796 249 +2796 424 +4256 2613 +5644 643 +5644 877 +5644 1316 +5644 1335 +5644 1928 +5644 3027 +5644 4101 +5644 5916 +5644 5917 +2890 56 +2890 442 +2890 1279 +2890 2220 +2890 3156 +2890 3794 +2890 4368 +2890 4397 +2890 4398 +3890 3 +3890 123 +3890 129 +3890 251 +3890 264 +3890 367 +3890 426 +3890 427 +3890 718 +3890 2717 +28 846 +28 1516 +28 1517 +2290 10 +2290 121 +2290 128 +2290 145 +2290 266 +2290 352 +2290 422 +2290 559 +2290 666 +2290 1317 +766 17 +766 262 +766 1332 +766 1689 +766 1956 +766 2330 +766 2569 +766 2697 +766 2698 +766 2699 +767 1618 +767 1863 +767 2550 +767 2690 +767 2691 +767 2692 +767 2693 +767 2694 +767 2695 +767 2696 +773 2907 +1806 124 +1806 251 +1806 368 +1806 369 +1806 422 +1806 718 +1806 754 +1806 856 +1806 2018 +1806 3216 +1813 146 +1813 176 +1813 246 +1813 252 +1813 264 +1813 368 +1813 369 +1813 390 +1813 667 +1813 718 +2020 5 +2020 126 +2020 144 +2020 145 +2020 149 +2020 176 +2020 247 +2020 249 +2020 251 +2020 352 +4421 124 +4421 381 +4421 477 +4421 1655 +4421 2055 +4421 2169 +4421 2254 +4421 4129 +4421 5266 +4421 5272 +5406 38 +5406 740 +5406 1956 +5406 2060 +5406 2391 +5406 4170 +5406 5096 +5406 5510 +5406 5803 +5406 5804 +4784 122 +4784 123 +4784 124 +4784 127 +4784 129 +4784 248 +4784 845 +4784 2381 +4784 3305 +4784 5492 +3305 115 +3305 911 +3305 2189 +3305 2955 +3305 3189 +3305 3486 +3305 3524 +3305 3537 +3305 4469 +3305 4662 +3503 176 +3503 937 +3503 1275 +3503 1387 +3503 2829 +3503 3596 +3503 4097 +3503 4445 +3503 4606 +3503 4788 +6171 311 +6171 809 +6171 1022 +6171 1694 +6171 3403 +6171 3677 +6171 4014 +6171 4518 +6171 5988 +6171 6236 +4815 463 +4815 1676 +4815 2274 +4815 2860 +4815 2900 +4815 3149 +4815 3295 +4815 4352 +4815 5509 +1434 78 +1434 309 +1434 762 +1434 891 +1434 1019 +1434 1317 +1434 1435 +1434 1436 +1434 1437 +1434 1438 +5276 235 +5276 342 +5276 1591 +5276 3205 +5276 3428 +5276 4041 +5276 4740 +5276 5321 +5276 5747 +5276 5748 +25 1022 +3690 252 +3690 360 +3690 1224 +3690 1288 +3690 3868 +3690 4200 +3690 4884 +3690 4885 +3690 4886 +3690 4887 +475 1670 +475 1915 +475 2480 +475 2481 +475 2482 +475 2483 +475 2484 +475 2485 +475 2486 +475 2487 +4482 3 +4482 8 +4482 127 +4482 143 +4482 176 +4482 177 +4482 248 +4482 352 +4482 353 +4482 367 +1094 121 +1094 124 +1094 127 +1094 128 +1094 144 +1094 145 +1094 174 +1094 179 +1094 247 +1094 1246 +3507 738 +3507 1251 +3507 1458 +3507 1509 +3507 2077 +3507 2825 +3507 3249 +3507 4679 +3507 4789 +3507 4790 +4826 230 +4826 1192 +4826 2217 +4826 2360 +4826 3903 +4826 4112 +4826 4215 +4826 5300 +4826 5523 +4826 5524 +5045 1015 +5045 2869 +5045 3084 +5045 5056 +5045 5080 +5045 5096 +5045 5425 +5045 5614 +5045 5615 +5045 5616 +2626 4227 +4416 122 +4416 527 +4416 571 +4416 894 +4416 1027 +4416 2563 +4416 2615 +4416 4373 +4416 4719 +4416 5269 +4417 95 +4417 1197 +4417 1619 +4417 2079 +4417 2114 +4417 3253 +4417 3598 +4417 4303 +4417 4950 +4417 5175 +2530 63 +2530 933 +2530 1220 +2530 1618 +2530 2579 +2530 2626 +2530 3758 +2530 4155 +2530 4156 +2530 4157 +409 3 +409 146 +409 147 +409 175 +409 247 +409 248 +409 266 +409 368 +409 422 +409 2018 +655 1032 +655 1246 +655 1378 +655 1411 +655 1836 +655 1999 +655 2200 +655 2565 +655 2566 +655 2567 +3087 38 +3087 2571 +3087 2948 +3087 4134 +3087 4420 +3087 4510 +3087 4511 +3087 4512 +3087 4513 +3087 4514 +5281 7 +5281 174 +5281 390 +5281 699 +5281 753 +5281 754 +5281 762 +5281 2064 +5281 2077 +5281 3118 +5656 442 +5657 667 +5657 1923 +5657 2005 +5657 3083 +5657 3200 +5657 4234 +5657 4324 +5657 5016 +5657 5922 +1081 512 +1081 922 +1081 940 +1081 1720 +1081 2978 +1081 2979 +1081 2980 +1081 2981 +1081 2982 +1081 2983 +4112 7 +4112 8 +4112 145 +4112 148 +4112 174 +4112 266 +4112 424 +4112 856 +4112 2338 +5158 4402 +3571 199 +3571 293 +3571 364 +3571 659 +3571 1259 +3571 1266 +3571 2020 +3571 4831 +3571 4832 +3571 4833 +5421 2146 +1346 1730 +1346 1766 +1346 2503 +1346 2708 +1346 3177 +1346 3187 +1346 3188 +1346 3189 +1346 3190 +1346 3191 +67 472 +67 534 +67 762 +67 1123 +67 2222 +67 2789 +67 3052 +67 3332 +67 3769 +67 3956 +3152 769 +3152 1078 +3152 1409 +3152 2374 +3152 4116 +3152 4316 +3152 4442 +3152 4553 +3152 4554 +3152 4555 +3555 1039 +3555 1792 +3555 2314 +3555 4148 +3555 4350 +3555 4362 +3555 4675 +3555 4818 +3555 4819 +3555 4820 +1443 1444 +5535 2499 +5535 2670 +5535 2958 +5535 3067 +5535 3629 +5535 3674 +5535 4276 +5535 4840 +5535 5811 +5535 5835 +5078 531 +5078 605 +5078 810 +5078 813 +5078 924 +5078 1867 +5078 1868 +5078 2677 +5078 3336 +5078 5630 +1973 155 +1973 520 +1973 2020 +1973 2222 +1973 2889 +1973 3220 +1973 3595 +1973 3742 +1973 3743 +4692 532 +4692 2916 +4692 4371 +4692 4402 +4692 5425 +5273 680 +5273 1267 +5273 2268 +5273 2465 +5273 5757 +705 226 +705 352 +705 1594 +705 1600 +705 1641 +705 2625 +705 2626 +705 2627 +705 2628 +705 2629 +2329 103 +2329 1631 +2329 2114 +2329 3283 +2329 3329 +2329 3466 +2329 4027 +2329 4028 +2329 4029 +1401 510 +1401 677 +1401 736 +1401 2546 +1401 3169 +1401 3254 +1401 3255 +1401 3256 +1401 3257 +5267 3 +5267 9 +5267 122 +5267 125 +5267 126 +5267 145 +5267 149 +5267 174 +5267 247 +5267 1317 +5937 817 +5937 1652 +5937 3083 +5937 4075 +5937 5614 +5939 325 +5939 1007 +5939 1952 +5939 2477 +5939 3124 +5939 3416 +5939 3543 +5939 4877 +5939 5896 +5939 6072 +3315 1362 +3315 2087 +3315 2425 +3315 2999 +3315 3156 +3315 3849 +3315 4375 +3315 4559 +3315 4671 +3315 4672 +4852 554 +4852 763 +4852 1400 +4852 1881 +4852 4447 +4852 4645 +4852 5110 +4852 5527 +4852 5528 +4852 5529 +2803 633 +2803 942 +2803 2095 +2803 2307 +2803 2327 +2803 2870 +2803 2927 +2803 3204 +2803 3808 +2803 4310 +1872 356 +1872 458 +1872 1209 +1872 2383 +1872 3539 +1872 3619 +1872 3620 +1872 3621 +1872 3622 +1872 3623 +4467 2345 +4467 3097 +4467 3260 +4467 3314 +4467 5037 +4432 92 +4432 892 +4432 1217 +4432 1404 +4432 1989 +4432 4004 +4432 4031 +4432 4058 +4432 5277 +4432 5278 +599 437 +599 564 +599 581 +599 600 +599 601 +599 602 +599 603 +599 604 +599 605 +599 606 +1855 161 +1855 473 +1855 552 +1855 1670 +1855 1731 +1855 2563 +1855 3364 +1855 3572 +1855 3600 +1855 3601 +5156 3370 +4036 813 +4036 842 +4036 924 +4036 2904 +4036 2928 +4036 3058 +4036 3109 +4036 4248 +4036 4978 +5221 96 +5221 292 +5221 334 +5221 400 +5221 1122 +5221 1177 +5221 1377 +5221 2322 +5221 3306 +5221 5719 +2296 3987 +4382 4 +4382 124 +4382 146 +4382 247 +4382 249 +4382 367 +4382 427 +4382 559 +4382 718 +4382 754 +5263 124 +5263 143 +5263 147 +5263 247 +5263 390 +5263 422 +5263 423 +5263 427 +5263 2001 +5432 379 +5432 418 +5432 513 +5432 882 +5432 2354 +5432 2684 +5432 4779 +5432 5344 +5432 5734 +5432 5817 +1941 749 +1941 1362 +1941 2785 +1941 3136 +1941 3599 +1941 3708 +1941 3709 +1941 3710 +1941 3711 +1941 3712 +1943 13 +1943 279 +1943 646 +1943 1887 +1943 2545 +1943 3256 +1943 3515 +1943 3715 +1943 3716 +1943 3717 +5478 122 +5478 123 +5478 145 +5478 148 +5478 238 +5478 353 +5478 424 +5478 697 +5478 736 +5478 2001 +5479 2697 +5479 4065 +5479 5882 +1610 60 +1610 234 +1610 269 +1610 721 +1610 1539 +1610 1611 +1610 1612 +1610 1613 +1610 1614 +1610 1615 +1971 769 +1971 774 +1971 1127 +1971 1341 +1971 2847 +1971 3737 +1971 3738 +1971 3739 +1971 3740 +1971 3741 +5565 705 +5565 1029 +5565 1084 +5565 3765 +5565 3818 +5565 5874 +5565 5875 +5565 5876 +5565 5877 +5565 5878 +349 473 +349 855 +349 946 +349 1716 +349 2296 +349 2297 +349 2298 +349 2299 +349 2300 +407 412 +407 1217 +407 1749 +407 2392 +4038 2236 +4674 5283 +3369 104 +3369 391 +3369 860 +3369 1855 +3369 3014 +3369 4093 +3369 4120 +3369 4298 +3369 4714 +3369 4715 +5410 275 +5410 605 +5410 1123 +5410 1430 +5410 1818 +5410 2721 +5410 3919 +5410 5809 +5410 5810 +5410 5811 +967 15 +967 440 +967 669 +967 2855 +967 2856 +967 2857 +967 2858 +967 2859 +967 2860 +967 2861 +1202 3105 +5343 946 +5343 2414 +5343 2563 +5343 2780 +5343 3930 +5343 4245 +5343 4675 +5343 5300 +5343 5781 +5343 5782 +5589 203 +5589 697 +5589 750 +5589 913 +5589 2716 +5589 4156 +5589 4189 +5589 5407 +5589 5449 +504 3 +504 123 +504 125 +504 146 +504 264 +504 352 +504 353 +504 427 +504 1245 +504 1246 +5147 123 +5147 1321 +5147 3052 +5147 4213 +5147 4929 +5147 4998 +5147 5301 +5147 5653 +5147 5654 +5147 5655 +5135 184 +5135 613 +5135 2973 +5135 4111 +5135 5647 +5135 5648 +5135 5649 +5135 5650 +5135 5651 +5135 5652 +3092 1424 +3092 1524 +3092 2257 +3092 3053 +3092 3096 +3092 3105 +3092 3269 +3092 3716 +3092 4130 +3092 4532 +4788 1909 +4788 1942 +4788 2068 +4788 4183 +4788 4216 +4788 4653 +4788 5115 +4788 5304 +4788 5493 +4788 5494 +3867 1297 +3867 1866 +3867 1867 +3867 2356 +3867 2376 +3867 3329 +3867 3615 +3867 4828 +3867 4971 +3867 4972 +5515 8 +5515 123 +5515 124 +5515 127 +5515 179 +5515 247 +5515 367 +5515 390 +5515 423 +5515 1246 +5858 612 +1138 152 +1138 2013 +1138 2221 +1138 2770 +1138 2785 +1138 2848 +1138 3015 +1138 3016 +1138 3017 +1871 3491 +4175 5209 +4973 140 +4973 350 +4973 1066 +4973 3417 +4973 4324 +4973 4501 +4973 4752 +4973 5310 +4973 5463 +4973 5521 +5226 748 +5226 1316 +5226 1326 +5226 1487 +5226 2414 +5226 2639 +5226 2901 +5226 3192 +5226 3849 +5226 4765 +5227 480 +5227 1039 +5227 1654 +5227 3348 +5227 5138 +5227 5427 +5227 5721 +5227 5722 +5227 5723 +5227 5724 +1136 553 +1136 856 +1136 1137 +1136 1138 +1136 1139 +1136 1140 +1136 1141 +1136 1142 +1136 1143 +1136 1144 +5585 106 +5585 1949 +5585 2593 +5585 2594 +5585 2595 +5585 2892 +5585 3343 +5585 4613 +5585 5887 +5585 5888 +3148 3301 +4837 5525 +1154 538 +1154 738 +1154 744 +1154 921 +1154 1155 +1154 1156 +1154 1157 +1154 1158 +1154 1159 +1154 1160 +5359 4 +5359 125 +5359 175 +5359 352 +5359 368 +5359 558 +5359 717 +5359 856 +5359 1317 +5359 2338 +5950 9 +5950 147 +5950 149 +5950 238 +5950 252 +5950 266 +5950 426 +5950 666 +5950 717 +5950 2018 +5951 870 +5951 2348 +5951 3165 +5951 3550 +5951 3733 +5951 4093 +5951 5129 +5951 5644 +5951 6078 +5951 6079 +978 215 +978 314 +978 315 +978 1140 +978 2877 +978 2878 +978 2879 +978 2880 +978 2881 +978 2882 +4458 47 +4458 491 +4458 541 +4458 2869 +4458 3779 +4458 5118 +4458 5298 +4458 5299 +4458 5300 +4458 5301 +5608 65 +5608 311 +5608 612 +5608 2308 +5608 2566 +5608 3539 +5608 5004 +5608 5897 +5608 5898 +5608 5899 +3206 2909 +3206 3403 +3206 3489 +3206 4588 +3206 4589 +3208 559 +3208 1037 +3208 1122 +3208 1175 +3208 2018 +3208 2524 +3208 4005 +3208 4508 +3208 4592 +3208 4593 +4051 122 +4051 175 +4051 250 +4051 252 +4051 266 +4051 367 +4051 423 +4051 558 +4051 754 +4051 2001 +4358 124 +4358 250 +4358 264 +4358 266 +4358 368 +4358 423 +4358 427 +4358 559 +4358 2018 +5545 63 +5545 629 +5545 1034 +5545 1384 +5545 2078 +5545 2249 +5545 2386 +5545 2698 +5545 2780 +5545 3110 +5545 3517 +5545 4503 +5545 4838 +5545 6292 +5545 6293 +5545 6294 +5545 6295 +5548 4453 +5548 5012 +5548 5634 +5548 5871 +5548 5872 +5543 123 +5543 146 +5543 249 +5543 264 +5543 352 +5543 369 +5543 422 +5543 423 +5543 427 +5543 2338 +5498 144 +5498 145 +5498 147 +5498 148 +5498 149 +5498 175 +5498 367 +5498 390 +5498 718 +2145 262 +2145 1407 +2145 1637 +2145 1926 +2145 3900 +2145 3901 +2145 3902 +2145 3903 +2145 3904 +2145 3905 +1172 296 +1172 1173 +1172 1174 +1172 1175 +1172 1176 +1172 1177 +1172 1178 +1172 1179 +1172 1180 +5082 348 +5082 731 +5082 1233 +5082 1323 +5082 1506 +5082 3213 +5082 3356 +5082 3468 +5082 4893 +5082 5373 +2267 855 +2267 1323 +2267 1439 +2267 1808 +2267 3568 +2267 4275 +2267 4738 +2267 4806 +2267 6121 +2267 6122 +5012 266 +5012 440 +5012 826 +5012 852 +5012 2394 +5012 2552 +5012 3334 +5012 3456 +5012 4281 +181 182 +181 183 +181 184 +181 185 +181 186 +181 187 +181 188 +181 189 +181 190 +181 191 +2900 177 +2900 303 +2900 1487 +2900 2751 +2900 3142 +2900 3179 +2900 3544 +2900 4384 +2900 4385 +2900 4386 +5960 3304 +1616 288 +1616 1595 +1616 1617 +1616 1618 +1616 1619 +1616 1620 +1616 1621 +1616 1622 +1616 1623 +1616 1624 +1836 112 +1836 298 +1836 579 +1836 627 +1836 894 +1836 2485 +1836 2730 +1836 3569 +1836 3570 +2506 983 +2506 2223 +2506 2646 +2506 2733 +2506 3569 +2506 3772 +2506 3894 +2506 4061 +2506 4141 +2506 4142 +2992 928 +2992 1054 +2992 2906 +2992 2995 +2992 3681 +2992 4438 +2992 4439 +2992 4440 +2992 4441 +2992 4442 +4739 260 +4739 762 +4739 1333 +4739 3475 +4739 3504 +4739 3807 +4739 3851 +4739 5454 +4739 5455 +4740 908 +4740 942 +4740 991 +4740 1412 +4740 2162 +4740 2708 +4740 3767 +4740 4113 +4740 5457 +4740 5458 +2774 2440 +1419 740 +1419 1085 +1419 1131 +1419 1271 +1419 1420 +1419 1421 +1419 1422 +1419 1423 +1419 1424 +1419 1425 +1843 567 +1843 892 +1843 1021 +1843 2033 +1843 2853 +1843 3307 +1843 3573 +1843 3574 +1843 3575 +1843 3576 +1844 50 +1844 586 +1844 1064 +1844 1528 +1844 2221 +1844 3585 +1844 3586 +1844 3587 +1844 3588 +1844 3589 +4078 387 +4078 584 +4078 674 +4078 1670 +4078 2091 +4078 3091 +4078 4328 +4078 4467 +4078 5070 +4078 5071 +2452 77 +2452 1027 +2452 1321 +2452 1925 +2452 2373 +2452 3156 +2452 3849 +2452 4106 +2452 4107 +2452 4108 +2454 586 +2459 215 +2459 856 +2459 960 +2459 1103 +2459 1152 +2459 1402 +2459 1709 +2459 3165 +2459 3866 +2459 4109 +2460 892 +2460 1019 +2460 1342 +2460 1476 +2460 2530 +2460 2531 +2460 2532 +2460 3874 +2460 4110 +2460 4111 +722 2713 +4274 164 +4274 230 +4274 424 +4274 2017 +4274 2148 +4274 2787 +4274 3523 +4274 3988 +4274 4813 +4274 5178 +4276 5 +4276 7 +4276 125 +4276 126 +4276 147 +4276 149 +4276 175 +4276 266 +4276 667 +4276 754 +3913 204 +3913 607 +3913 804 +3913 1072 +3913 1605 +3913 1728 +3913 1780 +3913 3339 +3913 4995 +1930 190 +1930 814 +1930 923 +1930 1655 +1930 2900 +1930 3703 +1930 3704 +1930 3705 +1930 3706 +1930 3707 +3627 3022 +3627 3699 +3627 4867 +3627 4868 +3627 4869 +3628 352 +1229 1916 +1229 2140 +1229 2949 +1229 2984 +1229 3084 +1229 3085 +1229 3086 +1229 3087 +1229 3088 +3542 470 +3542 2304 +3542 4625 +3542 4788 +3542 4793 +3542 4811 +3542 4812 +3542 4813 +3542 4814 +3673 123 +3673 127 +3673 177 +3673 246 +3673 264 +3673 353 +3673 422 +3673 717 +3673 856 +3673 1245 +4782 1947 +4782 2524 +4782 2787 +4782 3140 +4782 3283 +4782 3288 +4782 3766 +4782 5487 +4782 5488 +4782 5489 +4813 300 +4813 1434 +4813 1487 +4813 1730 +4813 2541 +4813 2787 +4813 2881 +4813 5510 +2627 9 +2627 144 +2627 146 +2627 148 +2627 149 +2627 175 +2627 264 +2627 390 +2627 1245 +6004 583 +6004 1058 +6004 5292 +6004 5940 +6004 6112 +6004 6113 +6004 6114 +6004 6115 +6004 6116 +6006 230 +6006 1458 +6006 2649 +6006 3389 +6006 3794 +6006 6117 +6006 6118 +6006 6119 +6006 6120 +1687 721 +1687 1115 +1687 2359 +1687 3070 +1687 3100 +1687 3230 +1687 3439 +1687 3440 +1687 3441 +1687 3442 +2694 3363 +4381 89 +4381 691 +4381 3189 +4381 3314 +4381 3849 +4381 4344 +4381 4788 +4381 4934 +4381 5246 +4389 208 +4389 1173 +4389 1362 +4389 4164 +4389 5248 +4389 5249 +4390 339 +4390 527 +4390 1339 +4390 2066 +4390 2839 +4390 2973 +4390 3524 +4390 3661 +4390 4723 +4390 5250 +4391 1894 +225 199 +225 221 +225 893 +225 1343 +225 1749 +225 1861 +225 2177 +225 2178 +225 2179 +225 2180 +226 168 +226 314 +226 1114 +226 1564 +226 2171 +226 2172 +226 2173 +226 2174 +226 2175 +226 2176 +2678 2314 +2678 2481 +2678 2788 +2678 2828 +2678 3279 +2678 4251 +2678 4252 +2678 4253 +2678 4254 +2678 4255 +4792 769 +4792 874 +4792 1227 +4792 1894 +4792 2538 +4792 2670 +4792 4199 +4792 4338 +4792 4578 +4792 5327 +1586 4 +1586 8 +1586 147 +1586 148 +1586 174 +1586 352 +1586 368 +1586 424 +1586 856 +1586 2098 +6070 1087 +6070 1512 +6070 2857 +6070 3593 +6070 3841 +6070 3948 +6070 4159 +6070 4844 +6070 5373 +6070 5436 +1292 3149 +2807 143 +2807 249 +2807 264 +2807 390 +2807 423 +2807 559 +2807 1842 +2807 4312 +2807 4313 +2807 4314 +2501 5 +2501 123 +2501 125 +2501 126 +2501 129 +2501 144 +2501 148 +2501 149 +2501 248 +2501 1317 +2503 132 +2503 181 +2503 397 +2503 707 +2503 1786 +2503 2750 +2503 2751 +2503 3801 +2503 3995 +2503 4136 +4187 31 +4187 144 +4187 145 +4187 146 +4187 149 +4187 180 +4187 266 +4187 423 +4187 856 +4187 1317 +4269 4797 +1737 710 +1737 740 +1737 2246 +1737 2758 +1737 3093 +1737 3236 +1737 3243 +1737 3528 +1737 3529 +1739 3 +1739 123 +1739 125 +1739 179 +1739 251 +1739 352 +1739 353 +1739 369 +1739 427 +1739 1317 +3802 478 +3805 2059 +3805 2238 +3805 4508 +3805 5001 +3805 5848 +3805 5849 +3805 5850 +3805 5851 +3805 5852 +3805 5853 +5827 3077 +5827 3964 +5827 4614 +5827 5323 +5827 6059 +5827 6060 +5828 122 +5828 246 +5828 264 +5459 385 +5459 870 +5459 1048 +5459 1980 +5459 4793 +5459 5831 +5459 5832 +5459 5833 +5459 5834 +1577 550 +1577 1578 +6045 5338 +6046 73 +6046 177 +6046 1974 +6046 3022 +6046 3088 +6046 4465 +6046 4511 +6046 4580 +6046 5962 +6046 6139 +6047 5754 +448 108 +448 128 +448 148 +448 878 +448 1317 +448 1376 +448 1556 +448 1912 +448 2439 +448 2440 +1063 2493 +1063 2987 +1063 2988 +1063 2989 +1063 2990 +1063 2991 +1063 2992 +1063 2993 +1063 2994 +1063 2995 +3536 751 +3536 1802 +3536 3795 +3536 3918 +3536 4804 +3536 4805 +3536 4806 +3536 4807 +3537 123 +3537 126 +3537 145 +3537 149 +3537 177 +3537 352 +3537 353 +3537 424 +3537 558 +3537 754 +3539 47 +3539 503 +3539 1342 +3539 3460 +3539 4199 +3539 4281 +3539 4727 +3539 4808 +3539 4809 +3539 4810 +1438 173 +1438 202 +1438 222 +1438 685 +1438 1421 +1438 1534 +1438 3291 +1438 3292 +1438 3293 +1438 3294 +5682 364 +5682 852 +5682 1700 +5682 1910 +5682 1945 +5682 2085 +5682 3299 +5682 4891 +5682 5116 +5682 5837 +6049 157 +6049 500 +6049 664 +6049 1017 +6049 1715 +6049 2991 +6049 3293 +6049 6140 +6049 6141 +6049 6142 +701 118 +701 499 +701 506 +701 702 +701 703 +701 704 +701 705 +701 706 +701 707 +701 708 +5339 124 +5339 147 +5339 175 +5339 247 +5339 250 +5339 367 +5339 368 +5339 369 +5339 559 +5339 754 +634 308 +634 503 +634 717 +634 2941 +634 2968 +634 3112 +634 5880 +634 6131 +634 6132 +634 6133 +4338 56 +4338 363 +4338 432 +4338 554 +4338 1859 +4338 3608 +4338 4143 +4338 4151 +4338 4929 +4338 5225 +4340 1255 +4340 1300 +4340 1591 +4340 1792 +4340 2112 +4340 2164 +4340 3893 +4340 5141 +4340 5223 +4340 5224 +5802 4273 +3910 122 +3910 124 +3910 127 +3910 143 +3910 247 +3910 264 +3910 352 +3910 353 +3910 390 +3910 1245 +1341 63 +1341 435 +1341 740 +1341 1754 +1341 2125 +1341 2217 +1341 2524 +1341 2740 +1341 3204 +1341 3205 +1360 968 +1360 1561 +1360 2356 +1360 2918 +1360 3223 +5102 23 +5102 1022 +5102 1044 +5102 1867 +5102 3414 +5102 3488 +5102 4039 +5102 5475 +5102 5637 +5102 5638 +1995 3767 +1996 909 +1996 1297 +1996 1535 +1996 1571 +1996 2201 +1996 2265 +1996 2942 +1996 3193 +1996 3765 +1996 3766 +1998 3770 +2003 442 +2003 494 +2003 918 +2003 1326 +2003 3230 +2003 3773 +2003 3774 +2003 3775 +2003 3776 +2003 3777 +4378 255 +4378 363 +4378 741 +4378 869 +4378 1456 +4378 1762 +4378 2485 +4378 3109 +4378 4854 +4378 5251 +996 77 +996 997 +996 998 +3560 126 +3560 224 +3560 756 +3560 820 +3560 821 +3560 1362 +3560 3105 +3560 4450 +3560 4821 +3560 4822 +1440 292 +1440 1177 +1440 1557 +1440 1718 +1440 2656 +1440 3302 +1440 3303 +1440 3304 +1440 3305 +1440 3306 +2315 458 +2315 869 +2315 881 +2315 1447 +2315 2886 +2315 3547 +2315 4000 +2315 4001 +2315 4002 +2315 4003 +2318 1021 +2318 2538 +2318 3763 +2318 3789 +2318 4008 +2318 4009 +2318 4010 +2318 4011 +2318 4012 +2318 4013 +5701 603 +5701 1552 +5701 1720 +5701 2081 +5701 2177 +5701 2933 +5701 3224 +5701 3543 +5701 3743 +5701 5406 +5695 1384 +5695 2219 +5695 5254 +5695 5975 +4900 5 +4900 8 +4900 121 +4900 129 +4900 149 +4900 174 +4900 179 +4900 249 +4900 251 +4900 352 +4902 996 +4902 2868 +4902 3188 +4902 3580 +4902 3804 +4902 4563 +4902 4903 +4902 5556 +4902 5557 +4902 5558 +4903 2679 +4903 3195 +4903 3822 +4903 4732 +4903 5056 +4903 5559 +4903 5560 +4903 5561 +4903 5562 +5703 789 +3236 17 +3236 145 +3236 175 +3236 179 +3236 180 +3236 424 +3236 717 +3236 736 +3236 754 +3236 2001 +3276 5 +3276 8 +3276 31 +3276 149 +3276 176 +3276 352 +3276 353 +3276 558 +3276 754 +6110 1084 +6110 2117 +6110 2276 +6110 3252 +6110 3257 +6110 3531 +6110 5557 +6110 5600 +6110 6195 +6110 6196 +6111 554 +6111 839 +6111 967 +6111 1267 +6111 3227 +6111 3327 +6111 3481 +6111 4914 +6111 5601 +3544 3 +3544 121 +3544 124 +3544 143 +3544 174 +3544 177 +3544 264 +3544 426 +3544 427 +3544 717 +6174 5 +6174 7 +6174 8 +6174 121 +6174 149 +6174 247 +6174 353 +6174 424 +6174 754 +6174 1317 +6175 4 +6175 125 +6175 148 +6175 559 +6175 697 +6175 754 +6175 856 +6175 1317 +6175 5710 +5603 1094 +5603 1495 +5603 1597 +5603 1608 +5603 1788 +5603 2689 +5603 3053 +5603 4295 +5603 4702 +5603 5895 +5909 282 +5909 342 +5909 1805 +5909 2612 +5909 3963 +5909 4170 +5909 4333 +5909 4365 +5909 5729 +6108 76 +6108 131 +6108 1023 +6108 1863 +6108 2080 +6108 2127 +6108 3677 +6108 3962 +6108 4260 +6108 6182 +6181 8 +6181 122 +6181 177 +6181 247 +6181 249 +6181 251 +6181 266 +6181 353 +6181 422 +6181 718 +5380 1001 +5901 664 +5901 2663 +5901 3415 +5901 3906 +5901 5407 +5901 5415 +5901 5781 +5901 6054 +5901 6055 +6180 129 +6180 1351 +6180 2068 +6180 2360 +6180 3886 +6180 4009 +6180 5729 +6180 6243 +6180 6244 +6180 6245 +1369 256 +1369 308 +1369 860 +1369 1457 +1369 1767 +1369 1817 +1369 3219 +1369 3220 +1369 3221 +1369 3222 +6163 491 +6163 744 +6163 851 +6163 2202 +6163 2583 +6163 3089 +6163 3601 +6163 5826 +6163 6041 +6163 6233 +6165 255 +6165 376 +6165 777 +6165 1229 +6165 3190 +6165 3683 +6165 4757 +6165 4885 +6165 5593 +6165 5801 +5529 345 +5529 2377 +5529 3285 +5529 3334 +5529 4160 +5529 4735 +5529 4986 +5529 5168 +5529 5866 +5529 5867 +5970 86 +5970 477 +5970 586 +5970 1240 +5970 1770 +5970 4756 +5970 4844 +5970 5627 +5970 6090 +6288 77 +6288 5097 +6288 5211 +6288 6287 +6288 6296 +1082 3 +1082 7 +1082 8 +1082 124 +1082 126 +1082 144 +1082 238 +1082 248 +1082 352 +1082 427 +5073 363 +5073 462 +5073 518 +5073 1047 +5073 2127 +5073 2612 +5073 3083 +5073 4408 +5073 5624 +5073 5625 +5504 505 +5504 3293 +5504 3778 +5504 4293 +5504 4458 +5504 5121 +5504 5703 +5504 5792 +5504 5854 +5504 5855 +5962 249 +5962 266 +5962 367 +5962 422 +5962 559 +5962 695 +5962 736 +5962 754 +5962 3677 +5168 229 +5168 1039 +5168 1192 +5168 1458 +5168 2127 +5168 2974 +5168 4563 +5168 5678 +5168 5679 +5168 5680 +5965 179 +5965 1335 +5965 2361 +5965 2487 +5965 3388 +5965 5514 +5965 5626 +5965 5989 +5965 6088 +5965 6089 +3919 7 +3919 219 +3919 256 +3919 424 +3919 1602 +3919 2119 +3919 2364 +3919 3120 +3919 4756 +3919 4996 +3920 49 +3920 1056 +3920 1512 +3920 1739 +3920 2789 +3920 3322 +3920 4412 +3920 4597 +3920 4716 +3920 4997 +4137 264 +4137 385 +4137 1227 +4137 1281 +4137 1310 +4137 3266 +4137 4077 +4137 4345 +4137 4362 +4137 4739 +5716 206 +5716 941 +5716 2037 +5716 2823 +5716 4639 +5716 4694 +5716 4809 +5716 5944 +5716 5945 +5716 5946 +2883 337 +2883 409 +2883 1289 +2883 1473 +2883 2321 +2883 2744 +2883 3565 +2883 4365 +2883 4366 +2883 4367 +4596 133 +4596 3949 +4596 4426 +4596 5308 +4596 5370 +4596 5371 +4596 5372 +4596 5373 +4596 5374 +4596 5375 +4598 4 +4598 146 +4598 180 +4598 250 +4598 368 +4598 390 +4598 697 +4598 1245 +4598 1317 +1932 364 +1932 685 +1932 921 +1932 1313 +1932 1829 +1932 2644 +1932 3018 +1932 3713 +1932 3714 +4445 4 +4445 127 +4445 143 +4445 247 +4445 249 +4445 250 +4445 369 +4445 559 +4445 667 +4445 2001 +89 211 +89 914 +89 1476 +89 1776 +89 1906 +89 1976 +89 2010 +89 2011 +89 2012 +89 2013 +2962 823 +2962 1457 +2962 2397 +2962 2637 +2962 2873 +2962 2898 +2962 3127 +2962 3992 +2962 4443 +314 121 +314 147 +314 177 +314 248 +314 249 +314 252 +314 264 +314 266 +314 423 +314 1245 +1276 901 +1276 2075 +1276 2585 +1276 2874 +1276 3128 +1276 3153 +1276 3154 +1276 3155 +1276 3156 +1276 3157 +1279 1227 +1279 1787 +1279 1993 +1279 2626 +1279 3017 +1279 3128 +1279 3129 +1279 3130 +1279 3131 +1279 3132 +1281 483 +1281 833 +1281 1431 +1281 1509 +1281 2034 +1281 2236 +1281 3133 +1281 3134 +1281 3135 +1281 3136 +1284 148 +1284 174 +1284 266 +1284 368 +1284 369 +1284 423 +1284 427 +1284 559 +1284 1245 +1284 1317 +4420 224 +4420 281 +4420 386 +4420 1401 +4420 3358 +4420 3448 +4420 3590 +4420 5270 +4420 5271 +2223 107 +2223 883 +2223 1021 +2223 1048 +2223 1175 +2223 1269 +2223 1936 +2223 2414 +2223 3868 +2223 3930 +4456 9 +4456 126 +4456 143 +4456 144 +4456 145 +4456 148 +4456 179 +4456 423 +4456 697 +4748 1337 +4748 1981 +4748 2383 +4748 3775 +4748 3810 +4748 4598 +4748 5102 +4748 5464 +4748 5465 +4748 5466 +4999 123 +4999 149 +4999 179 +4999 427 +508 260 +508 452 +508 487 +508 509 +508 510 +508 511 +508 512 +508 513 +508 514 +508 515 +5531 1945 +5531 1955 +5531 2062 +5531 2399 +5531 2617 +5531 2850 +5531 2874 +5531 5405 +5531 5902 +5531 5903 +5532 8 +5532 17 +5532 126 +5532 129 +5532 147 +5532 250 +5532 422 +5532 424 +5532 3937 +588 589 +588 590 +588 591 +588 592 +588 593 +588 594 +588 595 +588 596 +588 597 +588 598 +1821 112 +1821 690 +1821 703 +1821 1636 +1821 1703 +1821 1822 +1821 1823 +1821 1824 +1821 1825 +1821 1826 +302 1233 +302 2519 +5691 3481 +617 618 +617 619 +617 620 +617 621 +617 622 +617 623 +617 624 +617 625 +617 626 +617 627 +734 623 +734 893 +734 1412 +734 1734 +734 2015 +734 2582 +734 2631 +734 2684 +734 2685 +734 2686 +1627 364 +1627 442 +1627 2278 +1627 3384 +1627 3385 +4076 175 +4076 251 +4076 252 +4076 266 +4076 292 +4076 390 +4076 422 +4076 558 +4076 856 +4076 3933 +5618 637 +5618 969 +5618 1039 +5618 1311 +5618 1541 +5618 2444 +5618 2646 +5618 4798 +5618 5904 +5618 5905 +1633 83 +1633 831 +1633 1634 +1633 1635 +1633 1636 +1633 1637 +1633 1638 +1633 1639 +1633 1640 +6036 474 +6036 810 +6036 1332 +6036 1458 +6036 1842 +6036 3213 +6036 3411 +6036 3658 +6036 3913 +6036 6137 +6038 50 +6038 190 +6038 1376 +6038 1557 +6038 1689 +6038 2254 +6038 2354 +6038 2414 +6038 2657 +6038 2750 +33 34 +33 35 +33 36 +33 37 +33 38 +33 39 +33 40 +33 41 +33 42 +33 43 +1729 23 +1729 1058 +1729 1594 +1729 1647 +1729 1679 +1729 1730 +1729 1731 +1729 1732 +1729 1733 +1729 1734 +4510 157 +4510 158 +4510 442 +4510 1317 +4510 4177 +4510 4958 +4510 5328 +4510 5329 +4510 5330 +4557 41 +4557 804 +4557 2247 +4557 2536 +4557 3996 +4557 4459 +4557 5162 +4557 5300 +4557 5346 +4557 5347 +1331 390 +1331 548 +1331 892 +1331 1332 +1331 1333 +1331 1334 +1331 1335 +1331 1336 +1331 1337 +1331 1338 +1046 3 +1046 17 +1046 31 +1046 146 +1046 147 +1046 175 +1046 250 +1046 368 +1046 1245 +3088 121 +3088 122 +3088 123 +3088 125 +3088 127 +3088 144 +3088 174 +3088 352 +3088 369 +3088 1317 +5043 2557 +2351 1248 +2351 1335 +2351 1779 +2351 2669 +2351 2792 +2351 3172 +2351 3580 +2351 3935 +2351 4035 +2352 63 +2352 738 +2352 1556 +2352 1949 +2352 2279 +2352 2699 +2352 3204 +2352 3863 +2352 4039 +2352 4040 +1009 77 +1009 784 +1009 1010 +1009 1011 +1009 1012 +1009 1013 +1009 1014 +1009 1015 +1009 1016 +1009 1017 +1191 116 +1191 1076 +1191 1079 +1191 1331 +1191 1339 +1191 1340 +1191 1341 +1191 1342 +1191 1343 +1191 1344 +2921 296 +2921 828 +2921 944 +2921 1456 +2921 2354 +2921 3139 +2921 3779 +2921 4248 +2921 4407 +2921 4408 +3790 256 +3790 413 +3790 459 +3790 1305 +3790 1940 +3790 2113 +3790 2841 +3790 3288 +3790 4160 +3790 4581 +232 2223 +608 2026 +610 881 +610 1217 +610 1392 +610 1990 +610 2273 +610 2558 +610 2559 +610 2560 +610 2561 +610 2562 +611 532 +611 586 +611 740 +611 808 +611 1500 +611 2265 +611 2480 +611 2543 +611 2544 +611 2545 +613 1631 +613 2337 +613 2453 +613 2546 +613 2547 +613 2548 +613 2549 +613 2550 +613 2551 +5279 1402 +5279 2035 +5279 3080 +5279 4882 +5279 5749 +5366 942 +5366 1456 +5366 2230 +5366 2366 +5366 2612 +5366 2841 +5366 2982 +5366 3707 +5366 5798 +5643 5918 +5613 1454 +5613 2191 +5613 3328 +5613 3574 +5613 4885 +5613 5576 +5613 5704 +5613 5784 +5613 5887 +5613 5896 +5735 1120 +5735 1375 +5735 2027 +5735 3109 +5735 3335 +5735 3930 +5735 4986 +5735 5956 +5735 5957 +5707 823 +1743 849 +1743 2016 +1743 2648 +1743 2735 +1743 2781 +1743 2836 +1743 3188 +1743 3500 +1743 3501 +1743 3502 +4003 3 +4003 8 +4003 127 +4003 143 +4003 177 +4003 248 +4003 352 +4003 353 +4003 367 +4003 424 +5486 1056 +5486 1160 +5486 1199 +5486 2709 +5486 3489 +5486 3977 +5486 4332 +5486 5836 +5486 5837 +5486 5838 +3355 584 +3355 1837 +3355 2629 +3355 3035 +3355 3319 +3355 3335 +3355 4693 +3355 4694 +3355 4695 +3355 4696 +3356 127 +3356 128 +3356 246 +3356 248 +3356 352 +3356 353 +3356 422 +3356 427 +3356 667 +3356 856 +956 2836 +3348 124 +3348 128 +3348 146 +3348 147 +3348 176 +3348 238 +3348 249 +3348 264 +3348 368 +3348 718 +5222 3301 +2659 945 +2659 1489 +2659 2086 +2659 2411 +2659 2982 +2659 3684 +2659 4245 +2659 4246 +2679 10 +2679 148 +2679 265 +2679 369 +2679 427 +2679 698 +2679 754 +2679 947 +2679 2064 +2679 4257 +2680 1466 +2680 1685 +2680 2881 +2680 3023 +2680 3207 +2680 3247 +2680 4095 +2680 4237 +2680 4256 +2682 4173 +3985 563 +3985 1846 +3985 2489 +3985 2517 +3985 3819 +3985 3863 +3985 3988 +3985 4241 +3985 4565 +3985 5023 +3986 531 +3986 749 +3986 1279 +3986 2207 +3986 2383 +3986 2864 +3986 4087 +3986 4734 +3986 5026 +3986 5027 +5292 1240 +5292 3029 +5292 4641 +5292 5159 +5292 5766 +5294 64 +5294 2633 +5294 3205 +5294 3218 +5294 4205 +5294 4939 +5294 5759 +5294 5760 +5294 5761 +5294 5762 +4073 134 +4073 1224 +4073 1250 +4073 1739 +4073 1862 +4073 2050 +4073 3460 +4073 4262 +4073 5072 +4073 5073 +1752 83 +1752 690 +1752 1022 +1752 2198 +1752 2311 +1752 3272 +1752 3516 +1752 3517 +1752 3518 +1752 3519 +3086 327 +3086 1087 +3086 1689 +3086 2195 +3086 3823 +3086 4505 +3086 4506 +3086 4507 +3086 4508 +3086 4509 +3197 585 +3197 1036 +3197 1730 +3197 1797 +3197 2556 +3197 2997 +3197 3619 +3197 3808 +3197 4582 +3197 4583 +5007 1880 +5007 2841 +5007 3460 +5007 4111 +5007 4619 +5007 5594 +5007 5595 +5007 5596 +5007 5597 +5007 5598 +1710 1711 +5623 212 +5623 531 +5623 1094 +5623 1665 +5623 2298 +5623 2468 +5623 5378 +5623 5906 +5623 5907 +5623 5908 +2698 470 +2698 802 +2698 928 +2698 958 +2698 1067 +2698 1590 +2698 3995 +2698 4137 +2698 4270 +2698 4271 +2550 2163 +5096 145 +5096 359 +5096 427 +5096 605 +5096 881 +5096 1861 +5096 3402 +5096 3550 +5096 5635 +5096 5636 +5804 1538 +5804 3345 +5804 3702 +5804 4939 +5804 5988 +5804 5992 +5804 5993 +5804 5994 +5804 5995 +5804 5996 +5492 163 +5492 1968 +5492 2648 +5492 4844 +5492 5475 +5492 5767 +5492 5841 +5492 5842 +5492 5843 +5492 5844 +4662 828 +4662 1195 +4662 2698 +4662 2773 +4662 2891 +4662 3595 +4662 4770 +4662 4848 +4662 5392 +4662 5411 +2829 43 +2829 122 +2829 123 +2829 251 +2829 423 +2829 1228 +2829 1245 +2829 1679 +2829 1721 +2829 4334 +4606 862 +4606 1458 +4606 1900 +4606 3220 +4606 3221 +4606 4287 +4606 4586 +4606 5377 +4606 5378 +4606 5379 +1676 3 +1676 5 +1676 7 +1676 8 +1676 122 +1676 123 +1676 149 +1676 174 +1676 251 +1676 717 +2860 122 +2860 127 +2860 143 +2860 177 +2860 179 +2860 367 +2860 369 +2860 390 +2860 422 +2860 718 +5509 1405 +5509 2218 +5509 3288 +5509 4501 +5509 4854 +5509 5859 +5509 5860 +5509 5861 +5509 5862 +2485 33 +2485 100 +2485 568 +2485 2422 +2485 2588 +2485 2654 +2485 3335 +2485 4124 +2485 4125 +2485 4126 +4790 547 +4790 909 +4790 1007 +4790 1812 +4790 2928 +4790 3033 +4790 4558 +4790 5050 +4790 5495 +4790 5496 +5523 241 +1015 503 +1015 535 +1015 673 +1015 840 +1015 979 +1015 2916 +1015 2917 +1015 2918 +1015 2919 +5425 415 +5425 1158 +5425 1383 +5425 2059 +5425 2677 +5425 2869 +5425 3213 +5425 3516 +5425 4377 +5425 5616 +5614 4415 +5616 133 +5616 813 +5616 1533 +5616 2215 +5616 2391 +5616 2625 +5616 2847 +5616 3836 +5616 4484 +4157 5096 +4513 904 +4513 1524 +4513 2164 +4513 2710 +4513 3241 +4513 3303 +4513 3478 +4513 5191 +4513 5336 +4513 5337 +1266 906 +4833 1056 +4833 1539 +4833 1974 +4833 2020 +4833 2114 +4833 2755 +4833 3277 +4833 4810 +4833 5521 +4833 5522 +3190 123 +3190 124 +3190 367 +3190 368 +3190 667 +3190 857 +3190 1208 +3190 4577 +3190 4578 +3190 4579 +4442 522 +4442 837 +4442 1034 +4442 2670 +4442 3110 +4442 3141 +4442 3448 +4442 3737 +4442 5291 +5811 222 +5811 342 +5811 2324 +5811 2445 +5811 2475 +5811 2612 +5811 4131 +5811 4597 +5811 4885 +5630 290 +5630 380 +5630 3299 +5630 5914 +5630 5915 +3742 979 +3742 1730 +3742 2204 +3742 2215 +3742 2556 +3742 3020 +3742 3523 +3742 4285 +3742 4408 +3742 4411 +5757 4570 +1594 1595 +1600 127 +1600 248 +1600 264 +1600 367 +1600 390 +1600 422 +1600 423 +1600 559 +1600 666 +1600 667 +1641 604 +1641 1077 +1641 1097 +1641 1642 +1641 1643 +1641 1644 +1641 1645 +1641 1646 +1641 1647 +3254 1067 +3255 127 +3255 146 +3255 250 +3255 367 +3255 369 +3255 423 +3255 697 +3255 754 +3255 856 +3256 762 +3256 1361 +3256 2222 +3256 2753 +3256 3358 +3256 3467 +3256 4139 +3256 4636 +3256 4637 +4447 416 +4447 1287 +4447 2621 +4447 2886 +4447 4260 +4447 4462 +4447 4921 +4447 5288 +4447 5289 +4447 5290 +1404 228 +1404 2429 +1404 2477 +1404 2755 +1404 3274 +1404 3275 +1404 3276 +1404 3277 +1404 3278 +1404 3279 +5882 261 +5882 337 +5882 442 +5882 1530 +5882 1952 +5882 3732 +5882 3989 +5882 5086 +5882 5261 +5882 5546 +1612 1724 +1612 2222 +1612 3377 +1612 3378 +3765 921 +3765 4586 +3765 4796 +3765 4918 +3765 4919 +104 2025 +5809 4 +5809 7 +5809 8 +5809 126 +5809 129 +5809 144 +5809 175 +5809 179 +5809 1317 +4245 437 +4245 481 +4245 505 +4245 870 +4245 1137 +4245 1741 +4245 1780 +4245 2114 +4245 2535 +4245 4166 +5654 3 +5654 123 +5654 124 +5654 127 +5654 247 +5654 369 +5654 390 +5654 666 +5654 667 +5654 856 +5650 5921 +5651 290 +5651 2379 +5651 2898 +5651 3367 +5651 3489 +5651 5288 +5651 5887 +5651 5919 +5651 5920 +5304 113 +5304 2313 +5304 2932 +5304 3017 +5304 3134 +5304 4702 +5304 5281 +5304 5299 +5304 5510 +5304 5657 +1155 823 +1155 824 +1155 955 +1155 2394 +1155 2966 +1155 3034 +1155 3035 +1155 3036 +1155 3037 +1155 3038 +6078 14 +6078 36 +6078 1100 +6078 1291 +6078 1824 +6078 1859 +6078 2275 +6078 3035 +6078 4813 +6078 6169 +6079 458 +6079 944 +6079 983 +6079 3981 +6079 5016 +6079 5115 +6079 5790 +6079 5802 +6079 6170 +2879 5 +2879 31 +2879 125 +2879 126 +2879 148 +2879 175 +2879 179 +2879 238 +2879 353 +2879 558 +5897 758 +5897 918 +5897 919 +5897 1865 +5897 5562 +5897 5576 +5897 6050 +5897 6051 +5897 6052 +5897 6053 +5899 17 +5899 96 +5899 3376 +5899 4024 +5899 4987 +5899 5230 +5899 5341 +5899 6056 +5899 6057 +5899 6058 +4508 125 +4508 129 +4508 145 +4508 174 +4508 180 +4508 353 +4508 559 +4508 697 +4508 717 +4508 1317 +4593 227 +4593 727 +4593 802 +4593 945 +4593 1347 +4593 1956 +4593 2884 +4593 3485 +4593 4324 +4593 5369 +6293 117 +6293 274 +6293 788 +6293 1100 +6293 2249 +6293 2635 +6293 3344 +6293 5155 +6293 5685 +6293 6300 +1174 1178 +1174 1233 +1174 1439 +1174 1491 +1174 1946 +1174 3050 +1174 3051 +1174 3052 +1174 3053 +5457 438 +5457 908 +5457 991 +5457 3767 +5457 4486 +5457 4487 +5457 5554 +5457 5829 +5457 5830 +5458 2719 +2440 1881 +2440 4957 +2440 5304 +2440 5305 +3573 184 +3573 412 +3573 725 +3573 2119 +3573 2461 +3573 3602 +3573 4382 +3573 4445 +3573 4834 +3573 4835 +3575 1842 +3588 4813 +4106 452 +4106 453 +4106 1587 +4106 3404 +4106 5081 +1605 102 +1605 430 +1605 472 +1605 1024 +1605 1297 +1605 1381 +1605 1606 +1605 1607 +1605 1608 +1605 1609 +4995 800 +4995 1590 +4995 1600 +4995 1872 +4995 2860 +4995 2930 +4995 3674 +4995 5291 +4995 5590 +3703 459 +3703 1171 +3703 1822 +3703 3193 +3703 3204 +3703 3767 +3703 3778 +3703 4813 +3703 4893 +300 218 +300 301 +300 302 +300 303 +300 304 +300 305 +300 306 +300 307 +300 308 +300 309 +6114 424 +6114 858 +6114 1629 +6114 5962 +6114 6189 +6114 6190 +6114 6191 +6114 6192 +6114 6193 +6114 6194 +3100 303 +3100 1017 +3100 1221 +3100 1941 +3100 2932 +3100 3123 +3100 3722 +3100 3788 +3100 4171 +3100 4544 +5250 5733 +1343 351 +1343 1168 +1343 1504 +1343 1764 +1343 1765 +1343 2585 +1343 3195 +1343 3196 +1343 3197 +1343 3198 +2178 17 +2178 31 +2178 123 +2178 126 +2178 145 +2178 149 +2178 176 +2178 697 +2178 1317 +2171 3907 +2172 96 +2172 604 +2172 828 +2172 1291 +2172 1575 +2172 1961 +2172 2533 +2172 2555 +2172 3020 +2172 3713 +2174 1144 +4252 115 +4252 760 +4252 1672 +4252 1838 +4252 1955 +4252 2690 +4252 4301 +4252 4961 +4252 4976 +4253 5169 +4255 1146 +4255 1635 +4255 2694 +4255 2936 +4255 3181 +4255 3813 +4255 4578 +4255 5166 +4255 5167 +4255 5168 +4312 280 +4312 492 +4312 704 +4312 1084 +4312 1862 +4312 2847 +4312 3717 +4312 5206 +4312 5207 +4312 5208 +3528 305 +3528 707 +3528 2285 +3528 2869 +3528 4726 +3528 4797 +3528 4798 +3528 4799 +3528 4800 +3528 4801 +3529 127 +3529 146 +3529 180 +3529 249 +3529 266 +3529 559 +3529 754 +3529 1245 +3529 2001 +6059 683 +6060 174 +6060 179 +6060 251 +6060 351 +6060 983 +5831 8 +5831 36 +5831 57 +5831 75 +5831 102 +5831 252 +5831 311 +5831 383 +5831 582 +5831 583 +5831 611 +5831 634 +5831 654 +5831 1157 +5831 1173 +5831 1477 +5831 1872 +5831 1890 +5831 1931 +5831 2248 +5831 2746 +5831 2767 +5831 2931 +5831 2941 +5831 3115 +5831 3161 +5831 3343 +5831 3981 +5831 4115 +5831 4159 +5831 4303 +5831 5184 +5831 5528 +5831 5872 +5831 5931 +5831 5932 +5831 6012 +5831 6013 +5831 6014 +5831 6015 +5831 6016 +5831 6017 +5831 6018 +5831 6019 +5831 6020 +5831 6021 +5831 6022 +5831 6023 +5834 124 +5834 177 +5834 248 +5834 249 +5834 1245 +6139 187 +6139 257 +6139 301 +6139 558 +6139 1017 +6139 1052 +6139 1797 +6139 3837 +6139 5765 +6139 6197 +6139 6198 +6139 6199 +6139 6200 +6139 6201 +6139 6202 +6139 6203 +6139 6204 +6139 6205 +6139 6206 +6139 6207 +6139 6208 +6139 6209 +6139 6210 +6139 6211 +6139 6212 +6139 6213 +6139 6214 +6139 6215 +6139 6216 +6139 6217 +6139 6218 +6139 6219 +6139 6220 +6139 6221 +6139 6222 +6139 6223 +6139 6224 +6139 6225 +6139 6226 +6139 6227 +6139 6228 +2988 1396 +2988 1598 +2988 1821 +2988 2069 +2988 2276 +2988 3188 +2988 3433 +2988 3563 +2988 3974 +2988 4422 +2989 2232 +2989 2448 +2991 1335 +2991 2394 +2991 2663 +2991 2787 +2991 3244 +2991 3815 +2991 4423 +2991 4446 +2991 4447 +2991 4448 +4805 55 +4805 325 +4805 490 +4805 963 +4805 1287 +4805 1370 +4805 1423 +4805 3577 +4805 5506 +4810 5 +4810 143 +4810 145 +4810 368 +4810 667 +4810 740 +4810 1548 +4810 2718 +4810 3002 +4810 3048 +6141 213 +6141 1762 +6141 2179 +6141 2234 +6141 2272 +6141 2449 +6141 2797 +6141 3557 +6141 4815 +6141 6229 +499 71 +499 466 +499 500 +499 501 +499 502 +499 503 +499 504 +499 505 +499 506 +499 507 +704 612 +704 702 +704 851 +704 1531 +704 1539 +704 2621 +704 2622 +704 2623 +704 2624 +6132 3 +6132 125 +6132 176 +6132 249 +6132 251 +6132 353 +6132 559 +6132 754 +6132 1317 +6132 3371 +3776 77 +3776 262 +3776 492 +3776 1975 +3776 3343 +3776 3681 +3776 4266 +3776 4587 +3776 4664 +3776 4922 +5251 5368 +5251 5738 +5251 5739 +5251 5740 +5251 5741 +5251 5742 +5251 5743 +5251 5744 +5251 5745 +5251 5746 +4822 1054 +4822 1561 +4822 1619 +4822 2310 +4822 2652 +4822 2713 +4822 2981 +4822 4598 +4822 5511 +4822 5512 +4000 294 +4000 2964 +4000 4658 +4000 4961 +4000 5038 +4008 1199 +4008 1297 +4008 1867 +4008 2664 +4008 3071 +4008 3801 +4008 4723 +4008 5042 +4008 5043 +4008 5044 +6196 124 +6196 1396 +6196 1845 +6196 1971 +6196 2235 +6196 5110 +6196 5204 +6196 5263 +6196 6247 +6196 6248 +1495 1496 +6243 3243 +6244 3270 +6244 3808 +6245 187 +6245 367 +6245 469 +6245 474 +6245 3227 +6245 4196 +6245 4503 +6245 4985 +6245 5788 +6245 5988 +3222 296 +3222 413 +3222 1903 +3222 1939 +3222 4603 +3222 4604 +3222 4605 +3222 4606 +3222 4607 +3222 4608 +5866 2232 +5866 3481 +6296 798 +6296 849 +6296 1325 +6296 2058 +6296 5076 +6296 5236 +6296 6297 +6296 6298 +6296 6299 +5625 686 +5625 1863 +5625 1940 +5625 2794 +5625 3193 +5625 3205 +5625 4891 +5625 5912 +5625 5913 +5854 1087 +5854 3084 +5854 4068 +5854 5556 +5854 5626 +5854 5976 +5854 5977 +5854 5979 +5854 6031 +5854 6032 +5855 171 +5855 788 +5855 3378 +5855 3385 +5855 5523 +5855 5735 +5855 5850 +5855 6033 +5855 6034 +5855 6035 +5680 531 +5680 678 +5680 3124 +5680 3232 +5680 3571 +5680 4006 +5680 4193 +5680 4307 +5680 5589 +5680 5936 +6088 220 +6088 2181 +6088 2773 +6088 3858 +6088 3989 +6088 5815 +6088 6027 +6088 6099 +6088 6171 +6089 6237 +5944 969 +5944 2090 +5944 3488 +5944 3903 +5944 5536 +5944 5607 +5944 6001 +5944 6005 +5944 6076 +5944 6077 +1473 9 +1473 121 +1473 127 +1473 128 +1473 144 +1473 149 +1473 238 +1473 247 +1473 426 +1473 1317 +5372 2594 +4443 173 +4443 489 +4443 1896 +4443 1974 +4443 2646 +4443 3114 +4443 3806 +4443 4036 +4443 4275 +4443 5284 +3135 283 +3135 476 +3135 1511 +3135 1714 +3135 2860 +3135 3343 +3135 3463 +3135 4419 +3135 4551 +3135 4552 +5270 2398 +5270 3350 +5270 3385 +5270 4375 +5270 5482 +5464 2005 +5464 2532 +5464 2862 +5464 3564 +5464 3860 +5464 4633 +5464 5155 +5464 5425 +5464 5823 +5464 5835 +4798 821 +4798 1456 +4798 1842 +4798 1955 +4798 2866 +4798 2889 +4798 3233 +4798 3805 +4798 5499 +4798 5500 +5905 130 +5905 570 +5905 1261 +5905 1511 +5905 1921 +5905 3722 +5905 4485 +5905 4875 +5905 4979 +5905 5723 +1638 2017 +36 3 +36 123 +36 126 +36 145 +36 174 +36 179 +36 247 +36 249 +36 264 +36 424 +1732 9 +1732 128 +1732 148 +1732 149 +1732 175 +1732 179 +1732 238 +1732 352 +1732 353 +1732 559 +5347 20 +5347 54 +5347 146 +5347 534 +5347 749 +5347 1901 +5347 2616 +5347 3292 +5347 4051 +5347 5224 +5347 5348 +5347 5462 +5347 5542 +5347 5616 +5347 5632 +5347 5783 +5347 5784 +1011 3044 +1013 302 +1013 406 +1013 435 +1013 2119 +1013 2909 +1013 2912 +1013 2913 +1013 2914 +1013 2915 +1344 1219 +1344 1288 +1344 1309 +1344 2650 +1344 2744 +1344 2966 +1344 3018 +1344 3184 +1344 3185 +1344 3186 +2549 5 +2549 126 +2549 148 +2549 149 +2549 179 +2549 180 +2549 266 +2549 754 +2549 1245 +2549 2018 +5956 503 +5956 2154 +5956 2373 +5956 2378 +5956 2385 +5956 4944 +5956 5429 +5956 6081 +5956 6082 +5956 6083 +5957 86 +5957 1246 +5957 2008 +5957 4353 +5957 4368 +5957 5504 +5957 5715 +5957 6084 +5957 6085 +5957 6086 +3500 2127 +3500 2420 +3500 4185 +3500 4626 +3500 4782 +3500 4783 +3500 4784 +3500 4785 +3500 4786 +3500 4787 +4246 496 +4246 1224 +4246 2058 +4246 2068 +4246 2744 +4246 3117 +4246 3133 +4246 3277 +4246 5159 +4246 5160 +5026 1050 +5026 1447 +5026 1590 +5026 1689 +5026 1912 +5026 2194 +5026 2337 +5026 4133 +5026 5602 +5026 5603 +5759 704 +5759 837 +5759 1137 +5759 1928 +5759 4095 +5759 5230 +5759 5931 +5759 5968 +5759 5969 +5761 1388 +5761 2176 +5761 2385 +5761 3018 +5761 3516 +5761 4776 +5761 5050 +5761 5567 +5761 5826 +5761 5970 +4505 3456 +4506 5316 +1880 219 +1880 363 +1880 846 +1880 925 +1880 1001 +1880 2563 +1880 3105 +1880 3629 +1880 3630 +1880 3631 +5597 419 +5597 1025 +5597 1728 +5597 4779 +5597 5886 +1665 126 +1665 251 +1665 264 +1665 265 +1665 266 +1665 368 +1665 666 +1665 667 +1665 1666 +1665 1667 +5378 296 +5378 352 +5378 1358 +5378 3221 +5378 3446 +5378 3519 +5378 5432 +5378 5612 +5378 5800 +5907 796 +5907 1380 +5907 1892 +5907 4131 +5907 4268 +5907 5442 +5907 6063 +5907 6064 +5907 6065 +5994 38 +5994 132 +5994 747 +5994 1130 +5994 2556 +5994 3460 +5994 5879 +5994 6105 +5994 6106 +5994 6107 +5995 122 +5379 2579 +5495 183 +5495 610 +5495 1848 +5495 2044 +5495 3471 +5495 3516 +5495 4940 +5495 5118 +5495 5211 +5495 5847 +5915 1255 +5915 1677 +5915 2161 +5915 2612 +5915 2622 +5915 3194 +5915 3954 +5915 4754 +5915 6066 +5915 6067 +4139 268 +4139 487 +4139 1339 +4139 2220 +4139 2898 +4139 4307 +4139 4328 +4139 4382 +4139 4841 +4139 4993 +5290 3476 +3274 4644 +3378 2875 +4918 5577 +5921 1064 +5921 2450 +5921 2552 +5921 3698 +5921 4109 +5921 4507 +5921 4793 +5921 5788 +5921 6068 +5921 6069 +3037 1212 +3037 2051 +3037 2782 +3037 2796 +3037 3740 +3037 4434 +3037 4477 +3037 4478 +3037 4479 +3037 4480 +6169 83 +6169 969 +6169 1679 +6169 3190 +6169 3304 +6169 4654 +6169 4762 +6169 6065 +6169 6234 +6169 6235 +6170 717 +6170 803 +6170 1401 +6170 2621 +6170 3076 +6170 3477 +6170 3485 +6170 6238 +6170 6239 +6170 6240 +6050 307 +6050 1173 +6050 2220 +6050 6143 +6050 6144 +6050 6145 +6050 6146 +6050 6147 +6050 6148 +6050 6149 +6057 3218 +438 156 +438 456 +438 1383 +438 1522 +438 2094 +438 2220 +438 2443 +438 2444 +438 2445 +438 2446 +5829 3480 +5830 529 +5830 942 +5830 2622 +5830 2797 +5830 2798 +5830 4469 +5830 5593 +5830 6023 +5830 6024 +5830 6025 +430 826 +430 1415 +430 2235 +430 2373 +430 2416 +430 2417 +430 2418 +430 2419 +430 2420 +430 2421 +5590 706 +5590 800 +5590 1600 +5590 1766 +5590 5885 +305 587 +305 710 +305 838 +305 1498 +305 1776 +305 1850 +305 2256 +305 2257 +305 2258 +305 2259 +6191 2237 +6193 1287 +6193 2403 +6193 2868 +6193 3448 +6193 3728 +6193 5101 +6193 5615 +6193 5975 +6193 6246 +6194 4934 +6194 5049 +6194 5850 +6194 6289 +5167 1886 +5167 1940 +5167 1980 +5167 2569 +5167 3069 +5167 3125 +5167 4125 +5167 5672 +5167 5673 +5167 5674 +5206 43 +5206 169 +5206 219 +5206 246 +5206 2652 +5206 3058 +5206 3601 +5206 3925 +5206 3944 +5206 5704 +5207 544 +5207 816 +5207 1504 +5207 1764 +5207 1765 +5207 2069 +5207 4846 +5207 5499 +5207 5708 +5207 5709 +4800 1240 +4800 1559 +4800 1766 +4800 3205 +4800 3672 +4800 3678 +4800 4942 +4800 5503 +4800 5504 +4800 5505 +6012 2023 +6012 2024 +6012 3988 +6012 4058 +6012 5469 +6012 5498 +6012 6123 +6012 6124 +6012 6125 +6012 6126 +6015 235 +6015 1402 +6015 1846 +6015 1860 +6015 2086 +6015 2325 +6015 3486 +6015 3820 +6015 4754 +6015 6127 +6016 1042 +6016 1203 +6016 1255 +6016 1430 +6016 2492 +6016 3630 +6016 6041 +6016 6128 +6016 6129 +6016 6130 +6018 443 +6023 78 +6023 350 +6023 1168 +6023 4303 +6023 4423 +6023 5350 +6023 6134 +6023 6135 +6023 6136 +3244 120 +3244 257 +3244 456 +3244 872 +3244 1492 +3244 1651 +3244 1758 +3244 4626 +3244 4627 +3244 4628 +4446 4733 +6229 983 +6229 1602 +6229 1719 +6229 2693 +6229 3798 +6229 4169 +6229 4235 +6229 6186 +6229 6253 +6229 6254 +2622 889 +2622 892 +2622 1824 +2622 2193 +2622 2194 +2622 3076 +2622 3244 +2622 3999 +2622 4225 +2622 4226 +5740 2018 +5742 381 +5742 448 +5742 1311 +5742 1850 +5742 2663 +5742 3460 +5742 3801 +5742 4365 +5742 5677 +5742 5961 +5042 2968 +5044 122 +5044 123 +5044 125 +5044 144 +5044 174 +5044 352 +5044 369 +5044 424 +5044 427 +5044 2338 +5976 337 +5976 1541 +5976 1952 +5976 2417 +5976 3385 +5976 3732 +5976 4668 +5976 5086 +5976 5688 +5976 6092 +5977 243 +5977 424 +5977 1893 +5977 2448 +5977 3171 +5977 3344 +5977 3756 +5977 4213 +5977 6007 +5977 6093 +6031 4966 +5936 31 +5936 485 +5936 1127 +5936 2424 +5936 3214 +5936 3771 +5936 4016 +5936 4128 +5936 4526 +5936 5378 +6077 9 +6077 125 +6077 148 +6077 174 +6077 179 +6077 352 +6077 353 +6077 424 +6077 736 +6077 753 +4552 3813 +5499 3635 +5499 4128 +5499 4462 +5499 4670 +5499 5828 +5500 2059 +5783 351 +5783 996 +5783 3249 +5783 5779 +5783 5823 +5783 5976 +5783 5977 +5783 5978 +5783 5979 +6081 129 +6081 219 +6081 864 +6081 1812 +6081 2079 +6081 4107 +6081 4319 +6081 6046 +5160 201 +5160 400 +5160 459 +5160 1484 +5160 2023 +5160 2492 +5160 3594 +5160 3715 +5160 3849 +5160 4487 +5602 1085 +5602 1333 +3631 788 +5886 285 +5886 1592 +5886 1761 +5886 2563 +5886 2646 +5886 5487 +5886 5617 +5886 5941 +5886 6023 +5886 6041 +6063 255 +6063 275 +6063 456 +6063 527 +6063 1375 +6063 2126 +6063 5216 +6063 5288 +6063 5406 +6063 5556 +6105 6179 +1848 167 +1848 276 +1848 368 +1848 2127 +1848 2571 +1848 2787 +1848 2996 +1848 3593 +1848 3594 +5847 518 +5847 1240 +5847 1691 +5847 5511 +5847 6026 +5847 6027 +5847 6028 +5847 6029 +5847 6030 +6066 86 +6066 1246 +6066 2008 +6066 3138 +6066 3515 +6066 6071 +6066 6086 +6066 6154 +6066 6155 +6066 6156 +6067 17 +6067 123 +6067 175 +6067 249 +6067 390 +6067 423 +6067 695 +6067 697 +6067 856 +6069 158 +6069 490 +6069 650 +6069 1522 +6069 3205 +6069 5133 +6069 5469 +6069 6167 +6069 6168 +4479 183 +4479 604 +4479 913 +4479 2039 +4479 2291 +4479 3318 +4479 4378 +4479 5317 +4479 5318 +4479 5319 +6234 5552 +6239 2397 +6239 2854 +6239 5369 +6239 5475 +6239 5960 +6239 6118 +6239 6258 +6239 6259 +6239 6260 +6239 6261 +544 522 +544 2505 +544 2506 +544 2507 +544 2508 +544 2509 +544 2510 +544 2511 +544 2512 +544 2513 +5708 5943 +5505 295 +6123 523 +6123 524 +6123 1038 +6123 2046 +6123 2821 +6123 3331 +6123 4301 +6123 4383 +6123 5765 +6123 5844 +6124 311 +6124 510 +6124 962 +6124 2136 +6124 2151 +6124 4885 +6124 4915 +6124 4978 +6124 6176 +6124 6183 +6125 1377 +6125 3125 +6125 3264 +6125 3981 +6125 5535 +6125 6184 +6125 6185 +6125 6186 +6125 6187 +6125 6188 +6134 3960 +120 3 +120 121 +120 122 +120 123 +120 124 +120 125 +120 126 +120 127 +120 128 +120 129 +1758 1135 +1758 2805 +1758 3126 +1758 3520 +1758 3521 +1758 3522 +1758 3523 +1758 3524 +1758 3525 +1758 3526 +6186 57 +6186 440 +6186 1221 +6186 1618 +6186 2823 +6186 4076 +6186 5261 +6186 5824 +6186 5988 +6186 6091 +5961 1460 +5961 2881 +5961 2933 +5961 6108 +6092 4 +6092 8 +6092 126 +6092 129 +6092 144 +6092 179 +6092 1317 +6092 3022 +6092 5911 +6093 253 +6093 2292 +6093 2445 +6093 3963 +6093 4872 +6093 5269 +6093 6166 +6093 6172 +6093 6173 +1484 1581 +1484 2071 +1484 2516 +1484 2532 +1484 3079 +1484 3200 +1484 3323 +1484 3324 +1484 3325 +6155 2394 +6155 2487 +6155 3768 +6155 4080 +6155 4503 +6155 4883 +6155 5086 +6155 6230 +6155 6231 +5318 346 +5318 1861 +5318 1922 +5318 2353 +5318 2360 +5318 2456 +5318 3190 +5318 3418 +5318 5773 +5318 5774 +6258 1531 +6258 1882 +6258 2500 +6258 2693 +6258 5253 +6258 5514 +6258 5529 +6258 6271 +6258 6272 +6258 6273 +2505 23 +2505 133 +2505 916 +2505 3594 +2505 4137 +2510 49 +2510 101 +2510 1339 +2510 1628 +2510 2114 +2510 2231 +2510 3077 +2510 4138 +2510 4139 +2510 4140 +2136 3888 +6187 4170 +3521 629 +3521 711 +3521 1049 +3521 2594 +3521 2650 +3521 2779 +3521 4096 +3521 4794 +3521 4795 +3521 4796 +3522 179 +3522 1089 +3522 1604 +3522 4096 +3522 4360 +3522 4362 +3522 4487 +3522 4516 +3522 4793 +1460 1461 +4140 248 +4140 344 +4140 387 +4140 894 +4140 1942 +4140 2383 +4140 2394 +4140 3921 +4140 4210 +4140 5090 +5090 122 +5090 123 +5090 129 +5090 143 +5090 147 +5090 177 +5090 367 +5090 368 +5090 390 +5090 1245 +22 23 +22 24 +22 25 +22 26 +22 27 +22 28 +22 29 +22 30 +22 31 +22 32 +44 45 +44 46 +44 47 +44 48 +44 49 +44 50 +44 51 +44 52 +44 53 +44 54 +6273 1437 +6273 2413 +6273 2984 +6273 3733 +6273 3981 +6273 5911 +6273 6276 +6273 6277 +6273 6278 +66 16 +66 67 +66 68 +66 69 +66 70 +66 71 +66 72 +66 73 +66 74 +66 75 +98 99 +98 100 +98 101 +98 102 +98 103 +98 104 +98 105 +98 106 +98 107 +98 108 +109 110 +109 111 +109 112 +109 113 +109 114 +109 115 +109 116 +109 117 +109 118 +109 119 +6276 810 +6276 3488 +6276 3632 +6276 4926 +6276 5395 +6276 5545 +6276 5627 +6276 5710 +6276 6159 +6276 6172 +6277 1798 +6277 5040 +6277 5791 +6277 5911 +6277 6290 +192 38 +192 193 +192 194 +192 195 +192 196 +194 86 +194 139 +194 1020 +194 2135 +194 2136 +194 2137 +194 2138 +194 2139 +194 2140 +194 2141 +236 24 +236 237 +236 238 +236 239 +236 240 +236 241 +236 242 +236 243 +236 244 +236 245 +310 311 +310 312 +310 313 +310 314 +310 315 +310 316 +310 317 +310 318 +310 319 +310 320 +316 2267 +366 3 +366 124 +366 147 +366 177 +366 251 +366 264 +366 266 +366 367 +366 368 +366 369 +399 400 +399 401 +399 402 +399 403 +399 404 +399 405 +399 406 +399 407 +399 408 +399 409 +410 411 +410 412 +410 413 +410 414 +410 415 +410 416 +410 417 +410 418 +410 419 +410 420 +421 8 +421 122 +421 123 +421 125 +421 264 +421 352 +421 390 +421 422 +421 423 +421 424 +428 429 +428 430 +428 431 +428 432 +428 433 +428 434 +428 435 +428 436 +428 437 +428 438 +431 487 +431 2214 +431 2311 +431 2422 +431 2423 +431 2424 +431 2425 +431 2426 +431 2427 +431 2428 +439 440 +439 441 +439 442 +439 443 +439 444 +439 445 +439 446 +439 447 +439 448 +439 449 +516 350 +516 517 +516 518 +516 519 +516 520 +516 521 +516 522 +516 523 +516 524 +516 525 +537 538 +537 539 +537 540 +537 541 +537 542 +537 543 +537 544 +537 545 +537 546 +537 547 +636 475 +636 507 +636 637 +636 638 +636 639 +636 640 +636 641 +636 642 +636 643 +644 645 +647 216 +647 585 +647 648 +647 649 +647 650 +647 651 +647 652 +647 653 +647 654 +647 655 +719 479 +719 720 +719 721 +719 722 +719 723 +719 724 +719 725 +719 726 +719 727 +752 5 +752 180 +752 247 +752 250 +752 351 +752 426 +752 554 +752 753 +752 754 +752 755 +775 776 +797 289 +797 420 +797 460 +797 463 +797 798 +797 799 +797 800 +797 801 +797 802 +797 803 +896 563 +896 897 +896 898 +896 899 +896 900 +896 901 +896 902 +896 903 +896 904 +896 905 +929 335 +929 930 +929 931 +929 932 +929 933 +929 934 +929 935 +929 936 +929 937 +948 31 +948 862 +948 949 +948 950 +948 951 +949 1028 +949 1661 +949 2697 +949 2829 +949 2830 +949 2831 +949 2832 +949 2833 +949 2834 +949 2835 +950 870 +950 1570 +950 1631 +950 1747 +950 2793 +950 2824 +950 2825 +950 2826 +950 2827 +950 2828 +2831 133 +2831 397 +2831 398 +2831 982 +2831 3221 +2831 3981 +2831 4326 +2831 4327 +2831 4328 +2831 4329 +2835 815 +2835 1197 +2835 1234 +2835 2821 +2835 3351 +2835 4191 +2835 4330 +2835 4331 +2835 4332 +2835 4333 +961 8 +961 262 +961 280 +961 560 +961 962 +961 963 +961 964 +961 965 +961 966 +961 967 +964 364 +964 697 +964 2213 +964 2844 +964 2845 +964 2846 +964 2847 +964 2848 +964 2849 +964 2850 +992 3 +992 174 +992 251 +992 265 +992 351 +992 369 +992 390 +992 697 +992 947 +992 993 +994 995 +999 716 +999 1000 +999 1001 +999 1002 +999 1003 +999 1004 +999 1005 +999 1006 +999 1007 +999 1008 +1075 116 +1075 1076 +1075 1077 +1075 1078 +1075 1079 +1075 1080 +1075 1081 +1075 1082 +1075 1083 +1080 2868 +1098 1051 +1098 1099 +1098 1100 +1098 1101 +1098 1102 +1098 1103 +1098 1104 +1098 1105 +1098 1106 +1108 467 +1108 1109 +1108 1110 +1108 1111 +1108 1112 +1108 1113 +1108 1114 +1108 1115 +1108 1116 +1111 435 +1111 1618 +1111 1645 +1111 1982 +1111 2163 +1111 3018 +1111 3019 +1111 3020 +1111 3021 +1111 3022 +1113 4 +1113 124 +1113 249 +1113 266 +1113 367 +1113 368 +1113 369 +1113 423 +1113 1245 +1117 29 +1117 124 +1117 126 +1117 496 +1117 1118 +1117 1119 +1117 1120 +1117 1121 +1117 1122 +1117 1123 +1161 3 +1161 5 +1161 8 +1161 121 +1161 122 +1161 124 +1161 144 +1161 145 +1161 177 +1161 248 +1181 1182 +1181 1183 +1181 1184 +1181 1185 +1181 1186 +1181 1187 +1181 1188 +1181 1189 +1181 1190 +1181 1191 +1189 3054 +1200 229 +1200 341 +1200 1201 +1200 1202 +1200 1203 +1200 1204 +1200 1205 +1200 1206 +1200 1207 +1200 1208 +1204 1097 +1204 1322 +1204 2887 +1204 3098 +1204 3099 +1204 3100 +1204 3101 +1204 3102 +1204 3103 +1204 3104 +1205 141 +1205 1849 +1205 1850 +1205 2996 +1205 3065 +1205 3066 +1205 3067 +1205 3068 +1205 3069 +1205 3070 +1207 1749 +1207 2739 +1207 3071 +1207 3072 +1207 3073 +1207 3074 +1207 3075 +1207 3076 +1207 3077 +1207 3078 +3074 289 +3074 979 +3074 1228 +3074 4288 +3074 4493 +3078 75 +3078 108 +3078 272 +3078 274 +3078 477 +3078 814 +3078 1542 +3078 2248 +3078 4019 +3078 4500 +4500 120 +4500 1666 +4500 1884 +4500 4002 +4500 4799 +4500 4841 +4500 5187 +4500 5283 +4500 5315 +4500 5327 +1884 122 +1884 123 +1884 124 +1884 125 +1884 127 +1884 128 +1884 129 +1884 144 +1884 264 +1884 427 +1218 58 +1218 165 +1218 292 +1218 514 +1218 941 +1218 1000 +1218 1219 +1218 1220 +1218 1221 +1222 49 +1222 78 +1222 468 +1222 1223 +1222 1224 +1222 1225 +1222 1226 +1222 1227 +1222 1228 +1222 1229 +1237 842 +1237 852 +1237 1238 +1237 1239 +1237 1240 +1237 1241 +1237 1242 +1237 1243 +1237 1244 +1241 1492 +1247 158 +1247 582 +1247 583 +1247 955 +1247 1032 +1247 1068 +1247 1070 +1247 1248 +1247 1249 +1247 1250 +1260 301 +1260 1084 +1260 1086 +1260 1261 +1260 1262 +1260 1263 +1260 1264 +1260 1265 +1260 1266 +1286 391 +1286 1056 +1286 1100 +1286 1287 +1286 1288 +1286 1289 +1286 1290 +1286 1291 +1286 1292 +1286 1293 +1294 148 +1294 369 +1294 438 +1294 690 +1294 1069 +1294 1295 +1294 1296 +1294 1297 +1294 1298 +1294 1299 +1307 240 +1307 1308 +1307 1309 +1307 1310 +1307 1311 +1307 1312 +1307 1313 +1307 1314 +1307 1315 +1307 1316 +1308 2661 +1308 2922 +1308 3181 +1308 3182 +1308 3183 +1398 554 +1398 736 +1398 1022 +1398 1399 +1398 1400 +1398 1401 +1398 1402 +1399 387 +1399 416 +1399 765 +1399 806 +1399 3242 +1399 3243 +1399 3244 +1399 3245 +1399 3246 +1399 3247 +3246 268 +3246 576 +3246 840 +3246 1797 +3246 3956 +3246 4608 +3246 4629 +3246 4630 +3246 4631 +3246 4632 +4631 251 +4631 664 +4631 803 +4631 2218 +4631 2285 +4631 2309 +4631 4137 +4631 5393 +4631 5394 +4631 5395 +1403 132 +1403 188 +1403 926 +1403 1404 +1403 1405 +1403 1406 +1403 1407 +1403 1408 +1403 1409 +1403 1410 +1445 326 +1445 502 +1445 578 +1445 1446 +1445 1447 +1445 1448 +1445 1449 +1445 1450 +1445 1451 +1445 1452 +1453 221 +1453 476 +1453 1195 +1453 1295 +1453 1454 +1453 1455 +1453 1456 +1453 1457 +1453 1458 +1453 1459 +1462 1463 +1462 1464 +1462 1465 +1462 1466 +1462 1467 +1462 1468 +1462 1469 +1462 1470 +1462 1471 +1462 1472 +1474 158 +1478 110 +1478 798 +1478 1095 +1478 1215 +1478 1479 +1478 1480 +1478 1481 +1478 1482 +1478 1483 +1478 1484 +1494 5 +1494 7 +1494 125 +1494 144 +1494 149 +1494 174 +1494 179 +1494 424 +1494 559 +1494 667 +1497 125 +1497 828 +1497 1498 +1497 1499 +1497 1500 +1497 1501 +1497 1502 +1497 1503 +1497 1504 +1497 1505 +1520 609 +1520 614 +1520 883 +1520 958 +1520 1521 +1520 1522 +1520 1523 +1520 1524 +1520 1525 +1520 1526 +1527 3 +1527 454 +1527 462 +1527 691 +1527 970 +1527 1025 +1527 1492 +1527 1528 +1527 1529 +1527 1530 +1562 391 +1562 405 +1562 824 +1562 1105 +1562 1563 +1562 1564 +1562 1565 +1562 1566 +1562 1567 +1562 1568 +1566 297 +1566 338 +1566 1192 +1566 1425 +1566 2450 +1566 3351 +1566 3352 +1566 3353 +1566 3354 +1566 3355 +1579 391 +1579 602 +1579 1240 +1579 1246 +1579 1385 +1579 1580 +1579 1581 +1579 1582 +1579 1583 +1582 355 +1582 1791 +1582 1797 +1582 2285 +1582 2309 +1582 2799 +1582 3282 +1582 3371 +1582 3372 +1596 298 +1596 465 +1596 1597 +1596 1598 +1596 1599 +1596 1600 +1596 1601 +1596 1602 +1596 1603 +1596 1604 +1603 5 +1603 8 +1603 9 +1603 147 +1603 149 +1603 179 +1603 252 +1603 426 +1603 856 +1603 2098 +1625 29 +1625 303 +1625 364 +1625 1061 +1625 1626 +1625 1627 +1625 1628 +1625 1629 +1625 1630 +1625 1631 +1648 1649 +1649 297 +1649 324 +1649 1044 +1649 1157 +1649 2793 +1649 3396 +1649 3397 +1649 3398 +3396 163 +3396 266 +3396 894 +3396 2196 +3396 2221 +3396 2443 +3396 4402 +3396 4689 +3396 4733 +3396 4734 +3398 341 +3398 1859 +3398 1955 +3398 2891 +3398 2905 +3398 3788 +3398 3822 +3398 4743 +3398 4744 +3398 4745 +4745 56 +4745 738 +4745 823 +4745 898 +4745 1568 +4745 2024 +4745 3681 +4745 4337 +4745 4769 +4745 5461 +1657 89 +1657 547 +1657 1340 +1657 1658 +1657 1659 +1657 1660 +1657 1661 +1657 1662 +1657 1663 +1657 1664 +1663 266 +1663 1152 +1663 2257 +1663 2429 +1663 3140 +1663 3571 +1668 71 +1668 1353 +1668 1669 +1668 1670 +1668 1671 +1674 513 +1674 1587 +1674 1675 +1674 1676 +1674 1677 +1674 1678 +1674 1679 +1674 1680 +1674 1681 +1674 1682 +1680 2131 +1683 1684 +1692 191 +1692 280 +1692 1084 +1692 1256 +1692 1693 +1692 1694 +1692 1695 +1692 1696 +1692 1697 +1692 1698 +1712 1713 +1713 469 +1713 514 +1713 1219 +1713 1252 +1713 1776 +1713 2163 +1713 3472 +1713 3473 +1713 3474 +1713 3475 +1722 1723 +1723 4 +1723 7 +1723 149 +1723 175 +1723 179 +1723 252 +1723 266 +1723 352 +1723 424 +1742 577 +1742 813 +1742 938 +1742 1408 +1742 1600 +1742 1743 +1742 1744 +1742 1745 +1742 1746 +1742 1747 +1746 255 +1746 406 +1746 538 +1746 889 +1746 2084 +1746 2314 +1746 2547 +1746 3503 +1746 3504 +1746 3505 +3505 3 +3505 143 +3505 145 +3505 177 +3505 251 +3505 353 +3505 753 +3505 754 +3505 3002 +3505 3132 +1748 255 +1748 916 +1748 1028 +1748 1044 +1748 1564 +1748 1749 +1748 1750 +1748 1751 +1748 1752 +1753 182 +1753 1754 +1753 1755 +1753 1756 +1753 1757 +1753 1758 +1753 1759 +1753 1760 +1753 1761 +1753 1762 +1785 174 +1785 1574 +1785 1786 +1785 1787 +1785 1788 +1785 1789 +1785 1790 +1785 1791 +1785 1792 +1785 1793 +1793 1248 +1793 1901 +1793 2336 +1793 2543 +1793 2713 +1793 2818 +1793 2838 +1793 3541 +1834 224 +1834 275 +1834 1287 +1834 1835 +1834 1836 +1834 1837 +1834 1838 +1834 1839 +1834 1840 +1839 53 +1839 222 +1839 818 +1839 2359 +1839 2377 +1839 2683 +1839 2767 +1839 3590 +1839 3591 +1839 3592 +1847 141 +1847 977 +1847 1848 +1847 1849 +1847 1850 +1847 1851 +1847 1852 +1847 1853 +1847 1854 +1847 1855 +1856 289 +1856 1211 +1856 1857 +1856 1858 +1856 1859 +1856 1860 +1856 1861 +1856 1862 +1856 1863 +1857 757 +1857 758 +1857 884 +1857 2176 +1857 3609 +1857 3610 +1857 3611 +1857 3612 +1857 3613 +1857 3614 +1864 58 +1864 924 +1864 1297 +1864 1606 +1864 1608 +1864 1865 +1864 1866 +1864 1867 +1864 1868 +1864 1869 +1876 1288 +1877 477 +1877 534 +1877 1733 +1877 1878 +1877 1879 +1877 1880 +1877 1881 +1877 1882 +1877 1883 +1877 1884 +5537 477 +5537 1194 +5537 1365 +5537 2345 +5537 2955 +5537 5538 +5537 5539 +5537 5540 +5537 5541 +5537 5542 +5538 162 +5538 223 +5538 477 +5538 2345 +5538 3081 +5538 3989 +5538 5058 +5538 5868 +5538 5869 +5538 5870 +5539 125 diff --git a/snap-python/source/dev/test/genrnd.py b/snap-python/source/dev/test/genrnd.py new file mode 100644 index 0000000000000000000000000000000000000000..4c1fe74d4acbaacc0d9aff1ff3794d72fa17f928 --- /dev/null +++ b/snap-python/source/dev/test/genrnd.py @@ -0,0 +1,36 @@ +import random +import sys + +sys.path.append("../swig") + +import snap + +def GenRndGnm(): + Graph = snap.GenRndGnm_PNGraph(1000,10000) + print "Graph", str(type(Graph)), Graph.GetNodes(), Graph.GetEdges() + + # save the graph + FName = "test2.graph" + print "Save", FName + + FOut = snap.TFOut(snap.TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + print "Read", FName + FIn = snap.TFIn(snap.TStr(FName)) + #Graph2 = snap.TNGraph(FIn) + #Graph2 = snap.TNGraph.Load(FIn) + Graph2 = snap.PNGraph.New() + print "Graph2", str(type(Graph2)) + print str(dir(Graph2)) + Graph2.Load(FIn) + #Graph2 = snap.Load_PNGraph(FIn) + #print "Read end", FName + #print "Graph2", str(type(Graph2)), Graph2.GetNodes(), Graph2.GetEdges() + +if __name__ == '__main__': + print "----- GenRndGnm -----" + GenRndGnm() + diff --git a/snap-python/source/dev/test/hash.py b/snap-python/source/dev/test/hash.py new file mode 100644 index 0000000000000000000000000000000000000000..ddcc383d01a47b8470221feb6d330dc503133d3b --- /dev/null +++ b/snap-python/source/dev/test/hash.py @@ -0,0 +1,126 @@ +import random +import os +import sys +import time + +sys.path.append("../swig") +import snap + +numnodes = 100 +valrange = numnodes / 5 + +Edges = snap.TIntV() + +for i in range(0,numnodes): + Edges.Add(int(random.random() * valrange)) + +d = {} +for i in range(0,numnodes,2): + #print "Edges", i/2, Edges.GetVal(i).Val, Edges.GetVal(i+1).Val + d[(Edges.GetVal(i).Val,Edges.GetVal(i+1).Val)] = 1 + +Hash = snap.TIntH() +#snap.Edge2Hash(Edges,Hash) + +Hash.AddDat(3,5) +Hash.AddDat(4,6) +Hash.AddDat(1,8) +Hash.AddDat(6,2) + +print "type", type(Edges), type(Hash) + +#for i in range(0,valrange): +# Vec2 = Hash.GetDat(i) +# print i, Vec2.Val + +print "len", Hash.Len() +Iter = Hash.BegI() +Key = Iter.GetKey().Val +Value = Iter.GetDat().Val +print "iter", Key, Value + +print "Iter < Hash.EndI", Iter < Hash.EndI() +#while Iter < Hash.EndI(): +while not Iter.IsEnd(): + Key = Iter.GetKey().Val + Value = Iter.GetDat().Val + print Key, Value + + Iter.Next() + +sys.exit(0) + +AdjLists = snap.TIntIntVH() +print "type", type(Edges), type(AdjLists) +snap.GetAdjLists(Edges, AdjLists) + +size = 0 +for i in range(0,valrange): + Vec2 = AdjLists.GetDat(i) + size += Vec2.Len() + + for j in range(0,Vec2.Len()): + print i, Vec2.GetVal(j).Val + +print "done", Edges.Len(), AdjLists.Len(), size, len(d) + +sys.exit(0) + +#print "dir(snap.TIntV)", dir(snap.TIntV) +Vec1 = snap.TIntV(numnodes) +#print "dir(Vec1)", dir(Vec1) +print "Len Vec1", Vec1.Len() + +#print "dir(snap.TIntIntVV)", dir(snap.TIntIntVV) +Vec2 = snap.TIntIntVV(numtask) +#print "dir(Vec2)", dir(Vec2) +print "Len Vec2", Vec2.Len() + +print "Vec1", type(Vec1) + +snap.GetDegrees(Vec1, 10.0, 1.5) + +for i in range(0,Vec1.Len()): + print "Vec1", i, Vec1.GetVal(i).Val + +snap.AssignRndTask(Vec1, Vec2) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print "Vec3", i, Vec3.Len() + + for j in range(0,Vec3.Len()): + print "Vec4", i, j, Vec3.GetVal(j).Val + +sys.exit(0) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print "Vec3", i, Vec3.Len() + + h = httplib.HTTPConnection("rokl1.stanford.edu",8100) + #h.request("POST","/msg/GenStubs-0/GenTasks-2","12345",{"User-agent": "007"}) + h.connect() + url = "/msg/GenStubs-0/GenTasks-%d" % (i) + h.putrequest("POST",url) + h.putheader("User-Agent", "007") + #h.putheader("Content-Length", "9") + h.putheader("Content-Length", str(Vec3.GetMemSize())) + h.endheaders() + + fileno = h.sock.fileno() + print "fileno", fileno + + n = Vec3.Send(fileno) + #n = os.write(fileno,"123abcdef") + print n + + #h.send("abc123") + + res = h.getresponse() + print res.status, res.reason + data = res.read() + print len(data) + print data + + diff --git a/snap-python/source/dev/test/hkey.py b/snap-python/source/dev/test/hkey.py new file mode 100644 index 0000000000000000000000000000000000000000..bfcb4c247c22414918a88f0d0213f2c6777c0ac7 --- /dev/null +++ b/snap-python/source/dev/test/hkey.py @@ -0,0 +1,27 @@ +import snap + +h = snap.TIntIntVH() +print h.Len() + +for i in range(0,10): + k = h.AddKey(snap.TInt(i)) + v = h.GetDat(snap.TInt(i)) + + for j in range(0,i+3): + v.Add(j) + + print i,k + +print h.Len() + +print "-----------" + +for i in range(0,10): + j = h.GetKeyId(snap.TInt(i)) + print j + + v = h.GetDat(snap.TInt(i)) + #print type(j), type(v) + print v.Len() + print + diff --git a/snap-python/source/dev/test/info b/snap-python/source/dev/test/info new file mode 100644 index 0000000000000000000000000000000000000000..b0c410eaafbff0f9073a162c0815a1b886053f82 --- /dev/null +++ b/snap-python/source/dev/test/info @@ -0,0 +1,14 @@ +basic graph info (e.g. iteration, triads): Directed + Nodes: 45103 + Edges: 117746 + Zero Deg Nodes: 242 + Zero InDeg Nodes: 3311 + Zero OutDeg Nodes: 3356 + NonZero In-Out Deg Nodes: 38678 + Unique directed edges: 117746 + Unique undirected edges: 117742 + Self Edges: 0 + BiDir Edges: 8 + Closed triangles 23 + Open triangles 615137 + Frac. of closed triads 0.000037 diff --git a/snap-python/source/dev/test/install-dir.py b/snap-python/source/dev/test/install-dir.py new file mode 100644 index 0000000000000000000000000000000000000000..a30153b9cc21b0a67d69343a3a49f5c5282ef4db --- /dev/null +++ b/snap-python/source/dev/test/install-dir.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python + +""" +print out the Python install directory +""" + +import inspect +import os +import sys + +# get the installation directory + +# get the system Python directory +sys_install = os.path.join( + os.path.dirname(inspect.getfile(inspect)), + "site-packages") + +# check for an alternative Python user directory +user_install = sys_install +for p in sys.path: + n = p.find("site-packages") + if n > 0: + user_install = os.path.join(p[:n],"site-packages") + break + +print "install-prefix", user_install + diff --git a/snap-python/source/dev/test/memtest.py b/snap-python/source/dev/test/memtest.py new file mode 100644 index 0000000000000000000000000000000000000000..2f5ef6f3f12352094df1581952b96617a9e7b5f1 --- /dev/null +++ b/snap-python/source/dev/test/memtest.py @@ -0,0 +1,28 @@ +import os +import sys + +sys.path.append("../swig") + +import snap + +if __name__ == '__main__': + + if len(sys.argv) < 2: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + gname = sys.argv[1] + tname = snap.TStr(gname) + + count = 0 + #l = [] + while 1: + g = snap.LoadEdgeList_PNGraph(tname, 0, 1) + #l.append(g) + + count += 1 + if count % 100 == 0: + print count + + if count > 1000: + break diff --git a/snap-python/source/dev/test/printstat.py b/snap-python/source/dev/test/printstat.py new file mode 100644 index 0000000000000000000000000000000000000000..264aaa6df71c6b7affff79247ed62621b5f7b717 --- /dev/null +++ b/snap-python/source/dev/test/printstat.py @@ -0,0 +1,22 @@ +import os +import sys + +sys.path.append("../swig") + +import snap + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + gname = sys.argv[1] + header = sys.argv[2] + + tname = snap.TStr(gname) + tlabel = snap.TStr(os.path.splitext(gname)[0]) + theader = snap.TStr(header) + + g = snap.LoadEdgeList_PNGraph(tname, 0, 1) + snap.PrintGraphStatTable_PNGraph(g,tlabel,theader) \ No newline at end of file diff --git a/snap-python/source/dev/test/readvec.py b/snap-python/source/dev/test/readvec.py new file mode 100644 index 0000000000000000000000000000000000000000..7f2f225df2f004ef420edd5430ded9c2d9dd935c --- /dev/null +++ b/snap-python/source/dev/test/readvec.py @@ -0,0 +1,24 @@ +import os +import sys +import time + +sys.path.append("/home/rok/git/rok/snapworld") +import snap + +if __name__ == '__main__': + + if len(sys.argv) < 2: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + fname = sys.argv[1] + + FIn = snap.TFIn(snap.TStr(fname)) + Vec = snap.TIntV(FIn) + print "len", Vec.Len() + + Vec.Sort() + + for i in range(0,Vec.Len()): + print "Vec", i, Vec.GetVal(i).Val + diff --git a/snap-python/source/dev/test/results-sheridan/coeff.txt b/snap-python/source/dev/test/results-sheridan/coeff.txt new file mode 100644 index 0000000000000000000000000000000000000000..ad92700ff0a9499b04e324b73e749354a77bc091 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/coeff.txt @@ -0,0 +1 @@ +8 0.0000 -0.0000 0.0225 diff --git a/snap-python/source/dev/test/results-sheridan/plot_CDD.png b/snap-python/source/dev/test/results-sheridan/plot_CDD.png new file mode 100644 index 0000000000000000000000000000000000000000..1024aced9cd84a058860d8872b233a8f45b5fbc6 Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_CDD.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_ClustCoef.png b/snap-python/source/dev/test/results-sheridan/plot_ClustCoef.png new file mode 100644 index 0000000000000000000000000000000000000000..0cd8e9bde82ccce8ea54b7b6c554e4858f61aab2 Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_ClustCoef.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_DD.png b/snap-python/source/dev/test/results-sheridan/plot_DD.png new file mode 100644 index 0000000000000000000000000000000000000000..695e35dc03d11f5032ac6c0b426746aae42957d7 Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_DD.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_HOP.png b/snap-python/source/dev/test/results-sheridan/plot_HOP.png new file mode 100644 index 0000000000000000000000000000000000000000..88750aa0619ab93f87051716a290273176f8f5d0 Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_HOP.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_SVal.png b/snap-python/source/dev/test/results-sheridan/plot_SVal.png new file mode 100644 index 0000000000000000000000000000000000000000..d012bbe9e93f09512728e24174e14384bd0b18ff Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_SVal.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_SVec.png b/snap-python/source/dev/test/results-sheridan/plot_SVec.png new file mode 100644 index 0000000000000000000000000000000000000000..848689b45c9fc5248bc66ca6c35497d8a54a0aa7 Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_SVec.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_Scc.png b/snap-python/source/dev/test/results-sheridan/plot_Scc.png new file mode 100644 index 0000000000000000000000000000000000000000..135f289191537bd67f3c59d7aca295a0e47276ef Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_Scc.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_Wcc.png b/snap-python/source/dev/test/results-sheridan/plot_Wcc.png new file mode 100644 index 0000000000000000000000000000000000000000..f5bacd7f9d4ddb99f82f1f08df6227b596619ee5 Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_Wcc.png differ diff --git a/snap-python/source/dev/test/results-sheridan/plot_info.png b/snap-python/source/dev/test/results-sheridan/plot_info.png new file mode 100644 index 0000000000000000000000000000000000000000..7227f854e3b96701339860ec6c787e3fa0a6e80a Binary files /dev/null and b/snap-python/source/dev/test/results-sheridan/plot_info.png differ diff --git a/snap-python/source/dev/test/results-sheridan/pref-CDD.txt b/snap-python/source/dev/test/results-sheridan/pref-CDD.txt new file mode 100644 index 0000000000000000000000000000000000000000..61720b3d8573cce5c17fb7281393050fb6f8f00a --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-CDD.txt @@ -0,0 +1,8 @@ +29 73 0.00080 +464 1167 0.00201 +5642 14853 0.00991 +16832 43002 0.03234 +31 34 0.00086 +289 653 0.00118 +3319 7500 0.00732 +95697 257068 0.23209 diff --git a/snap-python/source/dev/test/results-sheridan/pref-ClustCoef.txt b/snap-python/source/dev/test/results-sheridan/pref-ClustCoef.txt new file mode 100644 index 0000000000000000000000000000000000000000..5df336bdb9f1e32e57b7d0c8e3379fbe058edc16 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-ClustCoef.txt @@ -0,0 +1,8 @@ +29 73 0.00047 +464 1167 0.00259 +5642 14853 0.03049 +16832 43002 0.09886 +31 34 0.00053 +289 653 0.00179 +3319 7500 0.01814 +95697 257068 0.73708 diff --git a/snap-python/source/dev/test/results-sheridan/pref-DD.txt b/snap-python/source/dev/test/results-sheridan/pref-DD.txt new file mode 100644 index 0000000000000000000000000000000000000000..77717afd9572d47b15298a4c1adf88a1b9e94c46 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-DD.txt @@ -0,0 +1,8 @@ +29 73 0.00070 +464 1167 0.00140 +5642 14853 0.00959 +16832 43002 0.02671 +31 34 0.00065 +289 653 0.00170 +3319 7500 0.00619 +95697 257068 0.22465 diff --git a/snap-python/source/dev/test/results-sheridan/pref-HOP.txt b/snap-python/source/dev/test/results-sheridan/pref-HOP.txt new file mode 100644 index 0000000000000000000000000000000000000000..9a5cb3cef077ef9b4d25cf594e5a883a9ea5ee95 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-HOP.txt @@ -0,0 +1,8 @@ +29 73 0.00059 +464 1167 0.00726 +5642 14853 0.10424 +16832 43002 0.33599 +31 34 0.00077 +289 653 0.00572 +3319 7500 0.06101 +95697 257068 2.86075 diff --git a/snap-python/source/dev/test/results-sheridan/pref-SVal.txt b/snap-python/source/dev/test/results-sheridan/pref-SVal.txt new file mode 100644 index 0000000000000000000000000000000000000000..f76ac0a1a9d9a5cfb5fc61b5c2095ac760c1483d --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-SVal.txt @@ -0,0 +1,8 @@ +29 73 0.00210 +464 1167 1.31384 +5642 14853 1.87873 +16832 43002 3.24008 +31 34 0.00245 +289 653 0.49540 +3319 7500 1.63535 +95697 257068 15.98572 diff --git a/snap-python/source/dev/test/results-sheridan/pref-SVec.txt b/snap-python/source/dev/test/results-sheridan/pref-SVec.txt new file mode 100644 index 0000000000000000000000000000000000000000..64dd07a50d610db55d15c7f44107ae1883d45fdf --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-SVec.txt @@ -0,0 +1,8 @@ +29 73 0.00259 +464 1167 5.79216 +5642 14853 0.05256 +16832 43002 0.16061 +31 34 0.00436 +289 653 1.39118 +3319 7500 0.03084 +95697 257068 1.40444 diff --git a/snap-python/source/dev/test/results-sheridan/pref-Scc.txt b/snap-python/source/dev/test/results-sheridan/pref-Scc.txt new file mode 100644 index 0000000000000000000000000000000000000000..378cdfe390764a26795624f050f8fc45e04ed820 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-Scc.txt @@ -0,0 +1,8 @@ +29 73 0.00040 +464 1167 0.00158 +5642 14853 0.01746 +16832 43002 0.05174 +31 34 0.00044 +289 653 0.00138 +3319 7500 0.01019 +95697 257068 0.40017 diff --git a/snap-python/source/dev/test/results-sheridan/pref-Wcc.txt b/snap-python/source/dev/test/results-sheridan/pref-Wcc.txt new file mode 100644 index 0000000000000000000000000000000000000000..ad7c6519934644329d288a5b7fa68608329eeff8 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-Wcc.txt @@ -0,0 +1,8 @@ +29 73 0.00039 +464 1167 0.00114 +5642 14853 0.01145 +16832 43002 0.03249 +31 34 0.00037 +289 653 0.00120 +3319 7500 0.00671 +95697 257068 0.27814 diff --git a/snap-python/source/dev/test/results-sheridan/pref-info.txt b/snap-python/source/dev/test/results-sheridan/pref-info.txt new file mode 100644 index 0000000000000000000000000000000000000000..f838d28e64fd5499bf81def4a84a2dd2c713edac --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/pref-info.txt @@ -0,0 +1,8 @@ +29 73 0.00029 +464 1167 0.00314 +5642 14853 0.04465 +16832 43002 0.16381 +31 34 0.00026 +289 653 0.00315 +3319 7500 0.02551 +95697 257068 1.37540 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-CDD.txt b/snap-python/source/dev/test/results-sheridan/rmat-CDD.txt new file mode 100644 index 0000000000000000000000000000000000000000..cef8d97267b5aee552b19e243be08710fcda55d5 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-CDD.txt @@ -0,0 +1,8 @@ +94 194 0.00089 +882 2527 0.00237 +5407 9373 0.01073 +10584 15902 0.01667 +55 132 0.00083 +206 571 0.00148 +8085 16329 0.01660 +18011 18732 0.02348 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-ClustCoef.txt b/snap-python/source/dev/test/results-sheridan/rmat-ClustCoef.txt new file mode 100644 index 0000000000000000000000000000000000000000..ff1aab6ec5eacb13960cb2f1138de37f23d04038 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-ClustCoef.txt @@ -0,0 +1,8 @@ +94 194 0.00054 +882 2527 0.00414 +5407 9373 0.01453 +10584 15902 0.02240 +55 132 0.00069 +206 571 0.00111 +8085 16329 0.02682 +18011 18732 0.02894 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-DD.txt b/snap-python/source/dev/test/results-sheridan/rmat-DD.txt new file mode 100644 index 0000000000000000000000000000000000000000..c1a761b8433c3cf1ec48a9951f5f0eab5ed8b722 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-DD.txt @@ -0,0 +1,8 @@ +94 194 0.00079 +882 2527 0.00250 +5407 9373 0.01222 +10584 15902 0.01521 +55 132 0.00072 +206 571 0.00108 +8085 16329 0.01618 +18011 18732 0.02332 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-HOP.txt b/snap-python/source/dev/test/results-sheridan/rmat-HOP.txt new file mode 100644 index 0000000000000000000000000000000000000000..d3f13c35e3f2f890a712c3d6cebcead796e8ae63 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-HOP.txt @@ -0,0 +1,8 @@ +94 194 0.00121 +882 2527 0.00971 +5407 9373 0.06258 +10584 15902 0.12365 +55 132 0.00095 +206 571 0.00206 +8085 16329 0.09292 +18011 18732 0.17774 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-SVal.txt b/snap-python/source/dev/test/results-sheridan/rmat-SVal.txt new file mode 100644 index 0000000000000000000000000000000000000000..937e6c302587ad5e10b7e55b1b91080849625179 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-SVal.txt @@ -0,0 +1,8 @@ +94 194 0.03391 +882 2527 1.34530 +5407 9373 1.58710 +10584 15902 1.95610 +55 132 0.00754 +206 571 0.19242 +8085 16329 1.73450 +18011 18732 2.06363 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-SVec.txt b/snap-python/source/dev/test/results-sheridan/rmat-SVec.txt new file mode 100644 index 0000000000000000000000000000000000000000..db702626af20d4e97abf4e6a68ef0b77126c9e6b --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-SVec.txt @@ -0,0 +1,8 @@ +94 194 0.03390 +882 2527 0.00857 +5407 9373 0.03159 +10584 15902 0.06091 +55 132 0.00830 +206 571 0.35405 +8085 16329 0.05369 +18011 18732 0.09114 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-Scc.txt b/snap-python/source/dev/test/results-sheridan/rmat-Scc.txt new file mode 100644 index 0000000000000000000000000000000000000000..11bc5b815f91c899e1c13e90bc9d04e7908cee55 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-Scc.txt @@ -0,0 +1,8 @@ +94 194 0.00052 +882 2527 0.00255 +5407 9373 0.01089 +10584 15902 0.02036 +55 132 0.00053 +206 571 0.00079 +8085 16329 0.01926 +18011 18732 0.02721 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-Wcc.txt b/snap-python/source/dev/test/results-sheridan/rmat-Wcc.txt new file mode 100644 index 0000000000000000000000000000000000000000..414f5f77c2f884d765e903992f0689d699787dc4 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-Wcc.txt @@ -0,0 +1,8 @@ +94 194 0.00047 +882 2527 0.00221 +5407 9373 0.01024 +10584 15902 0.01674 +55 132 0.00042 +206 571 0.00094 +8085 16329 0.01573 +18011 18732 0.02182 diff --git a/snap-python/source/dev/test/results-sheridan/rmat-info.txt b/snap-python/source/dev/test/results-sheridan/rmat-info.txt new file mode 100644 index 0000000000000000000000000000000000000000..9eb565fa68457b656353fa25ba5b32b143238d38 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/rmat-info.txt @@ -0,0 +1,8 @@ +94 194 0.00043 +882 2527 0.00494 +5407 9373 0.01642 +10584 15902 0.02660 +55 132 0.00032 +206 571 0.00114 +8085 16329 0.02848 +18011 18732 0.03069 diff --git a/snap-python/source/dev/test/results-sheridan/sw-CDD.txt b/snap-python/source/dev/test/results-sheridan/sw-CDD.txt new file mode 100644 index 0000000000000000000000000000000000000000..b34877d997548e6c7d27a86a3fecca85fef27702 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-CDD.txt @@ -0,0 +1,12 @@ +94 167 0.00081 +525 803 0.00097 +4711 8894 0.00469 +12503 23784 0.01124 +53 93 0.00059 +688 753 0.00091 +2838 6843 0.00301 +39383 73448 0.03602 +83 218 0.00072 +967 1673 0.00188 +4352 8447 0.00376 +45103 117746 0.06317 diff --git a/snap-python/source/dev/test/results-sheridan/sw-ClustCoef.txt b/snap-python/source/dev/test/results-sheridan/sw-ClustCoef.txt new file mode 100644 index 0000000000000000000000000000000000000000..d6ba7e020e30e5fd2d4c919492185a00a324a14b --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-ClustCoef.txt @@ -0,0 +1,12 @@ +94 167 0.00051 +525 803 0.00086 +4711 8894 0.00659 +12503 23784 0.01779 +53 93 0.00038 +688 753 0.00088 +2838 6843 0.00509 +39383 73448 0.08431 +83 218 0.00057 +967 1673 0.00160 +4352 8447 0.00621 +45103 117746 0.12974 diff --git a/snap-python/source/dev/test/results-sheridan/sw-DD.txt b/snap-python/source/dev/test/results-sheridan/sw-DD.txt new file mode 100644 index 0000000000000000000000000000000000000000..3a0643037ec8d4676794011f420f4b8d9724ecec --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-DD.txt @@ -0,0 +1,12 @@ +94 167 0.00099 +525 803 0.00132 +4711 8894 0.00465 +12503 23784 0.00905 +53 93 0.00059 +688 753 0.00115 +2838 6843 0.00293 +39383 73448 0.03701 +83 218 0.00069 +967 1673 0.00127 +4352 8447 0.00362 +45103 117746 0.06338 diff --git a/snap-python/source/dev/test/results-sheridan/sw-HOP.txt b/snap-python/source/dev/test/results-sheridan/sw-HOP.txt new file mode 100644 index 0000000000000000000000000000000000000000..7a3c8e10d4a1155455fd38e7a370efa0a4c101de --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-HOP.txt @@ -0,0 +1,12 @@ +94 167 0.00110 +525 803 0.00595 +4711 8894 0.06153 +12503 23784 0.18946 +53 93 0.00058 +688 753 0.00897 +2838 6843 0.03216 +39383 73448 0.80197 +83 218 0.00097 +967 1673 0.00985 +4352 8447 0.05654 +45103 117746 0.86695 diff --git a/snap-python/source/dev/test/results-sheridan/sw-SVal.txt b/snap-python/source/dev/test/results-sheridan/sw-SVal.txt new file mode 100644 index 0000000000000000000000000000000000000000..1550578431a9b1812bef6678bae33264bed8d4f8 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-SVal.txt @@ -0,0 +1,11 @@ +94 167 0.03757 +525 803 1.36552 +4711 8894 1.61351 +12503 23784 1.97499 +53 93 0.00694 +688 753 1.33238 +2838 6843 1.49477 +39383 73448 3.47871 +83 218 0.03521 +967 1673 1.47755 +4352 8447 1.61136 diff --git a/snap-python/source/dev/test/results-sheridan/sw-SVec.txt b/snap-python/source/dev/test/results-sheridan/sw-SVec.txt new file mode 100644 index 0000000000000000000000000000000000000000..a3dd09ddcf933140bc610e71bc4efc5f63ac8a4a --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-SVec.txt @@ -0,0 +1,11 @@ +94 167 0.04207 +525 803 0.00338 +4711 8894 0.02529 +12503 23784 0.06582 +53 93 0.00707 +688 753 0.00399 +2838 6843 0.01625 +39383 73448 0.25321 +83 218 0.03625 +967 1673 0.00617 +4352 8447 0.02388 diff --git a/snap-python/source/dev/test/results-sheridan/sw-Scc.txt b/snap-python/source/dev/test/results-sheridan/sw-Scc.txt new file mode 100644 index 0000000000000000000000000000000000000000..1226a3d05fccb58a4996ae780aed862de5349f6f --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-Scc.txt @@ -0,0 +1,12 @@ +94 167 0.00047 +525 803 0.00084 +4711 8894 0.00594 +12503 23784 0.01620 +53 93 0.00035 +688 753 0.00084 +2838 6843 0.00415 +39383 73448 0.07791 +83 218 0.00044 +967 1673 0.00135 +4352 8447 0.00558 +45103 117746 0.09555 diff --git a/snap-python/source/dev/test/results-sheridan/sw-Wcc.txt b/snap-python/source/dev/test/results-sheridan/sw-Wcc.txt new file mode 100644 index 0000000000000000000000000000000000000000..09ab633d76dacfc969f59dc53a9da7e358552128 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-Wcc.txt @@ -0,0 +1,12 @@ +94 167 0.00048 +525 803 0.00070 +4711 8894 0.00446 +12503 23784 0.01174 +53 93 0.00031 +688 753 0.00071 +2838 6843 0.00322 +39383 73448 0.04937 +83 218 0.00039 +967 1673 0.00103 +4352 8447 0.00423 +45103 117746 0.07974 diff --git a/snap-python/source/dev/test/results-sheridan/sw-info.txt b/snap-python/source/dev/test/results-sheridan/sw-info.txt new file mode 100644 index 0000000000000000000000000000000000000000..cedededb423b2e158d8f8414b7e0a6dc39452636 --- /dev/null +++ b/snap-python/source/dev/test/results-sheridan/sw-info.txt @@ -0,0 +1,12 @@ +94 167 0.00065 +525 803 0.00135 +4711 8894 0.00918 +12503 23784 0.02785 +53 93 0.00016 +688 753 0.00112 +2838 6843 0.00670 +39383 73448 0.11115 +83 218 0.00033 +967 1673 0.00171 +4352 8447 0.00842 +45103 117746 0.19395 diff --git a/snap-python/source/dev/test/tungraph.py b/snap-python/source/dev/test/tungraph.py new file mode 100644 index 0000000000000000000000000000000000000000..c8d9ef3131afeb418ee38682d68a16e6b0ef7b82 --- /dev/null +++ b/snap-python/source/dev/test/tungraph.py @@ -0,0 +1,123 @@ +import random +import sys + +sys.path.append("../swig-sw") + +import snap + +def PrintGStats(s, Graph): + ''' + Print graph statistics + ''' + + print "graph %s, nodes %d, edges %d, empty %s" % ( + s, Graph.GetNodes(), Graph.GetEdges(), + "yes" if Graph.Empty() else "no") + +def DefaultConstructor(): + ''' + Test the default constructor + ''' + + Graph = snap.TUNGraph() + PrintGStats("DefaultConstructor:Graph",Graph) + +def ManipulateNodesEdges(): + ''' + Test node, edge creation + ''' + + NNodes = 10000 + NEdges = 100000 + FName = "test.graph" + + Graph = snap.TUNGraph() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1",Graph) + + # get all the nodes + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + # get all the edges for all the nodes + ECount1 = 0; + NI = Graph.BegNI() + while NI < Graph.EndNI(): + ECount1 += NI.GetOutDeg() + NI.Next() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0; + EI = Graph.BegEI() + while EI < Graph.EndEI(): + ECount2 += 1 + EI.Next() + + print "graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d" % ( + NCount, ECount1, ECount2) + + # assignment + Graph1 = Graph; + PrintGStats("ManipulateNodesEdges:Graph3",Graph1) + + # save the graph + print "graph type = ", type(Graph) + FOut = snap.TFOut(snap.TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + FIn = snap.TFIn(snap.TStr(FName)) + Graph2 = snap.TUNGraph(FIn) + PrintGStats("ManipulateNodesEdges:Graph4",Graph2) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5",Graph) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6",Graph1) + +def GetSmallGraph(): + ''' + Test small graph + ''' + + Graph = snap.TUNGraph() + Graph.GetSmallGraph() + PrintGStats("GetSmallGraph:Graph",Graph) + +if __name__ == '__main__': + print "----- DefaultConstructor -----" + DefaultConstructor() + print "----- ManipulateNodesEdges -----" + ManipulateNodesEdges() + print "----- GetSmallGraph -----" + GetSmallGraph() + diff --git a/snap-python/source/dev/test/vec.py b/snap-python/source/dev/test/vec.py new file mode 100644 index 0000000000000000000000000000000000000000..e3a657065a757ab6345daa963349e34b698bdc25 --- /dev/null +++ b/snap-python/source/dev/test/vec.py @@ -0,0 +1,69 @@ +import httplib +import os +import sys +import time + +sys.path.append("../swig") +import snap + +numnodes = 100 +numtask = 10 + +#print "dir(snap.TIntV)", dir(snap.TIntV) +Vec1 = snap.TIntV(numnodes) +#print "dir(Vec1)", dir(Vec1) +print "Len Vec1", Vec1.Len() + +#print "dir(snap.TIntIntVV)", dir(snap.TIntIntVV) +Vec2 = snap.TIntIntVV(numtask) +#print "dir(Vec2)", dir(Vec2) +print "Len Vec2", Vec2.Len() + +print "Vec1", type(Vec1) + +snap.GetDegrees(Vec1, 10.0, 1.5) + +for i in range(0,Vec1.Len()): + print "Vec1", i, Vec1.GetVal(i).Val + +snap.AssignRndTask(Vec1, Vec2) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print "Vec3", i, Vec3.Len() + + for j in range(0,Vec3.Len()): + print "Vec4", i, j, Vec3.GetVal(j).Val + +#sys.exit(0) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print "Vec3", i, Vec3.Len() + + h = httplib.HTTPConnection("rokl1.stanford.edu",8100) + #h.request("POST","/msg/GenStubs-0/GenTasks-2","12345",{"User-agent": "007"}) + h.connect() + url = "/msg/GenStubs-0/GenTasks-%d" % (i) + h.putrequest("POST",url) + h.putheader("User-Agent", "007") + #h.putheader("Content-Length", "9") + h.putheader("Content-Length", str(Vec3.GetMemSize())) + h.endheaders() + + fileno = h.sock.fileno() + print "fileno", fileno + + n = Vec3.Send(fileno) + #n = os.write(fileno,"123abcdef") + print n + + #h.send("abc123") + + res = h.getresponse() + print res.status, res.reason + data = res.read() + print len(data) + print data + + diff --git a/snap-python/source/doc/Makefile b/snap-python/source/doc/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..95624dd78a803f0597ab14ce524506cd8fa77a99 --- /dev/null +++ b/snap-python/source/doc/Makefile @@ -0,0 +1,177 @@ +# Makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +PAPER = +BUILDDIR = build + +# User-friendly check for sphinx-build +ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) +$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) +endif + +# Internal variables. +PAPEROPT_a4 = -D latex_paper_size=a4 +PAPEROPT_letter = -D latex_paper_size=letter +ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source +# the i18n builder cannot share the environment and doctrees with the others +I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source + +.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext + +help: + @echo "Please use \`make ' where is one of" + @echo " html to make standalone HTML files" + @echo " dirhtml to make HTML files named index.html in directories" + @echo " singlehtml to make a single large HTML file" + @echo " pickle to make pickle files" + @echo " json to make JSON files" + @echo " htmlhelp to make HTML files and a HTML help project" + @echo " qthelp to make HTML files and a qthelp project" + @echo " devhelp to make HTML files and a Devhelp project" + @echo " epub to make an epub" + @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" + @echo " latexpdf to make LaTeX files and run them through pdflatex" + @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" + @echo " text to make text files" + @echo " man to make manual pages" + @echo " texinfo to make Texinfo files" + @echo " info to make Texinfo files and run them through makeinfo" + @echo " gettext to make PO message catalogs" + @echo " changes to make an overview of all changed/added/deprecated items" + @echo " xml to make Docutils-native XML files" + @echo " pseudoxml to make pseudoxml-XML files for display purposes" + @echo " linkcheck to check all external links for integrity" + @echo " doctest to run all doctests embedded in the documentation (if enabled)" + +clean: + rm -rf $(BUILDDIR)/* + +html: + $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." + +dirhtml: + $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." + +singlehtml: + $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml + @echo + @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." + +pickle: + $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle + @echo + @echo "Build finished; now you can process the pickle files." + +json: + $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json + @echo + @echo "Build finished; now you can process the JSON files." + +htmlhelp: + $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp + @echo + @echo "Build finished; now you can run HTML Help Workshop with the" \ + ".hhp project file in $(BUILDDIR)/htmlhelp." + +qthelp: + $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp + @echo + @echo "Build finished; now you can run "qcollectiongenerator" with the" \ + ".qhcp project file in $(BUILDDIR)/qthelp, like this:" + @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Snappy.qhcp" + @echo "To view the help file:" + @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Snappy.qhc" + +devhelp: + $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp + @echo + @echo "Build finished." + @echo "To view the help file:" + @echo "# mkdir -p $$HOME/.local/share/devhelp/Snappy" + @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Snappy" + @echo "# devhelp" + +epub: + $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub + @echo + @echo "Build finished. The epub file is in $(BUILDDIR)/epub." + +latex: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo + @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." + @echo "Run \`make' in that directory to run these through (pdf)latex" \ + "(use \`make latexpdf' here to do that automatically)." + +latexpdf: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo "Running LaTeX files through pdflatex..." + $(MAKE) -C $(BUILDDIR)/latex all-pdf + @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." + +latexpdfja: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo "Running LaTeX files through platex and dvipdfmx..." + $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja + @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." + +text: + $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text + @echo + @echo "Build finished. The text files are in $(BUILDDIR)/text." + +man: + $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man + @echo + @echo "Build finished. The manual pages are in $(BUILDDIR)/man." + +texinfo: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo + @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." + @echo "Run \`make' in that directory to run these through makeinfo" \ + "(use \`make info' here to do that automatically)." + +info: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo "Running Texinfo files through makeinfo..." + make -C $(BUILDDIR)/texinfo info + @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." + +gettext: + $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale + @echo + @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." + +changes: + $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes + @echo + @echo "The overview file is in $(BUILDDIR)/changes." + +linkcheck: + $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck + @echo + @echo "Link check complete; look for any errors in the above output " \ + "or in $(BUILDDIR)/linkcheck/output.txt." + +doctest: + $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest + @echo "Testing of doctests in the sources finished, look at the " \ + "results in $(BUILDDIR)/doctest/output.txt." + +xml: + $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml + @echo + @echo "Build finished. The XML files are in $(BUILDDIR)/xml." + +pseudoxml: + $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml + @echo + @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." diff --git a/snap-python/source/doc/README-DOC.TXT b/snap-python/source/doc/README-DOC.TXT new file mode 100644 index 0000000000000000000000000000000000000000..380f9e0f1c1cfec6fa8038037b95298b8c19c913 --- /dev/null +++ b/snap-python/source/doc/README-DOC.TXT @@ -0,0 +1,68 @@ +Undocumented Functions +Provided in C++, but not documented for Python +Mar 11, 2014 + +TUNGraph +- AddNode (const int &NId, const TIntV &NbrNIdV) +- AddNode (const int &NId, const TVecPool< TInt > &Pool, const int &NIdVId) +- GetNIdV (TIntV &NIdV) +- IsOk (const bool &ThrowExcept=true) +- operator = + +TNGraph +- AddNode (const int &NId, const TIntV &InNIdV, const TIntV &OutNIdV) +- AddNode (const int &NId, const TVecPool< TInt > &Pool, const int &SrcVId, const int &DstVId) +- GetNIdV (TIntV &NIdV) +- IsOk (const bool &ThrowExcept=true) +- operator = + +TNEANet +- GetNIdV (TIntV &NIdV) +- IsOk (const bool &ThrowExcept=true) + +- AttrNameNI(const TInt& NId, TStrV& Names) +- AttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) +- AttrValueNI(const TInt& NId, TStrV& Values) +- AttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Values) +- IntAttrNameNI(const TInt& NId, TStrV& Names) +- IntAttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) +- IntAttrValueNI(const TInt& NId, TIntV& Values) +- IntAttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TIntV& Values) +- StrAttrNameNI(const TInt& NId, TStrV& Names) +- StrAttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) +- StrAttrValueNI(const TInt& NId, TStrV& Values) +- StrAttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Values) +- FltAttrNameNI(const TInt& NId, TStrV& Names) +- FltAttrNameNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TStrV& Names) +- FltAttrValueNI(const TInt& NId, TFltV& Values) +- FltAttrValueNI(const TInt& NId, TStrIntPrH::TIter NodeHI, TFltV& Values) + +- AttrNameEI(const TInt& EId, TStrV& Names) +- AttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) +- AttrValueEI(const TInt& EId, TStrV& Values) +- AttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Values) +- IntAttrNameEI(const TInt& EId, TStrV& Names) +- IntAttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) +- IntAttrValueEI(const TInt& EId, TIntV& Values) +- IntAttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TIntV& Values) +- StrAttrNameEI(const TInt& EId, TStrV& Names) +- StrAttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) +- StrAttrValueEI(const TInt& EId, TStrV& Values) +- StrAttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Values) +- FltAttrNameEI(const TInt& EId, TStrV& Names) +- FltAttrNameEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TStrV& Names) +- FltAttrValueEI(const TInt& EId, TFltV& Values) +- FltAttrValueEI(const TInt& EId, TStrIntPrH::TIter EdgeHI, TFltV& Values) + +- NodeAttrIsDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) +- NodeAttrIsIntDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) +- NodeAttrIsStrDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) +- NodeAttrIsFltDeleted(const int& NId, const TStrIntPrH::TIter& NodeHI) + +- EdgeAttrIsDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) +- EdgeAttrIsIntDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) +- EdgeAttrIsStrDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) +- EdgeAttrIsFltDeleted(const int& EId, const TStrIntPrH::TIter& EdgeHI) +- GetNodeAttrValue(const int& NId, const TStrIntPrH::TIter& NodeHI) +- GetEdgeAttrValue(const int& EId, const TStrIntPrH::TIter& EdgeHI) + diff --git a/snap-python/source/doc/guide.txt b/snap-python/source/doc/guide.txt new file mode 100644 index 0000000000000000000000000000000000000000..22b399f46884da805cc09b6278ca318e9e411471 --- /dev/null +++ b/snap-python/source/doc/guide.txt @@ -0,0 +1,44 @@ +A Quick Guide to Sphinx for Snap.py + +This guide gives an overview of a subset of the Sphinx markup language +as used to document functions in the Snap.py documentation. + + +Page Title + +Use the following format: + +''''''''''''''' + + +Function Definition + +.. function:: () + + +List + +- + + +- + + + +References of Programming Constructs + +class :class:`` +method :meth:`` +function :func:`` +parameter ** + + +Source Code + +:: + + + + + + diff --git a/snap-python/source/doc/source/conf.py b/snap-python/source/doc/source/conf.py new file mode 100644 index 0000000000000000000000000000000000000000..7c565801add78442472bd2a7204369cb74277a23 --- /dev/null +++ b/snap-python/source/doc/source/conf.py @@ -0,0 +1,253 @@ +# -*- coding: utf-8 -*- +# +# Snap.py documentation build configuration file, created by +# sphinx-quickstart on Mon Sep 9 16:19:03 2013. +# +# This file is execfile()d with the current directory set to its containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +import sys, os + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +#sys.path.insert(0, os.path.abspath('.')) + +swigpath = os.path.join('..', '..', 'swig') +sys.path.insert(0, swigpath) + +# -- General configuration ----------------------------------------------------- + +# If your documentation needs a minimal Sphinx version, state it here. +#needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be extensions +# coming with Sphinx (named 'sphinx.ext.*') or your custom ones. +extensions = ["sphinx.ext.autodoc"] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# The suffix of source filenames. +source_suffix = '.rst' + +# The encoding of source files. +#source_encoding = 'utf-8-sig' + +# The master toctree document. +master_doc = 'index' + +# General information about the project. +project = u'Snap.py' +copyright = u'2020, SNAP' + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. +# +# The short X.Y version. +version = '6.0' +# The full version, including alpha/beta/rc tags. +release = '6.0.0' + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +#language = None + +# There are two options for replacing |today|: either, you set today to some +# non-false value, then it is used: +#today = '' +# Else, today_fmt is used as the format for a strftime call. +#today_fmt = '%B %d, %Y' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +exclude_patterns = [] + +# The reST default role (used for this markup: `text`) to use for all documents. +#default_role = None + +# If true, '()' will be appended to :func: etc. cross-reference text. +#add_function_parentheses = True + +# If true, the current module name will be prepended to all description +# unit titles (such as .. function::). +#add_module_names = True + +# If true, sectionauthor and moduleauthor directives will be shown in the +# output. They are ignored by default. +#show_authors = False + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = 'sphinx' + +# A list of ignored prefixes for module index sorting. +#modindex_common_prefix = [] + +# If true, keep warnings as "system message" paragraphs in the built documents. +#keep_warnings = False + + +# -- Options for HTML output --------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +html_theme = 'default' + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +#html_theme_options = {} + +# Add any paths that contain custom themes here, relative to this directory. +#html_theme_path = [] + +# The name for this set of Sphinx documents. If None, it defaults to +# " v documentation". +#html_title = None +html_title = project + " " + version + " documentation" + +# A shorter title for the navigation bar. Default is the same as html_title. +#html_short_title = None + +# The name of an image file (relative to this directory) to place at the top +# of the sidebar. +#html_logo = None + +# The name of an image file (within the static path) to use as favicon of the +# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 +# pixels large. +#html_favicon = None + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +#html_static_path = ['_static'] +html_static_path = [] + +# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, +# using the given strftime format. +#html_last_updated_fmt = '%b %d, %Y' + +# If true, SmartyPants will be used to convert quotes and dashes to +# typographically correct entities. +#html_use_smartypants = True + +# Custom sidebar templates, maps document names to template names. +#html_sidebars = {} + +# Additional templates that should be rendered to pages, maps page names to +# template names. +#html_additional_pages = {} + +# If false, no module index is generated. +#html_domain_indices = True + +# If false, no index is generated. +#html_use_index = True + +# If true, the index is split into individual pages for each letter. +#html_split_index = False + +# If true, links to the reST sources are added to the pages. +#html_show_sourcelink = True + +# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. +#html_show_sphinx = True + +# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. +#html_show_copyright = True + +# If true, an OpenSearch description file will be output, and all pages will +# contain a tag referring to it. The value of this option must be the +# base URL from which the finished HTML is served. +#html_use_opensearch = '' + +# This is the file name suffix for HTML files (e.g. ".xhtml"). +#html_file_suffix = None + +# Output file base name for HTML help builder. +htmlhelp_basename = 'Snappydoc' + + +# -- Options for LaTeX output -------------------------------------------------- + +latex_elements = { +# The paper size ('letterpaper' or 'a4paper'). +#'papersize': 'letterpaper', + +# The font size ('10pt', '11pt' or '12pt'). +#'pointsize': '10pt', + +# Additional stuff for the LaTeX preamble. +#'preamble': '', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, author, documentclass [howto/manual]). +latex_documents = [ + ('index', 'Snappy.tex', u'Snap.py Documentation', + u'Snap', 'manual'), +] + +# The name of an image file (relative to this directory) to place at the top of +# the title page. +#latex_logo = None + +# For "manual" documents, if this is true, then toplevel headings are parts, +# not chapters. +#latex_use_parts = False + +# If true, show page references after internal links. +#latex_show_pagerefs = False + +# If true, show URL addresses after external links. +#latex_show_urls = False + +# Documents to append as an appendix to all manuals. +#latex_appendices = [] + +# If false, no module index is generated. +#latex_domain_indices = True + + +# -- Options for manual page output -------------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [ + ('index', 'snappy', u'Snap.py Documentation', + [u'Snap'], 1) +] + +# If true, show URL addresses after external links. +#man_show_urls = False + + +# -- Options for Texinfo output ------------------------------------------------ + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + ('index', 'Snappy', u'Snap.py Documentation', + u'Snap', 'Snappy', 'One line description of project.', + 'Miscellaneous'), +] + +# Documents to append as an appendix to all manuals. +#texinfo_appendices = [] + +# If false, no module index is generated. +#texinfo_domain_indices = True + +# How to display URL addresses: 'footnote', 'no', or 'inline'. +#texinfo_show_urls = 'footnote' + +# If true, do not generate a @detailmenu in the "Top" node's menu. +#texinfo_no_detailmenu = False diff --git a/snap-python/source/doc/source/index.rst b/snap-python/source/doc/source/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..f652efe40ca86ab7b6f824c4345aab3170ec9bf8 --- /dev/null +++ b/snap-python/source/doc/source/index.rst @@ -0,0 +1,11 @@ +Welcome to Snap.py! +=================== + +Contents: + +.. toctree:: + :maxdepth: 1 + + tutorial/index-tut + reference/index-ref + diff --git a/snap-python/source/doc/source/reference/AddSelfEdges-swig.rst b/snap-python/source/doc/source/reference/AddSelfEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c86db2ebd335c86995968b2881d3e33639686daf --- /dev/null +++ b/snap-python/source/doc/source/reference/AddSelfEdges-swig.rst @@ -0,0 +1,37 @@ +AddSelfEdges (SWIG) +''''''''''''''''''' + +.. function:: AddSelfEdges(Graph) + :noindex: + +Adds a self-edge for every node in *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- None + + +The following example shows how to add self edges to every node in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 10, 0) + snap.AddSelfEdges(Graph) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 10, 0) + snap.AddSelfEdges(UGraph) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.PNEANet, 10, 0) + snap.AddSelfEdges(Network) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/AddSelfEdges.rst b/snap-python/source/doc/source/reference/AddSelfEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..5e6ffff2e6e81a5347c34ff97442cc1b06edf640 --- /dev/null +++ b/snap-python/source/doc/source/reference/AddSelfEdges.rst @@ -0,0 +1,35 @@ +AddSelfEdges +'''''''''''' + +.. function:: AddSelfEdges() + +A graph method that adds a self-edge for every node in a graph. + +Parameters: + +- None + +Return value: + +- None + + +The following example shows how to add self edges to every node in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 10, 0) + Graph.AddSelfEdges() + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 10, 0) + UGraph.AddSelfEdges() + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.TNEANet, 10, 0) + Network.AddSelfEdges() + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/CntDegNodes-swig.rst b/snap-python/source/doc/source/reference/CntDegNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..df62d23e05ddffd5f1db394445e7ad4bc047fc0a --- /dev/null +++ b/snap-python/source/doc/source/reference/CntDegNodes-swig.rst @@ -0,0 +1,38 @@ +CntDegNodes (SWIG) +'''''''''''''''''' + +.. function:: CntDegNodes(Graph, NodeDeg) + :noindex: + +Returns the number of nodes in *Graph* with degree *NodeDeg*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NodeDeg*: int (input) + The degree of the nodes to be counted. + +Return value: + +- int + The number of nodes in *Graph* with degree *NodeDeg*. + + +The following example shows how to get the number of nodes with degree 20 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntDegNodes(Graph, 10) + print("Directed Graph: Count of nodes with degree 10 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntDegNodes(UGraph, 20) + print("Undirected Graph: Count of nodes with degree 20 is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntDegNodes(Network, 5) + print("Network Graph: Count of nodes with degree 5 is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntDegNodes.rst b/snap-python/source/doc/source/reference/CntDegNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..52a64e36b10c11dd43215f9aa74879071c409f9e --- /dev/null +++ b/snap-python/source/doc/source/reference/CntDegNodes.rst @@ -0,0 +1,34 @@ +CntDegNodes +''''''''''' + +.. function:: CntDegNodes(NodeDeg) + +A graph method that returns the number of nodes in a graph with degree *NodeDeg*. + +Parameters: + +- *NodeDeg*: int + The degree of the nodes to be counted. + +Return value: + +- int + The number of nodes in a graph with degree *NodeDeg*. + + +The following example shows how to get the number of nodes with degree 20 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntDegNodes(10) + print("Directed Graph: Count of nodes with degree 10 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntDegNodes(20) + print("Undirected Graph: Count of nodes with degree 20 is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntDegNodes(5) + print("Network Graph: Count of nodes with degree 5 is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntEdgesToSet-swig.rst b/snap-python/source/doc/source/reference/CntEdgesToSet-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..38891792c876eebc030d0980f40956011a822fa1 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntEdgesToSet-swig.rst @@ -0,0 +1,45 @@ +CntEdgesToSet (SWIG) +'''''''''''''''''''' + +.. function:: CntEdgesToSet(Graph, NId, NodeSet) + :noindex: + +Counts the number of edges between the given node with node id *NId* and the given set of nodes *NodeSet* in the provided graph *Graph*. If *Graph* is a directed graph, this function will return edges occurring in both directions between the given *NId* and *NodeSet*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or network. + +- *NId*: int (input) + The node id of the source node. + +- *NodeSet*: :class:`TIntSet`, a set of ints (input) + The set of destination node ids. + +Return Value: + +- int + The number of edges from node with id *NId* to nodes in the set *NodeSet*. + + +The following example shows how to use :func:`CntEdgesToSet` with :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NodeSet = snap.TIntSet() + for NI in range(1,50): + NodeSet.AddKey(NI) + NodeId = 65 + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + EdgeCount = snap.CntEdgesToSet(Graph, NodeId, NodeSet) + print("Number of edges from %d to NodeSet in PNGraph = %d" % (NodeId, EdgeCount)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + EdgeCount = CntEdgesToSet(UGraph, NodeId, NodeSet) + print("Number of edges from %d to NodeSet in PUNGraph = %d" % (NodeId, EdgeCount)) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + EdgeCount = CntEdgesToSet(Network, NodeId, NodeSet) + print("Number of edges from %d to NodeSet in PNEANet = %d" % (NodeId, EdgeCount)) diff --git a/snap-python/source/doc/source/reference/CntEdgesToSet.rst b/snap-python/source/doc/source/reference/CntEdgesToSet.rst new file mode 100644 index 0000000000000000000000000000000000000000..c232ef02805368a7564ff4cc75f5c5b650b6d57b --- /dev/null +++ b/snap-python/source/doc/source/reference/CntEdgesToSet.rst @@ -0,0 +1,41 @@ +CntEdgesToSet +''''''''''''' + +.. function:: CntEdgesToSet(NId, NodeSet) + +A graph method that counts the number of edges between the given node with node id *NId* and the given set of nodes *NodeSet* in a graph. If the graph is a directed graph, this function will return edges occurring in both directions between the given *NId* and *NodeSet*. + +Parameters: + +- *NId*: int + The node id of the source node. + +- *NodeSet*: Python set() or :class:`TIntSet`, a set of ints + The set of destination node ids. + +Return Value: + +- int + The number of edges from node with id *NId* to nodes in the set *NodeSet*. + + +The following example shows how to use :func:`CntEdgesToSet` with :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NodeSet = set() + for NI in range(1,50): + NodeSet.add(NI) + NodeId = 65 + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + EdgeCount = Graph.CntEdgesToSet(NodeId, NodeSet) + print("Number of edges from %d to NodeSet in TNGraph = %d" % (NodeId, EdgeCount)) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + EdgeCount = UGraph.CntEdgesToSet(NodeId, NodeSet) + print("Number of edges from %d to NodeSet in TUNGraph = %d" % (NodeId, EdgeCount)) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + EdgeCount = Network.CntEdgesToSet(NodeId, NodeSet) + print("Number of edges from %d to NodeSet in TNEANet = %d" % (NodeId, EdgeCount)) diff --git a/snap-python/source/doc/source/reference/CntInDegNodes-swig.rst b/snap-python/source/doc/source/reference/CntInDegNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..55c86e33e8190db18b238ae292cf938a490c4496 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntInDegNodes-swig.rst @@ -0,0 +1,38 @@ +CntInDegNodes (SWIG) +'''''''''''''''''''' + +.. function:: CntInDegNodes(Graph, NodeInDeg) + :noindex: + +Returns the number of nodes in *Graph* with in-degree *NodeInDeg*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NodeInDeg*: int (input) + The in-degree of the nodes to be counted. + +Return value: + +- int + The number of nodes in *Graph* with in-degree *NodeInDeg*. + + +The following example shows how to get the number of nodes with in-degrees 10, 20 and 5 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntInDegNodes(Graph, 10) + print("Directed Graph: Count of nodes with in-degree 10 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntInDegNodes(UGraph, 20) + print("Undirected Graph: Count of nodes with in-degree 20 is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntInDegNodes(Network, 5) + print("Network Graph: Count of nodes with in-degree 5 is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntInDegNodes.rst b/snap-python/source/doc/source/reference/CntInDegNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..95ef262a8d77df0472c8a391952cb80c35610073 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntInDegNodes.rst @@ -0,0 +1,34 @@ +CntInDegNodes +''''''''''''' + +.. function:: CntInDegNodes(NodeInDeg) + +A graph method that returns the number of nodes in a graph with in-degree *NodeInDeg*. + +Parameters: + +- *NodeInDeg*: int + The in-degree of the nodes to be counted. + +Return value: + +- int + The number of nodes in a graph with in-degree *NodeInDeg*. + + +The following example shows how to get the number of nodes with in-degrees 10, 20 and 5 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntInDegNodes(10) + print("Directed Graph: Count of nodes with in-degree 10 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntInDegNodes(20) + print("Undirected Graph: Count of nodes with in-degree 20 is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntInDegNodes(5) + print("Network Graph: Count of nodes with in-degree 5 is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntNonZNodes-swig.rst b/snap-python/source/doc/source/reference/CntNonZNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..22369ffa9a9e7af4b6c9cf37f330df105173385a --- /dev/null +++ b/snap-python/source/doc/source/reference/CntNonZNodes-swig.rst @@ -0,0 +1,36 @@ +CntNonZNodes (SWIG) +'''''''''''''''''''' + +.. function:: CntNonZNodes (Graph) + :noindex: + +Returns the number of nodes in *Graph* with degree greater than 0. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The number of nodes in *Graph* with degree greater than 0. + + +The following example shows how to calculate the number of non-zero nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntNonZNodes(Graph) + print("Directed Graph: Count of nodes with degree greater than 0 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntNonZNodes(UGraph) + print("Undirected Graph: Count of nodes with degree greater than 0 is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntNonZNodes(Network) + print("Network Graph: Count of nodes with degree greater than 0 is %d" % Count) + diff --git a/snap-python/source/doc/source/reference/CntNonZNodes.rst b/snap-python/source/doc/source/reference/CntNonZNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..c21414d5deafb39a7743afd7b0b6e72c6a28d8df --- /dev/null +++ b/snap-python/source/doc/source/reference/CntNonZNodes.rst @@ -0,0 +1,34 @@ +CntNonZNodes +'''''''''''' + +.. function:: CntNonZNodes () + +A graph method that returns the number of nodes in a graph with degree greater than 0. + +Parameters: + +- None + +Return value: + +- int + The number of nodes in a graph with degree greater than 0. + + +The following example shows how to calculate the number of non-zero nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntNonZNodes() + print("Directed Graph: Count of nodes with degree greater than 0 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntNonZNodes() + print("Undirected Graph: Count of nodes with degree greater than 0 is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntNonZNodes() + print("Network Graph: Count of nodes with degree greater than 0 is %d" % Count) + diff --git a/snap-python/source/doc/source/reference/CntOutDegNodes-swig.rst b/snap-python/source/doc/source/reference/CntOutDegNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f4ce2e8739944e0f089bac541322c5771b4629ee --- /dev/null +++ b/snap-python/source/doc/source/reference/CntOutDegNodes-swig.rst @@ -0,0 +1,38 @@ +CntOutDegNodes (SWIG) +''''''''''''''''''''' + +.. function:: CntOutDegNodes(Graph, NodeOutDeg) + :noindex: + +Returns the number of nodes in *Graph* with out-degree *NodeOutDeg*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NodeOutDeg*: int (input) + The out-degree of the nodes to be counted. + +Return value: + +- int + The number of nodes in *Graph* with out-degree *NodeOutDeg*. + + +The following example shows how to get the number of nodes with out-degrees 10, 20 and 5 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntOutDegNodes(Graph, 10) + print("Directed Graph: Count of nodes with out-degree 10 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntOutDegNodes(UGraph, 20) + print("Undirected Graph: Count of nodes with out-degree 20 is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntOutDegNodes(Network, 5) + print("Network Graph: Count of nodes with out-degree 5 is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntOutDegNodes.rst b/snap-python/source/doc/source/reference/CntOutDegNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..eff877c84323c0f2e1f33c2e588f85a63364911c --- /dev/null +++ b/snap-python/source/doc/source/reference/CntOutDegNodes.rst @@ -0,0 +1,34 @@ +CntOutDegNodes +'''''''''''''' + +.. function:: CntOutDegNodes(NodeOutDeg) + +A graph method that returns the number of nodes in a graph with out-degree *NodeOutDeg*. + +Parameters: + +- *NodeOutDeg*: int + The out-degree of the nodes to be counted. + +Return value: + +- int + The number of nodes in a graph with out-degree *NodeOutDeg*. + + +The following example shows how to get the number of nodes with out-degrees 10, 20 and 5 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntOutDegNodes(10) + print("Directed Graph: Count of nodes with out-degree 10 is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntOutDegNodes(20) + print("Undirected Graph: Count of nodes with out-degree 20 is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntOutDegNodes(5) + print("Network Graph: Count of nodes with out-degree 5 is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntSelfEdges-swig.rst b/snap-python/source/doc/source/reference/CntSelfEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..91812d8d0fdf6bfe967d4ea6f920ffef8b1a46eb --- /dev/null +++ b/snap-python/source/doc/source/reference/CntSelfEdges-swig.rst @@ -0,0 +1,35 @@ +CntSelfEdges (SWIG) +''''''''''''''''''' + +.. function:: CntSelfEdges (Graph) + :noindex: + +Returns the number of self edges in the graph *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The number of self edges in *Graph*. + + +The following example shows how to calculate the number of self edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntSelfEdges(Graph) + print("Directed Graph: Count of self edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntSelfEdges(UGraph) + print("Undirected Graph: Count of self edges is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntSelfEdges(Network) + print("Network Graph: Count of self edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntSelfEdges.rst b/snap-python/source/doc/source/reference/CntSelfEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..0b80b505983350545413b67ad9908547ede875c8 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntSelfEdges.rst @@ -0,0 +1,33 @@ +CntSelfEdges +'''''''''''' + +.. function:: CntSelfEdges () + +A graph method that returns the number of self edges in a graph. + +Parameters: + +- None + +Return value: + +- int + The number of self edges in a graph. + + +The following example shows how to calculate the number of self edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntSelfEdges() + print("Directed Graph: Count of self edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntSelfEdges() + print("Undirected Graph: Count of self edges is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntSelfEdges() + print("Network Graph: Count of self edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntUniqBiDirEdges-swig.rst b/snap-python/source/doc/source/reference/CntUniqBiDirEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5d98e5b368c2de4fbd850469cf822d7ef596c713 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntUniqBiDirEdges-swig.rst @@ -0,0 +1,35 @@ +CntUniqBiDirEdges (SWIG) +'''''''''''''''''''''''' + +.. function:: CntUniqBiDirEdges(Graph) + :noindex: + +Returns the number of unique bidirectional edges in the graph *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The number of unique bidirectional edges in *Graph*. + + +The following example shows how to calculate the number of unique bidirectional edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntUniqBiDirEdges(Graph) + print("Directed Graph: Count of unique bidirectional edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntUniqBiDirEdges(UGraph) + print("Undirected Graph: Count of unique bidirectional edges is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntUniqBiDirEdges(Network) + print("Network Graph: Count of unique bidirectional edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntUniqBiDirEdges.rst b/snap-python/source/doc/source/reference/CntUniqBiDirEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..78c7916ad754835bf3c57f712bc3f160790a98b3 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntUniqBiDirEdges.rst @@ -0,0 +1,33 @@ +CntUniqBiDirEdges +''''''''''''''''' + +.. function:: CntUniqBiDirEdges() + +A function that returns the number of unique bidirectional edges in a graph. + +Parameters: + +- None + +Return value: + +- int + The number of unique bidirectional edges in a graph. + + +The following example shows how to calculate the number of unique bidirectional edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntUniqBiDirEdges() + print("Directed Graph: Count of unique bidirectional edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntUniqBiDirEdges() + print("Undirected Graph: Count of unique bidirectional edges is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntUniqBiDirEdges() + print("Network Graph: Count of unique bidirectional edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntUniqDirEdges-swig.rst b/snap-python/source/doc/source/reference/CntUniqDirEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a8f25e5d1842d78ae94872805f19139eee6ef7d0 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntUniqDirEdges-swig.rst @@ -0,0 +1,35 @@ +CntUniqDirEdges (SWIG) +'''''''''''''''''''''' + +.. function:: CntUniqDirEdges(Graph) + :noindex: + +Returns the number of unique directed edges in the graph *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The number of unique directed edges in *Graph*. + + +The following example shows how to calculate the number of unique directed edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntUniqDirEdges(Graph) + print("Directed Graph: Count of unique directed edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntUniqDirEdges(UGraph) + print("Undirected Graph: Count of unique Directed edges is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntUniqDirEdges(Network) + print("Network Graph: Count of unique Directed edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntUniqDirEdges.rst b/snap-python/source/doc/source/reference/CntUniqDirEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..ec29622c591f6ea98549318659a7d9a16cc66e09 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntUniqDirEdges.rst @@ -0,0 +1,33 @@ +CntUniqDirEdges +''''''''''''''' + +.. function:: CntUniqDirEdges() + +A graph method that returns the number of unique directed edges in a graph. + +Parameters: + +- None + +Return value: + +- int + The number of unique directed edges in a graph. + + +The following example shows how to calculate the number of unique directed edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntUniqDirEdges() + print("Directed Graph: Count of unique directed edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntUniqDirEdges() + print("Undirected Graph: Count of unique Directed edges is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntUniqDirEdges() + print("Network Graph: Count of unique Directed edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntUniqUndirEdges-swig.rst b/snap-python/source/doc/source/reference/CntUniqUndirEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..e7f2057834b7308f5e97ce035e858ce7f2ffea1e --- /dev/null +++ b/snap-python/source/doc/source/reference/CntUniqUndirEdges-swig.rst @@ -0,0 +1,35 @@ +CntUniqUndirEdges (SWIG) +'''''''''''''''''''''''' + +.. function:: CntUniqUndirEdges(Graph) + :noindex: + +Returns the number of unique undirected edges in the graph *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The number of unique undirected edges in *Graph*. + + +The following example shows how to calculate the number of unique undirected edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Count = snap.CntUniqUndirEdges(Graph) + print("Directed Graph: Count of unique undirected edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Count = snap.CntUniqUndirEdges(UGraph) + print("Undirected Graph: Count of unique undirected edges is %d" % Count) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Count = snap.CntUniqUndirEdges(Network) + print("Network Graph: Count of unique undirected edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CntUniqUndirEdges.rst b/snap-python/source/doc/source/reference/CntUniqUndirEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..8fd441a1f238470f44b29de408d5fe67607d7756 --- /dev/null +++ b/snap-python/source/doc/source/reference/CntUniqUndirEdges.rst @@ -0,0 +1,33 @@ +CntUniqUndirEdges +''''''''''''''''' + +.. function:: CntUniqUndirEdges() + +A graph method that returns the number of unique undirected edges in a graph. + +Parameters: + +- None + +Return value: + +- int + The number of unique undirected edges in a graph. + + +The following example shows how to calculate the number of unique undirected edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Count = Graph.CntUniqUndirEdges() + print("Directed Graph: Count of unique undirected edges is %d" % Count) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Count = UGraph.CntUniqUndirEdges() + print("Undirected Graph: Count of unique undirected edges is %d" % Count) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Count = Network.CntUniqUndirEdges() + print("Network Graph: Count of unique undirected edges is %d" % Count) diff --git a/snap-python/source/doc/source/reference/CommunityCNM-swig.rst b/snap-python/source/doc/source/reference/CommunityCNM-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..566429584a263468e1618728cc3a57a07a48b681 --- /dev/null +++ b/snap-python/source/doc/source/reference/CommunityCNM-swig.rst @@ -0,0 +1,35 @@ +CommunityCNM (SWIG) +''''''''''''''''''' + +.. function:: CommunityCNM (Graph, CmtyV) + :noindex: + +Uses the Clauset-Newman-Moore community detection method for large networks. At every step of the algorithm two communities that contribute maximum positive value to global modularity are merged. Fills *CmtyV* with all the communities detected and returns the modularity of the network. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. Make sure that *Graph* has no self-edges. If needed, use :meth:`DelSelfEdges`. + +- *CmtyV*: :class:`TCnComV`, a vector of connected components (output) + A vector of all the communities that are detected by the CNM method. Each community is represented as a vector of node IDs. + +Return value: + +- float + The modularity of the network. + + +The following example shows how to detect communities using CNM algorithm in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + CmtyV = snap.TCnComV() + modularity = snap.CommunityCNM(UGraph, CmtyV) + for Cmty in CmtyV: + print("Community: ") + for NI in Cmty: + print(NI) + print("The modularity of the network is %f" % modularity) + diff --git a/snap-python/source/doc/source/reference/CommunityCNM.rst b/snap-python/source/doc/source/reference/CommunityCNM.rst new file mode 100644 index 0000000000000000000000000000000000000000..42d829bc8b31e8d69e339fb8da04b593afe2335a --- /dev/null +++ b/snap-python/source/doc/source/reference/CommunityCNM.rst @@ -0,0 +1,32 @@ +CommunityCNM +'''''''''''' + +.. function:: CommunityCNM () + +A graph method for undirected graphs that uses the Clauset-Newman-Moore community detection method for large networks and returns the modularity of the network and detected communities. At every step of the algorithm two communities that contribute maximum positive value to global modularity are merged. + +Parameters: + +- None + +Return value: + +- float + The modularity of the network. + +- *CmtyV*: :class:`TCnComV`, a vector of connected components + A vector of all the communities that are detected by the CNM method. Each community is represented as a vector of node ids. + + +The following example shows how to detect communities using CNM algorithm in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + modularity, CmtyV = UGraph.CommunityCNM() + for Cmty in CmtyV: + print("Community: ") + for NI in Cmty: + print(NI) + print("The modularity of the network is %f" % modularity) + diff --git a/snap-python/source/doc/source/reference/CommunityGirvanNewman-swig.rst b/snap-python/source/doc/source/reference/CommunityGirvanNewman-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..bc04a67dab4dee2de23c1c34ec0be634bf67b577 --- /dev/null +++ b/snap-python/source/doc/source/reference/CommunityGirvanNewman-swig.rst @@ -0,0 +1,34 @@ +CommunityGirvanNewman (SWIG) +'''''''''''''''''''''''''''' + +.. function:: CommunityGirvanNewman(Graph, CmtyV) + :noindex: + +Uses the Girvan-Newman community detection algorithm based on betweenness centrality on *Graph*. Fills *CmtyV* with all the communities detected and returns the modularity of the network. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *CmtyV*: :class:`TCnComV`, a vector of connected components (output) + A vector of all the communities that are detected by the Girvan-Newman method. Each community is represented as a vector of node ids. + +Return value: + +- float + The modularity of the network. + + +The following example shows how to detect communities using Girvan-Newman algorithm in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + CmtyV = snap.TCnComV() + modularity = snap.CommunityGirvanNewman(UGraph, CmtyV) + for Cmty in CmtyV: + print("Community: ") + for NI in Cmty: + print(NI) + print("The modularity of the network is %f" % modularity) diff --git a/snap-python/source/doc/source/reference/CommunityGirvanNewman.rst b/snap-python/source/doc/source/reference/CommunityGirvanNewman.rst new file mode 100644 index 0000000000000000000000000000000000000000..cedc990dcd8bbbcf3cabb394e3c03d5c3d1aa17b --- /dev/null +++ b/snap-python/source/doc/source/reference/CommunityGirvanNewman.rst @@ -0,0 +1,31 @@ +CommunityGirvanNewman +''''''''''''''''''''' + +.. function:: CommunityGirvanNewman() + +A graph method for undirected graphs that uses the Girvan-Newman community detection algorithm based on betweenness centrality to detect communities and returns the modularity of the network and detected communities. + +Parameters: + +- None + +Return value: + +- float + The modularity of the network. + +- *CmtyV*: :class:`TCnComV`, a vector of connected components + A vector of all the communities that are detected by the Girvan-Newman method. Each community is represented as a vector of node ids. + + +The following example shows how to detect communities using Girvan-Newman algorithm in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + modularity, CmtyV = UGraph.CommunityGirvanNewman() + for Cmty in CmtyV: + print("Community: ") + for NI in Cmty: + print(NI) + print("The modularity of the network is %f" % modularity) diff --git a/snap-python/source/doc/source/reference/ConvertESubGraph-swig.rst b/snap-python/source/doc/source/reference/ConvertESubGraph-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..6fc3541190276ca8763593c11d018c06765d25a5 --- /dev/null +++ b/snap-python/source/doc/source/reference/ConvertESubGraph-swig.rst @@ -0,0 +1,49 @@ +ConvertESubGraph (SWIG) +''''''''''''''''''''''' + +.. function:: ConvertESubGraph(GraphType, InGraph, EIdV, RenumberNodes=False) + :noindex: + +Returns a subgraph of graph *InGraph* with *EIdV* edges with an optional node renumbering. The resulting subgraph will have type *GraphType*. Node and edge data is not copied, but it is shared by input and output graphs. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InGraph*: network (input) + A Snap.py network. + +- *EIdV*: :class:`TIntV`, a vector of ints (input) + Edge IDs that will be included in the subgraph. + +- *RenumberNodes*: bool (input) + Determines whether the node IDs are preserved or not. If False, then nodes in the resulting graph have the same node IDs as nodes in *InGraph*. If True, then nodes in the resulting graph are renumbered sequentially from 0 to N-1, where N is the number of nodes. By default, the nodes are not renumbered. + +Return value: + +- graph + A snap.py graph of type *GraphType* with *EIdV* edges from the original graph *InGraph*. + + +The following example shows how to create a subgraph for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + V = snap.TIntV() + for i in range(100): + V.Add(i) + + Sub_Graph = snap.ConvertESubGraph(snap.PNGraph, Network, V, False) + for EI in Sub_Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Sub_UGraph = snap.ConvertESubGraph(snap.PUNGraph, Network, V, False) + for EI in Sub_UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Sub_Network = snap.ConvertESubGraph(snap.PNEANet, Network, V, False) + for EI in Sub_Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/ConvertESubGraph.rst b/snap-python/source/doc/source/reference/ConvertESubGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..6b767bf0d3a2b0d4516468e0e8034d089486bc4c --- /dev/null +++ b/snap-python/source/doc/source/reference/ConvertESubGraph.rst @@ -0,0 +1,45 @@ +ConvertESubGraph +'''''''''''''''' + +.. function:: ConvertESubGraph(GraphType, EIdV, RenumberNodes=False) + +A graph method that returns a subgraph of the original graph with *EIdV* edges with an optional node renumbering. The resulting subgraph will have type *GraphType*. Any node and edge data is not copied, but it is shared by input and output graphs. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of TNGraph, TUNGraph or TNEANet. + +- *EIdV*: Python list or :class:`TIntV`, a vector of ints + Edge ids that will be included in the subgraph. + +- (optional) *RenumberNodes*: bool + Determines whether the node ids are preserved or not. If False, then nodes in the resulting graph have the same node ids as nodes in the original graph. If True, then nodes in the resulting graph are renumbered sequentially from 0 to N-1, where N is the number of nodes. By default, the nodes are not renumbered. + +Return value: + +- graph + A graph of type *GraphType* with *EIdV* edges from the original graph. + + +The following example shows how to create a subgraph for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + V = [] + for i in range(100): + V.append(i) + + Sub_Graph = Network.ConvertESubGraph(snap.TNGraph, V) + for EI in Sub_Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Sub_UGraph = Network.ConvertESubGraph(snap.TUNGraph, V) + for EI in Sub_UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Sub_Network = Network.ConvertESubGraph(snap.TNEANet, V) + for EI in Sub_Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/ConvertGraph-swig.rst b/snap-python/source/doc/source/reference/ConvertGraph-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c798282ffa2ba9c96bc8cd0c3feaabe60dbdabfa --- /dev/null +++ b/snap-python/source/doc/source/reference/ConvertGraph-swig.rst @@ -0,0 +1,40 @@ +ConvertGraph (SWIG) +''''''''''''''''''' + +.. function:: ConvertGraph(GraphType, InGraph, RenumberNodes=False) + :noindex: + +Converts *InGraph* to a graph of type *GraphType* with an optional node renumbering. The resulting graph will have type *GraphType*. Node and edge data is not copied, but it is shared by input and output graphs. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InGraph*: graph (input) + A Snap.py graph or network. + +- *RenumberNodes*: bool (input) + Determines whether the node IDs are preserved or not. If False, then nodes in the resulting graph have the same node IDs as nodes in *InGraph*. If True, then nodes in the resulting graph are renumbered sequentially from 0 to N-1, where N is the number of nodes. By default, the nodes are not renumbered. + +Return value: + +- graph + A snap.py graph of type *GraphType* converted from the original graph *InGraph*. + + +The following example shows how to convert between different types of graphs:: + + import snap + + GIn = snap.GenRndGnm(snap.PNGraph, 100, 1000) + # convert directed graph to undirected + GOut = snap.ConvertGraph(snap.PUNGraph, GIn) + + GIn = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + # convert undirected graph to directed + GOut = snap.ConvertGraph(snap.PNGraph, GIn) + + GIn = snap.GenRndGnm(snap.PNGraph, 100, 1000) + # convert directed graph to a network + GOut = snap.ConvertGraph(snap.PNEANet, GIn) diff --git a/snap-python/source/doc/source/reference/ConvertGraph.rst b/snap-python/source/doc/source/reference/ConvertGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..1a7301039bd720ec994434b5f1799af9feb3b9ab --- /dev/null +++ b/snap-python/source/doc/source/reference/ConvertGraph.rst @@ -0,0 +1,36 @@ +ConvertGraph +'''''''''''' + +.. function:: ConvertGraph(GraphType, RenumberNodes=False) + +A graph method that converts a graph to a graph of type *GraphType* with an optional node renumbering. The resulting graph will have type *GraphType*. Any node and edge data is not copied, but it is shared by input and output graphs. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of TNGraph, TUNGraph or TNEANet. + +- (optional) *RenumberNodes*: bool + Determines whether the node ids are preserved or not. If False, then nodes in the resulting graph have the same node ids as nodes in the original graph. If True, then nodes in the resulting graph are renumbered sequentially from 0 to N-1, where N is the number of nodes. By default, the nodes are not renumbered. + +Return value: + +- graph + A graph of type *GraphType* converted from the original graph. + + +The following example shows how to convert between :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` types of graphs:: + + import snap + + GIn = snap.GenRndGnm(snap.TNGraph, 100, 1000) + # convert directed graph to undirected + GOut = GIn.ConvertGraph(snap.TUNGraph) + + GIn = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + # convert undirected graph to directed + GOut = GIn.ConvertGraph(snap.TNGraph) + + GIn = snap.GenRndGnm(snap.TNGraph, 100, 1000) + # convert directed graph to a network + GOut = GIn.ConvertGraph(snap.TNEANet) diff --git a/snap-python/source/doc/source/reference/ConvertSubGraph-swig.rst b/snap-python/source/doc/source/reference/ConvertSubGraph-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..b8de4ce9e2199ae4f263f2ea64a54676e3a045ac --- /dev/null +++ b/snap-python/source/doc/source/reference/ConvertSubGraph-swig.rst @@ -0,0 +1,52 @@ +ConvertSubGraph (SWIG) +'''''''''''''''''''''' + +.. function:: ConvertSubGraph(GraphType, InGraph, NIdV, RenumberNodes=False) + :noindex: + +Returns an induced subgraph of graph *InGraph* with *NIdV* nodes with an optional node renumbering. The resulting subgraph will have type *GraphType*. Node and edge data is not copied, but it is shared by input and output graphs. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InGraph*: graph (input) + A Snap.py graph or a network. + +- *NIdV*: :class:`TIntV`, a vector of ints (input) + Node IDs that will be included in the subgraph. + +- *RenumberNodes*: bool (input) + Determines whether the node IDs are preserved or not. If False, then nodes in the resulting graph have the same node IDs as nodes in *InGraph*. If True, then nodes in the resulting graph are renumbered sequentially from 0 to N-1, where N is the number of nodes. By default, the nodes are not renumbered. + +Return value: + +- graph + A snap.py graph of type *GraphType* with *NIdV* nodes from the original graph *InGraph*. + + +The following example shows how to convert a subgraph between the different types of graphs:: + + import snap + + V = snap.TIntV() + for i in range(10): + V.Add(i) + + GIn = snap.GenRndGnm(snap.PNGraph, 100, 1000) + GOut = snap.ConvertSubGraph(snap.PUNGraph, GIn, V) + for NI in GOut.Nodes(): + print("node: %d" % NI.GetId()) + + GIn = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + GOut = snap.ConvertSubGraph(snap.PNEANet, GIn, V) + for NI in GOut.Nodes(): + print("node: %d" % NI.GetId()) + + GIn = snap.GenRndGnm(snap.PNEANet, 100, 1000) + GOut = snap.ConvertSubGraph(snap.PNGraph, GIn, V) + for NI in GOut.Nodes(): + print("node: %d" % NI.GetId()) + + diff --git a/snap-python/source/doc/source/reference/ConvertSubGraph.rst b/snap-python/source/doc/source/reference/ConvertSubGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..b9b4826a50662d4d8ee10952907f26c408e9f710 --- /dev/null +++ b/snap-python/source/doc/source/reference/ConvertSubGraph.rst @@ -0,0 +1,47 @@ +ConvertSubGraph +''''''''''''''' + +.. function:: ConvertSubGraph(GraphType, NIdV, RenumberNodes=False) + +A graph method that returns an induced subgraph of the original graph with *NIdV* nodes with an optional node renumbering. The resulting subgraph will have type *GraphType*. Any node and edge data is not copied, but it is shared by input and output graphs. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of TNGraph, TUNGraph, or TNEANet. + +- *NIdV*: Python list or :class:`TIntV`, a vector of ints + Node ids that will be included in the subgraph. + +- (optional) *RenumberNodes*: bool + Determines whether the node ids are preserved or not. If False, then nodes in the resulting graph have the same node ids as nodes in the original graph. If True, then nodes in the resulting graph are renumbered sequentially from 0 to N-1, where N is the number of nodes. By default, the nodes are not renumbered. + +Return value: + +- graph + A graph of type *GraphType* with *NIdV* nodes from the original graph. + + +The following example shows how to convert a subgraph between the different types of graphs:: + + import snap + + V = [] + for i in range(10): + V.append(i) + + GIn = snap.GenRndGnm(snap.TNGraph, 100, 1000) + GOut = GIn.ConvertSubGraph(snap.TUNGraph, V) + for NI in GOut.Nodes(): + print("node: %d" % NI.GetId()) + + GIn = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + GOut = GInsnap.ConvertSubGraph(snap.TNEANet, V) + for NI in GOut.Nodes(): + print("node: %d" % NI.GetId()) + + GIn = snap.GenRndGnm(snap.TNEANet, 100, 1000) + GOut = GInsnap.ConvertSubGraph(snap.TNGraph, V) + for NI in GOut.Nodes(): + print("node: %d" % NI.GetId()) + diff --git a/snap-python/source/doc/source/reference/DelDegKNodes-swig.rst b/snap-python/source/doc/source/reference/DelDegKNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..4613cca9c3474964e4d0f2e6834e679d9c3c8073 --- /dev/null +++ b/snap-python/source/doc/source/reference/DelDegKNodes-swig.rst @@ -0,0 +1,52 @@ +DelDegKNodes (SWIG) +''''''''''''''''''' + +.. function:: DelDegKNodes(Graph, OutDegK, InDegK) + :noindex: + +Removes all nodes of out-degree *OutDegK* and all nodes of in-degree *InDegK* from *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutDegK*: int (input) + Specifies out-degree of nodes to be removed. + +- *InDegK*: int (input) + Specifies in-degree of nodes to be removed. + +Return value: + +- None + + +The following example shows how to remove nodes with out-degree *OutDegK* or in-degree *InDegK* in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 10) + snap.DelDegKNodes(Graph, 1, 1) + for NI in Graph.Nodes(): + if NI.GetOutDeg() == 1: + print("Node %d has out-degree 1." % NI.GetId()) + if NI.GetInDeg() == 1: + print("Node %d has in-degree 1." % NI.GetId()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 10) + snap.DelDegKNodes(UGraph, 1, 1) + for NI in UGraph.Nodes(): + if NI.GetOutDeg() == 1: + print("Node %d has out-degree 1." % NI.GetId()) + if NI.GetInDeg() == 1: + print("Node %d has in-degree 1." % NI.GetId()) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 10) + snap.DelDegKNodes(Network, 1, 1) + for NI in Network.Nodes(): + if NI.GetOutDeg() == 1: + print("Node %d has out-degree 1." % NI.GetId()) + if NI.GetInDeg() == 1: + print("Node %d has in-degree 1." % NI.GetId()) diff --git a/snap-python/source/doc/source/reference/DelDegKNodes.rst b/snap-python/source/doc/source/reference/DelDegKNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..6c1e182039d34834f51e71acab3ea319c9b61677 --- /dev/null +++ b/snap-python/source/doc/source/reference/DelDegKNodes.rst @@ -0,0 +1,48 @@ +DelDegKNodes +'''''''''''' + +.. function:: DelDegKNodes(OutDegK, InDegK) + +A graph method that removes all nodes of out-degree *OutDegK* and all nodes of in-degree *InDegK* from a graph. + +Parameters: + +- *OutDegK*: int + Specifies out-degree of nodes to be removed. + +- *InDegK*: int + Specifies in-degree of nodes to be removed. + +Return value: + +- None + + +The following example shows how to remove nodes with out-degree *OutDegK* or in-degree *InDegK* in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 10) + Graph.DelDegKNodes(1, 1) + for NI in Graph.Nodes(): + if NI.GetOutDeg() == 1: + print("Node %d has out-degree 1." % NI.GetId()) + if NI.GetInDeg() == 1: + print("Node %d has in-degree 1." % NI.GetId()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 10) + UGraph.DelDegKNodes(1, 1) + for NI in UGraph.Nodes(): + if NI.GetOutDeg() == 1: + print("Node %d has out-degree 1." % NI.GetId()) + if NI.GetInDeg() == 1: + print("Node %d has in-degree 1." % NI.GetId()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 10) + Network.DelDegKNodes(1, 1) + for NI in Network.Nodes(): + if NI.GetOutDeg() == 1: + print("Node %d has out-degree 1." % NI.GetId()) + if NI.GetInDeg() == 1: + print("Node %d has in-degree 1." % NI.GetId()) diff --git a/snap-python/source/doc/source/reference/DelNodes-swig.rst b/snap-python/source/doc/source/reference/DelNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..006e57926c8aae96c4b03cf0496a41d5b0fe0f3f --- /dev/null +++ b/snap-python/source/doc/source/reference/DelNodes-swig.rst @@ -0,0 +1,47 @@ +DelNodes (SWIG) +''''''''''''''' + +.. function:: DelNodes(Graph, NIdV) + :noindex: + +Removes the nodes contained in the vector *NIdV* from *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdV*: :class:`TIntV`, vector of ints (input) + A vector of node ids to be deleted from *Graph*. + +Return value: + +- None + + +The following example shows how to delete nodes from +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + V = snap.TIntV() + for i in range(10): + V.Add(i) + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.DelNodes(Graph, V) + for NI in V: + if Graph.IsNode(NI): + print("Node %d found in graph." % NI) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.DelNodes(UGraph, V) + for NI in V: + if UGraph.IsNode(NI): + print("Node %d found in graph." % NI) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.DelNodes(Network, V) + for NI in V: + if Network.IsNode(NI): + print("Node %d found in graph." % NI) diff --git a/snap-python/source/doc/source/reference/DelNodes.rst b/snap-python/source/doc/source/reference/DelNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..321a32af89754c791f8e4b8224b592b0d1062d57 --- /dev/null +++ b/snap-python/source/doc/source/reference/DelNodes.rst @@ -0,0 +1,43 @@ +DelNodes +'''''''' + +.. function:: DelNodes(NIdV) + +A graph method that removes the nodes contained in the vector *NIdV* from a graph. + +Parameters: + +- *NIdV*: Python list or :class:`TIntV`, vector of ints + A vector of node ids to be deleted. + +Return value: + +- None + + +The following example shows how to delete nodes from +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + V = [] + for i in range(10): + V.append(i) + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Network.DelNodes(V) + for NI in V: + if Graph.IsNode(NI): + print("Node %d found in graph." % NI) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.DelNodes(V) + for NI in V: + if UGraph.IsNode(NI): + print("Node %d found in graph." % NI) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.DelNodes(V) + for NI in V: + if Network.IsNode(NI): + print("Node %d found in graph." % NI) diff --git a/snap-python/source/doc/source/reference/DelSelfEdges-swig.rst b/snap-python/source/doc/source/reference/DelSelfEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..dd01b79e69c8f7e7d5ee1a7a3ff194bb2b3be79c --- /dev/null +++ b/snap-python/source/doc/source/reference/DelSelfEdges-swig.rst @@ -0,0 +1,52 @@ +DelSelfEdges (SWIG) +''''''''''''''''''' + +.. function:: DelSelfEdges (Graph) + :noindex: + +Removes all the self-edges from *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or network. + +Return value: + +- None + + +The following example shows how to delete self-edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.AddSelfEdges(Graph) + for NI in Graph.Nodes(): + if Graph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + snap.DelSelfEdges(Graph) + for NI in Graph.Nodes(): + if Graph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + + UGraph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.AddSelfEdges(UGraph) + for NI in UGraph.Nodes(): + if UGraph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + snap.DelSelfEdges(UGraph) + for NI in UGraph.Nodes(): + if UGraph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + + Network = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.AddSelfEdges(Network) + for NI in Network.Nodes(): + if Network.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + snap.DelSelfEdges(Network) + for NI in Network.Nodes(): + if Network.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) diff --git a/snap-python/source/doc/source/reference/DelSelfEdges.rst b/snap-python/source/doc/source/reference/DelSelfEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..ed1514d77834717ff76e695ede2ff7b6861734f5 --- /dev/null +++ b/snap-python/source/doc/source/reference/DelSelfEdges.rst @@ -0,0 +1,50 @@ +DelSelfEdges +'''''''''''' + +.. function:: DelSelfEdges () + +A graph method to remove all the self-edges from a graph. + +Parameters: + +- None + +Return value: + +- None + + +The following example shows how to delete self-edges in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.AddSelfEdges() + for NI in Graph.Nodes(): + if Graph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + Graph.DelSelfEdges() + for NI in Graph.Nodes(): + if Graph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + + UGraph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + UGraph.AddSelfEdges() + for NI in UGraph.Nodes(): + if UGraph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + UGraph.DelSelfEdges() + for NI in UGraph.Nodes(): + if UGraph.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + + Network = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Network.AddSelfEdges() + for NI in Network.Nodes(): + if Network.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) + Network.DelSelfEdges() + for NI in Network.Nodes(): + if Network.IsEdge(NI.GetId(),NI.GetId()): + print("Self-edge on node %d" % NI.GetId()) diff --git a/snap-python/source/doc/source/reference/DelZeroDegNodes-swig.rst b/snap-python/source/doc/source/reference/DelZeroDegNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a1fdc1af6a73e54bb38551cb7d6435f0b203d099 --- /dev/null +++ b/snap-python/source/doc/source/reference/DelZeroDegNodes-swig.rst @@ -0,0 +1,37 @@ +DelZeroDegNodes (SWIG) +''''''''''''''''''''''' + +.. function:: DelZeroDegNodes(Graph) + :noindex: + +Removes all the zero-degree nodes from *Graph*. + +Parameters: + +- *Graph*: graph (input and output) + A Snap.py graph or a network. + +Return value: + +- None + + +The following example shows how to delete all zero-degree nodes from +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 0) + print("Number of nodes in directed graph: %d" % Graph.GetNodes()) + snap.DelZeroDegNodes(Graph) + print("Number of nodes in directed graph after delete: %d" % Graph.GetNodes()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 0) + print("Number of nodes in undirected graph: %d" % UGraph.GetNodes()) + snap.DelZeroDegNodes(UGraph) + print("Number of nodes in undirected graph after delete: %d" % UGraph.GetNodes()) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 0) + print("Number of nodes in network: %d" % Network.GetNodes()) + snap.DelZeroDegNodes(Network) + print("Number of nodes in network after delete: %d" % Network.GetNodes()) diff --git a/snap-python/source/doc/source/reference/DelZeroDegNodes.rst b/snap-python/source/doc/source/reference/DelZeroDegNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..9b216fa118ca153bb7c272415d5ee5d211d4d662 --- /dev/null +++ b/snap-python/source/doc/source/reference/DelZeroDegNodes.rst @@ -0,0 +1,35 @@ +DelZeroDegNodes +''''''''''''''' + +.. function:: DelZeroDegNodes() + +A graph method that removes all the zero-degree nodes from a graph. + +Parameters: + +- None + +Return value: + +- None + + +The following example shows how to delete all zero-degree nodes from +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 0) + print("Number of nodes in directed graph: %d" % Graph.GetNodes()) + Graph.DelZeroDegNodes() + print("Number of nodes in directed graph after delete: %d" % Graph.GetNodes()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 0) + print("Number of nodes in undirected graph: %d" % UGraph.GetNodes()) + UGraph.DelZeroDegNodes() + print("Number of nodes in undirected graph after delete: %d" % UGraph.GetNodes()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 0) + print("Number of nodes in network: %d" % Network.GetNodes()) + Network.DelZeroDegNodes() + print("Number of nodes in network after delete: %d" % Network.GetNodes()) diff --git a/snap-python/source/doc/source/reference/DrawGViz-swig.rst b/snap-python/source/doc/source/reference/DrawGViz-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..9aa8a0e394e129d90f9259d02ddcc4ff5ee3c7a1 --- /dev/null +++ b/snap-python/source/doc/source/reference/DrawGViz-swig.rst @@ -0,0 +1,52 @@ +DrawGViz (SWIG) +''''''''''''''' + +.. function:: DrawGViz(Graph, Layout, PltFNm, Desc=TStr(), NodeLabels=False, NIdColorH=TIntStrH()) + :noindex: + +Draws the given *Graph* using a selected GraphViz Layout engine with nodes colored. Useful for drawing small (<100 node) graphs. Creates a file with name *PltFNm*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *Layout*: TGVizLayout (input) + One of gvlDot, gvlNeato, gvlTwopi, gvlCirco, gvlSfdp. The type of layout for the graph. + +- *PltFNm*: string (input) + Output filename (extension .ps, .png, .gif) determines the output format. + +- *Desc*: string (input) + A string describing the visualization. + +- *NodeLabels*: bool (input) + Whether or not the nodes in image have labels associated with them. + +- *NIdColorH*: :class:`TIntStrH`, a hash table with int keys and string values (input) + Maps node ids to node colors (see GraphViz documentation for more details). + +Return value: + +- None + + +Note that larger graphs (more than a few hundred nodes) may take several minutes to finish generating the image. The following example shows how to make a pretty graph image for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 10, 20) + snap.DrawGViz(Graph, snap.gvlDot, "graph.png", "graph 1") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 10, 40) + snap.DrawGViz(UGraph, snap.gvlNeato, "graph_undirected.png", "graph 2", True) + + NIdColorH = snap.TIntStrH() + NIdColorH[0] = "green" + NIdColorH[1] = "red" + NIdColorH[2] = "purple" + NIdColorH[3] = "blue" + NIdColorH[4] = "yellow" + Network = snap.GenRndGnm(snap.PNEANet, 5, 10) + snap.DrawGViz(Network, snap.gvlSfdp, "network.png", "graph 3", True, NIdColorH) diff --git a/snap-python/source/doc/source/reference/DrawGViz.rst b/snap-python/source/doc/source/reference/DrawGViz.rst new file mode 100644 index 0000000000000000000000000000000000000000..823c2c8487fd11eec2632795ba29eff2ad42d3a8 --- /dev/null +++ b/snap-python/source/doc/source/reference/DrawGViz.rst @@ -0,0 +1,47 @@ +DrawGViz +'''''''' + +.. function:: DrawGViz(Layout, PltFNm, Desc, NodeLabelH) + +A graph method to draw a given graph using a selected GraphViz Layout engine with nodes labeled. Creates a file with name *PltFNm*. + +Parameters: + +- *Layout*: TGVizLayout + One of gvlDot, gvlNeato, gvlTwopi, gvlCirco, gvlSfdp. The type of layout for the graph. + +- *PltFNm*: string + Output filename (extension .ps, .png, .gif) determines the output format. + +- *Desc*: string + A string describing the visualization. + +- *NodeLabelH*: Python dictionary or :class:`TIntStrH`, a hash table of int keys and string values + Maps node ids to node labels. + +Return value: + +- None + + +The following example shows how to draw the graph for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 10, 50) + labels = {} + for NI in Graph.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + Graph.DrawGViz(snap.gvlDot, "output.png", " ", labels) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 10, 50) + labels = {} + for NI in UGraph.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + UGraph.DrawGViz(snap.gvlDot, "output.png", " ", labels) + + Network = snap.GenRndGnm(snap.TNEANet, 10, 50) + labels = {} + for NI in Network.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + Network.DrawGViz(snap.gvlDot, "output.png", " ", labels) diff --git a/snap-python/source/doc/source/reference/DrawGViz1-swig.rst b/snap-python/source/doc/source/reference/DrawGViz1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..06d8e9d7dd5ef874e633b9fefc9e87edb87a0301 --- /dev/null +++ b/snap-python/source/doc/source/reference/DrawGViz1-swig.rst @@ -0,0 +1,51 @@ +DrawGViz (SWIG) +''''''''''''''' + +.. function:: DrawGViz(Graph, Layout, PltFNm, Desc, NodeLabelH) + :noindex: + +Draws a given *Graph* using a selected GraphViz Layout engine with nodes labeled. Creates a file with name *PltFNm*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *Layout*: TGVizLayout (input) + One of gvlDot, gvlNeato, gvlTwopi, gvlCirco, gvlSfdp. The type of layout for the graph. + +- *PltFNm*: string (input) + Output filename (extension .ps, .png, .gif) determines the output format. + +- *Desc*: string (input) + A string describing the visualization. + +- *NodeLabelH*: :class:`TIntStrH`, a hash table of int keys and string values (input) + Maps node ids to node labels. + +Return value: + +- None + + +The following example shows how to draw the graph for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 10, 50) + labels = snap.TIntStrH() + for NI in Graph.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + snap.DrawGViz(Graph, snap.gvlDot, "output.png", " ", labels) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 10, 50) + labels = snap.TIntStrH() + for NI in UGraph.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + snap.DrawGViz(UGraph, snap.gvlDot, "output.png", " ", labels) + + Network = snap.GenRndGnm(snap.PNEANet, 10, 50) + labels = snap.TIntStrH() + for NI in Network.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + snap.DrawGViz(Network, snap.gvlDot, "output.png", " ", labels) diff --git a/snap-python/source/doc/source/reference/DrawGVizColor.rst b/snap-python/source/doc/source/reference/DrawGVizColor.rst new file mode 100644 index 0000000000000000000000000000000000000000..7087f94018d875732279077d63a863678f30e040 --- /dev/null +++ b/snap-python/source/doc/source/reference/DrawGVizColor.rst @@ -0,0 +1,44 @@ +DrawGVizColor +''''''''''''' + +.. function:: DrawGVizColor(Layout, PltFNm, Desc=TStr(), NodeLabels=False, NIdColorH=TIntStrH()) + +A graph method that draws a graph using a selected GraphViz Layout engine with nodes colored. Useful for drawing small (<100 node) graphs. Creates a file with name *PltFNm*. + +Parameters: + +- *Layout*: TGVizLayout + One of gvlDot, gvlNeato, gvlTwopi, gvlCirco, gvlSfdp. The type of layout for the graph. + +- *PltFNm*: string + Output filename (extension .ps, .png, .gif) determines the output format. + +- *Desc*: string + A string describing the visualization. + +- *NodeLabels*: bool + Whether or not the nodes in image have labels associated with them. + +- *NIdColorH*: Python dictionary or :class:`TIntStrH`, a hash table with int keys and string values + Maps node ids to node colors (see GraphViz documentation for more details). + +Return value: + +- None + + +Note that larger graphs (more than a few hundred nodes) may take several minutes to finish generating the image. The following example shows how to make a pretty graph image for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 10, 20) + Graph.DrawGVizColor(snap.gvlDot, "graph.png", "graph 1") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 10, 40) + UGraph.DrawGVizColor(snap.gvlNeato, "graph_undirected.png", "graph 2", True) + + NIdColorH = { 0 : "green", 1 : "red", 2 : "purple", 3 : "blue", 4 : "yellow" } + Network = snap.GenRndGnm(snap.TNEANet, 5, 10) + Network.DrawGVizColor(snap.gvlSfdp, "network.png", "graph 3", True, NIdColorH) + diff --git a/snap-python/source/doc/source/reference/GenBaraHierar-swig.rst b/snap-python/source/doc/source/reference/GenBaraHierar-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f269cd3c8cd656a126987c21ba32d88e65524f17 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenBaraHierar-swig.rst @@ -0,0 +1,50 @@ +GenBaraHierar (SWIG) +'''''''''''''''''''' + +.. function:: GenBaraHierar(GraphType, Levels, IsDir=True) + :noindex: + +Generates a Ravasz-Barabasi deterministic scale-free graph. + +Corners of the graph are recursively expanded with miniature copies of the base graph (below). The graph has power-law degree distribution with the exponent 1+ln(5)/ln(4) and clustering coefficient with power-law decay exponent -1. Base graph:: + + o---o + |\ /| + | o | + |/ \| + o---o + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *Levels*: int (input) + The number of expansions of the base graph. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + +For more information see: Hierarchical organization in complex networks. Ravasz and Barabasi. http://arxiv.org/abs/cond-mat/0206130 + + +The following example shows how to generate a Ravasz-Barabasi deterministic scale-free graph (in this case of level 100) using the :func:`GenBaraHierar` for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenBaraHierar(snap.PNGraph, 3, True) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenBaraHierar(snap.PUNGraph, 3, True) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenBaraHierar(snap.PNEANet, 3, True) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenBaraHierar.rst b/snap-python/source/doc/source/reference/GenBaraHierar.rst new file mode 100644 index 0000000000000000000000000000000000000000..74e9f76c718ecbc056a1e0e227bd09d633eb25a1 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenBaraHierar.rst @@ -0,0 +1,49 @@ +GenBaraHierar +''''''''''''' + +.. function:: GenBaraHierar(GraphType, Levels, IsDir=True) + +Generates a Ravasz-Barabasi deterministic scale-free graph. + +Corners of the graph are recursively expanded with miniature copies of the base graph (below). The graph has power-law degree distribution with the exponent 1+ln(5)/ln(4) and clustering coefficient with power-law decay exponent -1. Base graph:: + + o---o + |\ /| + | o | + |/ \| + o---o + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *Levels*: int (input) + The number of expansions of the base graph. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + +For more information see: Hierarchical organization in complex networks. Ravasz and Barabasi. http://arxiv.org/abs/cond-mat/0206130 + + +The following example shows how to generate a Ravasz-Barabasi deterministic scale-free graph (in this case of level 100) using the :func:`GenBaraHierar` for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenBaraHierar(snap.TNGraph, 3, True) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenBaraHierar(snap.TUNGraph, 3, True) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenBaraHierar(snap.TNEANet, 3, True) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenCircle-swig.rst b/snap-python/source/doc/source/reference/GenCircle-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..4980e3658b5fc9019383ba67bbc015f791cd684e --- /dev/null +++ b/snap-python/source/doc/source/reference/GenCircle-swig.rst @@ -0,0 +1,43 @@ +GenCircle (SWIG) +'''''''''''''''' + +.. function:: GenCircle(GraphType, Nodes, OutDegree, IsDir=True) + :noindex: + +Generate a circular graph of type *GraphType* with *Nodes* nodes. The generated graph will have an edge from each node to the subsequent *OutDegree* nodes. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *Nodes*: int (input) + Number of nodes in the generated graph. + +- *OutDegree*: int (input) + The number of edges to be added to each node. This number does not include reciprocal edges. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate circular graphs for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenCircle(snap.PNGraph, 100, 10) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenCircle(snap.PUNGraph, 100, 10) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenCircle(snap.PNEANet, 100, 10) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenCircle.rst b/snap-python/source/doc/source/reference/GenCircle.rst new file mode 100644 index 0000000000000000000000000000000000000000..1474310f8f003ecccf506f01d6ea3eb8ba6aff95 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenCircle.rst @@ -0,0 +1,42 @@ +GenCircle +''''''''' + +.. function:: GenCircle(GraphType, Nodes, OutDegree, IsDir=True) + +Generate a circular graph of type *GraphType* with *Nodes* nodes. The generated graph will have an edge from each node to the subsequent *OutDegree* nodes. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *Nodes*: int (input) + Number of nodes in the generated graph. + +- *OutDegree*: int (input) + The number of edges to be added to each node. This number does not include reciprocal edges. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate circular graphs for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenCircle(snap.TNGraph, 100, 10) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenCircle(snap.TUNGraph, 100, 10) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenCircle(snap.TNEANet, 100, 10) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenConfModel-swig.rst b/snap-python/source/doc/source/reference/GenConfModel-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..928b0b969678e742dcf3ccc366d60bb966bd1dc4 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenConfModel-swig.rst @@ -0,0 +1,35 @@ +GenConfModel (SWIG) +''''''''''''''''''' + +.. function:: GenConfModel(DegSeqV, Rnd=TRnd) + :noindex: + +Generates a random undirected graph with the given degree sequence *DegSeqV* using the configuration model. + +Parameters: + +- *DegSeqV*: :class:`TIntV`, a vector of ints (input) + The degree sequence vector. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A random Snap.py undirected graph with degree sequence given by *DegSeqV*. + + +The following example generates a random undirected graph with degree sequence 1, 2, 3:: + + import snap + + DegSeqV = snap.TIntV() + DegSeqV.Add(1) + DegSeqV.Add(2) + DegSeqV.Add(3) + Rnd = snap.TRnd() + + UGraph = snap.GenConfModel(DegSeqV, Rnd) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenConfModel.rst b/snap-python/source/doc/source/reference/GenConfModel.rst new file mode 100644 index 0000000000000000000000000000000000000000..b3fc3e89f09437cc3bc6083dac2cba7ebc06ed0f --- /dev/null +++ b/snap-python/source/doc/source/reference/GenConfModel.rst @@ -0,0 +1,34 @@ +GenConfModel +'''''''''''' + +.. function:: GenConfModel(DegSeqV, Rnd=TRnd) + +Generates a random undirected graph with the given degree sequence *DegSeqV* using the configuration model. + +Parameters: + +- *DegSeqV*: :class:`TIntV`, a vector of ints (input) + The degree sequence vector. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A random Snap.py undirected graph with degree sequence given by *DegSeqV*. + + +The following example generates a random undirected graph with degree sequence 1, 2, 3:: + + import snap + + DegSeqV = snap.TIntV() + DegSeqV.Add(1) + DegSeqV.Add(2) + DegSeqV.Add(3) + Rnd = snap.TRnd() + + UGraph = snap.GenConfModel(DegSeqV, Rnd) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenConfModel1-swig.rst b/snap-python/source/doc/source/reference/GenConfModel1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..618c8aaab4adb23624035d31eb96a9d7e2141aef --- /dev/null +++ b/snap-python/source/doc/source/reference/GenConfModel1-swig.rst @@ -0,0 +1,32 @@ +GenConfModel (SWIG) +'''''''''''''''''''' + +.. function:: GenConfModel (Graph) + :noindex: + +Generate a random undirected graph using (approximately) the same node degrees as in *Graph* using the configuration model. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +Return value: + +- undirected graph + A random Snap.py undirected graph with the approximate degree sequence as in *Graph*. + + +The following example shows how to generate a random undirected graph of the same node degrees in +:class:`TUNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + for NI in Graph.Nodes(): + print(NI.GetId(), NI.GetDeg()) + + G1 = snap.GenConfModel(Graph) + for NI in G1.Nodes(): + print(NI.GetId(), NI.GetDeg()) + diff --git a/snap-python/source/doc/source/reference/GenConfModel1.rst b/snap-python/source/doc/source/reference/GenConfModel1.rst new file mode 100644 index 0000000000000000000000000000000000000000..09798e88e29e8fd6d20f63a77f45b59f71147caf --- /dev/null +++ b/snap-python/source/doc/source/reference/GenConfModel1.rst @@ -0,0 +1,32 @@ +GenConfModel +'''''''''''' + +.. function:: GenConfModel (Graph) + :noindex: + +Generate a random undirected graph using (approximately) the same node degrees as in *Graph* using the configuration model. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +Return value: + +- undirected graph + A random Snap.py undirected graph with the approximate degree sequence as in *Graph*. + + +The following example shows how to generate a random undirected graph of the same node degrees in +:class:`TUNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + for NI in Graph.Nodes(): + print(NI.GetId(), NI.GetDeg()) + + G1 = snap.GenConfModel(Graph) + for NI in G1.Nodes(): + print(NI.GetId(), NI.GetDeg()) + diff --git a/snap-python/source/doc/source/reference/GenCopyModel-swig.rst b/snap-python/source/doc/source/reference/GenCopyModel-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..93e98db7ac25ddaaddeda7cc847d3eeb6b44b0d3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenCopyModel-swig.rst @@ -0,0 +1,33 @@ +GenCopyModel (SWIG) +''''''''''''''''''' + +.. function:: GenCopyModel (Nodes, Beta, Rnd=TRnd) + :noindex: + +Generates a random scale-free network with *Nodes* nodes using the Copying Model. The generating process operates as follows: Node u is added to a graph, it selects a random +node v, and with probability *Beta* it links to v, with 1 - *Beta* links u links to +neighbor of v. + +Parameters: + +- *Nodes*: int (input) + Number of nodes in the generated graph. + +- *Beta*: float (input) + Probability used in the generating process. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- directed graph + A Snap.py directed graph generated using the Copying Model. + + +The following example shows how to generate a :class:`TNGraph` using :func:`GenCopyModel`:: + + import snap + + Graph = snap.GenCopyModel(20, 0.4, snap.TRnd()) + print("Resulting Graph: Nodes %d, Edges %d" % (Graph.GetNodes(), Graph.GetEdges())) diff --git a/snap-python/source/doc/source/reference/GenCopyModel.rst b/snap-python/source/doc/source/reference/GenCopyModel.rst new file mode 100644 index 0000000000000000000000000000000000000000..95338bed635797ef89fb341965ee8a70ffe50eb4 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenCopyModel.rst @@ -0,0 +1,32 @@ +GenCopyModel +'''''''''''' + +.. function:: GenCopyModel (Nodes, Beta, Rnd=TRnd) + +Generates a random scale-free network with *Nodes* nodes using the Copying Model. The generating process operates as follows: Node u is added to a graph, it selects a random +node v, and with probability *Beta* it links to v, with 1 - *Beta* links u links to +neighbor of v. + +Parameters: + +- *Nodes*: int (input) + Number of nodes in the generated graph. + +- *Beta*: float (input) + Probability used in the generating process. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- directed graph + A Snap.py directed graph generated using the Copying Model. + + +The following example shows how to generate a :class:`TNGraph` using :func:`GenCopyModel`:: + + import snap + + Graph = snap.GenCopyModel(20, 0.4, snap.TRnd()) + print("Resulting Graph: Nodes %d, Edges %d" % (Graph.GetNodes(), Graph.GetEdges())) diff --git a/snap-python/source/doc/source/reference/GenDegSeq-swig.rst b/snap-python/source/doc/source/reference/GenDegSeq-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5323cf4b122b5a67c8f3961609a7a7d6358275b5 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenDegSeq-swig.rst @@ -0,0 +1,39 @@ +GenDegSeq (SWIG) +'''''''''''''''' + +.. function:: GenDegSeq(DegSeqV, Rnd=TRnd) + :noindex: + +Generates an undirected random graph with the exact degree sequence given by *DegSeqV*. + +Parameters: + +- *DegSeqV*: :class:`TIntV`, a vector of ints (input) + The desired degree sequence, sorted in descending order. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A Snap.py undirected graph generated with the degree sequence given by *DegSeqV*. + + +The following example shows how to generate a random :class:`TUNGraph` with +exact degree sequence:: + + import snap + + DegSeqV = snap.TIntV() + DegSeqV.Add(3) + DegSeqV.Add(2) + DegSeqV.Add(1) + DegSeqV.Add(1) + DegSeqV.Add(1) + Rnd = snap.TRnd() + UGraph = snap.GenDegSeq(DegSeqV, Rnd) + + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenDegSeq.rst b/snap-python/source/doc/source/reference/GenDegSeq.rst new file mode 100644 index 0000000000000000000000000000000000000000..d1851fa514bcd3c0dd76f1307c6373a20427ecb1 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenDegSeq.rst @@ -0,0 +1,38 @@ +GenDegSeq +''''''''' + +.. function:: GenDegSeq(DegSeqV, Rnd=TRnd) + +Generates an undirected random graph with the exact degree sequence given by *DegSeqV*. + +Parameters: + +- *DegSeqV*: :class:`TIntV`, a vector of ints (input) + The desired degree sequence, sorted in descending order. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A Snap.py undirected graph generated with the degree sequence given by *DegSeqV*. + + +The following example shows how to generate a random :class:`TUNGraph` with +exact degree sequence:: + + import snap + + DegSeqV = snap.TIntV() + DegSeqV.Add(3) + DegSeqV.Add(2) + DegSeqV.Add(1) + DegSeqV.Add(1) + DegSeqV.Add(1) + Rnd = snap.TRnd() + UGraph = snap.GenDegSeq(DegSeqV, Rnd) + + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenForestFire-swig.rst b/snap-python/source/doc/source/reference/GenForestFire-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..7db9330573472fd8c37ce6bd4faeba2112c5eff1 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenForestFire-swig.rst @@ -0,0 +1,32 @@ +GenForestFire (SWIG) +'''''''''''''''''''' + +.. function:: GenForestFire(Nodes, FwdProb, BckProb) + :noindex: + +Generates a random Forest Fire, directed graph with given probabilities. + +Parameters: + +- *Nodes*: int (input) + Number of nodes in the directed graph, + +- *FwdProb*: float (input) + Forward probability of an edge. + +- *BckProb*: float (input) + Backward probability of an edge. + +Return value: + +- directed graph + A Snap.py directed graph generated using the Forest Fire model. + + +The following example shows how to use :func:`GenForestFire`:: + + import snap + + Graph = snap.GenForestFire(100, 0.5, 0.5) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenForestFire.rst b/snap-python/source/doc/source/reference/GenForestFire.rst new file mode 100644 index 0000000000000000000000000000000000000000..f89516887d870eca5fbb80f2f38c6f4e731bcb93 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenForestFire.rst @@ -0,0 +1,31 @@ +GenForestFire +''''''''''''' + +.. function:: GenForestFire(Nodes, FwdProb, BckProb) + +Generates a random Forest Fire, directed graph with given probabilities. + +Parameters: + +- *Nodes*: int (input) + Number of nodes in the directed graph, + +- *FwdProb*: float (input) + Forward probability of an edge. + +- *BckProb*: float (input) + Backward probability of an edge. + +Return value: + +- directed graph + A Snap.py directed graph generated using the Forest Fire model. + + +The following example shows how to use :func:`GenForestFire`:: + + import snap + + Graph = snap.GenForestFire(100, 0.5, 0.5) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenFull-swig.rst b/snap-python/source/doc/source/reference/GenFull-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..e06db86d5d329f391060118421c088bf921394e9 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenFull-swig.rst @@ -0,0 +1,37 @@ +GenFull (SWIG) +'''''''''''''' + +.. function:: GenFull(GraphType, Nodes) + :noindex: + +Generates a complete graph on *Nodes* nodes. Graph has no self-loops. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *Nodes*: int (input) + The number of nodes used to generate the graph. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate different types of fully connected graphs for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenFull(snap.PNGraph, 5) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenFull(snap.PUNGraph, 5) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenFull(snap.PNEANet, 5) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenFull.rst b/snap-python/source/doc/source/reference/GenFull.rst new file mode 100644 index 0000000000000000000000000000000000000000..6372f344abf30506b024023d6c00dbc0de634677 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenFull.rst @@ -0,0 +1,36 @@ +GenFull +''''''' + +.. function:: GenFull(GraphType, Nodes) + +Generates a complete graph on *Nodes* nodes. Graph has no self-loops. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *Nodes*: int (input) + The number of nodes used to generate the graph. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate different types of fully connected graphs for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenFull(snap.TNGraph, 5) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenFull(snap.TUNGraph, 5) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenFull(snap.TNEANet, 5) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenGeoPrefAttach-swig.rst b/snap-python/source/doc/source/reference/GenGeoPrefAttach-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f7116dc6dcb8cfecdbf98f3f9c80f66b5651c060 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenGeoPrefAttach-swig.rst @@ -0,0 +1,41 @@ +GenGeoPrefAttach (SWIG) +''''''''''''''''''''''' + +.. function:: GenGeoPrefAttach(NumNodes, NumEdges, Beta, Rnd=TRnd) + :noindex: + +Generate a random scale-free, undirected graph using the Geometric Preferential Attachment model by Flexman, Frieze and Vera. + +Parameters: + +- *NumNodes*: int (input) + The number of nodes to be created in the graph. + +- *NumEdges*: int (input) + The number of edges to add to each node. + +- *Beta*: float (input) + The beta parameter for the Geometric Preferential Attachment model. Controls the size of the radius that the algorithm will select nodes from within to which the given node will be connected to by an edge. The value + of *Beta* should be between 0 and 0.5, but may be any value. + The radius is calculated as r = n^{\beta - 1/2}\ln(n). + +- *Rnd*: :class:`TRnd` (input) + Random number generator . + +Return Value: + +- undirected graph + A Snap.py undirected graph generated using the Geometric Preferential Attachment model. + +For more information see: A geometric preferential attachment model of networks by Flexman, Frieze and Vera. WAW 2004. URL: http://math.cmu.edu/~af1p/Texfiles/GeoWeb.pdf + + +The following example shows how to generate a random scale-free, undirected graph of type :class:`TUNGraph` using the Geometric Preferential Attachment:: + + import snap + + Rnd = snap.TRnd(); + UGraph = snap.GenGeoPrefAttach(100, 10, 0.25, Rnd) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenGeoPrefAttach.rst b/snap-python/source/doc/source/reference/GenGeoPrefAttach.rst new file mode 100644 index 0000000000000000000000000000000000000000..2d86bf303246acd3f8677fadf959d3dd3594f9c6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenGeoPrefAttach.rst @@ -0,0 +1,40 @@ +GenGeoPrefAttach +'''''''''''''''' + +.. function:: GenGeoPrefAttach(NumNodes, NumEdges, Beta, Rnd=TRnd) + +Generate a random scale-free, undirected graph using the Geometric Preferential Attachment model by Flexman, Frieze and Vera. + +Parameters: + +- *NumNodes*: int (input) + The number of nodes to be created in the graph. + +- *NumEdges*: int (input) + The number of edges to add to each node. + +- *Beta*: float (input) + The beta parameter for the Geometric Preferential Attachment model. Controls the size of the radius that the algorithm will select nodes from within to which the given node will be connected to by an edge. The value + of *Beta* should be between 0 and 0.5, but may be any value. + The radius is calculated as r = n^{\beta - 1/2}\ln(n). + +- *Rnd*: :class:`TRnd` (input) + Random number generator . + +Return Value: + +- undirected graph + A Snap.py undirected graph generated using the Geometric Preferential Attachment model. + +For more information see: A geometric preferential attachment model of networks by Flexman, Frieze and Vera. WAW 2004. URL: http://math.cmu.edu/~af1p/Texfiles/GeoWeb.pdf + + +The following example shows how to generate a random scale-free, undirected graph of type :class:`TUNGraph` using the Geometric Preferential Attachment:: + + import snap + + Rnd = snap.TRnd(); + UGraph = snap.GenGeoPrefAttach(100, 10, 0.25, Rnd) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenGrid-swig.rst b/snap-python/source/doc/source/reference/GenGrid-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..b3531a61ed786155658c5f5757e89882ef573a48 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenGrid-swig.rst @@ -0,0 +1,43 @@ +GenGrid (SWIG) +'''''''''''''' + +.. function:: GenGrid(GraphType, Rows, Cols, IsDir=True) + :noindex: + +Generates a two-dimensional graph of rows and columns specified by *Rows* and *Cols* parameters. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *Rows*: int (input) + Specifies number of rows for graph. + +- *Cols*: int (input) + Specifies number of columns for graph. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate grid graphs for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenGrid(snap.PNGraph, 10, 12, False) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenGrid(snap.PUNGraph, 10, 12, False) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenGrid(snap.PNEANet, 10, 12, False) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenGrid.rst b/snap-python/source/doc/source/reference/GenGrid.rst new file mode 100644 index 0000000000000000000000000000000000000000..85eea6c86fe3371a1aeff0628160cf044d1f3b8e --- /dev/null +++ b/snap-python/source/doc/source/reference/GenGrid.rst @@ -0,0 +1,42 @@ +GenGrid +''''''' + +.. function:: GenGrid(GraphType, Rows, Cols, IsDir=True) + +Generates a two-dimensional graph of rows and columns specified by *Rows* and *Cols* parameters. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *Rows*: int (input) + Specifies number of rows for graph. + +- *Cols*: int (input) + Specifies number of columns for graph. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate grid graphs for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenGrid(snap.TNGraph, 10, 12, False) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenGrid(snap.TUNGraph, 10, 12, False) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenGrid(snap.TNEANet, 10, 12, False) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenPrefAttach-swig.rst b/snap-python/source/doc/source/reference/GenPrefAttach-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2d50bf05547a2f3151da209a3efb4ce7d2b5136b --- /dev/null +++ b/snap-python/source/doc/source/reference/GenPrefAttach-swig.rst @@ -0,0 +1,35 @@ +GenPrefAttach (SWIG) +'''''''''''''''''''' + +.. function:: GenPrefAttach(Nodes, NodesOutDeg, Rnd=TRnd) + :noindex: + +Generates an undirected graph with a power-law degree distribution using Barabasi-Albert model of scale-free graphs. + +Parameters: + +- *Nodes*: int (input) + The number of nodes desired. + +- *NodeOutDeg*: int (input) + The out degree of each node desired. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return Value: + +- undirected graph + A Snap.py undirected graph representing the power-law degree distribution. + +The function implements a Barabasi-Albert model of scale-free graphs and generates graphs with a power-law degree distribution. See: Emergence of scaling in random networks by Barabasi and Albert. URL: http://arxiv.org/abs/cond-mat/9910332 + + +The following example shows how to use :func:`GenPrefAttach`:: + + import snap + + Rnd = snap.TRnd() + UGraph = snap.GenPrefAttach(100, 10, Rnd) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenPrefAttach.rst b/snap-python/source/doc/source/reference/GenPrefAttach.rst new file mode 100644 index 0000000000000000000000000000000000000000..1ed2ed45fe381249a932e811d9197bcba0d1b5b5 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenPrefAttach.rst @@ -0,0 +1,34 @@ +GenPrefAttach +''''''''''''' + +.. function:: GenPrefAttach(Nodes, NodesOutDeg, Rnd=TRnd) + +Generates an undirected graph with a power-law degree distribution using Barabasi-Albert model of scale-free graphs. + +Parameters: + +- *Nodes*: int (input) + The number of nodes desired. + +- *NodeOutDeg*: int (input) + The out degree of each node desired. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return Value: + +- undirected graph + A Snap.py undirected graph representing the power-law degree distribution. + +The function implements a Barabasi-Albert model of scale-free graphs and generates graphs with a power-law degree distribution. See: Emergence of scaling in random networks by Barabasi and Albert. URL: http://arxiv.org/abs/cond-mat/9910332 + + +The following example shows how to use :func:`GenPrefAttach`:: + + import snap + + Rnd = snap.TRnd() + UGraph = snap.GenPrefAttach(100, 10, Rnd) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenRMat-swig.rst b/snap-python/source/doc/source/reference/GenRMat-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5825a9245ce7264f4aa73b659b4ada83fbf6522b --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRMat-swig.rst @@ -0,0 +1,44 @@ +GenRMat (SWIG) +'''''''''''''' + +.. function:: GenRMat(Nodes, Edges, A, B, C, Rnd=TRnd) + :noindex: + +Generates an R-MAT directed graph using recursive descent into a 2x2 matrix [A,B; C, 1-(A+B+C)]. + +Parameters: + +- *Nodes*: int (input) + The number of nodes used to generate the graph. + +- *Edges*: int (input) + The number of edges used to generate the graph. + +- *A*: float (input) + Probability of an edge falling into the A partition in the R-MAT model. + +- *B*: float (input) + Probability of an edge falling into the B partition in the R-MAT model. + +- *C*: float (input) + Probability of an edge falling into the C partition in the R-MAT model. + +- *Rnd*: :class:`TRnd` (input) + Random number generator . + +Return value: + +- directed graph + A Snap.py directed R-MAT graph. + +For more info see: "R-MAT Generator: A Recursive Model for Graph Mining." D. Chakrabarti, Y. Zhan and C. Faloutsos, in SIAM Data Mining 2004. URL: http://www.cs.cmu.edu/~deepay/mywww/papers/siam04.pdf + + +The following example shows how to generate an R-MAT graph:: + + import snap + + Rnd = snap.TRnd() + Graph = snap.GenRMat(1000, 2000, .6, .1, .15, Rnd) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenRMat.rst b/snap-python/source/doc/source/reference/GenRMat.rst new file mode 100644 index 0000000000000000000000000000000000000000..b1c7dda61f4f215e277c5e2c74dae6a49ef14ae3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRMat.rst @@ -0,0 +1,43 @@ +GenRMat +''''''' + +.. function:: GenRMat(Nodes, Edges, A, B, C, Rnd=TRnd) + +Generates an R-MAT directed graph using recursive descent into a 2x2 matrix [A,B; C, 1-(A+B+C)]. + +Parameters: + +- *Nodes*: int (input) + The number of nodes used to generate the graph. + +- *Edges*: int (input) + The number of edges used to generate the graph. + +- *A*: float (input) + Probability of an edge falling into the A partition in the R-MAT model. + +- *B*: float (input) + Probability of an edge falling into the B partition in the R-MAT model. + +- *C*: float (input) + Probability of an edge falling into the C partition in the R-MAT model. + +- *Rnd*: :class:`TRnd` (input) + Random number generator . + +Return value: + +- directed graph + A Snap.py directed R-MAT graph. + +For more info see: "R-MAT Generator: A Recursive Model for Graph Mining." D. Chakrabarti, Y. Zhan and C. Faloutsos, in SIAM Data Mining 2004. URL: http://www.cs.cmu.edu/~deepay/mywww/papers/siam04.pdf + + +The following example shows how to generate an R-MAT graph:: + + import snap + + Rnd = snap.TRnd() + Graph = snap.GenRMat(1000, 2000, .6, .1, .15, Rnd) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenRMatEpinions-swig.rst b/snap-python/source/doc/source/reference/GenRMatEpinions-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..da309213958bcde5d05f07f198c84a95f2584479 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRMatEpinions-swig.rst @@ -0,0 +1,28 @@ +GenRMatEpinions (SWIG) +'''''''''''''''''''''' + +.. function:: GenRMatEpinions() + :noindex: + +Generates an R-Mat directed graph, with a synthetic copy of the Epinions social network. + +Parameters: + +- None + +Return value: + +- directed graph + A Snap.py directed graph which is a synthetic copy of the Epinions social network. + +R-Mat generator with parameters set so that it generates a synthetic copy of the Epinions social network. The original Epinions social network can be downloaded at http://snap.stanford.edu/data/soc-Epinions1.html . This function is equivalent to GenRMat(75888, 508837, 0.550, 0.228, 0.212). + + +The following example shows how to generate a synthetic R-Mat with the same parameters as the Epinions social network:: + + import snap + + Graph = snap.GenRMatEpinions() + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenRMatEpinions.rst b/snap-python/source/doc/source/reference/GenRMatEpinions.rst new file mode 100644 index 0000000000000000000000000000000000000000..4642ce55190cb44af585545f405f1bc892e2de78 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRMatEpinions.rst @@ -0,0 +1,27 @@ +GenRMatEpinions +''''''''''''''' + +.. function:: GenRMatEpinions() + +Generates an R-Mat directed graph, with a synthetic copy of the Epinions social network. + +Parameters: + +- None + +Return value: + +- directed graph + A Snap.py directed graph which is a synthetic copy of the Epinions social network. + +R-Mat generator with parameters set so that it generates a synthetic copy of the Epinions social network. The original Epinions social network can be downloaded at http://snap.stanford.edu/data/soc-Epinions1.html . This function is equivalent to GenRMat(75888, 508837, 0.550, 0.228, 0.212). + + +The following example shows how to generate a synthetic R-Mat with the same parameters as the Epinions social network:: + + import snap + + Graph = snap.GenRMatEpinions() + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenRewire-swig.rst b/snap-python/source/doc/source/reference/GenRewire-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..1135f3c70d485d7a734ac69e8f7b6ce337700d5e --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRewire-swig.rst @@ -0,0 +1,38 @@ +GenRewire (SWIG) +'''''''''''''''' + +.. function:: GenRewire (Graph, NSwitch, Rnd=TRnd) + :noindex: + +Rewires an undirected *Graph* by randomly rewiring its edges while keeping the degrees the same. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *NSwitch*: int (input) + An integer that specifies the number of switches. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + The Snap.py undirected rewired graph. + + +The following example shows how to use :func:`GenRewire` with nodes in +:class:`TUNGraph`:: + + import snap + + GIn = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + for EI in GIn.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Rnd = snap.TRnd() + GOut = snap.GenRewire(Graph, 100, Rnd) + for EI in GOut.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenRewire.rst b/snap-python/source/doc/source/reference/GenRewire.rst new file mode 100644 index 0000000000000000000000000000000000000000..9ba297cd3bd41bfcbc2a9db036859de5850eecd0 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRewire.rst @@ -0,0 +1,37 @@ +GenRewire +''''''''' + +.. function:: GenRewire (Graph, NSwitch, Rnd=TRnd) + +Rewires an undirected *Graph* by randomly rewiring its edges while keeping the degrees the same. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *NSwitch*: int (input) + An integer that specifies the number of switches. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + The Snap.py undirected rewired graph. + + +The following example shows how to use :func:`GenRewire` with nodes in +:class:`TUNGraph`:: + + import snap + + GIn = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + for EI in GIn.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Rnd = snap.TRnd() + GOut = snap.GenRewire(GIn, 100, Rnd) + for EI in GOut.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenRndDegK-swig.rst b/snap-python/source/doc/source/reference/GenRndDegK-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..928b31a85fcdae3a783430bc17069f744b08ce28 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRndDegK-swig.rst @@ -0,0 +1,39 @@ +GenRndDegK (SWIG) +''''''''''''''''' + +.. function:: GenRndDegK(Nodes, NodeDeg, NSwitch=100, Rnd=TRnd) + :noindex: + +Generates a random graph with *Nodes* nodes, which each have a degree of exactly *NodeDeg*. + +Parameters: + +- *Nodes*: int (input) + Number of nodes desired in output graph. + +- *NodeDeg*: int (input) + Degree of nodes desired in output graph. + +- *NSwitch*: int (input) + Average number of switches to make per edge. More switches means a more random graph. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + + A Snap.py undirected graph randomly generated. + +The following example shows how to generate random graphs with control +over the aforementioned attributes:: + + import snap + + UGraph = snap.GenRndDegK(1000, 10) + + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(UGraph, DegToCntV) + for item in DegToCntV: + print("degree %d: count %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GenRndDegK.rst b/snap-python/source/doc/source/reference/GenRndDegK.rst new file mode 100644 index 0000000000000000000000000000000000000000..7dedcb930f026286f969c1f0e88bef9e7e8c3da8 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRndDegK.rst @@ -0,0 +1,38 @@ +GenRndDegK +'''''''''' + +.. function:: GenRndDegK(Nodes, NodeDeg, NSwitch=100, Rnd=TRnd) + +Generates a random graph with *Nodes* nodes, which each have a degree of exactly *NodeDeg*. + +Parameters: + +- *Nodes*: int (input) + Number of nodes desired in output graph. + +- *NodeDeg*: int (input) + Degree of nodes desired in output graph. + +- *NSwitch*: int (input) + Average number of switches to make per edge. More switches means a more random graph. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + + A Snap.py undirected graph randomly generated. + +The following example shows how to generate random graphs with control +over the aforementioned attributes:: + + import snap + + UGraph = snap.GenRndDegK(1000, 10) + + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(UGraph, DegToCntV) + for item in DegToCntV: + print("degree %d: count %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GenRndGnm-swig.rst b/snap-python/source/doc/source/reference/GenRndGnm-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2a29b577afe76ea91eeeaf3b24f2af85e6fad9c8 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRndGnm-swig.rst @@ -0,0 +1,47 @@ +GenRndGnm (SWIG) +'''''''''''''''' + +.. function:: GenRndGnm(GraphType, Nodes, Edges, IsDir=True, Rnd=TRnd) + :noindex: + +Generates an Erdos-Renyi random graph of the specified *GraphType*. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *Nodes*: int (input) + Number of nodes in the generated graph. + +- *Edges*: int (input) + Number of edges in the genereated graph. + +- *IsDir*: bool (input) + Indicates whether to consider the edges as directed or undirected. Defaults to directed. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate random graphs of types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenRndGnm.rst b/snap-python/source/doc/source/reference/GenRndGnm.rst new file mode 100644 index 0000000000000000000000000000000000000000..a50863866c080e7b7385f251e00e1fb74344c429 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRndGnm.rst @@ -0,0 +1,46 @@ +GenRndGnm +''''''''' + +.. function:: GenRndGnm(GraphType, Nodes, Edges, IsDir=True, Rnd=TRnd) + +Generates an Erdos-Renyi random graph of the specified *GraphType*. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *Nodes*: int (input) + Number of nodes in the generated graph. + +- *Edges*: int (input) + Number of edges in the genereated graph. + +- *IsDir*: bool (input) + Indicates whether to consider the edges as directed or undirected. Defaults to directed. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate random graphs of types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenRndPowerLaw-swig.rst b/snap-python/source/doc/source/reference/GenRndPowerLaw-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c3a654b28d5e2e4eb50438c1bce2b977df401ef3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRndPowerLaw-swig.rst @@ -0,0 +1,39 @@ +GenRndPowerLaw (SWIG) +''''''''''''''''''''' + +.. function:: GenRndPowerLaw (Nodes, PowerExp, ConfModel=True, Rnd=TRnd) + :noindex: + +Generates a random scale-free graph with power-law degree distribution with exponent *PowerExp*. The method uses either the Configuration model (fast but the result is approximate) or the Edge Rewiring method (slow but exact). + +Parameters: + +- *Nodes*: int (input) + Number of nodes. + +- *PowerExp*: float (input) + Power exponent, which must be greater than 1. + +- *ConfModel*: bool (input) + Whether the method uses the Configuration model. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A Snap.py undirected, random, scale-free graph. + + +The following example shows how to create :class:`PUNGraph` with this function:: + + import snap + + UGraph1 = snap.GenRndPowerLaw (9, 10) + for NI in UGraph1.Nodes(): + print("node: %d, out-degree %d, in-degree %d" % (NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) + + UGraph2 = snap.GenRndPowerLaw (5, 2, False) + for NI in UGraph2.Nodes(): + print("node: %d, out-degree %d, in-degree %d" % (NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) diff --git a/snap-python/source/doc/source/reference/GenRndPowerLaw.rst b/snap-python/source/doc/source/reference/GenRndPowerLaw.rst new file mode 100644 index 0000000000000000000000000000000000000000..82706192dc385f155ea3facf55abaebca31bc209 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenRndPowerLaw.rst @@ -0,0 +1,38 @@ +GenRndPowerLaw +'''''''''''''' + +.. function:: GenRndPowerLaw (Nodes, PowerExp, ConfModel=True, Rnd=TRnd) + +Generates a random scale-free graph with power-law degree distribution with exponent *PowerExp*. The method uses either the Configuration model (fast but the result is approximate) or the Edge Rewiring method (slow but exact). + +Parameters: + +- *Nodes*: int (input) + Number of nodes. + +- *PowerExp*: float (input) + Power exponent, which must be greater than 1. + +- *ConfModel*: bool (input) + Whether the method uses the Configuration model. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A Snap.py undirected, random, scale-free graph. + + +The following example shows how to create :class:`TUNGraph` with this function:: + + import snap + + UGraph1 = snap.GenRndPowerLaw (9, 10) + for NI in UGraph1.Nodes(): + print("node: %d, out-degree %d, in-degree %d" % (NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) + + UGraph2 = snap.GenRndPowerLaw (5, 2, False) + for NI in UGraph2.Nodes(): + print("node: %d, out-degree %d, in-degree %d" % (NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) diff --git a/snap-python/source/doc/source/reference/GenSmallWorld-swig.rst b/snap-python/source/doc/source/reference/GenSmallWorld-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..8acfe9b207db6db7709e99af29a2172bc56daee6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenSmallWorld-swig.rst @@ -0,0 +1,43 @@ +GenSmallWorld (SWIG) +'''''''''''''''''''' + +.. function:: GenSmallWorld(Nodes, NodeOutDeg, RewireProb, Rnd=TRnd) + :noindex: + +Generates and returns a random small-world graph using the Watts-Strogatz model. We assume a circle where each node creates links to *NodeOutDeg* other nodes. + +Parameters: + +- *Nodes*: int (input) + The number of nodes desired. + +- *NodeOutDeg*: int (input) + The out degree of each node desired. Since the generated graph is undirected, the out degree for each node, on average, will be twice this value. + +- *RewireProb*: float (input) + Represents the probability that an edge will be rewired. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A Snap.py undirected graph generated with the Watts-Strogatz model. + +See: Collective dynamics of 'small-world' networks. Watts and Strogatz. URL: http://research.yahoo.com/files/w_s_NATURE_0.pdf + + +The following example shows how to generate a small-world graph for various values of *RewireProb*:: + + import snap + + Rnd = snap.TRnd(1,0) + UGraph1 = snap.GenSmallWorld(10, 3, 0, Rnd) + for EI in UGraph1.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph2 = snap.GenSmallWorld(10, 3, 0.7, Rnd) + for EI in UGraph2.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenSmallWorld.rst b/snap-python/source/doc/source/reference/GenSmallWorld.rst new file mode 100644 index 0000000000000000000000000000000000000000..e10e84c41e5cbad10c291553399408d5cf819114 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenSmallWorld.rst @@ -0,0 +1,42 @@ +GenSmallWorld +''''''''''''' + +.. function:: GenSmallWorld(Nodes, NodeOutDeg, RewireProb, Rnd=TRnd) + +Generates and returns a random small-world graph using the Watts-Strogatz model. We assume a circle where each node creates links to *NodeOutDeg* other nodes. + +Parameters: + +- *Nodes*: int (input) + The number of nodes desired. + +- *NodeOutDeg*: int (input) + The out degree of each node desired. Since the generated graph is undirected, the out degree for each node, on average, will be twice this value. + +- *RewireProb*: float (input) + Represents the probability that an edge will be rewired. + +- *Rnd*: :class:`TRnd` (input) + Random number generator. + +Return value: + +- undirected graph + A Snap.py undirected graph generated with the Watts-Strogatz model. + +See: Collective dynamics of 'small-world' networks. Watts and Strogatz. URL: http://research.yahoo.com/files/w_s_NATURE_0.pdf + + +The following example shows how to generate a small-world graph for various values of *RewireProb*:: + + import snap + + Rnd = snap.TRnd(1,0) + UGraph1 = snap.GenSmallWorld(10, 3, 0, Rnd) + for EI in UGraph1.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph2 = snap.GenSmallWorld(10, 3, 0.7, Rnd) + for EI in UGraph2.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GenStar-swig.rst b/snap-python/source/doc/source/reference/GenStar-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..14fe01b84e27b07c47b34a38fe4a4487bbce9d6b --- /dev/null +++ b/snap-python/source/doc/source/reference/GenStar-swig.rst @@ -0,0 +1,40 @@ +GenStar (SWIG) +'''''''''''''' + +.. function:: GenStar (GraphType, Nodes, IsDir=True) + :noindex: + +Generates a graph with star topology. Node id 0 is in the center and then links to all other nodes. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *Nodes*: int (input) + Number of nodes in the star graph, including the center node. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate a star graph with five nodes using :func:`GenStar` for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenStar(snap.PNGraph, 5, True) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenStar(snap.PUNGraph, 5, True) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenStar(snap.PNEANet, 5, True) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenStar.rst b/snap-python/source/doc/source/reference/GenStar.rst new file mode 100644 index 0000000000000000000000000000000000000000..6061d85065f3528134bde470c19304b181c3f325 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenStar.rst @@ -0,0 +1,39 @@ +GenStar +''''''' + +.. function:: GenStar (GraphType, Nodes, IsDir=True) + +Generates a graph with star topology. Node id 0 is in the center and then links to all other nodes. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *Nodes*: int (input) + Number of nodes in the star graph, including the center node. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +Return value: + +- graph + A Snap.py graph of the specified type. + + +The following example shows how to generate a star graph with five nodes using :func:`GenStar` for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenStar(snap.TNGraph, 5, True) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenStar(snap.TUNGraph, 5, True) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenStar(snap.TNEANet, 5, True) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GenTree-swig.rst b/snap-python/source/doc/source/reference/GenTree-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5a8d212116838627ae4cc386a75de972611b8c73 --- /dev/null +++ b/snap-python/source/doc/source/reference/GenTree-swig.rst @@ -0,0 +1,48 @@ +GenTree (SWIG) +'''''''''''''' + +.. function:: GenTree(GraphType, Fanout, Levels, IsDir=True, ChildPointsToParent=True) + :noindex: + +Generates a tree graph of *Levels* levels with every parent having *Fanout* children. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *Fanout*: int (input) + Number of children of each parent node. + +- *Levels*: int (input) + Number of levels of the tree. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +- *ChildPointsToParent*: bool (input) + True if children should point to their parents. Only applies to directed graphs. + +Return Value: + +- graph + A Snap.py graph of the specified type. + + +The following examples shows how to generate a tree graph for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.PNGraph, 3, 3) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenTree(snap.PUNGraph, 3, 3) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenTree(snap.PNEANet, 3, 3) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + diff --git a/snap-python/source/doc/source/reference/GenTree.rst b/snap-python/source/doc/source/reference/GenTree.rst new file mode 100644 index 0000000000000000000000000000000000000000..dc12d57b5c43e9b7fc657dd403c0d3ba9bc00b4e --- /dev/null +++ b/snap-python/source/doc/source/reference/GenTree.rst @@ -0,0 +1,47 @@ +GenTree +''''''' + +.. function:: GenTree(GraphType, Fanout, Levels, IsDir=True, ChildPointsToParent=True) + +Generates a tree graph of *Levels* levels with every parent having *Fanout* children. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *Fanout*: int (input) + Number of children of each parent node. + +- *Levels*: int (input) + Number of levels of the tree. + +- *IsDir*: bool (input) + Indicates whether the edges should be directed or undirected. Defaults to directed. + +- *ChildPointsToParent*: bool (input) + True if children should point to their parents. Only applies to directed graphs. + +Return Value: + +- graph + A Snap.py graph of the specified type. + + +The following examples shows how to generate a tree graph for classes :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.TNGraph, 3, 3) + for EI in Graph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenTree(snap.TUNGraph, 3, 3) + for EI in UGraph.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenTree(snap.TNEANet, 3, 3) + for EI in Network.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + diff --git a/snap-python/source/doc/source/reference/Get1CnCom-swig.rst b/snap-python/source/doc/source/reference/Get1CnCom-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..e104eedd561f33204a72d579eef7094a11e4b3a7 --- /dev/null +++ b/snap-python/source/doc/source/reference/Get1CnCom-swig.rst @@ -0,0 +1,33 @@ +Get1CnCom (SWIG) +'''''''''''''''' + +.. function:: Get1CnCom(Graph, Cn1ComV) + :noindex: + +Returns 1-components: maximal connected components of that can be disconnected from the *Graph* by removing a single edge. + +Parameters: + +- *Graph*: undirected graph (input) + An undirected Snap.py graph. + +- *Cn1ComV*: :class:`TCnComV`, a vector of connected components (output) + The vector of 1-components, each of which consists of a vector of node ids. + +Return Value: + +- None + + +The following example shows how to get the 1-components with +:class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + CnComs = snap.TCnComV() + snap.Get1CnCom(UGraph, CnComs) + + for CnCom in CnComs: + for NI in CnCom: + print(NI) diff --git a/snap-python/source/doc/source/reference/Get1CnCom.rst b/snap-python/source/doc/source/reference/Get1CnCom.rst new file mode 100644 index 0000000000000000000000000000000000000000..6160abad8770d259cf407f32f2873492c0f88c22 --- /dev/null +++ b/snap-python/source/doc/source/reference/Get1CnCom.rst @@ -0,0 +1,27 @@ +Get1CnCom +''''''''' + +.. function:: Get1CnCom() + +A graph method for undirected graphs that returns 1-components: maximal connected components of that can be disconnected from a graph by removing a single edge. + +Parameters: + +- None + +Return Value: + +- *Cn1ComV*: :class:`TCnComV`, a vector of connected components + The vector of 1-components, each of which consists of a vector of node ids. + + +The following example shows how to get the 1-components with +:class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + CnComs = UGraph.Get1CnCom() + for CnCom in CnComs: + for NI in CnCom: + print(NI) diff --git a/snap-python/source/doc/source/reference/Get1CnComSzCnt-swig.rst b/snap-python/source/doc/source/reference/Get1CnComSzCnt-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c7f36145832ed2e6574af296841251e38c39f506 --- /dev/null +++ b/snap-python/source/doc/source/reference/Get1CnComSzCnt-swig.rst @@ -0,0 +1,31 @@ +Get1CnComSzCnt (SWIG) +''''''''''''''''''''' + +.. function:: Get1CnComSzCnt (Graph, SzCntV) + :noindex: + +Returns a distribution of sizes of 1-components: maximal connected components of that can be disconnected from the *Graph* by removing a single edge. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *SzCntV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of pairs (number of nodes in the 1-component, number of such components). + +Return value: + +- None + + +The following example shows how to get distribution of sizes of 1-components in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 100) + szCntV = snap.TIntPrV() + + snap.Get1CnComSzCnt(UGraph, szCntV) + for item in szCntV: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/Get1CnComSzCnt.rst b/snap-python/source/doc/source/reference/Get1CnComSzCnt.rst new file mode 100644 index 0000000000000000000000000000000000000000..02758bdad89f0f88d15ad739cc3bfe8da05f0f99 --- /dev/null +++ b/snap-python/source/doc/source/reference/Get1CnComSzCnt.rst @@ -0,0 +1,25 @@ +Get1CnComSzCnt +'''''''''''''' + +.. function:: Get1CnComSzCnt () + +A graph method for undirected graphs that returns a distribution of sizes of 1-components: maximal connected components of that can be disconnected from a graph by removing a single edge. + +Parameters: + +- None + +Return value: + +- *SzCntV*: :class:`TIntPrV`, a vector of (int, int) pairs + A vector of pairs (number of nodes in the 1-component, number of such components). + + +The following example shows how to get distribution of sizes of 1-components in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 100) + szCntV = UGraph.Get1CnComSzCnt() + for item in szCntV: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetAnf-swig.rst b/snap-python/source/doc/source/reference/GetAnf-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..6b5561ccd2508194cbf6ec35866449079d19a28b --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnf-swig.rst @@ -0,0 +1,60 @@ +GetAnf (SWIG) +''''''''''''' + +.. function:: GetAnf(Graph, SrcNId, DistNbrsV, MxDist, IsDir, NApprox=32) + :noindex: + +Approximate neighborhood function of a node. Prints the (approximate) number of nodes reachable from *SrcNId* in less than *MxDist* hops. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *SrcNId*: int (input) + The node id for the starting node. + +- *DistNbrsV*: :class:`TIntFltKdV`, a vector of (integer, float) pairs (output) + Maps between the distance H (in hops) and the number of nodes reachable in <= H hops. + +- *MxDist*: int (input) + Maximum number of hops the algorithm spreads from *SrcNId*. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +- *Napprox*: int (input) + Quality of approximation. See the ANF paper. Should be a multiple of 8. + +Return value: + +- None + +The ANF paper: http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf + + +The following example shows how to use :func:`GetAnf` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + SrcNId = 0 + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, SrcNId, DistNbrsV, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + SrcNId = 0 + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(UGraph, SrcNId, DistNbrsV, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + SrcNId = 0 + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Network, SrcNId, DistNbrsV, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) diff --git a/snap-python/source/doc/source/reference/GetAnf1-swig.rst b/snap-python/source/doc/source/reference/GetAnf1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..30d9525354d349a322cdaf318977b44437d71abd --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnf1-swig.rst @@ -0,0 +1,54 @@ +GetAnf (SWIG) +''''''''''''' + +.. function:: GetAnf(Graph, DistNbrsV, MxDist, IsDir, NApprox=32) + :noindex: + +Approximate Neighborhood Function of *Graph*. Returns the number of pairs of nodes reachable in less than or equal to H hops. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *DistNbrsV*: :class:`TIntFltKd`, a vector of (int, float) pairs (output) + Maps between the distance H (in hops) and the number of nodes reachable in <= H hops. + +- *MxDist*: int (input) + Maximum number of hops the algorithm takes between pairs. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +- *NApprox*: int (input) + Quality of approximation. See the ANF paper (link below). Should be a multiple of 8. + +Return value: + +- None + +The ANF paper: http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf + + +The following example shows how to use :func:`GetAnf` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, DistNbrsV, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(UGraph, DistNbrsV, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Network, DistNbrsV, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) diff --git a/snap-python/source/doc/source/reference/GetAnfEffDiam-swig.rst b/snap-python/source/doc/source/reference/GetAnfEffDiam-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..263c4aafd49c097faaf5a9b5f40cfcbda9b76e5c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnfEffDiam-swig.rst @@ -0,0 +1,40 @@ +GetAnfEffDiam (SWIG) +'''''''''''''''''''' + +.. function:: GetAnfEffDiam(Graph, IsDir, Percentile, NApprox) + :noindex: + +Returns a given *Percentile* of the shortest path length distribution of a *Graph* (based on a single run of ANF of approximation quality *NApprox*). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *IsDir*: boolean (input) + Indicates whether the edges should be considered directed or undirected. + +- *Percentile*: float (input) + Percentile of the shortest path length distribution of a Graph. + +- *NApprox*: int (input) + Quality of approximation. Should be a multiple of 8. + +Return value: + +- float + the given *Percentile* of the shortest path length distribution. + +The following example shows how to use this function +with graphs :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.GetAnfEffDiam(Graph, False, 0.9, 16) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.GetAnfEffDiam(UGraph, False, 0.9, 16) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.GetAnfEffDiam(Network, False, 0.9, 16) diff --git a/snap-python/source/doc/source/reference/GetAnfEffDiam.rst b/snap-python/source/doc/source/reference/GetAnfEffDiam.rst new file mode 100644 index 0000000000000000000000000000000000000000..4d12525a7615489cfa1e6b6dbcc80d95fd7f4018 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnfEffDiam.rst @@ -0,0 +1,36 @@ +GetAnfEffDiam +''''''''''''' + +.. function:: GetAnfEffDiam(IsDir, Percentile, NApprox) + +A graph method that returns a given *Percentile* of the shortest path length distribution (based on a single run of ANF of approximation quality *NApprox*). + +Parameters: + +- *IsDir*: boolean + Indicates whether the edges should be considered directed or undirected. + +- *Percentile*: float + Percentile of the shortest path length distribution. + +- *NApprox*: int + Quality of approximation. Should be a multiple of 8. + +Return value: + +- float + the given *Percentile* of the shortest path length distribution. + +The following example shows how to use this function +with :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + print(Graph.GetAnfEffDiam(False, 0.9, 16)) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + print(UGraph.GetAnfEffDiam(False, 0.9, 16)) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + print(Network.GetAnfEffDiam(False, 0.9, 16)) diff --git a/snap-python/source/doc/source/reference/GetAnfEffDiam1-swig.rst b/snap-python/source/doc/source/reference/GetAnfEffDiam1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..eb8461fe91fcc9385ad42678d49f900cc75813bc --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnfEffDiam1-swig.rst @@ -0,0 +1,39 @@ +GetAnfEffDiam (SWIG) +'''''''''''''''''''' + +.. function:: GetAnfEffDiam(Graph, NRuns=1, NApprox=-1) + :noindex: + +Returns a 90th percentile of the shortest path length distribution of a Graph (based on a NRuns runs of Approximate Neighborhood Function of approximation quality NApprox). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NRuns*: int (input) + Number of runs of the Approximate Neighborhood Function (ANF). Default value is 1. + +- *NApprox*: int (input) + Number of approximations. Default value is -1. + +Return value: + +- float + the given 90th of the shortest path length distribution. + +For more info see: http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf + +The following example shows how to calculate the ANF Effective Diameter for a graph +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.GetAnfEffDiam(Graph) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.GetAnfEffDiam(UGraph) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.GetAnfEffDiam(Network) diff --git a/snap-python/source/doc/source/reference/GetAnfEffDiam1.rst b/snap-python/source/doc/source/reference/GetAnfEffDiam1.rst new file mode 100644 index 0000000000000000000000000000000000000000..c8b0565ba2933288b02be3300bb6119d5c9164c9 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnfEffDiam1.rst @@ -0,0 +1,36 @@ +GetAnfEffDiam +''''''''''''' + +.. function:: GetAnfEffDiam(NRuns=1, NApprox=-1) + :noindex: + +A graph method that returns a 90th percentile of the shortest path length distribution of a Graph (based on a NRuns runs of Approximate Neighborhood Function of approximation quality NApprox). + +Parameters: + +- (Optional) *NRuns*: int + Number of runs of the Approximate Neighborhood Function (ANF). Default value is 1. + +- (Optional) *NApprox*: int + Number of approximations. Default value is -1. + +Return value: + +- float + the given 90th of the shortest path length distribution. + +For more info see: http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf + +The following example shows how to calculate the ANF Effective Diameter for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + print(Graph.GetAnfEffDiam()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + print(UGraph.GetAnfEffDiam()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + print(Network.GetAnfEffDiam()) diff --git a/snap-python/source/doc/source/reference/GetAnfGraph.rst b/snap-python/source/doc/source/reference/GetAnfGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..c4f6728cdab1cc009f48d20b780b833c33e40730 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnfGraph.rst @@ -0,0 +1,45 @@ +GetAnfGraph +''''''''''' + +.. function:: GetAnfGraph(MxDist, IsDir, NApprox=32) + +A graph method that calculates approximate neighborhoods. Returns the number of pairs of nodes reachable in less than or equal to H hops. + +Parameters: + +- *MxDist*: int + Maximum number of hops the algorithm takes between pairs. + +- *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +- (optional) *NApprox*: int + Quality of approximation. See the ANF paper (link below). Should be a multiple of 8. + +Return value: + +- :class:`TIntFltKd`, a vector of (int, float) pairs + Each pair gives the distance H (in hops) and the number of nodes reachable in <= H hops. + +The ANF paper: http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf + + +The following example shows how to use :func:`GetAnf` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + DistNbrsV = Graph.GetAnfGraph(3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + DistNbrsV = UGraph.GetAnfGraph(3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + DistNbrsV = Network.GetAnfGraph(3, False, 32) + for item in DistNbrsV: + print(item.Dat()) diff --git a/snap-python/source/doc/source/reference/GetAnfNode.rst b/snap-python/source/doc/source/reference/GetAnfNode.rst new file mode 100644 index 0000000000000000000000000000000000000000..c6db5c13e56e55930319763524a8bb265275456e --- /dev/null +++ b/snap-python/source/doc/source/reference/GetAnfNode.rst @@ -0,0 +1,51 @@ +GetAnfNode +'''''''''' + +.. function:: GetAnfNode(SrcNId, MxDist, IsDir, NApprox=32) + +A graph method that returns approximate neighborhood sizes of a node. Prints the (approximate) number of nodes reachable from *SrcNId* in less than *MxDist* hops. + +Parameters: + +- *SrcNId*: int + The node id for the starting node. + +- *MxDist*: int + Maximum number of hops the algorithm spreads from *SrcNId*. + +- *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +- (optional) *Napprox*: int + Quality of approximation. See the ANF paper. Should be a multiple of 8. + +Return value: + +- :class:`TIntFltKdV`, a vector of (integer, float) pairs + Each pair gives the distance H (in hops) and the number of nodes reachable in <= H hops. + +The ANF paper: http://www.cs.cmu.edu/~christos/PUBLICATIONS/kdd02-anf.pdf + + +The following example shows how to use :func:`GetAnf` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + SrcNId = 0 + DistNbrsV = Graph.GetAnfNode(SrcNId, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + SrcNId = 0 + DistNbrsV = UGraph.GetAnfNode(SrcNId, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + SrcNId = 0 + DistNbrsV = Network.GetAnfNode(SrcNId, 3, False, 32) + for item in DistNbrsV: + print(item.Dat()) diff --git a/snap-python/source/doc/source/reference/GetArtPoints-swig.rst b/snap-python/source/doc/source/reference/GetArtPoints-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c77270aec8878a963507dffee07979098ce6e399 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetArtPoints-swig.rst @@ -0,0 +1,36 @@ +GetArtPoints (SWIG) +''''''''''''''''''' + +.. function:: GetArtPoints(InGraph,ArtNIdV) + :noindex: + +Returns articulation points of an undirected *InGraph*. + +Parameters: + +- *InGraph*: undirected graph (input) + A Snap.py undirected graph. + +- *ArtNIdV*: :class:`TIntV`, a vector of ints (output) + The node ids of the articulation points in the grpah *InGraph*. + +Return value: + +- None + +For more info see: http://www.geeksforgeeks.org/articulation-points-or-cut-vertices-in-a-graph/ + + +The following example shows how to find articulation points in a graph of type +:class:`TNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 1000, 10) + ArtNIdV = snap.TIntV() + snap.GetArtPoints(UGraph, ArtNIdV) + + print("Articulation points of a random Undirected Graph : ") + for NI in ArtNIdV: + print("node: %d" % NI) + diff --git a/snap-python/source/doc/source/reference/GetArtPoints.rst b/snap-python/source/doc/source/reference/GetArtPoints.rst new file mode 100644 index 0000000000000000000000000000000000000000..21fc6f2bf156cb6ef50599cdfd1e911a9ad3877c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetArtPoints.rst @@ -0,0 +1,30 @@ +GetArtPoints +'''''''''''' + +.. function:: GetArtPoints() + +A graph method for undirected graphs that returns articulation points of a graph. + +Parameters: + +- None + +Return value: + +- *ArtNIdV*: :class:`TIntV`, a vector of ints + The node ids of the articulation points in the graph. + +For more info see: http://www.geeksforgeeks.org/articulation-points-or-cut-vertices-in-a-graph/ + + +The following example shows how to find articulation points in a graph of type +:class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 1000, 10) + ArtNIdV = UGraph.GetArtPoints() + print("Articulation points of a random Undirected Graph : ") + for NI in ArtNIdV: + print("node: %d" % NI) + diff --git a/snap-python/source/doc/source/reference/GetBetweennessCentr-swig.rst b/snap-python/source/doc/source/reference/GetBetweennessCentr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..b67e578a7892533a68e30048dc0a8a48908c422a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBetweennessCentr-swig.rst @@ -0,0 +1,66 @@ +GetBetweennessCentr (SWIG) +'''''''''''''''''''''''''' + +.. function:: GetBetweennessCentr(Graph, NIdBtwH, EdgeBtwH, NodeFrac=1.0, IsDir=False) + :noindex: + +Computes (approximate) Node and Edge Betweenness Centrality based on a sample of *NodeFrac* nodes. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdBtwH*: :class:`TIntFltH`, a hash table with int keys and float values (output) + Hash table mapping node ids to their corresponding betweenness centrality values. + +- *EdgeBtwH*: :class:`TIntPrFltH`, a hash table with int pair keys and float values (output) + Hash table mapping edges (provided as pairs of node ids) to their corresponding betweenness centrality values. + +- *NodeFrac*: float (input) + Quality of the approximation. NodeFrac=1.0 gives exact betweenness values. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed (*True*) or undirected (*False*). + +Return Value: + +- None + +See "A Faster Algorithm for Betweenness Centrality", Ulrik Brandes, Journal of Mathematical Sociology, 2001, and "Centrality Estimation in Large Networks", Urlik Brandes and Christian Pich, 2006 for more details. + + +The following example shows how to calculate Betweenness Centrality scores for nodes and edges in +:class:`TNGraph`, +:class:`TUNGraph`, and +:class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Nodes = snap.TIntFltH() + Edges = snap.TIntPrFltH() + snap.GetBetweennessCentr(Graph, Nodes, Edges, 1.0) + for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) + for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Nodes = snap.TIntFltH() + Edges = snap.TIntPrFltH() + snap.GetBetweennessCentr(UGraph, Nodes, Edges, 1.0) + for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) + for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Nodes = snap.TIntFltH() + Edges = snap.TIntPrFltH() + snap.GetBetweennessCentr(Network, Nodes, Edges, 1.0) + for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) + for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + diff --git a/snap-python/source/doc/source/reference/GetBetweennessCentr.rst b/snap-python/source/doc/source/reference/GetBetweennessCentr.rst new file mode 100644 index 0000000000000000000000000000000000000000..aa883e3ec3e6208160ce4ee3d4269d3730e023d8 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBetweennessCentr.rst @@ -0,0 +1,54 @@ +GetBetweennessCentr +''''''''''''''''''' + +.. function:: GetBetweennessCentr(NodeFrac=1.0, IsDir=False) + +A graph method that computes (approximate) Node and Edge Betweenness Centrality based on a sample of *NodeFrac* nodes. + +Parameters: + +- (optional) *NodeFrac*: float + Quality of the approximation. NodeFrac=1.0 gives exact betweenness values. + +- (optional) *IsDir*: bool + Indicates whether the edges should be considered directed (*True*) or undirected (*False*). + +Return Value: + +- *NIdBtwH*: :class:`TIntFltH`, a hash table with int keys and float values + Hash table mapping node ids to their corresponding betweenness centrality values. + +- *EdgeBtwH*: :class:`TIntPrFltH`, a hash table with int pair keys and float values + Hash table mapping edges (provided as pairs of node ids) to their corresponding betweenness centrality values. + +See "A Faster Algorithm for Betweenness Centrality", Ulrik Brandes, Journal of Mathematical Sociology, 2001, and "Centrality Estimation in Large Networks", Urlik Brandes and Christian Pich, 2006 for more details. + + +The following example shows how to calculate Betweenness Centrality scores for nodes and edges in +:class:`TNGraph`, +:class:`TUNGraph`, and +:class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Nodes, Edges = Graph.GetBetweennessCentr(1.0) + for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) + for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Nodes, Edges = UGraph.GetBetweennessCentr(1.0) + for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) + for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Nodes, Edges = Network.GetBetweennessCentr(1.0) + for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) + for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + diff --git a/snap-python/source/doc/source/reference/GetBfsEffDiam-swig.rst b/snap-python/source/doc/source/reference/GetBfsEffDiam-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d486c2e8e368b9b0b073405f48a545d86d298713 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsEffDiam-swig.rst @@ -0,0 +1,46 @@ +GetBfsEffDiam (SWIG) +'''''''''''''''''''' + +.. function:: GetBfsEffDiam(Graph, NTestNodes, IsDir=False) + :noindex: + +Returns the (approximation of the) Effective Diameter (90-th percentile of the distribution of shortest path lengths) of a graph (by performing BFS from NTestNodes random starting nodes). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NTestNodes*: int (input) + The number of random start nodes to use in the BFS used to calculate the graph diameter and effective diameter. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- float + The (approximation of the) Effective Diameter of a graph. + +The following example shows how to calculate BfsEffDiam for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NTestNodes = 10 + IsDir = False + EffDiam = snap.GetBfsEffDiam(Graph, NTestNodes, IsDir) + print(EffDiam) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NTestNodes = 10 + IsDir = False + EffDiam = snap.GetBfsEffDiam(UGraph, NTestNodes, IsDir) + print(EffDiam) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NTestNodes = 10 + IsDir = False + EffDiam = snap.GetBfsEffDiam(Network, NTestNodes, IsDir) + print(EffDiam) diff --git a/snap-python/source/doc/source/reference/GetBfsEffDiam.rst b/snap-python/source/doc/source/reference/GetBfsEffDiam.rst new file mode 100644 index 0000000000000000000000000000000000000000..6a5ca78e63aee46f4b0bf1ad9d4537791ef943cb --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsEffDiam.rst @@ -0,0 +1,42 @@ +GetBfsEffDiam +''''''''''''' + +.. function:: GetBfsEffDiam(NTestNodes, IsDir=False) + +A graph method that returns the (approximation of the) Effective Diameter (90-th percentile of the distribution of shortest path lengths) of a graph (by performing BFS from NTestNodes random starting nodes). + +Parameters: + +- *NTestNodes*: int + The number of random start nodes to use in the BFS used to calculate the graph diameter and effective diameter. + +- *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- float + The (approximation of the) Effective Diameter of a graph. + +The following example shows how to calculate BfsEffDiam for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NTestNodes = 10 + IsDir = False + EffDiam = Graph.GetBfsEffDiam(NTestNodes, IsDir) + print(EffDiam) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NTestNodes = 10 + IsDir = False + EffDiam = UGraph.GetBfsEffDiam(NTestNodes, IsDir) + print(EffDiam) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NTestNodes = 10 + IsDir = False + EffDiam = Network.GetBfsEffDiam(NTestNodes, IsDir) + print(EffDiam) diff --git a/snap-python/source/doc/source/reference/GetBfsEffDiam1-swig.rst b/snap-python/source/doc/source/reference/GetBfsEffDiam1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..bbcea779741fb215c940c4d3d582006d6dd79111 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsEffDiam1-swig.rst @@ -0,0 +1,57 @@ +GetBfsEffDiam (SWIG) +'''''''''''''''''''' + +.. function:: GetBfsEffDiam(Graph, NTestNodes, SubGraphNIdV, IsDir) + :noindex: + +Uses the entire graph (all edges) to measure the shortest path lengths but reports only the path lengths between nodes in SubGraphNIdV. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NTestNodes*: int (input) + Number of starting nodes for calculating path lengths. + +- *SubGraphNIdV*: TIntV - vector of ints (input) + List of nodes in the subgraph for which the path lengths will be reported. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- list: [float, float, int] + The list contains three elements: the first and the second element are + the 90th-percentile approximation for the average shortest path length + among the nodes in SubGraphNIdV, the third element is the diameter. + +Notes: + +- There are three other versions of GetBfsEffDiam with different parameters. + + +The following example shows how to calculate the average shortest path length +for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Num = 50 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + Result = snap.GetBfsEffDiam(Graph, Num, List, True) + print(Result) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Num = 75 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + Result = snap.GetBfsEffDiam(Graph, Num, List, False) + print(Result) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Num = 33 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + Result = snap.GetBfsEffDiam(Graph, Num, List, True) + print(Result) + diff --git a/snap-python/source/doc/source/reference/GetBfsEffDiam1.rst b/snap-python/source/doc/source/reference/GetBfsEffDiam1.rst new file mode 100644 index 0000000000000000000000000000000000000000..4712c1ab0176234556e9aca817d59a511018df26 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsEffDiam1.rst @@ -0,0 +1,54 @@ +GetBfsEffDiam +''''''''''''' + +.. function:: GetBfsEffDiam(NTestNodes, SubGraphNIdV, IsDir) + :noindex: + +A graph method that uses the entire graph (all edges) to measure the shortest path lengths but reports only the path lengths between nodes in *SubGraphNIdV*. + +Parameters: + +- *NTestNodes*: int + Number of starting nodes for calculating path lengths. + +- *SubGraphNIdV*: Python list or TIntV - vector of ints + List of nodes in the subgraph for which the path lengths will be reported. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- list: [float, float, int] + The list contains three elements: the first and the second element are + the 90th-percentile approximation for the average shortest path length + among the nodes in SubGraphNIdV, the third element is the diameter. + +Notes: + +- There is another version of GetBfsEffDiam with different parameters. + + +The following example shows how to calculate the average shortest path length +for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Num = 50 + Nodes = [ 1, 4, 9, 16, 25, 36 ] + Result = Graph.GetBfsEffDiam(Num, Nodes, True) + print(Result) + + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Num = 75 + Nodes = [ 1, 4, 9, 16, 25, 36 ] + Result = Graph.GetBfsEffDiam(Num, Nodes, False) + print(Result) + + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Num = 33 + Nodes = [ 1, 4, 9, 16, 25, 36 ] + Result = Graph.GetBfsEffDiam(Num, Nodes, True) + print(Result) + diff --git a/snap-python/source/doc/source/reference/GetBfsEffDiamAll-swig.rst b/snap-python/source/doc/source/reference/GetBfsEffDiamAll-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..6ad8c60b9bad4c0dd8530432e2c9a5c7f3d37d44 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsEffDiamAll-swig.rst @@ -0,0 +1,44 @@ +GetBfsEffDiamAll (SWIG) +''''''''''''''''''''''' + +.. function:: GetBfsEffDiamAll(Graph, NTestNode, IsDir) + :noindex: + +Returns the approximation of the effective diameter, the diameter, and +the average shortest path length in a graph. Does this by performing +BFS from *NTestNodes* random starting nodes. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NTestNodes*: int (input) + The number of random start nodes to use in the BFS used to calculate the graph diameter and effective diameter. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- list: [ float, float, int, float ] + The list contains four elements: the first and the second element are + the effective diameter of the graph, the third element is the diameter, + and the fourth element is the average shortest path length. + +The following example shows how to calculate an effective diameter:: + + import snap + + G = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + result = snap.GetBfsEffDiamAll(G, 10, False) + print(result) + + G = snap.GenRndGnm(snap.PNGraph, 100, 1000) + result = snap.GetBfsEffDiamAll(G, 10, False) + print(result) + + G = snap.GenRndGnm(snap.PNEANet, 100, 1000) + result = snap.GetBfsEffDiamAll(G, 10, False) + print(result) + diff --git a/snap-python/source/doc/source/reference/GetBfsEffDiamAll.rst b/snap-python/source/doc/source/reference/GetBfsEffDiamAll.rst new file mode 100644 index 0000000000000000000000000000000000000000..ff7c29c181a26f4a2588eb2e8baad1a3ce58a7f7 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsEffDiamAll.rst @@ -0,0 +1,39 @@ +GetBfsEffDiamAll +'''''''''''''''' + +.. function:: GetBfsEffDiamAll(NTestNode, IsDir) + +A graph method that returns the approximation of the effective diameter, the diameter, and the average shortest path length in a graph. Does this by performing +BFS from *NTestNodes* random starting nodes. + +Parameters: + +- *NTestNodes*: int + The number of random start nodes to use in the BFS used to calculate the graph diameter and effective diameter. + +- *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- list: [ float, float, int, float ] + The list contains four elements: the first and the second element are + the effective diameter of the graph, the third element is the diameter, + and the fourth element is the average shortest path length. + +The following example shows how to calculate an effective diameter:: + + import snap + + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + result = Graph.GetBfsEffDiamAll(10, False) + print(result) + + UGraph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + result = UGraph.GetBfsEffDiamAll(10, False) + print(result) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + result = Network.GetBfsEffDiamAll(10, False) + print(result) + diff --git a/snap-python/source/doc/source/reference/GetBfsFullDiam-swig.rst b/snap-python/source/doc/source/reference/GetBfsFullDiam-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..3a6511b05f7f77ee93ae3315624322d3879add62 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsFullDiam-swig.rst @@ -0,0 +1,43 @@ +GetBfsFullDiam (SWIG) +''''''''''''''''''''' + +.. function:: GetBfsFullDiam (Graph, NTestNodes, IsDir=false) + :noindex: + +Computes the diameter, or 'longest shortest path', of a *Graph* by performing a breadth first search over the *Graph*. This diameter is approximate, as it is calculated with an *NTestNodes* number of random starting nodes. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NTestNodes*: int (input) + Number of starting test nodes. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- int + Approximate diameter of the graph. + +For more info see: http://mathworld.wolfram.com/GraphDiameter.html + + +The following example shows how to calculate diameters for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + diam = snap.GetBfsFullDiam(Graph, 100, False) + print(diam) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + diam = snap.GetBfsFullDiam(UGraph, 100, False) + print(diam) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + diam = snap.GetBfsFullDiam(Network, 100, False) + print(diam) diff --git a/snap-python/source/doc/source/reference/GetBfsFullDiam.rst b/snap-python/source/doc/source/reference/GetBfsFullDiam.rst new file mode 100644 index 0000000000000000000000000000000000000000..23cfacb31a63c82d40bce76e63bc4a8fe4ed438c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsFullDiam.rst @@ -0,0 +1,39 @@ +GetBfsFullDiam +'''''''''''''' + +.. function:: GetBfsFullDiam (NTestNodes, IsDir=false) + +A graph method that computes the diameter, or 'longest shortest path', of a graph by performing a breadth first search. This diameter is approximate, as it is calculated with an *NTestNodes* number of random starting nodes. + +Parameters: + +- *NTestNodes*: int + Number of starting test nodes. + +- *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- int + Approximate diameter of the graph. + +For more info see: http://mathworld.wolfram.com/GraphDiameter.html + + +The following example shows how to calculate diameters for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + diam = Graph.GetBfsFullDiam(100, False) + print(diam) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + diam = UGraph.GetBfsFullDiam(100, False) + print(diam) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + diam = Network.GetBfsFullDiam(100, False) + print(diam) diff --git a/snap-python/source/doc/source/reference/GetBfsTree-swig.rst b/snap-python/source/doc/source/reference/GetBfsTree-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..0b14bf4f1e8a85df1cb8b86cb32e3dbad8d33882 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsTree-swig.rst @@ -0,0 +1,47 @@ +GetBfsTree (SWIG) +''''''''''''''''' + +.. function:: GetBfsTree(Graph, StartNId, FollowOut, FollowIn) + :noindex: + +Returns a directed Breadth-First-Search tree rooted at *StartNId*. The nodes in the tree correspond to those of *Graph*, and the edges represent the edges traversed by the breadth-first search on *Graph* starting from *StartNId*. The tree is created by traversing along out-links (parameter *FollowOut* = True) and/or in-links (parameter *FollowIn* = True). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *StartNId*: int (input) + Id of the root node of the Breadth-First-Search tree. + +- *FollowOut*: bool (input) + A bool specifying if the graph should be constructed by following the outward links. + +- *FollowIn*: bool (input) + A bool specifying if the graph should be constructed by following inward links. + +Return value: + +- directed graph + A Snap.py directed graph whose nodes correspond to those of the original graph and whose edges represent the edges traversed by the breadth-first search. + + +The following examples show how to use :func:`GetBfsTree` with graphs of type +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + BfsTree = snap.GetBfsTree(Graph, 1, True, False) + for EI in BfsTree.Edges(): + print("Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + BfsTree = snap.GetBfsTree(UGraph, 1, True, False) + for EI in BfsTree.Edges(): + print("Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + BfsTree = snap.GetBfsTree(Network, 1, True, False) + for EI in BfsTree.Edges(): + print("Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetBfsTree.rst b/snap-python/source/doc/source/reference/GetBfsTree.rst new file mode 100644 index 0000000000000000000000000000000000000000..bf1462f019a735146f8529482a5d1f5d96b87d4c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBfsTree.rst @@ -0,0 +1,43 @@ +GetBfsTree +'''''''''' + +.. function:: GetBfsTree(StartNId, FollowOut, FollowIn) + +A graph method that returns a directed Breadth-First-Search tree rooted at *StartNId*. The nodes in the tree correspond to those of the graph, and the edges represent the edges traversed by the breadth-first search on the graph starting from *StartNId*. The tree is created by traversing along out-links (parameter *FollowOut* = True) and/or in-links (parameter *FollowIn* = True). + +Parameters: + +- *StartNId*: int + Id of the root node of the Breadth-First-Search tree. + +- *FollowOut*: bool + A bool specifying if the graph should be constructed by following the outward links. + +- *FollowIn*: bool + A bool specifying if the graph should be constructed by following inward links. + +Return value: + +- directed graph + A directed graph whose nodes correspond to those of the original graph and whose edges represent the edges traversed by the breadth-first search. + + +The following examples show how to use :func:`GetBfsTree` with graphs of type +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + BfsTree = Graph.GetBfsTree(1, True, False) + for EI in BfsTree.Edges(): + print("Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + BfsTree = UGraph.GetBfsTree(1, True, False) + for EI in BfsTree.Edges(): + print("Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + BfsTree = Network.GetBfsTree(1, True, False) + for EI in BfsTree.Edges(): + print("Edge from %d to %d in generated tree." % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetBiCon-swig.rst b/snap-python/source/doc/source/reference/GetBiCon-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5432f389bb9712ced49f8bfc19f7f3d467a87d31 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBiCon-swig.rst @@ -0,0 +1,32 @@ +GetBiCon (SWIG) +''''''''''''''' + +.. function:: GetBiCon(Graph, BiCnComV) + :noindex: + +Returns all bi-connected components of a Graph. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *BiCnComV*: :class:`TCnComV`, a vector of connected components (output) + A vector of bi-connected components. Each component is defined by the IDs of its member nodes. + +Return value: + +- None + + +The following example shows how to print out representations of the bi-connected components of a :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + V = snap.TCnComV() + snap.GetBiCon(UGraph, V) + for CnCom in V: + for NI in CnCom: + print(NI) + print("---------------") diff --git a/snap-python/source/doc/source/reference/GetBiCon.rst b/snap-python/source/doc/source/reference/GetBiCon.rst new file mode 100644 index 0000000000000000000000000000000000000000..882c3d78e63471b77375e2c0715e790ef8bb0d37 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBiCon.rst @@ -0,0 +1,27 @@ +GetBiCon +'''''''' + +.. function:: GetBiCon() + +A graph method for undirected graphs that returns all bi-connected components of a graph. + +Parameters: + +- None + +Return value: + +- *BiCnComV*: :class:`TCnComV`, a vector of connected components + A vector of bi-connected components. Each component is defined by the ids of its member nodes. + + +The following example shows how to print out representations of the bi-connected components of a :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + V = UGraph.GetBiCon() + for CnCom in V: + for NI in CnCom: + print(NI) + print("---------------") diff --git a/snap-python/source/doc/source/reference/GetBiConSzCnt-swig.rst b/snap-python/source/doc/source/reference/GetBiConSzCnt-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..6d8308a1ad8018ee45e2caeda7b625ed558df181 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBiConSzCnt-swig.rst @@ -0,0 +1,31 @@ +GetBiConSzCnt (SWIG) +'''''''''''''''''''' + +.. function:: GetBiConSzCnt(Graph, SzCntV) + :noindex: + +Returns a distribution of bi-connected component sizes. A bi-connected component is a maximal subgraph with no articulation points. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *SzCntV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of pairs (number of nodes in the bi-component, number of such components). + +Return value: + +- None + + +The following example shows how to calculate bi-connected component size +distribution in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 100) + SzCntV = snap.TIntPrV() + snap.GetBiConSzCnt(UGraph, SzCntV) + for item in SzCntV: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetBiConSzCnt.rst b/snap-python/source/doc/source/reference/GetBiConSzCnt.rst new file mode 100644 index 0000000000000000000000000000000000000000..52f3a8d59697fb2c8045c3767c16ce957fe7cca2 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetBiConSzCnt.rst @@ -0,0 +1,26 @@ +GetBiConSzCnt +''''''''''''' + +.. function:: GetBiConSzCnt() + +A graph method for undirected graphs that returns a distribution of bi-connected component sizes. A bi-connected component is a maximal subgraph with no articulation points. + +Parameters: + +- None + +Return value: + +- *SzCntV*: :class:`TIntPrV`, a vector of (int, int) pairs + A vector of pairs (number of nodes in the bi-component, number of such components). + + +The following example shows how to calculate bi-connected component size +distribution in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 100) + SzCntV = UGraph.GetBiConSzCnt() + for item in SzCntV: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetClosenessCentr-swig.rst b/snap-python/source/doc/source/reference/GetClosenessCentr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..dcb3c29bf055b41c8e18331f19d872a2079c7c87 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetClosenessCentr-swig.rst @@ -0,0 +1,50 @@ +GetClosenessCentr (SWIG) +'''''''''''''''''''''''' + +.. function:: GetClosenessCentr(Graph, NId, Normalized=True, IsDir=False) + :noindex: + +Returns closeness centrality of a given node *NId* in *Graph*. Closeness centrality is equal to 1/farness centrality. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId*: int (input) + A node id in *Graph*. + +- *Normalized*: bool (input) + Output should be normalized (*True*) or not (*False*). + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed (*True*) or undirected (*False*). + + +Return value: + +- float + The closeness centrality of the node *NId* in *Graph*. + + +The following example shows how to get the closeness centrality for nodes in +:class:`TNGraph`, +:class:`TUNGraph`, and +:class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + for NI in Graph.Nodes(): + CloseCentr = snap.GetClosenessCentr(Graph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + for NI in UGraph.Nodes(): + CloseCentr = snap.GetClosenessCentr(UGraph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + for NI in Network.Nodes(): + CloseCentr = snap.GetClosenessCentr(Network, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) diff --git a/snap-python/source/doc/source/reference/GetClosenessCentr.rst b/snap-python/source/doc/source/reference/GetClosenessCentr.rst new file mode 100644 index 0000000000000000000000000000000000000000..5c8265582c3e906d62b87cb4c9d6a1f1ef9431db --- /dev/null +++ b/snap-python/source/doc/source/reference/GetClosenessCentr.rst @@ -0,0 +1,46 @@ +GetClosenessCentr +''''''''''''''''' + +.. function:: GetClosenessCentr(NId, Normalized=True, IsDir=False) + +A graph method that returns closeness centrality of a given node *NId*. Closeness centrality is equal to 1/farness centrality. + +Parameters: + +- *NId*: int + A node id in *Graph*. + +- (optional) *Normalized*: bool + Output should be normalized (*True*) or not (*False*). + +- (optional) *IsDir*: bool + Indicates whether the edges should be considered directed (*True*) or undirected (*False*). + + +Return value: + +- float + The closeness centrality of the node *NId*. + + +The following example shows how to get the closeness centrality for nodes in +:class:`TNGraph`, +:class:`TUNGraph`, and +:class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + for NI in Graph.Nodes(): + CloseCentr = Graph.GetClosenessCentr(NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + for NI in UGraph.Nodes(): + CloseCentr = UGraph.GetClosenessCentr(NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + for NI in Network.Nodes(): + CloseCentr = Network.GetClosenessCentr(NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) diff --git a/snap-python/source/doc/source/reference/GetClustCf-swig.rst b/snap-python/source/doc/source/reference/GetClustCf-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2dc5ce169237c24cd64b744957b4e4d24014d1b1 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetClustCf-swig.rst @@ -0,0 +1,41 @@ +GetClustCf (SWIG) +''''''''''''''''' + +.. function:: GetClustCf (Graph, SampleNodes=-1) + :noindex: + +Computes the average clustering coefficient as defined in Watts and Strogatz, Collective dynamics of 'small-world' networks + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *SampleNodes*: int (input) + If !=-1 then compute clustering coefficient only for a random sample of SampleNodes nodes. Useful for approximate but quick computations. + +Return value: + +- float + The clustering coefficient for *Graph*. + +For more info see: http://en.wikipedia.org/wiki/Clustering_coefficient + +The following example shows how to calculate the average clustering coefficient in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + GraphClustCoeff = snap.GetClustCf (Graph, -1) + print("Clustering coefficient: %f" % GraphClustCoeff) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + GraphClustCoeff = snap.GetClustCf (UGraph, -1) + print("Clustering coefficient: %f" % GraphClustCoeff) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + GraphClustCoeff = snap.GetClustCf (Network, -1) + print("Clustering coefficient: %f" % GraphClustCoeff) + + diff --git a/snap-python/source/doc/source/reference/GetClustCf.rst b/snap-python/source/doc/source/reference/GetClustCf.rst new file mode 100644 index 0000000000000000000000000000000000000000..959d5681855706226fee4658611b2df56c44cfde --- /dev/null +++ b/snap-python/source/doc/source/reference/GetClustCf.rst @@ -0,0 +1,56 @@ +GetClustCf +'''''''''' + +.. function:: GetClustCf (CCfByDeg=False, SampleNodes=-1) + +A graph method that computes the average clustering coefficient as defined in Watts and Strogatz, Collective dynamics of 'small-world' networks. + +Parameters: + +- (optional) *CCfByDeg*: bool + If *CCfByDeg* is true, then return a vector of (degree, avg. clustering coefficient of nodes of that degree) pairs in addition to the clustering coefficient. + +- (optional) *SampleNodes*: int + If *SampleNodes* is -1 (default value), then compute the clustering coefficient over all the nodes. Otherwise, compute the clustering coefficient using only a random sample of *SampleNodes* nodes. + +Return value: + +- float + The clustering coefficient. + +- (optional) :class:`TFltPrV` + A vector of (degree, avg. clustering coefficient of nodes of that degree) pairs, returned when *CCfByDeg* is true. + +For more info see: http://en.wikipedia.org/wiki/Clustering_coefficient. + +The following example shows how to calculate the average clustering coefficient in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + GraphClustCoeff = Graph.GetClustCf(-1) + print("Clustering coefficient: %f" % GraphClustCoeff) + Cf, CfVec = Graph.GetClustCf(True, -1) + print("Average Clustering Coefficient: %f" % (Cf)) + print("Coefficients by degree:\n") + for pair in CfVec: + print("degree: %d, clustering coefficient: %f" % (pair.GetVal1(), pair.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + GraphClustCoeff = UGraph.GetClustCf(-1) + print("Clustering coefficient: %f" % GraphClustCoeff) + Cf, CfVec = UGraph.GetClustCf(True, -1) + print("Average Clustering Coefficient: %f" % (Cf)) + print("Coefficients by degree:\n") + for pair in CfVec: + print("degree: %d, clustering coefficient: %f" % (pair.GetVal1(), pair.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + GraphClustCoeff = Network.GetClustCf(-1) + print("Clustering coefficient: %f" % GraphClustCoeff) + Cf, CfVec = Network.GetClustCf(True, -1) + print("Average Clustering Coefficient: %f" % (Cf)) + print("Coefficients by degree:\n") + for pair in CfVec: + print("degree: %d, clustering coefficient: %f" % (pair.GetVal1(), pair.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetClustCf1-swig.rst b/snap-python/source/doc/source/reference/GetClustCf1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..87d4e70c780751313cc9ba15cd8edc53be20cf16 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetClustCf1-swig.rst @@ -0,0 +1,52 @@ +GetClustCf (SWIG) +''''''''''''''''' + +.. function:: GetClustCf(Graph, DegToCCfV, SampleNodes=-1) + :noindex: + +Computes the distribution of average clustering coefficient. Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *DegToCCfV*: :class:`TFltPrV`, a vector of float pairs (output) + Vector of (degree, avg. clustering coefficient of nodes of that degree) pairs. + +- *SampleNodes*: int (input) + If !=-1 then compute clustering coefficient only for a random sample of SampleNodes nodes. Useful for approximate but quick computations. + +Return value: + +- float + Average clustering coefficient over all node degrees. + +The following example shows how to compute the clustering coefficient distribution in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + CfVec = snap.TFltPrV() + Cf = snap.GetClustCf(Graph, CfVec, -1) + print("Average Clustering Coefficient: %f" % (Cf)) + print("Coefficients by degree:\n") + for pair in CfVec: + print("degree: %d, clustering coefficient: %f" % (pair.GetVal1(), pair.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + CfVec = snap.TFltPrV() + Cf = snap.GetClustCf(UGraph, CfVec, -1) + print("Average Clustering Coefficient: %f" % (Cf)) + print("Coefficients by degree:\n") + for pair in CfVec: + print("degree: %d, clustering coefficient: %f" % (pair.GetVal1(), pair.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + CfVec = snap.TFltPrV() + Cf = snap.GetClustCf(Network, CfVec, -1) + print("Average Clustering Coefficient: %f" % (Cf)) + print("Coefficients by degree:\n") + for pair in CfVec: + print("degree: %d, clustering coefficient: %f" % (pair.GetVal1(), pair.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetClustCfAll-swig.rst b/snap-python/source/doc/source/reference/GetClustCfAll-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..92daa1e3f9d6d139d3ce7d5116a93f2d9f7eab8c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetClustCfAll-swig.rst @@ -0,0 +1,59 @@ +GetClustCfAll (SWIG) +'''''''''''''''''''' + +.. function:: GetClustCfAll (Graph, DegToCCfV, SampleNodes=-1) + :noindex: + +Computes the average clustering coefficient, as well as the number of open and closed triads in the graph, as defined in Watts and Strogatz, Collective dynamics of 'small-world' networks. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *DegToCCfV*: a vector of pairs of floats (output) + The vector of pairs (degree, avg. clustering coefficient of nodes of that degree) + +- *SampleNodes*: int (input) + If !=-1 then compute clustering coefficient only for a random sample of SampleNodes nodes + +Return value: + +- list: [float, int, int] + The list contains three elements: the average clustering coefficient, + the number of closed triads, and the number of open triads in the graph. + +For more info see: http://en.wikipedia.org/wiki/Watts_and_Strogatz_model + +The following example shows how to compute the in degree for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + DegToCCfV = snap.TFltPrV() + result = snap.GetClustCfAll(Graph, DegToCCfV) + for item in DegToCCfV: + print("degree: %d, clustering coefficient: %f" % (item.GetVal1(), item.GetVal2())) + print("average clustering coefficient", result[0]) + print("closed triads", result[1]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + DegToCCfV = snap.TFltPrV() + result = snap.GetClustCfAll(Graph, DegToCCfV) + for item in DegToCCfV: + print("degree: %d, clustering coefficient: %f" % (item.GetVal1(), item.GetVal2())) + print("average clustering coefficient", result[0]) + print("closed triads", result[1]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + DegToCCfV = snap.TFltPrV() + result = snap.GetClustCfAll(Graph, DegToCCfV) + for item in DegToCCfV: + print("degree: %d, clustering coefficient: %f" % (item.GetVal1(), item.GetVal2())) + print("average clustering coefficient", result[0]) + print("closed triads", result[1]) + print("open triads", result[2]) + diff --git a/snap-python/source/doc/source/reference/GetClustCfAll.rst b/snap-python/source/doc/source/reference/GetClustCfAll.rst new file mode 100644 index 0000000000000000000000000000000000000000..dd1333241bb66ee83fcc4373d37ad37a5c074b35 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetClustCfAll.rst @@ -0,0 +1,52 @@ +GetClustCfAll +''''''''''''' + +.. function:: GetClustCfAll (SampleNodes=-1) + +A graph method that computes the average clustering coefficient, as well as the number of open and closed triads in the graph, as defined in Watts and Strogatz, Collective dynamics of 'small-world' networks. + +Parameters: + +- (optional) *SampleNodes*: int + If *SampleNodes* is -1 (default value), then compute the clustering coefficient over all the nodes. Otherwise, compute the clustering coefficient using only a random sample of *SampleNodes* nodes. + +Return value: + +- list: [float, int, int] + The list contains three elements: the average clustering coefficient, + the number of closed triads, and the number of open triads in the graph. + +- :class:`TFltPrV` + The vector of pairs (degree, avg. clustering coefficient of nodes of that degree) + +For more info see: http://en.wikipedia.org/wiki/Watts_and_Strogatz_model + +The following example shows how to compute the in degree for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + result, DegToCCfV = Graph.GetClustCfAll() + for item in DegToCCfV: + print("degree: %d, clustering coefficient: %f" % (item.GetVal1(), item.GetVal2())) + print("average clustering coefficient", result[0]) + print("closed triads", result[1]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + result, DegToCCfV = Graph.GetClustCfAll() + for item in DegToCCfV: + print("degree: %d, clustering coefficient: %f" % (item.GetVal1(), item.GetVal2())) + print("average clustering coefficient", result[0]) + print("closed triads", result[1]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + result, DegToCCfV = Graph.GetClustCfAll() + for item in DegToCCfV: + print("degree: %d, clustering coefficient: %f" % (item.GetVal1(), item.GetVal2())) + print("average clustering coefficient", result[0]) + print("closed triads", result[1]) + print("open triads", result[2]) + diff --git a/snap-python/source/doc/source/reference/GetCmnNbrs-swig.rst b/snap-python/source/doc/source/reference/GetCmnNbrs-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..79ce29e61c5625743774e3d91cf253954eccccd0 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetCmnNbrs-swig.rst @@ -0,0 +1,38 @@ +GetCmnNbrs (SWIG) +''''''''''''''''' + +.. function:: GetCmnNbrs(Graph, NId1, NId2) + :noindex: + +Computes the number of shared neighbors between a pair of nodes *NId1* and *NId2*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId1*: int (input) + Node id of the first node. + +- *NId2*: int (input) + Node id of the second node. + +Return value: + +- int + The number of common neighbors between the pair of nodes. + + +The following example shows how to calculate number of neighbors for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.GetCmnNbrs(Graph, 1, 10) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.GetCmnNbrs(UGraph, 1, 10) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.GetCmnNbrs(Network, 1, 10) diff --git a/snap-python/source/doc/source/reference/GetCmnNbrs.rst b/snap-python/source/doc/source/reference/GetCmnNbrs.rst new file mode 100644 index 0000000000000000000000000000000000000000..7ec7dfbedacb2971ceadc97434d019e27de5bdc3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetCmnNbrs.rst @@ -0,0 +1,55 @@ +GetCmnNbrs +'''''''''' + +.. function:: GetCmnNbrs(NId1, NId2, NbrList = False) + +A graph method that computes the number of shared neighbors between a pair of nodes *NId1* and *NId2*. + +Parameters: + +- *NId1*: int + Node id of the first node. + +- *NId2*: int + Node id of the second node. + +- (optional) *NbrList*: bool + Specifies whether to return the list of shared neighbors *NbrV*. + +Return value: + +- int + The number of common neighbors between the pair of nodes. + +- (optional) *NbrV*: :class:`TIntV`, a string hash table with string keys and int values + It provides shared neighbors between the two nodes and is returned if *NbrList* is True. Neighbors are given by their node ids. + + +The following example shows how to calculate number of neighbors for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.GetCmnNbrs(1, 10) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.GetCmnNbrs(1, 10) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.GetCmnNbrs(1, 10) + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + numNbrs, Nbrs = Graph.GetCmnNbrs(1, 10, True) + for NId in Nbrs: + print("node: %d" % NId) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + numNbrs, Nbrs = UGraph.GetCmnNbrs(1, 10, True) + for NId in Nbrs: + print("node: %d" % NId) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + numNbrs, Nbrs = Network.GetCmnNbrs(1, 10, True) + for NId in Nbrs: + print("node: %d" % NId) diff --git a/snap-python/source/doc/source/reference/GetCmnNbrs1-swig.rst b/snap-python/source/doc/source/reference/GetCmnNbrs1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..979b0ba340ae89577159c886fdcd62705f421350 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetCmnNbrs1-swig.rst @@ -0,0 +1,48 @@ +GetCmnNbrs (SWIG) +''''''''''''''''' + +.. function:: GetCmnNbrs(Graph, NId1, NId2, NbrV) + :noindex: + +Computes the number of shared neighbors between a pair of nodes *NId1* and *NId2*. The node ids of the neighbors are stored in *NbrV*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId1*: int (input) + Node id of the first node. + +- *NId2*: int (input) + Node id of the second node. + +- *NbrV*: TIntV, vector of int (output) + Shared neighbors between the two nodes. Neighbors are node IDs. + +Return value: + +- int + The number of common neighbors between the pair of nodes. + +The following example shows how to find the shared neighbors of two nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Nbrs = snap.TIntV() + snap.GetCmnNbrs(Graph, 1, 10, Nbrs) + for NId in Nbrs: + print("node: %d" % NId) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Nbrs = snap.TIntV() + snap.GetCmnNbrs(UGraph, 1, 10, Nbrs) + for NId in Nbrs: + print("node: %d" % NId) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Nbrs = snap.TIntV() + snap.GetCmnNbrs(Network, 1, 10, Nbrs) + for NId in Nbrs: + print("node: %d" % NId) diff --git a/snap-python/source/doc/source/reference/GetDegCnt-swig.rst b/snap-python/source/doc/source/reference/GetDegCnt-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a57a9e0155ba6aa2175d4ec3783fb00467480f34 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetDegCnt-swig.rst @@ -0,0 +1,42 @@ +GetDegCnt (SWIG) +'''''''''''''''' + +.. function:: GetDegCnt(Graph, DegToCntV) + :noindex: + +Computes a degree histogram: a vector of pairs (degree, number of nodes of such degree). The results are stored in *DegToCntV*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *DegToCntV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of (degree, number of nodes of such degree) pairs. + +Return Value: + +- None + + +The following examples shows how to obtain the degree histogram for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(Graph, DegToCntV) + for item in DegToCntV: + print("%d nodes with degree %d" % (item.GetVal2(), item.GetVal1())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(UGraph, DegToCntV) + for item in DegToCntV: + print("%d nodes with degree %d" % (item.GetVal2(), item.GetVal1())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(Network, DegToCntV) + for item in DegToCntV: + print("%d nodes with degree %d" % (item.GetVal2(), item.GetVal1())) diff --git a/snap-python/source/doc/source/reference/GetDegCnt.rst b/snap-python/source/doc/source/reference/GetDegCnt.rst new file mode 100644 index 0000000000000000000000000000000000000000..f6dafe1052be2ccf8e23d574afb811f6d3607bd3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetDegCnt.rst @@ -0,0 +1,34 @@ +GetDegCnt +''''''''' + +.. function:: GetDegCnt() + +A graph method that returns the number of nodes for each degree as a vector of pairs (degree, number of nodes of such degree). + +Parameters: + +- None + +Return value: + +- *DegToCntV*: :class:`TIntPrV`, a vector of (int, int) pairs + A vector of (degree, number of nodes of such degree) pairs. + +The following examples shows how to obtain the degree histogram for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + DegToCntV = Graph.GetDegCnt() + for item in DegToCntV: + print("%d nodes with degree %d" % (item.GetVal2(), item.GetVal1())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + DegToCntV = UGraph.GetDegCnt() + for item in DegToCntV: + print("%d nodes with degree %d" % (item.GetVal2(), item.GetVal1())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + DegToCntV = Network.GetDegCnt() + for item in DegToCntV: + print("%d nodes with degree %d" % (item.GetVal2(), item.GetVal1())) diff --git a/snap-python/source/doc/source/reference/GetDegSeqV-swig.rst b/snap-python/source/doc/source/reference/GetDegSeqV-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a119205b920ba23ac7e97a29f4b19e44bef85b33 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetDegSeqV-swig.rst @@ -0,0 +1,43 @@ +GetDegSeqV (SWIG) +''''''''''''''''' + +.. function:: GetDegSeqV(Graph, DegV) + :noindex: + +Computes the degree sequence vector for nodes in *Graph*. The degree sequence vector is stored in *DegV*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *DegV*: :class:`TIntV`, a vector of ints (output) + A vector containing the degree for each node in the graph. + +Return value: + +- None + + +The following example shows how to compute the sequence vector for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` (Note that the resulting vector is not ordered by the node IDs, its elements can be in an arbitrary order. Nodes in the printout are just vector indexes.):: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + result_degree = snap.TIntV() + snap.GetDegSeqV(Graph, result_degree) + for i in range(0, result_degree.Len()): + print("Node %s has degree %s" % (i, result_degree[i])) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + result_degree = snap.TIntV() + snap.GetDegSeqV(UGraph, result_degree) + for i in range(0, result_degree.Len()): + print("Node %s has degree %s" % (i, result_degree[i])) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + result_degree = snap.TIntV() + snap.GetDegSeqV(Network, result_degree) + for i in range(0, result_degree.Len()): + print("Node %s has degree %s" % (i, result_degree[i])) diff --git a/snap-python/source/doc/source/reference/GetDegSeqV.rst b/snap-python/source/doc/source/reference/GetDegSeqV.rst new file mode 100644 index 0000000000000000000000000000000000000000..cb376c5da0801da099228393c899b514658f8d7a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetDegSeqV.rst @@ -0,0 +1,56 @@ +GetDegSeqV +'''''''''' + +.. function:: GetDegSeqV(Dir = False) + +A graph method that returns the degree of nodes in *Graph*. The degrees are stored either in a single vector *DegV* for *Dir* being False, or in a pair of vectors *InDegV* and *OutDegV* for *Dir* being True. + +Parameters: + +- *Dir*: bool + If False, edge direction is ignored. If True, edge direction is significant. + +Return value: + +- *DegV*: :class:`TIntV`, a vector of ints + If *Dir* is False, a vector containing the degree for each node in the graph. + +- *InDegV*: :class:`TIntV`, a vector of ints + If *Dir* is True, a vector containing the in-degree for each node in the graph. + +- *OutDegV*: :class:`TIntV`, a vector of ints + If *Dir* is True, a vector containing the out-degree for each node in the graph. + + +Note that the resulting vectors are not ordered by the node ids, their elements can be in an arbitrary order. Nodes in the printout below are just vector indexes, not node ids. + +The following example shows how to compute the sequence vector for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + degree = Graph.GetDegSeqV() + for i in range(0, degree.Len()): + print("Node %s has degree %s" % (i, degree[i])) + in_degree, out_degree = Graph.GetDegSeqV() + for i in range(0, in_degree.Len()): + print("Node %s has in-degree %s and out-degree %s" % (i, in_degree[i], out_degree[i])) + + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + degree = UGraph.GetDegSeqV() + for i in range(0, degree.Len()): + print("Node %s has degree %s" % (i, degree[i])) + in_degree, out_degree = UGraph.GetDegSeqV() + for i in range(0, in_degree.Len()): + print("Node %s has in-degree %s and out-degree %s" % (i, in_degree[i], out_degree[i])) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + degree = Network.GetDegSeqV() + for i in range(0, degree.Len()): + print("Node %s has degree %s" % (i, degree[i])) + in_degree, out_degree = Network.GetDegSeqV() + for i in range(0, in_degree.Len()): + print("Node %s has in-degree %s and out-degree %s" % (i, in_degree[i], out_degree[i])) + diff --git a/snap-python/source/doc/source/reference/GetDegSeqV1-swig.rst b/snap-python/source/doc/source/reference/GetDegSeqV1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..09e0c54207eebc492795537ae4634e61b5abd108 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetDegSeqV1-swig.rst @@ -0,0 +1,50 @@ +GetDegSeqV (SWIG) +''''''''''''''''' + +.. function:: GetDegSeqV(Graph, InDegV, OutDegV) + :noindex: + +Computes the in- and out- degree sequence vector for nodes in *Graph*. The degree sequence vectors are stored in *InDegV* and *OutDegV*, respectively. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *InDegV*: :class:`TIntV`, a vector of ints (output) + In-degree sequence vector. + +- *OutDegV*: :class:`TIntV`, a vector of ints (output) + Out-degree sequence vector. + +Return Value: + +- None + + +The following examples shows how to compute the in- and out-degree sequence vectors for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` (Note that the resulting vectors are not ordered by the node IDs, their elements can be in an arbitrary order. Nodes in the printout are just vector indexes.):: + + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + result_in_degree = snap.TIntV() + result_out_degree = snap.TIntV() + snap.GetDegSeqV(Graph, result_in_degree, result_out_degree) + for i in range(0, result_in_degree.Len()): + print("Node %s has in-degree %s and out-degree %s" % (i, result_in_degree[i], result_out_degree[i])) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + result_in_degree = snap.TIntV() + result_out_degree = snap.TIntV() + snap.GetDegSeqV(UGraph, result_in_degree, result_out_degree) + for i in range(0, result_in_degree.Len()): + print("Node %s has in-degree %s and out-degree %s" % (i, result_in_degree[i], result_out_degree[i])) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + result_in_degree = snap.TIntV() + result_out_degree = snap.TIntV() + snap.GetDegSeqV(Network, result_in_degree, result_out_degree) + for i in range(0, result_in_degree.Len()): + print("Node %s has in-degree %s and out-degree %s" % (i, result_in_degree[i], result_out_degree[i])) + diff --git a/snap-python/source/doc/source/reference/GetDegreeCentr-swig.rst b/snap-python/source/doc/source/reference/GetDegreeCentr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..346a757b09f552a86f28c9b5220ec165f82e0b4f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetDegreeCentr-swig.rst @@ -0,0 +1,29 @@ +GetDegreeCentr (SWIG) +''''''''''''''''''''' + +.. function:: GetDegreeCentr(Graph, NId) + :noindex: + +Returns degree centrality of a given node *NId* in *Graph*. Degree centrality of a node is defined as its degree/(N-1), where N is the number of nodes in the network. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *NId*: int (input) + A node id in *Graph*. + +Return value: + +- float + The degree centrality of the node *NId* in *Graph*. + +The following example shows how to get the degree centrality for nodes in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + for NI in UGraph.Nodes(): + DegCentr = snap.GetDegreeCentr(UGraph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), DegCentr)) diff --git a/snap-python/source/doc/source/reference/GetDegreeCentr.rst b/snap-python/source/doc/source/reference/GetDegreeCentr.rst new file mode 100644 index 0000000000000000000000000000000000000000..ccac81a2a7fc08061566e20313565cd81a2aaef1 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetDegreeCentr.rst @@ -0,0 +1,25 @@ +GetDegreeCentr +'''''''''''''' + +.. function:: GetDegreeCentr(NId) + +A graph method for undirected graphs that returns degree centrality of a given node *NId*. Degree centrality of a node is defined as its degree/(N-1), where N is the number of nodes in the graph. + +Parameters: + +- *NId*: int + A node id in *Graph*. + +Return value: + +- float + The degree centrality of the node *NId*. + +The following example shows how to get the degree centrality for nodes in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + for NI in UGraph.Nodes(): + DegCentr = UGraph.GetDegreeCentr(NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), DegCentr)) diff --git a/snap-python/source/doc/source/reference/GetESubGraph-swig.rst b/snap-python/source/doc/source/reference/GetESubGraph-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..55209e85b770e44e69d774c5351d438fa14e8b5a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetESubGraph-swig.rst @@ -0,0 +1,32 @@ +GetESubGraph (SWIG) +''''''''''''''''''' + +.. function:: GetESubGraph(Graph, EIdV) + :noindex: + +Returns a subgraph of graph *Graph*. The resulting subgraph contains all the edges from *Graph* with edge IDs in *EIdV* and all the nodes that are connected by at least one edge in *EIdV*. Nodes and edges in the resulting subgraph have the same IDs as in *Graph*. + +Parameters: + +- *Graph*: network (input) + A Snap.py network. + +- *EIdV*: :class:`TIntV`, a vector of ints (input) + A vector of edge IDs in graph. + +Return value: + +- network + A Snap.py network, which is a subgraph of *Graph* with *EIdV* edges. + + +The following example shows how to use :func:`GetESubGraph` with +:class:`TNEANet`:: + + import snap + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + EIdV = snap.TIntV() + for EI in Network.Edges(): + EIdV.Add(EI.GetId()) + ESubGraph = snap.GetESubGraph(Network, EIdV) diff --git a/snap-python/source/doc/source/reference/GetESubGraph.rst b/snap-python/source/doc/source/reference/GetESubGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..599026351fb2f692c7baf4d6e4151476c39eafe8 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetESubGraph.rst @@ -0,0 +1,28 @@ +GetESubGraph +'''''''''''' + +.. function:: GetESubGraph(EIdV) + +A graph method for that returns a subgraph of the original graph, which contains all the edges from the original graph with edge ids in *EIdV* and all the nodes that are connected by at least one edge in *EIdV*. Nodes and edges in the resulting subgraph have the same ids as in the original graph. This method is only implemented for :class:`TNEANet`. + +Parameters: + +- *EIdV*: Python list or :class:`TIntV`, a vector of ints (input) + A vector of edge ids in graph. + +Return value: + +- network + A network, which is a subgraph of the original graph with *EIdV* edges. + + +The following example shows how to use :func:`GetESubGraph` with +:class:`TNEANet`:: + + import snap + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + EIdV = [] + for EI in Network.Edges(): + EIdV.append(EI.GetId()) + ESubGraph = Network.GetESubGraph(EIdV) diff --git a/snap-python/source/doc/source/reference/GetEdgeBridges-swig.rst b/snap-python/source/doc/source/reference/GetEdgeBridges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..1b251bc5921e208eae68a58006b518d87f4bbf82 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEdgeBridges-swig.rst @@ -0,0 +1,31 @@ +GetEdgeBridges (SWIG) +''''''''''''''''''''' + +.. function:: GetEdgeBridges(Graph, EdgeV) + :noindex: + + Returns the edge bridges in *Graph* in the vector *EdgeV*. An edge is a bridge if, when removed, increases the number of connected components. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *EdgeV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + The bride edges of the graph. Each edge is represented by a node id pair. + +Return value: + +- None + + +The following example shows how to calculate number of bidirectional edges for +:class:`TNGraph` and :class:`TNEANet`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + EdgeV = snap.TIntPrV() + snap.GetEdgeBridges(UGraph, EdgeV) + for edge in EdgeV: + print("edge: (%d, %d)" % (edge.GetVal1(), edge.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetEdgeBridges.rst b/snap-python/source/doc/source/reference/GetEdgeBridges.rst new file mode 100644 index 0000000000000000000000000000000000000000..c399ee45bf8120e5956e6db892e7bc8d8fa7b7df --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEdgeBridges.rst @@ -0,0 +1,25 @@ +GetEdgeBridges +'''''''''''''' + +.. function:: GetEdgeBridges() + +A graph method for undirected graphs that returns the edge bridges in a graph. An edge is a bridge if, when removed, increases the number of connected components. + +Parameters: + +- None + +Return value: + +- *EdgeV*: :class:`TIntPrV`, a vector of (int, int) pairs + The bride edges of the graph. Each edge is represented by a node id pair. + +The following example shows how to calculate number of bidirectional edges for +:class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + EdgeV = UGraph.GetEdgeBridges() + for edge in EdgeV: + print("edge: (%d, %d)" % (edge.GetVal1(), edge.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetEdgesInOut-swig.rst b/snap-python/source/doc/source/reference/GetEdgesInOut-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2b63c7e9fde227e1f0d7ec4fc34dac9c6a2496de --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEdgesInOut-swig.rst @@ -0,0 +1,42 @@ +GetEdgesInOut (SWIG) +'''''''''''''''''''' + +.. function:: GetEdgesInOut (Graph, NIdV) + :noindex: + +Returns the number of reciprocal edges between the nodes in *NIdV* and the number of edges between the nodes in *NIdV* and the rest of the graph. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdV*: :class:`TIntV`, a vector of ints (input) + A vector of node IDs. + +Return value: + +- list: [ int, int ] + The list contains two elements: the first element gives the number of reciprocal edges between the nodes in *NIdV*, and the second element gives the number of edges between the nodes in *NIdV* and the rest of the graph. + +The following example shows how to use :func:`GetEdgesInOut` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Nodes = snap.TIntV() + for nodeId in range(10): + Nodes.Add(nodeId) + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + results = snap.GetEdgesInOut(Graph, Nodes) + print("EdgesIn: %s EdgesOut: %s" % (results[0], results[1])) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + results = snap.GetEdgesInOut(UGraph, Nodes) + print("EdgesIn: %s EdgesOut: %s" % (results[0], results[1])) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + results = snap.GetEdgesInOut(Network, Nodes) + print("EdgesIn: %s EdgesOut: %s" % (results[0], results[1])) + diff --git a/snap-python/source/doc/source/reference/GetEdgesInOut.rst b/snap-python/source/doc/source/reference/GetEdgesInOut.rst new file mode 100644 index 0000000000000000000000000000000000000000..cc6da4caa44031b0c5fe9aceab3c60e4e92c0dd6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEdgesInOut.rst @@ -0,0 +1,38 @@ +GetEdgesInOut +''''''''''''' + +.. function:: GetEdgesInOut (NIdV) + +A graph method that returns the number of reciprocal edges between the nodes in *NIdV* and the number of edges between the nodes in *NIdV* and the rest of the graph. + +Parameters: + +- *NIdV*: Python list or :class:`TIntV`, a vector of ints + A vector of node ids. + +Return value: + +- list: [ int, int ] + The list contains two elements: the first element gives the number of reciprocal edges between the nodes in *NIdV*, and the second element gives the number of edges between the nodes in *NIdV* and the rest of the graph. + +The following example shows how to use :func:`GetEdgesInOut` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Nodes = [] + for nodeId in range(10): + Nodes.append(nodeId) + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + results = Graph.GetEdgesInOut(Nodes) + print("EdgesIn: %s EdgesOut: %s" % (results[0], results[1])) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + results = UGraph.GetEdgesInOut(Nodes) + print("EdgesIn: %s EdgesOut: %s" % (results[0], results[1])) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + results = Network.GetEdgesInOut(Nodes) + print("EdgesIn: %s EdgesOut: %s" % (results[0], results[1])) + diff --git a/snap-python/source/doc/source/reference/GetEgonet.rst b/snap-python/source/doc/source/reference/GetEgonet.rst new file mode 100644 index 0000000000000000000000000000000000000000..8f314b9728f834f168dcbf5d1089b9e75d420c58 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEgonet.rst @@ -0,0 +1,35 @@ +GetEgonet +''''''''' + +.. function:: GetEgonet(NId) + +A graph method that returns an ego network of the node *NId* and the number of connecting edges. The ego network includes the node *NId*, its neighbours, and all the edges between them. Connecting edges are the edges between a node in the ego network and a node not in the network. The method is supported for :class:`TUNGraph` and :class:`TNGraph`. For :class:`TUNGraph`, connecting edges is a single value, for :class:`TNGraph`, connecting edges is represented by a pair of incoming and outgoind edges from the ego network. + +Parameters: + +- *NId*: int + Id of the center node of the ego network. + +Return value: + +- graph + A graph of the same type as the input graph, containing the ego network for *NId*. + +- edges: int + The number of connecting edges from the ego network. For :class:`TNGraph`, only incoming edges are counted here. + +- edges: int (returned only for :class:`TNGraph`): + The number of outgoing connecting edges from the ego network. + + +The following example shows how to create a subgraph for nodes in +:class:`TUNGraph`, and :class:`TNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Egonet, edges = UGraph.GetEgonet(0) + + NGraph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Egonet, edges_in, edges_out = NGraph.GetEgonet(0) + diff --git a/snap-python/source/doc/source/reference/GetEgonetHop.rst b/snap-python/source/doc/source/reference/GetEgonetHop.rst new file mode 100644 index 0000000000000000000000000000000000000000..7775e92c7bd3e94bbf5301dcb641bc945fc82b7e --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEgonetHop.rst @@ -0,0 +1,34 @@ +GetEgonetHop +'''''''''''' + +.. function:: GetEgonetHop(NId, H) + +A graph method that returns an *H* hop ego network of the node *NId*. The *H* hop ego network includes the node *NId*, its *H* hop neighbours, and all the edges between them. + +Parameters: + +- *NId*: int + Id of the center node of the ego network. + +- *H*: int + The number of hops for the ego network. + +Return value: + +- graph + A graph of the same type as the input graph, containing the ego network for *NId*. + +The following example shows how to create a subgraph for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NGraph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Egonet = NGraph.GetInEgonetHop(0, 2) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Egonet = UGraph.GetInEgonetHop(3, 1) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Egonet = Network.GetInEgonetHop(10, 3) + diff --git a/snap-python/source/doc/source/reference/GetEigVals-swig.rst b/snap-python/source/doc/source/reference/GetEigVals-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..17ec630b1c04648569293e46f83eb38f74f5c17d --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEigVals-swig.rst @@ -0,0 +1,34 @@ +GetEigVals (SWIG) +''''''''''''''''' + +.. function:: GetEigVals(Graph, EigVals, PEigV) + :noindex: + +Computes top *EigVals* eigenvalues of the adjacency matrix representing the given undirected graph *Graph*. + +Parameters: + +- *Graph*: undirected graph (input) + An undirected Snap.py graph. + +- *EigVals*: int (input) + The number of eigenvalues. + +- *PEigV*: :class:`TFltV`, a vector of floats (output) + The eigenvector of floating point values. + +Return value: + +- None + + +The following example shows how to calcualte the top *EigVals* eigenvalues for :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + EigVals = 5 + PEigV = snap.TFltV() + snap.GetEigVals(UGraph, EigVals, PEigV) + for item in PEigV: + print(item) diff --git a/snap-python/source/doc/source/reference/GetEigVals.rst b/snap-python/source/doc/source/reference/GetEigVals.rst new file mode 100644 index 0000000000000000000000000000000000000000..cf16f697439b9c6049e4937d913e4cae8342c565 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEigVals.rst @@ -0,0 +1,27 @@ +GetEigVals +'''''''''' + +.. function:: GetEigVals(EigVals) + +A graph method that computes top *EigVals* eigenvalues of the adjacency matrix representing the given undirected graph. + +Parameters: + +- *EigVals*: int + The number of eigenvalues. + +Return value: + +- :class:`TFltV`, a vector of floats + The eigenvector of floating point values. + + +The following example shows how to calcualte the top *EigVals* eigenvalues for :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + EigVals = 5 + PEigV = UGraph.GetEigVals(EigVals) + for item in PEigV: + print(item) diff --git a/snap-python/source/doc/source/reference/GetEigVec-swig.rst b/snap-python/source/doc/source/reference/GetEigVec-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..deadbcf480286f331d95a5552deba941b9dd4f77 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEigVec-swig.rst @@ -0,0 +1,31 @@ +GetEigVec (SWIG) +'''''''''''''''' + +.. function:: GetEigVec(Graph, EigVec) + :noindex: + +Computes leading eigenvector of the adjacency matrix representing an undirected *Graph*. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *EigVec*: :class:`TFltV`, a vector of floats (output) + A leading eigenvector of the adjacency matrix representing the given *Graph*. + +Return value: + +- None + + +The following example shows how to get leading eigenvector of the adjacency matrix for +:class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + EigVec = snap.TFltV() + snap.GetEigVec(UGraph, EigVec) + for Val in EigVec: + print(Val) diff --git a/snap-python/source/doc/source/reference/GetEigVec1-swig.rst b/snap-python/source/doc/source/reference/GetEigVec1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..6e88333ed87ea659ec13c7b2d18d332ff9853ef6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEigVec1-swig.rst @@ -0,0 +1,49 @@ +GetEigVec (SWIG) +'''''''''''''''' + +.. function:: GetEigVec(Graph, EigVecs, EigVal, EigVecV) + :noindex: + +Computes top EigVecs eigenvalues and eigenvectors of the adjacency matrix representing a given undirected Graph. + +Parameters: + +- *Graph*: graph (input) + A Snap.py undirected Graph. + +- *EigVecs*: int (input) + Rank of eigenvalues and eigenvectors that should be outputted. + +- *EigValV*: TFltV, a vector of floats (output) + Eigenvalues. + +- *EigVecV*: TFltVFltV> (output) + Eigenvectors. + +Return value: + +- None + +For more info see: http://en.wikipedia.org/wiki/GetEigVec + +The following example shows how to calculate the top 2 eigenvalues and eigenvectors for :class:`TUNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + EigValV = snap.TFltV() + EigVecV = snap.TFltVFltV() + snap.GetEigVec(Graph, 10, EigVal, EigVecV) + + i = 0 + for item in EigVal: + i += 1 + print("Eigenvalue %d: %.6f" % (i, item)) + + i = 0 + for v in EigVecV: + i += 1 + print("=== Eigenvector: %d ===" % (i)) + for item in v: + print(item) + diff --git a/snap-python/source/doc/source/reference/GetEigVecs.rst b/snap-python/source/doc/source/reference/GetEigVecs.rst new file mode 100644 index 0000000000000000000000000000000000000000..27c49fa17fef1e8fd394c2413317d790fc7f0630 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEigVecs.rst @@ -0,0 +1,41 @@ +GetEigVecs +'''''''''' + +.. function:: GetEigVecs(EigVecs) + +A graph method that computes top EigVecs eigenvalues and eigenvectors of the adjacency matrix representing a given undirected graph. + +Parameters: + +- *EigVecs*: int + Rank of eigenvalues and eigenvectors that should be outputted. + +Return value: + +- *EigValV*: :class:`TFltV`, a vector of floats + Eigenvalues. + +- *EigVecV*: :class:`TFltVFltV`, a vector of vector of floats + Eigenvectors. + +For more info see: http://en.wikipedia.org/wiki/GetEigVec + +The following example shows how to calculate the top 2 eigenvalues and eigenvectors for :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + EigValV, EigVecV = UGraph.GetEigVecs(10) + + i = 0 + for item in EigValV: + i += 1 + print("Eigenvalue %d: %.6f" % (i, item)) + + i = 0 + for v in EigVecV: + i += 1 + print("=== Eigenvector: %d ===" % (i)) + for item in v: + print(item) + diff --git a/snap-python/source/doc/source/reference/GetEigenVectorCentr-swig.rst b/snap-python/source/doc/source/reference/GetEigenVectorCentr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..472a2f6d2db350167fb1dd151c1b929fce4727a6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEigenVectorCentr-swig.rst @@ -0,0 +1,36 @@ +GetEigenVectorCentr (SWIG) +'''''''''''''''''''''''''' + +.. function:: GetEigenVectorCentr(Graph, NIdEigenH, Eps = 1e-4, MaxIter = 100) + :noindex: + +Computes eigenvector centrality of all nodes in *Graph* and stores it in *NIdEigenH*. Eigenvector Centrality of a node N is defined recursively as the average of centrality values of N's neighbors in the network. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph + +- *NIdEigenH*: :class:`TIntFltH`, a hash table of int keys and float values (output) + Hash table mapping node ids to their corresponding eigenvector centrality values. + +- *Eps*: float (input) + Epsilon (stop when accumulated difference in eigenvector centrality value for all nodes in an iteration is less than epsilon). + +- *MaxIter*: int (input) + Maximum number of iterations (stop when exceeding this number of iterations). + +Return value: + +- None + + +The following example shows how to calculate eigenvector centrality values for nodes in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NIdEigenH = snap.TIntFltH() + snap.GetEigenVectorCentr(UGraph, NIdEigenH) + for item in NIdEigenH: + print("%node: d centrality: %f" % (item, NIdEigenH[item])) diff --git a/snap-python/source/doc/source/reference/GetEigenVectorCentr.rst b/snap-python/source/doc/source/reference/GetEigenVectorCentr.rst new file mode 100644 index 0000000000000000000000000000000000000000..df3ef80829c651bbe57ad7dc25e0d0cf02ebaced --- /dev/null +++ b/snap-python/source/doc/source/reference/GetEigenVectorCentr.rst @@ -0,0 +1,29 @@ +GetEigenVectorCentr +''''''''''''''''''' + +.. function:: GetEigenVectorCentr(Eps = 1e-4, MaxIter = 100) + +A graph method for undirected graphs that returns eigenvector centrality of all nodes. Eigenvector Centrality of a node N is defined recursively as the average of centrality values of N's neighbors in the network. + +Parameters: + +- (optional) *Eps*: float + Epsilon (stop when accumulated difference in eigenvector centrality value for all nodes in an iteration is less than epsilon). + +- (optional) *MaxIter*: int + Maximum number of iterations (stop when exceeding this number of iterations). + +Return value: + +- *NIdEigenH*: :class:`TIntFltH`, a hash table of int keys and float values + Hash table mapping node ids to their corresponding eigenvector centrality values. + + +The following example shows how to calculate eigenvector centrality values for nodes in :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NIdEigenH = UGraph.GetEigenVectorCentr() + for item in NIdEigenH: + print("%node: d centrality: %f" % (item, NIdEigenH[item])) diff --git a/snap-python/source/doc/source/reference/GetFarnessCentr-swig.rst b/snap-python/source/doc/source/reference/GetFarnessCentr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..57a126c8450348424d2c59830a4a44f5b0cdabc9 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetFarnessCentr-swig.rst @@ -0,0 +1,50 @@ +GetFarnessCentr (SWIG) +'''''''''''''''''''''' + +.. function:: GetFarnessCentr(Graph, NId, Normalized=True, IsDir=False) + :noindex: + +Returns farness centrality of a given node *NId* in *Graph*. Farness centrality of a node is the average shortest path length to all other nodes that reside in the same connected component as the given node. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId*: int (input) + A node id in *Graph*. + +- *Normalized*: bool (input) + Output should be normalized (*True*) or not (*False*). + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed (*True*) or undirected (*False*). + +Return value: + +- float + The farness centrality of the node *NId* in *Graph*. + + +The following example shows how to get the farness centrality for nodes in +:class:`TNGraph`, +:class:`TUNGraph`, and +:class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + for NI in Graph.Nodes(): + FarCentr = snap.GetFarnessCentr(Graph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + for NI in UGraph.Nodes(): + FarCentr = snap.GetFarnessCentr(UGraph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + for NI in Network.Nodes(): + FarCentr = snap.GetFarnessCentr(Network, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + diff --git a/snap-python/source/doc/source/reference/GetFarnessCentr.rst b/snap-python/source/doc/source/reference/GetFarnessCentr.rst new file mode 100644 index 0000000000000000000000000000000000000000..16af58666538693cb322e250978144246d6fc6a8 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetFarnessCentr.rst @@ -0,0 +1,46 @@ +GetFarnessCentr +''''''''''''''' + +.. function:: GetFarnessCentr(NId, Normalized=True, IsDir=False) + +A graph method that returns farness centrality of a given node *NId*. Farness centrality of a node is the average shortest path length to all other nodes that reside in the same connected component as the given node. + +Parameters: + +- *NId*: int + A node id. + +- (optional) *Normalized*: bool + Output should be normalized (*True*) or not (*False*). + +- (optional) *IsDir*: bool + Indicates whether the edges should be considered directed (*True*) or undirected (*False*). + +Return value: + +- float + The farness centrality of the node *NId*. + + +The following example shows how to get the farness centrality for nodes in +:class:`TNGraph`, +:class:`TUNGraph`, and +:class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + for NI in Graph.Nodes(): + FarCentr = Graph.GetFarnessCentr(NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + for NI in UGraph.Nodes(): + FarCentr = UGraph.GetFarnessCentr(NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + for NI in Network.Nodes(): + FarCentr = Network.GetFarnessCentr(NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + diff --git a/snap-python/source/doc/source/reference/GetGraphUnion.rst b/snap-python/source/doc/source/reference/GetGraphUnion.rst new file mode 100644 index 0000000000000000000000000000000000000000..f50e2bbe824a39e92ed172d67663ed8e54ab4bb0 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetGraphUnion.rst @@ -0,0 +1,35 @@ +GetGraphUnion +''''''''''''' + +.. function:: GetGraphUnion(Graph) + +A graph method that computes a graph union between two graphs, the graph object and the *Graph* parameter. The graph object and the *Graph* parameter must be of the same type. The graph union is computed by adding to the graph object nodes and edges from *Graph* that are not already in the graph object. The resulting graph union is stored in the graph object and also returned as a result. + +The graph union for type :class:`TNEANet` has some specific properties in dealing with multi edges and edge IDs. In the case of multiple edges between two nodes, only one edge will be added between two nodes and only when that edge does not yet exist in the graph object. This means that the union will preserve any multi edges in the graph object, but will not create new multi edges. Edges are directed, so edges with swapped source and destination nodes are treated as separate. Edge IDs from *Graph* are not preserved in the graph union. + +Parameters: + +- *Graph*: graph object + An object instance of type TNGraph, TUNGraph or TNEANet, must be the same type as the graph object. + +Return value: + +- graph + The resulting union graph, the same as the graph object. + +The following example shows how to compute a union with graphs of type :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + G1 = snap.GenRndGnm(snap.TNGraph, 100, 1000) + G2 = snap.GenRndGnm(snap.TNGraph, 100, 1000) + G1.GetGraphUnion(G2) + + G3 = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + G4 = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + G3.GetGraphUnion(G4) + + G5 = snap.GenRndGnm(snap.TNEANet, 100, 1000) + G6 = snap.GenRndGnm(snap.TNEANet, 100, 1000) + G5.GetGraphUnion(G6) + diff --git a/snap-python/source/doc/source/reference/GetGraphUnionAttr.rst b/snap-python/source/doc/source/reference/GetGraphUnionAttr.rst new file mode 100644 index 0000000000000000000000000000000000000000..907bb8f4c6fb42c4914eccdd9d5162418d918f2b --- /dev/null +++ b/snap-python/source/doc/source/reference/GetGraphUnionAttr.rst @@ -0,0 +1,46 @@ +GetGraphUnionAttr +''''''''''''''''' + +.. function:: GetGraphUnionAttr(Graph) + +A graph method that computes a graph union with attributes between two graphs, the graph object and the *Graph* parameter. The graph object and the *Graph* parameter must be of type :class:`TNEANet`. The graph union with attributes is computed by adding to the graph object nodes and edges from *Graph* that are not already in the graph object. The corresponding attributes are copied as well. The resulting graph union is stored in the graph object and also returned as a result. + +The graph union has some specific properties in dealing with multi edges and edge IDs. In the case of multiple edges between two nodes, only one edge will be added between two nodes and only when that edge does not yet exist in the graph object. This means that the union will preserve any multi edges in the graph object, but will not create new multi edges. Edges are directed, so edges with swapped source and destination nodes are treated as separate. Edge IDs from *Graph* are not preserved in the graph union. + +Parameters: + +- *Graph*: graph object + An object instance of type TNEANet. + +Return value: + +- graph + The resulting union graph, the same as the graph object. + +The following example shows how to compute a graph union with attributes for :class:`TNEANet`:: + + import snap + + G1 = snap.GenRndGnm(snap.TNEANet, 100, 1000) + s = "attr" + count = 0 + for NI in G1.Nodes(): + count += 1 + G1.AddIntAttrDatN(NI.GetId(), count, s) + count = 0 + for EI in G1.Edges(): + count += 1 + G1.AddIntAttrDatE(EI.GetId(), count, s) + + G2 = snap.GenRndGnm(snap.TNEANet, 100, 1000) + count = 0 + for NI in G2.Nodes(): + count += 1 + G2.AddIntAttrDatN(NI.GetId(), count, s) + count = 0 + for EI in G2.Edges(): + count += 1 + G2.AddIntAttrDatE(EI.GetId(), count, s) + + G1.GetGraphUnionAttr(G2) + diff --git a/snap-python/source/doc/source/reference/GetHits-swig.rst b/snap-python/source/doc/source/reference/GetHits-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..124110c74588fe4529aa326bf70e53106cbedd39 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetHits-swig.rst @@ -0,0 +1,59 @@ +GetHits (SWIG) +'''''''''''''' + +.. function:: GetHits (Graph, NIdHubH, NIdAuthH, MaxIter = 20) + :noindex: + +Computes the Hubs and Authorities score of every node in *Graph*. The scores are stored in *NIdHubH* and *NIdAuthH*. + + +Parameters + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdHubH*: :class:`TIntFltH`, a hash table of int keys and float values (output) + The keys are the node ids and the values are the hub scores as outputed by the HITS algorithm. + +- *NIdAuthH*: :class:`TIntFltH`, a hash table of int keys and float values (output) + The keys are the node ids and the values are the authority scores as outputed by the HITS algorithm. + +- *MaxIter*: int (input) + Maximum number of iterations. + +Return value: + +- None + + +The following example shows how to calculate Hub and Authority scores for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NIdHubH = snap.TIntFltH() + NIdAuthH = snap.TIntFltH() + snap.GetHits(Graph, NIdHubH, NIdAuthH) + for item in NIdHubH: + print(item, NIdHubH[item]) + for item in NIdAuthH: + print(item, NIdAuthH[item]) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NIdHubH = snap.TIntFltH() + NIdAuthH = snap.TIntFltH() + snap.GetHits(UGraph, NIdHubH, NIdAuthH) + for item in NIdHubH: + print(item, NIdHubH[item]) + for item in NIdAuthH: + print(item, NIdAuthH[item]) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NIdHubH = snap.TIntFltH() + NIdAuthH = snap.TIntFltH() + snap.GetHits(Network, NIdHubH, NIdAuthH) + for item in NIdHubH: + print(item, NIdHubH[item]) + for item in NIdAuthH: + print(item, NIdAuthH[item]) diff --git a/snap-python/source/doc/source/reference/GetHits.rst b/snap-python/source/doc/source/reference/GetHits.rst new file mode 100644 index 0000000000000000000000000000000000000000..461b17fc02a5c28245c1f834743debc8f9c76f2a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetHits.rst @@ -0,0 +1,47 @@ +GetHits +''''''' + +.. function:: GetHits (MaxIter = 20) + +A graph method that returns the Hubs and Authorities score of every node. + + +Parameters + +- (optional) *MaxIter*: int + Maximum number of iterations. + +Return value: + +- *NIdHubH*: :class:`TIntFltH`, a hash table of int keys and float values + The keys are the node ids and the values are the hub scores as outputed by the HITS algorithm. + +- *NIdAuthH*: :class:`TIntFltH`, a hash table of int keys and float values + The keys are the node ids and the values are the authority scores as outputed by the HITS algorithm. + + +The following example shows how to calculate Hub and Authority scores for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NIdHubH, NIdAuthH = Graph.GetHits() + for item in NIdHubH: + print(item, NIdHubH[item]) + for item in NIdAuthH: + print(item, NIdAuthH[item]) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NIdHubH, NIdAuthH = UGraph.GetHits() + for item in NIdHubH: + print(item, NIdHubH[item]) + for item in NIdAuthH: + print(item, NIdAuthH[item]) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NIdHubH, NIdAuthH = Network.GetHits() + for item in NIdHubH: + print(item, NIdHubH[item]) + for item in NIdAuthH: + print(item, NIdAuthH[item]) diff --git a/snap-python/source/doc/source/reference/GetInDegCnt-swig.rst b/snap-python/source/doc/source/reference/GetInDegCnt-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..88449dab34e98cc16ab2adf7741fafbf0bb28474 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetInDegCnt-swig.rst @@ -0,0 +1,42 @@ +GetInDegCnt (SWIG) +'''''''''''''''''' + +.. function:: GetInDegCnt(Graph, DegToCntV) + :noindex: + +Computes an in-degree histogram: a vector of pairs (in-degree, number of nodes of such in-degree). The results are stored in *DegToCntV*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *DegToCntV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of (in-degree, number of nodes of such in-degree) pairs. + +Return value: + +- None + + +The following examples shows how to obtain the in-degree histogram for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetInDegCnt(Graph, DegToCntV) + for item in DegToCntV: + print("%d nodes with in-degree %d" % (item.GetVal2(), item.GetVal1())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetInDegCnt(UGraph, DegToCntV) + for item in DegToCntV: + print("%d nodes with in-degree %d" % (item.GetVal2(), item.GetVal1())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetInDegCnt(Network, DegToCntV) + for item in DegToCntV: + print("%d nodes with in-degree %d" % (item.GetVal2(), item.GetVal1())) diff --git a/snap-python/source/doc/source/reference/GetInDegCnt.rst b/snap-python/source/doc/source/reference/GetInDegCnt.rst new file mode 100644 index 0000000000000000000000000000000000000000..fa2ba82fb4c88e2f36459659149608cc528ee7a5 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetInDegCnt.rst @@ -0,0 +1,35 @@ +GetInDegCnt +''''''''''' + +.. function:: GetInDegCnt(Graph, DegToCntV) + +A graph method that returns the number of nodes for each in-degree as a vector of pairs (in-degree, number of nodes of such in-degree). + +Parameters: + +- None + +Return value: + +- *DegToCntV*: :class:`TIntPrV`, a vector of (int, int) pairs + A vector of (in-degree, number of nodes of such in-degree) pairs. + + +The following examples shows how to obtain the in-degree histogram for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + DegToCntV = Graph.GetInDegCnt() + for item in DegToCntV: + print("%d nodes with in-degree %d" % (item.GetVal2(), item.GetVal1())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + DegToCntV = UGraph.GetInDegCnt() + for item in DegToCntV: + print("%d nodes with in-degree %d" % (item.GetVal2(), item.GetVal1())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + DegToCntV = Network.GetInDegCnt() + for item in DegToCntV: + print("%d nodes with in-degree %d" % (item.GetVal2(), item.GetVal1())) diff --git a/snap-python/source/doc/source/reference/GetInEgonetHop.rst b/snap-python/source/doc/source/reference/GetInEgonetHop.rst new file mode 100644 index 0000000000000000000000000000000000000000..8b676b776652c81417a8629130ac866d7b784788 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetInEgonetHop.rst @@ -0,0 +1,34 @@ +GetInEgonetHop +'''''''''''''' + +.. function:: GetInEgonetHop(NId, H) + +A graph method that returns an *H* hop in-ego network of the node *NId*. The *H* hop in-ego network includes the node *NId*, its in-neighbours and edges that connect them to the origin node, then all their in-neighbours and edges and so on until *H* hop neighbours. + +Parameters: + +- *NId*: int + Id of the center node of the ego network. + +- *H*: int + The number of hops for the ego network. + +Return value: + +- graph + A graph of the same type as the input graph, containing the in-ego network for *NId*. + +The following example shows how to create a subgraph for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NGraph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + InEgonet = NGraph.GetInEgonetHop(0, 2) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + InEgonet = UGraph.GetInEgonetHop(3, 1) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + InEgonet = Network.GetInEgonetHop(10, 3) + diff --git a/snap-python/source/doc/source/reference/GetInEgonetSub.rst b/snap-python/source/doc/source/reference/GetInEgonetSub.rst new file mode 100644 index 0000000000000000000000000000000000000000..f17fdb23df690d7471d7310655fb191a5cb8c11a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetInEgonetSub.rst @@ -0,0 +1,40 @@ +GetInEgonetSub +'''''''''''''' + +.. function:: GetInEgonetSub(NId, H, N = 2, P = -1.0) + +A graph method that returns a sampled *H* hop in-ego network of the node *NId*. A sampled *H* hop in-ego network includes the node *NId*, a sample of its in-neighbours and edges that connect them to the origin node, then samples of all their in-neighbours and edges and so on until *H* hop neighbours. The sampling is specified by the *N* and *P* parameters. If *P* is -1.0, then *N* determines the maximum number of neighbours added to the in-ego network for each node. If *P* is different than -1.0, then it determines the percentage of added neighbours. For example, if *P* is 0.5, then half of the neighbours will be added to the in-ego network for each node. The neighbours are selected randomly. + +Parameters: + +- *NId*: int + Id of the center node of the ego network. + +- *H*: int + The number of hops for the ego network. + +- (optional) *N*: int + The maximum number of neighbours selected. Default value is 2. It has no effect, is *P* is different from -1.0. + +- (optional) *P*: float + The percentage of neighbours selected, between 0.0 and 1.0. Default value is -1.0, which means that the parameter has no effect. + +Return value: + +- graph + A graph of the same type as the input graph, containing the in-ego network for *NId*. + +The following example shows how to create a subgraph for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NGraph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + InEgonet = NGraph.GetInEgonetSub(0, 2, 3) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + InEgonet = UGraph.GetInEgonetSub(3, 1, 3) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + InEgonet = Network.GetInEgonetSub(10, 3, 0, 0.4) + diff --git a/snap-python/source/doc/source/reference/GetInvParticipRat-swig.rst b/snap-python/source/doc/source/reference/GetInvParticipRat-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..14e5650316449b236b2bdbc5354a117478aa3040 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetInvParticipRat-swig.rst @@ -0,0 +1,51 @@ +GetInvParticipRat (SWIG) +'''''''''''''''''''''''' + +.. function:: GetInvParticipRat(Graph, MaxEigVecs, TimeLimit, EigValIprV) + :noindex: + +Computes Inverse participation ratio of a given graph. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *EigVecs*: int (input) + Maximum number of eigenvectors to return. + +- *TimeLimit*: int (input) + Maximum number seconds to search. + +- *EigValIprV*: :class:`TFltPrV`, a vector of (float, float) pairs (output) + The output inverse participation ratios. + +Return value: + +- None + +See Spectra of "real-world" graphs: Beyond the semicircle law by Farkas, Derenyi, Barabasi and Vicsek URL: http://arxiv.org/abs/cond-mat/0102335 + + +The following example computes the inverse participation ratio for :class:`TNGraph`:: + + import snap + + UGraph = snap.TUNGraph.New() + UGraph.AddNode(1) + UGraph.AddNode(2) + UGraph.AddNode(3) + UGraph.AddNode(4) + UGraph.AddNode(5) + UGraph.AddNode(6) + UGraph.AddEdge(1, 2) + UGraph.AddEdge(2, 3) + UGraph.AddEdge(3, 5) + UGraph.AddEdge(4, 6) + UGraph.AddEdge(4, 1) + + EigValIprV = snap.TFltPrV() + snap.GetInvParticipRat(UGraph, 20, 1000, EigValIprV) + for item in EigValIprV: + print('%f, %f' % (item.GetVal1(), item.GetVal2())) + diff --git a/snap-python/source/doc/source/reference/GetInvParticipRat.rst b/snap-python/source/doc/source/reference/GetInvParticipRat.rst new file mode 100644 index 0000000000000000000000000000000000000000..3bfd52e70945680ec4123f00b56f5310a044cc6e --- /dev/null +++ b/snap-python/source/doc/source/reference/GetInvParticipRat.rst @@ -0,0 +1,44 @@ +GetInvParticipRat +''''''''''''''''' + +.. function:: GetInvParticipRat(MaxEigVecs, TimeLimit) + +A graph method that computes the inverse participation ratio of an undirected graph. + +Parameters: + +- *EigVecs*: int + Maximum number of eigenvectors to return. + +- *TimeLimit*: int + Maximum number seconds to search. + +Return value: + +- *EigValIprV*: :class:`TFltPrV`, a vector of (float, float) pairs (output) + The output inverse participation ratios. + +See Spectra of "real-world" graphs: Beyond the semicircle law by Farkas, Derenyi, Barabasi and Vicsek URL: http://arxiv.org/abs/cond-mat/0102335 + + +The following example computes the inverse participation ratio for :class:`TUNGraph`:: + + import snap + + UGraph = snap.TUNGraph.New() + UGraph.AddNode(1) + UGraph.AddNode(2) + UGraph.AddNode(3) + UGraph.AddNode(4) + UGraph.AddNode(5) + UGraph.AddNode(6) + UGraph.AddEdge(1, 2) + UGraph.AddEdge(2, 3) + UGraph.AddEdge(3, 5) + UGraph.AddEdge(4, 6) + UGraph.AddEdge(4, 1) + + EigValIprV = UGraph.GetInvParticipRat(20, 1000) + for item in EigValIprV: + print('%f, %f' % (item.GetVal1(), item.GetVal2())) + diff --git a/snap-python/source/doc/source/reference/GetKCore-swig.rst b/snap-python/source/doc/source/reference/GetKCore-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a622b27452aa5c2a0cfa4040eb9f6adc0269eaac --- /dev/null +++ b/snap-python/source/doc/source/reference/GetKCore-swig.rst @@ -0,0 +1,50 @@ +GetKCore (SWIG) +''''''''''''''' + +.. function:: GetKCore(Graph, K) + :noindex: + +Returns the K-core of the graph *Graph*. If the core of order *K* does not exist, the function returns an empty graph. + +Parameters + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *K*: int (input) + Minimum degree needed for a subgraph to be in the core. + +Return value: + +- graph + A Snap.py graph or network where all nodes have degree >= *K*. The graph is empty if no such graph exists. + + +The following example shows how to check if a K-Core subgraph exists +for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + K = 5 + KCore = snap.GetKCore(Graph, K) + if KCore.Empty(): + print('No Core exists for K=%d' % K) + else: + print('Core exists for K=%d' % K) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + K = 10 + KCore = snap.GetKCore(UGraph, K) + if KCore.Empty(): + print('No Core exists for K=%d' % K) + else: + print('Core exists for K=%d' % K) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + K = 15 + KCore = snap.GetKCore(Network, K) + if KCore.Empty(): + print('No Core exists for K=%d' % K) + else: + print('Core exists for K=%d' % K) diff --git a/snap-python/source/doc/source/reference/GetKCore.rst b/snap-python/source/doc/source/reference/GetKCore.rst new file mode 100644 index 0000000000000000000000000000000000000000..2b6e64ecabc3e54b0bf4f3bfcbabba2b4f4b8b16 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetKCore.rst @@ -0,0 +1,45 @@ +GetKCore +'''''''' + +.. function:: GetKCore(K) + +A graph method that returns the K-core of a graph. If the core of order *K* does not exist, the function returns an empty graph. + +Parameters + +- *K*: int + Minimum degree needed for a subgraph to be in the core. + +Return value: + +- graph + A graph or a network where all nodes have degree >= *K*. The graph is empty if no such graph exists. + +The following example shows how to check if a K-Core subgraph exists +for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + K = 5 + KCore = Graph.GetKCore(K) + if KCore.Empty(): + print('No Core exists for K=%d' % K) + else: + print('Core exists for K=%d' % K) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + K = 10 + KCore = UGraph.GetKCore(K) + if KCore.Empty(): + print('No Core exists for K=%d' % K) + else: + print('Core exists for K=%d' % K) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + K = 15 + KCore = Network.GetKCore(K) + if KCore.Empty(): + print('No Core exists for K=%d' % K) + else: + print('Core exists for K=%d' % K) diff --git a/snap-python/source/doc/source/reference/GetKCoreEdges-swig.rst b/snap-python/source/doc/source/reference/GetKCoreEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d0a346c66875ff41b610be90440c9e8688f61d49 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetKCoreEdges-swig.rst @@ -0,0 +1,44 @@ +GetKCoreEdges (SWIG) +'''''''''''''''''''' + +.. function:: GetKCoreEdges(Graph, CoreIdSzV) + :noindex: + +Returns the number of edges in each core of order K (where K=0, 1, ...). Stores pairs (K, number of edges) in *CoreIdSzV*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *CoreIdSzV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of (order, number of edges of the given order) pairs. + +Return value: + +- int + The number of cores. + + +The following example shows how to get the number of edges for a given k-core in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + CoreIDSzV = snap.TIntPrV() + kValue = snap.GetKCoreEdges(Graph, CoreIDSzV) + for item in CoreIDSzV: + print("order: %d edges: %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + CoreIDSzV = snap.TIntPrV() + kValue = snap.GetKCoreEdges(UGraph, CoreIDSzV) + for item in CoreIDSzV: + print("order: %d edges: %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + CoreIDSzV = snap.TIntPrV() + kValue = snap.GetKCoreEdges(Network, CoreIDSzV) + for item in CoreIDSzV: + print("order: %d edges: %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetKCoreEdges.rst b/snap-python/source/doc/source/reference/GetKCoreEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..570b60ba122481962e300dc0806b05a87d4177eb --- /dev/null +++ b/snap-python/source/doc/source/reference/GetKCoreEdges.rst @@ -0,0 +1,38 @@ +GetKCoreEdges +''''''''''''' + +.. function:: GetKCoreEdges() + +A graph method that returns the number of edges in each core of order K (where K=0, 1, ...). + +Parameters: + +- None + +Return value: + +- int + The number of cores. + +- :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of (order K, number of edges of the given order) pairs. + +The following example shows how to get the number of edges for a given k-core in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + kValue, CoreIDSzV = Graph.GetKCoreEdges() + for item in CoreIDSzV: + print("order: %d edges: %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + kValue, CoreIDSzV = UGraph.GetKCoreEdges() + for item in CoreIDSzV: + print("order: %d edges: %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + kValue, CoreIDSzV = Network.GetKCoreEdges() + for item in CoreIDSzV: + print("order: %d edges: %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetKCoreNodes-swig.rst b/snap-python/source/doc/source/reference/GetKCoreNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..b6c676269d0addc1aebe3d8ca707ed660081609f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetKCoreNodes-swig.rst @@ -0,0 +1,45 @@ +GetKCoreNodes (SWIG) +'''''''''''''''''''' + +.. function:: GetKCoreNodes(Graph, CoreIdSzV) + :noindex: + +Returns the number of nodes in each core of order K (where K=0, 1, ...). Stores pairs (K, number of nodes) in *CoreIdSzV*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or directed graph. + +- *CoreIdSzV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of (order, number of nodes of the given order) pairs. + +Return value: + +- int + The number of cores. + + +The following example shows how to get the number of nodes for a given k-core in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + CoreIDSzV = snap.TIntPrV() + kValue = snap.GetKCoreNodes(Graph, CoreIDSzV) + for item in CoreIDSzV: + print("order: %d nodes: %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + CoreIDSzV = snap.TIntPrV() + kValue = snap.GetKCoreNodes(UGraph, CoreIDSzV) + for item in CoreIDSzV: + print("order: %d nodes: %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + CoreIDSzV = snap.TIntPrV() + kValue = snap.GetKCoreNodes(Network, CoreIDSzV) + for item in CoreIDSzV: + print("order: %d nodes: %d" % (item.GetVal1(), item.GetVal2())) + diff --git a/snap-python/source/doc/source/reference/GetKCoreNodes.rst b/snap-python/source/doc/source/reference/GetKCoreNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..f0d0959ad7435e4c269409a1ac04a97f32d6c22a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetKCoreNodes.rst @@ -0,0 +1,39 @@ +GetKCoreNodes +''''''''''''' + +.. function:: GetKCoreNodes() + +A graph method that returns the number of nodes in each core of order K (where K=0, 1, ...). + +Parameters: + +- None + +Return value: + +- int + The number of cores. + +- :class:`TIntPrV`, a vector of (int, int) pairs + A vector of (order K, number of nodes of the given order) pairs. + +The following example shows how to get the number of nodes for a given k-core in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + kValue, CoreIDSzV = Graph.GetKCoreNodes() + for item in CoreIDSzV: + print("order: %d nodes: %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + kValue, CoreIDSzV = UGraph.GetKCoreNodes() + for item in CoreIDSzV: + print("order: %d nodes: %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + kValue, CoreIDSzV = Network.GetKCoreNodes() + for item in CoreIDSzV: + print("order: %d nodes: %d" % (item.GetVal1(), item.GetVal2())) + diff --git a/snap-python/source/doc/source/reference/GetLeadEigVec.rst b/snap-python/source/doc/source/reference/GetLeadEigVec.rst new file mode 100644 index 0000000000000000000000000000000000000000..a684dc805b934bed7719f653d2da70eae914b2eb --- /dev/null +++ b/snap-python/source/doc/source/reference/GetLeadEigVec.rst @@ -0,0 +1,25 @@ +GetLeadEigVec +''''''''''''' + +.. function:: GetLeadEigVec() + +A graph method that computes the leading eigenvector of the adjacency matrix representing an undirected graph. + +Parameters: + +- None + +Return value: + +- :class:`TFltV`, a vector of floats + The leading eigenvector of the adjacency matrix representing the given graph. + +The following example shows how to get the leading eigenvector of the adjacency matrix for +:class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + EigVec = UGraph.GetLeadEigVec() + for Val in EigVec: + print(Val) diff --git a/snap-python/source/doc/source/reference/GetLeadSngVec.rst b/snap-python/source/doc/source/reference/GetLeadSngVec.rst new file mode 100644 index 0000000000000000000000000000000000000000..2492ede7e4d2d5e73f93593fb30930fe53507edf --- /dev/null +++ b/snap-python/source/doc/source/reference/GetLeadSngVec.rst @@ -0,0 +1,37 @@ +GetLeadSngVec +''''''''''''' + +.. function:: GetLeadSngVec() + +A graph method that computes the leading left and right singular vectors of the adjacency matrix +representing a directed graph. + +Parameters: + +- None + +Return value: + +- *LeftSV*: :class:`TFltV`, a vector of floats + The left singular vector. + +- *RightSV*: :class:`TFltV`, a vector of floats + The right singular vector. + +For more info see: http://en.wikipedia.org/wiki/Singular_value_decomposition + +The following example shows how to calculate the left and right singular +vectors:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + LeftSV, RightSV = Graph.GetLeadSngVec() + + print("Left singular vector:") + for item in LeftSV: + print(item) + + print("Right singular vector:") + for item in RightSV: + print(item) diff --git a/snap-python/source/doc/source/reference/GetLen2Paths-swig.rst b/snap-python/source/doc/source/reference/GetLen2Paths-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2df5c1be19a821af42a2edfc849f6cc8bba866f8 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetLen2Paths-swig.rst @@ -0,0 +1,36 @@ +GetLen2Path (SWIG) +'''''''''''''''''' + +.. function:: GetLen2Paths (Graph, NId1, NId2) + :noindex: + +Returns the number of length 2 directed paths between a pair of nodes *NId1*, *NId2* (*NId1* --> U --> *NId2*). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId1*: int (input) + ID of first node. + +- *NId1*: int (input) + ID of second node. + +Return value: + +- int: the number of length 2 paths between *NId1* and *NId2*. + +The following example shows how to calculate the number of length 2 directed paths between nodes within a :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 3000) + NumLen2Paths = snap.GetLen2Paths(Graph, 0, 1) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 3000) + NumLen2Paths = snap.GetLen2Paths(Graph, 0, 1) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 3000) + NumLen2Paths = snap.GetLen2Paths(Graph, 0, 1) + diff --git a/snap-python/source/doc/source/reference/GetLen2Paths.rst b/snap-python/source/doc/source/reference/GetLen2Paths.rst new file mode 100644 index 0000000000000000000000000000000000000000..0fd5a09ca1f35412a9af52b087315a49dfac788f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetLen2Paths.rst @@ -0,0 +1,49 @@ +GetLen2Paths +'''''''''''' + +.. function:: GetLen2Paths (NId1, NId2, ReturnPaths=False) + +A graph method that returns the number of length 2 directed paths between a pair of nodes *NId1*, *NId2* (*NId1* --> U --> *NId2*). + +Parameters: + +- *NId1*: int + ID of first node. + +- *NId2*: int + ID of second node. + +- (optional) *ReturnPaths*: bool + Specifies whether to return *NbrV* + +Return value: + +- int: the number of length 2 paths between *NId1* and *NId2*. + +- (optional) *NbrV*: :class:`TIntV` + A vector of nodes on each path between node *NId1* and node *NId2*. It is returned, if *ReturnPaths* is True. + +The following example shows how to calculate the number of length 2 directed paths between nodes within a :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NumLen2Paths = Graph.GetLen2Paths(0, 1) + NumLen2Paths, NbrV = Graph.GetLen2Paths(0, 1, True) + print("The number of paths between nodes %d and %d is %d" % (0, 1, NumLen2Paths)) + for Nbr in NbrV: + print("Path: %d %d %d" % (0, Nbr, 1)) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NumLen2Paths = UGraph.GetLen2Paths(0, 1) + NumLen2Paths, NbrV = UGraph.GetLen2Paths(0, 1, True) + print("The number of paths between nodes %d and %d is %d" % (0, 1, NumLen2Paths)) + for Nbr in NbrV: + print("Path: %d %d %d" % (0, Nbr, 1)) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NumLen2Paths = Network.GetLen2Paths(0, 1) + NumLen2Paths, NbrV = Network.GetLen2Paths(0, 1, True) + print("The number of paths between nodes %d and %d is %d" % (0, 1, NumLen2Paths)) + for Nbr in NbrV: + print("Path: %d %d %d" % (0, Nbr, 1)) diff --git a/snap-python/source/doc/source/reference/GetLen2Paths1-swig.rst b/snap-python/source/doc/source/reference/GetLen2Paths1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..54069a45227c453f4695e4602189b4ed1e9c0988 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetLen2Paths1-swig.rst @@ -0,0 +1,51 @@ +GetLen2Paths (SWIG) +''''''''''''''''''' + +.. function:: GetLen2Paths (Graph, NId1, NId2, NbrV) + :noindex: + +Returns the number of length 2 paths between a pair of nodes *NId1*, *NId2* (*NId1* --> U --> *NId2*). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *NId1*: int (input) + ID of the source node + +- *NId2*: int (input) + ID of the destination node + +- *NbrV*: TIntV (output) + A vector of nodes on each path between node *NId1* and node *NId2*. The vector is filled by the function. + +Return value: + +- int: the number of length 2 paths between a pair of nodes. + +The following example shows how to use GetLen2Paths in :class:`PUNGraph`, :class:`PNGraph`, and :class:`PNEANet`:: + + import snap + + g = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NbrV = snap.TIntV() + Num = snap.GetLen2Paths(g, 0, 1, NbrV) + print("The number of paths between nodes %d and %d is %d" % (0, 1, Num)) + for Nbr in NbrV: + print("Path: %d %d %d" % (0, Nbr, 1)) + + g = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NbrV = snap.TIntV() + Num = snap.GetLen2Paths(g, 0, 1, NbrV) + print("The number of paths between nodes %d and %d is %d" % (0, 1, Num)) + for Nbr in NbrV: + print("Path: %d %d %d" % (0, Nbr, 1)) + + g = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NbrV = snap.TIntV() + Num = snap.GetLen2Paths(g, 0, 1, NbrV) + print("The number of paths between nodes %d and %d is %d" % (0, 1, Num)) + for Nbr in NbrV: + print("Path: %d %d %d" % (0, Nbr, 1)) + diff --git a/snap-python/source/doc/source/reference/GetModularity-swig.rst b/snap-python/source/doc/source/reference/GetModularity-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f5f65f4a739c9e9d61978618ae2dfab8a594b720 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetModularity-swig.rst @@ -0,0 +1,42 @@ +GetModularity (SWIG) +'''''''''''''''''''' + +.. function:: GetModularity(Graph, NIdV, GEdges=-1) + :noindex: + +Computes the modularity score of a set of node ids *NIdV* in *Graph*. The function runs much faster if the number of edges in Graph is provided in the optional *GEdges* parameter. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdV*: :class:`TIntV`, a vector of ints (input) + The set of nodes ids from which the modularity score will be computed. + +- *GEdges*: int (input) + Optional parameter indicating number of edges in the graph which speeds up the function execution if provided. Note: if GEdges is not equal to the number of edges in the graph, then the computed modularity score will be incorrect. + +Return value: + +- float + The modularity score computed from the provided graph and set of node ids. + + +The following example shows how to calculate Modularity scores for the first 10 nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Nodes = snap.TIntV() + for nodeId in range(10): + Nodes.Add(nodeId) + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + print(snap.GetModularity(Graph, Nodes, 1000)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + print(snap.GetModularity(UGraph, Nodes, 1000)) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + print(snap.GetModularity(Network, Nodes, 1000)) diff --git a/snap-python/source/doc/source/reference/GetModularity.rst b/snap-python/source/doc/source/reference/GetModularity.rst new file mode 100644 index 0000000000000000000000000000000000000000..257d1f6cf8f500bb1e94035a6bbb0f51814e02bb --- /dev/null +++ b/snap-python/source/doc/source/reference/GetModularity.rst @@ -0,0 +1,38 @@ +GetModularity +''''''''''''' + +.. function:: GetModularity(NIdV, GEdges=-1) + +A graph method that computes the modularity score of a set of node ids *NIdV*. The function runs much faster if the number of edges is provided in the optional *GEdges* parameter. + +Parameters: + +- *NIdV*: Python list or :class:`TIntV`, a vector of ints + The set of nodes ids from which the modularity score will be computed. + +- (optional) *GEdges*: int + A parameter providing the number of edges in the graph which speeds up the function execution if provided. Note: if GEdges must be equal to the number of edges in the graph, otherwise the computed modularity score will be incorrect. + +Return value: + +- float + The modularity score computed from the provided graph and set of node ids. + + +The following example shows how to calculate Modularity scores for the first 10 nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Nodes = [] + for nodeId in range(10): + Nodes.append(nodeId) + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + print(Graph.GetModularity(Nodes, 1000)) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + print(UGraph.GetModularity(Nodes, 1000)) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + print(Network.GetModularity(Nodes, 1000)) diff --git a/snap-python/source/doc/source/reference/GetMxBiCon-swig.rst b/snap-python/source/doc/source/reference/GetMxBiCon-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..7827e01af2a0ae830d047ce6adb0928068cbb64d --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxBiCon-swig.rst @@ -0,0 +1,38 @@ +GetMxBiCon (SWIG) +''''''''''''''''' + +.. function:: GetMxBiCon(Graph) + :noindex: + +Returns a graph representing the largest bi-connected component in *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- graph + A Snap.py graph or a network representing the largest bi-connected component in *Graph*. + + +The following example shows how to get the largest bi-connected component in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 500) + BiCon = snap.GetMxBiCon(Graph) + for EI in BiCon.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 500) + BiCon = snap.GetMxBiCon(UGraph) + for EI in BiCon.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 500) + BiCon = snap.GetMxBiCon(Network) + for EI in BiCon.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetMxBiCon.rst b/snap-python/source/doc/source/reference/GetMxBiCon.rst new file mode 100644 index 0000000000000000000000000000000000000000..f6798b89722e930982957b4e63d8eb7d09b553d4 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxBiCon.rst @@ -0,0 +1,36 @@ +GetMxBiCon +'''''''''' + +.. function:: GetMxBiCon() + +A graph method that returns a graph representing the largest bi-connected component in the original graph. + +Parameters: + +- None + +Return value: + +- graph + A graph representing the largest bi-connected component in the original graph. + + +The following example shows how to get the largest bi-connected component in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 500) + BiCon = Graph.GetMxBiCon() + for EI in BiCon.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 500) + BiCon = UGraph.GetMxBiCon() + for EI in BiCon.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 500) + BiCon = Network.GetMxBiCon() + for EI in BiCon.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetMxDegNId-swig.rst b/snap-python/source/doc/source/reference/GetMxDegNId-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f94af798f2a00e92b0368b1d242697c186aa5cb3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxDegNId-swig.rst @@ -0,0 +1,36 @@ +GetMxDegNId (SWIG) +'''''''''''''''''' + +.. function:: GetMxDegNId(Graph) + :noindex: + +Returns the node id of a randomly chosen node from all the nodes in *Graph* with the maximum degree. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The node id for a randomly chosen node from all the nodes in *Graph* with the maximum degree. + + +The following example shows how to use :func:`GetMxDegNId` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NId1 = snap.GetMxDegNId(Graph) + print(NId1) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NId2 = snap.GetMxDegNId(UGraph) + print(NId2) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NId3 = snap.GetMxDegNId(Network) + print(NId3) + diff --git a/snap-python/source/doc/source/reference/GetMxDegNId.rst b/snap-python/source/doc/source/reference/GetMxDegNId.rst new file mode 100644 index 0000000000000000000000000000000000000000..178b17972f7fe8d8b198cc934f065189b8988589 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxDegNId.rst @@ -0,0 +1,34 @@ +GetMxDegNId +''''''''''' + +.. function:: GetMxDegNId(Graph) + +A method that returns the node id of a randomly chosen node from all the nodes in *Graph* with the maximum degree. + +Parameters: + +- None + +Return value: + +- int + The node id for a randomly chosen node from all the nodes in *Graph* with the maximum degree. + + +The following example shows how to use :func:`GetMxDegNId` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NId1 = Graph.GetMxDegNId() + print(NId1) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NId2 = UGraph.GetMxDegNId() + print(NId2) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NId3 = Network.GetMxDegNId() + print(NId3) + diff --git a/snap-python/source/doc/source/reference/GetMxInDegNId-swig.rst b/snap-python/source/doc/source/reference/GetMxInDegNId-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..05a024bb8f59ff480dbbf6b988f89072e9669847 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxInDegNId-swig.rst @@ -0,0 +1,36 @@ +GetMxInDegNId (SWIG) +'''''''''''''''''''' + +.. function:: GetMxInDegNId(Graph) + :noindex: + +Returns the node id of a randomly chosen node from all the nodes in *Graph* with the maximum in-degree. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The node id of a randomly chosen node from all the nodes in *Graph* with the maximum in-degree. + + +The following example shows how to use :func:`GetMxInDegNId` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NId1 = snap.GetMxInDegNId(Graph) + print(NId1) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NId2 = snap.GetMxInDegNId(UGraph) + print(NId2) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NId3 = snap.GetMxInDegNId(Network) + print(NId3) + diff --git a/snap-python/source/doc/source/reference/GetMxInDegNId.rst b/snap-python/source/doc/source/reference/GetMxInDegNId.rst new file mode 100644 index 0000000000000000000000000000000000000000..cf4010123ad27c76ed4f55f38564b5e1bc4616a3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxInDegNId.rst @@ -0,0 +1,34 @@ +GetMxInDegNId +''''''''''''' + +.. function:: GetMxInDegNId() + +A method that returns the node id of a randomly chosen node from all the nodes in *Graph* with the maximum in-degree. + +Parameters: + +- None + +Return value: + +- int + The node id of a randomly chosen node from all the nodes in *Graph* with the maximum in-degree. + + +The following example shows how to use :func:`GetMxInDegNId` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NId1 = Graph.GetMxInDegNId() + print(NId1) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NId2 = UGraph.GetMxInDegNId() + print(NId2) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NId3 = Network.GetMxInDegNId() + print(NId3) + diff --git a/snap-python/source/doc/source/reference/GetMxOutDegNId-swig.rst b/snap-python/source/doc/source/reference/GetMxOutDegNId-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..94045615383f0a9726936b3299b1af324ef949f4 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxOutDegNId-swig.rst @@ -0,0 +1,36 @@ +GetMxOutDegNId (SWIG) +''''''''''''''''''''' + +.. function:: GetMxOutDegNId(Graph) + :noindex: + +Returns the node id of a randomly chosen node from all the nodes in *Graph* with the maximum out-degree. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- int + The node id of a randomly chosen node from all the nodes in *Graph* with the maximum out-degree. + + +The following example shows how to use :func:`GetMxOutDegNId` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NId1 = snap.GetMxOutDegNId(Graph) + print(NId1) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NId2 = snap.GetMxOutDegNId(UGraph) + print(NId2) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NId3 = snap.GetMxOutDegNId(Network) + print(NId3) + diff --git a/snap-python/source/doc/source/reference/GetMxOutDegNId.rst b/snap-python/source/doc/source/reference/GetMxOutDegNId.rst new file mode 100644 index 0000000000000000000000000000000000000000..6bf8ecd026a03355a486ed7d1a67a6f9da76ab1f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxOutDegNId.rst @@ -0,0 +1,34 @@ +GetMxOutDegNId +'''''''''''''' + +.. function:: GetMxOutDegNId() + +A method that returns the node id of a randomly chosen node from all the nodes in *Graph* with the maximum out-degree. + +Parameters: + +- None + +Return value: + +- int + The node id of a randomly chosen node from all the nodes in *Graph* with the maximum out-degree. + + +The following example shows how to use :func:`GetMxOutDegNId` with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NId1 = Graph.GetMxOutDegNId() + print(NId1) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NId2 = UGraph.GetMxOutDegNId() + print(NId2) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NId3 = Network.GetMxOutDegNId() + print(NId3) + diff --git a/snap-python/source/doc/source/reference/GetMxScc-swig.rst b/snap-python/source/doc/source/reference/GetMxScc-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..4e6860b3d79c8c69bd87710f34dfe2a0f89ef4de --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxScc-swig.rst @@ -0,0 +1,38 @@ +GetMxScc (SWIG) +''''''''''''''' + +.. function:: GetMxScc(Graph) + :noindex: + +Returns a graph representing the largest strongly connected component in *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- graph + A Snap.py graph or a network representing the largest strongly connected component in *Graph*. + + +The following example shows how to get the largest strongly connected component in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 500) + MxScc = snap.GetMxScc(Graph) + for EI in MxScc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 500) + MxScc = snap.GetMxScc(UGraph) + for EI in MxScc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 500) + MxScc = snap.GetMxScc(Network) + for EI in MxScc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetMxScc.rst b/snap-python/source/doc/source/reference/GetMxScc.rst new file mode 100644 index 0000000000000000000000000000000000000000..7c471445c2e9115f56e05ad145dd5e2587d91693 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxScc.rst @@ -0,0 +1,36 @@ +GetMxScc +'''''''' + +.. function:: GetMxScc() + +A graph method that returns a graph representing the largest strongly connected component in the original graph. + +Parameters: + +- None + +Return value: + +- graph + A graph representing the largest strongly connected component in the original graph. + + +The following example shows how to get the largest strongly connected component in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 500) + MxScc = Graph.GetMxScc() + for EI in MxScc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 500) + MxScc = UGraph.GetMxScc() + for EI in MxScc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 500) + MxScc = Network.GetMxScc() + for EI in MxScc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetMxSccSz-swig.rst b/snap-python/source/doc/source/reference/GetMxSccSz-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2f97e37ef4dc7c0b7ed37a19484729d6ef5cef3f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxSccSz-swig.rst @@ -0,0 +1,33 @@ +GetMxSccSz (SWIG) +''''''''''''''''' + +.. function:: GetMxSccSz(Graph) + :noindex: + +Returns the fraction of nodes in the largest strongly connected component of a *Graph*. + +Parameters: + + - *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + + - float + The fraction of nodes in the largest strongly connected component of a graph. + + +The following code shows how to calculate the relative size of the maximum strongly connected component for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 20, 10) + print('Relative size of SCC in Directed Graph:', snap.GetMxSccSz(Graph)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 20, 10) + print('Relative size of Size SCC in Undirected Graph:', snap.GetMxSccSz(UGraph)) + + Network = snap.GenRndGnm(snap.PNEANet, 20, 10) + print('Relative size of SCC in Network:', snap.GetMxSccSz(Network)) + diff --git a/snap-python/source/doc/source/reference/GetMxSccSz.rst b/snap-python/source/doc/source/reference/GetMxSccSz.rst new file mode 100644 index 0000000000000000000000000000000000000000..646d42490ddd0befeba60dc71168113a6a71c157 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxSccSz.rst @@ -0,0 +1,31 @@ +GetMxSccSz +'''''''''' + +.. function:: GetMxSccSz() + +A graph method that returns the fraction of nodes in the largest strongly connected component of a graph. + +Parameters: + +- None + +Return value: + +- float + The fraction of nodes in the largest strongly connected component of a graph. + + +The following code shows how to calculate the relative size of the maximum strongly connected component for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 20, 10) + print('Relative size of SCC in Directed Graph:', Graph.GetMxSccSz()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 20, 10) + print('Relative size of Size SCC in Undirected Graph:', UGraph.GetMxSccSz()) + + Network = snap.GenRndGnm(snap.TNEANet, 20, 10) + print('Relative size of SCC in Network:', Network.GetMxSccSz()) + diff --git a/snap-python/source/doc/source/reference/GetMxWcc-swig.rst b/snap-python/source/doc/source/reference/GetMxWcc-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c3eeec7fa159184f3149dcdcf85810fd980b59e2 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxWcc-swig.rst @@ -0,0 +1,38 @@ +GetMxWcc (SWIG) +''''''''''''''' + +.. function:: GetMxWcc(Graph) + :noindex: + +Returns a graph representing the largest weakly connected component in *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +Return value: + +- graph + A Snap.py graph or a network representing the largest weakly connected component in *Graph*. + + +The following example shows how to get the largest weakly connected component in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 500) + MxWcc = snap.GetMxWcc(Graph) + for EI in MxWcc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 500) + MxWcc = snap.GetMxWcc(UGraph) + for EI in MxWcc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 500) + MxWcc = snap.GetMxWcc(Network) + for EI in MxWcc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetMxWcc.rst b/snap-python/source/doc/source/reference/GetMxWcc.rst new file mode 100644 index 0000000000000000000000000000000000000000..c24c3aee85fcd099b566d51ea7c2bf0626d22029 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxWcc.rst @@ -0,0 +1,36 @@ +GetMxWcc +'''''''' + +.. function:: GetMxWcc() + +A graph method that returns a graph representing the largest weakly connected component in the original graph. + +Parameters: + +- None + +Return value: + +- graph + A graph representing the largest weakly connected component in the original graph. + + +The following example shows how to get the largest weakly connected component in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 500) + MxWcc = Graph.GetMxWcc() + for EI in MxWcc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 500) + MxWcc = UGraph.GetMxWcc() + for EI in MxWcc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 500) + MxWcc = Network.GetMxWcc() + for EI in MxWcc.Edges(): + print("edge: (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetMxWccSz-swig.rst b/snap-python/source/doc/source/reference/GetMxWccSz-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..37e4b80d8f6e35cbae53ef9552f54b7924b330e5 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxWccSz-swig.rst @@ -0,0 +1,32 @@ +GetMxWccSz (SWIG) +''''''''''''''''' + +.. function:: GetMxWccSz(Graph) + :noindex: + +Returns the fraction of nodes in the largest weakly connected component of a Graph. + +Parameters: + + - *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + + - float + The fraction of nodes in the largest weakly connected component of a graph. + + +The following code shows how to calculate the relative size of the maximum weakly connected component for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 20, 10) + print('Relative size of WCC in Directed Graph:', snap.GetMxWccSz(Graph)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 20, 10) + print('Relative size of WCC in Undirected Graph:', snap.GetMxWccSz(UGraph)) + + Network = snap.GenRndGnm(snap.PNEANet, 20, 10) + print('Relative size of WCC in Network:', snap.GetMxWccSz(Network)) diff --git a/snap-python/source/doc/source/reference/GetMxWccSz.rst b/snap-python/source/doc/source/reference/GetMxWccSz.rst new file mode 100644 index 0000000000000000000000000000000000000000..3818179965e94345d0941b87f6a89676dcecba35 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetMxWccSz.rst @@ -0,0 +1,30 @@ +GetMxWccSz +'''''''''' + +.. function:: GetMxWccSz() + +A graph method that returns the fraction of nodes in the largest weakly connected component of a graph. + +Parameters: + +- None + +Return value: + +- float + The fraction of nodes in the largest weakly connected component of a graph. + + +The following code shows how to calculate the relative size of the maximum weakly connected component for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 20, 10) + print('Relative size of WCC in Directed Graph:', Graph.GetMxWccSz()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 20, 10) + print('Relative size of WCC in Undirected Graph:', UGraph.GetMxWccSz()) + + Network = snap.GenRndGnm(snap.TNEANet, 20, 10) + print('Relative size of WCC in Network:', Network.GetMxWccSz()) diff --git a/snap-python/source/doc/source/reference/GetNodeClustCf-swig.rst b/snap-python/source/doc/source/reference/GetNodeClustCf-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d4f6a6bbfd0ae33ffcff487fe1068e81b1affd2a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeClustCf-swig.rst @@ -0,0 +1,35 @@ +GetNodeClustCf (SWIG) +''''''''''''''''''''' + +.. function:: GetNodeClustCf(Graph, NId) + :noindex: + +Returns clustering coefficient of a particular node. Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId*: int (input) + A node id in the *Graph*. + +Return value: + +- float + Clustering coefficient of a particular node. + + +The following example shows how to calculate clustering coefficient of a particular node in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.GetNodeClustCf(Graph, 50) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.GetNodeClustCf(UGraph, 50) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.GetNodeClustCf(Network, 50) diff --git a/snap-python/source/doc/source/reference/GetNodeClustCf.rst b/snap-python/source/doc/source/reference/GetNodeClustCf.rst new file mode 100644 index 0000000000000000000000000000000000000000..67a18383e9142945fc8231be9b03dad812035a84 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeClustCf.rst @@ -0,0 +1,31 @@ +GetNodeClustCf +'''''''''''''' + +.. function:: GetNodeClustCf(NId) + +A graph method that returns clustering coefficient of a particular node. Considers the graph as undirected. + +Parameters: + +- *NId*: int + A node id in the *Graph*. + +Return value: + +- float + Clustering coefficient of a particular node. + + +The following example shows how to calculate clustering coefficient of a particular node in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.GetNodeClustCf(50) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.GetNodeClustCf(50) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.GetNodeClustCf(50) diff --git a/snap-python/source/doc/source/reference/GetNodeClustCf1-swig.rst b/snap-python/source/doc/source/reference/GetNodeClustCf1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a760b0aa4c8da139b49e55906ac8af0e7333c21f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeClustCf1-swig.rst @@ -0,0 +1,44 @@ +GetNodeClustCf (SWIG) +''''''''''''''''''''' + +.. function:: GetNodeClustCf(Graph, NIdCCfH) + :noindex: + +Computes clustering coefficient of each node in *Graph*. Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdCCfH*: :class:`TIntFltH`, a hash table of int keys and float values (output) + Clustering Coefficients. Keys are node IDs, values are the node's computed clustering coefficients. + +Return value: + +- None + + +The following example shows how to calculate the clustering coefficient for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NIdCCfH = snap.TIntFltH() + snap.GetNodeClustCf(Graph, NIdCCfH) + for item in NIdCCfH: + print(item, NIdCCfH[item]) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NIdCCfH = snap.TIntFltH() + snap.GetNodeClustCf(UGraph, NIdCCfH) + for item in NIdCCfH: + print(item, NIdCCfH[item]) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NIdCCfH = snap.TIntFltH() + snap.GetNodeClustCf(Network, NIdCCfH) + for item in NIdCCfH: + print(item, NIdCCfH[item]) + diff --git a/snap-python/source/doc/source/reference/GetNodeClustCfAll.rst b/snap-python/source/doc/source/reference/GetNodeClustCfAll.rst new file mode 100644 index 0000000000000000000000000000000000000000..9a9069d81b10fe72155d97e1624e5a6eb4775f3c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeClustCfAll.rst @@ -0,0 +1,37 @@ +GetNodeClustCfAll +''''''''''''''''' + +.. function:: GetNodeClustCfAll() + +A graph method that computes the clustering coefficient of each node. Considers the graph as undirected. + +Parameters: + +- None + +Return value: + +- :class:`TIntFltH`: a hash table of int keys and float values + Clustering Coefficients. Keys are node ids, values are the node's computed clustering coefficients. + + +The following example shows how to calculate the clustering coefficient for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NIdCCfH = Graph.GetNodeClustCfAll() + for item in NIdCCfH: + print(item, NIdCCfH[item]) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NIdCCfH = UGraph.GetNodeClustCfAll() + for item in NIdCCfH: + print(item, NIdCCfH[item]) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NIdCCfH = Network.GetNodeClustCfAll() + for item in NIdCCfH: + print(item, NIdCCfH[item]) + diff --git a/snap-python/source/doc/source/reference/GetNodeEcc-swig.rst b/snap-python/source/doc/source/reference/GetNodeEcc-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5511b53295fc80678b654a6977d058f4fefc900f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeEcc-swig.rst @@ -0,0 +1,41 @@ +GetNodeEcc (SWIG) +''''''''''''''''' + +.. function:: GetNodeEcc(Graph, NId, IsDir=False) + :noindex: + +Returns node eccentricity, the largest shortest-path distance from the node *NId* to any other node in the *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId*: int (output) + A node id in *Graph*. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- int + The eccentricity of node *NId* within *Graph*. + +The following example shows how to calculate eccentricity for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 10, 30) + for NI in Graph.Nodes(): + print(NI.GetId(), snap.GetNodeEcc(Graph, NI.GetId(), True)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 10, 30) + for NI in UGraph.Nodes(): + print(NI.GetId(), snap.GetNodeEcc(UGraph, NI.GetId(), False)) + + Network = snap.GenRndGnm(snap.PNEANet, 10, 30) + for NI in Network.Nodes(): + print(NI.GetId(), snap.GetNodeEcc(Network, NI.GetId(), True)) + diff --git a/snap-python/source/doc/source/reference/GetNodeEcc.rst b/snap-python/source/doc/source/reference/GetNodeEcc.rst new file mode 100644 index 0000000000000000000000000000000000000000..0b040325293ebb0423af86c611a700014be84e6b --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeEcc.rst @@ -0,0 +1,37 @@ +GetNodeEcc +'''''''''' + +.. function:: GetNodeEcc(NId, IsDir=False) + +A graph method that returns node eccentricity, the largest shortest-path distance from the node *NId* to any other node. + +Parameters: + +- *NId*: int + A node id. + +- (optional) *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- int + The eccentricity of node *NId*. + +The following example shows how to calculate eccentricity for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 10, 30) + for NI in Graph.Nodes(): + print(NI.GetId(), Graph.GetNodeEcc(NI.GetId(), True)) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 10, 30) + for NI in UGraph.Nodes(): + print(NI.GetId(), UGraph.GetNodeEcc(NI.GetId(), False)) + + Network = snap.GenRndGnm(snap.TNEANet, 10, 30) + for NI in Network.Nodes(): + print(NI.GetId(), Network.GetNodeEcc(NI.GetId(), True)) + diff --git a/snap-python/source/doc/source/reference/GetNodeInDegV-swig.rst b/snap-python/source/doc/source/reference/GetNodeInDegV-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..31e983df026ac125cac539eeecfa4b2d5f2a12e0 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeInDegV-swig.rst @@ -0,0 +1,43 @@ +GetNodeInDegV (SWIG) +'''''''''''''''''''' + +.. function:: GetNodeInDegV(Graph, NIdInDegV) + :noindex: + +Computes the in-degree for every node in *Graph*. +The result is stored in *NIdInDegV*, a vector of pairs (node id, node in degree). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdInDegV*: :class:`TIntPrV`, a vector or (int, int) pairs (output) + A vector of (node id, node in-degree) pairs. + +Return value: + +- None + + +The following example shows how to use :func:`GetNodeInDegV` with nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + InDegV = snap.TIntPrV() + snap.GetNodeInDegV(Graph, InDegV) + for item in InDegV: + print("node ID %d: in-degree %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + InDegV = snap.TIntPrV() + snap.GetNodeInDegV(UGraph, InDegV) + for item in InDegV: + print("node ID %d: in-degree %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + InDegV = snap.TIntPrV() + snap.GetNodeInDegV(Network, InDegV) + for item in InDegV: + print("node ID %d: in-degree %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetNodeInDegV.rst b/snap-python/source/doc/source/reference/GetNodeInDegV.rst new file mode 100644 index 0000000000000000000000000000000000000000..a1104d66733011f36ff7d5bbc9b4310cd92a071d --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeInDegV.rst @@ -0,0 +1,34 @@ +GetNodeInDegV +''''''''''''' + +.. function:: GetNodeInDegV() + +A graph method that returns the in-degree for every node. + +Parameters: + +- None + +Return value: + +- *NIdInDegV*: :class:`TIntPrV`, a vector or (int, int) pairs + A vector of (node id, node in-degree) pairs. + +The following example shows how to use :func:`GetNodeInDegV` with nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + InDegV = Graph.GetNodeInDegV() + for item in InDegV: + print("node ID %d: in-degree %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + InDegV = UGraph.GetNodeInDegV() + for item in InDegV: + print("node ID %d: in-degree %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + InDegV = Network.GetNodeInDegV() + for item in InDegV: + print("node ID %d: in-degree %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetNodeOutDegV-swig.rst b/snap-python/source/doc/source/reference/GetNodeOutDegV-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d8e345877ae1da5054f0f75c28c5b01b0e3ed42c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeOutDegV-swig.rst @@ -0,0 +1,44 @@ +GetNodeOutDegV (SWIG) +''''''''''''''''''''' + +.. function:: GetNodeOutDegV(Graph, NIdOutDegV) + :noindex: + +Computes the out-degree for every node in *Graph*. +The result is stored in *NIdOutDegV*, a vector of pairs (node id, node out degree). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdOutDegV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of (node id, node out degree) pairs. + +Return value: + +- None + + +The following example shows how to use :func:`GetNodeOutDegV` with nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + OutDegV = snap.TIntPrV() + snap.GetNodeOutDegV(Graph, OutDegV) + for item in OutDegV: + print("node ID %d: out-degree %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + OutDegV = snap.TIntPrV() + snap.GetNodeOutDegV(UGraph, OutDegV) + for item in OutDegV: + print("node ID %d: out-degree %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + OutDegV = snap.TIntPrV() + snap.GetNodeOutDegV(Network, OutDegV) + for item in OutDegV: + print("node ID %d: out-degree %d" % (item.GetVal1(), item.GetVal2())) + diff --git a/snap-python/source/doc/source/reference/GetNodeOutDegV.rst b/snap-python/source/doc/source/reference/GetNodeOutDegV.rst new file mode 100644 index 0000000000000000000000000000000000000000..1f3039bc74c08bb30d77c7eb68fb58b0df936bf3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeOutDegV.rst @@ -0,0 +1,36 @@ +GetNodeOutDegV +'''''''''''''' + +.. function:: GetNodeOutDegV() + +A graph method that returns the out-degree for every node. + +Parameters: + +- None + +Return value: + +- *NIdOutDegV*: :class:`TIntPrV`, a vector of (int, int) pairs + A vector of (node id, node out degree) pairs. + + +The following example shows how to use :func:`GetNodeOutDegV` with nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + OutDegV = Graph.GetNodeOutDegV() + for item in OutDegV: + print("node ID %d: out-degree %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + OutDegV = UGraph.GetNodeOutDegV() + for item in OutDegV: + print("node ID %d: out-degree %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + OutDegV = Network.GetNodeOutDegV() + for item in OutDegV: + print("node ID %d: out-degree %d" % (item.GetVal1(), item.GetVal2())) + diff --git a/snap-python/source/doc/source/reference/GetNodeTriads-swig.rst b/snap-python/source/doc/source/reference/GetNodeTriads-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..9ce75bfe86faf5315d88a8d0e32c2752f74c238a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeTriads-swig.rst @@ -0,0 +1,38 @@ +GetNodeTriads (SWIG) +'''''''''''''''''''' + +.. function:: GetNodeTriads(Graph, NId) + :noindex: + +Returns number of triads a node *NId* participates in. Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId*: int (input) + A node id in *Graph*. + +Return value: + +- int + The number of triads node *NId* participates in. + +The following example shows the number of triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + for NI in Graph.Nodes(): + print('%d %d' % (NI.GetId(), snap.GetNodeTriads(Graph, NI.GetId()))) + + UGraph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + for NI in UGraph.Nodes(): + print('%d %d' % (NI.GetId(), snap.GetNodeTriads(UGraph, NI.GetId()))) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + for NI in Network.Nodes(): + print('%d %d' % (NI.GetId(), snap.GetNodeTriads(Network, NI.GetId()))) + diff --git a/snap-python/source/doc/source/reference/GetNodeTriads.rst b/snap-python/source/doc/source/reference/GetNodeTriads.rst new file mode 100644 index 0000000000000000000000000000000000000000..d4ee00eb95695558086d10e362a2080c85f5407a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeTriads.rst @@ -0,0 +1,34 @@ +GetNodeTriads +''''''''''''' + +.. function:: GetNodeTriads(NId) + +A graph method that returns the number of triads a node *NId* participates in. Considers the graph as undirected. + +Parameters: + +- *NId*: int + A node id in the graph. + +Return value: + +- int + The number of triads node *NId* participates in. + +The following example shows how to calculate the number of triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + for NI in Graph.Nodes(): + print('%d %d' % (NI.GetId(), Graph.GetNodeTriads(NI.GetId()))) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + for NI in UGraph.Nodes(): + print('%d %d' % (NI.GetId(), UGraph.GetNodeTriads(NI.GetId()))) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + for NI in Network.Nodes(): + print('%d %d' % (NI.GetId(), Network.GetNodeTriads(NI.GetId()))) + diff --git a/snap-python/source/doc/source/reference/GetNodeTriads1-swig.rst b/snap-python/source/doc/source/reference/GetNodeTriads1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2fb5fb85f89c9567807ebf945f7e91c95c995b59 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeTriads1-swig.rst @@ -0,0 +1,64 @@ +GetNodeTriads (SWIG) +'''''''''''''''''''' + +.. function:: GetNodeTriads(Graph, NId, GroupSet) + :noindex: + +Returns the number of closed triads between a node *NId* and a subset of its neighbors in *GroupSet* as well as the number of triads for cases where neighbors are not in *GroupSet*. +Considers *Graph* to be undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *NId*: int (input) + NId of the node of interest + +- *GroupSet*: TIntSet (input) + Set of NIds representing a subset of the neighbors of the node of interest + + +Return value: + +- list: [int, int, int, int] + The list contains four elements: the first two elements are the number of closed triads between *NId* and nodes in *GroupSet*, the third element is the number of triads between *NId* and a node in *GroupSet* and another node not in *GroupSet*, the fourth element is the number of triads between *NId* and two nodes not in *GroupSet*. + +The following example shows how to calculate the number of triads a node participates in for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenFull(snap.PNGraph, 100) + NI = Graph.Nodes().next() + NId = NI.GetId() + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + result = snap.GetNodeTriads(Graph, NId, GroupSet) + print("number of triads between", NId, " and two set members", result[0]) + print("number of triads between", NId, " and a set member and a set non-member", result[2]) + print("number of triads between", NId, " and two set non-members", result[3]) + + Graph = snap.GenFull(snap.PUNGraph, 100) + NI = Graph.Nodes().next() + NId = NI.GetId() + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + result = snap.GetNodeTriads(Graph, NId, GroupSet) + print("number of triads between", NId, " and two set members", result[0]) + print("number of triads between", NId, " and a set member and a set non-member", result[2]) + print("number of triads between", NId, " and two set non-members", result[3]) + + Graph = snap.GenFull(snap.PNEANet, 100) + NI = Graph.Nodes().next() + NId = NI.GetId() + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + result = snap.GetNodeTriads(Graph, NId, GroupSet) + print("number of triads between", NId, " and two set members", result[0]) + print("number of triads between", NId, " and a set member and a set non-member", result[2]) + print("number of triads between", NId, " and two set non-members", result[3]) + diff --git a/snap-python/source/doc/source/reference/GetNodeTriadsAll-swig.rst b/snap-python/source/doc/source/reference/GetNodeTriadsAll-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..9e131c6732d725ead8a0272468684cbcfbe7c248 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeTriadsAll-swig.rst @@ -0,0 +1,48 @@ +GetNodeTriadsAll (SWIG) +''''''''''''''''''''''' + +.. function:: GetNodeTriadsAll(Graph, NId) + :noindex: + +Returns the number of closed and open triads that a node *NId* participates in. + +Considers the *Graph* as undirected. + +Parameters: + +- *Graph*: PGraph (input) + A Snap.py PGraph (considered as undirected) + +- *NId*: int (input) + The Id of the node of interest in *Graph* + +- *ClosedTriads*: int (input) + Number of closed triads + +- *OpenTriads*: int (input) + Number of open triads + +Return value: + +- list: [int, int, int] + The list contains three elements: the first two elements are the number of closed triads and the third element is the number of open triads in the graph. + +The following example shows how to compute the number of closed and open triads that a node *NId* participates in for the :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` classes:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + result = snap.GetNodeTriadsAll(Graph, 2) + print("closed triads", result[0]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + result = snap.GetNodeTriadsAll(Graph, 5) + print("closed triads", result[0]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + result = snap.GetNodeTriadsAll(Graph, 6) + print("closed triads", result[0]) + print("open triads", result[2]) + diff --git a/snap-python/source/doc/source/reference/GetNodeTriadsAll.rst b/snap-python/source/doc/source/reference/GetNodeTriadsAll.rst new file mode 100644 index 0000000000000000000000000000000000000000..a2edd7a60553bdefd17de749a81c7cda9c64a8f0 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeTriadsAll.rst @@ -0,0 +1,38 @@ +GetNodeTriadsAll +'''''''''''''''' + +.. function:: GetNodeTriadsAll(NId) + +A graph method that returns the number of closed and open triads that a node *NId* participates in. + +Considers the graph as undirected. + +Parameters: + +- *NId*: int + The id of the node of interest. + +Return value: + +- list: [int, int, int] + The list contains three elements: the first two elements are the number of closed triads and the third element is the number of open triads in the graph. + +The following example shows how to compute the number of closed and open triads that a node *NId* participates in for the :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` classes:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + result = Graph.GetNodeTriadsAll(2) + print("closed triads", result[0]) + print("open triads", result[2]) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + result = UGraph.GetNodeTriadsAll(5) + print("closed triads", result[0]) + print("open triads", result[2]) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + result = Network.GetNodeTriadsAll(6) + print("closed triads", result[0]) + print("open triads", result[2]) + diff --git a/snap-python/source/doc/source/reference/GetNodeTriadsSet.rst b/snap-python/source/doc/source/reference/GetNodeTriadsSet.rst new file mode 100644 index 0000000000000000000000000000000000000000..eb4d6b9e510e39c739291b138398fce3ff1a5192 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeTriadsSet.rst @@ -0,0 +1,60 @@ +GetNodeTriadsSet +'''''''''''''''' + +.. function:: GetNodeTriadsSet(NId, GroupSet) + +A graph method that returns the number of closed triads between a node *NId* and a subset of its neighbors in *GroupSet* as well as the number of triads for cases where neighbors are not in *GroupSet*. +Considers the graph to be undirected. + +Parameters: + +- *NId*: int + NId of the node of interest + +- *GroupSet*: Python set or :class:`TIntSet` + Set of NIds representing a subset of the neighbors of the node of interest + + +Return value: + +- list: [int, int, int, int] + The list contains four elements: the first two elements are the number of closed triads between *NId* and nodes in *GroupSet*, the third element is the number of triads between *NId* and a node in *GroupSet* and another node not in *GroupSet*, the fourth element is the number of triads between *NId* and two nodes not in *GroupSet*. + +The following example shows how to calculate the number of triads a node participates in for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenFull(snap.TNGraph, 100) + NId = Graph.GetRndNId() + NI = Graph.GetNI(NId) + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + result = Graph.GetNodeTriadsSet(NId, GroupSet) + print("number of triads between", NId, " and two set members", result[0]) + print("number of triads between", NId, " and a set member and a set non-member", result[2]) + print("number of triads between", NId, " and two set non-members", result[3]) + + UGraph = snap.GenFull(snap.TUNGraph, 100) + NId = UGraph.GetRndNId() + NI = UGraph.GetNI(NId) + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + result = UGraph.GetNodeTriadsSet(NId, GroupSet) + print("number of triads between", NId, " and two set members", result[0]) + print("number of triads between", NId, " and a set member and a set non-member", result[2]) + print("number of triads between", NId, " and two set non-members", result[3]) + + Network = snap.GenFull(snap.TNEANet, 100) + NId = Network.GetRndNId() + NI = Network.GetNI(NId) + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + result = Network.GetNodeTriadsSet(NId, GroupSet) + print("number of triads between", NId, " and two set members", result[0]) + print("number of triads between", NId, " and a set member and a set non-member", result[2]) + print("number of triads between", NId, " and two set non-members", result[3]) + diff --git a/snap-python/source/doc/source/reference/GetNodeWcc-swig.rst b/snap-python/source/doc/source/reference/GetNodeWcc-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f8a4f98b3ba4e6400f05d9264f3d358ea2b33477 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeWcc-swig.rst @@ -0,0 +1,51 @@ +GetNodeWcc (SWIG) +''''''''''''''''' + +.. function:: GetNodeWcc(Graph, NId, CnCom) + :noindex: + +Returns (via output parameter *CnCom*) all nodes that are in the same connected component as node *NId*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NId*: int (input) + A node id in *Graph*. + +- *CnCom*: :class:`TIntV`, a vector of ints (output) + All nodes that are in the same weakly connected component as *NId*. + +Return value: + +- None + + +The following example shows how to get the nodes in the same connected component as node 0 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + CnCom = snap.TIntV() + snap.GetNodeWcc(Graph, 0, CnCom) + print("Nodes in the same connected component as node 0:") + for node in CnCom: + print(node) + + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + CnCom = snap.TIntV() + snap.GetNodeWcc(UGraph, 0, CnCom) + print("Nodes in the same connected component as node 0:") + for node in CnCom: + print(node) + + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + CnCom = snap.TIntV() + snap.GetNodeWcc(Network, 0, CnCom) + print("Nodes in the same connected component as node 0:") + for node in CnCom: + print(node) diff --git a/snap-python/source/doc/source/reference/GetNodeWcc.rst b/snap-python/source/doc/source/reference/GetNodeWcc.rst new file mode 100644 index 0000000000000000000000000000000000000000..86140fa8a6ec8aeaf5f640cf288fc268f8dbf813 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodeWcc.rst @@ -0,0 +1,41 @@ +GetNodeWcc +'''''''''' + +.. function:: GetNodeWcc(NId) + +A graph method that returns all nodes that are in the same connected component as node *NId*. + +Parameters: + +- *NId*: int + A node id in the graph. + +Return value: + +- *CnCom*: :class:`TIntV`, a vector of ints + All nodes that are in the same weakly connected component as *NId*. + +The following example shows how to get the nodes in the same connected component as node 0 in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + CnCom = Graph.GetNodeWcc(0) + print("Nodes in the same connected component as node 0:") + for node in CnCom: + print(node) + + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + CnCom = UGraph.GetNodeWcc(0) + print("Nodes in the same connected component as node 0:") + for node in CnCom: + print(node) + + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + CnCom = Network.GetNodeWcc(0) + print("Nodes in the same connected component as node 0:") + for node in CnCom: + print(node) diff --git a/snap-python/source/doc/source/reference/GetNodesAtHop-swig.rst b/snap-python/source/doc/source/reference/GetNodesAtHop-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..672979a89b2f2be18b4482f29aefc1f72eaf2c3c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodesAtHop-swig.rst @@ -0,0 +1,54 @@ +GetNodesAtHop (SWIG) +'''''''''''''''''''' + +.. function:: GetNodesAtHop(Graph, StartNId, Hop, NIdV, IsDir) + :noindex: + +Finds the node ids of all the nodes that are at distance *Hop* from node *StartNId* and stores them in *NIdV*. The function returns the number of nodes found. + +Parameters: + +- *PGraph*: graph (input) + A Snap.py graph or a network. + +- *StartNId*: int (input) + Starting node id. + +- *Hop*: int (input) + Distance from the starting node. + +- *NIdV*: :class:`TIntV`, a vector of ints (output) + Node ids of nodes *Hop* distance away from *StartNId*. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed (True) or undirected (False). + +Return value: + +- int + The number of nodes at distance *Hop* from *StartNId*. + + +The following example shows how to get a vector of nodes at hop distance +2 away from start node 1 for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NodeVec = snap.TIntV() + snap.GetNodesAtHop(Graph, 1, 2, NodeVec, True) + for item in NodeVec: + print(item) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NodeVec = snap.TIntV() + snap.GetNodesAtHop(UGraph, 1, 2, NodeVec, False) + for item in NodeVec: + print(item) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NodeVec = snap.TIntV() + snap.GetNodesAtHop(Network, 1, 2, NodeVec, True) + for item in NodeVec: + print(item) diff --git a/snap-python/source/doc/source/reference/GetNodesAtHop.rst b/snap-python/source/doc/source/reference/GetNodesAtHop.rst new file mode 100644 index 0000000000000000000000000000000000000000..7f63e6200526eb041c161afc7ffd7fb43c7772c2 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodesAtHop.rst @@ -0,0 +1,47 @@ +GetNodesAtHop +''''''''''''' + +.. function:: GetNodesAtHop(StartNId, Hop, IsDir) + +A graph method that finds the node ids of all the nodes that are at distance *Hop* from node *StartNId* and stores them in *NIdV*. The function returns the number of nodes found. + +Parameters: + +- *StartNId*: int + Starting node id. + +- *Hop*: int + Distance from the starting node. + +- *IsDir*: bool + Indicates whether the edges should be considered directed (True) or undirected (False). + +Return value: + +- int + The number of nodes at distance *Hop* from *StartNId*. + +- *NIdV*: :class:`TIntV`, a vector of ints + Node ids of nodes *Hop* distance away from *StartNId*. + + +The following example shows how to get a vector of nodes at hop distance +2 away from start node 1 for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NodeNum, NodeVec = Graph.GetNodesAtHop(1, 2, True) + for item in NodeVec: + print(item) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NodeNum, NodeVec = UGraph.GetNodesAtHop(1, 2, False) + for item in NodeVec: + print(item) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NodeNum, NodeVec = Network.GetNodesAtHop(1, 2, True) + for item in NodeVec: + print(item) diff --git a/snap-python/source/doc/source/reference/GetNodesAtHops-swig.rst b/snap-python/source/doc/source/reference/GetNodesAtHops-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..cdebe8b7fb5dad5dc6870e54b8315ccb0bf89a11 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodesAtHops-swig.rst @@ -0,0 +1,49 @@ +GetNodesAtHops (SWIG) +''''''''''''''''''''' + +.. function:: GetNodesAtHops (Graph, StartNId, HopCntV, IsDir=False) + :noindex: + +Fills *HopCntV* with pairs (hop distance from *StartNId*, number of nodes at that hop distance). The function returns the number of different hop distances reachable from *StartNId*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *StartNId*: int (input) + Starting node id. + +- *HopCntV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + Vector of (hop distance, number of nodes at that distance) pairs. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed (True) or undirected (False). + +Return value: + +- int + Number of different hop distances reachable from *StartNId*, including self-loops. + + +The following example shows how to obtain number of nodes for each hop distance from node 1 in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NodeVec = snap.TIntPrV() + snap.GetNodesAtHops(Graph, 1, NodeVec, True) + for item in NodeVec: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NodeVec = snap.TIntPrV() + snap.GetNodesAtHops(UGraph, 1, NodeVec, False) + for item in NodeVec: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NodeVec = snap.TIntPrV() + snap.GetNodesAtHops(Network, 1, NodeVec, True) + for item in NodeVec: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetNodesAtHops.rst b/snap-python/source/doc/source/reference/GetNodesAtHops.rst new file mode 100644 index 0000000000000000000000000000000000000000..60a2195e811f2c53eb599dd756ca89e5855ae78e --- /dev/null +++ b/snap-python/source/doc/source/reference/GetNodesAtHops.rst @@ -0,0 +1,42 @@ +GetNodesAtHops +'''''''''''''' + +.. function:: GetNodesAtHops (StartNId, IsDir=False) + +A graph method that computes the number of nodes at different hop distances reachable from *StartNId*. It returns the number of different hops and pairs (hop distance from *StartNId*, number of nodes at that hop distance). + +Parameters: + +- *StartNId*: int + Starting node id. + +- *IsDir*: bool + Indicates whether the edges should be considered directed (True) or undirected (False). + +Return value: + +- int + Number of different hop distances reachable from *StartNId*, including self-loops. + +- *HopCntV*: :class:`TIntPrV`, a vector of (int, int) pairs + Vector of (hop distance, number of nodes at that distance) pairs. + + +The following example shows how to obtain number of nodes for each hop distance from node 1 in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NodeNum, NodeVec = Graph.GetNodesAtHops(1, True) + for item in NodeVec: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NodeNum, NodeVec = UGraph.GetNodesAtHops(1, False) + for item in NodeVec: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NodeNum, NodeVec = Network.GetNodesAtHops(1, True) + for item in NodeVec: + print("%d, %d" % (item.GetVal1(), item.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetOutDegCnt-swig.rst b/snap-python/source/doc/source/reference/GetOutDegCnt-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..01f7fddf77e3e205c4751f017858ea2988c7bf0c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetOutDegCnt-swig.rst @@ -0,0 +1,42 @@ +GetOutDegCnt (SWIG) +''''''''''''''''''' + +.. function:: GetOutDegCnt(Graph, DegToCntV) + :noindex: + +Computes an out-degree histogram: a vector of pairs (out-degree, number of nodes of such out-degree). The results are stored in *DegToCntV*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *DegToCntV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + A vector of (out-degree, number of nodes of such out-degree) pairs. + +Return value: + +- None + + +The following examples shows how to obtain the out-degree histogram for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetOutDegCnt(Graph, DegToCntV) + for item in DegToCntV: + print("%d nodes with out-degree %d" % (item.GetVal2(), item.GetVal1())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetOutDegCnt(UGraph, DegToCntV) + for item in DegToCntV: + print("%d nodes with out-degree %d" % (item.GetVal2(), item.GetVal1())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + DegToCntV = snap.TIntPrV() + snap.GetOutDegCnt(Network, DegToCntV) + for item in DegToCntV: + print("%d nodes with out-degree %d" % (item.GetVal2(), item.GetVal1())) diff --git a/snap-python/source/doc/source/reference/GetOutDegCnt.rst b/snap-python/source/doc/source/reference/GetOutDegCnt.rst new file mode 100644 index 0000000000000000000000000000000000000000..89abee514e3e6bb7dc0627054d0ceab26cde4950 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetOutDegCnt.rst @@ -0,0 +1,35 @@ +GetOutDegCnt +'''''''''''' + +.. function:: GetOutDegCnt() + +A graph method that returns the number of nodes for each out-degree as a vector of pairs (out-degree, number of nodes of such out-degree). + +Parameters: + +- None + +Return value: + +- *DegToCntV*: :class:`TIntPrV`, a vector of (int, int) pairs + A vector of (out-degree, number of nodes of such out-degree) pairs. + + +The following examples shows how to obtain the out-degree histogram for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + DegToCntV = Graph.GetOutDegCnt() + for item in DegToCntV: + print("%d nodes with out-degree %d" % (item.GetVal2(), item.GetVal1())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + DegToCntV = UGraph.GetOutDegCnt() + for item in DegToCntV: + print("%d nodes with out-degree %d" % (item.GetVal2(), item.GetVal1())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + DegToCntV = Network.GetOutDegCnt() + for item in DegToCntV: + print("%d nodes with out-degree %d" % (item.GetVal2(), item.GetVal1())) diff --git a/snap-python/source/doc/source/reference/GetOutEgonetHop.rst b/snap-python/source/doc/source/reference/GetOutEgonetHop.rst new file mode 100644 index 0000000000000000000000000000000000000000..d0c0f66222fc051b6e9b5e3b8fed90f6ce3904f8 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetOutEgonetHop.rst @@ -0,0 +1,34 @@ +GetOutEgonetHop +''''''''''''''' + +.. function:: GetOutEgonetHop(NId, H) + +A graph method that returns an *H* hop out-ego network of the node *NId*. The *H* hop out-ego network includes the node *NId*, its out-neighbours and edges that connect them to the origin node, then all their out-neighbours and edges and so on until *H* hop neighbours. + +Parameters: + +- *NId*: int + Id of the center node of the ego network. + +- *H*: int + The number of hops for the ego network. + +Return value: + +- graph + A graph of the same type as the input graph, containing the out-ego network for *NId*. + +The following example shows how to create a subgraph for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NGraph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + OutEgonet = NGraph.GetOutEgonetHop(0, 2) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + OutEgonet = UGraph.GetOutEgonetHop(3, 1) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + OutEgonet = Network.GetOutEgonetHop(10, 3) + diff --git a/snap-python/source/doc/source/reference/GetPageRank-swig.rst b/snap-python/source/doc/source/reference/GetPageRank-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..e36f7fcbf982b2ad284f7c49cd2faa9720499ec3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetPageRank-swig.rst @@ -0,0 +1,53 @@ +GetPageRank (SWIG) +'''''''''''''''''' + +.. function:: GetPageRank(Graph, PRankH, C=0.85, Eps=1e-4, MaxIter=100) + :noindex: + +Computes the PageRank score of every node in *Graph*. The scores are stored in *PRankH*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *PRankH*: :class:`TIntFltH`, a hash of int keys and float values (output) + PageRank scores. Keys are node IDs, values are computed PageRank scores. + +- *C*: float (input) + Damping factor. + +- *Eps*: float (input) + Convergence difference. + +- *MaxIter*: int (input) + Maximum number of iterations. + +Return value: + +- None + + +The following example shows how to calculate PageRank scores for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + PRankH = snap.TIntFltH() + snap.GetPageRank(Graph, PRankH) + for item in PRankH: + print(item, PRankH[item]) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + PRankH = snap.TIntFltH() + snap.GetPageRank(UGraph, PRankH) + for item in PRankH: + print(item, PRankH[item]) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + PRankH = snap.TIntFltH() + snap.GetPageRank(Network, PRankH) + for item in PRankH: + print(item, PRankH[item]) + diff --git a/snap-python/source/doc/source/reference/GetPageRank.rst b/snap-python/source/doc/source/reference/GetPageRank.rst new file mode 100644 index 0000000000000000000000000000000000000000..2761e9fef9118c9c697101a7737d4ad31376e8a9 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetPageRank.rst @@ -0,0 +1,44 @@ +GetPageRank +''''''''''' + +.. function:: GetPageRank(C=0.85, Eps=1e-4, MaxIter=100) + +A graph method that returns the PageRank score of every node. + +Parameters: + +- *C*: float + Damping factor. + +- *Eps*: float + Convergence difference. + +- *MaxIter*: int + Maximum number of iterations. + +Return value: + +- *PRankH*: :class:`TIntFltH`, a hash of int keys and float values + PageRank scores. Keys are node ids, values are computed PageRank scores. + + +The following example shows how to calculate PageRank scores for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + PRankH = Graph.GetPageRank() + for item in PRankH: + print(item, PRankH[item]) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + PRankH = UGraph.GetPageRank() + for item in PRankH: + print(item, PRankH[item]) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + PRankH = Network.GetPageRank() + for item in PRankH: + print(item, PRankH[item]) + diff --git a/snap-python/source/doc/source/reference/GetRndESubGraph-swig.rst b/snap-python/source/doc/source/reference/GetRndESubGraph-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a9ac66f18ab8e429ad18e6842a1f72c296d283c1 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetRndESubGraph-swig.rst @@ -0,0 +1,35 @@ +GetRndESubGraph (SWIG) +'''''''''''''''''''''' + +.. function:: GetRndESubGraph(Graph, numEdges) + :noindex: + +Randomly selects *numEdges* edges from the input graph *Graph* and returns a subgraph on those edges. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *numEdges*: int (input) + Number of edges desired in the output graph. + +Return value: + +- graph + The induced sub-graph. + + +The following example shows how to get a random subgraph with 10 edges from a graph of type +:class:`TNGraph`, :class:`TUNGraph`, or :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + SubGraph = snap.GetRndESubGraph(Graph, 10) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + SubUGraph = snap.GetRndESubGraph(UGraph, 10) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + SubNetwork = snap.GetRndESubGraph(Network, 10) diff --git a/snap-python/source/doc/source/reference/GetRndESubGraph.rst b/snap-python/source/doc/source/reference/GetRndESubGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..bd6c11fc864b9e0344ee9aa7a6d54a045069ec6f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetRndESubGraph.rst @@ -0,0 +1,31 @@ +GetRndESubGraph +''''''''''''''' + +.. function:: GetRndESubGraph(numEdges) + +A graph method that randomly selects *numEdges* edges from the original graph and returns a subgraph on those edges. + +Parameters: + +- *numEdges*: int + Number of edges desired in the output graph. + +Return value: + +- graph + The induced sub-graph. + + +The following example shows how to get a random subgraph with 10 edges from a graph of type +:class:`TNGraph`, :class:`TUNGraph`, or :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + SubGraph = Graph.GetRndESubGraph(10) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + SubUGraph = UGraph.GetRndESubGraph(10) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + SubNetwork = Network.GetRndESubGraph(10) diff --git a/snap-python/source/doc/source/reference/GetRndSubGraph-swig.rst b/snap-python/source/doc/source/reference/GetRndSubGraph-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2cad504d764478694cd2d7289db6c6e3a0a460dc --- /dev/null +++ b/snap-python/source/doc/source/reference/GetRndSubGraph-swig.rst @@ -0,0 +1,36 @@ +GetRndSubGraph (SWIG) +''''''''''''''''''''' + +.. function:: GetRndSubGraph(Graph, numNodes) + :noindex: + +Randomly selects *numNodes* nodes from the input graph and returns an induced graph on those nodes. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *numNodes*: int (input) + Number of nodes desired in the output graph. + +Return value: + +- graph + The induced sub-graph. + + +The following example shows how to get a random subgraph of size 10 from a graph of type +:class:`TNGraph`, :class:`TUNGraph`, or :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + SubGraph = snap.GetRndSubGraph(Graph,10) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + SubUGraph = snap.GetRndSubGraph(UGraph,10) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + SubNetwork = snap.GetRndSubGraph(Network,10) + diff --git a/snap-python/source/doc/source/reference/GetRndSubGraph.rst b/snap-python/source/doc/source/reference/GetRndSubGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..51123c7c8096345000557a8d624cd439aaa9f628 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetRndSubGraph.rst @@ -0,0 +1,32 @@ +GetRndSubGraph +'''''''''''''' + +.. function:: GetRndSubGraph(numNodes) + +A graph method that randomly selects *numNodes* nodes from the input graph and returns an induced graph on those nodes. + +Parameters: + +- *numNodes*: int + Number of nodes desired in the output graph. + +Return value: + +- graph + The induced sub-graph. + + +The following example shows how to get a random subgraph of size 10 from a graph of type +:class:`TNGraph`, :class:`TUNGraph`, or :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + SubGraph = Graph.GetRndSubGraph(10) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + SubUGraph = UGraph.GetRndSubGraph(10) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + SubNetwork = Network.GetRndSubGraph(10) + diff --git a/snap-python/source/doc/source/reference/GetSccSzCnt-swig.rst b/snap-python/source/doc/source/reference/GetSccSzCnt-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f57004c1088e91c6ee25ddd535f4b3d43f4ebd78 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSccSzCnt-swig.rst @@ -0,0 +1,43 @@ +GetSccSzCnt (SWIG) +'''''''''''''''''' + +.. function:: GetSccSzCnt(Graph, SccSzCnt) + :noindex: + +Returns a distribution of strongly connected component sizes. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *SccSzCnt*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + Vector of pairs (number of nodes in the component, number of such components). + +Return Value: + +- None + + +The following example shows how to get the distribution of strongly-connected component sizes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + ComponentDist = snap.TIntPrV() + snap.GetSccSzCnt(Graph, ComponentDist) + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + ComponentDist = snap.TIntPrV() + snap.GetSccSzCnt(UGraph, ComponentDist) + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + ComponentDist = snap.TIntPrV() + snap.GetSccSzCnt(Network, ComponentDist) + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetSccSzCnt.rst b/snap-python/source/doc/source/reference/GetSccSzCnt.rst new file mode 100644 index 0000000000000000000000000000000000000000..32dee26eaa80607131f068fab3e68f0e97c53d19 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSccSzCnt.rst @@ -0,0 +1,36 @@ +GetSccSzCnt +''''''''''' + +.. function:: GetSccSzCnt() + +A graph method that returns a distribution of strongly connected component sizes. + +Parameters: + +- None + +Return Value: + +- *SccSzCnt*: :class:`TIntPrV`, a vector of (int, int) pairs + Vector of pairs (number of nodes in the component, number of such components). + + +The following example shows how to get the distribution of strongly-connected component sizes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + ComponentDist = Graph.GetSccSzCnt() + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + ComponentDist = UGraph.GetSccSzCnt() + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + ComponentDist = Network.GetSccSzCnt() + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetSccs-swig.rst b/snap-python/source/doc/source/reference/GetSccs-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..919e56350f1a6d5ca90bb8461d35a71f70f74bd3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSccs-swig.rst @@ -0,0 +1,44 @@ +GetSccs (SWIG) +'''''''''''''' + +.. function:: GetSccs (Graph, CnComV) + :noindex: + +Returns all strongly connected components in *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *CnComV*: :class:`TCnComV`, a vector of connected components (output) + Vector of all strongly-connected components. Each component consists of a TIntV vector of node ids. + +Return value: + +- None + + +The following example shows how to calculate all strongly-connected components in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Components = snap.TCnComV() + snap.GetSccs(Graph, Components) + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 1000, 50) + Components = snap.TCnComV() + snap.GetSccs(UGraph, Components) + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + Network = snap.GenRndGnm(snap.PNEANet, 1000, 300) + Components = snap.TCnComV() + snap.GetSccs(Network, Components) + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + diff --git a/snap-python/source/doc/source/reference/GetSccs.rst b/snap-python/source/doc/source/reference/GetSccs.rst new file mode 100644 index 0000000000000000000000000000000000000000..71887e4b59cd316a2ad500cf2c73461f372bbd7b --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSccs.rst @@ -0,0 +1,37 @@ +GetSccs +''''''' + +.. function:: GetSccs () + +A graph method that returns all strongly connected components in a graph. + +Parameters: + +- None + +Return value: + +- *CnComV*: :class:`TCnComV`, a vector of connected components + Vector of all strongly-connected components. Each component consists of a TIntV vector of node ids. + + +The following example shows how to calculate all strongly-connected components in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Components = Graph.GetSccs() + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 1000, 50) + Components =UGraph.GetSccs() + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + Network = snap.GenRndGnm(snap.TNEANet, 1000, 300) + Components = Network.GetSccs() + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + diff --git a/snap-python/source/doc/source/reference/GetShortPath-swig.rst b/snap-python/source/doc/source/reference/GetShortPath-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..3c0eb2acfb48f8d6cf12cf8f0cd8767c48c4b2e5 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetShortPath-swig.rst @@ -0,0 +1,45 @@ +GetShortPath (SWIG) +''''''''''''''''''' + +.. function:: GetShortPath(Graph, SrcNId, DstNId, IsDir=False) + :noindex: + +Returns the length of the shortest path from node *SrcNId* to node *DstNId*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *SrcNId*: int (input) + Node id for source node. + +- *DstNId*: int (input) + Node id for destination node. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- int + Number of edges traversed in shortest path from *SrcNId* to *DstNId*. + + +The following example shows how to find shortest path for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Length = GetShortPath(Graph, 1, 100) + print("Shortest Path from node 1 to node 100 is %d edges" % Length) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Length = GetShortPath(UGraph, 1, 100) + print("Shortest Path from node 1 to node 100 is %d edges" % Length) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Length = GetShortPath(Network, 1, 100) + print("Shortest Path from node 1 to node 100 is %d edges" % Length) + diff --git a/snap-python/source/doc/source/reference/GetShortPath.rst b/snap-python/source/doc/source/reference/GetShortPath.rst new file mode 100644 index 0000000000000000000000000000000000000000..ea2044927733cbfac82d39c5f4235caa8f7d7ba3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetShortPath.rst @@ -0,0 +1,41 @@ +GetShortPath +'''''''''''' + +.. function:: GetShortPath(SrcNId, DstNId, IsDir=False) + +A graph method that returns the length of the shortest path from node *SrcNId* to node *DstNId*. + +Parameters: + +- *SrcNId*: int + Node id for source node. + +- *DstNId*: int + Node id for destination node. + +- (optional) *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +Return value: + +- int + Number of edges traversed in shortest path from *SrcNId* to *DstNId*. + + +The following example shows how to find shortest path for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Length = Graph.GetShortPath(1, 100) + print("Shortest Path from node 1 to node 100 is %d edges" % Length) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Length = UGraph.GetShortPath(1, 100) + print("Shortest Path from node 1 to node 100 is %d edges" % Length) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Length = Network.GetShortPath(1, 100) + print("Shortest Path from node 1 to node 100 is %d edges" % Length) + diff --git a/snap-python/source/doc/source/reference/GetShortPath1-swig.rst b/snap-python/source/doc/source/reference/GetShortPath1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d6a22bfd2ddaddabb1716ea74561e3210b089394 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetShortPath1-swig.rst @@ -0,0 +1,57 @@ +GetShortPath (SWIG) +''''''''''''''''''' + +.. function:: GetShortPath(Graph, SrcNId, NIdToDistH, IsDir=false, MaxDist=TInt::Mx) + :noindex: + +Returns the length of the shortest path from node SrcNId to all other nodes in the network. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *SrcNId*: int (input) + Node id for source node. + +- *NIdToDistH*: :class:`TIntH`, a hash table with integer keys and values (output) + Maps node id to shortest path distance. Only contains nodes that are reachable from *SrcNId*. + +- *IsDir*: bool (input) + Indicates whether the edges should be considered directed or undirected. + +- *MaxDist*: int (input) + Maximum number of hops that BFS expands to. This is helpful for speeding-up the code if one in interested only in nodes less than *MaxDist* away from *SrcNId*. + +Return value: + +- int + The length of the shortest path from *SrcNId* to all other nodes. + + +The following example shows how to calculate the length of the shortest path in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NIdToDistH = snap.TIntH() + shortestPath = snap.GetShortPath(Graph, 10, NIdToDistH) + for item in NIdToDistH: + print(item, NIdToDistH[item]) + print(shortestPath) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NIdToDistH = snap.TIntH() + shortestPath = snap.GetShortPath(UGraph, 10, NIdToDistH) + for item in NIdToDistH: + print(item, NIdToDistH[item]) + print(shortestPath) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NIdToDistH = snap.TIntH() + shortestPath = snap.GetShortPath(Network, 10, NIdToDistH) + for item in NIdToDistH: + print(item, NIdToDistH[item]) + print(shortestPath) + diff --git a/snap-python/source/doc/source/reference/GetShortPathAll.rst b/snap-python/source/doc/source/reference/GetShortPathAll.rst new file mode 100644 index 0000000000000000000000000000000000000000..e619f1debe1c6a2722a437d6af2a04056ededb0c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetShortPathAll.rst @@ -0,0 +1,50 @@ +GetShortPathAll +''''''''''''''' + +.. function:: GetShortPathAll(SrcNId, IsDir=false, MaxDist=TInt::Mx) + +A graph method that returns the length of the shortest path from node SrcNId to all other nodes. + +Parameters: + +- *SrcNId*: int + Node id for source node. + +- (optional) *IsDir*: bool + Indicates whether the edges should be considered directed or undirected. + +- (optional) *MaxDist*: int + Maximum number of hops that BFS expands to. This is helpful for speeding-up the code if one in interested only in nodes less than *MaxDist* away from *SrcNId*. + +Return value: + +- int + The length of the shortest path from *SrcNId* to all other nodes. + +- *NIdToDistH*: :class:`TIntH`, a hash table with integer keys and values + Maps node id to shortest path distance. Only contains nodes that are reachable from *SrcNId*. + + +The following example shows how to calculate the length of the shortest path in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + shortestPath, NIdToDistH = Graph.GetShortPathAll(10) + for item in NIdToDistH: + print(item, NIdToDistH[item]) + print(shortestPath) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + shortestPath, NIdToDistH = UGraph.GetShortPathAll(10) + for item in NIdToDistH: + print(item, NIdToDistH[item]) + print(shortestPath) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + shortestPath, NIdToDistH = Network.GetShortPathAll(10) + for item in NIdToDistH: + print(item, NIdToDistH[item]) + print(shortestPath) + diff --git a/snap-python/source/doc/source/reference/GetSngVals-swig.rst b/snap-python/source/doc/source/reference/GetSngVals-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c4df7c0a67e7205e372744e13382dd38b6397efe --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSngVals-swig.rst @@ -0,0 +1,35 @@ +GetSngVals (SWIG) +''''''''''''''''' + +.. function:: GetSngVals(Graph, SngVals, SngValV) + :noindex: + +Computes *SngVals* largest singular values of the adjacency matrix representing the directed graph *Graph*. + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py directed graph. + +- *SngVals*: int (input) + The number of singular values to compute. + +- *SngValV*: :class:`TFltV`, a vector of floats (output) + The vector of singular values. + +Return value: + +- None + + +The following example shows how to calculate singular values for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + SngVals = 4 + SngValV = snap.TFltV() + snap.GetSngVals(Graph, SngVals, SngValV) + for item in SngValV: + print(item) + diff --git a/snap-python/source/doc/source/reference/GetSngVals.rst b/snap-python/source/doc/source/reference/GetSngVals.rst new file mode 100644 index 0000000000000000000000000000000000000000..ef39f69e0b87c4c7e3a29b6617034321fb045c55 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSngVals.rst @@ -0,0 +1,27 @@ +GetSngVals +'''''''''' + +.. function:: GetSngVals(SngVals) + +A graph method that computes *SngVals* largest singular values of the adjacency matrix representing the directed graph graph. + +Parameters: + +- *SngVals*: int + The number of singular values to compute. + +Return value: + +- :class:`TFltV`, a vector of floats + The vector of singular values. + +The following example shows how to calculate singular values for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + SngVals = 4 + SngValV = Graph.GetSngVals(SngVals) + for item in SngValV: + print(item) + diff --git a/snap-python/source/doc/source/reference/GetSngVec-swig.rst b/snap-python/source/doc/source/reference/GetSngVec-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..7b085f769a5cf782399f7138706345446d655f63 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSngVec-swig.rst @@ -0,0 +1,43 @@ +GetSngVec (SWIG) +'''''''''''''''' + +.. function:: GetSngVec(Graph, LeftSV, RightSV) + :noindex: + +Computes the leading left and right singular vectors of the adjacency matrix +representing a directed Graph. + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py directed graph. + +- *LeftSV*: :class:`TFltV`, a vector of floats (output) + The left singular vector. + +- *RightSV*: :class:`TFltV`, a vector of floats (output) + The right singular vector. + +Return value: + +- None + +For more info see: http://en.wikipedia.org/wiki/Singular_value_decomposition + +The following example shows how to calculate the left and right singular +vectors:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + LeftSV = snap.TFltV() + RightSV = snap.TFltV() + snap.GetSngVec(Graph, LeftSV, RightSV) + + print("Left singular vector:") + for item in LeftSV: + print(item) + + print("Right singular vector:") + for item in RightSV: + print(item) diff --git a/snap-python/source/doc/source/reference/GetSngVec1-swig.rst b/snap-python/source/doc/source/reference/GetSngVec1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..ffbb4585ca3409153dbf6d532120fa3db545730e --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSngVec1-swig.rst @@ -0,0 +1,78 @@ +GetSngVec (SWIG) +'''''''''''''''' + +.. function:: GetSngVec(Graph, SngVecs, SngValV, LeftSV, RightSV) + :noindex: + +Computes the singular values and left and right singular vectors of the adjacency matrix representing a directed Graph. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- SngVecs: int (input) + The number of singular values/vectors to compute + +- SngValV: TFltV (output) + Computed singular values stored as a vector of floats + +- LeftSV: TFltVFltV (output) + Computed left singular vectors stored as a vector of vectors of floats + +- RightSV: TFltVTFltV (output) + Computed right singular vectors stored as a vector of vectors of floats + +Return value: + +- None + +The following example shows how to fetch the in-degrees for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + SngVecs = 5 + SngValV = snap.TFltV() + LeftSV = snap.TFltVFltV() + RightSV = snap.TFltVFltV() + snap.GetSngVec(Graph, SngVecs, SngValV, LeftSV, RightSV) + for value in SngValV: + print("Singular value: %f" % value) + for vector in LeftSV: + for value in vector: + print("Left Singular Vector Value %f" % value) + for vector in RightSV: + for value in vector: + print("Right Singular Vector Value %f" % value) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + SngVecs = 5 + SngValV = snap.TFltV() + LeftSV = snap.TFltVFltV() + RightSV = snap.TFltVFltV() + snap.GetSngVec(Graph, SngVecs, SngValV, LeftSV, RightSV) + for value in SngValV: + print("Singular value: %f" % value) + for vector in LeftSV: + for value in vector: + print("Left Singular Vector Value %f" % value) + for vector in RightSV: + for value in vector: + print("Right Singular Vector Value %f" % value) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + SngVecs = 5 + SngValV = snap.TFltV() + LeftSV = snap.TFltVFltV() + RightSV = snap.TFltVFltV() + snap.GetSngVec(Graph, SngVecs, SngValV, LeftSV, RightSV) + for value in SngValV: + print("Singular value: %f" % value) + for vector in LeftSV: + for value in vector: + print("Left Singular Vector Value %f" % value) + for vector in RightSV: + for value in vector: + print("Right Singular Vector Value %f" % value) diff --git a/snap-python/source/doc/source/reference/GetSngVecs.rst b/snap-python/source/doc/source/reference/GetSngVecs.rst new file mode 100644 index 0000000000000000000000000000000000000000..626e974778a17a307a11e86a2241b3dcea4e9cfd --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSngVecs.rst @@ -0,0 +1,39 @@ +GetSngVecs +'''''''''' + +.. function:: GetSngVecs(SngVecs) + +A graph method that computes the singular values and left and right singular vectors of the adjacency matrix representing a directed graph. + +Parameters: + +- SngVecs: int + The number of singular values/vectors to compute + +Return value: + +- SngValV: :class:`TFltV` + Computed singular values stored as a vector of floats + +- LeftSV: :class:`TFltVFltV` + Computed left singular vectors stored as a vector of vectors of floats + +- RightSV: :class:`TFltVTFltV` + Computed right singular vectors stored as a vector of vectors of floats + +The following example shows how to fetch the in-degrees for nodes in +:class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + SngVecs = 5 + SngValV, LeftSV, RightSV = Graph.GetSngVecs(SngVecs) + for value in SngValV: + print("Singular value: %f" % value) + for vector in LeftSV: + for value in vector: + print("Left Singular Vector Value %f" % value) + for vector in RightSV: + for value in vector: + print("Right Singular Vector Value %f" % value) diff --git a/snap-python/source/doc/source/reference/GetSubGraph-swig.rst b/snap-python/source/doc/source/reference/GetSubGraph-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..708d073459d40f493317b0d6b832f3ef0a3fa918 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSubGraph-swig.rst @@ -0,0 +1,46 @@ +GetSubGraph (SWIG) +'''''''''''''''''' + +.. function:: GetSubGraph(Graph, NIdV) + :noindex: + +Returns an induced subgraph of an undirected graph *Graph* with *NIdV* nodes. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdV*: :class:`TIntV`, a vector of ints (input) + Vector of node ids to be included in the graph. + +Return value: + +- graph + A Snap.py graph that is a subgraph of *Graph* with the nodes given by *NIdV*. + + +The following example shows how to return get a subgraph of +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NIdV = snap.TIntV() + for i in range(1, 10): + NIdV.Add(i) + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + SubGraph = snap.GetSubGraph(Graph, NIdV) + for EI in SubGraph.Edges(): + print("edge (%d %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + SubGraph = snap.GetSubGraph(UGraph, NIdV) + for EI in SubGraph.Edges(): + print("edge (%d %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + SubGraph = snap.GetSubGraph(Network, NIdV) + for EI in SubGraph.Edges(): + print("edge (%d %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GetSubGraph.rst b/snap-python/source/doc/source/reference/GetSubGraph.rst new file mode 100644 index 0000000000000000000000000000000000000000..995127ec57edef915b03809c3b5e2017aa246161 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSubGraph.rst @@ -0,0 +1,42 @@ +GetSubGraph +''''''''''' + +.. function:: GetSubGraph(NIdV) + +A graph method that returns an induced subgraph on *NIdV* nodes. + +Parameters: + +- *NIdV*: Python list or :class:`TIntV`, a vector of ints + Vector of node ids to be included in the graph. + +Return value: + +- graph + A graph that is a subgraph of the original graph with the nodes given by *NIdV*. + + +The following example shows how to return get a subgraph of +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NIdV = [] + for i in range(1, 10): + NIdV.append(i) + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + SubGraph = Graph.GetSubGraph(NIdV) + for EI in SubGraph.Edges(): + print("edge (%d %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + SubGraph = UGraph.GetSubGraph(NIdV) + for EI in SubGraph.Edges(): + print("edge (%d %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + SubGraph = Network.GetSubGraph(NIdV) + for EI in SubGraph.Edges(): + print("edge (%d %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/GetSubGraphRenumber-swig.rst b/snap-python/source/doc/source/reference/GetSubGraphRenumber-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c2e4079066b06414fee7ae1516ea2766cab17729 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSubGraphRenumber-swig.rst @@ -0,0 +1,40 @@ +GetSubGraphRenumber (SWIG) +'''''''''''''''''''''''''' + +.. function:: GetSubGraphRenumber(Graph, NIdV) + :noindex: + +Returns the subgraph of *Graph* induced by the nodes in *NIdV* with renumbered node ids from 0 to N-1. This function is implemented for :class:`TNGraph` and :class:`TUNGraph`. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *NIdV*: TIntV (input) + Node ID vector. The subgraph consists of all nodes in *NIdV* and the edges between nodes in *NIdV*. + +Return value: + +- a subgraph that is the same type as *Graph* and contains the nodes from *Graph*, which have node IDs in the *NIdV* vector and all the edges with both nodes in *NIdV*. The nodes in the resulting subgraph are renumbered sequentially from 0 to N-1. + +For more information, see: http://en.wikipedia.org/wiki/Glossary_of_graph_theory#Subgraphs + +The following example shows how to get subgraphs for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 50, 500) + Nodes = snap.TIntV() + for N in Graph.GetNI(0).GetOutEdges(): + Nodes.Add(N) + # Get subgraph induced by the neighbors of Node 0. + SubGraph = snap.GetSubGraphRenumber(Graph, Nodes) + + Graph = snap.GenCircle(snap.PUNGraph, 100, 2, False) + Nodes = snap.TIntV() + for N in Graph.GetNI(50).GetOutEdges(): + Nodes.Add(N) + SubGraph = snap.GetSubGraphRenumber(Graph, Nodes) + diff --git a/snap-python/source/doc/source/reference/GetSubGraphRenumber.rst b/snap-python/source/doc/source/reference/GetSubGraphRenumber.rst new file mode 100644 index 0000000000000000000000000000000000000000..ed62d432219524c3c5ad27a7ff93f3c2a5786f75 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSubGraphRenumber.rst @@ -0,0 +1,38 @@ +GetSubGraphRenumber +''''''''''''''''''' + +.. function:: GetSubGraphRenumber(NIdV) + +A graph method that returns the subgraph induced by the nodes in *NIdV* with renumbered node ids from 0 to N-1. This function is implemented for :class:`TNGraph` and :class:`TUNGraph`. + +Parameters: + +- *NIdV*: Python list or :class:`TIntV`, a vector of ints + Node id vector. The subgraph consists of all nodes in *NIdV* and the edges between nodes in *NIdV*. + +Return value: + +- graph + A subgraph that has the same type as the original graph and contains the nodes with ids in the *NIdV* vector and all the edges with both nodes in *NIdV*. The nodes in the resulting subgraph are renumbered sequentially from 0 to N-1. + +For more information, see: http://en.wikipedia.org/wiki/Glossary_of_graph_theory#Subgraphs + +The following example shows how to get subgraphs for +:class:`TNGraph` and :class:`TUNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 50, 500) + Nodes = [] + for N in Graph.GetNI(0).GetOutEdges(): + Nodes.append(N) + # Get subgraph induced by the neighbors of Node 0 + SubGraph = Graph.GetSubGraphRenumber(Nodes) + + UGraph = snap.GenCircle(snap.TUNGraph, 100, 2, False) + Nodes = [] + for N in UGraph.GetNI(50).GetOutEdges(): + Nodes.append(N) + # Get subgraph induced by the neighbors of Node 50 + SubGraph = UGraph.GetSubGraphRenumber(Nodes) + diff --git a/snap-python/source/doc/source/reference/GetSubTreeSz-swig.rst b/snap-python/source/doc/source/reference/GetSubTreeSz-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2744351700abe403849f3e0b5b8ed61d43169469 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSubTreeSz-swig.rst @@ -0,0 +1,44 @@ +GetSubTreeSz (SWIG) +''''''''''''''''''' + +.. function:: GetSubTreeSz(Graph, StartNId, FollowOut, FollowIn) + :noindex: + +Returns the BFS tree size (number of nodes) and depth (number of +levels) by following in-links and/or out-links of node *StartNId*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *StartNId*: int (input) + Starting node id. + +- *FollowOut*: bool (input) + Whether to follow out-links. + +- *FollowIn*: bool (input) + Whether to follow in-links. + +Return value: + +- list: [int, int, int] + The list is of size 3 and consists of the number of nodes in the tree (twice) and the number of levels in the tree. + +The following example shows how to get the size of the tree starting at node 0 with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.PNGraph, 3, 3) + results = snap.GetSubTreeSz(Graph, 0, True, True) + print("Size %d, Depth %d" % (results[0], results[2])) + + UGraph = snap.GenTree(snap.PUNGraph, 3, 3) + results = snap.GetSubTreeSz(UGraph, 0, True, True) + print("Size %d, Depth %d" % (results[0], results[2])) + + Network = snap.GenTree(snap.PNEANet, 3, 3) + results = snap.GetSubTreeSz(Network, 0, True, True) + print("Size %d, Depth %d" % (results[0], results[2])) diff --git a/snap-python/source/doc/source/reference/GetSubTreeSz.rst b/snap-python/source/doc/source/reference/GetSubTreeSz.rst new file mode 100644 index 0000000000000000000000000000000000000000..e4081329ba7722d171fb600126bbae7414a6f8b3 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetSubTreeSz.rst @@ -0,0 +1,39 @@ +GetSubTreeSz +'''''''''''' + +.. function:: GetSubTreeSz(StartNId, FollowOut, FollowIn) + +A graph method that returns the BFS tree size (number of nodes) and depth (number of levels) by following in-links and/or out-links of node *StartNId*. + +Parameters: + +- *StartNId*: int + Starting node id. + +- *FollowOut*: bool + Whether to follow out-links. + +- *FollowIn*: bool + Whether to follow in-links. + +Return value: + +- list: [int, int, int] + The list is of size 3 and consists of the number of nodes in the tree (twice) and the number of levels in the tree. + +The following example shows how to get the size of the tree starting at node 0 with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.TNGraph, 3, 3) + results = Graph.GetSubTreeSz(0, True, True) + print("Size %d, Depth %d" % (results[0], results[2])) + + UGraph = snap.GenTree(snap.TUNGraph, 3, 3) + results = UGraph.GetSubTreeSz(0, True, True) + print("Size %d, Depth %d" % (results[0], results[2])) + + Network = snap.GenTree(snap.TNEANet, 3, 3) + results = Network.GetSubTreeSz(0, True, True) + print("Size %d, Depth %d" % (results[0], results[2])) diff --git a/snap-python/source/doc/source/reference/GetTreeRootNId-swig.rst b/snap-python/source/doc/source/reference/GetTreeRootNId-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..4fb945322ae54a68f904d2f67b1bb202845095dc --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTreeRootNId-swig.rst @@ -0,0 +1,31 @@ +GetTreeRootNId (SWIG) +''''''''''''''''''''' + +.. function:: GetTreeRootNId(Graph) + :noindex: + +If *Graph* is a tree, the function returns the root id of the tree. Otherwise, it returns -1. + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py directed graph or a network + +Return value: + +- int + If *Graph* is a tree, the node id of the root. Otherwise, -1 is returned. + + +The following example shows how to get the root node id in +:class:`TNGraph` and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.PNGraph, 3, 3) + root_id = snap.GetTreeRootNId(Graph) + print("The graph has a root id: %d" % root_id) + + Network = snap.GenTree(snap.PNEANet, 3, 3) + root_id = snap.GetTreeRootNId(Network) + print("The graph has a root id: %d" % root_id) diff --git a/snap-python/source/doc/source/reference/GetTreeRootNId.rst b/snap-python/source/doc/source/reference/GetTreeRootNId.rst new file mode 100644 index 0000000000000000000000000000000000000000..83e9f5589a9c6545b70e857e5cf2124b532e290c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTreeRootNId.rst @@ -0,0 +1,29 @@ +GetTreeRootNId +'''''''''''''' + +.. function:: GetTreeRootNId() + +A graph method for directed graphs that returns the root id of the tree, if a graph is a tree. Otherwise, it returns -1. + +Parameters: + +- None + +Return value: + +- int + If the graph is a tree, the node id of the root. Otherwise, -1 is returned. + + +The following example shows how to get the root node id in +:class:`TNGraph` and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.TNGraph, 3, 3) + root_id = Graph.GetTreeRootNId() + print("The graph has a root id: %d" % root_id) + + Network = snap.GenTree(snap.TNEANet, 3, 3) + root_id = Network.GetTreeRootNId() + print("The graph has a root id: %d" % root_id) diff --git a/snap-python/source/doc/source/reference/GetTreeSig-swig.rst b/snap-python/source/doc/source/reference/GetTreeSig-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..cf4a9f5a0d5285a35908cdb4a537e2009072824b --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTreeSig-swig.rst @@ -0,0 +1,41 @@ +GetTreeSig (SWIG) +''''''''''''''''' + +.. note:: + + This page is a draft and under revision. + +.. function:: GetTreeSig(Graph, RootNId, Sig) + :noindex: + +.. note:: + + This function is not yet supported. + +Fills Sig, a TIntV object, with the tree signature of the input graph starting at node RootNId. The tree signature is the id of the nodes in descending level sorted within each level. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *RootNId*: int (input) + Id of the starting node + +- *Sig*: TIntV (input) + A vector of integers that holds the signature. + +GetTreeSig currently has a bug. The following code shows an example of the bug. When executed, the program runs out of memory and causes an error.:: + + import snap + + G1 = snap.TNGraph.New() + G1.AddNode(1) + G1.AddNode(2) + G1.AddEdge(1,2) + v1 = snap.TIntV() + snap.GetTreeSig(G1, 1, v1) + + for item in v1: + print(item) + diff --git a/snap-python/source/doc/source/reference/GetTreeSig.rst b/snap-python/source/doc/source/reference/GetTreeSig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5d08758f0da71fa531eb1772543f517f0120d6f6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTreeSig.rst @@ -0,0 +1,40 @@ +GetTreeSig +'''''''''' + +.. note:: + + This page is a draft and under revision. + +.. function:: GetTreeSig(Graph, RootNId, Sig) + +.. note:: + + This function is not yet supported. + +Fills Sig, a TIntV object, with the tree signature of the input graph starting at node RootNId. The tree signature is the id of the nodes in descending level sorted within each level. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *RootNId*: int (input) + Id of the starting node + +- *Sig*: TIntV (input) + A vector of integers that holds the signature. + +GetTreeSig currently has a bug. The following code shows an example of the bug. When executed, the program runs out of memory and causes an error.:: + + import snap + + G1 = snap.TNGraph.New() + G1.AddNode(1) + G1.AddNode(2) + G1.AddEdge(1,2) + v1 = snap.TIntV() + snap.GetTreeSig(G1, 1, v1) + + for item in v1: + print(item) + diff --git a/snap-python/source/doc/source/reference/GetTreeSig1-swig.rst b/snap-python/source/doc/source/reference/GetTreeSig1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..321b92bacfa98e91184e81d181ca9ada6f1ef49f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTreeSig1-swig.rst @@ -0,0 +1,80 @@ +GetTreeSig (SWIG) +''''''''''''''''' +.. note:: + + This page is a draft and under revision. + + +.. function:: GetTreeSig (Graph, RootNId, Sig, NodeMap) + :noindex: + +.. note:: + + This function is not yet supported. + +Returns the tree signature of the graph, for each level we sort the node in-degrees and concatenate them into a vector. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *RootNId*: int (input) + Root of the tree + +- *Sig*: a vector of ints (output) + The tree signature + +- *NodeMap*: a vector of pairs of ints (output) + The mapping of nodes in-degrees as a vector + +Return value: + +- None + +For more info see: http://en.wikipedia.org/wiki/Tree_%28graph_theory%29 + +The following example shows how to compute the tree signature for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Sig = snap.TIntV() + NodeMap = snap.TIntPrV() + for NI in Graph.Nodes(): + # Without if statement, we receive "error *** Error: Execution stopped: Node.GetInDeg()==0 || Node.GetOutDeg()==0, file /home/rok/include/snap/alg.h, line 513" (see source here: https://github.com/snap-stanford/snap/blob/master/snap-core/alg.h) + # With if statement, no tree signatures are computed + #if (NI.GetInDeg() == 0 or NI.GetOutDeg() == 0): + snap.GetTreeSig(Graph, NI.GetId(), Sig, NodeMap) + for item in Sig: + print(item) + for item in NodeMap: + print(item.GetVal1(), item.GetVal2()) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Sig = snap.TIntV() + NodeMap = snap.TIntPrV() + for NI in Graph.Nodes(): + # Without if statement, we receive "error *** Error: Execution stopped: Node.GetInDeg()==0 || Node.GetOutDeg()==0, file /home/rok/include/snap/alg.h, line 513" (see source here: https://github.com/snap-stanford/snap/blob/master/snap-core/alg.h) + # With if statement, no tree signatures are computed + #if (NI.GetInDeg() == 0 or NI.GetOutDeg() == 0): + snap.GetTreeSig(Graph, NI.GetId(), Sig, NodeMap) + for item in Sig: + print(item) + for item in NodeMap: + print(item.GetVal1(), item.GetVal2()) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Sig = snap.TIntV() + NodeMap = snap.TIntPrV() + for NI in Graph.Nodes(): + # Without if statement, we receive "error *** Error: Execution stopped: Node.GetInDeg()==0 || Node.GetOutDeg()==0, file /home/rok/include/snap/alg.h, line 513" (see source here: https://github.com/snap-stanford/snap/blob/master/snap-core/alg.h) + # With if statement, no tree signatures are computed + #if (NI.GetInDeg() == 0 or NI.GetOutDeg() == 0): + snap.GetTreeSig(Graph, NI.GetId(), Sig, NodeMap) + for item in Sig: + print(item) + for item in NodeMap: + print(item.GetVal1(), item.GetVal2()) + diff --git a/snap-python/source/doc/source/reference/GetTreeSig1.rst b/snap-python/source/doc/source/reference/GetTreeSig1.rst new file mode 100644 index 0000000000000000000000000000000000000000..521ff3a738b7d951cf03fe5958d6078b72637049 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTreeSig1.rst @@ -0,0 +1,80 @@ +GetTreeSig +'''''''''' +.. note:: + + This page is a draft and under revision. + + +.. function:: GetTreeSig (Graph, RootNId, Sig, NodeMap) + :noindex: + +.. note:: + + This function is not yet supported. + +Returns the tree signature of the graph, for each level we sort the node in-degrees and concatenate them into a vector. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *RootNId*: int (input) + Root of the tree + +- *Sig*: a vector of ints (output) + The tree signature + +- *NodeMap*: a vector of pairs of ints (output) + The mapping of nodes in-degrees as a vector + +Return value: + +- None + +For more info see: http://en.wikipedia.org/wiki/Tree_%28graph_theory%29 + +The following example shows how to compute the tree signature for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Sig = snap.TIntV() + NodeMap = snap.TIntPrV() + for NI in Graph.Nodes(): + # Without if statement, we receive "error *** Error: Execution stopped: Node.GetInDeg()==0 || Node.GetOutDeg()==0, file /home/rok/include/snap/alg.h, line 513" (see source here: https://github.com/snap-stanford/snap/blob/master/snap-core/alg.h) + # With if statement, no tree signatures are computed + #if (NI.GetInDeg() == 0 or NI.GetOutDeg() == 0): + snap.GetTreeSig(Graph, NI.GetId(), Sig, NodeMap) + for item in Sig: + print(item) + for item in NodeMap: + print(item.GetVal1(), item.GetVal2()) + + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + Sig = snap.TIntV() + NodeMap = snap.TIntPrV() + for NI in Graph.Nodes(): + # Without if statement, we receive "error *** Error: Execution stopped: Node.GetInDeg()==0 || Node.GetOutDeg()==0, file /home/rok/include/snap/alg.h, line 513" (see source here: https://github.com/snap-stanford/snap/blob/master/snap-core/alg.h) + # With if statement, no tree signatures are computed + #if (NI.GetInDeg() == 0 or NI.GetOutDeg() == 0): + snap.GetTreeSig(Graph, NI.GetId(), Sig, NodeMap) + for item in Sig: + print(item) + for item in NodeMap: + print(item.GetVal1(), item.GetVal2()) + + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Sig = snap.TIntV() + NodeMap = snap.TIntPrV() + for NI in Graph.Nodes(): + # Without if statement, we receive "error *** Error: Execution stopped: Node.GetInDeg()==0 || Node.GetOutDeg()==0, file /home/rok/include/snap/alg.h, line 513" (see source here: https://github.com/snap-stanford/snap/blob/master/snap-core/alg.h) + # With if statement, no tree signatures are computed + #if (NI.GetInDeg() == 0 or NI.GetOutDeg() == 0): + snap.GetTreeSig(Graph, NI.GetId(), Sig, NodeMap) + for item in Sig: + print(item) + for item in NodeMap: + print(item.GetVal1(), item.GetVal2()) + diff --git a/snap-python/source/doc/source/reference/GetTriadEdges-swig.rst b/snap-python/source/doc/source/reference/GetTriadEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2a2c8a891c8c3e19e2682854e5c91c6d1c2f5dcd --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriadEdges-swig.rst @@ -0,0 +1,37 @@ +GetTriadEdges (SWIG) +'''''''''''''''''''' + +.. function:: GetTriadEdges(Graph, SampleEdges=-1) + :noindex: + +Counts the number of edges that participate in at least one triad. Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *SampleEdges*: int (input) + If *SampleEdges* is not equal to -1, then compute triads only for a random sample of *SampleEdges* edges. Useful for approximate but quick computations. + +Return value: + +- int + The number of edges that participate in at least one triad. + +The following example shows how to calculate the number of edges in triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` (only shows first type):: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + NumTriadEdges = snap.GetTriadEdges(Graph) + print(NumTriadEdges) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + NumTriadEdges = snap.GetTriadEdges(UGraph) + print(NumTriadEdges) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + NumTriadEdges = snap.GetTriadEdges(Network) + print(NumTriadEdges) diff --git a/snap-python/source/doc/source/reference/GetTriadEdges.rst b/snap-python/source/doc/source/reference/GetTriadEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..5ff8e819db6dafce3fd5bb94e8b05a544fa2922f --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriadEdges.rst @@ -0,0 +1,33 @@ +GetTriadEdges +''''''''''''' + +.. function:: GetTriadEdges(SampleEdges=-1) + +A graph method that counts the number of edges that participate in at least one triad. Considers the graph as undirected. + +Parameters: + +- (Optional) *SampleEdges*: int + If *SampleEdges* is -1 (default value), then compute triads for all the edges. Otherwise, compute triads only for a random sample of *SampleEdges* edges, which is useful for approximate but quick computations. + +Return value: + +- int + The number of edges that participate in at least one triad. + +The following example shows how to calculate the number of edges in triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` (only shows first type):: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + NumTriadEdges = Graph.GetTriadEdges() + print(NumTriadEdges) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + NumTriadEdges = UGraph.GetTriadEdges() + print(NumTriadEdges) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + NumTriadEdges = Network.GetTriadEdges() + print(NumTriadEdges) diff --git a/snap-python/source/doc/source/reference/GetTriadParticip-swig.rst b/snap-python/source/doc/source/reference/GetTriadParticip-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..77dfd65141486d08b7f518272caeb920934722c9 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriadParticip-swig.rst @@ -0,0 +1,43 @@ +GetTriadParticip (SWIG) +''''''''''''''''''''''' + +.. function:: GetTriadParticip(Graph, TriadCntV) + :noindex: + +Calculates triangle participation ratio. For each node counts how many triangles it participates in and then returns a vector of pairs (number of triangles, number of such nodes). Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *TriadCntV*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + Pairs of (number of triangles, number of nodes). + +Return value: + +- None + + +The following example shows how to compute the triangles participation ratio for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + TriadCntV = snap.TIntPrV() + snap.GetTriadParticip(Graph, TriadCntV) + for pair in TriadCntV: + print(pair.Val1(), pair.Val2()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + TriadCntV = snap.TIntPrV() + snap.GetTriadParticip(UGraph, TriadCntV) + for pair in TriadCntV: + print(pair.Val1(), pair.Val2()) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + TriadCntV = snap.TIntPrV() + snap.GetTriadParticip(Network, TriadCntV) + for pair in TriadCntV: + print(pair.Val1(), pair.Val2()) diff --git a/snap-python/source/doc/source/reference/GetTriadParticip.rst b/snap-python/source/doc/source/reference/GetTriadParticip.rst new file mode 100644 index 0000000000000000000000000000000000000000..bd8c8dff8dae718d62539f44bfd2ddd97bb6e742 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriadParticip.rst @@ -0,0 +1,36 @@ +GetTriadParticip +'''''''''''''''' + +.. function:: GetTriadParticip() + +A graph method that calculates triangle participation ratio. It counts for each node how many triangles it participates in and then returns a vector of pairs (number of triangles, number of such nodes). Considers the graph as undirected. + +Parameters: + +- None + +Return value: + +- :class:`TIntPrV`, a vector of (int, int) pairs (output) + Pairs of (number of triangles, number of nodes). + + +The following example shows how to compute the triangles participation ratio for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + TriadCntV = Graph.GetTriadParticip() + for pair in TriadCntV: + print(pair.Val1(), pair.Val2()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + TriadCntV = UGraph.GetTriadParticip() + for pair in TriadCntV: + print(pair.Val1(), pair.Val2()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + TriadCntV = Network.GetTriadParticip() + for pair in TriadCntV: + print(pair.Val1(), pair.Val2()) diff --git a/snap-python/source/doc/source/reference/GetTriads-swig.rst b/snap-python/source/doc/source/reference/GetTriads-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..4f0cd0b6cfd282a3aa9462236f2d21e7ae6b564c --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriads-swig.rst @@ -0,0 +1,40 @@ +GetTriads (SWIG) +'''''''''''''''' + +.. function:: GetTriads(Graph, SampleNodes=-1) + :noindex: + +Computes the number of triads in the graph. + +Parameters: + + - *Graph*: graph (input) + A Snap.py graph or a network. + + - *SampleNodes*: int (input) + If !=-1 then compute triads only for a random sample of *SampleNodes* nodes. Useful for approximate but quick computations. + +Return value: + + - int + Number of triads. + + +The following code shows an example of GetTriads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 250) + NumTriads = snap.GetTriads(Graph, 50) + print('Number of triads with 50 sample nodes: %d' % NumTriads) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 250) + NumTriads = snap.GetTriads(UGraph, 75) + print('Number of triads with 75 sample nodes: %d' % NumTriads) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 250) + NumTriads = snap.GetTriads(Network, 100) + print('Number of triads with 100 sample nodes: %d' % NumTriads) + + diff --git a/snap-python/source/doc/source/reference/GetTriads.rst b/snap-python/source/doc/source/reference/GetTriads.rst new file mode 100644 index 0000000000000000000000000000000000000000..bf97d115e1d52e428017c5326f0ea1940ba3da59 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriads.rst @@ -0,0 +1,36 @@ +GetTriads +''''''''' + +.. function:: GetTriads(SampleNodes=-1) + +A graph method that computes the number of triads in the graph. + +Parameters: + + - (optional) *SampleNodes*: int + If *SampleNodes* is -1 (default value), then compute triads over all the nodes. Otherwise, compute triads using only a random sample of *SampleNodes* nodes. This is useful for quick, but approximate computations. + +Return value: + + - int + Number of triads. + + +The following code shows an example of GetTriads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 250) + NumTriads = Graph.GetTriads(50) + print('Number of triads with 50 sample nodes: %d' % NumTriads) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 250) + NumTriads = UGraph.GetTriads(75) + print('Number of triads with 75 sample nodes: %d' % NumTriads) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 250) + NumTriads = Network.GetTriads(100) + print('Number of triads with 100 sample nodes: %d' % NumTriads) + + diff --git a/snap-python/source/doc/source/reference/GetTriads1-swig.rst b/snap-python/source/doc/source/reference/GetTriads1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..091aea8c1e5ad1576c0a5891d0d09b1f18fe65a1 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriads1-swig.rst @@ -0,0 +1,46 @@ +GetTriads (SWIG) +'''''''''''''''' + +.. function:: GetTriads(Graph, NIdCOTriadV, SampleNodes=-1) + :noindex: + +Computes the number of closed and open triads for every node in *Graph*. Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network + +- *NIdCOTriadV*: :class:`TIntTrV`, a vector of triplets (integer, integer, integer) (output) + A triple contains (node id, number of closed triads, number of open triads). Closed triads are pairs of node's neighbors that are connected between themselves. Open triads are pairs of node's neighbors that are not connected. + +- *SampleNodes*: integer (input) + If !=-1 then compute triads only for a random sample of SampleNodes nodes. Useful for approximate but quick computations. + +Return value: + +- None + +The following example shows how to compute the number of closed and open triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + TriadV = snap.TIntTrV() + snap.GetTriads(Graph, TriadV) + for triple in TriadV: + print(triple.Val1(), triple.Val2(), triple.Val3()) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + TriadV = snap.TIntTrV() + snap.GetTriads(Graph, TriadV) + for triple in TriadV: + print(triple.Val1(), triple.Val2(), triple.Val3()) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + TriadV = snap.TIntTrV() + snap.GetTriads(Graph, TriadV) + for triple in TriadV: + print(triple.Val1(), triple.Val2(), triple.Val3()) + diff --git a/snap-python/source/doc/source/reference/GetTriadsAll-swig.rst b/snap-python/source/doc/source/reference/GetTriadsAll-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..791061ccafc9d786c20bfa3350b7827c997613f6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriadsAll-swig.rst @@ -0,0 +1,43 @@ +GetTriadsAll (SWIG) +''''''''''''''''''' + +.. function:: GetTriadsAll (Graph, SampleNodes=-1) + :noindex: + +Computes the number of closed and open triads for every node in *Graph*. Considers the graph as undirected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *SampleNodes*: integer (input) + If equal to -1, then compute triads over all the nodes. Otherwise, + compute triads only for a random sample of *SampleNodes* nodes, which is + useful for approximate but quick computations. + +Return value: + +- list: [int, int, int] + The list contains three elements: the first two elements are the number of closed triads and the third element is the number of open triads in the graph. + +The following example shows how to compute the number of open and closed triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + result = snap.GetTriadsAll(Graph) + print("closed triads", result[0]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + result = snap.GetTriadsAll(Graph) + print("closed triads", result[0]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + result = snap.GetTriadsAll(Graph) + print("closed triads", result[0]) + print("open triads", result[2]) + diff --git a/snap-python/source/doc/source/reference/GetTriadsAll.rst b/snap-python/source/doc/source/reference/GetTriadsAll.rst new file mode 100644 index 0000000000000000000000000000000000000000..3a1e44bd3b0409afa9b12c90509538696daeca7b --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriadsAll.rst @@ -0,0 +1,39 @@ +GetTriadsAll +'''''''''''' + +.. function:: GetTriadsAll (SampleNodes=-1) + +A graph method that computes the number of closed and open triads for every node. Considers the graph as undirected. + +Parameters: + +- (optional) *SampleNodes*: integer + If equal to -1, then compute triads over all the nodes. Otherwise, + compute triads only for a random sample of *SampleNodes* nodes, which is + useful for approximate but quick computations. + +Return value: + +- list: [int, int, int] + The list contains three elements: the first two elements are the number of closed triads and the third element is the number of open triads in the graph. + +The following example shows how to compute the number of open and closed triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + result = Graph.GetTriadsAll() + print("closed triads", result[0]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + result = Graph.GetTriadsAll() + print("closed triads", result[0]) + print("open triads", result[2]) + + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + result = Graph.GetTriadsAll() + print("closed triads", result[0]) + print("open triads", result[2]) + diff --git a/snap-python/source/doc/source/reference/GetTriadsByNode.rst b/snap-python/source/doc/source/reference/GetTriadsByNode.rst new file mode 100644 index 0000000000000000000000000000000000000000..270bc200838134afc7f230baf4edecd3b1548385 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetTriadsByNode.rst @@ -0,0 +1,36 @@ +GetTriadsByNode +''''''''''''''' + +.. function:: GetTriadsByNode(SampleNodes=-1) + +A graph method that computes the number of closed and open triads for every node. Considers the graph as undirected. + +Parameters: + +- (optional) *SampleNodes*: integer + If *SampleNodes* is -1 (default value), then compute triads for all the nodes. Otherwise, compute triads only for a random sample of *SampleNodes* nodes. + +Return value: + +- :class:`TIntTrV`: a vector of triplets (integer, integer, integer) + A triple contains (node id, number of closed triads, number of open triads). Closed triads are pairs of node's neighbors that are connected between themselves. Open triads are pairs of node's neighbors that are not connected. + +The following example shows how to compute the number of closed and open triads for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + TriadV = Graph.GetTriadsByNode() + for triple in TriadV: + print(triple.Val1(), triple.Val2(), triple.Val3()) + + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + TriadV = Graph.GetTriadsByNode() + for triple in TriadV: + print(triple.Val1(), triple.Val2(), triple.Val3()) + + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + TriadV = Graph.GetTriadsByNode() + for triple in TriadV: + print(triple.Val1(), triple.Val2(), triple.Val3()) diff --git a/snap-python/source/doc/source/reference/GetUnDir-swig.rst b/snap-python/source/doc/source/reference/GetUnDir-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..9106d61e8a70544a761e12be5005bd2506745f51 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetUnDir-swig.rst @@ -0,0 +1,34 @@ +GetUnDir (SWIG) +''''''''''''''' + +.. function:: GetUnDir(Graph) + :noindex: + +Returns an undirected version of the graph. For every edge (u,v) an edge (v,u) is added (if it does not yet exist). + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py graph or a network. + +Return value: + +- graph + The un-directed version of graph *Graph*. If *Graph* is undirected, returns an identical graph. + +The following example shows how to convert directed graph to un-directed graph using +:class:`TNGraph`:: + + import snap + + Graph = snap.TNGraph.New() + Graph.AddNode(1) + Graph.AddNode(3) + Graph.AddNode(5) + Graph.AddEdge(1,3) + Graph.AddEdge(3,5) + Graph.AddEdge(1,5) + + UGraph = snap.GetUnDir(Graph) + for EI in UGraph.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetUnDir.rst b/snap-python/source/doc/source/reference/GetUnDir.rst new file mode 100644 index 0000000000000000000000000000000000000000..88a63e60968eb8d74618ea3fdd92b894e35134eb --- /dev/null +++ b/snap-python/source/doc/source/reference/GetUnDir.rst @@ -0,0 +1,32 @@ +GetUnDir +'''''''' + +.. function:: GetUnDir() + +A graph method that returns a new graph which is an undirected version of the graph. For every edge (u,v) an edge (v,u) is added (if it does not yet exist). + +Parameters: + +- None + +Return value: + +- graph + The undirected version of the graph. If the graph is undirected, returns an identical graph. + +The following example shows how to convert directed graph to undirected graph using +:class:`TNGraph`:: + + import snap + + Graph = snap.TNGraph.New() + Graph.AddNode(1) + Graph.AddNode(3) + Graph.AddNode(5) + Graph.AddEdge(1,3) + Graph.AddEdge(3,5) + Graph.AddEdge(1,5) + + UGraph = Graph.GetUnDir() + for EI in UGraph.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) diff --git a/snap-python/source/doc/source/reference/GetWccSzCnt-swig.rst b/snap-python/source/doc/source/reference/GetWccSzCnt-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..abd9f470e1b1e2440c3380d0f38c8bee59a7dcc5 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetWccSzCnt-swig.rst @@ -0,0 +1,43 @@ +GetWccSzCnt (SWIG) +'''''''''''''''''' + +.. function:: GetWccSzCnt(Graph, WccSzCnt) + :noindex: + +Returns a distribution of weakly connected component sizes. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *WccSzCnt*: :class:`TIntPrV`, a vector of (int, int) pairs (output) + Vector of pairs (number of nodes in the component, number of such components). + +Return Value: + +- None + + +The following example shows how to get the distribution of weakly-connected component sizes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + ComponentDist = snap.TIntPrV() + snap.GetWccSzCnt(Graph, ComponentDist) + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + ComponentDist = snap.TIntPrV() + snap.GetWccSzCnt(UGraph, ComponentDist) + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + ComponentDist = snap.TIntPrV() + snap.GetWccSzCnt(Network, ComponentDist) + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetWccSzCnt.rst b/snap-python/source/doc/source/reference/GetWccSzCnt.rst new file mode 100644 index 0000000000000000000000000000000000000000..a64a365a957ff4e42c27378df75e3d3c523ce3e6 --- /dev/null +++ b/snap-python/source/doc/source/reference/GetWccSzCnt.rst @@ -0,0 +1,36 @@ +GetWccSzCnt +''''''''''' + +.. function:: GetWccSzCnt() + +A graph method that returns a distribution of weakly connected component sizes. + +Parameters: + +- None + +Return Value: + +- *WccSzCnt*: :class:`TIntPrV`, a vector of (int, int) pairs + Vector of pairs (number of nodes in the component, number of such components). + + +The following example shows how to get the distribution of weakly-connected component sizes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + ComponentDist = Graph.GetWccSzCnt() + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + ComponentDist = UGraph.GetWccSzCnt() + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + ComponentDist = Network.GetWccSzCnt() + for comp in ComponentDist: + print("Size: %d - Number of Components: %d" % (comp.GetVal1(), comp.GetVal2())) diff --git a/snap-python/source/doc/source/reference/GetWccs-swig.rst b/snap-python/source/doc/source/reference/GetWccs-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..765a21f4ebafb63506f887d0c7a7d01f101baedd --- /dev/null +++ b/snap-python/source/doc/source/reference/GetWccs-swig.rst @@ -0,0 +1,45 @@ +GetWccs (SWIG) +'''''''''''''' + +.. function:: GetWccs (Graph, CnComV) + :noindex: + +Returns all weakly connected components in *Graph*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *CnComV*: :class:`TCnComV`, a vector of connected components (output) + Vector of all weakly-connected components. Each component consists of a TIntV vector of node ids. + +Return value: + +- None + + +The following example shows how to calculate all weakly-connected components in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Components = snap.TCnComV() + snap.GetWccs(Graph, Components) + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 1000, 50) + Components = snap.TCnComV() + snap.GetWccs(UGraph, Components) + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + Network = snap.GenRndGnm(snap.PNEANet, 1000, 300) + Components = snap.TCnComV() + snap.GetWccs(Network, Components) + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + diff --git a/snap-python/source/doc/source/reference/GetWccs.rst b/snap-python/source/doc/source/reference/GetWccs.rst new file mode 100644 index 0000000000000000000000000000000000000000..a2c5dc03fb2be01eb21ade267823bf1c9352d35a --- /dev/null +++ b/snap-python/source/doc/source/reference/GetWccs.rst @@ -0,0 +1,38 @@ +GetWccs +''''''' + +.. function:: GetWccs () + +A graph method that returns all weakly connected components in a graph. + +Parameters: + +- None + +Return value: + +- *CnComV*: :class:`TCnComV`, a vector of connected components + Vector of all weakly-connected components. Each component consists of a TIntV vector of node ids. + + +The following example shows how to calculate all weakly-connected components in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Components = Graph.GetWccs() + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 1000, 50) + Components = UGraph.GetWccs() + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + Network = snap.GenRndGnm(snap.TNEANet, 1000, 300) + Components = Network.GetWccs() + for CnCom in Components: + print("Size of component: %d" % CnCom.Len()) + + diff --git a/snap-python/source/doc/source/reference/IsConnected-swig.rst b/snap-python/source/doc/source/reference/IsConnected-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..58a78b57863220c7f3c1782ab6082aa009e11ad2 --- /dev/null +++ b/snap-python/source/doc/source/reference/IsConnected-swig.rst @@ -0,0 +1,31 @@ +IsConnected (SWIG) +'''''''''''''''''' + +.. function:: IsConnected(Graph) + :noindex: + +Tests whether *Graph* is (weakly) connected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- bool + Returns True if the *Graph* is (weakly) connected, False otherwise. + +The following example shows how to use :func:`IsConnected` for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + print(snap.IsConnected(Graph)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + print(snap.IsConnected(UGraph)) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + print(snap.IsConnected(Network)) diff --git a/snap-python/source/doc/source/reference/IsConnected.rst b/snap-python/source/doc/source/reference/IsConnected.rst new file mode 100644 index 0000000000000000000000000000000000000000..cbace7ada1676f6fbf88171e90c4445a2dbf9ed9 --- /dev/null +++ b/snap-python/source/doc/source/reference/IsConnected.rst @@ -0,0 +1,29 @@ +IsConnected +''''''''''' + +.. function:: IsConnected() + +A graph method that tests whether a graph is connected. + +Parameters: + +- None + +Return value: + +- bool + Returns True if the graph is connected, False otherwise. + +The following example shows how to use :func:`IsConnected` for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + print(Graph.IsConnected()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + print(UGraph.IsConnected()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + print(Network.IsConnected()) diff --git a/snap-python/source/doc/source/reference/IsTree-swig.rst b/snap-python/source/doc/source/reference/IsTree-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..c1d9d441d5c520e3df1bf48711f3c33ea749effe --- /dev/null +++ b/snap-python/source/doc/source/reference/IsTree-swig.rst @@ -0,0 +1,33 @@ +IsTree (SWIG) +''''''''''''' + +.. function:: IsTree(Graph) + :noindex: + +Determines if *Graph* is a connected tree. The function returns a list of [bool, int], where the bool indicates whether *Graph* is a tree and the int is the node id for the root of the tree. + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py directed graph or a network + +Return value: + +- list: [bool, int] + The list consists of two elements: a bool that indicates whether *Graph* is a tree, and an int giving the node id for the root of the tree. + + +The following example shows how to detect trees in +:class:`TNGraph` and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.PNGraph, 3, 3) + [is_tree, root_id] = snap.IsTree(Graph) + print("The graph is a tree: %s " % is_tree) + print("The graph has a root id: %d" % root_id) + + Network = snap.GenTree(snap.PNEANet, 3, 3) + [is_tree, root_id] = snap.IsTree(Network) + print("The graph is a tree: %s " % is_tree) + print("The graph has a root id: %d" % root_id) diff --git a/snap-python/source/doc/source/reference/IsTree.rst b/snap-python/source/doc/source/reference/IsTree.rst new file mode 100644 index 0000000000000000000000000000000000000000..97b7c793a222c83334c39c7be494c9f6b1dbdf3e --- /dev/null +++ b/snap-python/source/doc/source/reference/IsTree.rst @@ -0,0 +1,31 @@ +IsTree +'''''' + +.. function:: IsTree() + +A graph method that determines if a graph is a connected tree. The function returns a list of [bool, int], where the bool indicates whether the graph is a tree and the int is the node id for the root of the tree. The method works with :class:`TNGraph` and :class:`TNEANet`. + +Parameters: + +- none + +Return value: + +- list: [bool, int] + The list consists of two elements: a bool that indicates whether the graph is a tree, and an int giving the node id for the root of the tree. + + +The following example shows how to detect trees in +:class:`TNGraph` and :class:`TNEANet`:: + + import snap + + Graph = snap.GenTree(snap.TNGraph, 3, 3) + [is_tree, root_id] = Graph.IsTree() + print("The graph is a tree: %s " % is_tree) + print("The graph has a root id: %d" % root_id) + + Network = snap.GenTree(snap.TNEANet, 3, 3) + [is_tree, root_id] = Network.IsTree() + print("The graph is a tree: %s " % is_tree) + print("The graph has a root id: %d" % root_id) diff --git a/snap-python/source/doc/source/reference/IsWeaklyConn-swig.rst b/snap-python/source/doc/source/reference/IsWeaklyConn-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..8ef8b1d425b80d557e7bd9e08a30d28364a18611 --- /dev/null +++ b/snap-python/source/doc/source/reference/IsWeaklyConn-swig.rst @@ -0,0 +1,32 @@ +IsWeaklyConn (SWIG) +''''''''''''''''''' + +.. function:: IsWeaklyConn(Graph) + :noindex: + +Tests whether *Graph* is weakly connected. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- bool + Returns True if the *Graph* is weakly connected, False otherwise. + + +The following example shows how to use :func:`IsWeaklyConn` for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + print(snap.IsWeaklyConn(Graph)) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + print(snap.IsWeaklyConn(UGraph)) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + print(snap.IsWeaklyConn(Network)) diff --git a/snap-python/source/doc/source/reference/IsWeaklyConn.rst b/snap-python/source/doc/source/reference/IsWeaklyConn.rst new file mode 100644 index 0000000000000000000000000000000000000000..1e1ab46b6d0e0e349b72f0c88d77e3dd50f960d2 --- /dev/null +++ b/snap-python/source/doc/source/reference/IsWeaklyConn.rst @@ -0,0 +1,30 @@ +IsWeaklyConn +'''''''''''' + +.. function:: IsWeaklyConn() + +A graph method that tests whether a graph is weakly connected. + +Parameters: + +- None + +Return value: + +- bool + Returns True if the graph is weakly connected, False otherwise. + + +The following example shows how to use :func:`IsWeaklyConn` for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + print(Graph.IsWeaklyConn()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + print(UGraph.IsWeaklyConn()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + print(Network.IsWeaklyConn()) diff --git a/snap-python/source/doc/source/reference/LoadConnList.rst b/snap-python/source/doc/source/reference/LoadConnList.rst new file mode 100644 index 0000000000000000000000000000000000000000..a572aecad0b61dc99f6da9a1226621ac3a9e085d --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadConnList.rst @@ -0,0 +1,41 @@ +LoadConnList +'''''''''''' + +.. function:: LoadConnList(GraphType,InFNm) + +Loads a graph from a text file *InFNm*. + +*InFNm* is a whitespace separated file of several columns: ... +First column of each line contains a source node id followed by ids of the destination nodes. Node ids must be ints. +For example, '1 2 3' encodes edges 1 => 2 and 1 => 3. +Note that this format allows for saving isolated nodes. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *InFNm*: string + Filename with the description of the graph nodes and edges. + +Return value: + +- graph + A Snap.py graph of the specified type *GraphType*. + +The following example shows how to load a graph using :func:`LoadConnList` from a file named "test.txt":: + + import snap + + Graph = snap.LoadConnList(snap.TNGraph, "test.txt") + for EI in Graph.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + UGraph = snap.LoadConnList(snap.TUNGraph, "test.txt") + for EI in UGraph.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + Network = snap.LoadConnList(snap.TNEANet, "test.txt") + for EI in Network.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + diff --git a/snap-python/source/doc/source/reference/LoadConnListStr-swig.rst b/snap-python/source/doc/source/reference/LoadConnListStr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f210fcb3560fca5532392a904defc5bd84844eac --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadConnListStr-swig.rst @@ -0,0 +1,48 @@ +LoadConnListStr (SWIG) +'''''''''''''''''''''' + +.. function:: LoadConnListStr(GraphType, InFNm, StrToNIdH) + :noindex: + +Loads a (directed, undirected, or multi) graph from a text file, *InFNm*, with 1 node and all its edges in a single line. + +*InFNm* is a whitespace separated file of several columns: ... +First column of each line contains a source node name followed by ids of the destination nodes. +For example, 'A B C' encodes edges A-->B and A-->C. +Note that this format allows for saving isolated nodes. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InFNm*: string (input) + Filename with the description of the graph nodes and edges. + +- *StrToNIdH*: :class:`TStrIntSH`, a hash table of string keys and int values (output) + Stores the mapping from node names to node ids. + Note that this is a special hash table for holding strings and has a different interface than the standard SNAP hash table. Use *GetDat(name)* to obtain a mapping from a node name to its node id. + +Return value: + +- graph + A Snap.py graph of the specified type *GraphType*. + + +The following example shows how to load each of the graph types from a file named *test.dat*:: + + import snap + + H = snap.TStrIntSH() + Graph = snap.LoadConnListStr(snap.PNGraph, "test.dat", H) + + H = snap.TStrIntSH() + UGraph = snap.LoadConnListStr(snap.PUNGraph, "test.dat", H) + + H = snap.TStrIntSH() + Network = snap.LoadConnListStr(snap.PNEANet, "test.dat", H) + +A sample of *test.dat* is:: + + A B C + B C D diff --git a/snap-python/source/doc/source/reference/LoadConnListStr.rst b/snap-python/source/doc/source/reference/LoadConnListStr.rst new file mode 100644 index 0000000000000000000000000000000000000000..eeaa4d31fddad9211c52fd8dba19e760b7f426c0 --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadConnListStr.rst @@ -0,0 +1,51 @@ +LoadConnListStr +''''''''''''''' + +.. function:: LoadConnListStr(GraphType, InFNm) + +Loads a (directed, undirected, or multi) graph from a text file, *InFNm*, with 1 node and all its edges in a single line. + +*InFNm* is a whitespace separated file of several columns: ... +First column of each line contains a source node name followed by ids of the destination nodes. +For example, 'A B C' encodes edges A => B and A => C. +Note that this format allows for saving isolated nodes. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *InFNm*: string + Filename with the description of the graph nodes and edges. + +Return value: + +- graph + A Snap.py graph of the specified type *GraphType*. + +- *StrToNIdH*: :class:`TStrIntSH`, a hash table of string keys and int values + Stores the mapping from node names to node ids. + Note that this is a special hash table for holding strings and its interface differs from the standard SNAP hash table. Use *GetKeyId(name)* to obtain a mapping from a node name to its node id. + + +The following example shows how to load each of the graph types from a file named *test.dat*:: + + import snap + + (Graph, H) = snap.LoadConnListStr(snap.TNGraph, "test.dat") + + (UGraph, H) = snap.LoadConnListStr(snap.TUNGraph, "test.dat") + + (Network, H) = snap.LoadConnListStr(snap.TNEANet, "test.dat") + + # convert input string to node id + NodeId = H.GetKeyId("A") + # convert node id to input string + NodeName = H.GetKey(NodeId) + print("name", NodeName) + print("id ", NodeId) + +A sample of *test.dat* is:: + + A B C + B C D diff --git a/snap-python/source/doc/source/reference/LoadDyNet.rst b/snap-python/source/doc/source/reference/LoadDyNet.rst new file mode 100644 index 0000000000000000000000000000000000000000..185e0206a7e438b1c4f14b88f3d2c0950cca5391 --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadDyNet.rst @@ -0,0 +1,44 @@ +LoadDyNet +''''''''' + +.. function:: LoadDyNet(FNm) + +Loads a directed network in the DyNetML format. Loads only the first network in the file *FNm*. + +Parameters: + +- *InFNm*: string + Filename with the description of the graph. + +Return value: + +- directed graph :class:`TNGraph` + A directed Snap.py graph. + +For more info, see ORA Network Analysis Data (http://www.casos.cs.cmu.edu/computational_tools/data2.php) + + +The following example shows how to get TNGraph object for nodes in +:class:`TNGraph`:: + + import snap + import sys + + GOut = snap.GenRndGnm(snap.TNGraph, 100, 1000) + + fname = "test.xml" + f = open(fname, "w") + f.write("\n") + + for EI in GOut.Edges(): + src = EI.GetSrcNId() + dst = EI.GetDstNId() + f.write("\t \n") + + f.write("\n") + f.close() + + GIn = snap.LoadDyNet(fname) + + if (GIn.GetNodes() == GOut.GetNodes()): + print("true") diff --git a/snap-python/source/doc/source/reference/LoadEdgeList-swig.rst b/snap-python/source/doc/source/reference/LoadEdgeList-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..2fe334913942da3086318b2b81db86c6acc5640a --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadEdgeList-swig.rst @@ -0,0 +1,53 @@ +LoadEdgeList (SWIG) +''''''''''''''''''' + +.. function:: LoadEdgeList(GraphType, InFNm, SrcColId, DstColId) + :noindex: + +Loads a (directed, undirected or multi) graph from a text file *InFNm* with 1 edge per line (whitespace separated columns, int node ids). + +*InFNm* is a whitespace separated file of several columns: ... ... ... Since the function assumes each line of the file encodes a single edge and a line in the file can have more than 2 columns, *SrcColId* and *DstColId* must be provided to indicate which column gives the source and which column gives the destination of the edge. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InFNm*: string (input) + Filename with the description of the graph edges. + +- *SrcColId*: int (input) + The column number in the file, which contains the node id representing the source vertex. + +- *DstColId*: int (input) + The column number in the file, which contains the node id representing the destination vertex. + +Return value: + +- graph + A Snap.py graph or a network represented by the *InFNm* of type *GraphType*. + + +The following example shows how to load a small file representing a graph:: + + import snap; + + Graph = snap.LoadEdgeList(snap.PNGraph, "toy_graph", 0, 1) + Graph.Dump() + + UGraph = snap.LoadEdgeList(snap.PUNGraph, "toy_graph", 0, 1) + UGraph.Dump() + + Network = snap.LoadEdgeList(snap.PNEANet, "toy_graph", 0, 1) + Network.Dump() + + +An example file is given below (toy_graph) :: + + 1 1 + 1 2 + 2 1 + 1 3 + + + diff --git a/snap-python/source/doc/source/reference/LoadEdgeList.rst b/snap-python/source/doc/source/reference/LoadEdgeList.rst new file mode 100644 index 0000000000000000000000000000000000000000..6d3ddf554f07770b8e49cbdc8a18e10efed1ef81 --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadEdgeList.rst @@ -0,0 +1,52 @@ +LoadEdgeList +'''''''''''' + +.. function:: LoadEdgeList(GraphType, InFNm, SrcColId=0, DstColId=1, Separator=" ") + +Loads a (directed, undirected or multi) graph from a text file *InFNm* with 1 edge per line (columns separated by *Separator*, int node ids). + +*InFNm* is a *Separator* separated file of several columns: ... ... ... Since the function assumes each line of the file encodes a single edge and a line in the file can have more than 2 columns, *SrcColId* and *DstColId* must be provided to indicate which column gives the source and which column gives the destination of the edge. Node ids must be ints. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *InFNm*: string + Filename with the description of the graph edges. + +- (optional) *SrcColId*: int + The column number in the file, which contains the node id representing the source vertex. + +- (optional) *DstColId*: int + The column number in the file, which contains the node id representing the destination vertex. + +- (optional) *Separator*: char + Column separator. The default value is whitespace. + +Return value: + +- graph + A Snap.py graph or a network represented by the *InFNm* of type *GraphType*. + + +The following example shows how to load edge lists for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.SaveEdgeList("TNGraph.edges") + LoadedGraph = snap.LoadEdgeList(snap.TNGraph, "TNGraph.edges", 0, 1, '\t') + LoadedGraph.Dump() + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.SaveEdgeList("TUNGraph.edges") + LoadedUGraph = snap.LoadEdgeList(snap.TUNGraph, "TUNGraph.edges", 0, 1, '\t') + LoadedUGraph.Dump() + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.SaveEdgeList("TNEANet.edges") + LoadedNet = snap.LoadEdgeList(snap.TNEANet, "TNEANet.edges", 0, 1, '\t') + LoadedNet.Dump() + diff --git a/snap-python/source/doc/source/reference/LoadEdgeList1-swig.rst b/snap-python/source/doc/source/reference/LoadEdgeList1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d8a225a29e637230b3d872dc325f96e1a366b213 --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadEdgeList1-swig.rst @@ -0,0 +1,52 @@ +LoadEdgeList (SWIG) +''''''''''''''''''' + +.. function:: LoadEdgeList(PGraph, InFNm, SrcColId, DstColId, Separator) + :noindex: + +Loads a (directed, undirected or multi) graph from a text file *InFNm* with 1 edge per line (columns separated by *Separator*, int node ids). + +*InFNm* is a *Separator* separated file of several columns: ... ... ... Since the function assumes each line of the file encodes a single edge and a line in the file can have more than 2 columns, *SrcColId* and *DstColId* must be provided to indicate which column gives the source and which column gives the destination of the edge. Node ids must be ints. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InFNm*: string (input) + Filename with the description of the graph edges. + +- *SrcColId*: int (input) + The column number in the file, which contains the node id representing the source vertex. + +- *DstColId*: int (input) + The column number in the file, which contains the node id representing the destination vertex. + +- *Separator*: char (input) + Column separator. + +Return value: + +- graph + A Snap.py graph or a network represented by the *InFNm* of type *GraphType*. + + +The following example shows how to load edge lists for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.SaveEdgeList(Graph, "PNGraph.edges") + LoadedGraph = snap.LoadEdgeList(snap.PNGraph, "PNGraph.edges", 0, 1, '\t') + LoadedGraph.Dump() + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.SaveEdgeList(UGraph, "PUNGraph.edges") + LoadedUGraph = snap.LoadEdgeList(snap.PUNGraph, "PUNGraph.edges", 0, 1, '\t') + LoadedUGraph.Dump() + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.SaveEdgeList(Network, "PNEANet.edges") + LoadedNet = snap.LoadEdgeList(snap.PNEANet, "PNEANet.edges", 0, 1, '\t') + LoadedNet.Dump() diff --git a/snap-python/source/doc/source/reference/LoadEdgeListStr-swig.rst b/snap-python/source/doc/source/reference/LoadEdgeListStr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d11e3003d96f7b0c40b4c8e7eed42a5b6780625f --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadEdgeListStr-swig.rst @@ -0,0 +1,42 @@ +LoadEdgeListStr (SWIG) +''''''''''''''''''''''' + +.. function:: LoadEdgeListStr(GraphType, InFNm, SrcColId=0, DstColId=1) + :noindex: + +Loads a (directed, undirected or multi) graph from a text file *InFNm* with 1 edge per line (whitespace separated columns, int node ids). + +*InFNm* is a whitespace separated file of several columns: ... ... ... Since the function assumes each line of the file encodes a single edge and a line in the file can have more than 2 columns, *SrcColId* and *DstColId* must be provided to indicate which column gives the source and which column gives the destination of the edge. The node ids given in the file can be arbitrary strings. Note that the mapping of node names to ids is discarded. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InFNm*: string (input) + Filename with the description of the graph edges. + +- *SrcColId*: int (input) + The column number in the file, which contains the node id representing the source vertex. + +- *DstColId*: int (input) + The column number in the file, which contains the node id representing the destination vertex. + +Return value: + +- graph + A Snap.py graph or a network represented by the *InFNm* of type *GraphType*. + + +The following example shows how to load the following from a text file, wiki-vote.txt from http://snap.stanford.edu/data/wiki-Vote.html, where node IDs are strings:: + + import snap + + G = snap.LoadEdgeListStr(snap.PNGraph, "Wiki-Vote.txt", 0, 1) + print("Number of Nodes: %d" % G.GetNodes()) + + G = snap.LoadEdgeListStr(snap.PUNGraph, "Wiki-Vote.txt", 0, 1) + print("Number of Nodes: %d" % G.GetNodes()) + + G = snap.LoadEdgeListStr(snap.PNEANet, "Wiki-Vote.txt", 0, 1) + print("Number of Nodes: %d" % G.GetNodes()) diff --git a/snap-python/source/doc/source/reference/LoadEdgeListStr.rst b/snap-python/source/doc/source/reference/LoadEdgeListStr.rst new file mode 100644 index 0000000000000000000000000000000000000000..e86ecd8ab6745bcf3993b1b26743e41a12946779 --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadEdgeListStr.rst @@ -0,0 +1,59 @@ +LoadEdgeListStr +''''''''''''''' + +.. function:: LoadEdgeListStr(GraphType, InFNm, SrcColId=0, DstColId=1, Mapping=False) + +Loads a (directed, undirected or multi) graph from a text file *InFNm* with 1 edge per line (whitespace separated columns, int node ids). + +*InFNm* is a whitespace separated file of several columns: ... ... ... Since the function assumes each line of the file encodes a single edge and a line in the file can have more than 2 columns, *SrcColId* and *DstColId* must be provided to indicate which column gives the source and which column gives the destination of the edge. The node ids given in the file can be arbitrary strings. The mapping of node names to ids either is discarded or saved in *StrToNIdH*, depending on the *Mapping* parameter. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *InFNm*: string + Filename with the description of the graph edges. + +- (optional) *SrcColId*: int + The column number in the file, which contains the node id representing the source vertex. + +- (optional) *DstColId*: int + The column number in the file, which contains the node id representing the destination vertex. + +- (optional) *Mapping*: bool + Specifies whether to return the mapping of node names to node ids. + +Return value: + +- graph + A Snap.py graph or a network represented by the *InFNm* of type *GraphType*. + +- (optional) *StrToNIdH*: :class:`TStrIntSH`, a string hash table with string keys and int values + It is returned, if *Mapping* is True and it contains the mapping of strings to node ids. + + +The following examples shows how to load a graph from a text file, wiki-vote.txt from http://snap.stanford.edu/data/wiki-Vote.html, where node ids are strings:: + + import snap + + G = snap.LoadEdgeListStr(snap.TNGraph, "wiki-Vote.txt", 0, 1) + print("Number of Nodes: %d" % G.GetNodes()) + + G = snap.LoadEdgeListStr(snap.TUNGraph, "wiki-Vote.txt", 0, 1) + print("Number of Nodes: %d" % G.GetNodes()) + + G = snap.LoadEdgeListStr(snap.TNEANet, "wiki-Vote.txt", 0, 1) + print("Number of Nodes: %d" % G.GetNodes()) + + (G, Map) = snap.LoadEdgeListStr(snap.TNGraph, "wiki-Vote.txt", 0, 1, True) + print("Number of Nodes: %d" % G.GetNodes()) + print("Number of Nodes: %d" % Map.Len()) + + # convert input string to node id + NodeId = Map.GetKeyId("1065") + # convert node id to input string + NodeName = Map.GetKey(NodeId) + print("name", NodeName) + print("id ", NodeId) + diff --git a/snap-python/source/doc/source/reference/LoadEdgeListStr1-swig.rst b/snap-python/source/doc/source/reference/LoadEdgeListStr1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..3a00ad8d4678ca43fa14fba8a5a41b89efb27431 --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadEdgeListStr1-swig.rst @@ -0,0 +1,48 @@ +LoadEdgeListStr (SWIG) +'''''''''''''''''''''' + +.. function:: LoadEdgeListStr(GraphType, InFNm, SrcColId, DstColId, StrToNIdH) + :noindex: + +Loads a (directed, undirected or multi) graph from a text file *InFNm* with 1 edge per line (whitespace separated columns, int node ids). + +*InFNm* is a whitespace separated file of several columns: ... ... ... Since the function assumes each line of the file encodes a single edge and a line in the file can have more than 2 columns, *SrcColId* and *DstColId* must be provided to indicate which column gives the source and which column gives the destination of the edge. The node ids given in the file can be arbitrary strings. The mapping of node names to ids is saved in *StrToNIdH*. + +Parameters: + +- *GraphType*: graph class (input) + Class of output graph -- one of :class:`PNGraph`, :class:`PNEANet`, or :class:`PUNGraph`. + +- *InFNm*: string (input) + Filename with the description of the graph edges. + +- *SrcColId*: int (input) + The column number in the file, which contains the node id representing the source vertex. + +- *DstColId*: int (input) + The column number in the file, which contains the node id representing the destination vertex. + +- *StrToNIdH*: :class:`TStrIntSH`, a string hash table with string keys and int values (output) + Contains the mapping of strings to node ids. + + +Return value: + +- graph + A Snap.py graph or a network represented by the *InFNm* of type *GraphType*. + + +The following example shows how to load the following from a text file, wiki-vote.txt from http://snap.stanford.edu/data/wiki-Vote.html, where node IDs are strings:: + + import snap + + mapping = snap.TStrIntSH() + G0 = snap.LoadEdgeListStr(snap.PNGraph, "wiki-Vote.txt", 0, 1, mapping) + + # convert input string to node id + NodeId = mapping.GetKeyId("1065") + # convert node id to input string + NodeName = mapping.GetKey(NodeId) + print("name", NodeName) + print("id ", NodeId) + diff --git a/snap-python/source/doc/source/reference/LoadPajek.rst b/snap-python/source/doc/source/reference/LoadPajek.rst new file mode 100644 index 0000000000000000000000000000000000000000..278c74a7119c0fff0218a52382fc4a89f5bdfe7e --- /dev/null +++ b/snap-python/source/doc/source/reference/LoadPajek.rst @@ -0,0 +1,54 @@ +LoadPajek +''''''''' + +.. function:: LoadPajek(GraphType, InFNm) + +Loads a *GraphType* from Pajek .PAJ format file from +the filename in *InFNm*. Function supports both the 1 edge per line ( + ) as well as the 1 node per line ( + ...) formats. + +Parameters: + +- *GraphType*: graph class + Class of output graph -- one of :class:`TNGraph`, :class:`TNEANet`, or :class:`TUNGraph`. + +- *InFNm*: string + Filename with the description of the graph edges. + +Return value: + +- graph + A Snap.py graph or a network represented by the *InFNm* of type *GraphType*. + +For more information on the Pajek format see: http://pajek.imfm.si/doku.php + + +The following example shows how to load a Pajek file:: + + import snap + + output = open("example.paj", "w") + output.write("""*Vertices 9 + 1 "1" 0.3034 0.7561 + 2 "2" 0.4565 0.6039 + 3 "3" 0.4887 0.8188 + *Arcs + 1 2 1 + 1 3 1 + 2 3 1 + """) + output.close() + + Graph = snap.LoadPajek(snap.TNGraph, 'example.paj') + for NI in Graph.Nodes(): + print(NI.GetId()) + + UGraph = snap.LoadPajek(snap.TUNGraph, 'example.paj') + for NI in UGraph.Nodes(): + print(NI.GetId()) + + Network = snap.LoadPajek(snap.TNEANet, 'example.paj') + for NI in Network.Nodes(): + print(NI.GetId()) + diff --git a/snap-python/source/doc/source/reference/MakeUnDir-swig.rst b/snap-python/source/doc/source/reference/MakeUnDir-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..040655e1cd873f1df46feff70b49b0d47e754ea6 --- /dev/null +++ b/snap-python/source/doc/source/reference/MakeUnDir-swig.rst @@ -0,0 +1,37 @@ +MakeUnDir (SWIG) +'''''''''''''''' + +.. function:: MakeUnDir(Graph) + :noindex: + +Makes the graph undirected. For every edge (u,v) an edge (v,u) is added (if it does not yet exist). The function has no effect on undirected graphs. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +Return value: + +- None + + +The following example shows usage with graph types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + print(Graph.GetEdges()) + snap.MakeUnDir(Graph) + print(Graph.GetEdges()) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + print(UGraph.GetEdges()) + snap.MakeUnDir(UGraph) + print(UGraph.GetEdges()) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + print(Network.GetEdges()) + snap.MakeUnDir(Network) + print(Network.GetEdges()) diff --git a/snap-python/source/doc/source/reference/MakeUnDir.rst b/snap-python/source/doc/source/reference/MakeUnDir.rst new file mode 100644 index 0000000000000000000000000000000000000000..d0bf704d76b66bee761e17ac072585419477438a --- /dev/null +++ b/snap-python/source/doc/source/reference/MakeUnDir.rst @@ -0,0 +1,35 @@ +MakeUnDir +''''''''' + +.. function:: MakeUnDir() + +A graph method that makes the graph undirected. For every edge (u,v) an edge (v,u) is added (if it does not yet exist). The function has no effect on undirected graphs. + +Parameters: + +- None + +Return value: + +- None + + +The following example shows usage with graph types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + print(Graph.GetEdges()) + Graph.MakeUnDir() + print(Graph.GetEdges()) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + print(UGraph.GetEdges()) + UGraph.MakeUnDir() + print(UGraph.GetEdges()) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + print(Network.GetEdges()) + Network.MakeUnDir() + print(Network.GetEdges()) diff --git a/snap-python/source/doc/source/reference/PlotClustCf-swig.rst b/snap-python/source/doc/source/reference/PlotClustCf-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..a315fe77c6833f841f1031156fae802d8eca9554 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotClustCf-swig.rst @@ -0,0 +1,38 @@ +PlotClustCf (SWIG) +'''''''''''''''''' + +.. function:: PlotClustCf(Graph, FNmPref, DescStr) + :noindex: + +Plots the distribution of clustering coefficient of *Graph*. The function creates three new files: 1) ccf.<*FNmPref*>.plt (the commands used to create the plot), 2) ccf.<*FNPref*>.png (the plot), and 3) ccf.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the distribution of clustering coefficients +for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotClustCf(Graph, "example", "Directed graph - clustering coefficient") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotClustCf(UGraph, "example", "Directed graph - clustering coefficient") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotClustCf(Network, "example", "Directed graph - clustering coefficient") + diff --git a/snap-python/source/doc/source/reference/PlotClustCf.rst b/snap-python/source/doc/source/reference/PlotClustCf.rst new file mode 100644 index 0000000000000000000000000000000000000000..4d645c2fa5f80fadb63ead9ca06d51e8de0a0fbc --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotClustCf.rst @@ -0,0 +1,34 @@ +PlotClustCf +''''''''''' + +.. function:: PlotClustCf(FNmPref, DescStr) + +A graph method that plots the distribution of clustering coefficient of a graph. The function creates three new files: 1) ccf.<*FNmPref*>.plt (the commands used to create the plot), 2) ccf.<*FNPref*>.png (the plot), and 3) ccf.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the distribution of clustering coefficients +for nodes in :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotClustCf("example", "Directed graph - clustering coefficient") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotClustCf("example", "Directed graph - clustering coefficient") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotClustCf("example", "Directed graph - clustering coefficient") + diff --git a/snap-python/source/doc/source/reference/PlotEigValDistr-swig.rst b/snap-python/source/doc/source/reference/PlotEigValDistr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5882aa8c92fceb408721cb851449ad59f9782a0c --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotEigValDistr-swig.rst @@ -0,0 +1,38 @@ +PlotEigValDistr (SWIG) +'''''''''''''''''''''' + +.. function:: PlotEigValDistr(Graph, NumEigenvalues, FNmPref, DescStr) + :noindex: + +Plots the frequency distribution of the leading *NumEigenvalues* eigenvalues of the undirected graph *Graph*. The function creates three new files: 1) eigDistr.<*FNmPref*>.plt (the commands used to create the plot), 2) eigDistr.<*FNPref*>.png (the plot), and 3) eigDistr.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *NumEigenvalues*: int (input) + The plot will contain the frequencies of the first *NumEigenvalues* eigenvalues. + +- *FNmPref*: string (input) + File name preference for the plotted graph. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the eigenvalue frequency distribution of +an undirected graph of type :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + + # Plot the frequencies of the first 10 eigenvalues + # NOTE: Random graphs are likely to thwart the calculation of eigenvalues + snap.PlotEigValDistr(UGraph, 10, "example", "Random Graph Eigenvalue Distribution") + diff --git a/snap-python/source/doc/source/reference/PlotEigValDistr.rst b/snap-python/source/doc/source/reference/PlotEigValDistr.rst new file mode 100644 index 0000000000000000000000000000000000000000..2f649cf3dc49e38fb24fd4a5320bdb2acdafd252 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotEigValDistr.rst @@ -0,0 +1,34 @@ +PlotEigValDistr +''''''''''''''' + +.. function:: PlotEigValDistr(NumEigenvalues, FNmPref, DescStr) + +A graph method for undirected graphs that plots the frequency distribution of the leading *NumEigenvalues* eigenvalues. The function creates three new files: 1) eigDistr.<*FNmPref*>.plt (the commands used to create the plot), 2) eigDistr.<*FNPref*>.png (the plot), and 3) eigDistr.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *NumEigenvalues*: int + The plot will contain the frequencies of the first *NumEigenvalues* eigenvalues. + +- *FNmPref*: string + File name preference for the plotted graph. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the eigenvalue frequency distribution of +an undirected graph of type :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + + # Plot the frequencies of the first 10 eigenvalues + # NOTE: Random graphs are likely to thwart the calculation of eigenvalues + UGraph.PlotEigValDistr(10, "example", "Random Graph Eigenvalue Distribution") + diff --git a/snap-python/source/doc/source/reference/PlotEigValRank-swig.rst b/snap-python/source/doc/source/reference/PlotEigValRank-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..1f2b37801b30f474bf318134df951e7a46cf6ebb --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotEigValRank-swig.rst @@ -0,0 +1,38 @@ +PlotEigValRank (SWIG) +''''''''''''''''''''' + +.. function:: PlotEigValRank(Graph, NumEigenvalues, FNmPref, DescStr) + :noindex: + +Plots the distribution of the ranks of the first *NumEigenvalues* eigenvalues of the undirected graph *Graph*. The function creates three new files: 1) eigVal.<*FNmPref*>.plt (the commands used to create the plot), 2) eigVal.<*FNPref*>.png (the plot), and 3) eigVal.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *NumEigenvalues*: int (input) + The plot will contain the ranks of the first *NumEigenvalues* eigenvalues'. ranks + +- *FNmPref*: string (input) + File name preference for the plotted graph. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the eigenvalue rank distribution of +an undirected graph of type :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 2000) + + # Plot the ranks of the first 10 eigenvalues + # NOTE: Random graphs are likely to thwart the calculation of eigenvalues + snap.PlotEigValRank(UGraph, 10, "example", "Random Graph Eigenvalue Rank") + diff --git a/snap-python/source/doc/source/reference/PlotEigValRank.rst b/snap-python/source/doc/source/reference/PlotEigValRank.rst new file mode 100644 index 0000000000000000000000000000000000000000..8510005f6bbda871e707eecbae8e909cca7fb33c --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotEigValRank.rst @@ -0,0 +1,34 @@ +PlotEigValRank +'''''''''''''' + +.. function:: PlotEigValRank(NumEigenvalues, FNmPref, DescStr) + +A graph method for undirected graphs that plots the distribution of the ranks of the first *NumEigenvalues* eigenvalues. The function creates three new files: 1) eigVal.<*FNmPref*>.plt (the commands used to create the plot), 2) eigVal.<*FNPref*>.png (the plot), and 3) eigVal.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *NumEigenvalues*: int + The number of the first *NumEigenvalues* eigenvalues' to include in the plot. + +- *FNmPref*: string + File name preference for the plotted graph. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the eigenvalue rank distribution of +an undirected graph of type :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 2000) + + # Plot the ranks of the first 10 eigenvalues + # NOTE: Random graphs are likely to thwart the calculation of eigenvalues + UGraph.PlotEigValRank(10, "example", "Random Graph Eigenvalue Rank") + diff --git a/snap-python/source/doc/source/reference/PlotHops-swig.rst b/snap-python/source/doc/source/reference/PlotHops-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..aa1474d4f9e13719060657019c2ac92bdd9ea7b9 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotHops-swig.rst @@ -0,0 +1,42 @@ +PlotHops (SWIG) +''''''''''''''' + +.. function:: PlotHops(Graph, FNmPref, DescStr, IsDir=False, NApprox=32) + :noindex: + +Plots the cumulative distribution of the shortest path lengths of *Graph*. The implementation is based on ANF (Approximate Neighborhood Function). The function creates three new files: 1) hop.<*FNmPref*>.plt (the commands used to create the plot), 2) hop.<*FNPref*>.png (the plot), and 3) hop.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +- *IsDir*: bool (input) + Whether the input graph is directed or not. + +- *NApprox*: int (input) + Number of ANF approximations, must be a multiple of eight. The larger this value is, the more accurate the distribution is. + +Return value: + +- None + + +The following example shows how to plot the cumulative distribution of shortest path lengths for graphs of types :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotHops(Graph, "example", "Directed graph - hops", True, 1024) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotHops(UGraph, "example", "Undirected graph - hops", False, 1024) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotHops(Network, "example", "Network - hops", True, 1024) diff --git a/snap-python/source/doc/source/reference/PlotHops.rst b/snap-python/source/doc/source/reference/PlotHops.rst new file mode 100644 index 0000000000000000000000000000000000000000..10dd970c226abdaf48cfd6d7ab6748d658984d42 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotHops.rst @@ -0,0 +1,38 @@ +PlotHops +'''''''' + +.. function:: PlotHops(FNmPref, DescStr, IsDir=False, NApprox=32) + +A graph method that plots the cumulative distribution of the shortest path lengths of a graph. The implementation is based on ANF (Approximate Neighborhood Function). The function creates three new files: 1) hop.<*FNmPref*>.plt (the commands used to create the plot), 2) hop.<*FNPref*>.png (the plot), and 3) hop.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +- *IsDir*: bool + Whether the input graph is directed or not. + +- *NApprox*: int + Number of ANF approximations, must be a multiple of eight. The larger this value is, the more accurate the distribution is. + +Return value: + +- None + + +The following example shows how to plot the cumulative distribution of shortest path lengths for graphs of types :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotHops("example", "Directed graph - hops", True, 1024) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotHops("example", "Undirected graph - hops", False, 1024) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotHops("example", "Network - hops", True, 1024) diff --git a/snap-python/source/doc/source/reference/PlotInDegDistr-swig.rst b/snap-python/source/doc/source/reference/PlotInDegDistr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..af6e9a9ad79055d2b39b14485fc6f9ab23393144 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotInDegDistr-swig.rst @@ -0,0 +1,43 @@ +PlotInDegDistr (SWIG) +''''''''''''''''''''' + +.. function:: PlotInDegDistr(Graph, FNmPref, DescStr, PlotCCdf=False, PowerFit=False) + :noindex: + +Plots the in-degree distribution of *Graph*. The function creates three new files: 1) inDeg.<*FNmPref*>.plt (the plot), 2) inDeg.<*FNPref*>.png (the plotting description), and 3) inDeg.<*FNmPref*>.tab (the tab separated plotting data). + + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +- *PlotCCdf*: bool (input) + Plots the distribution as a Complementary Cummulative distribution function. + +- *PowerFit*: bool (input) + Fits a Power-Law to the distribution. + +Return value: + +- None + + +The following example shows how generate a plot of the in-degree distribution for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotInDegDistr(Graph, "example", "Directed graph - in-degree Distribution") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotInDegDistr(UGraph, "example", "Undirected graph - in-degree Distribution") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotInDegDistr(Network, "example", "Network - in-degree Distribution") diff --git a/snap-python/source/doc/source/reference/PlotInDegDistr.rst b/snap-python/source/doc/source/reference/PlotInDegDistr.rst new file mode 100644 index 0000000000000000000000000000000000000000..ce39105684a1b658994f852c46dae9f0b1e4281f --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotInDegDistr.rst @@ -0,0 +1,39 @@ +PlotInDegDistr +'''''''''''''' + +.. function:: PlotInDegDistr(FNmPref, DescStr, PlotCCdf=False, PowerFit=False) + +A graph method that plots the in-degree distribution of a graph. The function creates three new files: 1) inDeg.<*FNmPref*>.plt (the plot), 2) inDeg.<*FNPref*>.png (the plotting description), and 3) inDeg.<*FNmPref*>.tab (the tab separated plotting data). + + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +- *PlotCCdf*: bool + Plots the distribution as a Complementary Cummulative distribution function. + +- *PowerFit*: bool + Fits a Power-Law to the distribution. + +Return value: + +- None + + +The following example shows how generate a plot of the in-degree distribution for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotInDegDistr("example", "Directed graph - in-degree Distribution") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotInDegDistr("example", "Undirected graph - in-degree Distribution") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotInDegDistr("example", "Network - in-degree Distribution") diff --git a/snap-python/source/doc/source/reference/PlotInvParticipRat-swig.rst b/snap-python/source/doc/source/reference/PlotInvParticipRat-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..50fa85a785191bd3b98dce52ce7d960a27179a28 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotInvParticipRat-swig.rst @@ -0,0 +1,40 @@ +PlotInvParticipRat (SWIG) +''''''''''''''''''''''''' + +.. function:: PlotInvParticipRat(Graph, MaxEigVecs, TimeLimit, FNmPref, DescStr) + :noindex: + +Plots the inverse participation ratio. See the reference below for more details. The function creates three new files: 1) eigIPR.<*FNmPref*>.plt (the commands used to create the plot), 2) eigIPR.<*FNPref*>.png (the plot), and 3) eigIPR.<*FNmPref*>.tab (the plotting data).. + +Parameters: + +- *Graph*: undirected graph (input) + A Snap.py undirected graph. + +- *MaxEigVecs*: int (input) + Maximum number of eigenvectors to return. + +- *TimeLimit*: int (input) + Maximum number seconds to search. + +- *FNmPref*: string (input) + File name preference for the plotted graph. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +For more info see: http://www.barabasilab.com/pubs/CCNR-ALB_Publications/200108-01_PhysRevE-SprectraRealWorld/200108-01_PhysRevE-SprectraRealWorld.pdf + +The following example shows how to plot the inverse participation ratio of +an undirected graph of type :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotInvParticipRat(UGraph, 50, 10, "example", "PlotInvParticipRat") + diff --git a/snap-python/source/doc/source/reference/PlotInvParticipRat.rst b/snap-python/source/doc/source/reference/PlotInvParticipRat.rst new file mode 100644 index 0000000000000000000000000000000000000000..7d7707e279d6063163d079083709ffe948150d0e --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotInvParticipRat.rst @@ -0,0 +1,36 @@ +PlotInvParticipRat +'''''''''''''''''' + +.. function:: PlotInvParticipRat(MaxEigVecs, TimeLimit, FNmPref, DescStr) + +A graph method for undirected graphs that plots the inverse participation ratio. See the reference below for more details. The function creates three new files: 1) eigIPR.<*FNmPref*>.plt (the commands used to create the plot), 2) eigIPR.<*FNPref*>.png (the plot), and 3) eigIPR.<*FNmPref*>.tab (the plotting data).. + +Parameters: + +- *MaxEigVecs*: int + Maximum number of eigenvectors to return. + +- *TimeLimit*: int + Maximum number seconds to search. + +- *FNmPref*: string + File name preference for the plotted graph. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +For more info see: http://www.barabasilab.com/pubs/CCNR-ALB_Publications/200108-01_PhysRevE-SprectraRealWorld/200108-01_PhysRevE-SprectraRealWorld.pdf + +The following example shows how to plot the inverse participation ratio of +an undirected graph of type :class:`TUNGraph`:: + + import snap + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotInvParticipRat(50, 10, "example", "PlotInvParticipRat") + diff --git a/snap-python/source/doc/source/reference/PlotKCoreEdges-swig.rst b/snap-python/source/doc/source/reference/PlotKCoreEdges-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..b188c4899733f6285ff64041e085d677be41acfa --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotKCoreEdges-swig.rst @@ -0,0 +1,39 @@ +PlotKCoreEdges (SWIG) +''''''''''''''''''''' + +.. function:: PlotKCoreEdges(Graph, FNmPref, DescStr) + :noindex: + +Plots the k-core edge-size distribution: core k vs. number of edges in k-core. The function creates three new files: 1) coreEdges.<*FNmPref*>.plt (the commands used to create the plot), 2) coreEdges.<*FNPref*>.png (the plot), and 3) coreEdges.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the k-core edge-size distribution for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotKCoreEdges(Graph, "example", "Directed graph - k-core edges") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotKCoreEdgees(UGraph, "example", "Undirected graph - k-core edges") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotKCoreEdges(Network, "example", "Network - k-core edges") + + diff --git a/snap-python/source/doc/source/reference/PlotKCoreEdges.rst b/snap-python/source/doc/source/reference/PlotKCoreEdges.rst new file mode 100644 index 0000000000000000000000000000000000000000..6a6fb08a736408cb258891ce20907d2acdc05a6d --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotKCoreEdges.rst @@ -0,0 +1,35 @@ +PlotKCoreEdges +'''''''''''''' + +.. function:: PlotKCoreEdges(FNmPref, DescStr) + +A graph method that plots the k-core edge-size distribution: core k vs. number of edges in k-core. The function creates three new files: 1) coreEdges.<*FNmPref*>.plt (the commands used to create the plot), 2) coreEdges.<*FNPref*>.png (the plot), and 3) coreEdges.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the k-core edge-size distribution for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotKCoreEdges("example", "Directed graph - k-core edges") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotKCoreEdgees("example", "Undirected graph - k-core edges") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotKCoreEdges("example", "Network - k-core edges") + + diff --git a/snap-python/source/doc/source/reference/PlotKCoreNodes-swig.rst b/snap-python/source/doc/source/reference/PlotKCoreNodes-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..cc50bd5d2da1e66ca75f4cae92f702f8450e7028 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotKCoreNodes-swig.rst @@ -0,0 +1,37 @@ +PlotKCoreNodes (SWIG) +''''''''''''''''''''' + +.. function:: PlotKCoreNodes(Graph, FNmPref, DescStr) + :noindex: + +Plots the k-core node-size distribution: core k vs. number of nodes in k-core. The function creates three new files: 1) coreNodes.<*FNmPref*>.plt (the commands used to create the plot), 2) coreNodes.<*FNPref*>.png (the plot), and 3) coreNodes.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the k-core node-size distribution for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotKCoreNodes(Graph, "example", "Directed graph - k-core nodes") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotKCoreNodes(UGraph, "example", "Undirected graph - k-core nodes") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotKCoreNodes(Network, "example", "Network - k-core nodes") diff --git a/snap-python/source/doc/source/reference/PlotKCoreNodes.rst b/snap-python/source/doc/source/reference/PlotKCoreNodes.rst new file mode 100644 index 0000000000000000000000000000000000000000..2b68d8f69d3ee69e003160eaad8c753d8b9eed56 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotKCoreNodes.rst @@ -0,0 +1,33 @@ +PlotKCoreNodes +'''''''''''''' + +.. function:: PlotKCoreNodes(FNmPref, DescStr) + +A graph method that plots the k-core node-size distribution: core k vs. number of nodes in k-core. The function creates three new files: 1) coreNodes.<*FNmPref*>.plt (the commands used to create the plot), 2) coreNodes.<*FNPref*>.png (the plot), and 3) coreNodes.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the k-core node-size distribution for +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotKCoreNodes("example", "Directed graph - k-core nodes") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotKCoreNodes("example", "Undirected graph - k-core nodes") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Graph.PlotKCoreNodes("example", "Network - k-core nodes") diff --git a/snap-python/source/doc/source/reference/PlotOutDegDistr-swig.rst b/snap-python/source/doc/source/reference/PlotOutDegDistr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..d6040784be85426ca2bd62605a6d5507b6c74e25 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotOutDegDistr-swig.rst @@ -0,0 +1,43 @@ +PlotOutDegDistr (SWIG) +'''''''''''''''''''''' + +.. function:: PlotOutDegDistr(Graph, FNmPref, DescStr, PlotCCdf=False, PowerFit=False) + :noindex: + +Plots the out-degree distribution of *Graph*. The function creates three new files: 1) outDeg.<*FNmPref*>.plt (the plot), 2) outDeg.<*FNPref*>.png (the plotting description), and 3) outDeg.<*FNmPref*>.tab (the tab separated plotting data). + + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +- *PlotCCdf*: bool (input) + Plots the distribution as a Complementary Cummulative distribution function. + +- *PowerFit*: bool (input) + Fits a Power-Law to the distribution. + +Return value: + +- None + + +The following example shows how generate a plot of the out-degree distribution for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotOutDegDistr(Graph, "example", "Directed graph - out-degree Distribution") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotOutDegDistr(UGraph, "example", "Undirected graph - out-degree Distribution") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotOutDegDistr(Network, "example", "Network - out-degree Distribution") diff --git a/snap-python/source/doc/source/reference/PlotOutDegDistr.rst b/snap-python/source/doc/source/reference/PlotOutDegDistr.rst new file mode 100644 index 0000000000000000000000000000000000000000..8ecf1f222d7dd76a51370e6778f74d6ed929310e --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotOutDegDistr.rst @@ -0,0 +1,39 @@ +PlotOutDegDistr +''''''''''''''' + +.. function:: PlotOutDegDistr(FNmPref, DescStr, PlotCCdf=False, PowerFit=False) + +A graph method that plots the out-degree distribution of a graph. The function creates three new files: 1) outDeg.<*FNmPref*>.plt (the plot), 2) outDeg.<*FNPref*>.png (the plotting description), and 3) outDeg.<*FNmPref*>.tab (the tab separated plotting data). + + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +- *PlotCCdf*: bool + Plots the distribution as a Complementary Cummulative distribution function. + +- *PowerFit*: bool + Fits a Power-Law to the distribution. + +Return value: + +- None + + +The following example shows how generate a plot of the out-degree distribution for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotOutDegDistr("example", "Directed graph - out-degree Distribution") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotOutDegDistr("example", "Undirected graph - out-degree Distribution") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotOutDegDistr("example", "Network - out-degree Distribution") diff --git a/snap-python/source/doc/source/reference/PlotSccDistr-swig.rst b/snap-python/source/doc/source/reference/PlotSccDistr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..97dfac16bc9b684bc59005c52f03c2f6237f5a24 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSccDistr-swig.rst @@ -0,0 +1,37 @@ +PlotSccDistr (SWIG) +''''''''''''''''''' + +.. function:: PlotSccDistr(Graph, FNmPref, DescStr) + :noindex: + +Plots the distribution of sizes of strongly connected components of *Graph*. The function creates three new files: 1) scc.<*FNmPref*>.plt (the commands used to create the plot), 2) scc.<*FNPref*>.png (the plot), and 3) scc.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the distribution of sizes of strongly connected components for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotSccDistr(Graph, "example", "Directed graph - scc distribution") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotSccDistr(UGraph, "example", "Undirected graph - scc distribution") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotSccDistr(Network, "example", "Network - scc distribution") + diff --git a/snap-python/source/doc/source/reference/PlotSccDistr.rst b/snap-python/source/doc/source/reference/PlotSccDistr.rst new file mode 100644 index 0000000000000000000000000000000000000000..bfde43412a0c06d14cd4703e75b6adf34a316f98 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSccDistr.rst @@ -0,0 +1,33 @@ +PlotSccDistr +'''''''''''' + +.. function:: PlotSccDistr(FNmPref, DescStr) + +A graph method that plots the distribution of sizes of strongly connected components of a graph. The function creates three new files: 1) scc.<*FNmPref*>.plt (the commands used to create the plot), 2) scc.<*FNPref*>.png (the plot), and 3) scc.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the distribution of sizes of strongly connected components for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotSccDistr("example", "Directed graph - scc distribution") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotSccDistr("example", "Undirected graph - scc distribution") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotSccDistr("example", "Network - scc distribution") + diff --git a/snap-python/source/doc/source/reference/PlotShortPathDistr-swig.rst b/snap-python/source/doc/source/reference/PlotShortPathDistr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..f69cf7214a9503760afa146944a449e7ca0021fa --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotShortPathDistr-swig.rst @@ -0,0 +1,40 @@ +PlotShortPathDistr (SWIG) +''''''''''''''''''''''''' + +.. function:: PlotShortPathDistr(Graph, FNmPref, DescStr, TestNodes=TInt.Mx) + :noindex: + +Plots the distribution of the shortest path lengths in *Graph*. The implementation is based on BFS. The function creates three new files: 1) diam.<*FNmPref*>.plt (the commands used to create the plot), 2) diam.<*FNPref*>.png (the plot), and 3) diam.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +- *TestNodes*: int (input) + Number of nodes from which to start BFS to count shortest path lengths. If TestNodes is less than the total number of graph nodes, then the plot may only be an approximation of the distribution of the shortest path lengths. + +Return value: + +- None + + +The following example shows how to generate plots of the distribution of shortest path lengths for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotShortPathDistr(Graph, "example", "Directed graph - shortest path") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotShortPathDistr(UGraph, "example", "Undirected graph - shortest path") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotShortPathDistr(Network, "example", "Network - shortest path") + diff --git a/snap-python/source/doc/source/reference/PlotShortPathDistr.rst b/snap-python/source/doc/source/reference/PlotShortPathDistr.rst new file mode 100644 index 0000000000000000000000000000000000000000..dfbebccdee798c0e7f5e9a5e50f233b20b1faea0 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotShortPathDistr.rst @@ -0,0 +1,36 @@ +PlotShortPathDistr +'''''''''''''''''' + +.. function:: PlotShortPathDistr(FNmPref, DescStr, TestNodes=TInt.Mx) + +A graph method that plots the distribution of the shortest path lengths in a graph. The implementation is based on BFS. The function creates three new files: 1) diam.<*FNmPref*>.plt (the commands used to create the plot), 2) diam.<*FNPref*>.png (the plot), and 3) diam.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +- *TestNodes*: int + Number of nodes from which to start BFS to count shortest path lengths. If TestNodes is less than the total number of graph nodes, then the plot may only be an approximation of the distribution of the shortest path lengths. + +Return value: + +- None + + +The following example shows how to generate plots of the distribution of shortest path lengths for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotShortPathDistr("example", "Directed graph - shortest path") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotShortPathDistr("example", "Undirected graph - shortest path") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotShortPathDistr("example", "Network - shortest path") + diff --git a/snap-python/source/doc/source/reference/PlotSngValDistr-swig.rst b/snap-python/source/doc/source/reference/PlotSngValDistr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..0d846f618480da619850b3b06813f15ede248ebf --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSngValDistr-swig.rst @@ -0,0 +1,33 @@ +PlotSngValDistr (SWIG) +'''''''''''''''''''''' + +.. function:: PlotSngValDistr(Graph,SngVals, FNmPref, DescStr) + :noindex: + +Plots a histogram distribution of the top 2x *SngVals* singular values of the *Graph* adjacency matrix. The function creates three new files: 1) sngDistr.<*FNmPref*>.plt (the commands used to create the plot), 2) sngDistr.<*FNPref*>.png (the plot), and 3) sngDistr.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py directed graph. + +- *SngVals*: integer (input) + Representing one half the desired number of singular values. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to use :func:`PlotSngValDistr` for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 5000) + snap.PlotSngValDistr(Graph, 50, "title", "SngVal Distribution") diff --git a/snap-python/source/doc/source/reference/PlotSngValDistr.rst b/snap-python/source/doc/source/reference/PlotSngValDistr.rst new file mode 100644 index 0000000000000000000000000000000000000000..2d57b7ed69750cfa0b0e8a3e4dc7f700a5ba32e8 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSngValDistr.rst @@ -0,0 +1,29 @@ +PlotSngValDistr +''''''''''''''' + +.. function:: PlotSngValDistr(SngVals, FNmPref, DescStr) + +A graph method for directed graphs that plots a histogram distribution of the top 2x *SngVals* singular values of the adjacency matrix. The function creates three new files: 1) sngDistr.<*FNmPref*>.plt (the commands used to create the plot), 2) sngDistr.<*FNPref*>.png (the plot), and 3) sngDistr.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *SngVals*: integer + Representing one half the desired number of singular values. + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to use :func:`PlotSngValDistr` for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 5000) + Graph.PlotSngValDistr(50, "title", "SngVal Distribution") diff --git a/snap-python/source/doc/source/reference/PlotSngValRank-swig.rst b/snap-python/source/doc/source/reference/PlotSngValRank-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..da2604552ac0d9784584a86d3e92015ad92dbe14 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSngValRank-swig.rst @@ -0,0 +1,33 @@ +PlotSngValRank (SWIG) +''''''''''''''''''''' + +.. function:: PlotSngValRank(Graph, SngVals, FNmPref, DescStr) + :noindex: + +Plots the rank distribution of singular values of the Graph adjacency matrix. Plots first *SngVals* values. The function creates three new files: 1) sngVal.<*FNmPref*>.plt (the commands used to create the plot), 2) sngVal.<*FNPref*>.png (the plot), and 3) sngVal.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py directed graph. + +- *SngVals*: int (input) + Number of largest singular values to plot. + +- *FNmPref*: string (input) + File name preference for the plotted graph. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the rank distribution of singular values of the Graph adjacency matrix for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotSngValRank(Graph, 100, "filename", "Singular Value Distribution") diff --git a/snap-python/source/doc/source/reference/PlotSngValRank.rst b/snap-python/source/doc/source/reference/PlotSngValRank.rst new file mode 100644 index 0000000000000000000000000000000000000000..f9a770826ec03a0d525e9f99619025139d3c9096 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSngValRank.rst @@ -0,0 +1,29 @@ +PlotSngValRank +'''''''''''''' + +.. function:: PlotSngValRank(SngVals, FNmPref, DescStr) + +A graph method for directed graphs that plots the rank distribution of singular values of the adjacency matrix. Plots first *SngVals* values. The function creates three new files: 1) sngVal.<*FNmPref*>.plt (the commands used to create the plot), 2) sngVal.<*FNPref*>.png (the plot), and 3) sngVal.<*FNmPref*>.tab (the plotting data). + +Parameters: + +- *SngVals*: int + Number of largest singular values to plot. + +- *FNmPref*: string + File name preference for the plotted graph. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the rank distribution of singular values of the Graph adjacency matrix for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotSngValRank(100, "filename", "Singular Value Distribution") diff --git a/snap-python/source/doc/source/reference/PlotSngVec-swig.rst b/snap-python/source/doc/source/reference/PlotSngVec-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..b28eee108f1eaa9fabd8391693770cdfa4959a47 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSngVec-swig.rst @@ -0,0 +1,30 @@ +PlotSngVec (SWIG) +''''''''''''''''' + +.. function:: PlotSngVec(Graph, FNmPref, DescStr) + :noindex: + +Ranks the values of the leading left singular vector of the graph adjacency matrix plots the first *SngVals* on a log-log chart. The function creates three new files: 1) sngVecL.<*FNmPref*>.plt (the plot), 2) sngVecL.<*FNPref*>.eps (the plotting description), and 3) sngVecL.<*FNmPref*>.tab (the tab separated plotting data). + +Parameters: + +- *Graph*: directed graph (input) + A Snap.py directed graph. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to use :func:`PlotSngVec` for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotSngVec(Graph, "my_filename", "my_chart_title") diff --git a/snap-python/source/doc/source/reference/PlotSngVec.rst b/snap-python/source/doc/source/reference/PlotSngVec.rst new file mode 100644 index 0000000000000000000000000000000000000000..b71dda4d399ca05e5bfb2091bb67bdd20b7e66c4 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotSngVec.rst @@ -0,0 +1,26 @@ +PlotSngVec +'''''''''' + +.. function:: PlotSngVec(FNmPref, DescStr) + +A graph method for directed graphs that ranks the values of the leading left singular vector of the adjacency matrix and then plots the first *SngVals* on a log-log chart. The function creates three new files: 1) sngVecL.<*FNmPref*>.plt (the plot), 2) sngVecL.<*FNPref*>.eps (the plotting description), and 3) sngVecL.<*FNmPref*>.tab (the tab separated plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to use :func:`PlotSngVec` for :class:`TNGraph`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotSngVec("my_filename", "my_chart_title") diff --git a/snap-python/source/doc/source/reference/PlotWccDistr-swig.rst b/snap-python/source/doc/source/reference/PlotWccDistr-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..796578eb47144abd9afbed0ea29fbbd6f5097847 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotWccDistr-swig.rst @@ -0,0 +1,36 @@ +PlotWccDistr (SWIG) +''''''''''''''''''' + +.. function:: PlotWccDistr(Graph, FNmPref, DescStr) + :noindex: + +Plots the distribution of sizes of weakly connected components of *Graph*. The function creates three new files: 1) wcc.<*FNmPref*>.plt (the plot), 2) wcc.<*FNPref*>.png (the plotting description), and 3) wcc.<*FNmPref*>.tab (the tab separated plotting data). + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *FNmPref*: string (input) + A string representing the preferred output file name. + +- *DescStr*: string (input) + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the distribution of sizes of weakly connected components for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PlotWccDistr(Graph, "example", "Directed graph - wcc distributaion") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PlotWccDistr(UGraph, "example", "Undirected graph - wcc distribution") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PlotWccDistr(Network, "example", "Network - wcc distribution") diff --git a/snap-python/source/doc/source/reference/PlotWccDistr.rst b/snap-python/source/doc/source/reference/PlotWccDistr.rst new file mode 100644 index 0000000000000000000000000000000000000000..a004467951be4488ff9b535e5e5fc4f0bf8e0527 --- /dev/null +++ b/snap-python/source/doc/source/reference/PlotWccDistr.rst @@ -0,0 +1,32 @@ +PlotWccDistr +'''''''''''' + +.. function:: PlotWccDistr(FNmPref, DescStr) + +A graph method that plots the distribution of sizes of weakly connected components of a graph. The function creates three new files: 1) wcc.<*FNmPref*>.plt (the plot), 2) wcc.<*FNPref*>.png (the plotting description), and 3) wcc.<*FNmPref*>.tab (the tab separated plotting data). + +Parameters: + +- *FNmPref*: string + A string representing the preferred output file name. + +- *DescStr*: string + Description of the graph. The string should be non-empty. + +Return value: + +- None + + +The following example shows how to plot the distribution of sizes of weakly connected components for :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PlotWccDistr("example", "Directed graph - wcc distribution") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PlotWccDistr("example", "Undirected graph - wcc distribution") + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PlotWccDistr("example", "Network - wcc distribution") diff --git a/snap-python/source/doc/source/reference/PrintInfo-swig.rst b/snap-python/source/doc/source/reference/PrintInfo-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..00bb4a98c47adbaeb6a70fff734d7cb24a819f71 --- /dev/null +++ b/snap-python/source/doc/source/reference/PrintInfo-swig.rst @@ -0,0 +1,45 @@ +PrintInfo (SWIG) +'''''''''''''''' + +.. function:: PrintInfo(Graph, Desc, OutFNm="", Fast=True) + :noindex: + +Prints basic *Graph* statistics to standard output or to a file named *OutFNm*. Additional extensive statistics which is computationally more expensive is computed when *Fast* is False. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *Desc*: string (input) + Graph description. Do not provide an empty string "" for this parameter, it might cause your program to crash. + +- *OutFNm*: string (input) + Optional file name for output. If not specified, output is printed to standard output. Do not provide an empty string "" for this parameter, it might cause your program to crash. To print to standard output on Mac OS X or Linux, provide "/dev/stdout" as a file name. This method does not work on Windows. + + +- *Fast*: bool (input) + Optional flag specifing whether basic (True) or extended (False) statistics should be printed. Currently, it is not possible to have extended statistics printed out to standard output on Windows, since *OutFNm* must be non-empty, if specified. + +Return value: + +- None + + +The following example shows how to calculate graph statistics +for random graphs of type :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + # print extended statistics to file 'info-pngraph.txt' + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.PrintInfo(Graph, "Python type PNGraph", "info-pngraph.txt", False) + + # print basic statistics to file 'info-pungraph.txt' + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.PrintInfo(UGraph, "Python type PUNGraph", "info-pungraph.txt") + + # print basic statistics to standard output + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.PrintInfo(Network, "Python type PNEANet") + diff --git a/snap-python/source/doc/source/reference/PrintInfo.rst b/snap-python/source/doc/source/reference/PrintInfo.rst new file mode 100644 index 0000000000000000000000000000000000000000..4a26aed63466ef2248ad5aa3949618c7440eb8b1 --- /dev/null +++ b/snap-python/source/doc/source/reference/PrintInfo.rst @@ -0,0 +1,40 @@ +PrintInfo +''''''''' + +.. function:: PrintInfo(Desc, OutFNm="", Fast=True) + +A graph method that prints basic graph statistics to standard output or to a file named *OutFNm*. If *Fast* is False, then additional, computationally more expensive statistics is computed. + +Parameters: + +- *Desc*: string + Graph description. Do not provide an empty string "" for this parameter, it might cause your program to crash. + +- (optional) *OutFNm*: string + Optional file name for output. If not specified, output is printed to standard output. Do not provide an empty string "" for this parameter, it might cause your program to crash. To print to standard output on Mac OS X or Linux, provide "/dev/stdout" as a file name. Standard output does not work on Windows. + +- (optional) *Fast*: bool + Optional flag specifing whether basic (True) or extended (False) statistics should be printed. Currently, it is not possible to have extended statistics printed out to standard output on Windows, since *OutFNm* must be non-empty, if specified. + +Return value: + +- None + + +The following example shows how to calculate graph statistics +for random graphs of type :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + # print extended statistics to file 'info-pngraph.txt' + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.PrintInfo("Python type TNGraph", "info-pngraph.txt", False) + + # print basic statistics to file 'info-pungraph.txt' + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.PrintInfo("Python type TUNGraph", "info-pungraph.txt") + + # print basic statistics to standard output + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.PrintInfo("Python type TNEANet") + diff --git a/snap-python/source/doc/source/reference/SaveEdgeList-swig.rst b/snap-python/source/doc/source/reference/SaveEdgeList-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..26fef84bd04422a5e385e97dc55e91bfedddd0be --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveEdgeList-swig.rst @@ -0,0 +1,37 @@ +SaveEdgeList (SWIG) +''''''''''''''''''' + +.. function:: SaveEdgeList(Graph, Filename, Description="") + :noindex: + +Saves lists of edges from a given graph into a file. Each line contains two columns and encodes a single edge. Creates a file named *Filename*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *Filename*: string (input) + The name of the file to save the graph to. + +- *Description*: string (input) + An optional description that will be written to the top of the file in a commented section. + +Return value: + +- None + + +The following example shows how to save edge lists with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.SaveEdgeList(Graph, 'mygraph.txt') + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.SaveEdgeList(UGraph, 'undirected_mygraph.txt') + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.SaveEdgeList(Network, 'network_mygraph.txt') diff --git a/snap-python/source/doc/source/reference/SaveEdgeList.rst b/snap-python/source/doc/source/reference/SaveEdgeList.rst new file mode 100644 index 0000000000000000000000000000000000000000..cf9f074f862f5937bb4525e65682684755ced7a5 --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveEdgeList.rst @@ -0,0 +1,33 @@ +SaveEdgeList +'''''''''''' + +.. function:: SaveEdgeList(Filename, Description="") + +A graph method that saves lists of edges from a given graph into a file. Each line contains two columns and encodes a single edge. Creates a file named *Filename*. + +Parameters: + +- *Filename*: string + The name of the file to save the graph to. + +- (optional) *Description*: string + A description that will be written to the top of the file in a commented section. + +Return value: + +- None + + +The following example shows how to save edge lists with +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.SaveEdgeList('mygraph.txt') + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.SaveEdgeList('undirected_mygraph.txt') + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.SaveEdgeList('network_mygraph.txt') diff --git a/snap-python/source/doc/source/reference/SaveGViz-swig.rst b/snap-python/source/doc/source/reference/SaveGViz-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..0d95be39c18598362b64622f46b8b4d89816f69c --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveGViz-swig.rst @@ -0,0 +1,52 @@ +SaveGViz (SWIG) +''''''''''''''' + +.. function:: SaveGViz(Graph, OutFNm, Desc, NodeLabels, NIdColorH) + :noindex: + +Saves *Graph* to the .DOT file format used by GraphViz. Use ".dot" as file extension for *OutFNm*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutFNm*: string (input) + Name of the output file. + +- *Desc*: string (input) + Description of the Graph. + +- *NodeLabels*: bool (input) + Indicates whether to show the node labels. + +- *NIdColorH*: :class:`TIntStrH`, a hash table with int keys and string values (input) + Maps node ids to node colors (see GraphViz documentation for more details). + +Return value: + +- None + +For more info about Graph Viz see: http://www.graphviz.org. + + +The following example shows how to save graphs of types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` for GraphViz:: + + import snap + + H = snap.TIntStrH() + H.AddDat(1, "blue") + H.AddDat(2, "blue") + H.AddDat(3, "red") + H.AddDat(4, "red") + + Graph = snap.GenRndGnm(snap.PNGraph, 4, 6) + snap.SaveGViz(Graph, "Graph1.dot", "Directed Random Graph", True, H) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 4, 6) + snap.SaveGViz(UGraph, "Graph2.dot", "Undirected Random Graph", True, H) + + Network = snap.GenRndGnm(snap.PNEANet, 4, 6) + snap.SaveGViz(Network, "Graph3.dot", "Directed Random Network with Attributes", True, H) + diff --git a/snap-python/source/doc/source/reference/SaveGViz.rst b/snap-python/source/doc/source/reference/SaveGViz.rst new file mode 100644 index 0000000000000000000000000000000000000000..be08cc2dc1f7dd797a0d19ec02a964655209f47d --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveGViz.rst @@ -0,0 +1,40 @@ +SaveGViz +'''''''' + +.. function:: SaveGViz(OutFNm, Desc, Labels) + +A graph method that saves a graph to the .DOT file format used by GraphViz. Use ".dot" as file extension for *OutFNm*. + +Parameters: + +- *OutFNm*: string + Name of the output file. + +- *Desc*: string + Description of the Graph. + +- *Labels*: Python dictionary or :class:`TIntStrH`, a hash table with int keys and string values + Maps node ids to node string labels. + +Return value: + +- None + +For more info about Graph Viz see: http://www.graphviz.org. + + +The following example shows how to save graphs of types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` for GraphViz:: + + import snap + + Labels = { 0: "zero", 1: "one", 2: "two", 3: "three" } + + Graph = snap.GenRndGnm(snap.TNGraph, 4, 6) + Graph.SaveGViz("graph1.dot", "Graph file", Labels) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 4, 6) + UGraph.SaveGViz("graph2.dot", "Graph file", Labels) + + Network = snap.GenRndGnm(snap.TNEANet, 4, 6) + Network.SaveGViz("graph3.dot", "Graph file", Labels) diff --git a/snap-python/source/doc/source/reference/SaveGViz1-swig.rst b/snap-python/source/doc/source/reference/SaveGViz1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..204e039c9939a694847104d31473714c6e2d9068 --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveGViz1-swig.rst @@ -0,0 +1,60 @@ +SaveGViz (SWIG) +''''''''''''''' + +.. function:: SaveGViz(Graph, OutFNm, Desc, NIdLabelH) + :noindex: + +Saves *Graph* to the .DOT file format used by GraphViz. Use ".dot" as file extension for *OutFNm*. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutFNm*: string (input) + Name of the output file. + +- *Desc*: string (input) + Description of the Graph. + +- *NIdLabelH*: :class:`TIntStrH`, a hash table with int keys and string values (input) + Maps node ids to node string labels. + +Return value: + +- None + +For more info about Graph Viz see: http://www.graphviz.org. + + +The following example shows how to save graphs of types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` for GraphViz:: + + import snap + + Graph = snap.TNGraph.New() + Graph.AddNode(1) + Graph.AddNode(2) + Graph.AddEdge(1, 2) + NIdLabelH = snap.TIntStrH() + NIdLabelH.AddDat(1, "one") + NIdLabelH.AddDat(2, "two") + snap.SaveGViz(Graph, "graph1.dot", "Graph file", NIdLabelH) + + UGraph = snap.TUNGraph.New() + UGraph.AddNode(1) + UGraph.AddNode(2) + UGraph.AddEdge(1, 2) + NIdLabelH = snap.TIntStrH() + NIdLabelH.AddDat(1, "one") + NIdLabelH.AddDat(2, "two") + snap.SaveGViz(UGraph, "graph2.dot", "Graph file", NIdLabelH) + + Network = snap.TNEANet.New() + Network.AddNode(1) + Network.AddNode(2) + Network.AddEdge(1, 2) + NIdLabelH = snap.TIntStrH() + NIdLabelH.AddDat(1, "one") + NIdLabelH.AddDat(2, "two") + snap.SaveGViz(Network, "graph3.dot", "Graph file", NIdLabelH) diff --git a/snap-python/source/doc/source/reference/SaveGVizColor.rst b/snap-python/source/doc/source/reference/SaveGVizColor.rst new file mode 100644 index 0000000000000000000000000000000000000000..5837b4052f2eb5ee871014a3a271cdbb4514d352 --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveGVizColor.rst @@ -0,0 +1,44 @@ +SaveGVizColor +''''''''''''' + +.. function:: SaveGVizColor(OutFNm, Desc, Labels, Colors) + +A graph method that saves a graph to the .DOT file format used by GraphViz. Use ".dot" as file extension for *OutFNm*. + +Parameters: + +- *OutFNm*: string + Name of the output file. + +- *Desc*: string + Description of the Graph. + +- *Labels*: bool + Indicates whether to show the node labels. + +- *Colors*: Python dictionary or :class:`TIntStrH`, a hash table with int keys and string values + Maps node ids to node colors (see GraphViz documentation for more details). + +Return value: + +- None + +For more info about GraphViz see: http://www.graphviz.org. + + +The following example shows how to save graphs of types +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` for GraphViz:: + + import snap + + Colors = { 0: "blue", 1: "blue", 2: "red", 3: "red" } + + Graph = snap.GenRndGnm(snap.TNGraph, 4, 6) + Graph.SaveGVizColor("Graph1.dot", "Directed Random Graph", True, Colors) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 4, 6) + UGraph.SaveGVizColor("Graph2.dot", "Undirected Random Graph", True, Colors) + + Network = snap.GenRndGnm(snap.TNEANet, 4, 6) + Network.SaveGVizColor("Graph3.dot", "Directed Random Network with Attributes", True, Colors) + diff --git a/snap-python/source/doc/source/reference/SaveMatlabSparseMtx-swig.rst b/snap-python/source/doc/source/reference/SaveMatlabSparseMtx-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..87c1512c4cd4ce4efbaefadd3d564a93332b4db7 --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveMatlabSparseMtx-swig.rst @@ -0,0 +1,34 @@ +SaveMatlabSparseMtx (SWIG) +'''''''''''''''''''''''''' + +.. function:: SaveMatlabSparseMtx(Graph, OutFNm) + :noindex: + +Saves a graph in a MATLAB sparse matrix format. + +Each line contains a tuple of 3 values: 1. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutFNm*: string (input) + Name of the output file. + +Return value: + +- None + +The following example shows how to save a graph of type :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` in a MATLAB sparse matrix format:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 1000, 500) + snap.SaveMatlabSparseMtx(Graph, "TNGraph.mat") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 1000, 500) + snap.SaveMatlabSparseMtx(UGraph, "TUNGraph.mat") + + Network = snap.GenRndGnm(snap.PNEANet, 1000, 500) + snap.SaveMatlabSparseMtx(Network, "TNEANet.mat") diff --git a/snap-python/source/doc/source/reference/SaveMatlabSparseMtx.rst b/snap-python/source/doc/source/reference/SaveMatlabSparseMtx.rst new file mode 100644 index 0000000000000000000000000000000000000000..7d7b75d02d678ce4ec384788df8316ba141d78f1 --- /dev/null +++ b/snap-python/source/doc/source/reference/SaveMatlabSparseMtx.rst @@ -0,0 +1,30 @@ +SaveMatlabSparseMtx +''''''''''''''''''' + +.. function:: SaveMatlabSparseMtx(OutFNm) + +A graph method that saves a graph in a MATLAB sparse matrix format. + +Each line contains a tuple of 3 values: 1. + +Parameters: + +- *OutFNm*: string + Name of the output file. + +Return value: + +- None + +The following example shows how to save a graph of type :class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet` in a MATLAB sparse matrix format:: + + import snap + + Graph = snap.GenRndGnm(snap.TNGraph, 1000, 500) + Graph.SaveMatlabSparseMtx("TNGraph.mat") + + UGraph = snap.GenRndGnm(snap.TUNGraph, 1000, 500) + UGraph.SaveMatlabSparseMtx("TUNGraph.mat") + + Network = snap.GenRndGnm(snap.TNEANet, 1000, 500) + Network.SaveMatlabSparseMtx("TNEANet.mat") diff --git a/snap-python/source/doc/source/reference/SavePajek-swig.rst b/snap-python/source/doc/source/reference/SavePajek-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..87be1de89ee463aa1abdd8035c0efcc6cf707eca --- /dev/null +++ b/snap-python/source/doc/source/reference/SavePajek-swig.rst @@ -0,0 +1,36 @@ +SavePajek (SWIG) +'''''''''''''''' + +.. function:: SavePajek(Graph, OutFNm) + :noindex: + +Saves a graph in Pajek .NET format. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutFNm*: string (input) + Specifies output filename of Pajek formatted graph. + +Return value: + +- None + +For additional information see http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf + + +The following example shows how to create a Pajek files for nodes in +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.SavePajek(Graph, "Pajek_Graph1.out") + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.SavePajek(UGraph, "Pajek_Graph2.out") + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.SavePajek(Network, "Pajek_Graph3.out") diff --git a/snap-python/source/doc/source/reference/SavePajek.rst b/snap-python/source/doc/source/reference/SavePajek.rst new file mode 100644 index 0000000000000000000000000000000000000000..ad265e7e241f6a790223203d932956399c2c8fed --- /dev/null +++ b/snap-python/source/doc/source/reference/SavePajek.rst @@ -0,0 +1,57 @@ +SavePajek +''''''''' + +.. function:: SavePajek (Graph, OutFNm, NIdColorH = None, NIdLabelH = None, EIdColorH = None) + +A graph method that saves a graph in a Pajek .NET format. + +Parameters: + +- *Graph*: graph + A Snap.py graph or a network. + +- *OutFNm*: string + Specifies output filename of Pajek formatted graph. + +- (optional) *NIdColorH*: Python dictionary or :class:`TIntStrH`, a hash table of int keys and string values + Maps node ids to node colors. Default node color is Red. + +- (optional) *NIdLabelH*: Python dictionary or :class:`TIntStrH`, a hash table of int keys and string values + Maps node ids to node string labels. + +- (optional) *EIdColorH*: Python dictionary or :class:`TIntStrH`, a hash table of int keys and string values + Maps edge ids to node colors. Default edge color is black. + +Return value: + +- None + +For additional information see http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf + + +The following example saves the graph in the Pajek format in: +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NIdColorH = {} + for i in range(100): + if i % 2 == 0: + NIdColorH[i] = "red" + else: + NIdColorH[i] = "blue" + NIdLabelH = {} + for i in range(100): + NIdLabelH[i] = str(i) + EIdColorH = {} + for i in range(1000): + EIdColorH[i] = "red" + + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + Graph.SavePajek("Pajek_Graph1.out", NIdColorH, NIdLabelH, EIdColorH) + + UGraph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + UGraph.SavePajek("Pajek_Graph2.out", NIdColorH, NIdLabelH, EIdColorH) + + Network = snap.GenRndGnm(snap.TNEANet, 100, 1000) + Network.SavePajek("Pajek_Graph3.out", NIdColorH, NIdLabelH, EIdColorH) diff --git a/snap-python/source/doc/source/reference/SavePajek1-swig.rst b/snap-python/source/doc/source/reference/SavePajek1-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..e88716f04c0fb90d3960808f4a8ba4c4e3456b95 --- /dev/null +++ b/snap-python/source/doc/source/reference/SavePajek1-swig.rst @@ -0,0 +1,46 @@ +SavePajek (SWIG) +'''''''''''''''' + +.. function:: SavePajek(Graph, OutFNm, NIdColorH) + :noindex: + +Saves the *Graph* in a Pajek .NET format + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutFNm*: string (input) + Specifies output filename of Pajek formatted graph. + +- *NIdColorH*: :class:`TIntStrH`, a hash table of int keys and string values (input) + Maps node ids to node colors. Default node color is Red. + +Return value: + +- None + +For additional information see http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf + + +The following example saves the graph in the Pajek format in: +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NIdColorH = snap.TIntStrH() + for i in range(100): + if i % 2 == 0: + NIdColorH[i] = "red" + else: + NIdColorH[i] = "blue" + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.SavePajek(Graph, "Pajek_Graph1.out", NIdColorH) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.SavePajek(UGraph, "Pajek_Graph2.out", NIdColorH) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.SavePajek(Network, "Pajek_Graph3.out", NIdColorH) diff --git a/snap-python/source/doc/source/reference/SavePajek2-swig.rst b/snap-python/source/doc/source/reference/SavePajek2-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..8b9470ce19eda8dc86494146fe7b87f4f6ee9f98 --- /dev/null +++ b/snap-python/source/doc/source/reference/SavePajek2-swig.rst @@ -0,0 +1,52 @@ +SavePajek (SWIG) +'''''''''''''''' + +.. function:: SavePajek(Graph, OutFNm, NIdColorH, NIdLabelH) + :noindex: + +Saves a graph in a Pajek .NET format. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutFNm*: string (input) + Specifies output filename of Pajek formatted graph. + +- *NIdColorH*: :class:`TIntStrH`, a hash table of int keys and string values (input) + Maps node ids to node colors. Default node color is Red. + +- *NIdLabelH*: :class:`TIntStrH`, a hash table of int keys and string values (input) + Maps node ids to node string labels. + +Return value: + +- None + +For additional information see http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf + + +The following example saves the graph in the Pajek format in: +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NIdColorH = snap.TIntStrH() + for i in range(100): + if i % 2 == 0: + NIdColorH[i] = "red" + else: + NIdColorH[i] = "blue" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.SavePajek(Graph, "Pajek_Graph1.out", NIdColorH, NIdLabelH) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.SavePajek(UGraph, "Pajek_Graph2.out", NIdColorH, NIdLabelH) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.SavePajek(Network, "Pajek_Graph3.out", NIdColorH, NIdLabelH) diff --git a/snap-python/source/doc/source/reference/SavePajek3-swig.rst b/snap-python/source/doc/source/reference/SavePajek3-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..bf43a488531941d39e9f3bccca719e16de5183f9 --- /dev/null +++ b/snap-python/source/doc/source/reference/SavePajek3-swig.rst @@ -0,0 +1,58 @@ +SavePajek (SWIG) +'''''''''''''''' + +.. function:: SavePajek (Graph, OutFNm, NIdColorH, NIdLabelH, EIdColorH) + :noindex: + +Saves a graph in a Pajek .NET format. + +Parameters: + +- *Graph*: graph (input) + A Snap.py graph or a network. + +- *OutFNm*: string (input) + Specifies output filename of Pajek formatted graph. + +- *NIdColorH*: :class:`TIntStrH`, a hash table of int keys and string values (input) + Maps node ids to node colors. Default node color is Red. + +- *NIdLabelH*: :class:`TIntStrH`, a hash table of int keys and string values (input) + Maps node ids to node string labels. + +- *EIdColorH*: :class:`TIntStrH`, a hash table of int keys and string values (input) + Maps edge ids to node colors. Default edge color is black. + +Return value: + +- None + +For additional information see http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/pajekman.pdf + + +The following example saves the graph in the Pajek format in: +:class:`TNGraph`, :class:`TUNGraph`, and :class:`TNEANet`:: + + import snap + + NIdColorH = snap.TIntStrH() + for i in range(100): + if i % 2 == 0: + NIdColorH[i] = "red" + else: + NIdColorH[i] = "blue" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + EIdColorH = snap.TIntStrH() + for i in range(1000): + EIdColorH[i] = "red" + + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + snap.SavePajek(Graph, "Pajek_Graph1.out", NIdColorH, NIdLabelH, EIdColorH) + + UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + snap.SavePajek(UGraph, "Pajek_Graph2.out", NIdColorH, NIdLabelH, EIdColorH) + + Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) + snap.SavePajek(Network, "Pajek_Graph3.out", NIdColorH, NIdLabelH, EIdColorH) diff --git a/snap-python/source/doc/source/reference/anf.rst b/snap-python/source/doc/source/reference/anf.rst new file mode 100644 index 0000000000000000000000000000000000000000..b65d956b2546816da928568b0b8342496a74a3cd --- /dev/null +++ b/snap-python/source/doc/source/reference/anf.rst @@ -0,0 +1,12 @@ + +Approximate Neighborhood +```````````````````````` + +.. toctree:: + :maxdepth: 2 + + GetAnfNode + GetAnfGraph + GetAnfEffDiam1 + GetAnfEffDiam + diff --git a/snap-python/source/doc/source/reference/attr.rst b/snap-python/source/doc/source/reference/attr.rst new file mode 100644 index 0000000000000000000000000000000000000000..94db303d0a9daec2a10209516cc8b6778865cffc --- /dev/null +++ b/snap-python/source/doc/source/reference/attr.rst @@ -0,0 +1,149 @@ +Sparse Attributes +````````````````` + +SNAP offers the following classes for handling sparse attributes: :class:`TAttr` for +when keys are integers and :class:`TAttrPair` for when keys are a pair of integers. +These classes use hash tables to organize and store integer, float, and string +attributes. + +**NOTE:** Sparse attributes are still under development in python. + + +TAttr +===== + +.. class:: TAttr() + TAttr(SIn) + TAttr(Attrs) + + Returns a data structure for tracking sparse attributes, where the keys are integers. + If *SIn* is specified, the data structure is loaded from the binary stream. If *Attrs* + is specified, the contents of *Attrs* are copied into the new sparse attribute data + structure. + + All the attribute related functions return an integer indicating whether there were + any errors during execution. Below is a list of functions supported by the + :class:`TAttr` class: + + .. describe:: Save() + + Saves the attributes to a (binary) stream SOut. + + .. describe:: Clr() + + Clears the contents of the attribute map. + + .. describe:: AddSAttrDat(Id, AttrName, Val) + AddSAttrDat(Id, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + integer id *Id*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDat(Id, AttrName, Val) + GetSAttrDat(Id, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + integer id *Id*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDat(Id, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + integer id *Id*. + + .. describe:: DelSAttrId(Id) + + Delete all attributes for the given integer id *Id*. + + .. describe:: GetSAttrV(Id, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given integer id *Id*. + *AttrType* should be one of IntType, FltType, or StrType. + + .. describe:: GetIdVSAttr(AttrName, IdV) + GetIdVSAttr(AttrId, IdV) + + Get a list of all ids that have an attribute with name *AttrName* or id + *AttrId*. + + .. describe:: AddSAttr(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrId(Name, AttrId, AttrType) + + Given the attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrName(AttrId, Name, AttrType) + + Given the attribute id *AttrId*, get the attribute name. + + +TAttrPair +========= + +.. class:: TAttrPair() + TAttrPair(SIn) + TAttrPair(Attrs) + + Returns a data structure for tracking sparse attributes, where the keys are integer pairs. + If *SIn* is specified, the data structure is loaded from the binary stream. If *Attrs* + is specified, the contents of *Attrs* are copied into the new sparse attribute data + structure. + + All the attribute related functions return an integer indicating whether there were + any errors during execution. Below is a list of functions supported by the + :class:`TAttrPair` class: + + .. describe:: Save() + + Saves the attributes to a (binary) stream SOut. + + .. describe:: Clr() + + Clears the contents of the attribute map. + + .. describe:: AddSAttrDat(Id, AttrName, Val) + AddSAttrDat(Id, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + integer pair id *Id*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDat(Id, AttrName, Val) + GetSAttrDat(Id, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + integer pair id *Id*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDat(Id, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + integer pair id *Id*. + + .. describe:: DelSAttrId(Id) + + Delete all attributes for the given integer pair id *Id*. + + .. describe:: GetSAttrV(Id, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given integer pair + id *Id*. *AttrType* should be one of IntType, FltType, or StrType. + + .. describe:: GetIdVSAttr(AttrName, IdV) + GetIdVSAttr(AttrId, IdV) + + Get a list of all ids that have an attribute with name *AttrName* or id + *AttrId*. + + .. describe:: AddSAttr(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrId(Name, AttrId, AttrType) + + Given the attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrName(AttrId, Name, AttrType) + + Given the attribute id *AttrId*, get the attribute name. diff --git a/snap-python/source/doc/source/reference/basic.rst b/snap-python/source/doc/source/reference/basic.rst new file mode 100644 index 0000000000000000000000000000000000000000..a99ece6962bd92f602190fba19d8fff687de4ed3 --- /dev/null +++ b/snap-python/source/doc/source/reference/basic.rst @@ -0,0 +1,641 @@ +Basic Types +``````````` + +Basic types in SNAP are :class:`TInt`, :class:`TFlt`, and :class:`TStr`, which +in Snap.py are automatically converted to Python types +:class:`int`, :class:`float`, and :class:`str`, respectively. In general, +there is no need to explicitly work with SNAP types in Snap.py because +of the automatic conversion. + + +TInt +==== + +.. class:: TInt() + TInt(val) + TInt(SIn) + + Returns a new :class:`TInt` initialized with the value specified by optional parameter + *val*. If no value is given, the :class:`TInt` object is initialized with the default value 0. If *SIn* is provided, the value is loaded from the binary stream *SIn*. + In Snap.py, :class:`TInt` is automatically converted to Python type :class:`int`. + + Below is a list of functions supported by the :class:`TInt` class: + + + .. describe:: Load(SIn) + + Loads the int from a binary stream *SIn*. + + .. describe:: Save(SOut) + + Saves the int to a binary stream *SOut*. + + .. describe:: Abs(val) + + A static method that returns the absolute value of *val*, an int. + + .. describe:: GetHexStr(val) + + A static method that returns a string with the hexidecimal representation of int *val*. + + .. describe:: GetInRng(val, min, max) + + A static method that returns int *val* if it is between *min* and *max*. If + *val* is smaller than *min*, it returns *min*. If *val* is larger than *max*, + it returns *max*. + + .. describe:: GetKiloStr(val) + + A static method that returns the int *val* as a kilo-formatted string. If *val* + is less than 1000, it returns *val* as a string. If *val* is greater than or + equal to 1000, it returns a string in form of 'x.yK', where x is some digit + from 1-9 and y from 0-9. + + .. describe:: GetMegaStr(val) + + A static method that returns the int *val* as a mega-formatted string. If + *val* is less than 1000000, it returns the equivalent of *GetKiloStr(val)*. + If *val* is greater than or equal to 1000000, it returns a string in the form + of 'x.yM', where x is some digit from 1-9 and y from 0-9. + + .. describe:: GetMemUsed() + + Returns the size in bytes. + + .. describe:: GetMn(val1, val2) + GetMn(val1, val2, val3) + GetMn(val1, val2, val3, val4) + + A static method that returns the minimum of the ints passed in as parameters. + + .. describe:: GetMx(val1, val2) + GetMx(val1, val2, val3) + GetMx(val1, val2, val3, val4) + + A static method that returns the maximum of the ints passed in as parameters. + + .. describe:: GetPrimHashCd() + + Returns the value stored in the int. + + .. describe:: GetRnd(range=0) + + A static method that returns a random int between 0 and *range*-1, inclusive. + If a *range* value of 0 is specified, it returns a random int between 0 and + INT_MAX. The default value of *range* is 0. + + .. describe:: GetSecHashCd() + + Returns the value stored in the int divided by 0x10. + + .. describe:: IsEven(val) + + A static method that returns a bool indicating whether *val* is even. + + .. describe:: IsOdd(val) + + A static method that returns a bool indicating whether *val* is odd. + + .. describe:: Sign(val) + + A static method that returns 1 if *val* > 0, -1 if *val* < 0, and 0 if + *val* == 0. + + + A single public attribute is offered by the :class:`TInt` class: + + .. describe:: Val + + A member of the :class:`TInt` object of type int that gives the value the int holds. + + + A few static public attributes are offered by the :class:`TInt` class: + + .. data:: Mn + + The minimum value of an signed int, equivalent to INT_MIN in C++. + + .. data:: Mx + + The maximum value of an signed int, equivalent to INT_MAX in C++. + + .. data:: Kilo + + Equal to 1024. + + .. data:: Mega + + Equal to 1024*1024. + + .. data:: Giga + + Equal to 1024*1024*1024. + + .. data:: Rnd + + The :class:`TRnd` object used in methods such as :func:`GetRnd`. + + Below is some code demonstrating the use of the :class:`TInt` type: + + >>> i = snap.TInt(10) + >>> print(i.Val) + 10 + >>> i.Val = 21 + >>> snap.TInt.IsEven(5) + False + >>> snap.TInt.GetMegaStr(1234567) + '1.2M' + +TFlt +==== + +.. class:: TFlt() + TFlt(val) + TFlt(SIn) + + Returns a new :class:`TFlt` initialized with the value specified by optional parameter + val. If no value is given, the :class:`TFlt` object is initialized with the default value 0. If *SIn* is provided, the value is loaded from the binary stream *SIn*. + In Snap.py, :class:`TFlt` is automatically converted to Python type :class:`float`. + + Below is a list of functions supported by the :class:`TFlt` class: + + .. describe:: Load(SIn) + + Loads the float from a binary stream *SIn*. + + .. describe:: Save(SOut) + + Saves the float to a binary stream *SOut*. + + .. describe:: Abs(val) + + A static method that returns the absolute value of *val*, a float. + + .. describe:: GetInRng(val, min, max) + + A static method that returns float *val* if it is between *min* and *max*. + If *val* is smaller than *min*, it returns *min*. If *val* is larger than + *max*, it returns *max*. + + .. describe:: GetKiloStr(val) + + A static method that returns the float *val* as a kilo-formatted string. If + *val* is less than 1000, it rounds *val* to the nearest int, and returns it + as a string. If *val* is greater than or equal to 1000, it returns a string in form of 'x.yK', where x is some digit from 1-9 and y from 0-9. + + .. describe:: GetMegaStr(val) + + A static method that returns the float *val* as a mega-formatted string. If + *val* is less than 1000000, it returns the equivalent of *GetKiloStr(val)*. + If *val* is greater than or equal to 1000000, it returns a string in the form of + 'x.yM', where x is some digit from 1-9 and y from 0-9. + + .. describe:: GetGigaStr(val) + + A static method that returns the float *val* as a giga-formatted string. If + *val* is less than 1000000000, it returns the equivalent of *GetMegaStr(val)*. + If *val* is greater than or equal to 1000000000, it returns a string in the + form of 'x.yG', where x is some digit from 1-9 and y from 0-9. + + .. describe:: GetMemUsed() + + Returns the size in bytes. + + .. describe:: GetMn(val1, val2) + GetMn(val1, val2, val3) + GetMn(val1, val2, val3, val4) + + A static method that returns the minimum of the floats passed in as parameters. + + .. describe:: GetMx(val1, val2) + GetMx(val1, val2, val3) + GetMx(val1, val2, val3, val4) + + A static method that returns the maximum of the floats passed in as parameters. + + .. describe:: GetPrimHashCd() + + Returns the primary hash code for the float object. + + .. describe:: GetRnd() + + A static method that returns a random int between 0 and 1. + + .. describe:: GetSecHashCd() + + Returns the secondary hash code for the float object. + + .. describe:: IsNum() + IsNum(val) + + A method that returns a bool indicating whether *val* is a valid numner. If *val* + is not provided, it returns a bool indicating whether this float is a valid number. + + .. describe:: IsNaN() + IsNaN(val) + + A static method that returns a bool indicating whether *val* is NaN, not a + number. If *val* is not provided, it returns a bool indicating whether this float + is NaN. + + .. describe:: Sign(val) + + A static method that returns 1 if *val* > 0, -1 if *val* < 0, and 0 if + *val* == 0. + + .. describe:: Round(val) + + A static method that returns *val* rounded to the nearest int. + + .. describe:: Eq6(val1, val2) + + A static method that returns whether *val1* and *val2* are equal to 6 decimal + places. + + + A single public attribute is offered by the :class:`TFlt` class: + + .. describe:: Val + + A member of the :class:`TFlt` object of type int that gives the value. + + + A few static public attributes are offered by the :class:`TFlt` class: + + .. data:: Mn + + The minimum value of a :class:`TFlt`, equivalent to -DBL_MAX in C++. + + .. data:: Mx + + The maximum value of a :class:`TFlt`, equivalent to DBL_MAX in C++. + + .. data:: NInf + + The value used to represent negative infinity, which is equivalent to Mn. + + .. data:: PInf + + The value used to represent positive infinity, which is equivalent to Mx. + + .. data:: Eps + + The epsilon value for the :class:`TFlt`, equal to 1e-16. + + .. data:: EpsHalf + + Equal to 1e-7. + + .. data:: Rnd + + The :class:`TRnd` object used in methods such as :func:`GetRnd`. + + + Below is some code demonstrating the use of the :class:`TFlt` type: + + >>> f = snap.TFlt(9.874) + >>> print(f.Val) + 9.874 + >>> f.Val = 2.1 + >>> f.IsNum() + True + >>> snap.TFlt.Round(1.234567) + 1 + +TStr +==== + +.. class:: TStr() + TStr(str) + TStr(SIn) + + Returns a new :class:`TStr` initialized with the value specified by optional parameter + *str*. If no value is given, the :class:`TStr` object is initialized with the empty string. If *SIn* is provided, the value is loaded from the binary stream *SIn*. + In Snap.py, :class:`TStr` is automatically converted to Python type :class:`str`. + + Below is a list of functions supported by the :class:`TStr` class: + + .. describe:: Load(SIn) + + Loads the string from a binary stream *SIn*. + + .. describe:: Save(SOut) + + Saves the string to a binary stream *SOut*. + + .. describe:: ChangeCh(orig, repl, start) + + Looks for the first instance of the character *orig* starting at index *start* + and replaces it with the character *repl*. Returns the index of the character + replaced. + + .. describe:: ChangeChAll(orig, repl, start) + + Looks for the all instances of the character *orig* starting at index *start* + and replaces them with the character *repl*. Returns the number of character + replaced. + + .. describe:: ChangeStr(orig, repl, start) + + Looks for the first instance of the string *orig* starting at index *start* + and replaces it with the string *repl*. Returns the starting index of the + string replaced. + + .. describe:: ChangeStrAll(orig, repl, start) + + Looks for the all instances of the string *orig* starting at index *start* and + replaces them with the string *repl*. Returns the number of replacements done. + + .. describe:: Clr() + + Sets the string to the empty string. + + .. describe:: CmpI(str) + + Compares the string to the parameter *str*, of type :class:`TStr`, character by character. + Returns a positive number if the string is greater than *str* and vice versa. + + .. describe:: CountCh(ch, start=0) + + Returns the number of times *ch* appears in the string, starting at position + *start*. + + .. describe:: CStr() + + Returns the string as a c-string, which is converted to a python :class:`str`. + + .. describe:: DelChAll(ch) + + Deletes all instances of the char *ch* from the string. + + .. describe:: DelStr(str) + + Deletes the first instance of *str* found in the string. Returns a bool + indicating whether anything was deleted. + + .. describe:: DelSubStr(start, end) + + Deletes the substring starting at position *start* and ending at position + *end* from the string. + + .. describe:: Empty() + + Returns a bool indicating whether the string is empty. + + .. describe:: Eql(str) + + Returns a bool indicating whether the string is equal to the :class:`TStr` *str*. + + .. describe:: FromHex() + + Converts the string from hex to the original string and returns the + resulting value. + + .. describe:: GetCap() + + Capitalizes the first letter of the contents of the string and returns the resulting + Python :class:`str`. + + .. describe:: GetCh(ChN) + + Returns the character at position *ChN*. + + .. describe:: GetFlt() + + Returns the contents of the string converted to a float. + + .. describe:: GetFromHex() + + Returns the string converted from hex as a Python :class:`str`. The contents of the + original string are left unchanged. + + .. describe:: GetHex() + + Returns the string converted to hex as a Python :class:`str`. The contents of the + original string are left unchanged. + + .. describe:: GetHexInt() + + Returns the contents of the string converted to an int, which is in decimal, not + hexadecimal format. + + .. describe:: GetHexInt64() + + Returns the contents of the string converted to a 64-bit int, which is in decimal, not + hexadecimal format. + + .. describe:: GetInt() + + Returns the contents of the string converted to an int. + + .. describe:: GetInt64() + + Returns the contents of the string converted to a 64-bit int. + + .. describe:: GetLc() + + Returns a Python :class:`str` with the contents of the string converted to lowercase. The + contents of the original string are left unchanged. + + .. describe:: GetMemUsed() + + Returns the size in bytes. + + .. describe:: GetPrimHashCd() + + Returns the primary hash code for the string. + + .. describe:: GetSecHashCd() + + Returns the secondary hash code for the string. + + .. describe:: GetSubStr(start) + GetSubStr(start, end) + + Returns a substring starting at position *start* and ending at position *end*, + inclusive. If *end* is not specified, the end position is assumed to be the + last character in the string. + + .. describe:: GetTrunc() + + Returns a Python :class:`str` with all the whitespace removed from the end of the contents of the string. + + .. describe:: GetUc() + + Returns a Python :class:`str` with the contents of the string converted to uppercase. The + contents of the original string are left unchanged. + + .. describe:: GetUInt() + + Returns the contents of the string converted to an unsigned int. + + .. describe:: GetUInt64() + + Returns the contents of the string converted to an unsigned 64-bit int. + + .. describe:: InsStr(pos, str) + + Inserts the contents of *str* (either a Python :class:`str` or a :class:`TStr`) into + the string at position *pos*. + + .. describe:: IsChIn(ch) + + Returns a bool indicating whether the character *ch* is in the string. + + .. describe:: IsFlt() + + Returns a bool indicating whether the contents of string is a valid float. + + .. describe:: IsHexInt() + + Returns a bool indicating whether the string is a valid hexadecimal int. + + .. describe:: IsHexInt64() + + Returns a bool indicating whether the string is a valid 64-bit hexadecimal int. + + .. describe:: IsInt() + + Returns a bool indicating whether the string is an int. + + .. describe:: IsInt64() + + Returns a bool indicating whether teh string is a 64-bit int. + + .. describe:: IsLc() + + Returns a bool indicating whether the string is lowercase. + + .. describe:: IsPrefix(prefix) + + Returns a bool indicating whether *prefix* is a prefix of the string. + + .. describe:: IsSuffix(suffix) + + Returns a bool indicating whether *suffix* is a suffix of the string. + + .. describe:: IsUc() + + Returns a bool indicating whether the string is uppercase. + + .. describe:: IsUInt() + + Returns a bool indicating whether the string is an unsigned int. + + .. describe:: IsUInt64() + + Returns a bool indicating whether the string is an unsigned 64-bit int. + + .. describe:: IsWord() + + Returns a bool indicating whether the contents of the string is a single word, which + is defined as a collection of letters and digits, starting with a letter. + + .. describe:: IsWs() + + Returns a bool indicating whether the content of the string is just whitespace. + + .. describe:: LastCh() + + Returns the last character in the string. + + .. describe:: Left(start) + + Returns the substring starting at position 0 to *start*-1. + + .. describe:: LeftOf(ch) + + Returns the substring left of the first instance of char *ch* in the string. + + .. describe:: LeftOfLast(ch) + + Returns the substring left of the last instance of char *ch* in the string. + + .. describe:: Len() + + Returns the length of the string. + + .. describe:: Mid(start) + Mid(start, numChars) + + Returns the Python :class:`str` starting at position *start* containing at most + *numChars* characters. If *numChars* is not specified, it returns the + substring starting at position *start* to the end of the string. + + .. describe:: PutCh(pos, ch) + + Replaces the character at position *pos* with character *ch*. + + .. describe:: Reverse() + + Returns a Python :class:`str` with the string reversed. + + .. describe:: Right(start) + + Returns the substring starting at position *start* to the end of the string. + + .. describe:: RightOf(ch) + + Returns the substring right of the first instance of char *ch* in the string. + + .. describe:: RightOfLast(ch) + + Returns the substring right of the last instance of char *ch* in the string. + + .. describe:: SearchCh(ch, start=0) + + Searches the string for the character *ch* starting at position *start* and + returns the index at which *ch* was found or -1 if it was not found. + + .. describe:: SearchChBack(ch, start=-1) + + Searches the string for the character *ch* starting at position *start* and + going backward. Returns the index at which the character was found or -1. A + *start* value of -1 indicates that the method should start searching at the + end of the string. + + .. describe:: SearchStr(str, start=0) + + Searches the string for the substring *str* starting at position *start* and + returns the index at which str was found or -1 if it was not found. + + .. describe:: Slice(start, numChars) + + Returns a substring of the string starting at position *start* containing + *numChars* characters. + + .. describe:: ToCap() + + Returns a Python :class:`str` with the first letter of the contents of the string capitalized. + + .. describe:: ToHex() + + Converts the string to hex and returns the resulting value. + + .. describe:: ToLc() + + Coverts the contents of the string to lowercase and returns the resulting string. + + .. describe:: ToTrunc() + + Removes the trailing whitespace from the contents of the string and returns the resulting + Python :class:`str`. + + .. describe:: ToUc() + + Coverts the contents of the string to uppercase and returns the resulting string. + + Below is some code demonstrating the use of the :class:`TStr` type: + + >>> s = snap.TStr('Welcome to Snap.py!') + >>> print(s.CStr()) + 'Welcome to Snap.py!' + >>> s.GetSubStr(0,6) + 'Welcome' + +.. note:: + + Do not use an empty string literal “” in Python, if a Snap.py + function parameter is of type :class:`TStr`. SNAP handling of TStr(“”) + is not compatible with Python, so an empty string literal will cause + an error. diff --git a/snap-python/source/doc/source/reference/bfsdfs.rst b/snap-python/source/doc/source/reference/bfsdfs.rst new file mode 100644 index 0000000000000000000000000000000000000000..6b5dab02195ac8a3dd8772af5d045fa698c71409 --- /dev/null +++ b/snap-python/source/doc/source/reference/bfsdfs.rst @@ -0,0 +1,20 @@ + +Breadth and Depth First Search +`````````````````````````````` + +.. toctree:: + :maxdepth: 2 + + GetBfsFullDiam + GetBfsEffDiam + GetBfsEffDiam1 + GetBfsEffDiamAll + GetNodesAtHop + GetNodesAtHops + GetShortPath + GetShortPathAll + GetBfsTree + GetTreeRootNId + GetTreeSig + GetTreeSig1 + diff --git a/snap-python/source/doc/source/reference/centr.rst b/snap-python/source/doc/source/reference/centr.rst new file mode 100644 index 0000000000000000000000000000000000000000..47b3214bdf11e6a174dc722dc9f5f16e0ed0f9a8 --- /dev/null +++ b/snap-python/source/doc/source/reference/centr.rst @@ -0,0 +1,16 @@ + +Node Centrality +``````````````` + +.. toctree:: + :maxdepth: 2 + + GetDegreeCentr + GetBetweennessCentr + GetClosenessCentr + GetFarnessCentr + GetPageRank + GetHits + GetNodeEcc + GetEigenVectorCentr + diff --git a/snap-python/source/doc/source/reference/cncom.rst b/snap-python/source/doc/source/reference/cncom.rst new file mode 100644 index 0000000000000000000000000000000000000000..dfd8e2f6cac093af323571df09625bfcf5940baa --- /dev/null +++ b/snap-python/source/doc/source/reference/cncom.rst @@ -0,0 +1,26 @@ + +Connected Components +```````````````````` + +.. toctree:: + :maxdepth: 2 + + GetSccs + GetSccSzCnt + GetWccs + GetWccSzCnt + GetMxBiCon + GetMxScc + GetMxSccSz + GetMxWcc + GetMxWccSz + IsConnected + IsWeaklyConn + GetNodeWcc + Get1CnCom + Get1CnComSzCnt + GetBiCon + GetBiConSzCnt + GetArtPoints + GetEdgeBridges + diff --git a/snap-python/source/doc/source/reference/community.rst b/snap-python/source/doc/source/reference/community.rst new file mode 100644 index 0000000000000000000000000000000000000000..2c287c7e270604a06dd0a2238db19907f4227bc9 --- /dev/null +++ b/snap-python/source/doc/source/reference/community.rst @@ -0,0 +1,12 @@ + +Community Detection +``````````````````` + +.. toctree:: + :maxdepth: 2 + + CommunityCNM + CommunityGirvanNewman + GetEdgesInOut + GetModularity + diff --git a/snap-python/source/doc/source/reference/composite.rst b/snap-python/source/doc/source/reference/composite.rst new file mode 100644 index 0000000000000000000000000000000000000000..e30ad2554b4a0c86407aec97d5d74856d70cadcc --- /dev/null +++ b/snap-python/source/doc/source/reference/composite.rst @@ -0,0 +1,1189 @@ +Composite Types +```````````````` + +Composite types in SNAP are :class:`TPair`, :class:`TVec`, :class:`THash`, and +:class:`THashSet`. + +TPair +===== + +The name :class:`TPair` refers to a general data structure that consists of two values, which can be of different types. All of the following methods are available for objects that are classified as :class:`TPair` objects. + +.. class:: TPair() + TPair(Val1, Val2) + TPair(SIn) + + + Creates a :class:`TPair` object consisting of the two values, if provided. If *Val1* and + *Val2* are not given, the default value for each of their respective types is used. + If *SIn* is provided, the pair of values are loaded from the binary stream *SIn*. + + The :class:`TPair` constructor cannot be directly called. To create a :class:`TPair` object, the correct + constructor must be chosen, which indicates the types of both the values in the pair. + The naming convention is as follows: `` of + the first object in the pair, `` for the second object in the pair + (without the `T`), and finally a `Pr`. If `` and `` are the + same, then the name may be condensed to `` followed by `Pr`. + + The following :class:`TPair` types are supported: :class:`TIntPr`, :class:`TFltPr`, + :class:`TIntStrPr`, :class:`TBoolFltPr`, :class:`TIntBoolPr`, :class:`TIntUInt64Pr`, + :class:`TIntIntPrPr`, :class:`TIntIntVPr`, :class:`TIntFltPr`, :class:`TIntStrVPr`, + :class:`TIntPrIntPr`, :class:`TUIntUIntPr`, :class:`TUIntIntPr`, :class:`TUInt64IntPr`, + :class:`TUInt64Pr`, :class:`TUint64FltPr`, :class:`TUInt64StrPr`, :class:`TFltIntPr`, + :class:`TFltUInt64Pr`, :class:`TFltStrPr`, :class:`TAscFltIntPr`, :class:`TAscFltPr`, + :class:`TAscFltStrPr`, :class:`TStrIntPr`, :class:`TStrFltPr`, :class:`TStrPr`, + :class:`TStrStrVPr`, :class:`TStrVIntPr`, :class:`TIntStrPrPr`, and :class:`TFltStrPrPr`. + + To illustrate, the following examples all return a :class:`TIntPr` with both values set to 0:: + + >>> snap.TIntPr(0, 0) + >>> snap.TIntPr(snap.TInt(0), snap.TInt(0)) + >>> snap.TIntPr() + + The following public functions are supported by the :class:`TPair` class: + + .. describe:: Load(SIn) + + Loads the pair from a binary stream *SIn*. + + .. describe:: Save(SOut) + + Saves the pair to a binary stream *SOut*. + + .. describe:: GetMemUsed() + + Returns the size of the :class:`TPair` object in bytes. + + .. describe:: GetVal1() + + Returns the first value in the :class:`TPair`. + + .. describe:: GetVal2() + + Returns the second value in the :class:`TPair`. + + .. describe:: GetPrimHashCd() + + Returns the primary hash code, which is computed using the primary hash codes of the two values in the pair. + + .. describe:: GetSecHashCd() + + Returns the secondary hash code, which is computed using the secondary hash codes of the two values in the pair. + + The following public attributes are available: + + .. describe:: Val1 + + The first value in the pair. Supports assignment, which requires the use of Snap.py types rather than Python types. + + .. describe:: Val2 + + The second value in the pair. Supports assignment, which requires the use of Snap.py types rather than Python types. + + + Below is some code demonstrating the use of the :class:`TPair` type: + + >>> pr = snap.TIntPr(10, 15) + >>> print(pr.Val1.Val) + 10 + >>> pr.Val1 = snap.TInt(21) + >>> print(pr.GetVal1()) + 21 + >>> pr.GetPrimHashCd() + 687 + +TVec +===== + +Vectors are sequences of values of the same type. Existing vector values can be accessed +or changed by their index in the sequence. New values can be added at the end of a +vector. All of the following methods are available for objects that are classified as +:class:`TVec` objects. + +.. class:: TVec() + TVec(NumVals) + TVec(MxVals, NumVals) + TVec(Vec) + TVec(SIn) + + + Creates a :class:`TVec` object of size *NumVals*, if specified. It *MxVals* is given, enough + memory to store *MxVals* will be reserved. MxVals must be larger than *NumVals*. If + *Vec* - a :class:`TVec` of the same type - is given, the values from *Vec* are copied into the + new :class:`TVec`. It *SIn* is provided, the contents of the vector are loaded from the binary stream *SIn*. + + The :class:`TVec` constructor cannot be directly called. To create a :class:`TVec` object, the correct + constructor must be chosen, which indicates the type stored in the :class:`TVec`. + Vector types in Snap.py and SNAP use a naming convention of being named as + ``, followed by `V`. For example, a vector of integers is named + :class:`TIntV`. + + The following :class:`TVec` types are supported: :class:`TIntV`, :class:`TFltV`, :class:`TIntPrV`, :class:`TFltPrV`, :class:`TIntTrV`, :class:`TIntFltKdV`, :class:`TBoolV`, :class:`TChV`, :class:`TUChV`, :class:`TUIntV`, :class:`TUInt64V`, :class:`TSFltV`, :class:`TAscFltV`, :class:`TStrV`, :class:`TChAV`, :class:`TIntQuV`, :class:`TFltTrV`, :class:`TUChIntPrV`, :class:`TUChUInt64PrV`, :class:`TIntUInt64PrV`, :class:`TIntUInt64KdV`, :class:`TIntFltPrV`, :class:`TIntFltPrKdV`, :class:`TFltIntPrV`, :class:`TFltUInt64PrV`, :class:`TFltStrPrV`, :class:`TAscFltStrPrV`, :class:`TIntStrPrV`, :class:`TIntIntStrTrV`, :class:`TIntIntFltTrV`, :class:`TIntFltIntTrV`, :class:`TIntStrIntTrV`, :class:`TIntKdV`, :class:`TUIntIntKdV`, :class:`TIntPrFltKdV`, :class:`TIntStrKdV`, :class:`TIntStrPrPrV`, :class:`TIntStrVPrV`, :class:`TIntIntVIntTrV`, :class:`TUInt64IntPrV`, :class:`TUInt64FltPrV`, :class:`TUInt64StrPrV`, :class:`TUInt64IntKdV`, :class:`TUInt64FltKdV`, :class:`TUInt64StrKdV`, :class:`TFltBoolKdV`, :class:`TFltIntKdV`, :class:`TFltUInt64KdV`, :class:`TFltIntPrKdV`, :class:`TFltKdV`, :class:`TFltStrKdV`, :class:`TFltStrPrPrV`, :class:`TFltIntIntTrV`, :class:`TFltFltStrTrV`, :class:`TAscFltIntPrV`, :class:`TAscFltIntKdV`, :class:`TStrPrV`, :class:`TStrIntPrV`, :class:`TStrIntKdV`, :class:`TStrFltKdV`, :class:`TStrAscFltKdV`, :class:`TStrTrV`, :class:`TStrQuV`, :class:`TStrFltFltTrV`, :class:`TStrStrIntTrV`, :class:`TStrKdV`, :class:`TStrStrVPrV`, :class:`TStrVIntPrV`, :class:`TFltIntIntIntQuV`, :class:`TIntStrIntIntQuV`, and :class:`TIntIntPrPrV`. + + To illustrate, the following examples show how to create a :class:`TVec`:: + + >>> snap.TIntV() + >>> snap.TIntV(5) + >>> v1 = snap.TIntV(8, 5) + >>> v1.append(1) + >>> v2 = snap.TIntV(v1) + >>> for val in v2: + ... print(val) + ... + 1 + + :class:`TVec` offers iterators of type :class:`TInt` for fast access through the vector. + The :class:`TInt` returned by any iterator method represents the value at a given index in the vector. + + The following public functions are Python list functions that are also supported by the :class:`TVec` classes: + .. describe:: V[Index] + + Returns the value at index *Index* in vector *v*. + + .. describe:: V[Index] = Value + + Set ``V[Index]`` to *Value*. + + .. describe:: del V[Index] + + Removes the value at index *index* from the vector. + + .. describe:: Val in V + + Returns ``True`` if *Val* is a value stored in vector *V*, else ``False``. + + .. describe:: Val not in V + + Equivalent to ``not Val in V``. + + .. describe:: append(Val) + + Appends *Val* to the end of the vector. + + .. describe:: len() + + Returns the length of the vector. + + .. describe:: delitem(Index) + + Deletes the value at index *Index* from the vector. + + .. describe:: extend(Vec) + + Appends the contents of another vector, *Vec*, to the end of the vector. + + .. describe:: clear() + + Clears the contents of the vector. + + .. describe:: insert(Index, Val) + + Inserts *Val* into the vector at index *Index*. + + .. describe:: remove(Val) + + Deletes the first instance of *Val* from the vector. If the value is not found, an error is thrown. + + .. describe:: index(Val) + + Returns the index of the first instance of *Val* in the vector. If the value is not found, an error is thrown. + + .. describe:: count(Val) + + Returns a count of the number of instances of *Val* in the vector. + + .. describe:: pop(Index) + + Deletes the contents of the vector at index *Index* and returns the value from that index. + + .. describe:: reverse() + + Reverses the contents of the vector. + + .. describe:: sort(asc=False) + + Sorts the vector. If *Asc* is true, sorts in ascending order; otherwise in descending order. + + .. describe:: copy() + + Returns a copy of the vector. + + + The following public functions are additional, SNAP-specific functions supported by the :class:`TVec` classes: + + .. iter(V) + + Returns an iterator over all the values in the vector. + + .. describe:: GetV(Val1) + GetV(Val1, Val2) + GetV(Val1, Val2, Val3) + GetV(Val1, Val2, Val3, Val4) + GetV(Val1, Val2, Val3, Val4, Val5) + GetV(Val1, Val2, Val3, Val4, Val5, Val6) + GetV(Val1, Val2, Val3, Val4, Val5, Val6, Val7) + GetV(Val1, Val2, Val3, Val4, Val5, Val6, Val7, Val8) + GetV(Val1, Val2, Val3, Val4, Val5, Val6, Val7, Val8, Val9) + + Returns a vector with the given values. + + .. describe:: Load(SIn) + + Loads a graph from a binary stream *SIn* and returns a pointer to it. + + .. describe:: Save(SOut) + + Saves the graph to a binary stream *SOut*. + + .. describe:: GetMemUsed() + + Returns the size of the vector object in bytes. + + .. describe:: GetPrimHashCd() + + Returns the primary hash code for the vector. + + .. describe:: GetSecHashCd() + + Returns the secondary hash code for the vector. + + .. describe:: Gen(Vals) + Gen(MxVals, Vals) + + Resizes the vector to hold *Vals* and initializes each position in the vector + with the default value for the given type of the vector (i.e. 0 for TInt). If + *MxVals* is provided, the function reserves enough memory for *MxVals* values in + the vector. + + .. describe:: Reserve(MxVals) + Reserve(MxVals, Vals) + + Reserves enough memory for *MxVals* values in the vector. If *Vals* is + provided, it resizes the vector to hold *NumVals* and initializes each position + in the vector with the default value for the given type of the vector. + + .. describe:: Clr() + + Clears the contents of the vector. + + .. describe:: Trunc(Vals=-1) + + Truncates the vector to length *Vals*. If *Vals* is not given, the vector + is left unchanged. + + .. describe:: Pack() + + The vector reduces its capacity (frees memory) to match its size. + + .. describe:: MoveFrom(Vec) + + Moves all the data from *Vec* into the current vector and changes its capacity to + match that of *Vec*. The contents and capacity of *Vec* are cleared in the process. + + .. describe:: Swap(Vec) + + Swaps the contents and the capacity of the current vector with *Vec*. + + .. describe:: Empty() + + Returns a bool indicating whether the vector is empty. + + .. describe:: Len() + + Returns the length of the vector. + + .. describe:: Reserved() + + Returns the reserved capacity for the vector. + + .. describe:: Last() + + Returns the last value in the vector. + + .. describe:: LastValN() + + Returns the index of the last value in the vector. + + .. describe:: LastLast() + + Returns the second to last element in the vector. + + .. describe:: BegI() + + Returns an iterator pointing to the first element in the vector. + + .. describe:: EndI() + + Returns an iterator referring to the past-the-end element in the vector. + + .. describe:: GetI(ValN) + + Returns an iterator an element at position *ValN*. + + .. describe:: Add() + Add(Val) + Add(Val, ResizeLen) + + Appends *Val* to the end of the vector. If *Val* is not specified, it adds an + element with the default value for the given type of the vector. Returns the + index at which the value was appended. If *ResizeLen* is given, it increases the + capacity of the vector by *ResizeLen*. + + .. describe:: AddV(ValV) + + Appends the contents of the vector *ValV* onto the vector. Returns the index of + the last element in the vector. + + .. describe:: AddSorted(Val, Asc=True) + + Adds *Val* to a sorted vector. If *Asc* is True, the vector is sorted in + ascending order. + + .. describe:: AddBackSorted(Val, Asc) + + Adds *Val* to a sorted vector. If *Asc* is True, the vector is sorted in + ascending order. + + .. describe:: AddMerged(Val) + + Adds element *Val* to a sorted vector only if the element *val* is not already + in the vector. Returns the index at which *val* was inserted or -1. + + .. describe:: AddVMerged(ValV) + + Adds elements of *ValV* to a sorted vector only if a particular element is not + already in the vector. Returns the new length of the vector. + + .. describe:: AddUnique(Val) + + Adds element *Val* to a vector only if the element *val* is not already in the + vector. Returns the index at which *val* was inserted or -1. + + .. describe:: GetVal(ValN) + + Returns the value at index *ValN*. + + .. describe:: SetVal(ValN, Val) + + Sets the value of the element at index *ValN* to *Val*. + + .. describe:: GetSubValV(BValN, EValN, vec) + + Fills *ValV* with the elements at positions *BValN* to *EValN*, inclusive, in this + vector. + + .. describe:: Ins(ValN, Val) + + Inserts the value *Val* into the vector before the element at position *ValN*. + + .. describe:: Del(ValN) + + Deletes the value at index *ValN*. + + .. describe:: Del(MnValN, MxValN) + + Deletes all elements from index *MnValN* to *MxValN*, inclusive. + + .. describe:: DelLast() + + Deletes the last element in the vector. + + .. describe:: DelIfIn(Val) + + Deletes the first instance of value *val* from the vector. Returns a boolean + indicating whether *Val* was found in the vector. + + .. describe:: DelAll(Val) + + Deletes all occurrences of *Val* from the vector. + + .. describe:: PutAll(Val) + + Sets all elements of the vector to value *Val*. + + .. describe:: Swap(ValN1, ValN2) + + Swaps elements at positions *ValN1* and *ValN2*. + + .. describe:: NextPerm() + + Generates next permutation of the elements in the vector. Returns a boolean + indicating whether the previous permutation is different from the original + permutation. + + .. describe:: GetPivotValN(LValN, RValN) + + Picks three random elements at positions *LValN* ... *RValN* and returns the + index of the middle one. + + .. describe:: BSort(MnLValN, MxRValN, Asc) + + Bubble sorts values in the portion of the vector starting at *MnLVal* and ending + at *MxRValN*. If *Asc* is True, it sorts the vector in ascending order. + + .. describe:: ISort(MnLValN, MxRValN, Asc) + + Insertion sorts the values in the portion of the vector starting at *MnLVal* and + ending at *MxRValN*. If *Asc* is True, it sorts the vector in ascending order. + + .. describe:: Partition(MnLValN, MxRValN, Asc) + + Partitions the values in the portion of the vector starting at *MnLVal* and + ending at *MxRValN*. If *Asc* is True, it partitions using ascending order. + + .. describe:: QSort(MnLValN, MxRValN, Asc) + + Quick sorts the values in the portion of the vector starting at *MnLVal* and + ending at *MxRValN*. If *Asc* is True, it sorts the vector in ascending order. + + .. describe:: Sort(Asc) + + Sorts the vector. If *Asc* is True, it sorts it in ascending order. + + .. describe:: IsSorted(Asc) + + Checks whether the vector is sorted in ascending (if *Asc* == True) or + descending (if *Asc* == False) order. + + .. describe:: Shuffle(Rnd) + + Shuffles the contents of the vector in random order, using the :class:`TRnd` object *Rnd*. + + .. describe:: Reverse() + + Reverses the contents of the vector. + + .. describe:: Reverse(LValN, RValN) + + Reverses the order of elements in the portion of the vector starting at index + *LValN* and ending at *RValN*. + + .. describe:: Merge() + + Sorts the vector and only keeps a single element of each value. + + .. describe:: Intrs(ValV) + + Updates this vector with the intersection of this vector with *ValV*. + + .. describe:: Union(ValV) + + Updates this vector with the union of this vector with *ValV*. + + .. describe:: Diff(ValV) + + Updates this vector with the difference of this vector with *ValV*. + + .. describe:: Intrs(ValV, DstValV) + + *DstValV* is the intersection of vectors this and *ValV*. + + .. describe:: Union(ValV, DstValV) + + *DstValV* is the union of vectors this and *ValV*. + + .. describe:: Diff(ValV, DstValV) + + *DstValV* is the difference of vectors this and *ValV*. + + .. describe:: IntrsLen(ValV) + + Returns the length of the intersection of this vector with *ValV*. + + .. describe:: UnionLen(ValV) + + Returns the length of the union of this vector with *ValV*. + + .. describe:: Count(Val) + + Returns the number of times *Val* appears in the vector. + + .. describe:: SearchBin(Val) + + Returns the index of an element with value *Val* or -1. + + .. describe:: SearchForw(Val, BValN=0) + + Returns the index of an element with value *Val* or -1. Starts looking at + index *BValN*. + + .. describe:: SearchBack(Val) + + Returns the index of an element wiht value *Val* or -1. + + .. describe:: SearchVForw(ValV, BValN=0) + + Returns the starting position of vector *ValV* or -1. Starts looking at + index *BValN*. + + .. describe:: IsIn(Val) + + Returns a bool checking whether element *Val* is a member of the vector. + + .. describe:: GetMxValN() + + Returns the position of the largest element in the vector. + + + + Below is some code demonstrating the use of the :class:`TVec` type: + + >>> vec1 = snap.TIntV.GetV(1, 2, 3, 4, 5, 6, 7, 8, 9) + >>> vec1.IsIn(5) + True + >>> vec2 = snap.TIntV(vec1) + >>> vec2.append(10) + >>> vec2.Diff(vec1) + >>> for val in vec2: + ... print(val) + ... + 10 + + +THash +===== + +Hash tables contain values of the same type. Each value has a user provided key associated with it. All the keys are of the same type. Table values can be accessed or changed through their keys. New values can be added as `(key, value)` pairs. All objects classified as :class:`THash` objects have access to the following methods. + +.. class:: THash() + THash(ExpectVals, AutoSizeP=False) + THash(Hash) + THash(SIn) + + + Creates a :class:`THash` object with a capacity of *ExpectVals*, if specified. If *Hash* - a + :class:`THash` of the same type - is given, the values from *Hash* are copied into the + new :class:`THash`. If *SIn* is provided, the contents of the hash table are loaded from the binary stream *SIn*. + + The :class:`THash` constructor cannot be directly called. To create a :class:`THash` object, the correct + constructor must be chosen, which indicates the types of the key and value in the :class:`THash`. Hash table types in Snap.py and SNAP use a naming convention of being named + as ``, followed by `H`. For example, a hash table + with integer key and string values is named :class:`TIntStrH`. If `` + and `` have the same type, only one type name might be used, such + as :class:`TIntH`. + + The following :class:`THash` types are supported: :class:`TIntH`, :class:`TIntIntH`, :class:`TIntFltH`, :class:`TIntStrH`, :class:`TIntPrFltH`, :class:`TUInt64H`, :class:`TIntBoolH`, :class:`TIntUInt64H`, :class:`TIntIntVH`, :class:`TIntIntHH`, :class:`TIntFltPrH`, :class:`TIntFltTrH`, :class:`TIntFltVH`, :class:`TIntStrVH`, :class:`TIntIntPrH`, :class:`TIntIntPrVH`, :class:`TUInt64StrVH`, :class:`TIntPrIntH`, :class:`TIntPrIntPrVH`, :class:`TIntTrIntH`, :class:`TIntVIntH`, :class:`TUIntH`, :class:`TIntPrIntVH`, :class:`TIntTrFltH`, :class:`TIntPrStrH`, :class:`TIntPrStrVH`, :class:`TIntStrPrIntH`, :class:`TFltFltH`, :class:`TStrH`, :class:`TStrBoolH`, :class:`TStrIntH`, :class:`TStrIntPrH`, :class:`TStrIntVH`, :class:`TStrUInt64H`, :class:`TStrUInt64VH`, :class:`TStrIntPrVH`, :class:`TStrFltH`, :class:`TStrFltVH`, :class:`TStrStrH`, :class:`TStrStrPrH`, :class:`TStrStrVH`, :class:`TStrStrPrVH`, :class:`TStrStrKdVH`, :class:`TStrIntFltPrH`, :class:`TStrStrIntPrVH`, :class:`TStrStrIntKdVH`, :class:`TStrPrBoolH`, :class:`TStrPrIntH`, :class:`TStrPrFltH`, :class:`TStrPrStrH`, :class:`TStrPrStrVH`, :class:`TStrTrIntH`, :class:`TStrIntPrIntH`, :class:`TStrVH`, :class:`TStrVIntVH`, :class:`TStrVStrH`, and :class:`TStrVStrVH`. + + + To illustrate, the following examples show how to create a :class:`THash` with each of the + constructors:: + + >>> snap.TIntH() + >>> h1 = snap.TIntH(5) + >>> h1[5] = 5 + >>> h2 = snap.TIntH(h1) + >>> for key in h2: + ... print(key, h2[key]) + ... + 5 5 + + :class:`THash` offers iterators of type :class:`THashKeyDatI` for fast access through + the hash table. + + The following public functions are Python dictionary functions that are also supported by the :class:`THash` classes: + + .. describe:: H[Key] + + Returns the value associated with the key *Key*. + + .. describe:: H[Key] = Value + + Set ``H[Key]`` to *Value*. + + .. describe:: del H[Key] + + Removes ``H[Key]`` from *H*. + + .. describe:: Key in H + + Returns ``True`` if *Key* is a key in hash table *H*, else ``False``. + + .. describe:: Key not in H + + Equivalent to ``not Key in H``. + + .. describe:: len(H) + + Returns the number of keys in the hash table. + + .. describe:: get(Key) + + Returns the value at the key *Key*. + + .. describe:: items() + + Returns a list of key, value pairs in the hash table. + + .. describe:: keys() + + Returns a list of the keys in the hash table. + + .. describe:: values() + + Returns a list of the values in the hash table. + + .. describe:: clear() + + Clears the contents of the hash table. + + .. describe:: copy() + + Copies the contents of the hash table. + + .. iter(H) + + Returns an iterator over all the keys in the hash table. + + .. describe:: pop(Key) + + Removes *Key* and its value from the hash table and returns its value. + + .. describe:: setdefault(Key, Default) + + If *Key* is present in the hash table, returns its value. Otherwise, creates a new entry *Key* in the hash table with value *Default* and returns *Default*. + + + The following public functions are additional, SNAP-specific functions supported by the :class:`THash` classes: + + .. describe:: Load(SIn) + + Loads the hash table from a binary stream *SIn*. + + .. describe:: Save(SOut) + + Saves the hash table to a binary stream *SOut*. + + .. describe:: GetMemUsed() + + Returns the size of the hash table in bytes. + + .. describe:: BegI() + + Returns an iterator to the beginning of the hash table. + + .. describe:: EndI() + + Returns an iterator to the past-the-end element of the hash table. + + .. describe:: GetI(Key) + + Returns an iterator starting at the node with key value *Key*. + + .. describe:: Clr(DoDel=True, NoDelLim=-1, ResetDat=True) + + Clears the contents of the hash table. + + .. describe:: Empty() + + Returns a boolean indicating whether the hash table is empty. + + .. describe:: Len() + + Returns the the number of key-value pairs in the hash table. + + .. describe:: GetPorts() + + Returns the number of ports. + + .. describe:: IsAutoSize() + + Returns whether it is auto-size, meaning the hash table can be resized. + + .. describe:: GetMxKeyIds() + + Returns the first key id that is larger than all those currently stored in the + hash table. + + .. describe:: GetReservedKeyIds() + + Returns the size of the allocated storage capacity for the hash table. + + .. describe:: IsKeyIdEqKeyN() + + Returns a boolean whether there have been any gaps in the key ids, which can occur if a key is deleted and the hash table has not been defraged. + + .. describe:: AddKey(Key) + + Adds key *Key* to the hash table and returns the key id. + + .. describe:: AddDatId(Key) + + Adds a key-value mapping to the hash table, using *Key* as the key and the key id of *Key* as the value. The value is then returned. + + .. describe:: AddDat(Key) + + Adds a key-value mapping to the hash table, using *Key* as the key and the default value for the datatype as the value (i.e. for :class:`TInt` values, the default value would be 0) if *Key* was not already in the hash table. If *Key* was already in the hash table, the value remains unchanged. The value is then returned. + + .. describe:: AddDat(Key, Dat) + + Adds a key-value mapping to the hash table, using *Key* as the key and *Dat* as the value. The value, *Dat*, is then returned. + + .. describe:: DelKey(Key) + + Removes the mapping using *Key* as the key from the hash table. Raises an exception if *Key* is not a key in the hash table. + + .. describe:: DelIfKey(Key) + + Removes the mapping using *Key* as the key from the hash table if it exists. Returns a boolean indicating whether *Key* was a key in the hash table. + + .. describe:: DelKeyId(KeyId) + + Removes the mapping using the key with id *KeyId* from the hash table. Raises an exception if *KeyId* is not a valid id for a key in the hash table. + + .. describe:: DelKeyIdV(KeyIdV) + + Removes all the mappings that use a key with an id in *KeyIdV* from the hash table. Raises an exception if one of the key ids in *KeyIdV* is not a valid id for a key in the hash table. + + .. describe:: GetKey(KeyId) + + Returns the key with id *KeyId*. + + .. describe:: GetKeyId(Key) + + Returns the key id for key *Key*. + + .. describe:: GetRndKeyId(Rnd) + + Get the index of a random key. If the hash table has many deleted keys, this may take a long time. + + .. describe:: GetRndKeyId (Rnd, EmptyFrac) + + Get the index of a random key. If the hash table has many deleted keys, defrag the hash table first. + + .. describe:: IsKey(Key) + + Returns a bool indicating whether *Key* is a key in the hash table. + + .. describe:: IsKeyId(KeyId) + + Returns a bool indicating whether there is a key in the hash table with id *KeyId*. + + .. describe:: GetDat(Key) + + Returns the value in the hash table that *Key* maps to. + + .. describe:: FFirstKeyId() + + Returns 1 less than the smallest key id. + + .. describe:: GetKeyV(KeyV) + + Adds all the keys in the hash table to the vector *KeyV*. + + .. describe:: GetDatV(DatV) + + Adds all the values/data in the hash table to the vector *DatV*. + + .. describe:: GetKeyDatPrV(KeyDatPrV) + + Adds all the key-value pairs (as :class:`TPair` objects) to the vector *KeyDatPrV*. + + .. describe:: GetDatKeyPrV(DatKeyPrV) + + Adds all the value-key pairs (as :class:`TPair` objects) to the vector *DatKeyPrV*. + + .. describe:: GetKeyDatKdV(KeyDatKdV) + + Adds all the key-value pairs (as :class:`TKeyDat` objects) to the vector *KeyDatKdV*. + + .. describe:: GetDatKeyKdV(DatKeyKdV) + + Adds all the value-key pairs (as :class:`TKeyDat` objects) to the vector *DatKeyKdV*. + + .. describe:: Swap(Hash) + + Swaps the contents of this hash table with those of *Hash*. + + .. describe:: Defrag() + + Defrags the hash table. + + .. describe:: Pack() + + Reduces the capacity of the memory used to hold the hash table to match its size. + + .. describe:: Sort(CmpKey, Asc) + + Sorts the hash table. If *CmpKey* is True, it sorts based on keys rather than values. + + .. describe:: SortByKey(Asc) + + Sorts the hash table based on keys. + + .. describe:: SortByDat(Asc) + + Sorts the hash table based on the values. + + Below is some code demonstrating the use of the :class:`THash` type: + + >>> h1 = snap.TIntH() + >>> for i in range(10): + ... h1[i] = i + 1 + ... + >>> h2 = snap.TIntH(h1) + >>> del h2[0] + >>> h1.Swap(h2) + >>> h1.IsKey(0) + False + +TKeyDat +======= + +Object used to represent the key-value pairs in a :class:`THash` object. + +.. class:: TKeyDat() + TKeyDat (KeyDat) + TKeyDat (Key) + TKeyDat(Key, Dat) + TKeyDat(SIn) + + + Creates a :class:`TKeyDat` object. If *KeyDat* is provided, which is of type :class:`TKeyDat`, its contents will be copied into the newly created object. If *Key* and/or *Dat* are provided, the key for :class:`TKeyDat` will be set to *Key* and the value will be set to *Dat*. If *SIn* is provided, the contents of the :class:`TKeyDat` will be read from the stream. + + + The :class:`TKeyDat` constructor cannot be directly called. To create a :class:`TKeyDat` object, the correct + constructor must be chosen, which indicates the types of the key and value in the :class:`TKeyDat`. Key-value pair types in Snap.py and SNAP use a naming convention of being named + as ``, followed by `Kd`. For example, a hash table + with integer key and string values is named :class:`TIntStrKd`. If `` + and `` have the same type, only one type name might be used, such + as :class:`TIntKd`. + + The following :class:`TKeyDat` types are supported: :class:`TIntKd`, :class:`TIntUInt64Kd`, :class:`TIntPrFltKdKd`, :class:`TIntFltPrKd`, :class:`TIntSFltKd`, :class:`TIntStrKd`, :class:`TUIntIntKd`, :class:`TUIntKd`, :class:`TUInt64IntKd`, :class:`TUInt64FltKd`, :class:`TUInt64StrKd`, :class:`TFltBoolKd`, :class:`TFltIntKd`, :class:`TFltUInt64Kd`, :class:`TFltIntPrKd`, :class:`TFltUIntKd`, :class:`TFltKd`, :class:`TFltStrKd`, :class:`TFltBoolKd`, :class:`TFloatIntBoolPrKd`, :class:`TAscFltIntKd`, :class:`TStrBoolKd`, :class:`TStrIntKd`, :class:`TStrFltKd`, :class:`TStrAscFltKd`, :class:`TStrKd`, and :class:`TIntFltKd`. + + The following public functions are supported by the :class:`TKeyDat` class: + + .. describe:: Save(SOut) + + Saves the contents to the binary stream *SOut* + + .. describe:: GetPrimHashCd() + + Returns the primary hash code. + + .. describe:: GetSecHashCd() + + Returns the secondary hash code. + + The following public attributes are available: + + .. describe:: Key + + The key in the key-value pair. Currently does not support assignment. + + .. describe:: Dat + + The value in the key-value pair. Currently does not support assignment. + + + +THashKeyDatI +============ + +An iterator over the values in a :class:`THash` object. Normally, these objects are not created directly, but via a call to the hash table class :class:`THash` method, such as :func:`BegI`. + +.. class:: THashKeyDatI() + THashKeyDatI(HashKeyDatI) + + Creates a :class:`THashKeyDatI` iterator object. The contents of *HashKeyDatI*, if provided, + will be copied into the iterator. + + The :class:`THashKeyDatI` constructor cannot be directly called. To create a :class:`THashKeyDatI` object, + the correct constructor must be chosen, which indicates the types of the key and value. Hash table + iterator types in Snap.py and SNAP use a naming convention of being named + as ``, followed by `HI`. For example, a hash table iterator + with integer key and string values is named :class:`TIntStrHI`. If `` + and `` have the same type, only one type name might be used, such + as :class:`TIntHI`. + + The following iterator types are currently supported: :class:`TIntHI`, :class:`TIntIntHI`, :class:`TIntFltHI`, :class:`TIntStrHI`, :class:`TIntPrFltHI`, :class:`TUInt64HI`, :class:`TIntBoolHI`, :class:`TIntUint64HI`, :class:`TIntIntVHI`, :class:`TIntIntHHI`, :class:`TIntFltPrHI`, :class:`TIntFltTrHI`, :class:`TIntFltVHI`, :class:`TIntStrVHI`, :class:`TIntIntPrHI`, :class:`TIntIntPrVHI`, :class:`TUInt64StrVHI`, :class:`TIntPrIntPrVHI`, :class:`TIntTrIntHI`, :class:`TIntVIntHI`, :class:`TUIntHI`, :class:`TIntPrIntHI`, :class:`TIntPrIntVHI`, :class:`TIntTrFltHI`, :class:`TIntPrStrHI`, :class:`TIntPrStrVHI`, :class:`TIntStrPrIntHI`, :class:`TFltFltHI`, :class:`TStrHI`, :class:`TStrBoolHI`, :class:`TStrIntHI`, :class:`TStrIntPrHI`, :class:`TStrIntVHI`, :class:`TStrUInt64HI`, :class:`TStrUInt64VHI`, :class:`TStrIntPrVHI`, :class:`TStrFltHI`, :class:`TStrFltVHI`, :class:`TStrStrHI`, :class:`TStrStrPrHI`, :class:`TStrStrVHI`, :class:`TStrStrPrVHI`, :class:`TStrStrKdVHI`, :class:`TStrIntFltPrHI`, :class:`TStrStrIntPrVHI`, :class:`TStrStrIntKdVHI`, :class:`TStrPrBoolHI`, :class:`TStrPrIntHI`, :class:`TStrPrFltHI`, :class:`TStrPrStrHI`, :class:`TStrPrStrVHI`, :class:`TStrTrIntHI`, :class:`TStrIntPrIntHI`, :class:`TStrVHI`, :class:`TStrVStrHI`, and :class:`TStrVStrVHI`. + + The following public functions are supported by the :class:`THashKeyDatI` class: + + .. describe:: Next() + + Updates the iterator to point to the next key-value pair in the :class:`THash`. + + .. describe:: IsEmpty() + + Returns a bool indicating whether the iterator is empty. + + .. describe:: IsEnd() + + Returns a bool indicating whether the end of the iterator has been reached. + + .. describe:: GetKey() + + Get the key for the key-value pair at the current position in the iterator. + + .. describe:: GetDat() + + Get the value for the key-value pair at the current position in the iterator. + + Below is some code demonstrating the use of the :class:`THashKeyDatI` type: + + >>> h1 = snap.TIntH() + >>> for i in range(5): + ... h1[i] = i + 1 + ... + >>> it = h1.BegI() + >>> while not it.IsEnd(): + >>> print(it.GetKey(), it.GetDat()) + >>> it.Next() + 0 1 + 1 2 + 2 3 + 3 4 + 4 5 + +THashSet +======== + +Hash sets contain keys are of the same type. Specific keys can be accessed through their key ids. New values can be added to the hash set only if they are unique. All objects classified as :class:`THashSet` objects have access to the following methods. + +.. class:: THashSet() + THashSet(ExpectVals, AutoSizeP=False) + THashSet(KeyV) + THashSet(SIn) + + + Creates a :class:`THashSet` object with a capacity of *ExpectVals*, if specified. If *KeyV* is provided, which should hold the same type of object the hash set holds, a hash set with the unique values in the vector is created. If *SIn* is provided, the contents of the hash set are loaded from the binary stream *SIn*. + + The :class:`THashSet` constructor cannot be directly called. To create a :class:`THashSet` object, the correct constructor must be chosen, which indicates the type of the key in the hash set. Hash set types in Snap.py and SNAP use a naming convention of being named + as ``, followed by `Set`. For example, a hash set + with integer key is named :class:`TIntSet`. + + The only :class:`THashSet` currently supported is :class:`TIntSet`. + + + To illustrate, the following examples show how to create a :class:`THashSet` with each of the + constructors:: + + >>> snap.TIntSet() + >>> snap.TIntSet(5) + >>> v = snap.TIntV() + >>> for i in range(5): + ... v.Add(i) + ... v.Add(i) + ... + >>> hs = snap.TIntSet(v) + >>> for key in hs: + ... print(key) + ... + 0 + 1 + 2 + 3 + 4 + + For fast access through the hashset, iterators of type :class:`THashSetKeyI` are provided. + + The following public functions are supported by the :class:`THashSet` class: + + .. describe:: Key in HS + + Returns ``True`` if *Key* is a key in hash set *HS*, else ``False``. + + .. describe:: Key not in HS + + Equivalent to ``not Key in HS``. + + .. iter(H) + + Returns an iterator over all the keys in the hash set. + + .. describe:: GetSet(Key1) + GetSet(Key1, Key2) + GetSet(Key1, Key2, Key3) + GetSet(Key1, Key2, Key3, Key4) + GetSet(Key1, Key2, Key3, Key4, Key5) + GetSet(Key1, Key2, Key3, Key4, Key5, Key6) + GetSet(Key1, Key2, Key3, Key4, Key5, Key6, Key7) + GetSet(Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8) + GetSet(Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8, Key9) + + Returns a hash set with the given keys. + + .. describe:: Load(SIn) + + Loads the hash set from a binary stream *SIn*. + + .. describe:: Save(SOut) + + Saves the hash set to a binary stream *SOut*. + + .. describe:: GetMemUsed() + + Returns the size of the hash set in bytes. + + .. describe:: BegI() + + Returns an iterator pointing to the first element in the hash set. + + .. describe:: EndI() + + Returns an iterator referring to the past-the-end element in the hash set. + + .. describe:: Gen(ExpVals) + + Clears the hash set and resizes it with a capacity of at least *ExpVals*. + + .. describe:: Clr() + + Clears the contents of the hash set. + + .. describe:: Empty() + + Returns a bool indicating whether the hash set is empty. + + .. describe:: Len() + + Returns the number of keys in the hash set. + + .. describe:: GetPorts() + + Returns the number of ports. + + .. describe:: IsAutoSize() + + Returns a bool indicating whether it is auto-size, meaning the hash set can be resized. + + .. describe:: GetMxKeyIds() + + Returns the first key id that is larger than all those currently stored in the + hash set. + + .. describe:: GetReservedKeyIds() + + Returns the size of the allocated storage capacity for the hash set. + + .. describe:: IsKeyIdEqKeyN() + + Returns a boolean whether there have been any gaps in the key ids, which can occur if a key is deleted and the hash set has not been defraged. + + .. describe:: AddKey(Key) + + Adds key *Key* to the hash set, if it not already in the hash set, and returns the key id. + + .. describe:: AddKeyV(KeyV) + + Adds each key in *KeyV* not already in the hash set to the hash set. + + .. describe:: DelKey(Key) + + Removes *Key* from the hash set. Raises an exception if *Key* is not a key in the hash set. + + .. describe:: DelIfKey(Key) + + Removes *Key* from the hash set. Returns a boolean indicating whether *Key* was a key in the hash set. + + .. describe:: DelKeyId(KeyId) + + Removes the key with id *KeyId* from the hash set. Raises an exception if *KeyId* is not a valid id for a key in the hash set. + + .. describe:: DelKeyIdV(KeyIdV) + + Removes all the keys with an id in *KeyIdV* from the hash set. Raises an exception if one of the key ids in *KeyIdV* is not a valid id for a key in the hash set. + + .. describe:: GetKey(KeyId) + + Returns the key with id *KeyId*. + + .. describe:: GetKeyId(Key) + + Returns the key id for key *Key*. + + .. describe:: GetRndKeyId(Rnd) + + Get an index of a random key. If the hash set has many deleted keys, this may take a long time. + + .. describe:: IsKey(Key) + + Returns a bool indicating whether *Key* is a key in the hash set. + + .. describe:: IsKeyId(KeyId) + + Returns a bool indicating whether there is a key in the hash table with id *KeyId*. + + .. describe:: GetDat(Key) + + Returns the value in the hash table that *Key* maps to. + + .. describe:: FFirstKeyId() + + Returns 1 less than the smallest key id. + + .. describe:: GetKeyV(KeyV) + + Adds all the keys in the hash table to the vector *KeyV*. + + .. describe:: Swap(Set) + + Swaps the contents of this hash set with those of *Set*. + + .. describe:: Defrag() + + Defrags the hash set. + + .. describe:: Pack() + + Reduces the capacity of the memory used to hold the hash set to match its size. + + + Below is some code demonstrating the use of the :class:`THashSet` type: + + >>> hs = snap.TIntSet() + >>> for i in range(30): + ... hs.AddKey(i) + ... + >>> hs.IsKey(0) + True + >>> v = snap.TIntV() + >>> hs.GetKeyV(v) + + +THashSetKeyI +============ + +An iterator over the values in a :class:`THashSet` object. Normally, these objects are not created directly, but via a call to the hash table class :class:`THashSet` method, such as :func:`BegI`. + +.. class:: THashSetKeyI() + THashSetKeyI(SetKeyI) + + Creates a :class:`THashSetKeyI` iterator object. The contents of *SetKeyI*, if provided, + will be copied into the iterator. + + The :class:`THashSetKeyI` constructor cannot be directly called. To create a :class:`THashSetKeyI` object, + the correct constructor must be chosen, which indicates the type of the key in the hash set iterator. Hash set iterator types in Snap.py and SNAP use a naming convention of being named + as ``, followed by `HSI`. For example, a hash set iterator + with integer key is named :class:`TIntHSI`. + + The following iterator types are currently supported: :class:`TIntHSI`. + + The following public functions are supported by the :class:`THashSetKeyI` class: + + .. describe:: Next() + + Updates the iterator to point to the next key-value pair in the :class:`THashSet`. + + .. describe:: IsEmpty() + + Returns ``True``, if the iterator is empty, else ``False``. + + .. describe:: IsEnd() + + Returns ``True``, if the end of the iterator has been reached, else ``False``. + + .. describe:: GetKey() + + Returns the key at the current position in the iterator. + + Below is some code demonstrating the use of the :class:`THashSetKeyI` type: + + >>> hs1 = snap.TIntSet() + >>> hs1.AddKey(0) + >>> it = hs1.BegI() + >>> print(it.GetKey()) + 0 + + + diff --git a/snap-python/source/doc/source/reference/contrib.rst b/snap-python/source/doc/source/reference/contrib.rst new file mode 100644 index 0000000000000000000000000000000000000000..cac5fa9c99fed23a45f6af96f5a42f5589934c67 --- /dev/null +++ b/snap-python/source/doc/source/reference/contrib.rst @@ -0,0 +1,34 @@ + +Contributors +```````````` + +.. toctree:: + :maxdepth: 2 + +The following people contributed to the development of Snap.py (in +alphabetical order): + + * Arijit Banerjee + * Roger Chen + * Jason Jong + * Nikhil Khadke + * Vikesh Khanna + * Jure Leskovec + * Stephen Macke + * Dilli Raj Paudel + * Yonathan Perez + * Rohan Puttagunta + * Martin Raison + * Karthik Ramachandran + * Sheila Ramaswamy + * Pararth Shah + * Nicholas Shelly + * Rok Sosic + * Ming Han Teh + * Viswajith Venugopal + +Special thanks go to the students of the Fall 2013 class CS224W at +Stanford University who helped with the initial material for this +manual and Sheila Ramaswamy for her editing of the material in the +final document. + diff --git a/snap-python/source/doc/source/reference/conv-swig.rst b/snap-python/source/doc/source/reference/conv-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..5e94f2e79b4783a2aca913fe8dec1213cd548a80 --- /dev/null +++ b/snap-python/source/doc/source/reference/conv-swig.rst @@ -0,0 +1,317 @@ +Table to Graph Conversion Functions (SWIG) +`````````````````````````````````````````` + +One of the most common operations when processing large datasets in SNAP is to load the dataset into :class:`TTable` objects, and then construct graphs out of the tables to run SNAP's graph algorithms. The conversion functions, defined in namespace TSnap, provide the functionality to do this. + +Note that all the functions discussed below have both sequential and parallel implementations. The example code uses the sequential implementations; to use the parallelized functions (on a system which supports OpenMP), simply add MP to the function name (example, ToGraphMP and ToNetworkMP). + +.. function:: ToNetwork(GraphType, PTable Table, const TStr& SrcCol, const TStr& DstCol, TStrV& EdgeAttrV, PTable NodeTable, const TStr& NodeCol, TStrV& NodeAttrV, TAttrAggr AggrPolicy) + :noindex: + +Converts the edge and node tables to a network in SNAP, by looking at columns *SrcCol* and *DstCol* of *Table*, and at *NodeCol* of *NodeTable* +*EdgeAttrV* specifies a list of columns in *Table* which contain edge attributes. *NodeAttrV* specifies a list of columns in *NodeTable* which correspond to node attributes. +It is recommended to have a separate, explicit, node table, and to use this method, when it is desired to add separate node and edge attributes. + +Parameters: + +- *GraphType*: module name (input) + The class of network we want to create (usually snap.PNEANet) + +- *Table*: :class:`TTable` (input) + An instance of :class:`TTable` which contains the edges from which we want to construct a graph. + +- *SrcCol*: string (input) + The name of the column in the edge table which contains the source nodes. + +- *DstCol*: string (input) + The name of the column in the edge table which contains the destination nodes. + +- *EdgeAttrV*: TStrV (vector of strings) (input) + A list of names of columns in the edge table which correspond to edge attributes. + +- *NodeTable*: :class:`TTable` (input) + An instance of :class:`TTable` which contains the nodes of our graph. + +- *NodeCol*: string (input) + The name of the column in the node table which contains the node ids. + +- *NodeAttrV*: TStrV (vector of strings) (input) + A list of names of columns in the node table which correspond to node attributes. + +- *AggrPolicy*: :class:`TAttrAggr` (input) + The aggregation policy for attributes. It is not usually relevant for graphs (as opposed to networks), and can be safely set to snap.aaFirst by default. + +Return value: + +- *Net*: The constructed network. + +The following code shows example usage:: + + import snap + + edgefilename = "/path/to/edges.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids, + # and the edge attributes, separated by a tab. + + nodefilename = "/path/to/nodes.txt" # A file containing the nodes of a graph. Each row contains a node id, + # and (optionally) node attributes. + + + context = snap.TTableContext() # When loading strings from different files, it is important to use the same context + # so that SNAP knows that the same string has been seen before in another table. + + edgeschema = snap.Schema() + edgeschema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr1", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr2", snap.atStr)) + + nodeschema = snap.Schema() + nodeschema.Add(snap.TStrTAttrPr("nodeID", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr1", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr2", snap.atStr)) + + edge_table = snap.TTable.LoadSS(edgeschema, edgefilename, context, "\t", snap.TBool(False)) + node_table = snap.TTable.LoadSS(nodeschema, nodefilename, context, "\t", snap.TBool(False)) + + # In this example, we add both edge attributes to the network, but only one node attribute. + edgeattrv = snap.TStrV() + edgeattrv.Add("edgeattr1") + edgeattrv.Add("edgeattr2") + + nodeattrv = snap.TStrV() + nodeattrv.Add("nodeattr1") + + # net will be an object of type snap.PNEANet + net = snap.ToNetwork(snap.PNEANet, edge_table, "srcID", "dstID", edgeattrv, node_table, "nodeID", nodeattrv, snap.aaFirst) + + +.. function:: ToNetwork(GraphType, PTable Table, const TStr& SrcCol, const TStr& DstCol, TStrv& SrcAttrv, TStrV& DstAttrV, TStrV& EdgeAttrV, TAttrAggr AggrPolicy) + :noindex: + +Converts the edge table to a network in SNAP, by looking at columns *SrcCol* and *DstCol* of *Table*. +*EdgeAttrV* specifies a list of columns in *Table* which contain edge attributes. *SrcAttrV* and *DstAttrV* specifies the attributes of the source and destination columns. +Note: it is NOT recommended to use this method if there are node attributes to be added. Please see the overloaded method above which has a separate, explicit, node table. + +Parameters: + +- *GraphType*: module name (input) + The class of network we want to create (usually snap.PNEANet) + +- *Table*: :class:`TTable` (input) + An instance of :class:`TTable` which contains the edges from which we want to construct a graph. + +- *SrcCol*: string (input) + The name of the column in the edge table which contains the source nodes. + +- *DstCol*: string (input) + The name of the column in the edge table which contains the destination nodes. + +- *SrcAttrV*: TStrV (vector of strings) (input) + A list of names of columns in the edge table which correspond to attributes of the source node. + +- *DstAttrV*: TStrV (vector of strings) (input) + A list of names of columns in the edge table which correspond to attributes of the destination node. + +- *EdgeAttrV*: TStrV (vector of strings) (input) + A list of names of columns in the edge table which correspond to edge attributes. + +- *AggrPolicy*: :class:`TAttrAggr` (input) + The aggregation policy for attributes. Can be safely set to snap.aaFirst by default. + +Return value: + +- *Net*: The constructed network. + +The following code shows example usage:: + + import snap + + edgefilename = "/path/to/edges.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids, + # the edge attributes, and the source and destination node attributes + # separated by a tab. + + + context = snap.TTableContext() # When loading strings from different files, it is important to use the same context + # so that SNAP knows that the same string has been seen before in another table. + + schema = snap.Schema() + schema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + schema.Add(snap.TStrTAttrPr("edgeattr1", snap.atStr)) + schema.Add(snap.TStrTAttrPr("edgeattr2", snap.atStr)) + schema.Add(snap.TStrTAttrPr("srcnodeattr1", snap.atStr)) + schema.Add(snap.TStrTAttrPr("srcnodeattr2", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstnodeattr1", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstnodeattr2", snap.atStr)) + + table = snap.TTable.LoadSS(chema, edgefilename, context, "\t", snap.TBool(False)) + + # In this example, we add both edge attributes to the network, + # but only one src node attribute, and no dst node attributes. + edgeattrv = snap.TStrV() + edgeattrv.Add("edgeattr1") + edgeattrv.Add("edgeattr2") + + srcnodeattrv = snap.TStrV() + srcnodeattrv.Add("srcnodeattr1") + + dstnodeattrv = snap.TStrV() + + # net will be an object of type snap.PNEANet + net = snap.ToNetwork(snap.PNEANet, table, "srcID", "dstID", srcnodeattrv, dstnodeattrv, edgeattrv, snap.aaFirst) + + +.. function:: ToGraph(GraphType, PTable Table, const TStr& SrcCol, const TStr& DstCol, TAttrAggr AggrPolicy) + :noindex: + +Converts the table to a graph in SNAP, by looking at columns *SrcCol* and *DstCol* of *Table*. Whenever a new node is seen, it is implicitly added to the graph automatically. + +Parameters: + +- *GraphType*: module name (input) + The class of graph we want to create (usually snap.PNGraph) + +- *Table*: :class:`TTable` (input) + An instance of :class:`TTable` from which we want to construct a graph. + +- *SrcCol*: string (input) + The name of the column in the table which contains the source nodes. + +- *DstCol*: string (input) + The name of the column in the table which contains the destination nodes. + +- *AggrPolicy*: :class:`TAttrAggr` (input) + The aggregation policy for attributes. It is not usually relevant for graphs (as opposed to networks), and can be safely set to snap.aaFirst by default. + +Return value: + +- *Graph*: The constructed graph. + +The following code shows example usage:: + + import snap + + graphfilename = "/path/to/graph.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids + # separated by a tab. + schema = snap.Schema() + context = snap.TTableContext() + schema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + sample_table = snap.TTable.LoadSS(schema, graphfilename, context, "\t", snap.TBool(False)) + + # graph will be an object of type snap.PNGraph + graph = snap.ToGraph(snap.PNGraph, sample_table, "srcID", "dstID", snap.aaFirst) + +.. function:: LoadModeNetToNet(PMMNet Graph, const TStr& Name, PTable Table, const TStr& NCol, TStrV& NodeAttrV) + :noindex: + +Loads a mode, with name Name, into the PMMNet from the TTable. NCol specifies the node id column and NodeAttrV the node attributes. + +Parameters: + +- *Graph*: :class:`TMMNet` (input) + The multimodal network to which we want to add the mode. + +- *Name*: string (input) + This specifies the name to use for the constructed :class:`TModeNet`. + +- *Table*: :class:`TTable` (input) + The table from which we load the node ids. + +- *NCol*: string (input) + The column in the table which has the node ids. + +- *NodeAttrV*: TStrV (vector of strings) + A vector of column names corresponding to node attributes. + +The following code shows example usage:: + + import snap + + # Create an mmnet + mmnet = snap.TMMNet.New() + + nodefilename = "/path/to/nodes.txt" # A file containing the nodes of a graph. Each row contains a node id, + # and (optionally) node attributes. + + + context = snap.TTableContext() + + nodeschema = snap.Schema() + nodeschema.Add(snap.TStrTAttrPr("nodeID", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr1", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr2", snap.atStr)) + + node_table = snap.TTable.LoadSS(nodeschema, nodefilename, context, "\t", snap.TBool(False)) + + # In this example, we add just one of the node attributes from the table to the TMMNet + nodeattrv = snap.TStrV() + nodeattrv.Add("nodeattr1") + + # This will add a new mode net called "Mode1" to the mmnet. + snap.LoadModeNetToNet(mmnet, "Mode1", node_table, "nodeID", nodeattrv) + +.. function:: LoadCrossNetToNet(PMMNet Graph, const TStr& Mode1, const TStr& Mode2, const TStr& CrossName, PTable Table, const TStr& SrcCol, const TStr& DstCol, TStrV& EdgeAttrV) + :noindex: + +Loads a crossnet from Mode1 to Mode2, with name CrossName, into the PMMNet from the given TTable. SrcCol and DstCol specify the source and destination node id columns, and EdgeAttrV specifies the columns with edge attributs. + +Parameters: + +- *Graph*: :class:`TMMNet` (input) + The multimodal network to which we want to add the mode. + +- *Mode1*: string (input) + This specifies the name of the source :class:`TModeNet`. + +- *Mode2*: string (input) + This specifies the name of the destination :class:`TModeNet`. + +- *CrossName*: string (input) + This specifies the name to use for the constructed :class:`TCrossNet`. + +- *Table*: :class:`TTable` (input) + The table from which we load the edges. + +- *SrcCol*: string (input) + The column in the table which has the source node id of each edge. + +- *DstCol*: string (input) + The column in the table which has the destination node id of each edge. + +- *EdgeAttrV*: TStrV (vector of strings) + A vector of column names corresponding to edge attributes. + +The following code shows example usage:: + + import snap + + # Create an mmnet + mmnet = snap.TMMNet.New() + + + edgefilename = "/path/to/edges.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids, + # and the edge attributes, separated by a tab. + + + context = snap.TTableContext() + + edgeschema = snap.Schema() + edgeschema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr1", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr2", snap.atStr)) + + edge_table = snap.TTable.LoadSS(edgeschema, edgefilename, context, "\t", snap.TBool(False)) + + # In this example, we add both edge attributes to the network + edgeattrv = snap.TStrV() + edgeattrv.Add("edgeattr1") + edgeattrv.Add("edgeattr2") + + # This will add a new cross net called "Cross1" to the mmnet, from "Mode1" to "Mode2". + snap.LoadCrossNetToNet(mmnet, "Mode1", "Mode2", "Cross1", edge_table, "srcID", "dstID", edgeattrv) diff --git a/snap-python/source/doc/source/reference/conv.rst b/snap-python/source/doc/source/reference/conv.rst new file mode 100644 index 0000000000000000000000000000000000000000..8f96e6aaed58d8b0c01ac31732e85c6c7be96c47 --- /dev/null +++ b/snap-python/source/doc/source/reference/conv.rst @@ -0,0 +1,303 @@ +Table to Graph Conversion Methods +``````````````````````````````````` + +One of the most common operations when processing large datasets in SNAP is to load the dataset into :class:`TTable` objects, and then construct graphs out of the tables to run SNAP's graph algorithms. The conversion methods, defined for :class:`TTable`, provide the functionality to do this. + +Note that all the functions discussed below have both sequential and parallel implementations. The example code uses the sequential implementations; to use the parallelized functions (on a system which supports OpenMP), simply add MP to the function name (example, ToGraphMP and ToNetworkMP). + +.. function:: ToNetwork(GraphType, const TStr& SrcCol, const TStr& DstCol, TStrV& EdgeAttrV, PTable NodeTable, const TStr& NodeCol, TStrV& NodeAttrV, TAttrAggr AggrPolicy) + +Converts the edge and node tables to a network in SNAP, by looking at columns *SrcCol* and *DstCol* of *Table*, and at *NodeCol* of *NodeTable* +*EdgeAttrV* specifies a list of columns in *Table* which contain edge attributes. *NodeAttrV* specifies a list of columns in *NodeTable* which correspond to node attributes. +It is recommended to have a separate, explicit, node table, and to use this method, when it is desired to add separate node and edge attributes. + +Parameters: + +- *GraphType*: module name + The class of network we want to create (usually snap.TNEANet) + +- *SrcCol*: string + The name of the column in the edge table which contains the source nodes. + +- *DstCol*: string + The name of the column in the edge table which contains the destination nodes. + +- *EdgeAttrV*: TStrV (vector of strings) + A list of names of columns in the edge table which correspond to edge attributes. + +- *NodeTable*: :class:`TTable` + An instance of :class:`TTable` which contains the nodes of our graph. + +- *NodeCol*: string + The name of the column in the node table which contains the node ids. + +- *NodeAttrV*: TStrV (vector of strings) + A list of names of columns in the node table which correspond to node attributes. + +- *AggrPolicy*: :class:`TAttrAggr` + The aggregation policy for attributes. It is not usually relevant for graphs (as opposed to networks), and can be safely set to snap.aaFirst by default. + +Return value: + +- *Net*: The constructed network, most commonly of type :class:`TNEANet` + +The following code shows example usage:: + + import snap + + edgefilename = "/path/to/edges.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids, + # and the edge attributes, separated by a tab. + + nodefilename = "/path/to/nodes.txt" # A file containing the nodes of a graph. Each row contains a node id, + # and (optionally) node attributes. + + + context = snap.TTableContext() # When loading strings from different files, it is important to use the same context + # so that SNAP knows that the same string has been seen before in another table. + + edgeschema = snap.Schema() + edgeschema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr1", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr2", snap.atStr)) + + nodeschema = snap.Schema() + nodeschema.Add(snap.TStrTAttrPr("nodeID", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr1", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr2", snap.atStr)) + + edge_table = snap.TTable.LoadSS(edgeschema, edgefilename, context, "\t", snap.TBool(False)) + node_table = snap.TTable.LoadSS(nodeschema, nodefilename, context, "\t", snap.TBool(False)) + + # In this example, we add both edge attributes to the network, but only one node attribute. + edgeattrv = snap.TStrV() + edgeattrv.Add("edgeattr1") + edgeattrv.Add("edgeattr2") + + nodeattrv = snap.TStrV() + nodeattrv.Add("nodeattr1") + + net = edge_table.ToNetwork(snap.TNEANet, edge_table, "srcID", "dstID", edgeattrv, node_table, "nodeID", nodeattrv, snap.aaFirst) + + +.. function:: ToNetwork(GraphType, const TStr& SrcCol, const TStr& DstCol, TStrv& SrcAttrv, TStrV& DstAttrV, TStrV& EdgeAttrV, TAttrAggr AggrPolicy) + :noindex: + +Converts the edge table to a network in SNAP, by looking at columns *SrcCol* and *DstCol* of *Table*. +*EdgeAttrV* specifies a list of columns in *Table* which contain edge attributes. *SrcAttrV* and *DstAttrV* specifies the attributes of the source and destination columns. +Note: it is NOT recommended to use this method if there are node attributes to be added. Please see the overloaded method above which has a separate, explicit, node table. + +Parameters: + +- *GraphType*: module name + The class of network we want to create (usually snap.TNEANet) + +- *SrcCol*: string + The name of the column in the edge table which contains the source nodes. + +- *DstCol*: string + The name of the column in the edge table which contains the destination nodes. + +- *SrcAttrV*: TStrV (vector of strings) + A list of names of columns in the edge table which correspond to attributes of the source node. + +- *DstAttrV*: TStrV (vector of strings) + A list of names of columns in the edge table which correspond to attributes of the destination node. + +- *EdgeAttrV*: TStrV (vector of strings) + A list of names of columns in the edge table which correspond to edge attributes. + +- *AggrPolicy*: :class:`TAttrAggr` + The aggregation policy for attributes. Can be safely set to snap.aaFirst by default. + +Return value: + +- *Net*: The constructed network, most commonly of type :class:`TNEANet` + +The following code shows example usage:: + + import snap + + edgefilename = "/path/to/edges.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids, + # the edge attributes, and the source and destination node attributes + # separated by a tab. + + + context = snap.TTableContext() # When loading strings from different files, it is important to use the same context + # so that SNAP knows that the same string has been seen before in another table. + + schema = snap.Schema() + schema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + schema.Add(snap.TStrTAttrPr("edgeattr1", snap.atStr)) + schema.Add(snap.TStrTAttrPr("edgeattr2", snap.atStr)) + schema.Add(snap.TStrTAttrPr("srcnodeattr1", snap.atStr)) + schema.Add(snap.TStrTAttrPr("srcnodeattr2", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstnodeattr1", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstnodeattr2", snap.atStr)) + + table = snap.TTable.LoadSS(chema, edgefilename, context, "\t", snap.TBool(False)) + + # In this example, we add both edge attributes to the network, + # but only one src node attribute, and no dst node attributes. + edgeattrv = snap.TStrV() + edgeattrv.Add("edgeattr1") + edgeattrv.Add("edgeattr2") + + srcnodeattrv = snap.TStrV() + srcnodeattrv.Add("srcnodeattr1") + + dstnodeattrv = snap.TStrV() + + # net will be an object of type snap.TNEANet + net = table.ToNetwork(snap.TNEANet, "srcID", "dstID", srcnodeattrv, dstnodeattrv, edgeattrv, snap.aaFirst) + + +.. function:: ToGraph(GraphType, const TStr& SrcCol, const TStr& DstCol, TAttrAggr AggrPolicy) + +Converts the table to a graph in SNAP, by looking at columns *SrcCol* and *DstCol* of *Table*. Whenever a new node is seen, it is implicitly added to the graph automatically. + +Parameters: + +- *GraphType*: module name + The class of graph we want to create (usually snap.TNGraph) + +- *SrcCol*: string + The name of the column in the table which contains the source nodes. + +- *DstCol*: string + The name of the column in the table which contains the destination nodes. + +- *AggrPolicy*: :class:`TAttrAggr` + The aggregation policy for attributes. It is not usually relevant for graphs (as opposed to networks), and can be safely set to snap.aaFirst by default. + +Return value: + +- *Graph*: The constructed graph, most commonly of type :class:`TNGraph` + +The following code shows example usage:: + + import snap + + graphfilename = "/path/to/graph.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids + # separated by a tab. + schema = snap.Schema() + context = snap.TTableContext() + schema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + schema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + sample_table = snap.TTable.LoadSS(schema, graphfilename, context, "\t", snap.TBool(False)) + + # graph will be an object of type snap.TNGraph + graph = sample_table.ToGraph(snap.TNGraph, "srcID", "dstID", snap.aaFirst) + +.. function:: LoadModeNetToNet(PMMNet Graph, const TStr& Name, PTable Table, const TStr& NCol, TStrV& NodeAttrV) + +Loads a mode, with name Name, into the PMMNet from the TTable. NCol specifies the node id column and NodeAttrV the node attributes. + +Parameters: + +- *Graph*: :class:`TMMNet` (input) + The multimodal network to which we want to add the mode. + +- *Name*: string (input) + This specifies the name to use for the constructed :class:`TModeNet`. + +- *Table*: :class:`TTable` (input) + The table from which we load the node ids. + +- *NCol*: string (input) + The column in the table which has the node ids. + +- *NodeAttrV*: TStrV (vector of strings) + A vector of column names corresponding to node attributes. + +The following code shows example usage:: + + import snap + + # Create an mmnet + mmnet = snap.TMMNet.New() + + nodefilename = "/path/to/nodes.txt" # A file containing the nodes of a graph. Each row contains a node id, + # and (optionally) node attributes. + + + context = snap.TTableContext() + + nodeschema = snap.Schema() + nodeschema.Add(snap.TStrTAttrPr("nodeID", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr1", snap.atStr)) + nodeschema.Add(snap.TStrTAttrPr("nodeattr2", snap.atStr)) + + node_table = snap.TTable.LoadSS(nodeschema, nodefilename, context, "\t", snap.TBool(False)) + + # In this example, we add just one of the node attributes from the table to the TMMNet + nodeattrv = snap.TStrV() + nodeattrv.Add("nodeattr1") + + # This will add a new mode net called "Mode1" to the mmnet. + snap.LoadModeNetToNet(mmnet, "Mode1", node_table, "nodeID", nodeattrv) + +.. function:: LoadCrossNetToNet(PMMNet Graph, const TStr& Mode1, const TStr& Mode2, const TStr& CrossName, PTable Table, const TStr& SrcCol, const TStr& DstCol, TStrV& EdgeAttrV) + +Loads a crossnet from Mode1 to Mode2, with name CrossName, into the PMMNet from the given TTable. SrcCol and DstCol specify the source and destination node id columns, and EdgeAttrV specifies the columns with edge attributs. + +Parameters: + +- *Graph*: :class:`TMMNet` (input) + The multimodal network to which we want to add the mode. + +- *Mode1*: string (input) + This specifies the name of the source :class:`TModeNet`. + +- *Mode2*: string (input) + This specifies the name of the destination :class:`TModeNet`. + +- *CrossName*: string (input) + This specifies the name to use for the constructed :class:`TCrossNet`. + +- *Table*: :class:`TTable` (input) + The table from which we load the edges. + +- *SrcCol*: string (input) + The column in the table which has the source node id of each edge. + +- *DstCol*: string (input) + The column in the table which has the destination node id of each edge. + +- *EdgeAttrV*: TStrV (vector of strings) + A vector of column names corresponding to edge attributes. + +The following code shows example usage:: + + import snap + + # Create an mmnet + mmnet = snap.TMMNet.New() + + + edgefilename = "/path/to/edges.txt" # A file containing the graph, where each row contains an edge + # and each edge is represented with the source and dest node ids, + # and the edge attributes, separated by a tab. + + + context = snap.TTableContext() + + edgeschema = snap.Schema() + edgeschema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr1", snap.atStr)) + edgeschema.Add(snap.TStrTAttrPr("edgeattr2", snap.atStr)) + + edge_table = snap.TTable.LoadSS(edgeschema, edgefilename, context, "\t", snap.TBool(False)) + + # In this example, we add both edge attributes to the network + edgeattrv = snap.TStrV() + edgeattrv.Add("edgeattr1") + edgeattrv.Add("edgeattr2") + + # This will add a new cross net called "Cross1" to the mmnet, from "Mode1" to "Mode2". + snap.LoadCrossNetToNet(mmnet, "Mode1", "Mode2", "Cross1", edge_table, "srcID", "dstID", edgeattrv) diff --git a/snap-python/source/doc/source/reference/degree.rst b/snap-python/source/doc/source/reference/degree.rst new file mode 100644 index 0000000000000000000000000000000000000000..379a604376787e67c75d47209545466393098732 --- /dev/null +++ b/snap-python/source/doc/source/reference/degree.rst @@ -0,0 +1,21 @@ + +Node Degree +``````````` + +.. toctree:: + :maxdepth: 2 + + CntDegNodes + CntInDegNodes + CntOutDegNodes + CntNonZNodes + GetDegCnt + GetInDegCnt + GetOutDegCnt + GetMxDegNId + GetMxInDegNId + GetMxOutDegNId + GetNodeInDegV + GetNodeOutDegV + GetDegSeqV + diff --git a/snap-python/source/doc/source/reference/draw.rst b/snap-python/source/doc/source/reference/draw.rst new file mode 100644 index 0000000000000000000000000000000000000000..121cd9c8ade7d811643302969381129598305baf --- /dev/null +++ b/snap-python/source/doc/source/reference/draw.rst @@ -0,0 +1,25 @@ + +Plotting and Drawing +```````````````````` + +.. toctree:: + :maxdepth: 2 + + DrawGViz + DrawGVizColor + PlotSccDistr + PlotWccDistr + PlotClustCf + PlotInDegDistr + PlotOutDegDistr + PlotHops + PlotShortPathDistr + PlotEigValDistr + PlotEigValRank + PlotSngValDistr + PlotSngValRank + PlotSngVec + PlotInvParticipRat + PlotKCoreEdges + PlotKCoreNodes + diff --git a/snap-python/source/doc/source/reference/edges.rst b/snap-python/source/doc/source/reference/edges.rst new file mode 100644 index 0000000000000000000000000000000000000000..1264dccad4b5abf8fbc74d73cfd43af1e5265ff8 --- /dev/null +++ b/snap-python/source/doc/source/reference/edges.rst @@ -0,0 +1,13 @@ + +Edge Count +`````````` + +.. toctree:: + :maxdepth: 2 + + CntSelfEdges + CntUniqBiDirEdges + CntUniqDirEdges + CntUniqUndirEdges + CntEdgesToSet + diff --git a/snap-python/source/doc/source/reference/generators.rst b/snap-python/source/doc/source/reference/generators.rst new file mode 100644 index 0000000000000000000000000000000000000000..564c66d4174e946d8fbd81827b977eb9e7cb8037 --- /dev/null +++ b/snap-python/source/doc/source/reference/generators.rst @@ -0,0 +1,28 @@ + +Graph Generators +```````````````` + +.. toctree:: + :maxdepth: 2 + + GenFull + GenCircle + GenGrid + GenStar + GenTree + GenRndGnm + GenPrefAttach + GenGeoPrefAttach + GenForestFire + GenSmallWorld + GenBaraHierar + GenConfModel + GenConfModel1 + GenCopyModel + GenDegSeq + GenRewire + GenRndDegK + GenRndPowerLaw + GenRMat + GenRMatEpinions + diff --git a/snap-python/source/doc/source/reference/graphs.rst b/snap-python/source/doc/source/reference/graphs.rst new file mode 100644 index 0000000000000000000000000000000000000000..8c78bf1f662fd2e83fe317ac9596bdcad54cbdae --- /dev/null +++ b/snap-python/source/doc/source/reference/graphs.rst @@ -0,0 +1,2044 @@ +Graph and Network Classes +````````````````````````` + +Graphs and networks in SNAP are represented as undirected graphs :class:`TUNGraph`, directed graphs :class:`TNGraph` and multigraphs with attributes :class:`TNEANet`. + +TUNGraph +======== + +.. class:: TUNGraph() + TUNGraph(Nodes, Edges) + + Returns a new undirected graph. If no parameters are provided, + an empty graph is created. If *Nodes* and *Edges* are specified, space + is preallocated for *Nodes* nodes and *Edges* edges. + Do not call these methods directly! To create a new :class:`TUNGraph` + object, use one of the :meth:`New()` methods. + + Nodes have IDs, which are arbitrary non-negative integers. Nodes and edges + have no attributes/data associated with them. There is at most one + undirected edge between a pair of nodes. Self loops (one per node) are + allowed but multiple (parallel) edges are not. The undirected graph data + structure is implemented using sorted adjacency lists. This means adding + a node takes constant time, while adding an edge takes linear time (since + adjacency list is kept sorted) in the node degree. Accessing arbitrary + node takes constant time and accessing any edge takes logarithmic time + in the node degree. + + :class:`TUNGraph` provides iterators for fast traversal of nodes and edges. + Iterator classes are :class:`TUNGraphNodeI` for iterating over nodes and + :class:`TUNGraphEdgeI` for iterating over edges. + + :class:`TUNGraph` provides the following methods: + + .. describe:: New() + + Returns a pointer to a new graph. + + .. describe:: New(Nodes, Edges) + + Returns a pointer to a new graph and reserves enough memory for + *Nodes* nodes and *Edges* edges. + + .. describe:: Load(SIn) + + Loads a graph from a binary stream *SIn* and returns a pointer to it. + + .. describe:: Save(SOut) + + Saves the graph to a binary stream *SOut*. + + .. describe:: Nodes() + + Returns a generator for the nodes in the graph. + + .. describe:: GetNodes() + + Returns the number of nodes in the graph. + + .. describe:: AddNode(NId) + + Adds a node of ID *NId* to the graph, *NId* is an integer. + Returns node ID. If NId is -1, node ID is automatically assigned. + It throws an exception, if a node with ID *NId* already exists. + + .. describe:: AddNode(NodeI) + + Adds a node of ID *NodeI.GetId()* to the graph. *NodeI* is a node iterator. Returns node ID. + + .. describe:: DelNode(NId) + + Deletes node of ID *NId* from the graph. *NId* is an integer. + + .. describe:: DelNode(NodeI) + + Deletes node of ID *NodeI.GetId()* from the graph. *NodeI* is a node iterator. + + .. describe:: IsNode(NId) + + Returns true, if ID *NId* is a node in the graph. + + .. describe:: BegNI() + + Returns a node iterator referring to the first node in the graph. + + .. describe:: EndNI() + + Returns a node iterator referring to the past-the-end node in the graph. + + .. describe:: GetNI(NId) + + Returns a node iterator referring to the node of ID *NId* in the graph. + + .. describe:: GetMxNId() + + Returns an ID that is larger than any node ID in the graph. + + .. describe:: GetRndNId() + + Returns an ID of a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, for example with *TRnd.Randomize()*. The example below shows how to use *Randomize()*. Omit the line with *Randomize()* or the *Rnd* parameter to *GetRndNId()* to get the same return values for different program executions: + + .. code-block:: python + + import snap + G = snap.GenFull(snap.TNEANet, 100) + Rnd = snap.TRnd(42) + Rnd.Randomize() + for i in range(0,10): + NId = G.GetRndNId(Rnd) + print(NId) + + .. describe:: GetRndNI() + + Returns a node iterator referring to a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: Edges() + + Returns a generator for the edges in the graph. + + .. describe:: GetEdges() + + Returns the number of edges in the graph. + + .. describe:: AddEdge(SrcNId, DstNId) + + Adds an edge between node IDs *SrcNId* and *DstNId* to the graph. + Returns -1, if the edge was successfully added. Returns -2, if the + edge already exists. The function throws an exception, if *SrcNId* + or *DstNId* are not nodes in the graph. + + .. describe:: AddEdge(EdgeI) + + Adds an edge between *EdgeI.GetSrcNId()* and *EdgeI.GetDstNId()* to the graph. *EdgeI* is an edge iterator. Returns -1, if successful. Returns -2, otherwise. + + .. describe:: DelEdge(SrcNId, DstNId) + + Deletes an edge between node IDs *SrcNId* and *DstNId* from the graph. + If the edge between *SrcNId* and *DstNId* does not exist in the graph, + function still completes. But the function throws an exception, + if *SrcNId* or *DstNId* are not nodes in the graph. + + .. describe:: IsEdge(SrcNId, DstNId) + + Tests whether an edge between node IDs *SrcNId* and *DstNId* exists in the graph. + + .. describe:: BegEI() + + Returns an edge iterator referring to the first edge in the graph. + + .. describe:: EndEI() + + Returns an edge iterator referring to the past-the-end edge in the graph. + + .. describe:: GetEI(SrcNId, DstNId) + + Returns an edge iterator referring to edge between node IDs *SrcNId* + and *DstNId* in the graph. Since this is an undirected graph + *GetEI(SrcNId, DstNId)* has the same effect as *GetEI(DstNId, SrcNId)*. + + .. describe:: Empty() + + Returns true if the graph is empty, has zero nodes. + + .. describe:: Clr() + + Deletes all nodes and edges from the graph. + + .. describe:: Reserve(Nodes, Edges) + + Reserves memory for a graph of *Nodes* nodes and *Edges* edges. + + .. describe:: ReserveNIdDeg(NId, Deg) + + Reserves memory for node ID *NId* having *Deg* edges. + + .. describe:: HasFlag(Flag) + + Allows for run-time checking the type of the graph (see the TGraphFlag for flag definitions). + + .. describe:: Defrag() + + Defragments the graph. After performing many node and edge + insertions and deletions to a graph, the graph data structure + can be fragmented in memory. This function compacts down the + graph data structure and frees unneeded memory. + + .. describe:: Dump(OutF=sys.stdout) + + Prints the graph in a human readable form to the output stream *OutF*. + + .. describe:: GetSmallGraph() + + Returns a small graph on 5 nodes and 5 edges. + + Below is some code demonstrating the use of the :class:`TUNGraph` class: + + >>> G1 = snap.TUNGraph.New() + >>> G1.AddNode(1) + 1 + >>> G1.AddNode(2) + 2 + >>> G1.AddNode(5) + 5 + >>> G1.AddEdge(1,5) + -1 + >>> G1.AddEdge(1,2) + -1 + >>> print(G1.Empty()) + False + >>> print(G1.GetNodes()) + 3 + >>> print(G1.GetEdges()) + 2 + +TUNGraphNodeI +============= + +.. class:: TUNGraphNodeI() + + Returns a new node iterator for :class:`TUNGraph`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TUNGraph` method, + such as :meth:`BegNI()`, that returns a node iterator. + + :class:`TUNGraphNodeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next node in the graph. + + .. describe:: GetId() + + Returns node ID of the current node. + + .. describe:: GetDeg() + GetInDeg() + GetOutDeg() + + Returns degree of the current node. Since the graph is undirected, + all three methods return the same value. + + .. describe:: GetInNId(NodeN) + + Returns ID of *NodeN*-th in-node (the node pointing to the current node). + + .. describe:: GetOutNId(NodeN) + + Returns ID of *NodeN*-th out-node (the node the current node points to). + + .. describe:: GetNbrNId(NodeN) + + Returns ID of *NodeN*-th neighboring node. + + .. describe:: IsInNId(NId) + + Tests whether node with ID *NId* points to the current node. + + .. describe:: IsOutNId(NId) + + Tests whether the current node points to node with ID *NId*. + + .. describe:: IsNbrNId(NId) + + Tests whether node with ID *NId* is a neighbor of the current node. + +TUNGraphEdgeI +============= + +.. class:: TUNGraphEdgeI() + + Returns a new edge iterator for :class:`TUNGraph`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TUNGraph` method, + such as :meth:`BegEI()`, that returns an edge iterator. + + :class:`TUNGraphEdgeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next edge in the graph. + + .. describe:: GetId() + + Returns a tuple of (*SrcNId*, *DstNId*). No explicit edge IDs are + assigned to edges in :class:`TUNGraph`. + + .. describe:: GetSrcNId() + + Returns the ID of the source node of the edge. + Since the graph is undirected, + this is the node with a smaller ID of the edge endpoints. + + .. describe:: GetDstNId() + + Returns the ID of the destination node of the edge. + Since the graph is undirected, + this is the node with a greater ID of the edge endpoints. + +TNGraph +======= + +.. class:: TNGraph() + TNGraph(Nodes, Edges) + + Returns a new directed graph. If no parameters are provided, + an empty graph is created. If *Nodes* and *Edges* are specified, space + is preallocated for *Nodes* nodes and *Edges* edges. + Do not call these methods directly! To create a new :class:`TNGraph` + object, use one of the :meth:`New()` methods. + + Nodes have IDs, which are arbitrary non-negative integers. Nodes and edges + have no attributes/data associated with them. There is at most one + directed edge from one source node to a destination node. There can be + an edge between the same pair of nodes in the opposite direction. Self + loops (one per node) are allowed but multiple (parallel) edges are not. + The directed graph data structure is implemented using sorted adjacency + lists. This means adding a node takes constant time, while adding an edge + takes linear time (since adjacency list is kept sorted) in the node + degree. Accessing an arbitrary node takes constant time and accessing + any edge takes logarithmic time in the node degree. + + :class:`TNGraph` provides iterators for fast traversal of nodes and edges. + Iterator classes are :class:`TNGraphNodeI` for iterating over nodes and + :class:`TNGraphEdgeI` for iterating over edges. + + :class:`TNGraph` provides the following methods: + + .. describe:: New() + + Returns a pointer to a new graph. + + .. describe:: New(Nodes, Edges) + + Returns a pointer to a new graph and reserves enough memory for + *Nodes* nodes and *Edges* edges. + + .. describe:: Load(SIn) + + Loads a graph from a binary stream *SIn* and returns a pointer to it. + + .. describe:: Save(SOut) + + Saves the graph to a binary stream *SOut*. + + .. describe:: Nodes() + + Returns a generator for the nodes in the graph. + + .. describe:: GetNodes() + + Returns the number of nodes in the graph. + + .. describe:: AddNode(NId) + + Adds a node of ID *NId* to the graph, *NId* is an integer. + Returns node ID. If NId is -1, node ID is automatically assigned. + It throws an exception, if a node with ID *NId* already exists. + + .. describe:: AddNode(NodeI) + + Adds a node of ID *NodeI.GetId()* to the graph. *NodeI* is a node iterator. Returns node ID. + + .. describe:: DelNode(NId) + + Deletes node of ID *NId* from the graph. *NId* is an integer. + If the node of ID *NId* does not exist, the function throws an exception. + + .. describe:: DelNode(NodeI) + + Deletes node of ID *NodeI.GetId()* from the graph. *NodeI* is a node iterator. + + .. describe:: IsNode(NId) + + Returns true, if ID *NId* is a node in the graph. + + .. describe:: BegNI() + + Returns a node iterator referring to the first node in the graph. + + .. describe:: EndNI() + + Returns a node iterator referring to the past-the-end node in the graph. + + .. describe:: GetNI(NId) + + Returns a node iterator referring to the node of ID *NId* in the graph. + + .. describe:: GetMxNId() + + Returns an ID that is larger than any node ID in the graph. + + .. describe:: GetRndNId() + + Returns an ID of a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: GetRndNI() + + Returns a node iterator referring to a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: Edges() + + Returns a generator for the edges in the graph. + + .. describe:: GetEdges() + + Returns the number of edges in the graph. + + .. describe:: AddEdge(SrcNId, DstNId) + + Adds an edge from node *SrcNId* to node *DstNId* to the graph. + Returns -1, if the edge was successfully added. Returns -2, if the + edge already exists. The function throws an exception, if *SrcNId* + or *DstNId* are not nodes in the graph. + + .. describe:: AddEdge(EdgeI) + + Adds an edge from *EdgeI.GetSrcNId()* to *EdgeI.GetDstNId()* to the graph. *EdgeI* is an edge iterator. Returns -1, if successful. Returns -2, otherwise. + + .. describe:: DelEdge(SrcNId, DstNId) + + Deletes an edge from node IDs *SrcNId* to *DstNId* from the graph. + If the edge from *SrcNId* to *DstNId* does not exist in the graph, + function still completes. But the function throws an exception, + if *SrcNId* or *DstNId* are not nodes in the graph. + + .. describe:: IsEdge(SrcNId, DstNId) + + Tests whether an edge from node *SrcNId* to *DstNId* exists in the graph. + + .. describe:: BegEI() + + Returns an edge iterator referring to the first edge in the graph. + + .. describe:: EndEI() + + Returns an edge iterator referring to the past-the-end edge in the graph. + + .. describe:: GetEI(SrcNId, DstNId) + + Returns an edge iterator referring to edge between node IDs *SrcNId* + and *DstNId* in the graph. + + .. describe:: Empty() + + Returns true if the graph is empty, has zero nodes. + + .. describe:: Clr() + + Deletes all nodes and edges from the graph. + + .. describe:: Reserve(Nodes, Edges) + + Reserves memory for a graph of *Nodes* nodes and *Edges* edges. + + .. describe:: ReserveNIdInDeg(NId, Deg) + + Reserves memory for node ID *NId* having *InDeg* in-edges. + + .. describe:: ReserveNIdOutDeg(NId, Deg) + + Reserves memory for node ID *NId* having *OutDeg* out-edges. + + .. describe:: HasFlag(Flag) + + Allows for run-time checking the type of the graph (see the TGraphFlag for flag definitions). + + .. describe:: Defrag() + + Defragments the graph. After performing many node and edge + insertions and deletions to a graph, the graph data structure + can be fragmented in memory. This function compacts down the + graph data structure and frees unneeded memory. + + .. describe:: Dump(OutF=sys.stdout) + + Prints the graph in a human readable form to the output stream *OutF*. + + .. describe:: GetSmallGraph() + + Returns a small graph on 5 nodes and 6 edges. + + Below is some code demonstrating the use of the :class:`TNGraph` class: + + >>> G2 = snap.TNGraph.New() + >>> G2.AddNode(1) + 1 + >>> G2.AddNode(2) + 2 + >>> G2.AddNode(5) + 5 + >>> G2.AddEdge(1,5) + -1 + >>> G2.AddEdge(1,2) + -1 + >>> print(G2.Empty()) + False + >>> print(G2.GetNodes()) + 3 + >>> print(G2.GetEdges()) + 2 + +TNGraphNodeI +============ + +.. class:: TNGraphNodeI() + + Returns a new node iterator for :class:`TNGraph`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TNGraph` method, + such as :meth:`BegNI()`, that returns a node iterator. + + :class:`TNGraphNodeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next node in the graph. + + .. describe:: GetId() + + Returns node ID of the current node. + + .. describe:: GetDeg() + + Returns degree of the current node, the sum of in-degree and out-degree. + + .. describe:: GetInDeg() + + Returns in-degree of the current node. + + .. describe:: GetOutDeg() + + Returns out-degree of the current node. + + .. describe:: GetInNId(NodeN) + + Returns ID of *NodeN*-th in-node (the node pointing to the current node). + + .. describe:: GetOutNId(NodeN) + + Returns ID of *NodeN*-th out-node (the node the current node points to). + + .. describe:: GetNbrNId(NodeN) + + Returns ID of *NodeN*-th neighboring node. + + .. describe:: IsInNId(NId) + + Tests whether node with ID *NId* points to the current node. + + .. describe:: IsOutNId(NId) + + Tests whether the current node points to node with ID *NId*. + + .. describe:: IsNbrNId(NId) + + Tests whether node with ID *NId* is a neighbor of the current node. + +TNGraphEdgeI +============ + +.. class:: TNGraphEdgeI() + + Returns a new edge iterator for :class:`TNGraph`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TNGraph` method, + such as :meth:`BegEI()`, that returns an edge iterator. + + :class:`TNGraphEdgeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next edge in the graph. + + .. describe:: GetId() + + Returns a tuple of (*SrcNId*, *DstNId*). No explicit edge IDs are + assigned to edges in :class:`TNGraph`. + + .. describe:: GetSrcNId() + + Returns the ID of the source node of the edge. + + .. describe:: GetDstNId() + + Returns the ID of the destination node of the edge. + +TNEANet +======= + +.. class:: TNEANet() + TNEANet(Nodes, Edges) + + Returns a new directed multigraph with node and edge attributes. + If no parameters are provided, + an empty graph is created. If *Nodes* and *Edges* are specified, space + is preallocated for *Nodes* nodes and *Edges* edges. + Do not call these methods directly! To create a new :class:`TNEANet` + object, use one of the :meth:`New()` methods. + + Nodes have IDs, which are arbitrary non-negative integers. Edges have IDs. + There can be more than one directed edge from one source node to + a destination node. Self loops (one per node) are allowed as well as + multiple (parallel) edges. Nodes and edges can have attributes/data + associated with them. The attributes can be added dynamically at runtime. + The directed multigraph data structure is implemented using sorted + adjacency lists. This means adding a node takes constant time, while + adding an edge takes linear time (since adjacency list is kept sorted) + in the node degree. Accessing arbitrary node takes constant time and + accessing any edge takes logarithmic time in the node degree. + The attributes are organized in a columnar store, where each attribute + column is defined for all the nodes or edges in the network. + + Methods for :class:`TNEANet` are presented in two groups. The first + group of methods deal with graph structure which includes nodes and edges. + The second group of methods deal with node and edge attributes. + + :class:`TNEANet` provides iterators for fast traversal of nodes, edges + and attributes. + Iterator classes are :class:`TNEANetNodeI` for iterating over nodes, + :class:`TNEANetEdgeI` for iterating over edges, and + :class:`TNEANetAIntI`, :class:`TNEANetAFltI`, :class:`TNEANetAStrI` + for iterating over integer, float or string attributes, respectively. + Attribute iterators can operate over attributes for nodes or edges. + + :class:`TNEANet` methods for graph structure are the following: + + .. describe:: New() + + Returns a pointer to a new graph. + + .. describe:: New(Nodes, Edges) + + Returns a pointer to a new graph and reserves enough memory for + *Nodes* nodes and *Edges* edges. + + .. describe:: Load(SIn) + + Loads a graph from a binary stream *SIn* and returns a pointer to it. + + .. describe:: Save(SOut) + + Saves the graph to a binary stream *SOut*. + + .. describe:: Nodes() + + Returns a generator for the nodes in the graph. + + .. describe:: GetNodes() + + Returns the number of nodes in the graph. + + .. describe:: AddNode(NId) + + Adds a node of ID *NId* to the graph, *NId* is an integer. + Returns node ID. If NId is -1, node ID is automatically assigned. + It throws an exception, if a node with ID *NId* already exists. + + .. describe:: AddNode(NodeI) + + Adds a node of ID *NodeI.GetId()* to the graph. *NodeI* is a node iterator. Returns node ID. + + .. describe:: DelNode(NId) + + Deletes node of ID *NId* from the graph. *NId* is an integer. + If the node of ID *NId* does not exist, the function throws an exception. + + .. describe:: DelNode(NodeI) + + Deletes node of ID *NodeI.GetId()* from the graph. *NodeI* is a node iterator. + + .. describe:: IsNode(NId) + + Returns true, if ID *NId* is a node in the graph. + + .. describe:: BegNI() + + Returns a node iterator referring to the first node in the graph. + + .. describe:: EndNI() + + Returns a node iterator referring to the past-the-end node in the graph. + + .. describe:: GetNI(NId) + + Returns a node iterator referring to the node of ID *NId* in the graph. + + .. describe:: GetMxNId() + + Returns an ID that is larger than any node ID in the graph. + + .. describe:: GetRndNId() + + Returns an ID of a random node in the graph. For this method to return different values on program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: GetNIdV(NIdV) + + Returns IDs of all the nodes in vector *NIdV*, which must be of type *TIntV*. + + .. describe:: Edges() + + Returns a generator for the edges in the graph. + + .. describe:: GetEdges() + + Returns the number of edges in the graph. + + .. describe:: AddEdge(SrcNId, DstNId, EId=-1) + + Adds an edge with ID *EId* between node IDs *SrcNId* and *DstNId* + to the graph. Returns the ID of the edge being added. If *EId* is -1, + edge ID is automatically assigned. Throws an exception, if an edge + with ID *EId* already exists or if either *SrcNId* or *DstNId* does + not exist. + + .. describe:: AddEdge(EdgeI) + + Adds an edge from *EdgeI.GetSrcNId()* to *EdgeI.GetDstNId()* to + the graph. *EdgeI* is an edge iterator. Returns the ID of the + edge being added. If *EId* is -1, edge ID is automatically assigned. + Throws an exception, if an edge with ID *EId* already exists or + if either *SrcNId* or *DstNId* does not exist. + + .. describe:: DelEdge(SrcNId, DstNId) + + Deletes an edge from node IDs *SrcNId* to *DstNId* from the graph. + If the edge from *SrcNId* to *DstNId* does not exist in the graph, + function still completes. But the function throws an exception, + if *SrcNId* or *DstNId* are not nodes in the graph. + + .. describe:: IsEdge(SrcNId, DstNId) + + Tests whether an edge from node *SrcNId* to *DstNId* exists in the graph. + + .. describe:: BegEI() + + Returns an edge iterator referring to the first edge in the graph. + + .. describe:: EndEI() + + Returns an edge iterator referring to the past-the-end edge in the graph. + + .. describe:: GetEI(EId) + + Returns an edge iterator referring to edge with ID *EId*. + + .. describe:: GetEI(SrcNId, DstNId) + + Returns an edge iterator referring to edge between node IDs *SrcNId* + and *DstNId* in the graph. + + .. describe:: GetRndEId() + + Returns an ID of a random edge in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: GetEIdV(EIdV) + + Returns IDs of all the edges in vector *EIdV*, which must be of type *TIntV*. + + .. describe:: Empty() + + Returns true if the graph is empty, has zero nodes. + + .. describe:: Clr() + + Deletes all nodes and edges from the graph. + + .. describe:: Reserve(Nodes, Edges) + + Reserves memory for a graph of *Nodes* nodes and *Edges* edges. + + .. describe:: ReserveNIdInDeg(NId, Deg) + + Reserves memory for node ID *NId* having *InDeg* in-edges. + + .. describe:: ReserveNIdOutDeg(NId, Deg) + + Reserves memory for node ID *NId* having *OutDeg* out-edges. + + .. describe:: HasFlag(Flag) + + Allows for run-time checking the type of the graph (see the TGraphFlag for flag definitions). + + .. describe:: Defrag() + + Defragments the graph. After performing many node and edge + insertions and deletions to a graph, the graph data structure + can be fragmented in memory. This function compacts down the + graph data structure and frees unneeded memory. + + .. describe:: Dump(OutF=sys.stdout) + + Prints the graph in a human readable form to the output stream *OutF*. + + .. describe:: GetSmallGraph() + + Returns a small multigraph on 5 nodes and 6 edges. + + :class:`TNEANet` methods for node and edge attributes support + attributes of different types. + Integer, float and string attributes are implemented. + Each attribute type has its own method for a particular task. + Attributes are named via string names. The sections below describe + methods for dealing with node attributes first, followed by methods for + edge attributes. + + :class:`TNEANet` methods for node attributes are the following: + + .. describe:: AddIntAttrN(Attr) + AddFltAttrN(Attr) + AddStrAttrN(Attr) + + Defines a new integer, float or string node attribute, respectively. + + .. describe:: DelAttrN(Attr) + + Deletes node attribute *Attr*. + + .. describe:: GetAttrIndN(Attr) + + Returns the index of the value vector for node attribute *Attr*. + + .. describe:: AddIntAttrDatN(NodeI, Value, Attr) + AddFltAttrDatN(NodeI, Value, Attr) + AddStrAttrDatN(NodeI, Value, Attr) + + Sets the value of attribute named *Attr* for the node referred to + by node iterator *NodeI* to *Value*. + *Value* is an integer, a float, or a string, respectively. + + .. describe:: AddIntAttrDatN(NId, Value, Attr) + AddFltAttrDatN(NId, Value, Attr) + AddStrAttrDatN(NId, Value, Attr) + + Sets the value of attribute named *Attr* for the node with + node id *NId* to *Value*. + *Value* is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrDatN(NodeI, Attr) + GetFltAttrDatN(NodeI, Attr) + GetStrAttrDatN(NodeI, Attr) + + Returns the value of attribute named *Attr* for the node referred to + by node iterator *NodeI*. + Result is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrDatN(NId, Attr) + GetFltAttrDatN(NId, Attr) + GetStrAttrDatN(NId, Attr) + + Returns the value of attribute named *Attr* for the node with + node id *NId*. + Result is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrIndDatN(NodeI, Index) + GetFltAttrIndDatN(NodeI, Index) + GetStrAttrIndDatN(NodeI, Index) + + Returns the value of attribute at *Index* for the node referred to + by node iterator *NodeI*. + Result is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrIndDatN(NId, Index) + GetFltAttrIndDatN(NId, Index) + GetStrAttrIndDatN(NId, Index) + + Returns the value of attribute at *Index* for the node with + node id *NId*. + Result is an integer, a float, or a string, respectively. + + .. describe:: BegNAIntI(Attr) + BegNAFltI(Attr) + BegNAStrI(Attr) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the first node. + + .. describe:: EndNAIntI(Attr) + EndNAFltI(Attr) + EndNAStrI(Attr) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the past-the-end node. + + .. describe:: GetNAIntI(Attr, NId) + GetNAFltI(Attr, NId) + GetNAStrI(Attr, NId) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the node + with node ID *NId*. + + .. describe:: DelAttrDatN(NodeI, Attr) + + Deletes the value of attribute named *Attr* for the node referred to + by node iterator *NodeI*. + + .. describe:: DelAttrDatN(NId, Attr) + + Deletes the value of attribute named *Attr* for the node with + node ID *NId*. + + .. describe:: IsAttrDeletedN(NId, Attr) + + Returns true, if attribute *Attr* exists for node *NId* and + has been deleted -- its value is set to default. + + .. describe:: IsIntAttrDeletedN(NId, Attr) + IsFltAttrDeletedN(NId, Attr) + IsStrAttrDeletedN(NId, Attr) + + Returns true, if integer, float, or string attribute *Attr* exists + for node *NId* and has been deleted -- its value is set to default. + + .. describe:: AttrNameNI(NId, NameV) + + Provides names of attributes for the node *NId*. Only attributes + with an assigned value are provided. Attribute names are returned + as strings in *NameV*, which must be of type *TStrV*. + + .. describe:: IntAttrNameNI(NId, NameV) + FltAttrNameNI(NId, NameV) + StrAttrNameNI(NId, NameV) + + Provides names of integer, float, or string attributes for the + node *NId*, respectively. Only attributes with an assigned value + are provided. Attribute names are returned as strings in *NameV*, + which must be of type *TStrV*. + + .. describe:: AttrValueNI(NId, ValueV) + + Provides values of attributes for the node *NId*. Only attributes + with an assigned value are provided. Attribute values are converted + to strings and returned in *ValueV*, which must be of type *TStrV*. + + .. describe:: IntAttrValueNI(NId, ValueV) + FltAttrValueNI(NId, ValueV) + StrAttrValueNI(NId, ValueV) + + Provides values of integer, float, or string attributes for the + node *NId*, respectively. Only attributes with an assigned value + are provided. Attribute values are returned as integers, floats, or + strings in *ValueV*, which must be of type *TIntV*, *TFltV*, or + *TStrV*, respectively. + + :class:`TNEANet` methods for edge attributes are the following: + + .. describe:: AddIntAttrE(Attr) + AddFltAttrE(Attr) + AddStrAttrE(Attr) + + Defines a new integer, float or string edge attribute, respectively. + + .. describe:: DelAttrE(Attr) + + Deletes edge attribute *Attr*. + + .. describe:: GetAttrIndE(Attr) + + Returns the index of the value vector for edge attribute *Attr*. + + .. describe:: AddIntAttrDatE(EdgeI, Value, Attr) + AddFltAttrDatE(EdgeI, Value, Attr) + AddStrAttrDatE(EdgeI, Value, Attr) + + Sets the value of attribute named *Attr* for the edge referred to + by edge iterator *EdgeI* to *Value*. + *Value* is an integer, a float, or a string, respectively. + + .. describe:: AddIntAttrDatE(EId, Value, Attr) + AddFltAttrDatE(EId, Value, Attr) + AddStrAttrDatE(EId, Value, Attr) + + Sets the value of attribute named *Attr* for the edge with + edge id *EId* to *Value*. + *Value* is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrDatE(EdgeI, Attr) + GetFltAttrDatE(EdgeI, Attr) + GetStrAttrDatE(EdgeI, Attr) + + Returns the value of attribute named *Attr* for the edge referred to + by edge iterator *EdgeI*. + Result is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrDatE(EId, Attr) + GetFltAttrDatE(EId, Attr) + GetStrAttrDatE(EId, Attr) + + Returns the value of attribute named *Attr* for the edge with + edge id *EId*. + Result is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrIndDatE(EdgeI, Index) + GetFltAttrIndDatE(EdgeI, Index) + GetStrAttrIndDatE(EdgeI, Index) + + Returns the value of attribute at *Index* for the edge referred to + by edge iterator *EdgeI*. + Result is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrIndDatE(EId, Index) + GetFltAttrIndDatE(EId, Index) + GetStrAttrIndDatE(EId, Index) + + Returns the value of attribute at *Index* for the edge with + edge id *EId*. + Result is an integer, a float, or a string, respectively. + + .. describe:: BegEAIntI(Attr) + BegEAFltI(Attr) + BegEAStrI(Attr) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the first edge. + + .. describe:: EndEAIntI(Attr) + EndEAFltI(Attr) + EndEAStrI(Attr) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the past-the-end edge. + + .. describe:: GetEAIntI(Attr, EId) + GetEAFltI(Attr, EId) + GetEAStrI(Attr, EId) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the edge + with edge ID *EId*. + + .. describe:: DelAttrDatE(EdgeI, Attr) + + Deletes the value of attribute named *Attr* for the edge referred to + by edge iterator *EdgeI*. + + .. describe:: DelAttrDatE(EId, Attr) + + Deletes the value of attribute named *Attr* for the edge with + edge ID *EId*. + + .. describe:: IsAttrDeletedE(EId, Attr) + + Returns true, if attribute *Attr* exists for edge *EId* and + has been deleted -- its value is set to default. + + .. describe:: IsIntAttrDeletedE(EId, Attr) + IsFltAttrDeletedE(EId, Attr) + IsStrAttrDeletedE(EId, Attr) + + Returns true, if integer, float, or string attribute *Attr* exists + for edge *EId* and has been deleted -- its value is set to default. + + .. describe:: AttrNameEI(EId, NameV) + + Provides names of attributes for the edge *EId*. Only attributes + with an assigned value are provided. Attribute names are returned + as strings in *NameV*, which must be of type *TStrV*. + + .. describe:: IntAttrNameEI(EId, NameV) + FltAttrNameEI(EId, NameV) + StrAttrNameEI(EId, NameV) + + Provides names of integer, float, or string attributes for the + edge *EId*, respectively. Only attributes with an assigned value + are provided. Attribute names are returned as strings in *NameV*, + which must be of type *TStrV*. + + .. describe:: AttrValueEI(EId, ValueV) + + Provides values of attributes for the edge *EId*. Only attributes + with an assigned value are provided. Attribute values are converted + to strings and returned in *ValueV*, which must be of type *TStrV*. + + .. describe:: IntAttrValueEI(EId, ValueV) + FltAttrValueEI(EId, ValueV) + StrAttrValueEI(EId, ValueV) + + Provides values of integer, float, or string attributes for the + edge *EId*, respectively. Only attributes with an assigned value + are provided. Attribute values are returned as integers, floats, or + strings in *ValueV*, which must be of type *TIntV*, *TFltV*, or + *TStrV*, respectively. + + .. describe:: AttrValueEI(EId, ValueV) + + Provides values of attributes for the edge *EId*. Only attributes + with an assigned value are provided. Attribute values are converted + to strings and returned in *ValueV*, which must be of type *TStrV*. + + :class:`TNEANet` also provides methods for sparse attributes. **NOTE** these methods + are currently under development: + + .. describe:: AddSAttrDatN(NId, AttrName, Val) + AddSAttrDatN(NId, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + node with id *NId*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDatN(NId, AttrName, Val) + GetSAttrDat(NId, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + node with id *NId*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDatN(NId, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + node with id *NId*. + + .. describe:: GetSAttrVN(NId, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given node with id *NId*. + *AttrType* should be one of IntType, FltType, or StrType. *AttrV* stores the results - + a list of pairs, where each pair gives the attribute name and type. The type is + :class:`TAttrPrV`. + + .. describe:: GetIdVSAttrN(AttrName, IdV) + GetIdVSAttrN(AttrId, IdV) + + Get a list of all nodes that have an attribute with name *AttrName* or id + *AttrId*. + + .. describe:: AddSAttrN(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrIdN(Name, AttrId, AttrType) + + Given the node attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrNameN(AttrId, Name, AttrType) + + Given the node attribute id *AttrId*, get the attribute name. + + .. describe:: AddSAttrDatE(EId, AttrName, Val) + AddSAttrDatE(EId, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + edge with id *EId*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDatE(EId, AttrName, Val) + GetSAttrDatE(EId, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + edge with id *EId*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDat(EId, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + edge with id *EId*. + + .. describe:: GetSAttrVE(EId, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given edge with id *EId*. + *AttrType* should be one of IntType, FltType, or StrType. *AttrV* stores the results - + a list of pairs, where each pair gives the attribute name and type. The type is + :class:`TAttrPrV`. + + .. describe:: GetIdVSAttrE(AttrName, IdV) + GetIdVSAttrE(AttrId, IdV) + + Get a list of all edges that have an attribute with name *AttrName* or id + *AttrId*. + + .. describe:: AddSAttrE(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrIdE(Name, AttrId, AttrType) + + Given the edge attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrNameE(AttrId, Name, AttrType) + + Given the edge attribute id *AttrId*, get the attribute name. + + Below is some code demonstrating the use of the :class:`TNEANet` class: + + >>> G3 = snap.TNEANet.New() + >>> G3.AddNode(1) + 1 + >>> G3.AddNode(2) + 2 + >>> G3.AddNode(5) + 5 + >>> G3.AddEdge(1,5) + 0 + >>> G3.AddEdge(1,2) + 1 + >>> G3.AddEdge(1,2) + 2 + >>> print(G3.Empty()) + False + >>> print(G3.GetNodes()) + 3 + >>> print(G3.GetEdges()) + 3 + +TNEANetNodeI +============ + +.. class:: TNEANetNodeI() + + Returns a new node iterator for :class:`TNEANet`. Normally, these + objects are not created directly, + but obtained via a call to the network class :class:`TNEANet` method, + such as :meth:`BegNI()`, that returns a node iterator. + + :class:`TNEANetNodeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next node in the graph. + + .. describe:: GetId() + + Returns node ID of the current node. + + .. describe:: GetDeg() + + Returns degree of the current node, the sum of in-degree and out-degree. + + .. describe:: GetInDeg() + + Returns in-degree of the current node. + + .. describe:: GetOutDeg() + + Returns out-degree of the current node. + + .. describe:: GetInNId(NodeN) + + Returns ID of *NodeN*-th in-node (the node pointing to the current node). + + .. describe:: GetOutNId(NodeN) + + Returns ID of *NodeN*-th out-node (the node the current node points to). + + .. describe:: GetNbrNId(NodeN) + + Returns ID of *NodeN*-th neighboring node. + + .. describe:: IsInNId(NId) + + Tests whether node with ID *NId* points to the current node. + + .. describe:: IsOutNId(NId) + + Tests whether the current node points to node with ID *NId*. + + .. describe:: IsNbrNId(NId) + + Tests whether node with ID *NId* is a neighbor of the current node. + +TNEANetEdgeI +============ + +.. class:: TNEANetEdgeI() + + Returns a new edge iterator for :class:`TNEANet`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TNEANet` method, + such as :meth:`BegEI()`, that returns an edge iterator. + + :class:`TNEANetEdgeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next edge in the graph. + + .. describe:: GetId() + + Returns edge ID. + + .. describe:: GetSrcNId() + + Returns the ID of the source node of the edge. + + .. describe:: GetDstNId() + + Returns the ID of the destination node of the edge. + +TNEANetAIntI, TNEANetAFltI, TNEANetAStrI +======================================== + +.. class:: TNEANetAIntI() + TNEANetAFltI() + TNEANetAStrI() + + Returns a new integer, float or string attribute iterator + for :class:`TNEANet`. Normally, these objects are not created directly, + but obtained via a call to the graph class :class:`TNEANet` method, + such as :meth:`BegNAIntI()`, which returns an integer node iterator, or + :meth:`BegEAFltI()`, which returns a float edge iterator. + + Attribute iterators provide the following methods: + + .. describe:: Next() + + Moves the iterator to the next node or edge in the graph. + + .. describe:: GetDat() + + Returns an attribute of the node or edge. + + .. describe:: IsDeleted() + + Returns true if the attribute has been deleted. + +TUndirNet +========== + +.. class:: TUndirNet() + TUndirNet(Nodes, Edges) + + Returns a new undirected graph. If no parameters are provided, + an empty graph is created. If *Nodes* and *Edges* are specified, space + is preallocated for *Nodes* nodes and *Edges* edges. + Do not call these methods directly! To create a new :class:`TUndirNet` + object, use one of the :meth:`New()` methods. + + Nodes have IDs, which are arbitrary non-negative integers. Nodes and edges + have no attributes/data associated with them. There is at most one + undirected edge between a pair of nodes. Self loops (one per node) are + allowed but multiple (parallel) edges are not. The undirected graph data + structure is implemented using sorted adjacency lists. This means adding + a node takes constant time, while adding an edge takes linear time (since + adjacency list is kept sorted) in the node degree. Accessing arbitrary + node takes constant time and accessing any edge takes logarithmic time + in the node degree. + + :class:`TUndirNet` provides iterators for fast traversal of nodes and edges. + Iterator classes are :class:`TUndirNetNodeI` for iterating over nodes and + :class:`TUndirNetEdgeI` for iterating over edges. + + :class:`TUndirNet` provides the following methods: + + .. describe:: New() + + Returns a pointer to a new graph. + + .. describe:: New(Nodes, Edges) + + Returns a pointer to a new graph and reserves enough memory for + *Nodes* nodes and *Edges* edges. + + .. describe:: Load(SIn) + + Loads a graph from a binary stream *SIn* and returns a pointer to it. + + .. describe:: Save(SOut) + + Saves the graph to a binary stream *SOut*. + + .. describe:: GetNodes() + + Returns the number of nodes in the graph. + + .. describe:: AddNode(NId) + + Adds a node of ID *NId* to the graph, *NId* is an integer. + Returns node ID. If NId is -1, node ID is automatically assigned. + It throws an exception, if a node with ID *NId* already exists. + + .. describe:: AddNode(NodeI) + + Adds a node of ID *NodeI.GetId()* to the graph. *NodeI* is a node iterator. Returns node ID. + + .. describe:: DelNode(NId) + + Deletes node of ID *NId* from the graph. *NId* is an integer. + + .. describe:: DelNode(NodeI) + + Deletes node of ID *NodeI.GetId()* from the graph. *NodeI* is a node iterator. + + .. describe:: IsNode(NId) + + Returns true, if ID *NId* is a node in the graph. + + .. describe:: BegNI() + + Returns a node iterator referring to the first node in the graph. + + .. describe:: EndNI() + + Returns a node iterator referring to the past-the-end node in the graph. + + .. describe:: GetNI(NId) + + Returns a node iterator referring to the node of ID *NId* in the graph. + + .. describe:: GetMxNId() + + Returns an ID that is larger than any node ID in the graph. + + .. describe:: GetEdges() + + Returns the number of edges in the graph. + + .. describe:: AddEdge(SrcNId, DstNId) + + Adds an edge between node IDs *SrcNId* and *DstNId* to the graph. + Returns -1, if the edge was successfully added. Returns -2, if the + edge already exists. The function throws an exception, if *SrcNId* + or *DstNId* are not nodes in the graph. + + .. describe:: AddEdge(EdgeI) + + Adds an edge between *EdgeI.GetSrcNId()* and *EdgeI.GetDstNId()* to the graph. *EdgeI* is an edge iterator. Returns -1, if successful. Returns -2, otherwise. + + .. describe:: DelEdge(SrcNId, DstNId) + + Deletes an edge between node IDs *SrcNId* and *DstNId* from the graph. + If the edge between *SrcNId* and *DstNId* does not exist in the graph, + function still completes. But the function throws an exception, + if *SrcNId* or *DstNId* are not nodes in the graph. + + .. describe:: IsEdge(SrcNId, DstNId) + + Tests whether an edge between node IDs *SrcNId* and *DstNId* exists in the graph. + + .. describe:: BegEI() + + Returns an edge iterator referring to the first edge in the graph. + + .. describe:: EndEI() + + Returns an edge iterator referring to the past-the-end edge in the graph. + + .. describe:: GetEI(SrcNId, DstNId) + + Returns an edge iterator referring to edge between node IDs *SrcNId* + and *DstNId* in the graph. Since this is an undirected graph + *GetEI(SrcNId, DstNId)* has the same effect as *GetEI(DstNId, SrcNId)*. + + .. describe:: GetRndNId() + + Returns an ID of a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: GetRndNI() + + Returns a node iterator referring to a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: Empty() + + Returns true if the graph is empty, has zero nodes. + + .. describe:: Clr() + + Deletes all nodes and edges from the graph. + + .. describe:: Reserve(Nodes, Edges) + + Reserves memory for a graph of *Nodes* nodes and *Edges* edges. + + .. describe:: ReserveNIdDeg(NId, Deg) + + Reserves memory for node ID *NId* having *Deg* edges. + + .. describe:: HasFlag(Flag) + + Allows for run-time checking the type of the graph (see the TGraphFlag for flag definitions). + + .. describe:: Defrag() + + Defragments the graph. After performing many node and edge + insertions and deletions to a graph, the graph data structure + can be fragmented in memory. This function compacts down the + graph data structure and frees unneeded memory. + + .. describe:: Dump(OutF=sys.stdout) + + Prints the graph in a human readable form to the output stream *OutF*. + + .. describe:: GetSmallGraph() + + Returns a small graph on 5 nodes and 5 edges. + + :class:`TUndirNet` also provides methods for sparse attributes. **NOTE** these methods + are currently under development: + + .. describe:: AddSAttrDatN(NId, AttrName, Val) + AddSAttrDatN(NId, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + node with id *NId*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDatN(NId, AttrName, Val) + GetSAttrDat(NId, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + node with id *NId*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDatN(NId, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + node with id *NId*. + + .. describe:: GetSAttrVN(NId, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given node with id *NId*. + *AttrType* should be one of IntType, FltType, or StrType. *AttrV* stores the results - + a list of pairs, where each pair gives the attribute name and type. The type is + :class:`TAttrPrV`. + + .. describe:: GetIdVSAttrN(AttrName, IdV) + GetIdVSAttrN(AttrId, IdV) + + Get a list of all nodes that have an attribute with name *AttrName* or id + *AttrId*. + + .. describe:: AddSAttrN(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrIdN(Name, AttrId, AttrType) + + Given the node attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrNameN(AttrId, Name, AttrType) + + Given the node attribute id *AttrId*, get the attribute name. + + .. describe:: AddSAttrDatE(SrcNId, DstNId, AttrName, Val) + AddSAttrDatE(SrcNId, DstNId, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + edge from *SrcNId* to *DstNId*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDatE(SrcNId, DstNId, AttrName, Val) + GetSAttrDatE(SrcNId, DstNId, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + edge from *SrcNId* to *DstNId*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDat(SrcNId, DstNId, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + edge from *SrcNId* to *DstNId*. + + .. describe:: GetSAttrVE(SrcNId, DstNId, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given edge from *SrcNId* to *DstNId*. + *AttrType* should be one of IntType, FltType, or StrType. *AttrV* stores the results - + a list of pairs, where each pair gives the attribute name and type. The type is + :class:`TAttrPrV`. + + .. describe:: GetIdVSAttrE(AttrName, IdV) + GetIdVSAttrE(AttrId, IdV) + + Get a list of all edges that have an attribute with name *AttrName* or id + *AttrId*. *IdV* is a list of integer pairs, giving the source and destination + node ids. + + .. describe:: AddSAttrE(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrIdE(Name, AttrId, AttrType) + + Given the edge attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrNameE(AttrId, Name, AttrType) + + Given the edge attribute id *AttrId*, get the attribute name. + + Below is some code demonstrating the use of the :class:`TUndirNet` class: + + >>> G1 = snap.TUndirNet.New() + >>> G1.AddNode(1) + 1 + >>> G1.AddNode(2) + 2 + >>> G1.AddNode(5) + 5 + >>> G1.AddEdge(1,5) + -1 + >>> G1.AddEdge(1,2) + -1 + >>> print(G1.Empty()) + False + >>> print(G1.GetNodes()) + 3 + >>> print(G1.GetEdges()) + 2 + +TUndirNetNodeI +=============== + +.. class:: TUndirNetNodeI() + + Returns a new node iterator for :class:`TUndirNet`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TUndirNet` method, + such as :meth:`BegNI()`, that returns a node iterator. + + :class:`TUndirNetNodeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next node in the graph. + + .. describe:: GetId() + + Returns node ID of the current node. + + .. describe:: GetDeg() + GetInDeg() + GetOutDeg() + + Returns degree of the current node. Since the graph is undirected, + all three methods return the same value. + + .. describe:: GetInNId(NodeN) + + Returns ID of *NodeN*-th in-node (the node pointing to the current node). + + .. describe:: GetOutNId(NodeN) + + Returns ID of *NodeN*-th out-node (the node the current node points to). + + .. describe:: GetNbrNId(NodeN) + + Returns ID of *NodeN*-th neighboring node. + + .. describe:: IsInNId(NId) + + Tests whether node with ID *NId* points to the current node. + + .. describe:: IsOutNId(NId) + + Tests whether the current node points to node with ID *NId*. + + .. describe:: IsNbrNId(NId) + + Tests whether node with ID *NId* is a neighbor of the current node. + +TUndirNetEdgeI +=============== + +.. class:: TUndirNetEdgeI() + + Returns a new edge iterator for :class:`TUndirNet`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TUndirNet` method, + such as :meth:`BegEI()`, that returns an edge iterator. + + :class:`TUndirNetEdgeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next edge in the graph. + + .. describe:: GetId() + + Always returns -1 for :class:`TUndirNet`, since edges + do not have explicit IDs. + + .. describe:: GetSrcNId() + + Returns the ID of the source node of the edge. + Since the graph is undirected, + this is the node with a smaller ID of the edge endpoints. + + .. describe:: GetDstNId() + + Returns the ID of the destination node of the edge. + Since the graph is undirected, + this is the node with a greater ID of the edge endpoints. + +TDirNet +======== + +.. class:: TDirNet() + TDirNet(Nodes, Edges) + + Returns a new directed graph. If no parameters are provided, + an empty graph is created. If *Nodes* and *Edges* are specified, space + is preallocated for *Nodes* nodes and *Edges* edges. + Do not call these methods directly! To create a new :class:`TDirNet` + object, use one of the :meth:`New()` methods. + + Nodes have IDs, which are arbitrary non-negative integers. Nodes and edges + have no attributes/data associated with them. There is at most one + directed edge from one source node to a destination node. There can be + an edge between the same pair of nodes in the opposite direction. Self + loops (one per node) are allowed but multiple (parallel) edges are not. + The directed graph data structure is implemented using sorted adjacency + lists. This means adding a node takes constant time, while adding an edge + takes linear time (since adjacency list is kept sorted) in the node + degree. Accessing an arbitrary node takes constant time and accessing + any edge takes logarithmic time in the node degree. + + :class:`TDirNet` provides iterators for fast traversal of nodes and edges. + Iterator classes are :class:`TDirNetNodeI` for iterating over nodes and + :class:`TDirNetEdgeI` for iterating over edges. + + :class:`TDirNet` provides the following methods: + + .. describe:: New() + + Returns a pointer to a new graph. + + .. describe:: New(Nodes, Edges) + + Returns a pointer to a new graph and reserves enough memory for + *Nodes* nodes and *Edges* edges. + + .. describe:: Load(SIn) + + Loads a graph from a binary stream *SIn* and returns a pointer to it. + + .. describe:: Save(SOut) + + Saves the graph to a binary stream *SOut*. + + .. describe:: GetNodes() + + Returns the number of nodes in the graph. + + .. describe:: AddNode(NId) + + Adds a node of ID *NId* to the graph, *NId* is an integer. + Returns node ID. If NId is -1, node ID is automatically assigned. + It throws an exception, if a node with ID *NId* already exists. + + .. describe:: AddNode(NodeI) + + Adds a node of ID *NodeI.GetId()* to the graph. *NodeI* is a node iterator. Returns node ID. + + .. describe:: DelNode(NId) + + Deletes node of ID *NId* from the graph. *NId* is an integer. + If the node of ID *NId* does not exist, the function throws an exception. + + .. describe:: DelNode(NodeI) + + Deletes node of ID *NodeI.GetId()* from the graph. *NodeI* is a node iterator. + + .. describe:: IsNode(NId) + + Returns true, if ID *NId* is a node in the graph. + + .. describe:: BegNI() + + Returns a node iterator referring to the first node in the graph. + + .. describe:: EndNI() + + Returns a node iterator referring to the past-the-end node in the graph. + + .. describe:: GetNI(NId) + + Returns a node iterator referring to the node of ID *NId* in the graph. + + .. describe:: GetMxNId() + + Returns an ID that is larger than any node ID in the graph. + + .. describe:: GetEdges() + + Returns the number of edges in the graph. + + .. describe:: AddEdge(SrcNId, DstNId) + + Adds an edge from node *SrcNId* to node *DstNId* to the graph. + Returns -1, if the edge was successfully added. Returns -2, if the + edge already exists. The function throws an exception, if *SrcNId* + or *DstNId* are not nodes in the graph. + + .. describe:: AddEdge(EdgeI) + + Adds an edge from *EdgeI.GetSrcNId()* to *EdgeI.GetDstNId()* to the graph. *EdgeI* is an edge iterator. Returns -1, if successful. Returns -2, otherwise. + + .. describe:: DelEdge(SrcNId, DstNId) + + Deletes an edge from node IDs *SrcNId* to *DstNId* from the graph. + If the edge from *SrcNId* to *DstNId* does not exist in the graph, + function still completes. But the function throws an exception, + if *SrcNId* or *DstNId* are not nodes in the graph. + + .. describe:: IsEdge(SrcNId, DstNId) + + Tests whether an edge from node *SrcNId* to *DstNId* exists in the graph. + + .. describe:: BegEI() + + Returns an edge iterator referring to the first edge in the graph. + + .. describe:: EndEI() + + Returns an edge iterator referring to the past-the-end edge in the graph. + + .. describe:: GetEI(SrcNId, DstNId) + + Returns an edge iterator referring to edge between node IDs *SrcNId* + and *DstNId* in the graph. + + .. describe:: GetRndNId() + + Returns an ID of a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: GetRndNI() + + Returns a node iterator referring to a random node in the graph. For this method to return different values on subsequent program executions, the random generator must be seeded first, see the example under *TUNGraph.GetRndNId()*. + + .. describe:: Empty() + + Returns true if the graph is empty, has zero nodes. + + .. describe:: Clr() + + Deletes all nodes and edges from the graph. + + .. describe:: Reserve(Nodes, Edges) + + Reserves memory for a graph of *Nodes* nodes and *Edges* edges. + + .. describe:: ReserveNIdInDeg(NId, Deg) + + Reserves memory for node ID *NId* having *InDeg* in-edges. + + .. describe:: ReserveNIdOutDeg(NId, Deg) + + Reserves memory for node ID *NId* having *OutDeg* out-edges. + + .. describe:: HasFlag(Flag) + + Allows for run-time checking the type of the graph (see the TGraphFlag for flag definitions). + + .. describe:: Defrag() + + Defragments the graph. After performing many node and edge + insertions and deletions to a graph, the graph data structure + can be fragmented in memory. This function compacts down the + graph data structure and frees unneeded memory. + + .. describe:: Dump(OutF=sys.stdout) + + Prints the graph in a human readable form to the output stream *OutF*. + + .. describe:: GetSmallGraph() + + Returns a small graph on 5 nodes and 6 edges. + + :class:`TDirNet` also provides methods for sparse attributes. **NOTE** these methods + are currently under development: + + .. describe:: AddSAttrDatN(NId, AttrName, Val) + AddSAttrDatN(NId, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + node with id *NId*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDatN(NId, AttrName, Val) + GetSAttrDat(NId, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + node with id *NId*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDatN(NId, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + node with id *NId*. + + .. describe:: GetSAttrVN(NId, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given node with id *NId*. + *AttrType* should be one of IntType, FltType, or StrType. *AttrV* stores the results - + a list of pairs, where each pair gives the attribute name and type. The type is + :class:`TAttrPrV`. + + .. describe:: GetIdVSAttrN(AttrName, IdV) + GetIdVSAttrN(AttrId, IdV) + + Get a list of all nodes that have an attribute with name *AttrName* or id + *AttrId*. + + .. describe:: AddSAttrN(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrIdN(Name, AttrId, AttrType) + + Given the node attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrNameN(AttrId, Name, AttrType) + + Given the node attribute id *AttrId*, get the attribute name. + + .. describe:: AddSAttrDatE(SrcNId, DstNId, AttrName, Val) + AddSAttrDatE(SrcNId, DstNId, AttrId, Val) + + Adds attribute with name *AttrName* or attribtue id *AttrId* for the given + edge from *SrcNId* to *DstNId*. *Val* can be an int, float, or string. + + .. describe:: GetSAttrDatE(SrcNId, DstNId, AttrName, Val) + GetSAttrDatE(SrcNId, DstNId, AttrId, Val) + + Gets attribute with name *AttrName* or attribute id *AttrId* for the given + edge from *SrcNId* to *DstNId*. Resulting value is stored in *Val*. + + .. describe:: DelSAttrDat(SrcNId, DstNId, AttrId) + + Delete attribute with name *AttrName* or attribute id *AttrId* for the given + edge from *SrcNId* to *DstNId*. + + .. describe:: GetSAttrVE(SrcNId, DstNId, AttrType, AttrV) + + Get a list of all attributes of type *AttrType* for the given edge from *SrcNId* to *DstNId*. + *AttrType* should be one of IntType, FltType, or StrType. *AttrV* stores the results - + a list of pairs, where each pair gives the attribute name and type. The type is + :class:`TAttrPrV`. + + .. describe:: GetIdVSAttrE(AttrName, IdV) + GetIdVSAttrE(AttrId, IdV) + + Get a list of all edges that have an attribute with name *AttrName* or id + *AttrId*. *IdV* is a list of integer pairs, giving the source and destination + node ids. + + .. describe:: AddSAttrE(Name, AttrType, AttrId) + + Adds a mapping for an attribute with name *Name* and type *AttrType*. *AttrId* + is updated with the assigned attribute integer id. + + .. describe:: GetSAttrIdE(Name, AttrId, AttrType) + + Given the edge attribute name *Name*, get the attribute id. + + .. describe:: GetSAttrNameE(AttrId, Name, AttrType) + + Given the edge attribute id *AttrId*, get the attribute name. + + Below is some code demonstrating the use of the :class:`TDirNet` class: + + >>> G2 = snap.TDirNet.New() + >>> G2.AddNode(1) + 1 + >>> G2.AddNode(2) + 2 + >>> G2.AddNode(5) + 5 + >>> G2.AddEdge(1,5) + -1 + >>> G2.AddEdge(1,2) + -1 + >>> print(G2.Empty()) + False + >>> print(G2.GetNodes()) + 3 + >>> print(G2.GetEdges()) + 2 + +TDirNetNodeI +============= + +.. class:: TDirNetNodeI() + + Returns a new node iterator for :class:`TDirNet`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TDirNet` method, + such as :meth:`BegNI()`, that returns a node iterator. + + :class:`TDirNetNodeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next node in the graph. + + .. describe:: GetId() + + Returns node ID of the current node. + + .. describe:: GetDeg() + + Returns degree of the current node, the sum of in-degree and out-degree. + + .. describe:: GetInDeg() + + Returns in-degree of the current node. + + .. describe:: GetOutDeg() + + Returns out-degree of the current node. + + .. describe:: GetInNId(NodeN) + + Returns ID of *NodeN*-th in-node (the node pointing to the current node). + + .. describe:: GetOutNId(NodeN) + + Returns ID of *NodeN*-th out-node (the node the current node points to). + + .. describe:: GetNbrNId(NodeN) + + Returns ID of *NodeN*-th neighboring node. + + .. describe:: IsInNId(NId) + + Tests whether node with ID *NId* points to the current node. + + .. describe:: IsOutNId(NId) + + Tests whether the current node points to node with ID *NId*. + + .. describe:: IsNbrNId(NId) + + Tests whether node with ID *NId* is a neighbor of the current node. + +TDirNetEdgeI +============= + +.. class:: TDirNetEdgeI() + + Returns a new edge iterator for :class:`TDirNet`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TDirNet` method, + such as :meth:`BegEI()`, that returns an edge iterator. + + :class:`TDirNetEdgeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next edge in the graph. + + .. describe:: GetId() + + Always returns -1 for :class:`TDirNet`, since edges + do not have explicit IDs. + + .. describe:: GetSrcNId() + + Returns the ID of the source node of the edge. + + .. describe:: GetDstNId() + + Returns the ID of the destination node of the edge. + diff --git a/snap-python/source/doc/source/reference/index-ref.rst b/snap-python/source/doc/source/reference/index-ref.rst new file mode 100644 index 0000000000000000000000000000000000000000..72c6a26d1000a41c31bb3a204047e693491895ab --- /dev/null +++ b/snap-python/source/doc/source/reference/index-ref.rst @@ -0,0 +1,39 @@ +Snap.py Reference Manual +------------------------ + +Contents: + +.. toctree:: + :maxdepth: 1 + + introduction + basic + composite + streams + graphs + table + multimodal + attr + generators + conv + io + degree + edges + manipulation + subgraphs + info + draw + cncom + bfsdfs + centr + community + triads + kcore + anf + svd + legacy-swig + contrib + +.. # classes +.. # util + diff --git a/snap-python/source/doc/source/reference/info.rst b/snap-python/source/doc/source/reference/info.rst new file mode 100644 index 0000000000000000000000000000000000000000..f260ba7bbf940c0504236e1ef9ef96561dd10df7 --- /dev/null +++ b/snap-python/source/doc/source/reference/info.rst @@ -0,0 +1,10 @@ + +Graph Information +````````````````` + +.. toctree:: + :maxdepth: 2 + + IsTree + PrintInfo + diff --git a/snap-python/source/doc/source/reference/introduction.rst b/snap-python/source/doc/source/reference/introduction.rst new file mode 100644 index 0000000000000000000000000000000000000000..5e9dbfa957d9fc2c7f242fc08bc8ab46acf558f8 --- /dev/null +++ b/snap-python/source/doc/source/reference/introduction.rst @@ -0,0 +1,20 @@ +Introduction +```````````` + +This document is a reference guide to Snap.py functionality. + +Snap.py is a Python interface for SNAP. SNAP is a general purpose, +high performance system for analysis and manipulation of large networks. +SNAP is written in C++ and optimized for maximum performance and +compact graph representation. It easily scales to massive networks +with hundreds of millions of nodes, and billions of edges. + +Snap.py provides performance benefits of SNAP, combined with flexibility +of Python. Most of the SNAP functionality is available via Snap.py in Python. + +To use Snap.py in Python, import the **snap** module: + +>>> import snap + +The code in this document assumes that Snap.py has been imported as shown above. + diff --git a/snap-python/source/doc/source/reference/io.rst b/snap-python/source/doc/source/reference/io.rst new file mode 100644 index 0000000000000000000000000000000000000000..bb301badf45e16282765b97579cf8e92a2a67c9d --- /dev/null +++ b/snap-python/source/doc/source/reference/io.rst @@ -0,0 +1,19 @@ + +Input and Output +```````````````` + +.. toctree:: + :maxdepth: 2 + + LoadEdgeList + SaveEdgeList + LoadEdgeListStr + LoadConnList + LoadConnListStr + SaveGViz + SaveGVizColor + SaveMatlabSparseMtx + LoadPajek + SavePajek + LoadDyNet + diff --git a/snap-python/source/doc/source/reference/kcore.rst b/snap-python/source/doc/source/reference/kcore.rst new file mode 100644 index 0000000000000000000000000000000000000000..562230d0d2f69e533cae9b8085a5506a9bd2aa6a --- /dev/null +++ b/snap-python/source/doc/source/reference/kcore.rst @@ -0,0 +1,11 @@ + +K-core +`````` + +.. toctree:: + :maxdepth: 2 + + GetKCore + GetKCoreNodes + GetKCoreEdges + diff --git a/snap-python/source/doc/source/reference/legacy-swig.rst b/snap-python/source/doc/source/reference/legacy-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..cc863d5a36bd2a703e2ec9d58874a43fe46f94e0 --- /dev/null +++ b/snap-python/source/doc/source/reference/legacy-swig.rst @@ -0,0 +1,185 @@ +Legacy SWIG-based Operations +```````````````````````````` + +.. toctree:: + :maxdepth: 1 + + GenFull-swig + GenCircle-swig + GenGrid-swig + GenStar-swig + GenTree-swig + GenRndGnm-swig + GenPrefAttach-swig + GenGeoPrefAttach-swig + GenForestFire-swig + GenSmallWorld-swig + GenBaraHierar-swig + GenConfModel-swig + GenConfModel1-swig + GenCopyModel-swig + GenDegSeq-swig + GenRewire-swig + GenRndDegK-swig + GenRndPowerLaw-swig + GenRMat-swig + GenRMatEpinions-swig + + LoadEdgeList-swig + LoadEdgeList1-swig + SaveEdgeList-swig + LoadEdgeListStr-swig + LoadEdgeListStr1-swig + LoadConnListStr-swig + SaveGViz-swig + SaveGViz1-swig + SaveMatlabSparseMtx-swig + SavePajek-swig + SavePajek1-swig + SavePajek2-swig + SavePajek3-swig + + CntDegNodes-swig + CntInDegNodes-swig + CntOutDegNodes-swig + CntNonZNodes-swig + GetDegCnt-swig + GetInDegCnt-swig + GetOutDegCnt-swig + GetMxDegNId-swig + GetMxInDegNId-swig + GetMxOutDegNId-swig + GetNodeInDegV-swig + GetNodeOutDegV-swig + GetDegSeqV-swig + GetDegSeqV1-swig + + CntSelfEdges-swig + CntUniqBiDirEdges-swig + CntUniqDirEdges-swig + CntUniqUndirEdges-swig + CntEdgesToSet-swig + + AddSelfEdges-swig + DelDegKNodes-swig + DelNodes-swig + DelSelfEdges-swig + DelZeroDegNodes-swig + GetUnDir-swig + MakeUnDir-swig + + ConvertGraph-swig + ConvertSubGraph-swig + ConvertESubGraph-swig + GetSubGraph-swig + GetSubGraphRenumber-swig + GetSubTreeSz-swig + GetESubGraph-swig + GetRndSubGraph-swig + GetRndESubGraph-swig + + IsTree-swig + PrintInfo-swig + + DrawGViz-swig + DrawGViz1-swig + PlotSccDistr-swig + PlotWccDistr-swig + PlotClustCf-swig + PlotInDegDistr-swig + PlotOutDegDistr-swig + PlotHops-swig + PlotShortPathDistr-swig + PlotEigValDistr-swig + PlotEigValRank-swig + PlotSngValDistr-swig + PlotSngValRank-swig + PlotSngVec-swig + PlotInvParticipRat-swig + PlotKCoreEdges-swig + PlotKCoreNodes-swig + + GetSccs-swig + GetSccSzCnt-swig + GetWccs-swig + GetWccSzCnt-swig + GetMxBiCon-swig + GetMxScc-swig + GetMxSccSz-swig + GetMxWcc-swig + GetMxWccSz-swig + IsConnected-swig + IsWeaklyConn-swig + GetNodeWcc-swig + Get1CnCom-swig + Get1CnComSzCnt-swig + GetBiCon-swig + GetBiConSzCnt-swig + GetArtPoints-swig + GetEdgeBridges-swig + + GetBfsFullDiam-swig + GetBfsEffDiam-swig + GetBfsEffDiam1-swig + GetBfsEffDiamAll-swig + GetNodesAtHop-swig + GetNodesAtHops-swig + GetShortPath-swig + GetShortPath1-swig + GetBfsTree-swig + GetTreeRootNId-swig + GetTreeSig-swig + GetTreeSig1-swig + + GetDegreeCentr-swig + GetBetweennessCentr-swig + GetClosenessCentr-swig + GetFarnessCentr-swig + GetPageRank-swig + GetHits-swig + GetNodeEcc-swig + GetEigenVectorCentr-swig + + CommunityCNM-swig + CommunityGirvanNewman-swig + GetEdgesInOut-swig + GetModularity-swig + + GetClustCf-swig + GetClustCf1-swig + GetClustCfAll-swig + GetTriads-swig + GetTriads1-swig + GetTriadsAll-swig + GetCmnNbrs-swig + GetCmnNbrs1-swig + GetNodeClustCf-swig + GetNodeClustCf1-swig + GetNodeTriads-swig + GetNodeTriads1-swig + GetNodeTriadsAll-swig + GetLen2Paths-swig + GetLen2Paths1-swig + GetTriadEdges-swig + GetTriadParticip-swig + + GetKCore-swig + GetKCoreNodes-swig + GetKCoreEdges-swig + + GetAnf-swig + GetAnf1-swig + GetAnfEffDiam1-swig + GetAnfEffDiam-swig + + GetEigVals-swig + GetEigVec-swig + GetEigVec1-swig + GetSngVals-swig + GetSngVec-swig + GetSngVec1-swig + GetInvParticipRat-swig + + table-swig + conv-swig + diff --git a/snap-python/source/doc/source/reference/manipulation.rst b/snap-python/source/doc/source/reference/manipulation.rst new file mode 100644 index 0000000000000000000000000000000000000000..c059bece1f938b4d825958526e981f4105aecdcc --- /dev/null +++ b/snap-python/source/doc/source/reference/manipulation.rst @@ -0,0 +1,15 @@ + +Graph Manipulation +`````````````````` + +.. toctree:: + :maxdepth: 2 + + AddSelfEdges + DelDegKNodes + DelNodes + DelSelfEdges + DelZeroDegNodes + GetUnDir + MakeUnDir + diff --git a/snap-python/source/doc/source/reference/multimodal.rst b/snap-python/source/doc/source/reference/multimodal.rst new file mode 100644 index 0000000000000000000000000000000000000000..f38ae2380909778f83b7499b37ad60ca78949104 --- /dev/null +++ b/snap-python/source/doc/source/reference/multimodal.rst @@ -0,0 +1,621 @@ +Multimodal Networks +```````````````````` + +Multimodal networks in SNAP are represented by :class:`TMMNet`, which consist of modes, which are of class :class:`TModeNet`, and the links between them, which are of class :class:`TCrossNet`. + +The idea is that a multimodal network is a heterogeneous network where each node belongs to a particular mode, and edges belong to a particular cross net (that is, a particular kind of interaction between two modes). For example, in a biological dataset, genes, diseases and drugs might be the modes, and disease-disease interactions, disease-gene interactions and gene-drug interactions might be the links, or crossnets. To represent this in SNAP, we would build a :class:`TModeNet` for each mode -- each :class:`TModeNet` would contain only the nodes belonging to that mode. Next, we would build a :class:`TCrossNet` for every kind of link between modes. All edges should be added to the appropriate :class:`TCrossNet`. Note that there can be a :class:`TCrossNet` for links from the same mode to itself, and that there can be multiple :class:`TCrossNet` objects linking the same pair of modes (for example, in a multimodal social network dataset with a mode corresponding to users, and another corresponding to photos, there can be one :class:`TCrossNet` connecting users to photos they took, and another connecting users to photos they are tagged in). + +The :class:`TMMNet` class allows the construction of such multimodal networks in a modular fashion -- the user adds the corresponding instances of :class:`TModeNet`, specifying a name for each mode, and then adds the edges by adding instances of :class:`TCrossNet`, specifying the name of the cross net and the modes which it links. (:class:`TCrossNet` supports both undirected and directed multi-edges.) + +MMNets can be loaded from a :class:`TTable`, using functions :func:`LoadModeNetToNet` and :func:`LoadCrossNetToNet`. + +A :class:`TMMNet` can also be converted into a :class:`TNEANet`, using the :meth:`~multimodal.TMMNet.ToNetwork` method (documented below), after which all the SNAP algorithms that work on regular networks can be run on it. The method allows us to specify exactly which crossnets we want to include in the network, so that we can simply pull out the subgraph of interest to us. + +The following code shows example usage of :class:`TMMNet` to construct a toy multimodal network. (All the methods used in this example are documented in detail below.) :: + + import snap + + mmnet = snap.TMMNet.New() + + # Create a new modenet + mmnet.AddModeNet("TestMode1") + + # Add a crossnet which has directed links from TestMode1 to itself. + mmnet.AddCrossNet("TestMode1", "TestMode1", "TestCross1", snap.TBool(True)) + + # Add a crossnet which has undirected links from TestMode1 to itself. + mmnet.AddCrossNet("TestMode1", "TestMode1", "TestCross2", snap.TBool(False)) + + # Add a second mode + mmnet.AddModeNet("TestMode2") + + # Add a directed, and then an undirected crossnet from TestMode1 to TestMode2. + mmnet.AddCrossNet("TestMode1", "TestMode2", "TestCross3", snap.TBool(True)) + mmnet.AddCrossNet("TestMode1", "TestMode2", "TestCross4", snap.TBool(False)) + + # Get the mode net objects, and add nodes to them. + modenet1 = mmnet.GetModeNetByName("TestMode1") + modenet2 = mmnet.GetModeNetByName("TestMode2") + for i in range(1000): + modenet1.AddNode(i) + modenet2.AddNode(i*2) + + # Get the cross net objects, and add edges to them. + crossnet1 = mmnet.GetCrossNetByName("TestCross1") + crossnet2 = mmnet.GetCrossNetByName("TestCross2") + crossnet3 = mmnet.GetCrossNetByName("TestCross3") + crossnet4 = mmnet.GetCrossNetByName("TestCross4") + for i in range(1000): + crossnet1.AddEdge(i, (i+1)%1000, i) + crossnet2.AddEdge((i+5)%1000, i, i) + crossnet3.AddEdge(i, (i%1000)*2, i) + crossnet4.AddEdge((i+5)%1000, (i%1000)*2, i) + + # Iterate over modes + modeneti = mmnet.BegModeNetI() + while modeneti < mmnet.EndModeNetI(): + print(modeneti.GetModeName()) + modeneti.Next() + + # Iterate over crossnets + crossneti = mmnet.BegCrossNetI() + while crossneti < mmnet.EndCrossNetI(): + print(crossneti.GetCrossName()) + crossneti.Next() + + # Get a subgraph + crossnets = snap.TStrV() + crossnets.add("TestCross1") + sub_mmnet = mmnet.GetSubgraphByCrossNet(crossnets) + + # Convert to TNEANet + + crossnetids = snap.TIntV() + crossnetids.Add(mmnet.GetCrossId("TestCross1")) + crossnetids.Add(mmnet.GetCrossId("TestCross2")) + crossnetids.Add(mmnet.GetCrossId("TestCross3")) + + # These are mappings consisting of triples of (modeid, old attribute name, new attribute name) + nodeattrmapping = snap.TIntStrStrTrV() + edgeattrmapping = snap.TIntStrStrTrV() + + pneanet = mmnet.ToNetwork(crossnetids, nodeattrmapping, edgeattrmapping) + +TModeNet +========= + +.. class:: TModeNet() + TModeNet(ModeId) + TModeNet(Nodes, Edges) + TModeNet(Nodes, Edges, ModeId) + TModeNet(Graph) + + Returns a new directed multigraph with node and edge attributes that represents + a mode in a :class:`TMMNet`. + If no parameters are provided, + an empty graph is created. If *Nodes* and *Edges* are specified, space + is preallocated for *Nodes* nodes and *Edges* edges. If *Graph* is specified, + the new graph is a copy of the input graph. *ModeId* provides the integer id + for the mode the :class:`TModeNet` represents. + + In general, a :class:`TModeNet` should not be created directly and instead should + be added to a multimodal network using the :class:`TMMNet` method :meth:`AddModeNet`. + + :class:`TModeNet` inherits from :class:`TNEANet` and therefore has all + the same methods. In addition, it has the following multimodal related functions: + + .. describe:: GetCrossNetNames(Names) + + Gets a list of CrossNets that have this Mode as either a source or destination type. + + .. describe:: GetNeighborsByCrossNet(NId, Name, Neighbors, isOutEId=False) + + For the given node with id *NId*, gets all the neighbors for crossnet type with + name *Name*. If this mode is both the source and dest type, the flag *isOutEId* + specifies direction. + + .. describe:: BegMMNI(SIn) + + Returns an iterator referring to the first node in the graph. + + .. describe:: EndMMNI(SOut) + + Returns an iterator referring to the past-the-end node in the graph. + + .. describe:: GetMMNI() + + Returns an iterator referring to the node of ID NId in the graph. + + +TModeNetNodeI +============= + +.. class:: TModeNetNodeI() + + Returns a new node iterator for :class:`TModeNet`. Normally, these + objects are not created directly, + but obtained via a call to the network class :class:`TModeNet` method, + such as :meth:`BegMMNI()`, that returns a node iterator. + + :class:`TModeNetNodeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next node in the graph. + + .. describe:: GetId() + + Returns node ID of the current node. + + .. describe:: GetDeg() + + Returns degree of the current node, the sum of in-degree and out-degree. + + .. describe:: GetInDeg() + + Returns in-degree of the current node. + + .. describe:: GetOutDeg() + + Returns out-degree of the current node. + + .. describe:: GetInNId(NodeN) + + Returns ID of *NodeN*-th in-node (the node pointing to the current node). + + .. describe:: GetOutNId(NodeN) + + Returns ID of *NodeN*-th out-node (the node the current node points to). + + .. describe:: GetNbrNId(NodeN) + + Returns ID of *NodeN*-th neighboring node. + + .. describe:: IsInNId(NId) + + Tests whether node with ID *NId* points to the current node. + + .. describe:: IsOutNId(NId) + + Tests whether the current node points to node with ID *NId*. + + .. describe:: IsNbrNId(NId) + + Tests whether node with ID *NId* is a neighbor of the current node. + + .. describe:: GetCrossNetNames(Names) + + Gets a list of CrossNets that include the mode this node belongs to as either a + source or destination type. + + .. describe:: GetNeighborsByCrossNet(Name, Neighbors, isOutEId=False) + + For the given node, gets all the neighbors for crossnet type with name *Name*. If + this mode is both the source and dest type, the flag *isOutEId* specifies direction. + + + +TCrossNet +========== + +.. class:: TCrossNet() + TCrossNet(SrcModeId, DstModeId, CrossNetId) + TCrossNet(SrcModeId, DstModeId, IsDir, CrossNetId) + TCrossNet(Graph) + + Returns a new crossnet, which consists of the edges between two different modes + in a multimodal network. If no parameters are provided, an empty crossnet is created. + *SrcModeId* and *DstModeId* provide the ids for the source and destination mode id. + *IsDir* indicates whether the edges in the crossnet are directed. *CrossNetId* + gives the id for this crossnet. If *Graph* is specified, + the new crossnet is a copy of the input crossnet. + + A :class:`TCrossNet` should not be created directly and instead should + be added to a multimodal network using the :class:`TMMNet` method :meth:`AddCrossNet`. + + Methods for :class:`TCrossNet` are presented in two groups. The first + group of methods deal with graph structure which includes edges. + The second group of methods deal with edge attributes. + + :class:`TCrossNet` provides iterators for fast traversal of edges + and attributes. + Iterator classes are + :class:`TCrossNetEdgeI` for iterating over edges, and + :class:`TCrossNetAIntI`, :class:`TCrossNetAFltI`, :class:`TCrossNetAStrI` + for iterating over integer, float or string attributes, respectively. + + :class:`TCrossNet` methods for graph structure are the following: + + .. describe:: Save(SOut) + + Saves the crossnet to a binary stream *SOut*. + + .. describe:: GetEdges() + + Returns the number of edges in the crossnet. + + .. describe:: AddEdge(SrcNId, DstNId, EId=-1) + + Adds an edge with ID *EId* between node IDs *SrcNId* and *DstNId* + to the crossnet. Returns the ID of the edge being added. If *EId* is -1, + edge ID is automatically assigned. Throws an exception, if an edge + with ID *EId* already exists or if either *SrcNId* or *DstNId* does + not exist. + + .. describe:: DelEdge(EId) + + Deletes an edge with id *EId* from the crossnet. + + .. describe:: IsEdge(EId) + + Tests whether an edge with id *EId* exists in the graph. + + .. describe:: BegEdgeI() + + Returns an edge iterator referring to the first edge in the crossnet. + + .. describe:: EndEdgeI() + + Returns an edge iterator referring to the past-the-end edge in the crossnet. + + .. describe:: GetEdgeI(EId) + + Returns an edge iterator referring to edge with id *EId* in the crossnet. + + .. describe:: Clr() + + Deletes all edges from the graph. + + .. describe:: GetMode1() + + Returns the id of the source mode. + + .. describe:: GetMode2() + + Returns the id of the destination mode. + + .. describe:: IsDirected() + + Returns whether edges in the crossnet are directed. + + :class:`TCrossNet` methods for edge attributes support + attributes of different types. + Integer, float and string attributes are implemented. + Each attribute type has its own method for a particular task. + Attributes are named via string names. + + :class:`TCrossNet` methods for attributes are the following: + + .. describe:: AddIntAttrE(Attr) + AddFltAttrE(Attr) + AddStrAttrE(Attr) + + Defines a new integer, float or string edge attribute, respectively. + + .. describe:: DelAttrE(Attr) + + Deletes edge attribute *Attr*. + + .. describe:: AddIntAttrDatE(EdgeI, Value, Attr) + AddFltAttrDatE(EdgeI, Value, Attr) + AddStrAttrDatE(EdgeI, Value, Attr) + + Sets the value of attribute named *Attr* for the edge referred to + by edge iterator *EdgeI* to *Value*. + *Value* is an integer, a float, or a string, respectively. + + .. describe:: AddIntAttrDatE(EId, Value, Attr) + AddFltAttrDatE(EId, Value, Attr) + AddStrAttrDatE(EId, Value, Attr) + + Sets the value of attribute named *Attr* for the edge with + edge id *EId* to *Value*. + *Value* is an integer, a float, or a string, respectively. + + + .. describe:: GetIntAttrDatE(EdgeI, Attr) + GetFltAttrDatE(EdgeI, Attr) + GetStrAttrDatE(EdgeI, Attr) + + Returns the value of attribute named *Attr* for the edge referred to + by edge iterator *EdgeI**. + Result is an integer, a float, or a string, respectively. + + .. describe:: GetIntAttrDatE(EId, Attr) + GetFltAttrDatE(EId, Attr) + GetStrAttrDatE(EId, Attr) + + Returns the value of attribute named *Attr* for the edge with + edge id *EId*. + Result is an integer, a float, or a string, respectively. + + .. describe:: BegEAIntI(Attr) + BegEAFltI(Attr) + BegEAStrI(Attr) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the first edge. + + .. describe:: EndEAIntI(Attr) + EndEAFltI(Attr) + EndEAStrI(Attr) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the past-the-end edge. + + .. describe:: GetEAIntI(Attr, EId) + GetEAFltI(Attr, EId) + GetEAStrI(Attr, EId) + + Returns an integer, float, or string attribute iterator, respectively, + of the attribute named *Attr* referring to the edge + with edge ID *EId*. + + .. describe:: DelAttrDatE(EdgeI, Attr) + + Deletes the value of attribute named *Attr* for the edge referred to + by edge iterator *EdgeI*. + + .. describe:: DelAttrDatE(EId, Attr) + + Deletes the value of attribute named *Attr* for the edge with + edge ID *EId*. + + .. describe:: IsIntAttrDeletedE(EId, Attr) + IsFltAttrDeletedE(EId, Attr) + IsStrAttrDeletedE(EId, Attr) + + Returns whether the int, float, or string attribute, respectively + has been deleted. + +TCrossNetEdgeI +============== + +.. class:: TCrossNetEdgeI() + + Returns a new edge iterator for :class:`TCrossNet`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TCrossNet` method, + such as :meth:`BegEdgeI()`, that returns an edge iterator. + + :class:`TCrossNetEdgeI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next edge in the graph. + + .. describe:: GetId() + + Returns the the edge id. + + .. describe:: GetSrcNId() + + Returns the ID of the source node of the edge. + + .. describe:: GetDstNId() + + Returns the ID of the destination node of the edge. + + .. describe:: GetSrcModeId() + + Returns the ID of the source mode of the edge. + + .. describe:: GetDstModeId() + + Returns the ID of the destination mode of the edge. + + .. describe:: IsDirected() + + Returns whether the edge is directed. + +TCrossNetAIntI, TCrossNetAFltI, TCrossNetAStrI +============================================== + +.. class:: TCrossNetAIntI() + TCrossNetAFltI() + TCrossNetAStrI() + + Returns a new integer, float or string attribute iterator + for :class:`TCrossNet`. Normally, these objects are not created directly, + but obtained via a call to the graph class :class:`TCrossNet` method, + such as :meth:`BegEAIntI()`, which returns an integer edge iterator, or + :meth:`BegEAFltI()`, which returns a float edge iterator. + + Attribute iterators provide the following methods: + + .. describe:: Next() + + Moves the iterator to the next node or edge in the graph. + + .. describe:: GetDat() + + Returns an attribute of the node or edge. + + .. describe:: IsDeleted() + + Returns true if the attribute has been deleted. + + +TMMNet +======= + +.. class:: TMMNet() + TMMNet(Graph) + + Returns a new directed multimodal network, consisting of different modes and the + edges between them. + + Modes have user-specified names and SNAP-assigned integer IDs, which are + arbitrary non-negative integers. Cross-nets, which store the edges between + two modes, also have user-specified names and SNAP-assigned integer IDs. Cross-nets + are, by default, directed but can also be undirected. The same source mode can be + used as the destination mode for a given cross-net. + + :class:`TMMNet` provides iterators for fast traversal of modes and cross-nets. + Iterator classes are :class:`TMMNetModeNetI` for iterating over modes and + :class:`TMMNetCrossNetI` for iterating over edges. + + :class:`TMMNet` methods are the following: + + .. describe:: New() + + Returns a pointer to a new multimodal network. + + .. describe:: Load(SIn) + + Loads the multimodal network from a binary stream *SIn* and returns a pointer to it. + + .. describe:: Save(SOut) + + Saves the multimodal network to a binary stream *SOut*. + + .. describe:: GetModeNets() + + Returns the number of modes in the graph. + + .. describe:: AddModeNet(ModeName) + + Adds a mode with name *ModeName* to the multimodal network. Returns the id + for the mode. + + .. describe:: DelModeNet(ModeId) + DelModeNet(ModeName) + + Deletes the mode with id *ModeId* or name *ModeName*, respectively, from the + multimodal network. + + .. describe:: BegModeNetI() + + Returns a mode iterator referring to the first mode in the graph. + + .. describe:: EndModeNetI() + + Returns a mode iterator referring to the past-the-end mode in the graph. + + .. describe:: GetModeNetI(MId) + + Returns a mode iterator referring to the mode with ID *MId* in the graph. + + .. describe:: GetModeId(ModeName) + + Returns the id of the mode with name *ModeName*. + + .. describe:: GetModeName(ModeId) + + Returns the name of the mode with id *ModeId*. + + .. describe:: GetModeNetByName(ModeName) + GetModeNetById(ModeId) + + Returns a reference to the mode with name *ModeName* or id *ModeId*, respectively, + in the multimodal network. + + .. describe:: GetCrossNets() + + Returns the number of crossnets in the graph. + + .. describe:: AddCrossNet(ModeName1, ModeName2, CrossNetName, IsDir=True) + AddCrossNet(ModeId1, ModeId2, CrossNetName, IsDir=True) + + Adds a crossnet with name *CrossNetName* from the modes specified with + the given names or ids. *IsDir* indicates whether the edges in the crossnet + are directed. + + .. describe:: DelCrossNet(CrossId) + DelCrossNet(CrossName) + + Deletes the crossnet with id *CrossId* or name *CrossName*, respectively, from the + multimodal network. + + .. describe:: BegCrossNetI() + + Returns a crossnet iterator referring to the first crossnet in the graph. + + .. describe:: EndCrossNetI() + + Returns a crossnet iterator referring to the past-the-end crossnet in the graph. + + .. describe:: GetCrossNetI(CId) + + Returns a crossnet iterator referring to the crossnet with ID *CId* in the graph. + + .. describe:: GetCrossId(CrossName) + + Returns the id of the crossnet with name *CrossName*. + + .. describe:: GetCrossName(CrossId) + + Returns the name of the crossnet with id *CrossId*. + + .. describe:: GetCrossNetByName(CrossName) + GetCrossNetById(CrossId) + + Returns a reference to the crossnet with name *CrossName* or id *CrossId*, + respectively, in the multimodal network. + + .. describe:: ToNetwork(TIntV& CrossNetTypes, TIntStrStrTrV& NodeAttrMap, TIntStrStrTrV& EdgeAttrMap) + + Converts the MMNet to a :class:`TNEANet` (which flattens out the multimodal nature of the network), adding only + the crossnets (and corresponding modenets) whose ids are specified in the vector of integer ids, CrossNetTypes. + + As attribute names can collide (since different modes can have the same attribute name in a TMMNet, but can't + anymore once it is converted to a TNEANet), two attribute maps are passed, one for modes and one for crossnets. + Each attribute map is passed as a vector of triples. Each triple has the mode id, the attribute name in the + TMMNet, and the attribute name to be used in the newly created TNEANet. + + +TMMNetModeNetI +============== + +.. class:: TMMNetModeNetI() + + Returns a new mode iterator for :class:`TMMNet`. Normally, these + objects are not created directly, + but obtained via a call to the network class :class:`TMMNet` method, + such as :meth:`BegModeNetI()`, that returns a mode iterator. + + :class:`TMMNetModeNetI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next mode in the graph. + + .. describe:: GetModeId() + + Returns the ID of the current mode. + + .. describe:: GetModeName() + + Returns the name of the current mode. + + .. describe:: GetModeNet() + + Returns a reference to the current mode. + +TMMNetCrossNetI +=============== + +.. class:: TMMNetCrossNetI() + + Returns a new crossnet iterator for :class:`TMMNet`. Normally, these + objects are not created directly, + but obtained via a call to the graph class :class:`TMMNet` method, + such as :meth:`BegCrossNetI()`, that returns an crossnet iterator. + + :class:`TMMNetCrossNetI` provides the following methods: + + .. describe:: Next() + + Moves the iterator to the next crossnet in the graph. + + .. describe:: GetCrossId() + + Returns the ID of the current crossnet. + + .. describe:: GetCrossName() + + Returns the name of the current crossnet. + + .. describe:: GetCrossNet() + + Returns a reference to the current crossnet. diff --git a/snap-python/source/doc/source/reference/streams.rst b/snap-python/source/doc/source/reference/streams.rst new file mode 100644 index 0000000000000000000000000000000000000000..e4f056493e7590290625ffd2ae5df9d6f7e32cee --- /dev/null +++ b/snap-python/source/doc/source/reference/streams.rst @@ -0,0 +1,72 @@ +File Streams +```````````` + +The file streams offered by SNAP.py are :class:`TFOut`, which is used for file writing, and :class:`TFIn`, which is used for file reading. + +TFOut +===== + +.. class:: TFOut(FNm) + + Creates a :class:`TFOut` object that can be used to write the contents of the file specified by the path *FNm*. If a file with name *FNm* does not already exist, it creates a new file. If a file with name *FNm* exists, its contents will be overwritten. + + Below is a list of functions supported by the :class:`TFOut` class: + + .. describe:: PutCh(Ch) + + Writes the character *Ch* to the curret file stream position. + + .. describe:: Flush() + + Flushes the write buffer for the stream. + + .. describe:: New(FNm) + + Returns a new :class:`TFOut` object for the file with name *FNm*. + + Below is some code demonstrating the use of the :class:`TFOut` type, which creates a file with name 'test.graph' in the working directory: + + >>> Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + >>> FOut = snap.TFOut("test.graph") + >>> Graph.Save(FOut) + >>> FOut.Flush() + +TFIn +==== + +.. class:: TFIn(FNm) + + Creates a :class:`TFIn` object that can be used to read the contents of the file specified by the path *FNm*. Raises the exception :class:`RuntimeError` if a file with name *FNm* cannot be found. + + Below is a list of functions supported by the :class:`TFIn` class: + + .. describe:: Eof() + + Returns a boolean indicating whether the end of the file has been reached. + + .. describe:: Len() + + Returns the length of the remainder of the file starting at the current file stream position. + + .. describe:: GetCh() + + Returns the next character in the file and updates the file stream position to the next character in the file. + + .. describe:: PeekCh() + + Returns the next character in the file without updating the file stream position. + + .. describe:: Reset() + + Resets the file stream to the beginning of the file. + + .. describe:: New(FNm) + + Returns a new :class:`TFIn` object for the file with name *FNm*. + + Below is some code demonstrating the use of the :class:`TFIn` type, which assumes a file with name 'test.graph' exists in the working directory: + + >>> FIn = snap.TFIn("test.graph") + >>> Graph = snap.TNGraph.Load(FIn) + >>> FIn.Len() + 11445 diff --git a/snap-python/source/doc/source/reference/subgraphs.rst b/snap-python/source/doc/source/reference/subgraphs.rst new file mode 100644 index 0000000000000000000000000000000000000000..ad79368255a459f9889f4bac043202920af1f304 --- /dev/null +++ b/snap-python/source/doc/source/reference/subgraphs.rst @@ -0,0 +1,26 @@ + +Subgraphs and Graph Type Conversions +```````````````````````````````````` + +.. toctree:: + :maxdepth: 2 + + ConvertGraph + ConvertSubGraph + ConvertESubGraph + GetSubGraph + GetSubGraphRenumber + GetSubTreeSz + GetESubGraph + GetRndSubGraph + GetRndESubGraph + GetEgonet + GetEgonetHop + GetInEgonetHop + GetOutEgonetHop + GetInEgonetSub + GetGraphUnion + GetGraphUnionAttr + GetGraphIntersection + GetGraphIntersectionAttr + diff --git a/snap-python/source/doc/source/reference/svd.rst b/snap-python/source/doc/source/reference/svd.rst new file mode 100644 index 0000000000000000000000000000000000000000..7466b5e702bdfc7b69f6d262a73f48ee3d152fb5 --- /dev/null +++ b/snap-python/source/doc/source/reference/svd.rst @@ -0,0 +1,15 @@ + +Eigen and Singular Value Decomposition +`````````````````````````````````````` + +.. toctree:: + :maxdepth: 2 + + GetEigVals + GetLeadEigVec + GetEigVecs + GetSngVals + GetLeadSngVec + GetSngVecs + GetInvParticipRat + diff --git a/snap-python/source/doc/source/reference/table-swig.rst b/snap-python/source/doc/source/reference/table-swig.rst new file mode 100644 index 0000000000000000000000000000000000000000..94216c7702d2480e6d71b0df90cd654aed5d1165 --- /dev/null +++ b/snap-python/source/doc/source/reference/table-swig.rst @@ -0,0 +1,1075 @@ +Tables (SWIG) +````````````` + +Tables in SNAP are represented by the class :class:`TTable`. + +:class:`TTable` is designed to provide fast performance at scale, and to effortlessly handle datasets containing hundreds of millions of rows. They can be saved and loaded to disk in a binary format using the provided methods; loading from and saving to binary is orders of magnitude faster than using a text representation of the table. + +A :class:`TTable` can store integers, floats and strings in its entries. For performance reasons, strings are mapped to a unique integer, and the :class:`TTable` stores only the integer which maps to the string. Each :class:`TTable` object has an associated :class:`TTableContext` which stores the mapping from integers to strings and back, and can be used when the string corresponding to an integer needs to be retrieved. (Note: many :class:`TTable` objects can share the same context; this is often useful, for example, to ensure that equivalent strings in different tables are treated as equivalent in SNAP.) + +A :class:`TTable` object consists of multiple columns, each column being an integer, string or float. This is defined by the table's Schema. A schema is simply a vector of pairs of TStr and TAttrType. (Note: TAttrType represents the type of the column. Currently supported values are snap.atInt, snap.atFlt and snap.atStr.) Each entry in the schema has the name of the column, and the attribute type. + +After the schema and the colums are defined, the data can be stored in rows, with each row containing an entry for each column. It is possible to iterate over the data by row, using the :class:`TRowIterator` class (see documentation below for details). + +:class:`TTable` also provides functionality for doing joins (using the :meth:`Join` method), groupings (using the :meth:`Aggregate` method), selection and projection (using the :meth:`Select` and :meth:`Project` methods), as well as sorting (using the :meth:`Order` method). + +In order to quickly retrieve elements by value, :class:`TTable` allows the user to construct indexes on a column (using :meth:`RequestIndexInt`, :meth:`RequestIndexFlt` and :meth:`RequestIndexStrMap`. Note that unless these functions are explicitly called, the default is to not create any indexes.) + +:class:`TTable` can be loaded from a text-file in spreadsheet (tab-separated or comma-separated) format using the static :meth:`LoadSS` method. + +Tables can be converted to SNAP graph classes using the provided :func:`ToNetwork` functions. + +The tutorial provides extensive documentation on the use of table methods and functions in the section about :doc:`../tutorial/table-tut`. The code snippets below additionally highlight some of the common operations using :class:`TTable` objects. The reference descriptions of methods and functions used are documented in more detail below. + +The following code snippet shows how to load a :class:`TTable` object from a tab-separated file containing one integer, one float and two string columns, and then save the object to disk in binary format:: + + import snap + + context = snap.TTableContext() + filename = "/path/to/input.tsv" + + schema = snap.Schema() + schema.Add(snap.TStrTAttrPr("Col1", snap.atInt)) + schema.Add(snap.TStrTAttrPr("Col2", snap.atFlt)) + schema.Add(snap.TStrTAttrPr("Col3", snap.atStr)) + schema.Add(snap.TStrTAttrPr("Col4", snap.atStr)) + + table = snap.TTable.LoadSS(schema, filename, context, "\t", snap.TBool(False)) + + outfile = "/path/to/output.bin" + FOut = snap.TFOut(outfile) + table.Save(FOut) + FOut.Flush() + +The saved table can now be loaded from binary using:: + + import snap + context = snap.TTableContext() + + outfile = "/path/to/output.bin" + FIn = snap.TFIn(outfile) + table = snap.TTable.Load(FIn, context) + +Note that loading and saving from binary is over ten times faster than loading the raw text file. + +Next, we present a slightly more involved example. Let's say we have an authorship table for academic papers, *PapAuthT* where each row has a PaperID and an AuthorID. (Thus, if paper P1 was written by A1, A2 and A3, and paper P2 by authors A2, we would have four rows in our :class:`TTable`, with data (P1, A1), (P1, A2) and (P1, A3), and (P2, A2).) Further, let's say we have the citation count of each paper in a separate table, *PapCitT*, which has columns PaperID and CitCount. Assuming that these tables have already been loaded into :class:`TTable` objects with appropriate schema, the following code shows how to perform various useful operations on these tables:: + + # Assuming that PapAuthT and PapCitT are already loaded into TTable objects with columns as described above. + + # First, let's say we want to count the number of papers written by an author. We use Aggregate + # with the operation, snap.aaCount. + + # This counts the number of elements with a particular value of the attributes in GroupBy + # (namely, AuthorID), and puts the count in a new column called "CountAuthPapers". + # Note that for the aggregation operation snap.aaCount, the third argument is irrelevant. + GroupBy = snap.TStrV() + GroupBy.Add("AuthorID") + PapAuthT.Aggregate(GroupBy, snap.aaCount, "AuthorID", "CountAuthPapers", snap.TBool(False)) + + # To keep only one row for each author, we can use the TTable.Unique() method as PapAuthT.Unique("AuthorID") + # which will remove all rows with duplicate values of AuthorID. + + # Next, let's say we want to compute the total number of citations each author has. + # This is the sum of the citations of all the papers the author wrote. + # However, the citation info is in PapCitT. Hence, we must join it to this table now. + + # Joins these two tables, merging rows which have the same PaperID in both. + # Now, each row has a PaperID, AuthorID and a CitCount + PapAuthCitJoinT = PapAuthT.Join("PaperID", PapCitT, "PaperID") + + # We now aggregate the citation counts by author, summing them all up to get the + # total number of citations. + GroupBy = snap.TStrV() + GroupBy.Add("AuthorID") + PapAuthCitJoinT.Aggregate(GroupBy, snap.aaSum, "CitCount", "TotalAuthCits", snap.TBool(False)) + + # Now, we have the total number of citations by each author in a new column + # TotalAuthCits. We can now keep just the relevant columns, and drop duplicate rows + # with the same author ID. + + ProjectCols = snap.TStrV() + ProjectCols.Add("AuthorID") + ProjectCols.Add("TotalAuthCits") + AuthCitT = PapAuthCitJoinT.Project(ProjectCols) + AuthCitT.Unique("AuthorID") + + # We can also sort the authors in decreasing order of total citations. + OrderBy = snap.TStrV() # The TTable.Order method sorts using the values of + # the columns in OrderBy, in lexicographic order. + OrderBy.Add("TotalAuthCits") + AuthCitT.Order(OrderBy, "", snap.TBool(False), snap.TBool(False)) + +TTable +====== + +.. class:: TTable() + TTable(Context) + TTable(S, Context) + TTable(SIn, Context) + TTable(H, Col1, Col2, Context, IsStrKeys=False) + TTable(Table, const TIntV& RowIds) + TTable(Table) + :noindex: + + Returns a new table. If no parameters are provided, an empty table is returned. If + *S* and *Context* are provided, the table is initialized with the provided Schema and + TTableContext. If *SIn* is provided, the table is read from the binary stream. If *H*, a + :class:`THash` with :class:`TInt` keys and either :class:`TInt` or :class:`TFlt` values, + is given, the TTable is constructed from the hash table. If *IsStrKeys* is True, then + the :class:`TInt` keys in *H* refer to strings in the *Context*. *Col1* provides the name + for the keys in *H* in the schema for the table and *Col2* does the same for the values. + If *Table* is provided, the contents of *Table* are copied into the current table. If + *RowIds* is given, then only those particular rows are copied. + + Below is a list of functions supported by the :class:`TTable` class: + + .. describe:: AddDstNodeAttr(Attr) + + Adds column with name *Attr* to be used as the destination node attribute + of the graph. + + .. describe:: AddDstNodeAttr(Attrs) + + Adds columns with the names specified in *Attrs*, a :class:`TStrV`, to be used as + destination node attributes of the graph. + + .. describe:: AddEdgeAttr(Attr) + + Adds column with name *Attr* to be used as graph edge attribute. + + .. describe:: AddEdgeAttr(Attrs) + + Adds columns, with names provided in *Attrs*, to be used as graph edge attributes. + + .. describe:: AddNodeAttr(Attr) + + Adds column with name *Attr* to be used as node attribute (both source and destination). + + .. describe:: AddNodeAttr(Attrs) + + Adds columns, with names provided in *Attrs*, to be used as node attribute + (both source and destination). + + .. describe:: AddSrcNodeAttr(Attr) + + Adds column with name *Attr* to be used as the source node attribute + of the graph. + + .. describe:: AddSrcNodeAttr(Attrs) + + Adds columns with the names specified in *Attrs*, a :class:`TStrV`, to be used as + source node attributes of the graph. + + .. describe:: Aggregate(GroupByAttrs, AggOp, ValAttr, ResAttr, Ordered=True) + + Aggregates values over one attribute, *ValAttr*, after grouping with respect to a + list of attributes given in *GroupByAttrs*. Results are stored in a new attribute + with name *ResAttr*. *Ordered* indicates whether to treat grouping key as ordered + (true) or unordered. *AggOp* gives the aggregation policy. It must be one of + aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, or aaMedian. + + .. describe:: AggregateCols(AggrAttrs, AggOp, ResAttr) + + For each row in the table, aggregates values over a list of attributes given by *AggrAttrs*. Results are stored in a new attribute *ResAttr*. *AggOp* gives the aggregation policy. + It must be one of aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, aaMedian + + .. describe:: BegRI() + + Gets an iterator to the first valid row of the table. Returns a :class:`TRowIterator`. + + .. describe:: BegRIWR() + + Gets an iterator to remove the first valid row. Returns a :class:`TRowIteratorWithRemove`. + + .. describe:: Classify(Predicate, LabelAttr, PositiveLabel, NegativeLabel) + + Adds a label attribute, *LabelAttr*, with positive labels, a :class:`TInt` given by + *PositiveLabel*, on rows selected according to the :class:`TPredicate` *Predicate*, + and negative labels, a :class:`TInt` given by *NegativeLabel*, on the rest. + + .. describe:: ClassifyAtomic(Attr1, Attr2, Cmp, LabelAttr, PositiveLabel, + NegativeLabel) + + Adds an integer label attribute, *LabelAttr*, with positive labels, given by *PositiveLabel*, + on selected rows and negative labels, given by *NegativeLabel*, on the rest. Rows are + selected using the atomic compare operator of type :class:`TPredComp`, *Cmp*, over + *Attr1* and *Attr2*. *Cmp* must be one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + + .. describe:: ColAdd(Attr1, Attr2, ResAttr=:class:`TStr`("")) + ColAdd(Attr1, Table, Attr2, ResAttr=:class:`TStr`(""), AddToFirstTable) + ColAdd(Attr1, Value, ResAttr=:class:`TStr`(""), FloatCast) + + Performs the operation *Attr1* + *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* + *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: ColConcat(Attr1, Attr2, Separator, ResAttr=:class:`TStr`("")) + ColConcat(Attr1, Table, Attr2, Separator, ResAttr=:class:`TStr`(""), AddToFirstTable) + + Concatenates the two columns given by *Attr1* and *Attr2*, separated by *Separator*. + *Table* specifies the :class:`TTable` *Attr2* comes from. The result is stored in a + new column, *ResAttr*. If *ResAttr* = "", the result is stored instead in the column + corresponding to *Attr1*. *AddToFirstTable* is a flag specifying whether to add *ResAttr* + to the table corresponding to the caller (true), or to the table *Table*. **NOTE**: + This operation only works on String columns. + + .. describe:: ColConcatConst(Attr, Value, Separator, ResAttr=:class:`TStr`("")) + + Concatenates values for column *Attr* with the given string value *Value*, separated + by *Separator*. Result is stored in a new column *ResAttr*. If *ResAttr* = "", the + result is stored instead in the column corresponding to *Attr1*. **NOTE**: This operation + only works on String columns. + + .. describe:: ColDiv(Attr1, Attr2, ResAttr=:class:`TStr`("")) + ColDiv(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColDiv(Attr1, Value, ResAttr=:class:`TStr`(""), FloatCast) + + Performs the operation *Attr1* / *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* / *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: ColMax(Attr1, Attr2, ResAttr=:class:`TStr`("")) + + Performs the operation MAX (*Attr1*, *Attr2*), where *Attr1* and *Attr2* + are attributes in a table. The result is stored in a new column *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding + to *Attr1*. **NOTE**: This operation does not work on String columns. + + + .. describe:: ColMin(Attr1, Attr2, ResAttr=:class:`TStr`("")) + + Performs the operation MIN (*Attr1*, *Attr2*), where *Attr1* and *Attr2* + are attributes in a table. The result is stored in a new column *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding + to *Attr1*. **NOTE**: This operation does not work on String columns. + + .. describe:: ColMod(Attr1, Attr2, ResAttr) + ColMod(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColMod(Attr1, Value, ResAttr, FloatCast) + + Performs the operation *Attr1* % *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* % *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String or float columns. + + .. describe:: ColMul(Attr1, Attr2, ResAttr) + ColMul(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColMul(Attr1, Value, ResAttr, FloatCast) + + Performs the operation *Attr1* * *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* * *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: ColSub(Attr1, Attr2, ResAttr) + ColSub(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColSub(Attr1, Value, ResAttr, FloatCast) + + Performs the operation *Attr1* - *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* - *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: Count(Attr, ResAttr) + + For each row of the table, counts number of rows in the table sharing the same value + as it for a given attribute *Attr*, a :class:`TStr`. The result is stored in a new + attribute, *ResAttr*. + + .. describe:: EndRI() + + Gets an iterator to the last valid row of the table. Returns a :class:`TRowIterator`. + + + .. describe:: EndRIWR() + + Gets an iterator to remove the last valid row. Returns a :class:`TRowIteratorWithRemove`. + + + .. describe:: GetColType(Attr) + + Gets type of an attribute *Attr*. Returns a :class:`TAttrType` object representing + attribute type. + + .. describe:: GetDstCol() + + Returns the name, a :class:`TStr`, of the column representing destination nodes + in the graph. + + .. describe:: GetDstNodeFltAttrV() + + Returns the names of the Flt columns, in a :class:`TStrV`, corresponding to attributes + of the destination nodes. + + .. describe:: GetDstNodeIntAttrV() + + Returns the names of the Int columns, in a :class:`TStrV`, corresponding to attributes + of the destination nodes. + + .. describe:: GetDstNodeStrAttrV() + + Returns the names of the Str columns, in a :class:`TStrV`, corresponding to attributes + of the destination nodes. + + .. describe:: GetEdgeFltAttrV() + + Returns the names of the Flt columns, in a :class:`TStrV`, corresponding to edge + attributes. + + .. describe:: GetEdgeIntAttrV() + + Returns the names of the Int columns, in a :class:`TStrV`, corresponding to edge + attributes. + + .. describe:: GetEdgeStrAttrV() + + Returns the names of the Str columns, in a :class:`TStrV`, corresponding to edge + attributes. + + .. describe:: GetEdgeTable(Network, Context) + + Extracts edge TTable from the :class:`PNEANet` *Network*, using the :class:`TTableContext` + *Context*. Returns the resulting :class:`PTable`. + + .. describe:: GetEdgeTablePN(Network, Context) + + Extracts edge TTable from the :class:`PNGraphMP` *Network*, using the :class:`TTableContext` + *Context*. Returns the resulting :class:`PTable`. **NOTE**: Defined only if OpenMP present. + + .. describe:: GetFltNodePropertyTable(Network, Property, NodeAttrName, NodeAttrType, PropertyAttrName, Context) + + Extracts node and and edge property TTables from a THash. *Network* is of type + :class:`PNEANet`, *Property* is a :class:`TIntFltH`, *NodeAttrName* and + *PropertyAttrName* are :class:`TStr`s, *NodeAttrType* is a :class:`TAttrType`, and + *Context* is a :class:`TTableContext`. Returns a :class:`PTable` object. + + .. describe:: GetFltVal(Attr, RowIdx) + + Gets the value of float attribute with name *Attr* at row *RowIdx*. + + .. describe:: GetFltValAtRowIdx(ColIdx, RowIdx) + + Gets the value of the float column at index *ColIdx* at row *RowIdx*. + + .. describe:: GetIntVal(Attr, RowIdx) + + Gets the value of integer attribute with name *Attr* at row *RowIdx*. + + .. describe:: GetIntValAtRowIdx(ColIdx, RowIdx) + + Gets the value of the integer column at index *ColIdx* at row *RowIdx*. + + .. describe:: GetMP() + + Returns the value of the static variable TTable::UseMP, which controls whether + to use multi-threading. TTable::UseMP is 1 by default (meaning algorithms are + multi-threaded by default if the OpenMP library is present). + + .. describe:: GetMapHitsIterator(GraphSeq, Context, MaxIter=20) + + Computes a sequence of Hits tables for a graph sequence *GraphSeq*, a + :class:`TVec`. A :class:`TTableIterator` is returned. + + .. describe:: GetMapPageRank(GraphSeq, Context, C=0.85, Eps=1e-4, MaxIter=100) + + Computes a sequence of PageRank tables for a graph sequence *GraphSeq*, a + :class:`TVec`. A :class:`TTableIterator` is returned. + + .. describe:: GetNodeTable() + + Extracts node TTable from :class:`PNEANet` *Network*, using :class:`TTableContext` *Context*. + + .. describe:: GetNumRows() + + Returns total number of rows in the table. Count could include + rows which have been deleted previously. + + .. describe:: GetNumValidRows() + + Returns total number of valid rows in the table. + + .. describe:: GetSchema() + + Returns the schema of the table. Return type is :class:`Schema`. + + .. describe:: GetSrcCol() + + Returns the name of the column representing source nodes in the graph. + + .. describe:: GetSrcNodeFltAttrV() + + Returns the names of the Flt columns corresponding to attributes of the + source nodes. Return type is :class:`TStrV`. + + .. describe:: GetSrcNodeIntAttrV() + + Returns the names of the Int columns corresponding to attributes of the + source nodes. Return type is :class:`TStrV`. + + .. describe:: GetSrcNodeStrAttrV() + + Returns the names of the Str columns corresponding to attributes of the + source nodes. Return type is :class:`TStrV`. + + .. describe:: GetStrVal(Attr, RowIdx) + + Gets the value of string attribute with name *Attr* at row *RowIdx*. + + .. describe:: Group(GroupByAttrs, GroupAttrName, Ordered=True) + + Groups rows according to the attributes specified by GroupByAttrs, a :class:`TStrV`. + Result is stored in a new column of the table with name *GroupAttrName*. + + .. describe:: Intersection(PTable) + + Returns a new table containing rows present in the current table + that are also present in *PTable*, which is of type :class:`PTable`. + + .. describe:: Join(Attr1, PTable, Attr2) + + Performs an equi-join on the current table and another table, *PTable* over + attributes *Attr1* in the current table and *Attr2* in *PTable*. + + .. describe:: Load(SIn, Context) + + Loads table from the input stream *SIn* using + :class:`TTableContext` *Context*. Returns a :class:`PTable`. + + .. describe:: LoadSS(Schema, InFNm, Context, Separator='\\t', HasTitleLine=False) + + Loads table from spread sheet (TSV, CSV, etc). *Schema* is a :class:`Schema` object, + *InFNm* provides the input file name, *Context is a :class:`TTableContext`, *Separator* + is the field separator character in the input file, and HasTitleLine indicates whether + the first line is a title line with the name of the columns (without a # preceding it). + If *HasTitleLine* is True, then *Schema* is validated against it. + + .. describe:: Minus(PTable) + + Returns a new table containing rows present in the current table which are not + present in another table given by *PTable*. + + .. describe:: Order(OrderByAttrs, ResAttr, ResetRankFlag=False, Asc=True) + + Orders the rows according to the values in *OrderByAttrs* (a :class:`TStrV`). + Results are stored in new column with name *ResAttr*. If *Asc* is True, rows + are ordered in ascending lexicographic order. + + .. describe:: Project(ProjectAttrs) + + Returns a table with only the attributes in *ProjectAttrs*, a :class:`TStrV`. + + .. describe:: ProjectInPlace(ProjectAttrs) + + Modifies the current table to keep only the attributes specified + in *ProjectAttrs*. + + .. describe:: ReadFltCol(Attr, Result) + + Reads values of an entire float column given by *Attr* into the :class:`TFltV` + *Result*. + + .. describe:: ReadIntCol(Attr, Result) + + Reads values of an entire int column given by *Attr* into the :class:`TFltV` + *Result*. + + .. describe:: ReadStrCol(Attr, Result) + + Reads values of an entire string column given by *Attr* into the :class:`TFltV` + *Result*. + + .. describe:: Rename(Attr, NewAttr) + + Renames an attribute with name *Attr* to new name *NewAttr* in a table. + + + .. describe:: SaveBin(OutFNm) + + Saves table schema and content into a binary file with name *OutFNm*. + + .. describe:: SaveSS(OutFNm) + + Saves table schema and content into a TSV file with name *OutFNm*. + + .. describe:: Select(Predicate, SelectedRows, Remove=True) + + Selects rows that satisfy a given Predicate, of type :class:`TPredicate`. + The selected row indices are stored in *SelectedRows*, a :class:`TIntV`. If + *Remove* is True, rows that do not match the predicate are removed. + + .. describe:: SelectAtomic(Attr1, Attr2, Cmp, SelectedRows, Remove=True) + + Selects rows which satisfy an atomic compare operation, *Cmp*, of type + :class:`TPredComp`. *Cmp* must be one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, + or SUPERSTR. The selected row indices are stored in *SelectedRows*, + a :class:`TIntV`. If *Remove* is True, rows that do not match the predicate + are removed. + + .. describe:: SelectAtomicFltConst(Attr, Val, Cmp, SelectedTable) + + Selects rows where the value of a float attribute, *Attr*, satisfies an atomic + comparison, *Cmp*, with a primitive type *Val*. *Cmp* must be one of LT, LTE, + EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. The selected rows are added to the + :class:`PTable` *SelectedTable*. + + .. describe:: SelectAtomicIntConst(Attr, Val, Cmp, SelectedTable) + + Selects rows where the value of a int attribute, *Attr*, satisfies an atomic + comparison, *Cmp*, with a primitive type *Val*. *Cmp* must be one of LT, LTE, + EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. The selected rows are added to the + :class:`PTable` *SelectedTable*. + + .. describe:: SelectAtomicStrConst(Attr, Val, Cmp, SelectedTable) + + Selects rows where the value of a string attribute, *Attr*, satisfies an atomic + comparison, *Cmp*, with a primitive type *Val*. *Cmp* must be one of LT, LTE, EQ, + NEQ, GTE, GT, SUBSTR, or SUPERSTR. The selected rows are added to the :class:`PTable` + *SelectedTable*. + + .. describe:: SelectFirstNRows(N) + + Modifies table in place so that it only its first *N* rows are retained. + + .. describe:: SelfJoin(Attr) + + Performs a self-join on the table on the attribute *Attr*. Returns a new table. + + .. describe:: SelfSimJoin(Attrs, DistColAttr, SimType, Threshold) + + Performs a self sim-join on a table. Performs join if the distance between two rows is + less than the specified float threshold *Threshold*. *SimType* should be one of L1Norm, + L2Norm, Jaccard, and Haversine. *Attrs* gives the list of attributes for computing the + distance between rows. *DistColAttr* is the name of the attribute representing the + distance between rows in the new table. A new :class:`PTable` is returned. + + .. describe:: SetCommonNodeAttrs(SrcAttr, DstAttr, CommonAttr) + + Sets the columns to be used as both source and destination node + attributes. All input parameters should be strings. + + .. describe:: SetDstCol(Attr) + + Sets the column representing destination nodes in the graph. + + .. describe:: SetMP(Value) + + Sets the value of the static variable TTable::UseMP to *Value*, an integer. + + .. describe:: SetSrcCol(Attr) + + Sets the column representing source nodes in the graph. + + .. describe:: SimJoin(Attr1, Table, Attr2, DistColAttr, SimType, Threshold) + + Performs SimJoin on the current table and *Table*. Performs join if the distance between + two rows is less than the specified float threshold *Threshold*. *SimType* should be one + of L1Norm, L2Norm, Jaccard, and Haversine. *Attrs* gives the list of attributes for computing + the distance between rows. *DistColAttr* is the name of the attribute representing the + distance between rows in the new table. A new :class:`PTable` is returned. + + .. describe:: SpliceByGroup(GroupByAttrs, Ordered) + + Splices table into subtables according to the result of a grouping statement. *GroupByAttrs* + is a :class:`TStrV`, an attribute vector grouping should be performed with respect to. + *Ordered* is a flag specifying whether to treat the grouping key as ordered or unordered. + + .. describe:: StoreFltCol(ColName, ColVals) + + Adds entire float column to the table. *ColName* gives the column name and *ColVals* is + :class:`TFltV` giving the vector of column values. + + .. describe:: StoreIntCol(ColName, ColVals) + + Adds entire int column to the table. *ColName* gives the column name and *ColVals* is + :class:`TIntV` giving the vector of column values. + + .. describe:: StoreStrCol(ColName, ColVals) + + Adds entire string column to the table. *ColName* gives the column name and *ColVals* is + :class:`TStrV` giving the vector of column values. + + .. describe:: TableFromHashMap(HashMap, Attr1, Attr2, Context) + + Returns a table constructed from the given hash map *HashMap* of type :class:`TIntH` + or :class:`TIntFltH`. *Attr1* is the name of the attribute corresponding to the first + column and *Attr2* for the second column. + + .. describe:: ToGraphSequence(SplitAttr, AggrPolicy, WindowSize, JumpSize, StartVal, EndVal) + + Returns a sequence of graphs created from the table, where partitioning is based on + values of column with name *SplitAttr* and windows are specified by *JumpSize* and + *WindowSize*. *AggrPolicy* is a :class:`TAttrAggr` indicating the policy for + aggregating node attribute values when a node appears in multiple rows of the table. + It must be one of aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, or aaMedian. + *WindowSize* gives the partition size, and *JumpSize* gives the spacing of the + partitions. Only values of *SplitAttr* between *StartVal* and *EndVal*, inclusive, + are considered. + + .. describe:: ToVarGraphSequence(SplitAttr, AggrPolicy, SplitIntervals) + + Returns a sequence of graphs created from the table, where partitioning is based on values of column *SplitAttr* and intervals specified by *SplitIntervals*. *SplitIntervals* is a + :class:`TIntPrV` that gives the start and end *SplitAttr* attribute values for each + partition of the table. *AggrPolicy* is a :class:`TAttrAggr` indicating the policy for + aggregating node attribute values when a node appears in multiple rows of the table. + + .. describe:: ToGraphPerGroup(GroupAttr, AggrPolicy) + + Returns a sequence of graphs created from the table, where partitioning is based on + the group mappings specified by values of attribute *GroupAttr*. *AggrPolicy* is the + policy for aggregating node attribute values. It must be one of aaSum, aaCount, aaMin, aaMax, + aaFirst, aaLast, aaMean, aaMedian + + .. describe:: ToGraphSequenceIterator(SplitAttr, AggrPolicy, WindowSize, JumpSize, StartVal, EndVal) + + Similar to ToGraphSequence, but instead of returning the sequence of graphs, + returns the first graph in the sequence. To iterate over the sequence, use + TTable::NextGraphIterator and TTable::IsLastGraphOfSequence. + + Calls to TTable::NextGraphIterator() will generate graphs one at a time. This is + beneficial when the entire graph sequence cannot fit in memory. + + .. describe:: ToVarGraphSequenceIterator(SplitAttr, AggrPolicy, SplitIntervals) + + Similar to ToVarGraphSequence, but instead of returning the sequence of graphs, + returns the first graph in the sequence. To iterate over the sequence, use + TTable::NextGraphIterator and TTable::IsLastGraphOfSequence. + + Calls to TTable::NextGraphIterator() will generate graphs one at a time. This is + beneficial when the entire graph sequence cannot fit in memory. + + .. describe:: ToGraphPerGroupIterator(GroupAttr, AggrPolicy) + + Similar to ToGraphPerGroupSequence, but instead of returning the entire sequence + of graphs, returns the first graph in the sequence. To iterate over the sequence, + use :class:`TTable`::NextGraphIterator and :class:`TTable`::IsLastGraphOfSequence. + + Calls to :class:`TTable`::NextGraphIterator() will generate graphs one at a time. This + is beneficial when the entire graph sequence cannot fit in memory. + + .. describe:: NextGraphIterator() + + Returns the next graph, a :class:`PNEANet` object, in the sequence defined + by one of the TTable::ToGraph*Iterator functions. Calls to this function must + be preceded by a single call to one of the above TTable::ToGraph*Iterator functions. + + .. describe:: IsLastGraphOfSequence() + + Checks if the graph sequence defined by one of the TTable::ToGraph* Iterator + functions has been completely iterated over. Calls to this function must be + preceded by a single call to one of the above TTable::ToGraph*Iterator functions. + + .. describe:: Union(PTable) + + Returns a new table containing rows present in either one of the current + table and the passed table. Duplicate rows across tables may not be preserved. + + .. describe:: UnionAll(PTable) + + Returns a new table containing rows present in either one of the + current table and the passed table, *PTable*. Duplicate rows across tables + are preserved. + + .. describe:: Unique(Attrs, Ordered=True) + + Removes rows with duplicate values across the given attributes in *Attrs*. + If *Ordered* is True, values across attributes are treated as an ordered pair. + + + .. describe:: GetIntRowIdxByVal(const TStr& ColName, const TInt& Val) + + Gets a vector containing the indices of rows containing Val in int column ColName. + Uses an index if it has been requested explicitly; else, it loops over all the rows. + Be sure to request an index using :meth:`RequestIndexInt` first if you will call this multiple times. + + .. describe:: GetStrRowIdxByMap(const TStr& ColName, const TInt& Map) + + Gets a vector containing the indices of rows containing the integer Map (which maps to a string) in str column ColName. + Uses an index if it has been requested explicitly; else, it loops over all the rows. + Be sure to request an index using :meth:`RequestIndexStrMap` first if you will call this multiple times. + + .. describe:: GetFltRowIdxByVal(const TStr& ColName, const TFlt& Val) + + Gets a vector containing the indices of rows containing Val in flt column ColName. + Uses an index if it has been requested explicitly; else, it loops over all the rows. + Be sure to request an index using :meth:`RequestIndexFlt` first if you will call this multiple times. + + .. describe:: RequestIndexInt(const TStr& ColName) + + Creates a hash-based index for int column ColName, so that the rows containing a particular + value can be retrieved efficiently. Used by :meth:`GetIntRowIdxByVal` + + .. describe:: RequestIndexFlt(const TStr& ColName) + + Creates a hash-based index for float column ColName, so that the rows containing a particular + value can be retrieved efficiently. Used by :meth:`GetFltRowIdxByVal` + + .. describe:: RequestIndexStrMap(const TStr& ColName) + + Creates a hash-based index for string column ColName, using the integer mappings, + so that the rows containing a particular value can be retrieved efficiently. + Used by :meth:`GetStrRowIdxByMap` + +TAtomicPredicate +================= + +.. class:: TAtomicPredicate() + TAtomicPredicate(Typ, IsCnst, Cmp, L, R) + TAtomicPredicate(Typ, IsCnst, Cmp, L, R, ICnst, FCnst, SCnst) + :noindex: + + Returns a new atomic predicate, for encapsulating common operations. *Typ* provides the type + of the predicate variables, *IsCnst* is a flag indicating if this atomic node represents + a constant value, *Cmp* is one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR, *L* and *R* + are strings giving the left and right variable of the comparison op, and *ICnst*, *FCnst*, and + *SCnst* give the int, float, and str constant value to use if the object is a constant of the + respective type, + +TPredicateNode +============== + +.. class:: TPredicateNode() + TPredicateNode(A) + TPredicateNode(Opr) + TPredicateNode(P) + :noindex: + + Returns a new predicate node, which represents a binary predicate operation on + two predicate nodes. Specify *A*, a :class:`TAtomicPredicate`, if this is a leaf node, + *Opr*, one of AND, NOT, NOP, or OR, for logical operation predicate internal nodes, or + *P*, another :class:`TPredicateNode`, for the copy constructor. + + Below is a list of functions supported by the :class:`TPredicateNode` class: + + .. describe:: AddLeftChild(TPredicateNode* Child) + + Adds *Child* as the left child of the given node. *Child* is a pointer to a + :class:`TPredicateNode`. + + .. describe:: AddRightChild(TPredicateNode* Child) + + Adds *Child* as the right child of the given node. *Child* is a pointer to a + :class:`TPredicateNode`. + + .. describe:: GetVariables(Variables) + + Adds variables to *Variables* in the predicate tree rooted at this node. *Variables* + is a :class:`TStrV`. + +TPredicate +========== + +.. class:: TPredicate() + TPredicate(R) + TPredicate(Pred) + :noindex: + + Returns a new predicate, for encapsulating comparison operations. If *R*, a pointer to a + :class:`TPredicateNode`, is provided, it constructs a predicate with the given root node. + If *Pred*, another :class:`TPredicate`, is supplied, the copy constructor is called. + + Below is a list of functions supported by the :class:`TPredicate` class: + + .. describe:: SetIntVal(VarName, VarVal) + + Sets int variable with name *VarName* to value *VarVal*. + + .. describe:: SetFltVal(VarName, VarVal) + + Sets float variable with name *VarName* to value *VarVal*. + + .. describe:: SetStrVal(VarName, VarVal) + + Sets string variable with name *VarName* to value *VarVal*. + + .. describe:: Eval() + + Return the result of evaluating the current predicate. + + .. describe:: EvalAtomicPredicate(Atom) + + Evaluate the give atomic predicate *Atom*. + + .. describe:: GetVariables(Variables) + + Adds variables to *Variables* in the given predicate. *Variables* is a :class:`TStrV`. + +TTableContext +============= + +.. class:: TTableContext() + TTableContext(SIn) + :noindex: + + Returns an context object. A :class:`TTableContext` provides the execution context for a + :class:`TTable`. The context is loaded in binary from *SIn*, if it is provided. + + The Context is primarily used to handle strings. It maps strings in the table to a unique integer. + To support fast operations, the :class:`TTable` objects store only the corresponding integer for all strings. + When a program needs to retrive the string value, it does so by using the provided method's in the table's + :class:`TTableContext`. + + + Below is a list of functions supported by the :class:`TTableContext` class: + + .. describe:: Load(SIn) + + Loads context in binary from *SIn*. + + .. describe:: Save(SOut) + + Saves context in binary to *SOut*. + + .. describe:: AddStr(Key) + + Adds string *Key* to the context and returns its *KeyId*. + + .. describe:: GetStr(KeyId) + + Returns the string key for the given *KeyId*. + +TPrimitive +========== + +.. class:: TPrimitive() + TPrimitive(Val) + TPrimitive(Prim) + :noindex: + + Returns a new primitive, a wrapper around primitive types. If provided, initialized with + primitive type *Val*, which can be an int, float, or string. Providing *Prim*, another + :class:`TPrimitive`, copies the contents. + + Below is a list of functions supported by the :class:`TPrimitive` class: + + .. describe:: GetInt() + + Returns the int value of the primitive. If the primitive does not represent an int, + returns -1. + + .. describe:: GetFlt() + + Returns the float value of the primitive. If the primitive does not represent an float, + returns -1. + + .. describe:: GetStr() + + Returns the string value of the primitive. If the primitive does not represent an + string, returns the empty string. + + .. describe:: GetType() + + Returns the type of this primitive. + +TTableRow +========== + +.. class:: TTableRow() + :noindex: + + Returns a row object for a :class:`TTable`. + + Below is a list of functions supported by the :class:`TTable` class: + + .. describe:: AddInt(Val) + + Adds int attribute to this row. + + .. describe:: AddInt(Val) + + Adds float attribute to this row. + + .. describe:: AddInt(Val) + + Adds string attribute to this row. + + .. describe:: GetIntVals() + + Gets a vector of all the int attributes of this row. + + .. describe:: GetFltVals() + + Gets a vector of all the float attributes of this row. + + .. describe:: GetStrVals() + + Gets a vector of all the string attributes of this row. + +TRowIterator +============ + +.. class:: TRowIterator() + :noindex: + + Returns a new row iterator for :class:`TTable`. Normally, these objects are + not created directly, but obtained via a call to the table class :class:`TTable` + method, such as :meth:`BegRI()`, that returns a row iterator. + + Below is a list of functions supported by the :class:`TRowIterator` class: + + .. describe:: Next() + + Increments the iterator. + + .. describe:: GetRowIdx() + + Gets the id of the row pointed by this iterator. + + .. describe:: GetIntAttr(ColIdx) + + Returns the value of integer attribute specified by the integer column index for + the current row. + + .. describe:: GetFltAttr(ColIdx) + + Returns the value of float attribute specified by the integer column index for + the current row. + + .. describe:: GetStrAttr(ColIdx) + + Returns the value of string attribute specified by the integer column index for + the current row. + + .. describe:: GetStrMapById(ColIdx) + + Returns the integer mapping of a string attribute value specified by the string + column index for the current row. + + .. describe:: GetIntAttr(Col) + + Returns value of the integer attribute specified by attribute name for the + current row. + + .. describe:: GetFltAttr(Col) + + Returns value of the float attribute specified by attribute name for the + current row. + + .. describe:: GetStrAttr(Col) + + Returns value of the string attribute specified by attribute name for the + current row. + + .. describe:: GetStrMapByName(Col) + + Returns the integer mapping of string attribute specified by attribute name + for the current row. + + .. describe:: CompareAtomicConst(ColIdx, Val, Cmp) + + Compares value in column *ColIdx* with given primitive *Val*. *Cmp* must be one + of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + + .. describe:: CompareAtomicConstTStr(ColIdx, Val, Cmp) + + Compares value in column *ColIdx* with given :class:`TStr` *Val*. *Cmp* must be + one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + +TRowIteratorWithRemove +====================== + +.. class:: TRowIteratorWithRemove() + :noindex: + + Returns a new row iterator that allows for logical row removal while iterating + for :class:`TTable`. Normally, these objects are not created directly, but obtained + via a call to the table class :class:`TTable` method, such as :meth:`BegRIWR()`, that + returns a row iterator. + + Below is a list of functions supported by the :class:`TRowIteratorWithRemove` class: + + .. describe:: Next() + + Increments the iterator. + + .. describe:: GetRowIdx() + + Gets the id of the row pointed by this iterator. + + .. describe:: GetNextRowIdx() + + Gets the id of the next row. + + .. describe:: GetNextIntAttr(ColIdx) + + Returns the value of integer attribute specified by the integer column index for + the next row. + + .. describe:: GetNextFltAttr(ColIdx) + + Returns the value of float attribute specified by the integer column index for + the next row. + + .. describe:: GetNextStrAttr(ColIdx) + + Returns the value of string attribute specified by the integer column index for + the next row. + + .. describe:: GetNextIntAttr(Col) + + Returns value of the integer attribute specified by attribute name for the + next row. + + .. describe:: GetNextFltAttr(Col) + + Returns value of the float attribute specified by attribute name for the + next row. + + .. describe:: GetNextStrAttr(Col) + + Returns value of the string attribute specified by attribute name for the + next row. + + .. describe:: IsFirst() + + Checks whether iterator points to first valid row of the table. + + .. describe:: RemoveNext() + + Removes the next row. + + .. describe:: CompareAtomicConst(ColIdx, Val, Cmp) + + Compares value in column *ColIdx* with given primitive *Val*. *Cmp* must be one + of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + +TTableIterator +============== + +.. class:: TTableIterator() + :noindex: + + Returns a new iterator over vector of :class:`PTable`. Normally, these objects are + not created directly, but obtained via a call to the table class :class:`TTable` + method, such as :meth:`GetMapPageRank()`, that returns a node iterator. + + Below is a list of functions supported by the :class:`TTable` class: + + .. describe:: Next() + + Returns next table in the sequence and update iterator. + + .. describe:: HasNext() + + Checks if iterator has reached end of the sequence. diff --git a/snap-python/source/doc/source/reference/table.rst b/snap-python/source/doc/source/reference/table.rst new file mode 100644 index 0000000000000000000000000000000000000000..96764489b1e0718ed112b7794f940a59a2dba12e --- /dev/null +++ b/snap-python/source/doc/source/reference/table.rst @@ -0,0 +1,1065 @@ +Tables +`````` + +Tables in SNAP are represented by the class :class:`TTable`. + +:class:`TTable` is designed to provide fast performance at scale, and to effortlessly handle datasets containing hundreds of millions of rows. They can be saved and loaded to disk in a binary format using the provided methods; loading from and saving to binary is orders of magnitude faster than using a text representation of the table. + +A :class:`TTable` can store integers, floats and strings in its entries. For performance reasons, strings are mapped to a unique integer, and the :class:`TTable` stores only the integer which maps to the string. Each :class:`TTable` object has an associated :class:`TTableContext` which stores the mapping from integers to strings and back, and can be used when the string corresponding to an integer needs to be retrieved. (Note: many :class:`TTable` objects can share the same context; this is often useful, for example, to ensure that equivalent strings in different tables are treated as equivalent in SNAP. There is one another important aspect of context. Context should not be garbage collected by Python, which means that if it is defined within a function which returns a :class:`TTable` or :class:`TTableContext` variable, then the context variable must be declared as global within the function.) + +A :class:`TTable` object consists of multiple columns, each column being an integer, string or float. This is defined by the table's Schema. A schema is simply a vector of pairs of TStr and TAttrType. (Note: TAttrType represents the type of the column. Currently supported values are snap.atInt, snap.atFlt and snap.atStr.) Each entry in the schema has the name of the column, and the attribute type. + +After the schema and the colums are defined, the data can be stored in rows, with each row containing an entry for each column. It is possible to iterate over the data by row, using the :class:`TRowIterator` class (see documentation below for details). + +:class:`TTable` also provides functionality for doing joins (using the :meth:`Join` method), groupings (using the :meth:`Aggregate` method), selection and projection (using the :meth:`Select` and :meth:`Project` methods), as well as sorting (using the :meth:`Order` method). + +In order to quickly retrieve elements by value, :class:`TTable` allows the user to construct indexes on a column (using :meth:`RequestIndexInt`, :meth:`RequestIndexFlt` and :meth:`RequestIndexStrMap`. Note that unless these functions are explicitly called, the default is to not create any indexes.) + +:class:`TTable` can be loaded from a text-file in spreadsheet (tab-separated or comma-separated) format using the static :meth:`LoadSS` method. + +Tables can be converted to SNAP graph classes using the provided :func:`ToNetwork` functions. + +The tutorial provides extensive documentation on the use of table methods and functions in the section about :doc:`../tutorial/table-tut`. The code snippets below additionally highlight some of the common operations using :class:`TTable` objects. The reference descriptions of methods and functions used are documented in more detail below. + +The following code snippet shows how to load a :class:`TTable` object from a tab-separated file containing one integer, one float and two string columns, and then save the object to disk in binary format:: + + import snap + + context = snap.TTableContext() + filename = "/path/to/input.tsv" + + schema = snap.Schema() + schema.Add(snap.TStrTAttrPr("Col1", snap.atInt)) + schema.Add(snap.TStrTAttrPr("Col2", snap.atFlt)) + schema.Add(snap.TStrTAttrPr("Col3", snap.atStr)) + schema.Add(snap.TStrTAttrPr("Col4", snap.atStr)) + + table = snap.TTable.LoadSS(schema, filename, context, "\t", snap.TBool(False)) + + outfile = "/path/to/output.bin" + FOut = snap.TFOut(outfile) + table.Save(FOut) + FOut.Flush() + +The saved table can now be loaded from binary using:: + + import snap + context = snap.TTableContext() + + outfile = "/path/to/output.bin" + FIn = snap.TFIn(outfile) + table = snap.TTable.Load(FIn, context) + +Note that loading and saving from binary is over ten times faster than loading the raw text file. + +Next, we present a slightly more involved example. Let's say we have an authorship table for academic papers, *PapAuthT* where each row has a PaperID and an AuthorID. (Thus, if paper P1 was written by A1, A2 and A3, and paper P2 by authors A2, we would have four rows in our :class:`TTable`, with data (P1, A1), (P1, A2) and (P1, A3), and (P2, A2).) Further, let's say we have the citation count of each paper in a separate table, *PapCitT*, which has columns PaperID and CitCount. Assuming that these tables have already been loaded into :class:`TTable` objects with appropriate schema, the following code shows how to perform various useful operations on these tables:: + + # Assuming that PapAuthT and PapCitT are already loaded into TTable objects with columns as described above. + + # First, let's say we want to count the number of papers written by an author. We use Aggregate + # with the operation, snap.aaCount. + + # This counts the number of elements with a particular value of the attributes in GroupBy + # (namely, AuthorID), and puts the count in a new column called "CountAuthPapers". + # Note that for the aggregation operation snap.aaCount, the third argument is irrelevant. + GroupBy = snap.TStrV() + GroupBy.Add("AuthorID") + PapAuthT.Aggregate(GroupBy, snap.aaCount, "AuthorID", "CountAuthPapers", snap.TBool(False)) + + # To keep only one row for each author, we can use the TTable.Unique() method as PapAuthT.Unique("AuthorID") + # which will remove all rows with duplicate values of AuthorID. + + # Next, let's say we want to compute the total number of citations each author has. + # This is the sum of the citations of all the papers the author wrote. + # However, the citation info is in PapCitT. Hence, we must join it to this table now. + + # Joins these two tables, merging rows which have the same PaperID in both. + # Now, each row has a PaperID, AuthorID and a CitCount + PapAuthCitJoinT = PapAuthT.Join("PaperID", PapCitT, "PaperID") + + # We now aggregate the citation counts by author, summing them all up to get the + # total number of citations. + GroupBy = snap.TStrV() + GroupBy.Add("AuthorID") + PapAuthCitJoinT.Aggregate(GroupBy, snap.aaSum, "CitCount", "TotalAuthCits", snap.TBool(False)) + + # Now, we have the total number of citations by each author in a new column + # TotalAuthCits. We can now keep just the relevant columns, and drop duplicate rows + # with the same author ID. + + ProjectCols = snap.TStrV() + ProjectCols.Add("AuthorID") + ProjectCols.Add("TotalAuthCits") + AuthCitT = PapAuthCitJoinT.Project(ProjectCols) + AuthCitT.Unique("AuthorID") + + # We can also sort the authors in decreasing order of total citations. + OrderBy = snap.TStrV() # The TTable.Order method sorts using the values of + # the columns in OrderBy, in lexicographic order. + OrderBy.Add("TotalAuthCits") + AuthCitT.Order(OrderBy, "", snap.TBool(False), snap.TBool(False)) + +TTable +====== + +.. class:: TTable() + TTable(Context) + TTable(S, Context) + TTable(SIn, Context) + TTable(H, Col1, Col2, Context, IsStrKeys=False) + TTable(Table, const TIntV& RowIds) + TTable(Table) + + Returns a new table. If no parameters are provided, an empty table is returned. If + *S* and *Context* are provided, the table is initialized with the provided Schema and + TTableContext. If *SIn* is provided, the table is read from the binary stream. If *H*, a + :class:`THash` with :class:`TInt` keys and either :class:`TInt` or :class:`TFlt` values, + is given, the TTable is constructed from the hash table. If *IsStrKeys* is True, then + the :class:`TInt` keys in *H* refer to strings in the *Context*. *Col1* provides the name + for the keys in *H* in the schema for the table and *Col2* does the same for the values. + If *Table* is provided, the contents of *Table* are copied into the current table. If + *RowIds* is given, then only those particular rows are copied. + + Below is a list of functions supported by the :class:`TTable` class: + + .. describe:: AddDstNodeAttr(Attr) + + Adds column with name *Attr* to be used as the destination node attribute + of the graph. + + .. describe:: AddDstNodeAttr(Attrs) + + Adds columns with the names specified in *Attrs*, a :class:`TStrV`, to be used as + destination node attributes of the graph. + + .. describe:: AddEdgeAttr(Attr) + + Adds column with name *Attr* to be used as graph edge attribute. + + .. describe:: AddEdgeAttr(Attrs) + + Adds columns, with names provided in *Attrs*, to be used as graph edge attributes. + + .. describe:: AddNodeAttr(Attr) + + Adds column with name *Attr* to be used as node attribute (both source and destination). + + .. describe:: AddNodeAttr(Attrs) + + Adds columns, with names provided in *Attrs*, to be used as node attribute + (both source and destination). + + .. describe:: AddSrcNodeAttr(Attr) + + Adds column with name *Attr* to be used as the source node attribute + of the graph. + + .. describe:: AddSrcNodeAttr(Attrs) + + Adds columns with the names specified in *Attrs*, a :class:`TStrV`, to be used as + source node attributes of the graph. + + .. describe:: Aggregate(GroupByAttrs, AggOp, ValAttr, ResAttr, Ordered=True) + + Aggregates values over one attribute, *ValAttr*, after grouping with respect to a + list of attributes given in *GroupByAttrs*. Results are stored in a new attribute + with name *ResAttr*. *Ordered* indicates whether to treat grouping key as ordered + (true) or unordered. *AggOp* gives the aggregation policy. It must be one of + aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, or aaMedian. + + .. describe:: AggregateCols(AggrAttrs, AggOp, ResAttr) + + For each row in the table, aggregates values over a list of attributes given by *AggrAttrs*. Results are stored in a new attribute *ResAttr*. *AggOp* gives the aggregation policy. + It must be one of aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, aaMedian + + .. describe:: BegRI() + + Gets an iterator to the first valid row of the table. Returns a :class:`TRowIterator`. + + .. describe:: BegRIWR() + + Gets an iterator to remove the first valid row. Returns a :class:`TRowIteratorWithRemove`. + + .. describe:: Classify(Predicate, LabelAttr, PositiveLabel, NegativeLabel) + + Adds a label attribute, *LabelAttr*, with positive labels, a :class:`TInt` given by + *PositiveLabel*, on rows selected according to the :class:`TPredicate` *Predicate*, + and negative labels, a :class:`TInt` given by *NegativeLabel*, on the rest. + + .. describe:: ClassifyAtomic(Attr1, Attr2, Cmp, LabelAttr, PositiveLabel, + NegativeLabel) + + Adds an integer label attribute, *LabelAttr*, with positive labels, given by *PositiveLabel*, + on selected rows and negative labels, given by *NegativeLabel*, on the rest. Rows are + selected using the atomic compare operator of type :class:`TPredComp`, *Cmp*, over + *Attr1* and *Attr2*. *Cmp* must be one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + + .. describe:: ColAdd(Attr1, Attr2, ResAttr=:class:`TStr`("")) + ColAdd(Attr1, Table, Attr2, ResAttr=:class:`TStr`(""), AddToFirstTable) + ColAdd(Attr1, Value, ResAttr=:class:`TStr`(""), FloatCast) + + Performs the operation *Attr1* + *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* + *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: ColConcat(Attr1, Attr2, Separator, ResAttr=:class:`TStr`("")) + ColConcat(Attr1, Table, Attr2, Separator, ResAttr=:class:`TStr`(""), AddToFirstTable) + + Concatenates the two columns given by *Attr1* and *Attr2*, separated by *Separator*. + *Table* specifies the :class:`TTable` *Attr2* comes from. The result is stored in a + new column, *ResAttr*. If *ResAttr* = "", the result is stored instead in the column + corresponding to *Attr1*. *AddToFirstTable* is a flag specifying whether to add *ResAttr* + to the table corresponding to the caller (true), or to the table *Table*. **NOTE**: + This operation only works on String columns. + + .. describe:: ColConcatConst(Attr, Value, Separator, ResAttr=:class:`TStr`("")) + + Concatenates values for column *Attr* with the given string value *Value*, separated + by *Separator*. Result is stored in a new column *ResAttr*. If *ResAttr* = "", the + result is stored instead in the column corresponding to *Attr1*. **NOTE**: This operation + only works on String columns. + + .. describe:: ColDiv(Attr1, Attr2, ResAttr=:class:`TStr`("")) + ColDiv(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColDiv(Attr1, Value, ResAttr=:class:`TStr`(""), FloatCast) + + Performs the operation *Attr1* / *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* / *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: ColMax(Attr1, Attr2, ResAttr=:class:`TStr`("")) + + Performs the operation MAX (*Attr1*, *Attr2*), where *Attr1* and *Attr2* + are attributes in a table. The result is stored in a new column *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding + to *Attr1*. **NOTE**: This operation does not work on String columns. + + + .. describe:: ColMin(Attr1, Attr2, ResAttr=:class:`TStr`("")) + + Performs the operation MIN (*Attr1*, *Attr2*), where *Attr1* and *Attr2* + are attributes in a table. The result is stored in a new column *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding + to *Attr1*. **NOTE**: This operation does not work on String columns. + + .. describe:: ColMod(Attr1, Attr2, ResAttr) + ColMod(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColMod(Attr1, Value, ResAttr, FloatCast) + + Performs the operation *Attr1* % *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* % *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String or float columns. + + .. describe:: ColMul(Attr1, Attr2, ResAttr) + ColMul(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColMul(Attr1, Value, ResAttr, FloatCast) + + Performs the operation *Attr1* * *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* * *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: ColSub(Attr1, Attr2, ResAttr) + ColSub(Attr1, Table, Attr2, ResAttr, AddToFirstTable) + ColSub(Attr1, Value, ResAttr, FloatCast) + + Performs the operation *Attr1* - *Attr2*, where *Attr1* and *Attr2* are attributes + which can belong to the same or different tables. Could also perform *Attr1* - *Value*, + depending on the function prototype. The result is stored in a new attribute, *ResAttr*. + If *ResAttr* = "", the result is stored instead in the column corresponding to *Attr1*. + If *FloatCast*, a :class:`TBool`, is set to true, then values in Int columns are cast to + Flt values. *AddToFirstTable* is a flag specifying whether to add *ResAttr* to the table + corresponding to the caller (true), or to the table *Table*. **NOTE**: This operation + does not work on String columns. + + .. describe:: Count(Attr, ResAttr) + + For each row of the table, counts number of rows in the table sharing the same value + as it for a given attribute *Attr*, a :class:`TStr`. The result is stored in a new + attribute, *ResAttr*. + + .. describe:: EndRI() + + Gets an iterator to the last valid row of the table. Returns a :class:`TRowIterator`. + + + .. describe:: EndRIWR() + + Gets an iterator to remove the last valid row. Returns a :class:`TRowIteratorWithRemove`. + + + .. describe:: GetColType(Attr) + + Gets type of an attribute *Attr*. Returns a :class:`TAttrType` object representing + attribute type. + + .. describe:: GetDstCol() + + Returns the name, a :class:`TStr`, of the column representing destination nodes + in the graph. + + .. describe:: GetDstNodeFltAttrV() + + Returns the names of the Flt columns, in a :class:`TStrV`, corresponding to attributes + of the destination nodes. + + .. describe:: GetDstNodeIntAttrV() + + Returns the names of the Int columns, in a :class:`TStrV`, corresponding to attributes + of the destination nodes. + + .. describe:: GetDstNodeStrAttrV() + + Returns the names of the Str columns, in a :class:`TStrV`, corresponding to attributes + of the destination nodes. + + .. describe:: GetEdgeFltAttrV() + + Returns the names of the Flt columns, in a :class:`TStrV`, corresponding to edge + attributes. + + .. describe:: GetEdgeIntAttrV() + + Returns the names of the Int columns, in a :class:`TStrV`, corresponding to edge + attributes. + + .. describe:: GetEdgeStrAttrV() + + Returns the names of the Str columns, in a :class:`TStrV`, corresponding to edge + attributes. + + .. describe:: GetEdgeTable(Network, Context) + + Extracts edge TTable from the :class:`TNEANet` *Network*, using the :class:`TTableContext` + *Context*. Returns the resulting :class:`PTable`. + + .. describe:: GetEdgeTablePN(Network, Context) + + Extracts edge TTable from the :class:`PNGraphMP` *Network*, using the :class:`TTableContext` + *Context*. Returns the resulting :class:`PTable`. **NOTE**: Defined only if OpenMP present. + + .. describe:: GetFltNodePropertyTable(Network, Property, NodeAttrName, NodeAttrType, PropertyAttrName, Context) + + Extracts node and and edge property TTables from a THash. *Network* is of type + :class:`TNEANet`, *Property* is a :class:`TIntFltH`, *NodeAttrName* and + *PropertyAttrName* are :class:`TStr`s, *NodeAttrType* is a :class:`TAttrType`, and + *Context* is a :class:`TTableContext`. Returns a :class:`PTable` object. + + .. describe:: GetFltVal(Attr, RowIdx) + + Gets the value of float attribute with name *Attr* at row *RowIdx*. + + .. describe:: GetFltValAtRowIdx(ColIdx, RowIdx) + + Gets the value of the float column at index *ColIdx* at row *RowIdx*. + + .. describe:: GetIntVal(Attr, RowIdx) + + Gets the value of integer attribute with name *Attr* at row *RowIdx*. + + .. describe:: GetIntValAtRowIdx(ColIdx, RowIdx) + + Gets the value of the integer column at index *ColIdx* at row *RowIdx*. + + .. describe:: GetMP() + + Returns the value of the static variable TTable::UseMP, which controls whether + to use multi-threading. TTable::UseMP is 1 by default (meaning algorithms are + multi-threaded by default if the OpenMP library is present). + + .. describe:: GetMapHitsIterator(GraphSeq, Context, MaxIter=20) + + Computes a sequence of Hits tables for a graph sequence *GraphSeq*, a + :class:`TVec`. A :class:`TTableIterator` is returned. + + .. describe:: GetMapPageRank(GraphSeq, Context, C=0.85, Eps=1e-4, MaxIter=100) + + Computes a sequence of PageRank tables for a graph sequence *GraphSeq*, a + :class:`TVec`. A :class:`TTableIterator` is returned. + + .. describe:: GetNodeTable() + + Extracts node TTable from :class:`TNEANet` *Network*, using :class:`TTableContext` *Context*. + + .. describe:: GetNumRows() + + Returns total number of rows in the table. Count could include + rows which have been deleted previously. + + .. describe:: GetNumValidRows() + + Returns total number of valid rows in the table. + + .. describe:: GetSchema() + + Returns the schema of the table. Return type is :class:`Schema`. + + .. describe:: GetSrcCol() + + Returns the name of the column representing source nodes in the graph. + + .. describe:: GetSrcNodeFltAttrV() + + Returns the names of the Flt columns corresponding to attributes of the + source nodes. Return type is :class:`TStrV`. + + .. describe:: GetSrcNodeIntAttrV() + + Returns the names of the Int columns corresponding to attributes of the + source nodes. Return type is :class:`TStrV`. + + .. describe:: GetSrcNodeStrAttrV() + + Returns the names of the Str columns corresponding to attributes of the + source nodes. Return type is :class:`TStrV`. + + .. describe:: GetStrVal(Attr, RowIdx) + + Gets the value of string attribute with name *Attr* at row *RowIdx*. + + .. describe:: Group(GroupByAttrs, GroupAttrName, Ordered=True) + + Groups rows according to the attributes specified by GroupByAttrs, a :class:`TStrV`. + Result is stored in a new column of the table with name *GroupAttrName*. + + .. describe:: Intersection(PTable) + + Returns a new table containing rows present in the current table + that are also present in *PTable*, which is of type :class:`PTable`. + + .. describe:: Join(Attr1, PTable, Attr2) + + Performs an equi-join on the current table and another table, *PTable* over + attributes *Attr1* in the current table and *Attr2* in *PTable*. + + .. describe:: Load(SIn, Context) + + Loads table from the input stream *SIn* using + :class:`TTableContext` *Context*. Returns a :class:`PTable`. + + .. describe:: LoadSS(Schema, InFNm, Context, Separator='\\t', HasTitleLine=False) + + Loads table from spread sheet (TSV, CSV, etc). *Schema* is a :class:`Schema` object, + *InFNm* provides the input file name, *Context is a :class:`TTableContext`, *Separator* + is the field separator character in the input file, and HasTitleLine indicates whether + the first line is a title line with the name of the columns (without a # preceding it). + If *HasTitleLine* is True, then *Schema* is validated against it. + + .. describe:: Minus(PTable) + + Returns a new table containing rows present in the current table which are not + present in another table given by *PTable*. + + .. describe:: Order(OrderByAttrs, ResAttr, ResetRankFlag=False, Asc=True) + + Orders the rows according to the values in *OrderByAttrs* (a :class:`TStrV`). + Results are stored in new column with name *ResAttr*. If *Asc* is True, rows + are ordered in ascending lexicographic order. + + .. describe:: Project(ProjectAttrs) + + Returns a table with only the attributes in *ProjectAttrs*, a :class:`TStrV`. + + .. describe:: ProjectInPlace(ProjectAttrs) + + Modifies the current table to keep only the attributes specified + in *ProjectAttrs*. + + .. describe:: ReadFltCol(Attr, Result) + + Reads values of an entire float column given by *Attr* into the :class:`TFltV` + *Result*. + + .. describe:: ReadIntCol(Attr, Result) + + Reads values of an entire int column given by *Attr* into the :class:`TIntV` + *Result*. + + .. describe:: ReadStrCol(Attr, Result) + + Reads values of an entire string column given by *Attr* into the :class:`TStrV` + *Result*. + + .. describe:: Rename(Attr, NewAttr) + + Renames an attribute with name *Attr* to new name *NewAttr* in a table. + + + .. describe:: SaveBin(OutFNm) + + Saves table schema and content into a binary file with name *OutFNm*. + + .. describe:: SaveSS(OutFNm) + + Saves table schema and content into a TSV file with name *OutFNm*. + + .. describe:: Select(Predicate, SelectedRows, Remove=True) + + Selects rows that satisfy a given Predicate, of type :class:`TPredicate`. + The selected row indices are stored in *SelectedRows*, a :class:`TIntV`. If + *Remove* is True, rows that do not match the predicate are removed. + + .. describe:: SelectAtomic(Attr1, Attr2, Cmp, SelectedRows, Remove=True) + + Selects rows which satisfy an atomic compare operation, *Cmp*, of type + :class:`TPredComp`. *Cmp* must be one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, + or SUPERSTR. The selected row indices are stored in *SelectedRows*, + a :class:`TIntV`. If *Remove* is True, rows that do not match the predicate + are removed. + + .. describe:: SelectAtomicFltConst(Attr, Val, Cmp, SelectedTable) + + Selects rows where the value of a float attribute, *Attr*, satisfies an atomic + comparison, *Cmp*, with a primitive type *Val*. *Cmp* must be one of LT, LTE, + EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. The selected rows are added to the + :class:`PTable` *SelectedTable*. + + .. describe:: SelectAtomicIntConst(Attr, Val, Cmp, SelectedTable) + + Selects rows where the value of a int attribute, *Attr*, satisfies an atomic + comparison, *Cmp*, with a primitive type *Val*. *Cmp* must be one of LT, LTE, + EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. The selected rows are added to the + :class:`PTable` *SelectedTable*. + + .. describe:: SelectAtomicStrConst(Attr, Val, Cmp, SelectedTable) + + Selects rows where the value of a string attribute, *Attr*, satisfies an atomic + comparison, *Cmp*, with a primitive type *Val*. *Cmp* must be one of LT, LTE, EQ, + NEQ, GTE, GT, SUBSTR, or SUPERSTR. The selected rows are added to the :class:`PTable` + *SelectedTable*. + + .. describe:: SelectFirstNRows(N) + + Modifies table in place so that it only its first *N* rows are retained. + + .. describe:: SelfJoin(Attr) + + Performs a self-join on the table on the attribute *Attr*. Returns a new table. + + .. describe:: SelfSimJoin(Attrs, DistColAttr, SimType, Threshold) + + Performs a self sim-join on a table. Performs join if the distance between two rows is + less than the specified float threshold *Threshold*. *SimType* should be one of L1Norm, + L2Norm, Jaccard, and Haversine. *Attrs* gives the list of attributes for computing the + distance between rows. *DistColAttr* is the name of the attribute representing the + distance between rows in the new table. A new :class:`PTable` is returned. + + .. describe:: SetCommonNodeAttrs(SrcAttr, DstAttr, CommonAttr) + + Sets the columns to be used as both source and destination node + attributes. All input parameters should be strings. + + .. describe:: SetDstCol(Attr) + + Sets the column representing destination nodes in the graph. + + .. describe:: SetMP(Value) + + Sets the value of the static variable TTable::UseMP to *Value*, an integer. + + .. describe:: SetSrcCol(Attr) + + Sets the column representing source nodes in the graph. + + .. describe:: SimJoin(Attr1, Table, Attr2, DistColAttr, SimType, Threshold) + + Performs SimJoin on the current table and *Table*. Performs join if the distance between + two rows is less than the specified float threshold *Threshold*. *SimType* should be one + of L1Norm, L2Norm, Jaccard, and Haversine. *Attrs* gives the list of attributes for computing + the distance between rows. *DistColAttr* is the name of the attribute representing the + distance between rows in the new table. A new :class:`PTable` is returned. + + .. describe:: SpliceByGroup(GroupByAttrs, Ordered) + + Splices table into subtables according to the result of a grouping statement. *GroupByAttrs* + is a :class:`TStrV`, an attribute vector grouping should be performed with respect to. + *Ordered* is a flag specifying whether to treat the grouping key as ordered or unordered. + + .. describe:: StoreFltCol(ColName, ColVals) + + Adds entire float column to the table. *ColName* gives the column name and *ColVals* is + :class:`TFltV` giving the vector of column values. + + .. describe:: StoreIntCol(ColName, ColVals) + + Adds entire int column to the table. *ColName* gives the column name and *ColVals* is + :class:`TIntV` giving the vector of column values. + + .. describe:: StoreStrCol(ColName, ColVals) + + Adds entire string column to the table. *ColName* gives the column name and *ColVals* is + :class:`TStrV` giving the vector of column values. + + .. describe:: TableFromHashMap(HashMap, Attr1, Attr2, Context) + + Returns a table constructed from the given hash map *HashMap* of type :class:`TIntH` + or :class:`TIntFltH`. *Attr1* is the name of the attribute corresponding to the first + column and *Attr2* for the second column. + + .. describe:: ToGraphSequence(SplitAttr, AggrPolicy, WindowSize, JumpSize, StartVal, EndVal) + + Returns a sequence of graphs created from the table, where partitioning is based on + values of column with name *SplitAttr* and windows are specified by *JumpSize* and + *WindowSize*. *AggrPolicy* is a :class:`TAttrAggr` indicating the policy for + aggregating node attribute values when a node appears in multiple rows of the table. + It must be one of aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, or aaMedian. + *WindowSize* gives the partition size, and *JumpSize* gives the spacing of the + partitions. Only values of *SplitAttr* between *StartVal* and *EndVal*, inclusive, + are considered. + + .. describe:: ToVarGraphSequence(SplitAttr, AggrPolicy, SplitIntervals) + + Returns a sequence of graphs created from the table, where partitioning is based on values of column *SplitAttr* and intervals specified by *SplitIntervals*. *SplitIntervals* is a + :class:`TIntPrV` that gives the start and end *SplitAttr* attribute values for each + partition of the table. *AggrPolicy* is a :class:`TAttrAggr` indicating the policy for + aggregating node attribute values when a node appears in multiple rows of the table. + + .. describe:: ToGraphPerGroup(GroupAttr, AggrPolicy) + + Returns a sequence of graphs created from the table, where partitioning is based on + the group mappings specified by values of attribute *GroupAttr*. *AggrPolicy* is the + policy for aggregating node attribute values. It must be one of aaSum, aaCount, aaMin, aaMax, + aaFirst, aaLast, aaMean, aaMedian + + .. describe:: ToGraphSequenceIterator(SplitAttr, AggrPolicy, WindowSize, JumpSize, StartVal, EndVal) + + Similar to ToGraphSequence, but instead of returning the sequence of graphs, + returns the first graph in the sequence. To iterate over the sequence, use + TTable::NextGraphIterator and TTable::IsLastGraphOfSequence. + + Calls to TTable::NextGraphIterator() will generate graphs one at a time. This is + beneficial when the entire graph sequence cannot fit in memory. + + .. describe:: ToVarGraphSequenceIterator(SplitAttr, AggrPolicy, SplitIntervals) + + Similar to ToVarGraphSequence, but instead of returning the sequence of graphs, + returns the first graph in the sequence. To iterate over the sequence, use + TTable::NextGraphIterator and TTable::IsLastGraphOfSequence. + + Calls to TTable::NextGraphIterator() will generate graphs one at a time. This is + beneficial when the entire graph sequence cannot fit in memory. + + .. describe:: ToGraphPerGroupIterator(GroupAttr, AggrPolicy) + + Similar to ToGraphPerGroupSequence, but instead of returning the entire sequence + of graphs, returns the first graph in the sequence. To iterate over the sequence, + use :class:`TTable`::NextGraphIterator and :class:`TTable`::IsLastGraphOfSequence. + + Calls to :class:`TTable`::NextGraphIterator() will generate graphs one at a time. This + is beneficial when the entire graph sequence cannot fit in memory. + + .. describe:: NextGraphIterator() + + Returns the next graph, a :class:`PNEANet` object, in the sequence defined + by one of the TTable::ToGraph*Iterator functions. Calls to this function must + be preceded by a single call to one of the above TTable::ToGraph*Iterator functions. + + .. describe:: IsLastGraphOfSequence() + + Checks if the graph sequence defined by one of the TTable::ToGraph* Iterator + functions has been completely iterated over. Calls to this function must be + preceded by a single call to one of the above TTable::ToGraph*Iterator functions. + + .. describe:: Union(PTable) + + Returns a new table containing rows present in either one of the current + table and the passed table. Duplicate rows across tables may not be preserved. + + .. describe:: UnionAll(PTable) + + Returns a new table containing rows present in either one of the + current table and the passed table, *PTable*. Duplicate rows across tables + are preserved. + + .. describe:: Unique(Attrs, Ordered=True) + + Removes rows with duplicate values across the given attributes in *Attrs*. + If *Ordered* is True, values across attributes are treated as an ordered pair. + + + .. describe:: GetIntRowIdxByVal(const TStr& ColName, const TInt& Val) + + Gets a vector containing the indices of rows containing Val in int column ColName. + Uses an index if it has been requested explicitly; else, it loops over all the rows. + Be sure to request an index using :meth:`RequestIndexInt` first if you will call this multiple times. + + .. describe:: GetStrRowIdxByMap(const TStr& ColName, const TInt& Map) + + Gets a vector containing the indices of rows containing the integer Map (which maps to a string) in str column ColName. + Uses an index if it has been requested explicitly; else, it loops over all the rows. + Be sure to request an index using :meth:`RequestIndexStrMap` first if you will call this multiple times. + + .. describe:: GetFltRowIdxByVal(const TStr& ColName, const TFlt& Val) + + Gets a vector containing the indices of rows containing Val in flt column ColName. + Uses an index if it has been requested explicitly; else, it loops over all the rows. + Be sure to request an index using :meth:`RequestIndexFlt` first if you will call this multiple times. + + .. describe:: RequestIndexInt(const TStr& ColName) + + Creates a hash-based index for int column ColName, so that the rows containing a particular + value can be retrieved efficiently. Used by :meth:`GetIntRowIdxByVal` + + .. describe:: RequestIndexFlt(const TStr& ColName) + + Creates a hash-based index for float column ColName, so that the rows containing a particular + value can be retrieved efficiently. Used by :meth:`GetFltRowIdxByVal` + + .. describe:: RequestIndexStrMap(const TStr& ColName) + + Creates a hash-based index for string column ColName, using the integer mappings, + so that the rows containing a particular value can be retrieved efficiently. + Used by :meth:`GetStrRowIdxByMap` + +TAtomicPredicate +================= + +.. class:: TAtomicPredicate() + TAtomicPredicate(Typ, IsCnst, Cmp, L, R) + TAtomicPredicate(Typ, IsCnst, Cmp, L, R, ICnst, FCnst, SCnst) + + Returns a new atomic predicate, for encapsulating common operations. *Typ* provides the type + of the predicate variables, *IsCnst* is a flag indicating if this atomic node represents + a constant value, *Cmp* is one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR, *L* and *R* + are strings giving the left and right variable of the comparison op, and *ICnst*, *FCnst*, and + *SCnst* give the int, float, and str constant value to use if the object is a constant of the + respective type, + +TPredicateNode +============== + +.. class:: TPredicateNode() + TPredicateNode(A) + TPredicateNode(Opr) + TPredicateNode(P) + + Returns a new predicate node, which represents a binary predicate operation on + two predicate nodes. Specify *A*, a :class:`TAtomicPredicate`, if this is a leaf node, + *Opr*, one of AND, NOT, NOP, or OR, for logical operation predicate internal nodes, or + *P*, another :class:`TPredicateNode`, for the copy constructor. + + Below is a list of functions supported by the :class:`TPredicateNode` class: + + .. describe:: AddLeftChild(TPredicateNode* Child) + + Adds *Child* as the left child of the given node. *Child* is a pointer to a + :class:`TPredicateNode`. + + .. describe:: AddRightChild(TPredicateNode* Child) + + Adds *Child* as the right child of the given node. *Child* is a pointer to a + :class:`TPredicateNode`. + + .. describe:: GetVariables(Variables) + + Adds variables to *Variables* in the predicate tree rooted at this node. *Variables* + is a :class:`TStrV`. + +TPredicate +========== + +.. class:: TPredicate() + TPredicate(R) + TPredicate(Pred) + + Returns a new predicate, for encapsulating comparison operations. If *R*, a pointer to a + :class:`TPredicateNode`, is provided, it constructs a predicate with the given root node. + If *Pred*, another :class:`TPredicate`, is supplied, the copy constructor is called. + + Below is a list of functions supported by the :class:`TPredicate` class: + + .. describe:: SetIntVal(VarName, VarVal) + + Sets int variable with name *VarName* to value *VarVal*. + + .. describe:: SetFltVal(VarName, VarVal) + + Sets float variable with name *VarName* to value *VarVal*. + + .. describe:: SetStrVal(VarName, VarVal) + + Sets string variable with name *VarName* to value *VarVal*. + + .. describe:: Eval() + + Return the result of evaluating the current predicate. + + .. describe:: EvalAtomicPredicate(Atom) + + Evaluate the give atomic predicate *Atom*. + + .. describe:: GetVariables(Variables) + + Adds variables to *Variables* in the given predicate. *Variables* is a :class:`TStrV`. + +TTableContext +============= + +.. class:: TTableContext() + TTableContext(SIn) + + Returns an context object. A :class:`TTableContext` provides the execution context for a + :class:`TTable`. The context is loaded in binary from *SIn*, if it is provided. + + The Context is primarily used to handle strings. It maps strings in the table to a unique integer. + To support fast operations, the :class:`TTable` objects store only the corresponding integer for all strings. + When a program needs to retrive the string value, it does so by using the provided method's in the table's + :class:`TTableContext`. + + + Below is a list of functions supported by the :class:`TTableContext` class: + + .. describe:: Load(SIn) + + Loads context in binary from *SIn*. + + .. describe:: Save(SOut) + + Saves context in binary to *SOut*. + + .. describe:: AddStr(Key) + + Adds string *Key* to the context and returns its *KeyId*. + + .. describe:: GetStr(KeyId) + + Returns the string key for the given *KeyId*. + +TPrimitive +========== + +.. class:: TPrimitive() + TPrimitive(Val) + TPrimitive(Prim) + + Returns a new primitive, a wrapper around primitive types. If provided, initialized with + primitive type *Val*, which can be an int, float, or string. Providing *Prim*, another + :class:`TPrimitive`, copies the contents. + + Below is a list of functions supported by the :class:`TPrimitive` class: + + .. describe:: GetInt() + + Returns the int value of the primitive. If the primitive does not represent an int, + returns -1. + + .. describe:: GetFlt() + + Returns the float value of the primitive. If the primitive does not represent an float, + returns -1. + + .. describe:: GetStr() + + Returns the string value of the primitive. If the primitive does not represent an + string, returns the empty string. + + .. describe:: GetType() + + Returns the type of this primitive. + +TTableRow +========== + +.. class:: TTableRow() + + Returns a row object for a :class:`TTable`. + + Below is a list of functions supported by the :class:`TTable` class: + + .. describe:: AddInt(Val) + + Adds int attribute to this row. + + .. describe:: AddInt(Val) + + Adds float attribute to this row. + + .. describe:: AddInt(Val) + + Adds string attribute to this row. + + .. describe:: GetIntVals() + + Gets a vector of all the int attributes of this row. + + .. describe:: GetFltVals() + + Gets a vector of all the float attributes of this row. + + .. describe:: GetStrVals() + + Gets a vector of all the string attributes of this row. + +TRowIterator +============ + +.. class:: TRowIterator() + + Returns a new row iterator for :class:`TTable`. Normally, these objects are + not created directly, but obtained via a call to the table class :class:`TTable` + method, such as :meth:`BegRI()`, that returns a row iterator. + + Below is a list of functions supported by the :class:`TRowIterator` class: + + .. describe:: Next() + + Increments the iterator. + + .. describe:: GetRowIdx() + + Gets the id of the row pointed by this iterator. + + .. describe:: GetIntAttr(ColIdx) + + Returns the value of integer attribute specified by the integer column index for + the current row. + + .. describe:: GetFltAttr(ColIdx) + + Returns the value of float attribute specified by the integer column index for + the current row. + + .. describe:: GetStrAttr(ColIdx) + + Returns the value of string attribute specified by the integer column index for + the current row. + + .. describe:: GetStrMapById(ColIdx) + + Returns the integer mapping of a string attribute value specified by the string + column index for the current row. + + .. describe:: GetIntAttr(Col) + + Returns value of the integer attribute specified by attribute name for the + current row. + + .. describe:: GetFltAttr(Col) + + Returns value of the float attribute specified by attribute name for the + current row. + + .. describe:: GetStrAttr(Col) + + Returns value of the string attribute specified by attribute name for the + current row. + + .. describe:: GetStrMapByName(Col) + + Returns the integer mapping of string attribute specified by attribute name + for the current row. + + .. describe:: CompareAtomicConst(ColIdx, Val, Cmp) + + Compares value in column *ColIdx* with given primitive *Val*. *Cmp* must be one + of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + + .. describe:: CompareAtomicConstTStr(ColIdx, Val, Cmp) + + Compares value in column *ColIdx* with given :class:`TStr` *Val*. *Cmp* must be + one of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + +TRowIteratorWithRemove +====================== + +.. class:: TRowIteratorWithRemove() + + Returns a new row iterator that allows for logical row removal while iterating + for :class:`TTable`. Normally, these objects are not created directly, but obtained + via a call to the table class :class:`TTable` method, such as :meth:`BegRIWR()`, that + returns a row iterator. + + Below is a list of functions supported by the :class:`TRowIteratorWithRemove` class: + + .. describe:: Next() + + Increments the iterator. + + .. describe:: GetRowIdx() + + Gets the id of the row pointed by this iterator. + + .. describe:: GetNextRowIdx() + + Gets the id of the next row. + + .. describe:: GetNextIntAttr(ColIdx) + + Returns the value of integer attribute specified by the integer column index for + the next row. + + .. describe:: GetNextFltAttr(ColIdx) + + Returns the value of float attribute specified by the integer column index for + the next row. + + .. describe:: GetNextStrAttr(ColIdx) + + Returns the value of string attribute specified by the integer column index for + the next row. + + .. describe:: GetNextIntAttr(Col) + + Returns value of the integer attribute specified by attribute name for the + next row. + + .. describe:: GetNextFltAttr(Col) + + Returns value of the float attribute specified by attribute name for the + next row. + + .. describe:: GetNextStrAttr(Col) + + Returns value of the string attribute specified by attribute name for the + next row. + + .. describe:: IsFirst() + + Checks whether iterator points to first valid row of the table. + + .. describe:: RemoveNext() + + Removes the next row. + + .. describe:: CompareAtomicConst(ColIdx, Val, Cmp) + + Compares value in column *ColIdx* with given primitive *Val*. *Cmp* must be one + of LT, LTE, EQ, NEQ, GTE, GT, SUBSTR, or SUPERSTR. + +TTableIterator +============== + +.. class:: TTableIterator() + + Returns a new iterator over vector of :class:`PTable`. Normally, these objects are + not created directly, but obtained via a call to the table class :class:`TTable` + method, such as :meth:`GetMapPageRank()`, that returns a node iterator. + + Below is a list of functions supported by the :class:`TTable` class: + + .. describe:: Next() + + Returns next table in the sequence and update iterator. + + .. describe:: HasNext() + + Checks if iterator has reached end of the sequence. diff --git a/snap-python/source/doc/source/reference/triads.rst b/snap-python/source/doc/source/reference/triads.rst new file mode 100644 index 0000000000000000000000000000000000000000..262f072dcb9a9947da0994acd9e97e7a7896f4fa --- /dev/null +++ b/snap-python/source/doc/source/reference/triads.rst @@ -0,0 +1,22 @@ + +Triads and Clustering Coefficient +````````````````````````````````` + +.. toctree:: + :maxdepth: 2 + + GetClustCf + GetClustCfAll + GetTriads + GetTriadsByNode + GetTriadsAll + GetCmnNbrs + GetNodeClustCf + GetNodeClustCfAll + GetNodeTriads + GetNodeTriadsSet + GetNodeTriadsAll + GetLen2Paths + GetTriadEdges + GetTriadParticip + diff --git a/snap-python/source/doc/source/tutorial/index-tut.rst b/snap-python/source/doc/source/tutorial/index-tut.rst new file mode 100644 index 0000000000000000000000000000000000000000..0e509ae85669ac108150030380881c34a58171a4 --- /dev/null +++ b/snap-python/source/doc/source/tutorial/index-tut.rst @@ -0,0 +1,11 @@ +Snap.py Tutorial +---------------- + +Contents: + +.. toctree:: + :maxdepth: 1 + + tutorial + table-tut + diff --git a/snap-python/source/doc/source/tutorial/table-tut.rst b/snap-python/source/doc/source/tutorial/table-tut.rst new file mode 100644 index 0000000000000000000000000000000000000000..6be220bb7fc02dac08b569538653c858d5808993 --- /dev/null +++ b/snap-python/source/doc/source/tutorial/table-tut.rst @@ -0,0 +1,363 @@ +Tables +````````````````````` +The :class:`TTable` in SNAP is a table data structure for storing tabular data, which can easily be converted into the SNAP graph. The :class:`TTable` is much more efficient than other tabular data structures and functions seamlessly inside the SNAP universe. The :class:`TTable` can easily store hundreds of millions of rows and perform complex data manipulation operations. + +:class:`TTable` objects can be easily loaded from CSV and TSV files. :class:`TTable` objects can store integers, strings, and floats in its columns. Each column can store exactly one data type, and each column has its own name, a string. + +This tutorial will cover: + +* how to create a TTable, +* how to save and load a TTable, +* how to perform columnwise operations on TTables, +* how to perform rowwise operations on TTables, +* how to join two TTables together, +* and how to extract information from a TTable. + +Creating a :class:`TTable` +========================== + +To create a :class:`TTable` object in SNAP, you must first define the: + +* Context: The Context holds information behind-the-scenes about the mappings between integers and strings (which reduces memory usage). You don’t have to do anything with the Context except create it and use it as a parameter when creating your :class:`TTable`. Many :class:`TTable` objects can share the same Context. +* Schema: The Schema defines the column names in the table and their data types, which, unlike in other Python packages, you must specify up-front. Each column can be either an integer column, a float column, or a string column. Each column can hold values of only that data type. + +For this tutorial, let’s assume the table below is a tab-separated file with the following columns and values, called ‘student_grades.tsv’: + +.. table:: Student Grades + :widths: 15 10 10 10 + + ========== ========== ========== ========== + StudentID Midterm1 Midterm2 Final + ========== ========== ========== ========== + 101 79 86 88 + 102 84 80 79 + 103 56 76 80 + 104 90 92 96 + 105 92 85 87 + 106 87 95 92 + 107 94 90 91 + 108 76 88 81 + ========== ========== ========== ========== + +To turn this into a SNAP table, we must create a Context and Schema:: + + >>> import snap + + >>> context = snap.TTableContext() + >>> schema = snap.Schema() + >>> schema.Add(snap.TStrTAttrPr("StudentID", snap.atInt)) + >>> schema.Add(snap.TStrTAttrPr("Midterm1", snap.atInt)) + >>> schema.Add(snap.TStrTAttrPr("Midterm2", snap.atInt)) + >>> schema.Add(snap.TStrTAttrPr("Final", snap.atInt)) + +As you can see, defining the Context simply requires initializing an object of type *TTableContext*. That’s all you have to do for the Context! There is one another important aspect of Context. Context should not be garbage collected by Python, which means that if it is defined within a function which returns TTable or Context, then the variable must be declared as global within the function: + >>> global context + +For the Schema, you must first initialize an object of the SNAP Schema type, and then use the :meth:`Add()` method to create column types for the :class:`TTable` you want to build. The Add() method takes one parameter, a SNAP *TStrTAttrPr*, which is a pair consisting of a string and an attribute. An attribute in SNAP is used to represent different data types using an integer key; you don’t have to worry about this, but just remember that the Schema requires this data type for the columns. There are always 2 components of a *TStrTAttrPr*: the name of the column, which is a string, and the type of data that the column with that name will hold. The options are atInt (integer attribute), atFlt (float attribute), and atStr (string attribute). Since our columns are type integer, we will use atInt for all of them. + +We now have the building blocks for a :class:`TTable` with four columns and a context! Next, we’ll show how to create a :class:`TTable` from these components, plus a path to a file that we want to make a :class:`TTable` from. :class:`TTable` objects can be created from comma-separated files (CSV) and tab-separated files (TSV). Here’s an example:: + + >>> filename = "/path/to/student_grades.tsv" + >>> grade_table = snap.TTable.LoadSS(schema, filename, context, "\t", snap.TBool(True)) + +For the filename, we simply use the path to that file on the local machine. Then, to create a table, we use the function :meth:`TTable.LoadSS()`. This function takes in 5 parameters: + +* The Schema that we made before, which should correspond to the number and types of columns in the TSV file +* The name of the path to the file, as a string +* The Context created earlier +* The separator used in the file (“\t” for tab separated, “,” for comma separated, etc.) +* A *snap.TBool* boolean value indicating whether or not the file has a ‘title line,’ that is, a beginning line of column names or other text that is not commented out with a #. Remember that your Schema already has column names, so you don’t want to include them from your CSV or TSV since they’ll throw an error! In our example above, we did have column names in our TSV, so we set this boolean to True. + +Now we’ve successfully created a :class:`TTable` in SNAP! Recall that you can accommodate any table by changing the Schema for the number and type of columns that you need. + +Saving and Loading a :class:`TTable` with Binary Format +======================================================= + +Next, we’ll demonstrate how to save a :class:`TTable` and load one from binary. :class:`TTable` objects can be saved in binary format because this saves space (in fact, it’s orders of magnitude more efficient than saving it as text). To save a :class:`TTable` to binary format, you use the following: + + >>> outfile = "/path/to/grade_table.bin" + >>> FOut = snap.TFOut(outfile) + >>> table.Save(FOut) + >>> FOut.Flush() + +The four steps are: + +* Create a path to the file you want to save your :class:`TTable` to. +* Create a TFOut object. A SNAP *TFout* object allows writing the contents of a file to the specified pathname. +* Save the table to your *TFOut* object (here, named FOut) using the :meth:`Save()` function. +* Flush your *TFOut* object. This flushes the write buffer for the stream, meaning that it has been cleared of the contents of our table and it can be used again for further saving operations. + +Once we’ve saved a :class:`TTable` object to binary format, we can also load :class:`TTable` objects from their binary format as follows: + + >>> context = snap.TTableContext() + >>> outfile = "/path/to/grade_table.bin" + >>> FIn = snap.TFIn(outfile) + >>> table = snap.TTable.Load(FIn, context) + +Again, the four steps of loading a :class:`TTable` from binary format are: + +* Create a Context object for the :class:`TTable`. This is necessary when loading a :class:`TTable` that has been stored in binary format. +* Provide the pathname where the binary file currently resides. +* Create an *TFIn* object with the pathname to the binary file. The SNAP *FIn* object is used to read the contents of a binary file and parse it back into a more complex data structure. It takes the pathname as a parameter. +* Finally, create the :class:`TTable` using the :meth:`.Load()` method, which takes two parameters: the *TFIn* object we just made, and the context that was created in Step 1. + +We’ve now covered the basics of how to create, save, and load :class:`TTable` objects! + +Columnwise :class:`TTable` Operations +===================================== + +Now that we know how to create a :class:`TTable`, let’s investigate different column operations that are supported by :class:`TTable` objects. These column operations allow us to take two or more columns and create a new column via some operation. These include addition, subtraction, multiplication, division, modulo division, maximum, minimum, and concatenation. They are united by their function names, which are all of the form *.ColFunc()*, where Func is the operation name. There is also one more advanced function, :meth:`AggregateCols()`, that allows us to do other operations like count, first, last, mean, and median. + +Let’s do an example by taking our table from above and performing some basic operations. Here is the original for reference: + + +.. table:: Student Grades + :widths: 15 10 10 10 + + ========== ========== ========== ========== + StudentID Midterm1 Midterm2 Final + ========== ========== ========== ========== + 101 79 86 88 + 102 84 80 79 + 103 56 76 80 + 104 90 92 96 + 105 92 85 87 + 106 87 95 92 + 107 94 90 91 + 108 76 88 81 + ========== ========== ========== ========== + + +Let’s say we wanted to know the total number of points that each student earned across the two midterms. To do this, we want to use the :meth:`ColAdd()` function, which looks like `table.ColAdd(Attr1, Attr2, NewColName`. + +In the :meth:`ColAdd()` function, we provide three parameters: the first two are the columns we want to add together, using their string names, and the third is the name of the column we want to create that will hold the sums of the first two columns. This is true for all ColFunc() functions. Since we want to get the sum over the midterm scores, we will add together Midterm1 and Midterm2:: + + >>> grade_table.ColAdd("Midterm1", "Midterm2", "MidScoreSum") + +Which yields: + + +.. table:: Student Grades + :widths: 15 10 10 10 10 + + ========== ========== ========== ========== ========== + StudentID Midterm1 Midterm2 Final MidScoreSum + ========== ========== ========== ========== ========== + 101 79 86 88 165 + 102 84 80 79 164 + 103 56 76 80 132 + 104 90 92 96 182 + 105 92 85 87 177 + 106 87 95 92 182 + 107 94 90 91 184 + 108 76 88 81 164 + ========== ========== ========== ========== ========== + +Let’s say now that we wanted a column that gave the average of the midterm scores. In this case, we’d use the :meth:`AggregateCols()` method to create a new column with the mean of the midterm columns, row by row. The :meth:`AggregateCols()` has parameters `table.AggregateCols(AggAttrs, AggOp, NewColName` where *AggAttrs* is the list of columns you’re working with (it can be more than two), and *AggOp* is the operation you want to perform from the options: aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, aaMedian. We’ll choose aaMean for our purposes here. Last, you’ll again provide the string name of the new column you’d like to create! + +Here is the code for getting the mean over the midterm scores:: + + >>> AggAttrs = snap.TStrV() + >>> AggAttrs.Add("Midterm1") + >>> AggAttrs.Add("Midterm2") + >>> grade_table.AggregateCols(AggAttrs, snap.aaMean, "MidtermMean") + +With the result: + + +.. table:: Student Grades + :widths: 15 10 10 10 10 10 + + ========== ========== ========== ========== =========== ========== + StudentID Midterm1 Midterm2 Final MidScoreSum MidtermMean + ========== ========== ========== ========== =========== ========== + 101 79 86 88 165 82.5 + 102 84 80 79 164 82 + 103 56 76 80 132 66 + 104 90 92 96 182 91 + 105 92 85 87 177 88.5 + 106 87 95 92 182 91 + 107 94 90 91 184 92 + 108 76 88 81 164 82 + ========== ========== ========== ========== =========== ========== + +A similar methodology can be used for all of the column operation functions for :class:`TTable` objects. + +One important feature of this function group is: If the third parameter passed is an empty string, i.e.:: + + >>> table.ColDiv("Col1", "Col2", "") + +then the results will overwrite the values in the column of the first parameter. In this case, the results of dividing *Col1* values by *Col2* values would replace the values in Col1. + +Rowwise Table Operations +======================== + +The operations shown above focused on creating new data from some combination of two pre-existing columns. Now, we’ll look at operations that summarize or elucidate information about the table: namely, the Group(), Aggregate(), AggregateCols(), Select(), and Unique() functions. These methods affect the table in different ways. Here, we will describe the use cases of the most important features. + +First, we will investigate the :meth:`Select()` function family, which consists of :meth:`SelectAtomicIntConst()`, :meth:`SelectAtomicFltConst()`, :meth:`SelectAtomicStrConst()`, :meth:`SelectAtomic()`, and :meth:`Select()`. You will usually use the first four, as :meth:`Select()` is utilized for complex, layered selecting parameters. + +First, let’s look at :meth:`SelectAtomic***Const()` functions, which allows you to select rows based on their value in a single column. For example, perhaps you want to select students who had final scores of 90 or above. Here are the general parameters of :meth:`SelectAtomic***Const()` (insert Int, Flt, or Str depending on the type): `table.SelectAtomicIntConst(Column, Val, Cmp, SelectedTable`. + +*Column* is the column we want to select on. This would be final scores in the example above. *Val* is the value we want to compare to, which is 90 in the example above. *Cmp* is the comparator we want to use, with choices of less then (LT), less than or equal to (LTE), equal to (EQ), not equal to (NEQ), greater than or equal to (GTE), greater than (GT), substring of (SUBSTR), or superstring of (SUPERSTR). In the example above, we want to use greater than or equal to (GTE). Finally, we need to provide a *SelectedTable*, the table that we want add the selected rows to. Generally, using a new blank table is the right option. + +Here’s the code to select only rows where the final score is greater than or equal to 90. Let’s assume we’ve greater a new blank :class:`TTable` called 'above_90_table':: + + >>> grade_table.SelectAtomicIntConst("Final", 90, snap.GTE, above_90_table) + +Let’s now look at the :meth:`Group()` and :meth:`Unique()` functions. The :meth:`Group()` function allows us to create a new column to label each column according to shared attributes by using `Group(GroupByAttrs, GroupAttrName, Ordered=True`. +Let’s now look at the :meth:`Group()` and :meth:`Unique()` functions. The :meth:`Group()` function allows us to create a new column to label each column according to shared attributes by using `Group(GroupByAttrs, GroupAttrName, Ordered=True`. + +Here, *GroupByAttrs* are the columns we want to group with respect to, where their values are the same. *GroupAttrName* will be the name of the new column with the labels. Let’s say we wanted to group students by their midterm mean score. As we can see above, two students scored an average 91, and two students scored an average 82, so we will see some groups developed. Let’s write the code for this operation: + + >>> groupAttrs = snap.TStrV() + >>> groupAttrs.Add("MidtermMean") + >>> table.Group(groupAttrs, "MeanGroups", snap.TBool(True)) + +Which yields: + +.. table:: Student Grades + :widths: 15 10 10 10 10 10 10 + + ========== ========== ========== ========== =========== =========== ========== + StudentID Midterm1 Midterm2 Final MidScoreSum MidtermMean MeanGroups + ========== ========== ========== ========== =========== =========== ========== + 101 79 86 88 165 82.5 0 + 102 84 80 79 164 82 1 + 103 56 76 80 132 66 2 + 104 90 92 96 182 91 3 + 105 92 85 87 177 88.5 4 + 106 87 95 92 182 91 3 + 107 94 90 91 184 92 5 + 108 76 88 81 164 82 1 + ========== ========== ========== ========== =========== =========== ========== + +Another related method is :meth:`Unique()`. Rather than assigning the same labels to rows with similar values, any rows with the same sought-after values will be deleted so there are no remaining duplicates, using the paramaters :meth:`Unique(Attrs, Ordered=True)`. +Here, Attrs is simply the attributes that need to be equal in order for us to consider them duplicates. + +Let’s try this on the original table, and instead of grouping by the midterm mean, we’ll use :meth:`Unique()` to keep only students with a unique midterm mean score:: + + >>> attrs = snap.TStrV() + >>> attrs.Add("MidtermMean", snap.TBool(True)) + >>> table.Unique(attrs) + +Which would instead yield: + +.. table:: Student Grades + :widths: 15 10 10 10 10 10 + + ========== ========== ========== ========== =========== ========== + StudentID Midterm1 Midterm2 Final MidScoreSum MidtermMean + ========== ========== ========== ========== =========== ========== + 101 79 86 88 165 82.5 + 102 84 80 79 164 82 + 103 56 76 80 132 66 + 104 90 92 96 182 91 + 105 92 85 87 177 88.5 + ========== ========== ========== ========== =========== ========== + +Students 106 and 108 have been removed because they had the same midterm mean score as students before them. Remember that Unique() goes from top to bottom row, so earlier rows will be preserved. + +Now, let’s investigate the :meth:`Aggregate()` method, which allows us to aggregate statistics for each row based on values in certain columns. For example, we might want to add a column telling us how many instances of the AuthorID in each row exist in the dataset. :meth:`Aggregate()` is invoked using parameters `Aggregate(GroupByAttrs, AggOp, ValAttr, ResAttr, Ordered=True`. + +The Aggregate method takes: + +* *GroupByAttrs*: The attributes (columns) that you want to aggregate with respect to. This will need to be a vector of strings that you create in advance. +* *AggOp*: The operation you want to aggregate by: options are aaSum, aaCount, aaMin, aaMax, aaFirst, aaLast, aaMean, or aaMedian. +* *ValAttr*: Which attribute (column) we want to aggregate over. +* *ResAttr*: The name of the column where the result of the aggregation will be stored. +* *Ordered*: Whether to treat grouping keys as ordered or unordered. + +To make all this more concrete, let’s say we wanted to find the maximum final score over all students based on a particular mean midterm score. That is, for students with the same midterm score, we will add a value to their row indicating the highest final score achieved by someone with their same score. Here’s how we would use Aggregate() to do so:: + + >>> GroupBy = snap.TStrV() + >>> GroupBy.Add("MidtermMean") + >>> PapAuthT.Aggregate(GroupBy, snap.aaMax, "Final", "MaxFinal", snap.TBool(False)) + +Here, we use a variable *GroupBy* to hold a vector of strings representing the columns we want to group with respect to, that is, the MidtermMean column. We then use :meth:`Aggregate()` with the snap.aaCount function to count the number of times each mean appears in the dataset, and store the count in a new column called MeanCount. Here is what the result will look like: + +.. table:: Student Grades + :widths: 15 10 10 10 10 10 10 + + ========== ========== ========== ========== =========== =========== =========== + StudentID Midterm1 Midterm2 Final MidScoreSum MidtermMean MaxFinal + ========== ========== ========== ========== =========== =========== =========== + 101 79 86 88 165 82.5 88 + 102 84 80 79 164 82 81 + 103 56 76 80 132 66 80 + 104 90 92 96 182 91 96 + 105 92 85 87 177 88.5 87 + 106 87 95 92 182 91 96 + 107 94 90 91 184 92 91 + 108 76 88 81 164 82 81 + ========== ========== ========== ========== =========== =========== =========== + +As you can see, the MaxFinal values indicate the highest final score value for students with the same midterm mean. Notably, we see that students 102 and 108 have the same value, because they have the same midterm score, and their value is the maximum of either of their final scores (81 being higher than 79). The same occurred for students 104 and 106. + +Two Table Operations +==================== + +Some SNAP :class:`TTable` operations help us to combine two different tables into a single table according to various rules. These functions include Intersection, Union, Join, and Minus. They work as follows: + +* :meth:`Intersection()`: creates a new table from all rows that appear in both original tables. Returns a new table. +* :meth:`Union()`: creates a new table from all rows that appear in either original table. Returns a new table. *UnionAll* has a similar function, but retains duplicates of rows across the tables. +* :meth:`Minus()`: creates a new table from all rows in the first table not present in the second table. Returns a new table. +* :meth:`Join()`: a more customizable function, Join equi-joins two tables based on one attribute in the first table. Columns from the second table will be added to the first where the value of the desired attribute in the first table matches the value of the desired attribute in the second. Does not return a new table, but rather updates the original table with columns from the second table. +* :meth:`SimJoin()`: a function that performs an equi-join if the distance between two rows is less than the specified threshold. + +Let’s go back to our original grade table with four columns: StudentID, Midterm1, Midterm2, and Final. Let’s say we have another table that lists the student IDs of these students, plus a column with their names: + +.. table:: Student Names + :widths: 15 40 + + ========= ========== + ID Name + ========= ========== + 101 Will + 102 Amira + 103 Todd + 104 Yang + 105 Cathy + 106 Shubash + 107 Nicolo + 108 Maria + ========= ========== + +Let’s say we want to incorporate the Name column into our original table. We can do this using the :meth:`Join()` function, with parameters `Join(Attr1, PTable, Attr2`. + +Here, *Attr1* is the column we want to join on from the first table, *PTable* is the second table we want to join with, and *Attr2* is the column we want to join on from the second table. + +To combine our two tables, we would use:: + + >>> combined_table = grade_table.Join("StudentID", name_table, "ID") + +Which will create a new table called ‘combined_table’ as so: + +.. table:: Student Grades + :widths: 15 10 10 10 10 + + ========== ========== ========== ========== ========== + StudentID Midterm1 Midterm2 Final Name + ========== ========== ========== ========== ========== + 101 79 86 88 Will + 102 84 80 79 Amira + 103 56 76 80 Todd + 104 90 92 96 Yang + 105 92 85 87 Cathy + 106 87 95 92 Shubash + 107 94 90 91 Nicolo + 108 76 88 81 Maria + ========== ========== ========== ========== ========== + +Getting Information from Tables +=============================== + +SNAP has many functions to get information from :class:`TTable` objects, in the form of vectors or basic data types. Some of the most useful get functions include: + +* :meth:`GetNumRows()` +* :meth:`GetSchema()` +* :meth:`GetIntVal()`, :meth:`GetFltVal()`, and :meth:`GetStrVal()` +* :meth:`GetIntValAtRowIdx()`, :meth:`GetFltValAtRowIdx()`, and :meth:`GetStrValAtRowIdx()` +* :meth:`ReadIntCol()`, :meth:`ReadFltCol()`, and :meth:`ReadStrCol()` + +These functions are relatively straightforward, and will assist with obtaining pieces of information and summary statistics from the :class:`TTable`. The *Val* functions return single values, and the *Col* functions return vectors of entire column values. + diff --git a/snap-python/source/doc/source/tutorial/tutorial.rst b/snap-python/source/doc/source/tutorial/tutorial.rst new file mode 100644 index 0000000000000000000000000000000000000000..f02b60e6f890083ee1c61f893e84169eb65d0d2e --- /dev/null +++ b/snap-python/source/doc/source/tutorial/tutorial.rst @@ -0,0 +1,425 @@ +Introduction +```````````` + +This document is a quick tutorial to key Snap.py functionality. + +Snap.py is a Python interface for SNAP. SNAP is a general purpose, +high performance system for analysis and manipulation of large networks. +SNAP is written in C++ and optimized for maximum performance and +compact graph representation. It easily scales to massive networks +with hundreds of millions of nodes, and billions of edges. + +Snap.py provides performance benefits of SNAP, combined with flexibility +of Python.Since Snap.py is mostly just a direct interface to SNAP C++ +implementation, most of the SNAP functionality is available via Snap.py +in Python. There is a direct correspondence between the SNAP functions +and Snap.py functions. SNAP documentation is available here: +http://snap.stanford.edu/snap/doc/snapdev-ref/. + + +To use Snap.py in Python, import the **snap** module: + +>>> import snap + +The code in this document assumes that Snap.py has been imported as shown above. + + +Basic Types +``````````` + +Basic types in SNAP are :class:`TInt`, :class:`TFlt`, and :class:`TStr`. +In Snap.py, these types are converted to Python types +:class:`int`, :class:`float`, and :class:`str`, respectively. In general, +there is no need to explicitly work with SNAP types in Snap.py, since +Snap.py automatically converts these basic types to Python types. + +.. note:: + + Do not use an empty string literal `""` in Python, if a Snap.py + function parameter is of type :class:`TStr`. SNAP handling of `TStr("")` + is not compatible with Python, so an empty string literal will cause + an error. + +Vector Types +```````````` + +Vectors are sequences of values of the same type. Existing vector values can be accessed or changed by their index in the sequence. New values can be added at the end of a vector. + +Vector types in Snap.py and SNAP use a naming convention of being named as ``, followed by `V`. For example, a vector of integers is named :class:`TIntV`. + +Below are the most commonly used vector operations: + +- create an empty vector of integers + + >>> v = snap.TIntV() + +- add a value at the end of a vector. 5 values are added below in positions 0..4: + + >>> v.append(1) + >>> v.append(2) + >>> v.append(3) + >>> v.append(4) + >>> v.append(5) + +- get the number of values in the vector: + + >>> print(len(v)) + 5 + +- get a value at a specific vector location + + >>> print("v[2] =", v[2]) + v[2] = 3 + +- change a value at a specific vector location + + >>> v[2] = 6 + >>> print("v[2] =", v[2]) + v[2] = 6 + +- print all values in a vector using an iterator + + >>> for item in v: + >>> print(item) + 1 + 2 + 6 + 4 + 5 + +- print all values in a vector using an index + + >>> for i in range(0, len(v)): + >>> print(i, v[i]) + 0 1 + 1 2 + 2 6 + 3 4 + 4 5 + +.. seealso:: + + SNAP C++ documentation has a complete list of vector methods. Search for :class:`TVec` in: http://snap.stanford.edu/snap/doc/snapdev-ref/. + + +Hash Table Types +```````````````` + +Hash tables contain values of the same type. Each value has a user provided key associated with it. All the keys are of the same type. + +Table values can be accessed or changed either their keys. New values can be added as `(key, value)` pairs. + +Hash table types in Snap.py and SNAP use a naming convention of being named as ``, followed by `H`. For example, a hash table with integer key and string values is named :class:`TIntStrH`. If `` and `` have the same type, only one type name might be used, such as :class:`TIntH`. + +Below are the most commonly used hash table operations: + +- create an empty hash table with integer keys and string values + + >>> h = snap.TIntStrH() + +- add a value to the table. 5 values are added below: + + >>> h[5] = "apple" + >>> h[3] = "orange" + >>> h[9] = "plum" + >>> h[6] = "mango" + >>> h[1] = "banana" + +- get the number of values in the table: + + >>> print(len(h)) + 5 + +- get a value for a specific key + + >>> print("h[3] =", h[3]) + h[3] = orange + +- change a value at a specific key + + >>> h[3] = "apricot" + >>> print("h[3] =", h[3]) + h[3] = apricot + +- print all values in a table using an iterator + + >>> for key in h: + >>> print(key, h[key]) + 5 apple + 3 apricot + 9 plum + 6 mango + 1 banana + +.. seealso:: + + SNAP C++ documentation has a complete list of hash table methods. Search for :class:`THash` in: http://snap.stanford.edu/snap/doc/snapdev-ref/. + +Pair Types +`````````` +Pairs contain two values. Each value has its own type. + +Pair types in Snap.py and SNAP use a naming convention of being named as ``, followed by `Pr`. For example, a pair of (integer, string) is named :class:`TIntStrPr`. If `` and `` have the same type, only one type name might be used, such as :class:`TIntPr`. + +Below are the most commonly used pair operations: + +- create a pair of an integer and a string: + + >>> p = snap.TIntStrPr(1, "one") + +- print the first value: + + >>> print(p.GetVal1()) + 1 + +- print the second value: + + >>> print(p.GetVal2()) + one + +.. seealso:: + + SNAP C++ documentation has a complete list of pair methods. Search for :class:`TPair` in: http://snap.stanford.edu/snap/doc/snapdev-ref/. + + +SNAP Types in Snap.py +````````````````````` + +The following is a list of SNAP types that are used in Snap.py functions: + +- :class:`TNGraph`, a directed graph; +- :class:`TUNGraph`, an undirected graph; +- :class:`TNEANet`, a directed network; +- :class:`TGraph`, one of :class:`TNGraph`, :class:`TUNGraph`, or :class:`TNEANet`; +- :class:`TCnComV`, a vector of connected components; +- :class:`TFltPrV`, a vector of float pairs; +- :class:`TFltV`, a vector of floats; +- :class:`TGVizLayout`, one of `gvlDot`, `gvlNeato`, `gvlTwopi`, `gvlCirco`, `gvlSfdp`; +- :class:`TIntFltH`, a hash table with integer keys and float values; +- :class:`TIntFltKdV`, a vector of (integer, float) values; +- :class:`TIntH`, a hash table with integer keys and values; +- :class:`TIntPrFltH`, a hash table with (integer, integer) pair keys and float values; +- :class:`TIntPrV`, a vector of (integer, integer) pairs; +- :class:`TIntSet`, a hash table with integer keys and no values; +- :class:`TIntStrH`, a hash table with integer keys and string values; +- :class:`TIntTrV`, a vector of (integer, integer, integer) triplets; +- :class:`TIntV`, a vector of integers; +- :class:`TRnd`, a random generator; +- :class:`TStrHash< TInt >`, a hash table woth string keys and integer values; +- :class:`TVec< TFltV >`, a vector of vectors of floats. + +.. seealso:: + + SNAP C++ documentation has more details on the types above. Search for :class:`` in: http://snap.stanford.edu/snap/doc/snapdev-ref/. + + + +Graph and Network Types +``````````````````````` + +Snap.py supports *graphs* and *networks*. Graphs describe topologies, +where nodes have unique integer ids and directed/undirected/multiple edges +connect the nodes of the graph. +Networks are graphs with data on nodes and/or edges of the network. +Data types that reside on nodes and edges are simply passed as template +parameters which provides a very fast and convenient way to implement +various kinds of networks with rich data on nodes and edges. + +Graph classes in SNAP: + +* :class:`TUNGraph`: undirected graphs (single edge between an unordered pair of nodes) +* :class:`TNGraph`: directed graphs (single directed edge between an ordered pair of nodes) + +Network classes in SNAP: + +* :class:`TNEANet`: directed multigraphs (multiple directed edges between an ordered pair of nodes) with attributes for nodes and edges + +.. seealso:: + + SNAP C++ documentation has a complete list of graph and network methods. Search for :class:`TUNGraph`, :class:`TNGraph`, or :class:`TNEANet` in: http://snap.stanford.edu/snap/doc/snapdev-ref/. + +Snap.py does not directly use instances of the graph and network classes, +but utilizes smart pointers to those instances instead. The actual +instances in the Python program are of type :class:`PUNGraph`, +:class:`PNGraph`, or :class:`PNEANet` and correspond to :class:`TUNGraph`, +:class:`TNGraph`, and :class:`TNEANet`, respectively. +You can read more about smart pointers here: +http://snap.stanford.edu/snap/doc/snapdev-guide/#Smart_Pointers. + +Graph Creation +`````````````` + +Graphs are created with the :meth:`New()` method. +Examples of how to create graphs and networks: + +>>> G1 = snap.TUNGraph.New() +>>> G2 = snap.TNGraph.New() +>>> N1 = snap.TNEANet.New() + + +Adding Nodes and Edges +`````````````````````` + +Nodes are added with the :meth:`AddNode()` method. + +>>> G1.AddNode(1) +>>> G1.AddNode(5) +>>> G1.AddNode(32) + +Nodes have unique integer node ids. +There is no restriction for node ids to be contiguous integers starting at 0. + +Edges are added with the :meth:`AddEdge()` method. + +>>> G1.AddEdge(1,5) +>>> G1.AddEdge(5,1) +>>> G1.AddEdge(5,32) + +In TUNGraph and TNGraph edges have no explicit ids -- edges are identified by a pair of node ids. + + +Traversing Nodes and Edges +`````````````````````````` + +Nodes and edges are traversed with iterators. Some examples of iterator usage in Snap.py are shown below. + +Create a directed random graph on 100 nodes and 1000 edges: + +>>> G2 = snap.GenRndGnm(snap.TNGraph, 100, 1000) + +Traverse all the nodes using a node iterator: + +>>> for NI in G2.Nodes(): +>>> print("node: %d, out-degree %d, in-degree %d" % ( NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) + +Traverse all the edges using an edge iterator: + +>>> for EI in G2.Edges(): +>>> print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + +Traverse the edges by traversing nodes and getting all their neighbors: + +>>> for NI in G2.Nodes(): +>>> for Id in NI.GetOutEdges(): +>>> print("edge (%d %d)" % (NI.GetId(), Id)) + +Node iterators provide several useful methods: + +* GetId(): returns node id +* GetOutDeg(): returns out-degree of a node +* GetInDeg(): returns in-degree of a node +* GetOutNId(e): returns node id of the endpoint of e-th out-edge +* GetInNId(e): returns node id of the endpoint of e-th in-edge +* IsOutNId(n): tests if there is an out-edge to node n +* IsInNId(n): tests if there is an in-edge from node n +* IsNbrNId(n): tests if node n is a neighbor + +Saving and Loading Graphs +````````````````````````` + +With Snap.py, it is easy to save and load networks in various formats. +Internally, SNAP saves networks in a compact binary format, but functions for loading and saving networks in various other text and XML formats are also available (see gio.h). + +Snap.py code for saving and loading graphs looks as follows. + +Create a directed random graph on 100 nodes and 1000 edges: + +>>> G2 = snap.GenRndGnm(snap.TNGraph, 100, 1000) + +Save the graph in a binary format: + +>>> FOut = snap.TFOut("test.graph") +>>> G2.Save(FOut) +>>> FOut.Flush() + +Load the graph in a binary format: + +>>> FIn = snap.TFIn("test.graph") +>>> G4 = snap.TNGraph.Load(FIn) + +Save the graph to a text file: + +>>> G4.SaveEdgeList("test.txt", "Save as tab-separated list of edges") + +Load the graph from a text file: + +>>> G5 = snap.LoadEdgeList(snap.TNGraph, "test.txt", 0, 1) + +Graph Manipulation +`````````````````` + +Snap.py provides rich functionality to efficiently manipulate graphs and networks. Most functions support all graph and network types. Below are a few examples of graph operations. + +Generate a random Erdos-Renyi directed graph on 10000 nodes and with 5000 edges: + +>>> G6 = snap.GenRndGnm(snap.TNGraph, 10000, 5000) + +Convert a directed graph to an undirected graph: + +>>> G7 = G6.ConvertGraph(snap.TUNGraph) + +Get the largest weakly connected component: + +>>> WccG = G6.GetMxWcc() + +Generate a network using Forest Fire model: + +>>> G8 = snap.GenForestFire(1000, 0.35, 0.35) + +Get a subgraph induced on nodes {0,1,2,3,4}: + +>>> SubG = G8.GetSubGraph([0,1,2,3,4]) + +Get 3-core of G: + +>>> Core3 = G8.GetKCore(3) + +Delete nodes of out-degree 3 and in-degree 2: + +>>> G8.DelDegKNodes(3, 2) + +Computing Structural Properties +``````````````````````````````` + +Snap.py provides rich functionality to efficiently compute structural properties of networks. Most functions support all graph and network types. + +Generate a random Erdos-Renyi directed graph on 10000 nodes and with 1000 edges: + +>>> G9 = snap.GenRndGnm(snap.TNGraph, 10000, 1000) + +Define a vector of pairs of integers (size, count) and get a distribution of connected components (component size, count): + +>>> CntV = G9.GetWccSzCnt() +>>> for p in CntV: +>>> print("size %d: count %d" % (p.GetVal1(), p.GetVal2())) + +Get degree distribution pairs (out-degree, count): + +>>> CntV = G9.GetOutDegCnt() +>>> for p in CntV: +>>> print("degree %d: count %d" % (p.GetVal1(), p.GetVal2())) + +Generate a Preferential Attachment graph on 100 nodes and out-degree of 3: + +>>> G10 = snap.GenPrefAttach(100, 3) + +Define a vector of floats and get first eigenvector of graph adjacency matrix: + +>>> EigV = G10.GetLeadEigVec() +>>> nr = 0 +>>> for f in EigV: +>>> nr += 1 +>>> print("%d: %.6f" % (nr, f)) + +Get an approximation of graph diameter: + +>>> diam = G10.GetBfsFullDiam(10) + +Count the number of triads: + +>>> triads = G10.GetTriads() + +Get the clustering coefficient: + +>>> cf = G10.GetClustCf() + diff --git a/snap-python/source/doc/todo.txt b/snap-python/source/doc/todo.txt new file mode 100644 index 0000000000000000000000000000000000000000..99e83ba00fdede4ce47106bb9d09019ef4a7e5c7 --- /dev/null +++ b/snap-python/source/doc/todo.txt @@ -0,0 +1,19 @@ +Proposed Features +Nov 17, 2021 + +- Provide support for centrality calculations for weighted graphs in Python + +- Remove AddNode(NodeI) from the reference text + +- Convenience methods for graph density and for reversing a directed graph + (I took a look at the C++ version manual and they don't exist there either) + +- A python egg to be able to install the module locally (like with + easy_install --user with pypi packages) + +- Build a graph from numpy edge list + +- Support cmake build system + +- Implement a method in TNEANet to return a list of edges between two nodes + diff --git a/snap-python/source/docker/Dockerfile b/snap-python/source/docker/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..8da9a6a7ec5b49fee51488182b06fd596d504143 --- /dev/null +++ b/snap-python/source/docker/Dockerfile @@ -0,0 +1,4 @@ +FROM python:3.7.5-buster +COPY . /app +WORKDIR /app +RUN pip install -r requirements.txt --no-cache-dir diff --git a/snap-python/source/docker/README.md b/snap-python/source/docker/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f1956ea5f7c4725ac9df8e6e9a3b875b9f465025 --- /dev/null +++ b/snap-python/source/docker/README.md @@ -0,0 +1,237 @@ +# Snap-Python Docker +Creates a lightweight Docker compute stack for performing network graph analysis using snap-python, numpy, and matplotlib agnostic of the host operating system. + +This document stipulates installation requirements for the Docker Community Edition (CE), and walks through Docker installation, building, and running the snap-python Docker image. + +## OS Requirements + +Basic operating system requirements for running the Docker Engine - Community. See more at: [https://docs.docker.com/install/](https://docs.docker.com/install/). + +### Linux + +* **CentOS** + * A maintained version of CentOS 7 is required for Docker Engine - Community +* **Debian** + * To install Docker Engine - Community, you need the 64-bit version of one of these Debian or Raspbian versions: + * Buster 10 + * Stretch 9 (stable) / Raspbian Stretch +* **Fedora** + * To install Docker Engine - Community, you need the 64-bit version of one of these Fedora versions: + * 28 + * 29 +* **Ubuntu** + * To install Docker Engine - Community, you need the 64-bit version of one of these Ubuntu versions: + * Disco 19.04 + * Cosmic 18.10 + * Bionic 18.04 (LTS) + * Xenial 16.04 (LTS) + +### macOS +Your macOS hardware must meet the following requirements to install Docker Desktop. See more at: [https://docs.docker.com/docker-for-mac/install/](https://docs.docker.com/docker-for-mac/install/). + +* Mac hardware must be a 2010 or newer model, with Intel’s hardware support for memory management unit (MMU) virtualization, including Extended Page Tables (EPT) and Unrestricted Mode. You can check to see if your machine has this support by running the following command in a terminal: sysctl kern.hv_support + +* macOS must be version 10.13 or newer. We recommend upgrading to the latest version of macOS. + +* If you experience any issues after upgrading your macOS to version 10.15, you must install the latest version of Docker Desktop to be compatible with this version of macOS. + +* Note: Docker supports Docker Desktop on the most recent versions of macOS. That is, the current release of macOS and the previous two releases. As new major versions of macOS are made generally available, Docker will stop supporting the oldest version and support the newest version of macOS (in addition to the previous two releases). + +* At least 4 GB of RAM. + +* VirtualBox prior to version 4.3.30 must not be installed as it is not compatible with Docker Desktop. + +### Windows +System requirements: + +* Windows 10 64-bit: Pro, Enterprise, or Education (Build 15063 or later). +Hyper-V and Containers Windows features must be enabled. + +* The following hardware prerequisites are required to successfully run Client Hyper-V on Windows 10: + * 64 bit processor with [Second Level Address Translation (SLAT)](http://en.wikipedia.org/wiki/Second_Level_Address_Translation) + * 4GB system RAM + * BIOS-level hardware virtualization support must be enabled in the BIOS settings. For more information, see [Virtualization](https://docs.docker.com/docker-for-windows/troubleshoot/#virtualization-must-be-enabled) + +## Docker Installation + +Note that installation steps outlined below for Linux are purposefully only defined for Ubuntu. Installation of Docker for other Linux distributions is left as an exercise to the reader. These instructions outline installation from the Docker repository (the recommended approach), and are a subset of the instructions available at [https://docs.docker.com/install/](https://docs.docker.com/install/). + +#### Linux (Ubuntu) + +1. Begin by updating all packages: + + ``` + $ sudo apt-get update + ``` + +2. It is recommended to uninstall any old Docker software before proceeding (note that this command accounts for old versions of Docker, which were named "docker", "docker.io", etc.): + + ``` + $ sudo apt-get remove docker docker-engine docker.io containerd runc + ``` + +3. Set up the Docker repository to install from: + + ``` + $ sudo apt-get install \ + apt-transport-https \ + ca-certificates \ + curl \ + gnupg-agent \ + software-properties-common + ``` +4. Add Docker's official GPG key: + + ``` + $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - + ``` + +5. Verify that you have the key with the fingerprint `9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88` by searching for the last 8 characters of the fingerprint: + + ``` + $ sudo apt-key fingerprint 0EBFCD88 + + pub rsa4096 2017-02-22 [SCEA] + 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 + uid [ unknown] Docker Release (CE deb) + sub rsa4096 2017-02-22 [S] + ``` + +6. Use the following command to setup the **stable** repository: + + ``` + $ sudo add-apt-repository \ + "deb [arch=amd64] https://download.docker.com/linux/ubuntu \ + $(lsb_release -cs) \ + stable" + ``` + +7. Install the latest version of Docker Engine - Community and containerd: + + ``` + $ sudo apt-get install docker-ce docker-ce-cli containerd.io + ``` + +8. Verify that Docker Engine - Community is correctly installed by running the `hello-world` image: + + ``` + $ sudo docker run hello-world + ``` + +#### macOS +To download Docker Desktop for macOS, go to [Docker Hub](https://hub.docker.com/?overlay=onboarding) and sign in with your DockerID. You will require a Docker Hub account. See more at [https://docs.docker.com/docker-for-mac/install/](https://docs.docker.com/docker-for-mac/install/). + +1. Download the Docker Desktop installer for macOS from the link above +2. Double-click the Docker.dmg to open the installer, then drag the Docker icon to the Applications folder +3. Double-click Docker.app in the Applications folder to start Docker +4. Verify the Docker daemon is running by running the `hello-world` image: + + ``` + $ docker run hello-world + ``` + +#### Windows +To download Docker Desktop for Windows, go to [Docker Hub](https://hub.docker.com/?overlay=onboarding) and sign in with your DockerID. You will require a Docker Hub account. See more at [https://docs.docker.com/docker-for-windows/install/](https://docs.docker.com/docker-for-windows/install/). + +1. Download the Docker Desktop installer for Windows from the link above +2. Double click the **Docker Desktop Installer.exe** to run the installer +3. Follow the instructions on the installation wizard to accept the license, authorize the installer, and proceed with the install + * **Note:** When prompted, authorize the Docker Desktop Installer with your system password during the install process. Privileged access is needed to install networking components, links to the Docker apps, and manage the Hyper-V VMs +4. Click **Finish** on the setup complete dialog and launch the Docker Desktop application. +5. Verify the Docker daemon is running by running the `hello-world` image: + + ``` + $ docker run hello-world + ``` + +## Building the snap-python Docker image +Once Docker is installed on your host, we can build the `snap-python` Docker image. The Docker image is a lightweight read-only template used to build containers, which are running "jailed" processes. We can build the `snap-python` image in one of two ways: + +1. We can install directly from the hosted official image on Docker Hub (recommended): + * ```$ docker pull cam2337/snap-python:latest``` + + +2. Alternatively, if you've cloned this repository (see installation instructions in the top-level `README.md`), we can build the Docker image directly from the `Dockerfile` in `/docker/`: + * ```$ docker build . -t snap-python``` + +## Running a snap-python Docker container +We can verify that the `snap-python` image is installed by issuing the following command: + +``` +$ ctew-macbookpro:examples ctew$ docker images +REPOSITORY TAG IMAGE ID CREATED SIZE +cam2337/snap-python latest e2229d02c39e 46 minutes ago 1.09GB +``` + +As we see from the example above, this image was downloaded and built from the official image as hosted on Docker Hub. + +Now that the image is built, all we need to do is run a snap-python container: + +``` +$ docker run -it cam2337/snap-python +Python 3.7.5 (default, Nov 23 2019, 05:59:34) +[GCC 8.3.0] on linux +Type "help", "copyright", "credits" or "license" for more information. +>>> import snap +>>> snap.Version +'5.0.0' +``` + +While an interactive Python shell with `snap-python` capabilities is great, we can go one step further and specify a working directory for a python application that relies on snap. This directory can be mounted as [volume](https://docs.docker.com/storage/volumes/) in the snap-python Docker container. The scripts then have full access to the `snap-python` module that was baked into our image: + +``` +docker run -it --rm -v "":/usr/src/snap -w /usr/src/snap cam2337/snap-python python / +``` + +Let's individually cover some of the more interesting components of this command: + +* `-it`: This tells Docker that we want to run the container interactively, by keeping STDIN open even if not attached. It additionally allocates a pseudo-TTY +* `--rm`: Instructs Docker to automatically remove the container once it exits. Since our Docker container is functioning as a "compute stack" (instead of, say, a server or backend), this is desirable, as there's no need for a container to be hanging around after we've run our application. +* `-v`: Instructs Docker to mount the following local filesystem directory at `/usr/src/snap` +* `-w`: Instructs Docker that its working directory should be the newly-mounted volume at `/usr/src/snap` +* `cam2337/snap-python`: The image we want to run +* `python`: The command we want to issue once our container is started +* `/`: The python file from our local filesystem to run in the `snap-python` container + + +## Frequently Asked Questions (FAQ) + +### Q: My Python application has specific package requirements. How can I build my own custom Docker image that installs these additional packages? +You can leverage the image created by the `Dockerfile` in this directory (or hosted on [Docker Hub](https://hub.docker.com/repository/docker/cam2337/snap-python)) and build upon it in [layers](https://docs.docker.com/v17.09/engine/userguide/storagedriver/imagesandcontainers/#images-and-layers). Say, for instance, you need `pandas` installed for your Python application to work. An example Dockerfile might look like: + +``` +FROM cam2337/snap-python:latest +RUN pip install pandas +``` + +You can then build this image locally: + +``` +$ docker build -t my-custom-snap-python . +``` + +We can then run the container and verify that importing `pandas` behaves as expected: + +``` +$ ctew-macbookpro:docker ctew$ docker run -it my-custom-snap-python +Python 3.7.5 (default, Nov 23 2019, 05:59:34) +[GCC 8.3.0] on linux +Type "help", "copyright", "credits" or "license" for more information. +>>> import pandas +>>> +``` + +### Q: How can I leverage the snap-python Docker compute stack from the comfort of my favorite editor? +Most popular editors nowadays provide the option to create a custom "build system" for building/running a subset of files. In this way, they become more akin to a traditional integrated development environment (IDE). We can leverage this fact to create a custom build system for our snap-python Docker compute stack. + +For example, we can create the following custom build system in SublimeText: + +``` +{ + "shell_cmd": "docker run --rm -v $file_path:/usr/src/snap -w /usr/src/snap cam2337/snap-python python $file_name", + "selector": "source.python", + "file_regex": "^\\s*File \"(...*?)\", line ([0-9]*)" +} +``` + +Saving this as `docker-snap-python.build` in the SublimeText user build system space, we can now select it from `Tools > Build System > docker-snap-python`. Building an in-focus Python file with this option selected will now execute our snap-python Docker compute stack. \ No newline at end of file diff --git a/snap-python/source/docker/requirements.txt b/snap-python/source/docker/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..981953b3f7fb24fbc855d2411a639003155a3f28 --- /dev/null +++ b/snap-python/source/docker/requirements.txt @@ -0,0 +1,8 @@ +cycler==0.10.0 +kiwisolver==1.1.0 +matplotlib==3.1.2 +numpy==1.17.4 +pyparsing==2.4.5 +python-dateutil==2.8.1 +six==1.13.0 +snap-stanford==5.0.0 diff --git a/snap-python/source/examples/Makefile b/snap-python/source/examples/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..87437a9d2485b8981656a0e8663180819167abd6 --- /dev/null +++ b/snap-python/source/examples/Makefile @@ -0,0 +1,17 @@ +# +# Makefile for running +# + +all: + +# benchmark.py is obsolete and does not work with the latest Snap.py +# see ../test for a working version +tneanet: + python tneanet.py + +# benchmark.py is obsolete and does not work with the latest Snap.py +benchmark: + python benchmark.py + +clean: + rm -rf results *.graph diff --git a/snap-python/source/examples/benchmark.py b/snap-python/source/examples/benchmark.py new file mode 100644 index 0000000000000000000000000000000000000000..4fa1c92113bc5b2ebdd730dff16eb9022f785bd5 --- /dev/null +++ b/snap-python/source/examples/benchmark.py @@ -0,0 +1,437 @@ +#!/usr/bin/python +# benchmark.py +# +# Author: Nick Shelly, Spring 2013 +# Description: +# - Loads SNAP as a Python module. +# - Randomly generates a graph of specified size and type, and saves +# or loads the graph if it has already been created. +# - Benchmarks a number of "is this a good graph?" tests on the graph, +# calculating the amount of time required and appends to a file. +# +# usage: benchmark.py [-h] [-v] [-r RANGE] [-d] [-t GRAPH_TYPES] +# [-n NUM_ITERATIONS] [-o OUTPUT_FILE] [-g] +# +# optional arguments: +# -h, --help show this help message and exit +# -v, --verbose increase output verbosity +# -r RANGE, --range RANGE +# range (4-6) (10^4 to 10^6 nodes) +# -d, --deterministic deterministic benchmark +# -t GRAPH_TYPES, --graph_types GRAPH_TYPES +# Graph types, comma separated. Available: rand_ungraph, +# rand_ngraph, rmat, pref, sw +# -n NUM_ITERATIONS, --num_iterations NUM_ITERATIONS +# number of iterations +# -o OUTPUT_FILE, --output_file OUTPUT_FILE +# file to output results +# -g, --generate generate new graphs +# +# Examples: +# 1. Use default arguments. +# $ python menchmark.py +# 2. Generate deterministic RMAT graphs from 10^2-10^3 nodes, and +# run 3 times, outputing to results.txt. +# $ python benchmark.py -v -n 3 -g -d -r 2-3 -t rmat -o results/results.txt +# + +import os.path +import sys +import argparse +from socket import gethostname +from time import clock +from datetime import datetime + +sys.path.append("../swig") +import snap + +PROPERTY_TYPES = [1, 10] # 1=Triads, 10=BFS + +# Comma-separated, graph types: +# 'rmat' - R-MAT +# 'pref' - preferential attachment +# 'sw' - small world +# 'rand_ungraph' - random undirected +# 'rand_ngraph' - random directed +# 'rand_neanet' - random directed attribute +# 'syn_ngraph' - random directed +# 'syn_negraph' - synthetic multi-edge +# 'syn_neanet' - synthetic directed multi-edge attribute + +DEFAULT_TYPES = "rand_neanet" + +# Average is 1, non-average is 0. +DEFAULT_DEGREES = "1-2" # Default is 10x and 100x edges/node +DEFAULT_WRITE = False +SW_REWIRE_PROB = 0.1 +SYNTHETIC_DELTA = 10 + +# Exponent range (e.g. 10^x to 10^y) +DEFAULT_VERBOSE=True +DEFAULT_RANGE = '3-4' +DEFAULT_ITERATIONS = 1 + +# Hostname for results +HOSTNAME = gethostname() + +RESULTS_DIR = 'results' +DEFAULT_RESULTS_FILE = os.path.join(RESULTS_DIR, 'results%s.txt' % \ + datetime.now().strftime('%m%d-%H%M%S')) + +def benchmark_ngraph(Graph): + ''' + Perform benchmark tests for Directed Graphs + ''' + + results = {} + results['num_nodes'] = Graph.GetNodes() + results['num_edges'] = Graph.GetEdges() + + for degree in range(0, 11): + num = snap.NodesGTEDegree_PNGraph(Graph, degree) + percent_deg = float(num) / results['num_nodes'] + results['deg_gte_%d' % degree] = num + results['deg_gte_%d_percent' % degree] = percent_deg + + # Check for over-weighted nodes + results['max_degree'] = snap.GetMxDegNId(Graph) + + num = snap.NodesGTEDegree_PNGraph(Graph, results['max_degree']) + results['max_degree_num'] = num + + results['max_wcc_percent'] = snap.MxWccSz_PNGraph(Graph) \ + / results['num_nodes'] + results['max_scc_percent'] = snap.MxSccSz_PNGraph(Graph).GetNodes() \ + / results['num_nodes'] + + return results + +def benchmark_ungraph(Graph): + ''' + Perform benchmark tests for Undirected Graphs + ''' + + results = {} + results['num_nodes'] = Graph.GetNodes() + results['num_edges'] = Graph.GetEdges() + + for degree in range(0,11): + num = snap.NodesGTEDegree_PUNGraph(Graph, degree) + percent_deg = float(num) / results['num_nodes'] + results['deg_gte_%d' % degree] = num + results['deg_gte_%d_percent' % degree] = percent_deg + + # Check for over-weighted nodes + results['max_degree'] = snap.MxDegree_PUNGraph(Graph) + + num = snap.NodesGTEDegree_PUNGraph(Graph, results['max_degree']) + results['max_degree_num'] = num + results['max_wcc_percent'] = snap.MxWccSz_PUNGraph(Graph) \ + / results['num_nodes'] + results['max_scc_percent'] = snap.MxSccSz_PUNGraph(Graph).GetNodes() \ + / results['num_nodes'] + + # TODO: Calculate graph skew + return results + +def benchmark_neanet(Graph): + ''' + Perform benchmark tests for Directed Attribute Graphs + ''' + + results = {} + results['num_nodes'] = Graph.GetNodes() + results['num_edges'] = Graph.GetEdges() + + for degree in range(0, 11): + num = snap.NodesGTEDegree(Graph, degree) + percent_deg = float(num) / results['num_nodes'] + results['deg_gte_%d' % degree] = num + results['deg_gte_%d_percent' % degree] = percent_deg + + # Check for over-weighted nodes + results['max_degree'] = snap.MxDegree(Graph) + + num = snap.NodesGTEDegree(Graph, results['max_degree']) + results['max_degree_num'] = num + + results['max_wcc_percent'] = snap.GetMxWccSz(Graph) \ + / results['num_nodes'] + results['max_scc_percent'] = snap.GetMxSccSz(Graph).GetNodes() \ + / results['num_nodes'] + + return results + + +def convert_graph(Graph, TypeSrc, TypeDst): + ''' + Converts a GRAPH from type TYPESRC to a TYPEDST and returns the new graph + ''' + pass + + +def generate_graph(NNodes, NEdges, Model, Type, Rnd): + + if Model == 'rand_ungraph': + # GnRndGnm returns error, so manually generate + #Graph = snap.GenRndGnm_PUNGraph(NNodes, NEdges, 0) + Graph = snap.GenRndGnm(snap.PUNGraph, NNodes, NEdges, 0) + + elif Model == 'rand_ngraph': + #Graph = snap.GenRndGnm_PNGraph(NNodes, NEdges, 1) + Graph = snap.GenRndGnm(snap.PNGraph, NNodes, NEdges, 1) + + elif Model == 'rand_neanet': + print "1", NNodes, NEdges + #Graph = snap.GenRndGnm_PNEANet(NNodes, NEdges, 1) + Graph = snap.GenRndGnm(snap.PNEANet, NNodes, NEdges, 1) + print "2" + print "3", Graph.GetNodes(), Graph.GetEdges() + + elif Model == 'syn_neanet': + Graph = snap.GenSyntheticGraph(NNodes, NEdges/NNodes, + SYNTHETIC_DELTA) + + elif Model == 'syn_ngraph': + Graph = snap.GenSyntheticGraph_PNGraph(NNodes, NEdges/NNodes, + SYNTHETIC_DELTA) + + elif Model == 'rmat': + Graph = snap.GenRMat(NNodes, NEdges, 0.40, 0.25, 0.2, Rnd) + + elif Model == 'sw': + Graph = snap.GenSmallWorld(NNodes, NNodes/NEdges, 0.1) + + elif Model == 'pref': + Graph = snap.GenPrefAttach(NNodes, NNodes/NEdges) + + return Graph + +def run_tests(num_iterations=3, min_nodes_exponent=3, max_nodes_exponent=4): + ''' + Perform tests with specified exponent range + ''' + + if verbose: + print "Running results from %e to %e" % (min_nodes_exponent, + max_nodes_exponent) + + Rnd = snap.TRnd() + + for exp in range(min_nodes_exponent,max_nodes_exponent+1): + + for n in range(num_iterations): + + if verbose: + print "Iteration: %d of %d" % (n+1, num_iterations) + + # Random number of nodes of degree i + NNodes = 10**exp; + + for avg_deg in range(min_degree_edges, max_degree_edges+1): + + for g in graph_types: + + if deterministic: + if verbose: + print "Deterministic mode, putting seed" + else: + if verbose: + print "Non-deterministic mode" + Rnd.PutSeed(0) + + if verbose: print "Using average degree of 10^%d" % avg_deg + NEdges = NNodes*(10**avg_deg) + + Graph = None + if g in ['rmat', 'rand_ngraph', 'syn_ngraph','syn_negraph']: + Type = "directed" + + elif g in ['sw', 'pref', 'rand_ungraph']: + Type = "undirected" + + elif g in ['rand_neanet', 'syn_neanet']: + Type = "attribute" + + else: + print "Unknown graph type: %s" % g + sys.exit(1) + + StartTime = clock() + FName = os.path.join(RESULTS_DIR, "%s_10e%d_deg%d_%d.graph" % + (g, exp, NEdges/NNodes, n)) + + if not generate: + + if os.path.exists(FName): + try: + + if verbose: + print "Loading '%s' from ...'%s'" % (g, FName), + sys.stdout.flush() + + FIn = snap.TFIn(snap.TStr(FName)) + if Type == "directed": + Graph = snap.PNGraph_New() + elif Type == "undirected": + Graph = snap.PUNGraph_New() + elif Type == "attribute": + Graph = snap.PNEANet_New() + + Graph = Graph.Load(FIn) + if verbose: print "done" + + if verbose: + print "Re-loaded graph with %d Nodes and %d Edges" % \ + (Graph.GetNodes(), Graph.GetEdges()) + + except Exception, e: + print "Unable to load graph file, '%s': %s" % (FName, str(e)) + +# else: +# print "File not found: %s" % FName + + if not Graph: + + try: + + # User wants to re-generate graph, or no graph data available. + if verbose: + print "Generating '%s %s' graph with %e nodes, %e edges..." % \ + (Type, g, NNodes, NEdges), + sys.stdout.flush() + Graph = generate_graph(NNodes, NEdges, g, Type, Rnd) + if verbose: print "done" + + if opt_write: + + # Save the graph + if verbose: + print "Saving '%s' graph to file '%s'..." % (g, FName), + sys.stdout.flush() + + if Graph: + FOut = snap.TFOut(snap.TStr(FName)) + Graph.__ref__().Save(FOut) # Save as TUNGraph or TNGraph + FOut.Flush() + if verbose: print "done" + + except Exception, e: + print "Unable to generate/save graph file, '%s': %s" % \ + (FName, str(e)) + continue + + TimeGenerate = clock() - StartTime + + print "Running tests...", + sys.stdout.flush() + + StartTime = clock() + + if Type == 'directed': + results = benchmark_ngraph(Graph) + elif Type == 'undirected': + results = benchmark_ungraph(Graph) + elif Type == 'attribute': + results = benchmark_neanet(Graph) + + if verbose: print "done" + + TimeElapsed = clock() - StartTime + + print "Elapsed Time = %.4f sec" % TimeElapsed + + row_header = ["Hostname", "Model", "Type", "Nodes", "Edges", + "StartTime", "Generation Time", "Run Time"] + + print "Header: %s" % " ".join(row_header) + + import csv + with open(results_file, 'a+') as csvfile: + writer = csv.writer(csvfile) + if verbose: + print "Writing to '%s'..." % results_file, + sys.stdout.flush() + + row = [HOSTNAME, g, Type, NNodes, NEdges, + datetime.now().strftime("%d/%b/%Y:%H:%M:%S"), + TimeGenerate, TimeElapsed] + if verbose: print "done" + print "Time Data: %s" % repr(row) + writer.writerow(row) + + print "-"*75 + +def main(): + + global results_dir, verbose, deterministic, generate, graph_types, \ + hostname, num_iterations, results_file, \ + min_degree_edges, max_degree_edges, opt_write + + parser = argparse.ArgumentParser() + parser.add_argument("-v", "--verbose", default=DEFAULT_VERBOSE, + action="store_true", dest="verbose", + help="increase output verbosity") + + parser.add_argument("-r", "--range", default=DEFAULT_RANGE, + help="range (4-6) (10^4 to 10^6 nodes)") + + parser.add_argument("-e", "--edges_deg", default=DEFAULT_DEGREES, + help="range of degrees (e.g \"2-3\" => (10^1 to 10^3 edges per node)") + + parser.add_argument("-d", "--deterministic", default=False, + action="store_true", dest="deterministic", + help="deterministic benchmark") + + parser.add_argument("-t", "--graph_types", default=DEFAULT_TYPES, + help=''' + Graph types, comma separated. + Available: rand_ungraph, rand_ngraph, rmat, pref, sw''') + + parser.add_argument("-n", "--num_iterations", type=int, + default=DEFAULT_ITERATIONS, help="number of iterations") + + parser.add_argument("-o", "--output_file", + default=DEFAULT_RESULTS_FILE, + help="file to output results") + + parser.add_argument("-g", "--generate", default=False, + action="store_true", dest="generate", + help="generate new graphs") + + parser.add_argument("-w", "--write_graph", default=DEFAULT_WRITE, + action="store_true", dest="write", + help="save graph") + + args = parser.parse_args() + + verbose = args.verbose + generate = args.generate + deterministic = args.deterministic + results_file = args.output_file + num_iterations = args.num_iterations + graph_types = args.graph_types.split(",") + min_degree_edges = int(args.edges_deg.split("-")[0]) + max_degree_edges = int(args.edges_deg.split("-")[-1]) + opt_write = args.write + + + print "Edge degree = 10^%d to 10^%d edges/node" % \ + (min_degree_edges, max_degree_edges) + + if verbose: + print "Hostname: %s" % HOSTNAME + min = int(args.range.split("-")[0]) + max = int(args.range.split("-")[-1]) + print "Node range = 10^%d to 10^%d" % (min, max) + + if not os.path.exists(RESULTS_DIR): + print "Creating results directory %s" % RESULTS_DIR + os.makedirs(RESULTS_DIR) + + run_tests(num_iterations, min, max) + +if __name__ == "__main__": + main() + + diff --git a/snap-python/source/examples/data/p2p-Gnutella08.txt b/snap-python/source/examples/data/p2p-Gnutella08.txt new file mode 100644 index 0000000000000000000000000000000000000000..6f4d562f90e368dee1332172c3e3ef4f20f01c3d --- /dev/null +++ b/snap-python/source/examples/data/p2p-Gnutella08.txt @@ -0,0 +1,20781 @@ +# Directed graph: p2p-Gnutella08.txt +# epinions +# Nodes: 6301 Edges: 20777 +# FromNodeId ToNodeId +0 1 +0 2 +0 3 +0 4 +0 5 +0 6 +0 7 +0 8 +0 9 +0 10 +3 703 +3 826 +3 1097 +3 1287 +3 1591 +3 1895 +3 1896 +3 1897 +3 1898 +3 1899 +4 144 +4 258 +4 491 +4 1021 +4 1418 +4 1669 +4 1900 +4 1901 +4 1902 +4 1903 +5 121 +5 127 +5 128 +5 179 +5 247 +5 249 +5 264 +5 353 +5 424 +5 426 +7 145 +7 176 +7 177 +7 353 +7 753 +7 754 +7 762 +7 2064 +7 3002 +8 520 +8 665 +8 852 +8 1394 +8 1786 +8 1842 +8 1904 +8 1905 +8 1906 +8 1907 +9 124 +9 147 +9 177 +9 246 +9 247 +9 248 +9 249 +9 250 +9 251 +9 252 +703 898 +703 1581 +703 1620 +703 2634 +703 2635 +703 2636 +703 2637 +703 2638 +703 2639 +703 2640 +1287 38 +1287 331 +1287 626 +1287 1945 +1287 2690 +1287 3137 +1287 3138 +1287 3139 +1287 3140 +1287 3141 +1895 1860 +1896 1118 +1896 1227 +1896 1334 +1896 1556 +1896 1980 +1896 2333 +1896 3672 +1896 3677 +1896 3678 +1896 3679 +144 8 +144 121 +144 122 +144 125 +144 146 +144 246 +144 249 +144 264 +144 367 +1669 1573 +1669 3023 +1669 3216 +1669 3413 +1669 3414 +1669 3415 +1669 3416 +1669 3417 +1669 3418 +127 9 +127 144 +127 175 +127 177 +127 247 +127 427 +127 698 +127 762 +127 1246 +127 2076 +179 4 +179 9 +179 17 +179 31 +179 123 +179 125 +179 250 +179 559 +179 2018 +247 776 +247 900 +247 1067 +247 1068 +247 1069 +247 1070 +247 1071 +247 1072 +247 1073 +247 1074 +249 123 +249 250 +249 251 +249 351 +249 753 +249 755 +249 762 +249 983 +264 249 +264 697 +264 1787 +264 2193 +264 2194 +264 2224 +264 2225 +264 2226 +264 2227 +264 2228 +353 122 +353 123 +353 127 +353 249 +353 251 +353 367 +353 368 +353 666 +353 754 +353 856 +424 940 +424 960 +424 2409 +424 2410 +424 2411 +424 2412 +424 2413 +424 2414 +424 2415 +145 149 +145 246 +145 265 +145 367 +145 390 +145 667 +145 717 +145 1317 +145 2098 +176 5 +176 248 +176 369 +176 697 +176 700 +176 946 +176 947 +176 2001 +176 2122 +177 143 +177 145 +177 149 +177 266 +177 367 +177 368 +177 559 +177 856 +177 1245 +753 9 +753 121 +753 122 +753 127 +753 128 +753 129 +753 145 +753 177 +753 367 +762 3 +762 175 +762 176 +762 251 +762 264 +762 266 +762 559 +762 754 +762 2001 +762 2018 +665 4 +665 5 +665 9 +665 126 +665 148 +665 252 +665 352 +665 353 +665 666 +665 667 +852 250 +852 938 +852 1097 +852 1556 +852 1990 +852 2748 +852 2749 +852 2750 +852 2751 +852 2752 +1394 9 +1394 126 +1394 129 +1394 177 +1394 248 +1394 266 +1394 353 +1394 754 +1394 1317 +1394 2018 +1786 122 +1786 125 +1786 142 +1786 146 +1786 248 +1786 249 +1786 264 +1786 367 +1786 1245 +1842 628 +1842 1342 +1842 1383 +1842 2494 +1842 3577 +1842 3578 +1842 3579 +1842 3580 +1842 3581 +1842 3582 +1904 7 +1904 129 +1904 144 +1904 149 +1904 174 +1904 247 +1904 248 +1904 252 +1904 353 +1907 4 +1907 7 +1907 129 +1907 145 +1907 149 +1907 174 +1907 266 +1907 666 +124 122 +124 123 +124 145 +124 147 +124 176 +124 248 +124 390 +124 762 +124 2063 +124 2064 +147 8 +147 128 +147 176 +147 177 +147 264 +147 367 +147 424 +147 427 +147 1246 +248 326 +248 914 +248 915 +248 916 +248 917 +248 918 +248 919 +248 920 +248 921 +248 922 +250 51 +250 64 +250 114 +250 1349 +250 1389 +250 1644 +250 1726 +250 2018 +250 4180 +250 4181 +251 513 +251 586 +251 873 +251 1064 +251 1412 +251 2206 +251 2207 +251 2208 +251 2209 +251 2210 +252 62 +252 808 +252 1475 +252 2211 +252 2212 +252 2213 +252 2214 +252 2215 +252 2216 +898 1620 +898 2785 +1620 112 +1620 342 +1620 1658 +1620 2262 +1620 2612 +1620 2634 +1620 2706 +1620 3027 +1620 3382 +1620 3383 +2634 106 +2634 510 +2634 558 +2634 1817 +2634 2595 +2634 2635 +2634 3409 +2634 3897 +2634 4229 +2635 955 +2635 1265 +2635 1427 +2635 1584 +2635 1602 +2635 1699 +2635 2269 +2635 3310 +2635 4238 +2635 4239 +2638 179 +2638 1061 +2638 1317 +2638 2720 +2638 2721 +2638 3821 +2638 4230 +2638 4231 +2638 4232 +2638 4233 +2639 71 +2639 296 +2639 527 +2639 804 +2639 1017 +2639 2051 +2639 3215 +2639 3362 +2639 4234 +2639 4235 +38 725 +38 1376 +38 1915 +38 2002 +38 2007 +38 2167 +38 2168 +38 2169 +38 2170 +331 100 +331 332 +331 333 +331 334 +331 335 +331 336 +331 337 +331 338 +331 339 +1945 151 +1945 178 +1945 814 +1945 1144 +1945 1228 +1945 1653 +1945 2288 +1945 3722 +1945 3723 +1945 3724 +2690 581 +2690 1493 +2690 1636 +2690 1936 +2690 2234 +2690 2823 +2690 4258 +2690 4259 +2690 4260 +2690 4261 +3137 102 +3137 264 +3137 753 +3137 755 +3137 1212 +3137 3146 +3137 3849 +3137 4455 +3137 4546 +3137 4547 +3138 127 +3138 143 +3138 252 +3138 369 +3138 390 +3138 754 +3138 1387 +3138 1912 +3138 2050 +3138 4487 +3140 477 +3140 2593 +3140 2746 +3140 3364 +3140 3687 +3140 4159 +3140 4437 +3140 5629 +3140 5931 +3140 6071 +1118 560 +1118 813 +1118 2011 +1118 2625 +1118 2996 +1118 2997 +1118 2998 +1118 2999 +1118 3000 +1118 3001 +1556 123 +1556 700 +1556 792 +1556 859 +1556 1491 +1556 2184 +1556 3373 +1556 3374 +1556 3375 +1556 3376 +2333 126 +2333 529 +2333 1334 +2333 1706 +2333 1891 +2333 2344 +2333 3096 +2333 3672 +2333 3822 +2333 4030 +122 578 +122 658 +122 1428 +122 1451 +122 2057 +122 2058 +122 2059 +122 2060 +122 2061 +122 2062 +125 132 +125 222 +125 503 +125 1535 +125 2070 +125 2071 +125 2072 +125 2073 +125 2074 +125 2075 +146 7 +146 285 +146 3337 +146 5048 +146 5171 +146 5338 +146 5940 +146 5941 +146 5942 +367 4 +367 5 +367 7 +367 264 +367 266 +367 559 +367 666 +367 1317 +1573 224 +1573 490 +1573 491 +1573 496 +1573 1123 +1573 1140 +1573 2221 +1573 2222 +1573 2705 +1573 2953 +1573 2973 +1573 3376 +1573 3408 +3023 144 +3023 148 +3023 149 +3023 420 +3023 551 +3023 559 +3023 1184 +3023 1994 +3023 4425 +3023 4459 +3415 17 +3415 125 +3415 148 +3415 266 +3415 559 +3415 697 +3415 753 +3415 1317 +3415 1920 +3417 122 +3417 129 +3417 143 +3417 177 +3417 246 +3417 251 +3417 367 +3417 390 +3417 666 +175 1575 +175 3066 +175 3344 +175 3715 +175 3849 +175 4539 +175 5209 +175 5325 +175 5483 +175 5584 +427 4 +427 124 +427 251 +427 265 +427 353 +427 369 +427 695 +427 700 +427 946 +427 947 +17 1050 +17 2254 +17 2761 +17 3147 +17 3169 +17 3619 +17 3893 +17 4408 +17 4953 +31 124 +31 637 +31 870 +31 1219 +31 1954 +31 2237 +31 2524 +31 2630 +31 3637 +31 3874 +123 3 +123 7 +123 143 +123 145 +123 146 +123 147 +123 252 +123 367 +123 390 +123 423 +559 119 +559 756 +559 759 +559 818 +559 819 +559 820 +559 821 +559 822 +559 823 +559 824 +1067 969 +1067 1570 +1067 2976 +1067 2977 +1068 1688 +1068 2493 +1068 2972 +1068 2973 +1068 2974 +1070 2975 +351 121 +351 176 +351 352 +351 353 +351 354 +351 355 +351 356 +351 357 +351 358 +351 359 +697 870 +697 1441 +697 1589 +697 2034 +697 2214 +697 2597 +697 2598 +697 2599 +697 2600 +697 2601 +1787 549 +1787 802 +1787 1115 +1787 1574 +1787 1788 +1787 3563 +1787 3700 +1787 3701 +1787 3702 +2193 5 +2193 124 +2193 144 +2193 147 +2193 176 +2193 248 +2193 427 +2193 629 +2193 3914 +2193 3915 +2224 122 +2224 127 +2224 175 +2224 249 +2224 266 +2224 367 +2224 390 +2224 423 +2224 697 +2225 604 +2225 1054 +2225 1129 +2225 2278 +2225 2476 +2225 2600 +2225 2733 +2225 3235 +2225 3931 +2225 3932 +2226 260 +2226 282 +2226 822 +2226 889 +2226 1143 +2226 1975 +2226 2042 +2226 2414 +2226 2867 +2226 3933 +2228 222 +2228 1173 +2228 1374 +2228 2358 +2228 2552 +2228 3354 +2228 3934 +2228 3935 +2228 3936 +2228 3937 +856 5 +856 7 +856 145 +856 149 +856 174 +856 179 +856 180 +856 1317 +856 2018 +2411 246 +2411 351 +2411 503 +2411 944 +2411 2077 +2411 2593 +2411 3229 +2411 4089 +2411 4090 +2411 4091 +149 5 +149 10 +149 128 +149 148 +149 238 +149 250 +149 252 +149 265 +149 353 +149 1317 +390 108 +390 261 +390 391 +390 392 +390 393 +390 394 +390 395 +390 396 +390 397 +390 398 +667 152 +667 459 +667 468 +667 1350 +667 1956 +667 2578 +667 2579 +667 2580 +667 2581 +717 124 +717 175 +717 265 +717 369 +717 390 +717 426 +717 427 +717 554 +717 695 +717 754 +1317 1036 +1317 1534 +1317 2362 +1317 3109 +1317 3163 +1317 3164 +1317 3165 +1317 3166 +1317 3167 +1317 3168 +369 9 +369 145 +369 174 +369 246 +369 264 +369 266 +369 422 +369 559 +369 666 +700 584 +700 1056 +700 1517 +700 2614 +700 2615 +700 2616 +700 2617 +700 2618 +700 2619 +700 2620 +2001 253 +2001 261 +2001 924 +2001 1606 +2001 1867 +2001 2071 +2001 2281 +2001 3336 +2001 3771 +2001 3772 +143 122 +143 124 +143 128 +143 146 +143 246 +143 249 +143 367 +143 426 +143 427 +143 2098 +1245 5 +1245 126 +1245 146 +1245 147 +1245 149 +1245 175 +1245 180 +1245 368 +1245 422 +1245 2018 +129 133 +129 219 +129 778 +129 864 +129 2078 +129 2079 +129 2080 +129 2081 +129 2082 +129 2083 +126 127 +126 369 +126 696 +126 698 +126 754 +126 755 +126 946 +126 947 +126 2001 +126 2077 +148 121 +148 122 +148 123 +148 124 +148 176 +148 246 +148 248 +148 367 +148 422 +148 1245 +352 4 +352 146 +352 176 +352 249 +352 266 +352 367 +352 368 +352 422 +352 2001 +938 253 +938 534 +938 547 +938 939 +938 940 +938 941 +938 942 +938 943 +938 944 +938 945 +2748 165 +2748 1066 +2748 1140 +2748 3096 +2748 3801 +2748 3946 +2748 4153 +2748 4300 +2748 4301 +2748 4302 +2750 7 +2750 8 +2750 125 +2750 128 +2750 174 +2750 238 +2750 368 +2750 424 +2750 717 +2750 856 +2751 4 +2751 147 +2751 180 +2751 249 +2751 367 +2751 368 +2751 369 +2751 390 +2751 422 +2751 856 +628 9 +628 144 +628 145 +628 147 +628 149 +628 175 +628 176 +628 369 +628 629 +628 630 +1383 327 +1383 782 +1383 815 +1383 2359 +1383 2451 +1383 2964 +1383 3211 +1383 3227 +1383 3228 +1383 3229 +2494 1433 +2494 1978 +2494 2032 +2494 3530 +2494 4129 +3577 3 +3577 9 +3577 123 +3577 124 +3577 149 +3577 247 +3577 249 +3577 352 +3577 369 +3577 427 +3579 7 +3579 149 +3579 252 +3579 715 +3579 1481 +3579 2001 +3579 4172 +3579 4586 +3579 4679 +3579 4794 +3581 3750 +174 3 +174 5 +174 7 +174 122 +174 126 +174 142 +174 145 +174 249 +174 427 +174 667 +326 922 +326 1004 +326 2277 +326 2278 +326 2279 +326 2280 +326 2281 +326 2282 +326 2283 +326 2284 +914 2042 +918 451 +918 1047 +918 1213 +918 1376 +918 1708 +918 2624 +918 2818 +918 2819 +918 2820 +919 121 +919 122 +919 123 +919 126 +919 145 +919 149 +919 180 +919 250 +919 559 +922 2809 +922 2810 +922 2811 +922 2812 +922 2813 +922 2814 +922 2815 +922 2816 +922 2817 +64 91 +64 102 +64 106 +64 1946 +64 1947 +64 1948 +64 1949 +64 1950 +64 1951 +64 1952 +1389 143 +1389 732 +1389 1390 +1389 1391 +1389 1392 +1389 1393 +1389 1394 +1389 1395 +1389 1396 +1389 1397 +1644 424 +1644 823 +1644 1414 +1644 2040 +1644 2125 +1644 2399 +1644 2880 +1644 3162 +1644 3394 +1644 3395 +4180 143 +4180 476 +4180 693 +4180 911 +4180 1272 +4180 1273 +4180 2808 +4180 5126 +4180 5127 +4180 5128 +586 8 +586 126 +586 128 +586 149 +586 175 +586 247 +586 248 +586 666 +586 717 +586 754 +873 1227 +873 1336 +873 2392 +873 2433 +873 2581 +873 2756 +873 2757 +873 2758 +873 2759 +873 2760 +1412 9 +1412 127 +1412 145 +1412 149 +1412 174 +1412 179 +1412 264 +1412 422 +1412 427 +1412 1317 +62 1064 +62 1194 +62 1196 +62 1198 +62 1959 +62 1960 +62 1961 +62 1962 +62 1963 +11 12 +11 13 +11 14 +11 15 +11 16 +11 17 +11 18 +11 19 +11 20 +11 21 +13 2074 +14 809 +15 3 +15 123 +15 129 +15 143 +15 251 +15 264 +15 367 +15 426 +15 427 +15 718 +20 121 +20 147 +20 368 +20 427 +20 717 +20 856 +20 975 +20 1908 +20 1909 +20 1910 +21 92 +21 1702 +21 1711 +21 1833 +21 1916 +21 1917 +21 1918 +21 1919 +21 1920 +21 1921 +718 167 +718 243 +718 326 +718 404 +718 942 +718 1885 +718 1886 +718 1887 +2761 222 +2761 1780 +2761 2008 +2761 2048 +2761 2086 +2761 3484 +2761 3981 +2761 4093 +2761 4298 +2761 4299 +3147 240 +3147 534 +3147 4270 +3147 4653 +3893 126 +3893 145 +3893 147 +3893 252 +3893 667 +3893 732 +3893 754 +3893 1909 +3893 3349 +975 906 +975 940 +975 976 +975 977 +975 978 +975 979 +975 980 +975 981 +975 982 +975 983 +1910 271 +1910 549 +1910 659 +1910 711 +1910 1180 +1910 1583 +1910 2288 +1910 2634 +1910 2833 +1910 3682 +92 2015 +92 2016 +1711 2707 +1917 1601 +1917 1711 +1917 1845 +1917 1985 +1917 2181 +1917 2619 +1917 3052 +1917 3056 +1917 3683 +1917 3684 +1920 255 +1920 1005 +1920 1048 +1920 1548 +1920 1772 +1920 1956 +1920 2709 +1920 3685 +1920 3686 +1920 3687 +423 4 +423 127 +423 390 +423 427 +423 2403 +423 2404 +423 2405 +423 2406 +423 2407 +423 2408 +133 110 +133 253 +133 1193 +133 1531 +133 1896 +133 2084 +133 2085 +133 2086 +133 2087 +133 2088 +864 198 +864 290 +864 837 +864 894 +864 1333 +864 2517 +864 2744 +864 2745 +864 2746 +864 2747 +2079 295 +2079 864 +2079 1029 +2079 1850 +2079 2114 +2079 3228 +2079 3851 +2079 3852 +2079 3853 +2079 3854 +2080 71 +2080 1027 +2080 2424 +2080 2602 +2080 2653 +2080 3055 +2080 3448 +2080 3839 +2080 3840 +2080 3841 +695 106 +695 290 +695 1690 +695 1956 +695 2385 +695 2593 +695 2594 +695 2595 +695 2596 +167 8 +167 17 +167 121 +167 129 +167 175 +167 238 +167 266 +167 353 +167 424 +167 2018 +243 1564 +243 2189 +243 2190 +243 2191 +243 2192 +243 2193 +243 2194 +243 2195 +243 2196 +1885 5 +1885 143 +1885 144 +1885 147 +1885 174 +1885 252 +1885 264 +1885 390 +1885 423 +1885 558 +1780 1666 +1780 2049 +1780 3533 +1780 3534 +1780 3535 +2048 659 +2048 1801 +2048 1817 +2048 2305 +2048 2327 +2048 2764 +2048 2852 +2048 3149 +2048 3812 +2048 3813 +2086 381 +2086 1070 +2086 1587 +2086 1688 +2086 2720 +2086 2783 +2086 3842 +2086 3843 +2086 3844 +2086 3845 +3484 121 +3484 127 +3484 128 +3484 129 +3484 146 +3484 176 +3484 238 +3484 266 +3484 423 +3484 427 +3981 127 +3981 878 +3981 1007 +3981 1540 +3981 2592 +3981 3557 +3981 4793 +3981 5496 +3981 6241 +3981 6242 +4093 656 +4093 1156 +4093 1546 +4093 2207 +4093 2254 +4093 4039 +4093 4502 +4093 5049 +4093 5074 +4093 5075 +4298 911 +4298 1726 +4298 2789 +4298 3149 +4298 4371 +4298 4487 +4298 4770 +4298 5200 +4298 5201 +732 309 +732 928 +732 1071 +732 1233 +732 1246 +732 1435 +732 2228 +732 2650 +732 2651 +732 2652 +554 1547 +554 2148 +554 2472 +554 3141 +554 3283 +554 3312 +554 4477 +554 4515 +554 4516 +180 3 +180 1489 +180 1490 +180 1524 +180 1766 +180 2130 +180 2131 +180 2132 +180 2133 +180 2134 +906 303 +906 518 +906 907 +906 908 +906 909 +906 910 +906 911 +906 912 +906 913 +977 295 +977 2093 +977 2517 +977 2840 +977 2865 +977 2866 +977 2867 +977 2868 +977 2869 +977 2870 +978 215 +978 314 +978 315 +978 1140 +978 2877 +978 2878 +978 2879 +978 2880 +978 2881 +978 2882 +979 35 +979 119 +979 612 +979 762 +979 866 +979 1023 +979 1318 +979 1319 +979 1320 +979 1321 +981 8 +981 448 +981 731 +981 822 +981 1143 +981 1974 +981 2883 +981 2884 +981 2885 +981 2886 +982 3028 +982 3029 +982 3030 +982 3031 +659 123 +659 143 +659 667 +659 1084 +659 1814 +659 1870 +659 2244 +659 2295 +659 2576 +659 2577 +2288 3453 +2288 3791 +2288 3971 +2288 3972 +2288 3973 +2288 3974 +2288 3975 +2288 3976 +2288 3977 +2288 3978 +1601 125 +1601 126 +1601 129 +1601 148 +1601 149 +1601 179 +1601 247 +1601 248 +1601 717 +1601 754 +2181 63 +2181 291 +2181 307 +2181 1873 +2181 2546 +2181 2554 +2181 2646 +2181 2697 +2181 3204 +2181 3335 +3056 290 +3056 520 +3056 1493 +3056 2150 +3056 2334 +3056 3833 +3056 4481 +3056 4482 +3056 4483 +1005 174 +1005 227 +1005 1490 +1005 1624 +1005 2287 +1005 2330 +1005 2908 +1005 2909 +1005 2910 +1005 2911 +1048 844 +1048 973 +1048 1049 +1048 1050 +1048 1051 +1048 1052 +1048 1053 +1048 1054 +1048 1055 +1048 1056 +1548 169 +1548 880 +1548 1084 +1548 1947 +1548 2269 +1548 2822 +1548 3360 +1548 3361 +1548 3362 +1548 3363 +1772 255 +1772 815 +1772 1168 +1772 2265 +1772 2552 +1772 2736 +1772 2756 +1772 2943 +1772 2993 +1772 3530 +2709 23 +2709 518 +2709 2138 +2709 2360 +2709 2794 +2709 3992 +2709 4172 +2709 4287 +2709 4288 +2709 4289 +22 23 +22 24 +22 25 +22 26 +22 27 +22 28 +22 29 +22 30 +22 31 +22 32 +25 1022 +27 901 +27 960 +27 1511 +27 1624 +27 1836 +27 1911 +27 1912 +27 1913 +27 1914 +27 1915 +28 846 +28 1516 +28 1517 +29 962 +29 1656 +29 2201 +30 3 +30 5 +30 8 +30 121 +30 124 +30 126 +30 145 +30 174 +30 249 +30 424 +32 957 +32 1028 +32 1199 +32 1459 +32 1699 +32 1700 +32 1701 +32 1702 +32 1703 +1022 1023 +1022 1024 +1022 1025 +1022 1026 +1022 1027 +1022 1028 +1022 1029 +1022 1030 +1022 1031 +1022 1032 +1836 112 +1836 298 +1836 579 +1836 627 +1836 894 +1836 2485 +1836 2730 +1836 3569 +1836 3570 +846 152 +846 602 +846 847 +846 848 +846 849 +846 850 +846 851 +846 852 +846 853 +846 854 +962 867 +962 1228 +962 1777 +962 1778 +962 1779 +962 1780 +962 1781 +962 1782 +962 1783 +962 1784 +1656 2729 +1656 5140 +2201 1511 +2201 1815 +2201 1944 +2201 2090 +2201 2416 +2201 2943 +2201 2981 +2201 3205 +2201 3319 +2201 3928 +637 796 +637 869 +637 870 +637 871 +637 872 +637 873 +637 874 +637 875 +637 876 +637 877 +2237 1402 +2237 1454 +2237 1458 +2237 1728 +2237 1866 +2237 2658 +2237 2719 +2237 2789 +2237 3220 +2237 3357 +2524 38 +2524 103 +2524 289 +2524 1252 +2524 2551 +2524 2764 +2524 3114 +2524 3926 +2524 5653 +2524 5840 +1028 251 +1028 813 +1028 815 +1028 982 +1028 1798 +1028 2733 +1028 2940 +1028 2941 +1028 2942 +1028 2943 +1199 3 +1199 121 +1199 123 +1199 125 +1199 127 +1199 128 +1199 238 +1199 264 +1199 390 +1199 426 +1459 554 +1459 910 +1459 1179 +1459 1275 +1459 1491 +1459 1511 +1459 2494 +1459 3310 +1459 3311 +1459 3312 +1699 813 +1699 1064 +1699 2207 +1699 3241 +1699 3463 +1699 3464 +1699 3465 +1699 3466 +1699 3467 +1700 23 +1700 436 +1700 451 +1700 2165 +1700 2324 +1700 3455 +1700 3456 +1700 3457 +1700 3458 +1701 612 +1701 1659 +1701 1805 +1701 1939 +1701 2188 +1701 3459 +1701 3460 +1701 3461 +1701 3462 +1703 78 +1703 889 +1703 1358 +1703 2423 +1703 2906 +1703 3468 +1703 3469 +1703 3470 +1703 3471 +1025 99 +1025 584 +1025 689 +1025 902 +1025 2916 +1025 3191 +1025 3462 +1025 5106 +1025 5107 +1025 5108 +1026 129 +1026 177 +1026 251 +1026 1246 +1026 2199 +1026 2366 +1026 2791 +1026 2937 +1026 2938 +1026 2939 +1027 1221 +1027 1316 +1027 1750 +1027 2471 +1027 2612 +1027 2849 +1027 2859 +1027 2952 +1027 2953 +1027 2954 +1029 121 +1029 122 +1029 125 +1029 127 +1029 147 +1029 249 +1029 251 +1029 367 +1029 718 +1029 2098 +1030 791 +1030 2651 +1030 2693 +1030 2944 +1030 2945 +1030 2946 +1030 2947 +1030 2948 +1030 2949 +1030 2950 +112 1064 +112 1160 +112 2044 +112 2045 +112 2046 +112 2047 +112 2048 +112 2049 +112 2050 +298 7 +298 8 +298 121 +298 144 +298 252 +298 266 +298 352 +298 424 +298 666 +579 231 +579 893 +579 1476 +579 1629 +579 1682 +579 2529 +579 2530 +579 2531 +579 2532 +579 2533 +2485 33 +2485 100 +2485 568 +2485 2422 +2485 2588 +2485 2654 +2485 3335 +2485 4124 +2485 4125 +2485 4126 +848 448 +867 53 +867 470 +867 1734 +867 1738 +867 2527 +867 2766 +867 2767 +867 2768 +867 2769 +867 2770 +1228 23 +1228 123 +1228 126 +1228 173 +1228 1896 +1228 3323 +1228 4906 +1228 4907 +1782 503 +1782 1103 +1782 1224 +1782 1301 +1782 1585 +1782 2272 +1782 2766 +1782 3105 +1782 3531 +1782 3532 +1784 3 +1784 4 +1784 122 +1784 143 +1784 422 +1784 423 +1784 427 +1784 666 +1784 667 +1815 459 +1815 801 +1815 808 +1815 892 +1815 1794 +1815 1816 +1815 1817 +1815 1818 +1815 1819 +1815 1820 +869 586 +869 833 +869 1195 +869 1367 +869 1762 +869 2354 +869 2380 +869 2753 +869 2754 +869 2755 +874 149 +874 177 +874 307 +874 652 +874 1003 +874 1022 +874 1655 +874 2495 +874 2761 +874 2762 +876 541 +1402 55 +1402 96 +1402 1444 +1402 2186 +1402 2662 +1402 3137 +1402 3258 +1402 3259 +1402 3260 +1402 3261 +1454 3 +1454 629 +1454 691 +1454 937 +1454 1989 +1454 2089 +1454 3232 +1454 3307 +1454 3308 +1454 3309 +1458 4 +1458 5 +1458 125 +1458 144 +1458 148 +1458 149 +1458 353 +1458 422 +1458 666 +1458 856 +1866 4 +1866 123 +1866 127 +1866 368 +1866 390 +1866 1245 +1866 2572 +1866 3675 +1866 3676 +2719 92 +2719 182 +2719 835 +2719 1209 +2719 1255 +2719 1442 +2719 3117 +2719 4278 +2719 4279 +2719 4280 +3220 152 +3220 503 +3220 507 +3220 548 +3220 2345 +3220 2575 +3220 4600 +3220 4601 +3220 4602 +289 290 +289 291 +289 292 +289 293 +289 294 +289 295 +289 296 +289 297 +289 298 +289 299 +2551 962 +3926 2349 +3926 2362 +3926 2596 +3926 2925 +3926 3098 +3926 3358 +3926 4413 +3926 4534 +3926 5002 +3926 5003 +5653 538 +5653 614 +5653 675 +5653 2481 +5653 4655 +5653 5291 +5653 5601 +5653 5927 +5653 5928 +5653 5929 +2733 3 +2733 8 +2733 177 +2733 238 +2733 249 +2733 368 +2733 369 +2733 427 +2733 667 +2733 717 +2942 21 +2942 132 +2942 924 +2942 1335 +2942 1417 +2942 1842 +2942 1890 +2942 4415 +2942 4416 +2942 4417 +238 9 +238 143 +238 146 +238 174 +238 667 +238 2181 +238 2182 +238 2183 +238 2184 +238 2185 +910 518 +910 869 +910 2322 +910 2797 +910 2798 +910 2799 +910 2800 +910 2801 +910 2802 +910 2803 +1275 1276 +1275 1277 +1275 1278 +1275 1279 +1275 1280 +1275 1281 +1275 1282 +1275 1283 +1275 1284 +1275 1285 +3310 296 +3310 1444 +3310 1529 +3310 2453 +3310 3211 +3310 4664 +3310 4665 +3310 4666 +3310 4667 +3310 4668 +3311 493 +3311 498 +3311 560 +3311 767 +3311 2293 +3312 29 +3312 513 +3312 532 +3312 1784 +3312 2143 +3312 2695 +3312 2955 +3312 3997 +3312 4669 +3312 4670 +3463 257 +3463 478 +3463 786 +3463 1129 +3463 2261 +3463 2330 +3463 3417 +3463 4767 +3463 4768 +3465 7 +3465 8 +3465 126 +3465 149 +3465 427 +3465 1246 +3465 1388 +3465 2538 +3465 4551 +3465 4769 +3466 50 +3466 51 +3466 732 +3466 1313 +3466 1325 +3466 1980 +3466 2309 +3466 2984 +3466 3141 +3466 3405 +2324 240 +2324 566 +2324 810 +2324 968 +2324 1245 +2324 3230 +2324 3257 +2324 3475 +2324 3538 +2324 3752 +1659 143 +1659 522 +1659 1791 +1659 2285 +1659 2349 +1659 2862 +1659 3121 +1659 3175 +1659 3300 +1659 3412 +1805 871 +1805 1806 +1805 1807 +1805 1808 +1805 1809 +1805 1810 +1805 1811 +1805 1812 +1805 1813 +1805 1814 +1939 840 +3459 3 +3459 124 +3459 127 +3459 129 +3459 177 +3459 251 +3459 266 +3459 367 +3459 368 +3459 422 +3462 2115 +3462 2568 +3462 4393 +3462 4395 +3462 4761 +3462 4762 +3462 4763 +3462 4764 +3462 4765 +3462 4766 +78 725 +78 898 +78 1157 +78 1894 +78 2203 +78 2204 +78 2205 +889 2547 +889 2951 +2906 301 +2906 692 +2906 2106 +2906 2670 +2906 2916 +2906 3188 +2906 4334 +2906 4402 +2906 4403 +2906 4404 +3468 740 +3468 997 +3468 1565 +3468 3968 +3468 4206 +3468 4239 +3468 4355 +3468 4770 +3468 4771 +3468 4772 +3469 123 +3469 266 +3469 570 +3469 1630 +3469 2236 +3469 2752 +3469 2948 +3469 3247 +3469 4773 +3469 4774 +3470 583 +3470 1947 +3470 2360 +3470 2528 +3470 2636 +3470 4155 +3470 4775 +3470 4776 +3470 4777 +3471 714 +3471 2425 +3471 2517 +3471 3386 +3471 4854 +33 34 +33 35 +33 36 +33 37 +33 38 +33 39 +33 40 +33 41 +33 42 +33 43 +36 3 +36 123 +36 126 +36 145 +36 174 +36 179 +36 247 +36 249 +36 264 +36 424 +39 614 +39 1378 +39 1922 +39 1923 +39 1924 +39 1925 +39 1926 +39 1927 +39 1928 +39 1929 +43 1604 +43 1679 +43 1903 +43 1930 +43 1931 +43 1932 +43 1933 +43 1934 +43 1935 +43 1936 +2007 199 +2007 203 +2007 527 +2007 3581 +2007 3680 +2007 3785 +2007 3786 +2007 3787 +2007 3788 +2007 3789 +1922 873 +1922 1359 +1922 1526 +1922 2941 +1922 3612 +1922 3688 +1922 3689 +1922 3690 +1922 3691 +1922 3692 +1923 60 +1923 82 +1923 586 +1923 835 +1923 1749 +1923 1969 +1923 2317 +1923 3693 +1923 3694 +1923 3695 +1924 524 +1924 2451 +1924 2908 +1924 3051 +1924 3219 +1924 3867 +1926 982 +1926 1929 +1926 2090 +1926 2317 +1926 2407 +1926 3107 +1926 3696 +1926 3697 +1926 3698 +1926 3699 +1929 126 +1929 128 +1929 145 +1929 149 +1929 174 +1929 177 +1929 179 +1929 266 +1929 2001 +1929 2018 +1930 190 +1930 814 +1930 923 +1930 1655 +1930 2900 +1930 3703 +1930 3704 +1930 3705 +1930 3706 +1930 3707 +1932 364 +1932 685 +1932 921 +1932 1313 +1932 1829 +1932 2644 +1932 3018 +1932 3713 +1932 3714 +1934 4 +1934 5 +1934 144 +1934 145 +1934 175 +1934 367 +1934 390 +1934 559 +1934 718 +203 5973 +203 5974 +527 1020 +527 1171 +527 1342 +527 2671 +527 2837 +527 2935 +527 3786 +527 3840 +527 4248 +527 4455 +527 4876 +527 4979 +527 4980 +1359 626 +1359 913 +1359 1741 +1359 1958 +1359 1980 +1359 2194 +1359 2617 +1359 3206 +1359 3207 +1359 3208 +3612 4855 +3690 252 +3690 360 +3690 1224 +3690 1288 +3690 3868 +3690 4200 +3690 4884 +3690 4885 +3690 4886 +3690 4887 +60 1937 +60 1938 +60 1939 +60 1940 +60 1941 +60 1942 +60 1943 +60 1944 +60 1945 +1749 863 +1749 1094 +1749 1555 +1749 2722 +1749 2743 +1749 2996 +1749 3506 +1749 3507 +1749 3508 +1749 3509 +1969 1541 +1969 1548 +1969 2878 +1969 3179 +1969 3519 +1969 3549 +1969 3754 +1969 3755 +1969 3756 +1969 3757 +3693 3 +3693 123 +3693 126 +3693 144 +3693 149 +3693 179 +3693 251 +3693 367 +3693 424 +3693 717 +3694 1280 +2451 81 +2451 892 +2451 2345 +2451 3205 +2451 3442 +2451 3719 +2451 3735 +2451 4121 +2451 4122 +2451 4123 +3867 1297 +3867 1866 +3867 1867 +3867 2356 +3867 2376 +3867 3329 +3867 3615 +3867 4828 +3867 4971 +3867 4972 +2407 96 +2407 122 +2407 123 +2407 143 +2407 249 +2407 368 +2407 856 +2407 2001 +2407 2196 +2407 2563 +3699 195 +3699 1903 +3699 2479 +3699 2650 +3699 2768 +3699 3822 +3699 4180 +3699 4888 +3699 4889 +3699 4890 +923 451 +923 494 +923 685 +923 922 +923 924 +923 925 +923 926 +923 927 +923 928 +2900 177 +2900 303 +2900 1487 +2900 2751 +2900 3142 +2900 3179 +2900 3544 +2900 4384 +2900 4385 +2900 4386 +3703 459 +3703 1171 +3703 1822 +3703 3193 +3703 3204 +3703 3767 +3703 3778 +3703 4813 +3703 4893 +3705 276 +3705 552 +3705 995 +3705 1947 +3705 1972 +3705 2430 +3705 3594 +3705 4891 +3705 4892 +3714 1056 +44 45 +44 46 +44 47 +44 48 +44 49 +44 50 +44 51 +44 52 +44 53 +44 54 +49 101 +49 338 +49 2366 +49 2893 +49 3065 +49 3593 +49 3840 +49 3998 +49 3999 +101 143 +101 147 +101 249 +101 251 +101 264 +101 369 +101 422 +101 559 +101 718 +101 2018 +3998 255 +3998 1332 +3998 1730 +3998 1936 +3998 3213 +3998 3625 +3998 4704 +3998 5039 +3998 5040 +3998 5041 +422 1911 +422 2394 +422 2395 +422 2396 +422 2397 +422 2398 +422 2399 +422 2400 +422 2401 +422 2402 +3213 3 +3213 5 +3213 7 +3213 8 +3213 124 +3213 174 +3213 249 +3213 251 +3213 369 +3213 427 +5040 1010 +5040 2304 +5040 2392 +5040 2443 +5040 2853 +5040 3081 +5040 4507 +5040 5437 +5040 5612 +5040 5613 +55 56 +55 57 +55 58 +55 59 +55 60 +55 61 +55 62 +55 63 +55 64 +55 65 +61 907 +61 1922 +61 1992 +61 1993 +61 1994 +61 1995 +61 1996 +61 1997 +61 1998 +61 1999 +63 1364 +63 1950 +63 1977 +63 1978 +63 1979 +63 1980 +63 1981 +63 1982 +63 1983 +65 86 +65 1954 +65 2002 +65 2003 +65 2004 +65 2005 +65 2006 +65 2007 +65 2008 +65 2009 +1941 749 +1941 1362 +1941 2785 +1941 3136 +1941 3599 +1941 3708 +1941 3709 +1941 3710 +1941 3711 +1941 3712 +1942 2255 +1942 2272 +1942 2853 +1942 2932 +1942 3027 +1942 3718 +1942 3719 +1942 3720 +1942 3721 +1943 13 +1943 279 +1943 646 +1943 1887 +1943 2545 +1943 3256 +1943 3515 +1943 3715 +1943 3716 +1943 3717 +907 64 +907 1292 +907 1397 +907 2099 +907 2778 +907 2804 +907 2805 +907 2806 +907 2807 +907 2808 +1992 126 +1992 128 +1992 144 +1992 145 +1992 147 +1992 424 +1992 2018 +1992 2614 +1992 3466 +1992 3764 +1994 664 +1994 788 +1994 1022 +1994 1195 +1994 1371 +1994 1688 +1994 1762 +1994 1954 +1994 2001 +1994 2226 +1994 2255 +1994 2366 +1994 2377 +1994 2384 +1994 2490 +1994 2597 +1994 3429 +1994 3778 +1994 3779 +1994 3780 +1994 3781 +1994 3782 +1994 3783 +1994 3784 +1995 3767 +1996 909 +1996 1297 +1996 1535 +1996 1571 +1996 2201 +1996 2265 +1996 2942 +1996 3193 +1996 3765 +1996 3766 +1998 3770 +1999 209 +1999 924 +1999 1199 +1999 1297 +1999 1606 +1999 1608 +1999 1867 +1999 1868 +1999 3336 +1999 3769 +1198 338 +1198 1158 +1198 1382 +1198 1383 +1198 3059 +1198 3060 +1198 3061 +1198 3062 +1198 3063 +1198 3064 +1950 1528 +1950 2089 +1950 2462 +1950 2652 +1950 2931 +1981 451 +1981 1724 +1981 2255 +1981 2524 +1981 3758 +1981 3759 +1981 3760 +1981 3761 +1981 3762 +1981 3763 +1982 2086 +91 243 +91 1923 +91 2194 +102 1928 +102 1968 +102 2026 +102 2027 +102 2028 +1946 440 +1946 984 +1946 2486 +1946 2600 +1946 3058 +1946 3070 +1946 3310 +1946 3725 +1947 208 +1947 1934 +1947 2456 +1947 3419 +1947 3727 +1947 3728 +1947 3729 +1947 3730 +1947 3731 +1947 3732 +1948 121 +1948 126 +1948 128 +1948 144 +1948 145 +1948 148 +1948 265 +1948 368 +1948 559 +1948 1626 +1951 3113 +2003 442 +2003 494 +2003 918 +2003 1326 +2003 3230 +2003 3773 +2003 3774 +2003 3775 +2003 3776 +2003 3777 +1362 1026 +1362 1061 +1362 1348 +1362 1363 +1362 1364 +1362 1365 +1362 1366 +1362 1367 +1362 1368 +1362 1369 +3599 693 +3599 2916 +3599 3682 +3599 4852 +3599 4853 +3710 3335 +3710 3708 +3710 4959 +3027 29 +3027 38 +3027 576 +3027 1208 +3027 2018 +3027 2291 +3027 2396 +3027 4468 +3027 4469 +3027 4470 +3719 113 +3719 180 +3719 795 +3719 2186 +3719 2341 +3719 3523 +3719 3740 +3719 4884 +3719 4904 +3719 4905 +279 8 +279 280 +279 281 +279 282 +279 283 +279 284 +279 285 +279 286 +279 287 +279 288 +646 9 +646 126 +646 145 +646 147 +646 179 +646 252 +646 265 +646 368 +646 426 +3256 762 +3256 1361 +3256 2222 +3256 2753 +3256 3358 +3256 3467 +3256 4139 +3256 4636 +3256 4637 +3515 3 +3515 4 +3515 127 +3515 147 +3515 176 +3515 264 +3515 427 +3515 666 +3515 667 +3715 116 +3715 429 +3715 2287 +3715 4002 +3715 4476 +3715 4839 +3715 4894 +3715 4895 +3715 4896 +3715 4897 +3715 4898 +3716 977 +3716 3119 +3716 3301 +3716 3376 +3716 3890 +3716 4655 +3716 4900 +3716 4901 +3716 4902 +3716 4903 +151 152 +151 153 +151 154 +151 155 +151 156 +151 157 +151 158 +151 159 +151 160 +151 161 +178 255 +178 256 +178 554 +178 871 +178 1947 +178 2125 +178 2126 +178 2127 +178 2128 +178 2129 +1144 17 +1144 31 +1144 126 +1144 143 +1144 144 +1144 145 +1144 149 +1144 266 +1144 422 +1144 754 +1653 69 +1653 485 +1653 1246 +1653 1563 +1653 3403 +1292 3149 +1397 279 +1397 665 +1397 822 +1397 1143 +1397 1890 +1397 2160 +1397 2384 +1397 3194 +1397 3288 +1397 3289 +2778 3497 +2804 470 +2804 604 +2804 1325 +2804 1451 +2804 2422 +2804 2733 +2804 2768 +2804 3276 +2804 3772 +2804 4311 +2807 143 +2807 249 +2807 264 +2807 390 +2807 423 +2807 559 +2807 1842 +2807 4312 +2807 4313 +2807 4314 +2808 102 +2808 552 +2808 667 +2808 677 +2808 1056 +2808 1956 +2808 2719 +2808 4189 +2808 4316 +2808 4317 +2614 548 +2614 1165 +2614 1217 +2614 1342 +2614 1985 +2614 2018 +2614 2022 +2614 2343 +2614 2384 +2614 2465 +2614 3232 +2614 3385 +2614 3488 +2614 3903 +2614 4159 +2614 4212 +2614 4213 +2614 4214 +2614 4215 +2614 4216 +2614 4217 +2614 4218 +2377 227 +2377 432 +2377 500 +2377 561 +2377 2392 +2377 2646 +2377 2798 +2377 3172 +2377 4063 +2377 4064 +2384 187 +2384 503 +2384 1797 +2384 2350 +2384 2420 +2384 2563 +2384 4069 +2384 4070 +2384 4071 +2490 3 +2490 147 +2490 176 +2490 251 +2490 264 +2490 367 +2490 427 +2490 559 +2490 718 +2490 2018 +2597 21 +2597 352 +2597 476 +2597 505 +2597 621 +2597 1347 +2597 2964 +2597 3607 +2597 3687 +2597 3871 +3429 1447 +3429 2292 +3429 2413 +3429 2918 +3429 4020 +3781 327 +3781 1059 +3781 1086 +3781 1123 +3781 2519 +3781 3850 +3781 4031 +3781 4923 +3781 4924 +3781 4925 +3767 863 +3767 864 +3767 1239 +3767 1339 +3767 1711 +3767 2254 +3767 3299 +3767 4846 +3767 4920 +3767 4921 +909 124 +909 127 +909 175 +909 180 +909 251 +909 367 +909 368 +909 390 +909 718 +1297 289 +1297 435 +1297 753 +1297 901 +1297 1199 +1297 1504 +1297 1763 +1297 1764 +1297 1765 +1297 1766 +1535 261 +1535 694 +1535 1608 +1535 1631 +1535 1940 +1535 2179 +1535 2724 +1535 3334 +1535 3335 +1535 3336 +3193 1983 +3765 921 +3765 4586 +3765 4796 +3765 4918 +3765 4919 +209 976 +209 1903 +209 1940 +209 2103 +209 2429 +209 2430 +209 2431 +209 2432 +924 5 +924 7 +924 122 +924 123 +924 149 +924 176 +924 179 +924 249 +924 264 +924 717 +1867 665 +1867 810 +1867 1607 +1867 1849 +1867 2105 +1867 2787 +1867 3615 +1867 3616 +1867 3617 +1867 3618 +1868 146 +1868 148 +1868 149 +1868 174 +1868 251 +1868 252 +1868 367 +1868 390 +1868 718 +1868 1317 +1158 552 +1158 1017 +1158 1316 +1158 2146 +1158 2844 +1158 3039 +1158 3040 +1158 3041 +1158 3042 +1158 3043 +1382 130 +1382 208 +1382 476 +1382 849 +1382 874 +1382 1022 +1382 1384 +1382 1411 +1382 1671 +1382 1955 +1382 2226 +1382 2414 +1382 2612 +1382 2658 +1382 2819 +1382 3335 +1382 3552 +1382 4132 +1382 4170 +1382 4825 +1382 5241 +1382 5428 +1382 5487 +1382 5494 +1382 5717 +1382 5785 +1382 5786 +1382 5787 +1382 5788 +3059 7 +3059 8 +3059 123 +3059 129 +3059 144 +3059 149 +3059 174 +3059 248 +3059 367 +3059 717 +3060 92 +3060 268 +3060 393 +3060 1720 +3060 2114 +3060 2451 +3060 2500 +3060 3609 +3060 3959 +3060 4295 +3061 4 +3061 126 +3061 144 +3061 689 +3061 4428 +3061 4451 +3061 4486 +3061 4487 +3061 4488 +3063 707 +3063 926 +3063 3016 +3063 3570 +3063 4492 +1724 493 +1724 837 +1724 1677 +1724 1726 +1724 2038 +1724 3275 +1724 3487 +1724 3488 +1724 3489 +1724 3490 +3759 1217 +1968 476 +1968 955 +1968 1054 +1968 1773 +1968 2625 +1968 3733 +1968 3734 +1968 3735 +1968 3736 +440 261 +440 1607 +440 1868 +440 2312 +440 2399 +440 2492 +440 2784 +440 3617 +440 4781 +440 5476 +984 257 +984 440 +984 859 +984 985 +984 986 +984 987 +984 988 +984 989 +984 990 +984 991 +2486 133 +2486 309 +2486 478 +2486 691 +2486 1019 +2486 1235 +2486 1317 +2486 2196 +2486 4127 +2486 4128 +3058 122 +3058 124 +3058 143 +3058 247 +3058 252 +3058 264 +3058 367 +3058 369 +3058 559 +208 209 +208 210 +208 211 +208 212 +208 213 +208 214 +208 215 +208 216 +208 217 +2456 942 +3728 73 +3728 2923 +3728 3495 +3728 4908 +3728 4909 +3732 1454 +3732 1509 +3732 1568 +3732 1946 +3732 2276 +3732 5688 +3732 5796 +3732 5823 +3732 6138 +1626 340 +1626 637 +1626 860 +1626 2075 +1626 2410 +1626 2570 +1626 3110 +1626 3379 +1626 3380 +1626 3381 +494 658 +494 892 +494 924 +494 1372 +494 1787 +494 2475 +494 2476 +494 2477 +494 2478 +494 2479 +1326 335 +1326 2722 +1326 3192 +1326 3193 +1326 3194 +3776 77 +3776 262 +3776 492 +3776 1975 +3776 3343 +3776 3681 +3776 4266 +3776 4587 +3776 4664 +3776 4922 +66 16 +66 67 +66 68 +66 69 +66 70 +66 71 +66 72 +66 73 +66 74 +66 75 +67 472 +67 534 +67 762 +67 1123 +67 2222 +67 2789 +67 3052 +67 3332 +67 3769 +67 3956 +68 152 +68 219 +68 346 +68 965 +68 1953 +68 1954 +68 1955 +68 1956 +68 1957 +68 1958 +73 717 +73 1022 +73 1969 +73 1970 +73 1971 +73 1972 +73 1973 +73 1974 +73 1975 +73 1976 +75 190 +75 219 +75 262 +75 1142 +75 1337 +75 1964 +75 1965 +75 1966 +75 1967 +75 1968 +472 347 +472 1267 +472 1485 +472 1486 +472 1487 +472 1488 +472 1489 +472 1490 +472 1491 +472 1492 +3956 1030 +3956 2254 +3956 3822 +3956 5016 +3956 5017 +346 238 +346 343 +346 1018 +346 2301 +346 2302 +346 2303 +346 2304 +346 2305 +346 2306 +346 2307 +965 583 +965 1208 +965 1390 +965 1728 +965 2871 +965 2872 +965 2873 +965 2874 +965 2875 +965 2876 +1958 58 +1958 172 +1958 582 +1958 583 +1958 1250 +1958 1541 +1958 2394 +1958 2758 +1958 3159 +1958 3726 +1971 769 +1971 774 +1971 1127 +1971 1341 +1971 2847 +1971 3737 +1971 3738 +1971 3739 +1971 3740 +1971 3741 +1972 170 +1972 252 +1972 1615 +1972 2279 +1972 3563 +1972 3749 +1972 3750 +1972 3751 +1972 3752 +1972 3753 +1973 155 +1973 520 +1973 2020 +1973 2222 +1973 2889 +1973 3220 +1973 3595 +1973 3742 +1973 3743 +1974 694 +1974 1590 +1974 2368 +1974 3050 +1974 3530 +1974 3744 +1974 3745 +1974 3746 +1974 3747 +1974 3748 +1337 38 +1337 143 +1337 266 +1337 693 +1337 911 +1337 1221 +1337 1724 +1337 1725 +1337 1726 +1337 1727 +1267 251 +1267 459 +1267 1268 +1267 1269 +1267 1270 +1267 1271 +1267 1272 +1267 1273 +1267 1274 +1485 8 +1485 9 +1485 121 +1485 125 +1485 128 +1485 129 +1485 144 +1485 352 +1485 427 +1485 1246 +1487 3 +1487 127 +1487 177 +1487 183 +1487 247 +1487 249 +1487 367 +1487 427 +1487 718 +1487 2338 +3822 78 +3822 886 +3822 1423 +3822 2642 +3822 2982 +3822 3779 +3822 4623 +3822 4746 +3822 4939 +5016 133 +5016 241 +5016 582 +5016 965 +5016 1316 +5016 1541 +5016 1882 +5016 2090 +5016 5178 +5016 5601 +343 122 +343 127 +343 176 +343 249 +343 251 +343 558 +343 666 +343 667 +343 754 +343 1245 +2304 1327 +2304 1347 +2304 2189 +1390 313 +1390 387 +1390 1942 +1390 2322 +1390 2904 +1390 3230 +1390 3231 +1390 3232 +1390 3233 +1390 3234 +2871 13 +2871 554 +2871 1756 +2871 3247 +2871 3485 +2871 3489 +2871 3959 +2871 4342 +2871 4343 +2873 3 +2873 124 +2873 143 +2873 176 +2873 248 +2873 264 +2873 352 +2873 367 +2873 369 +2873 856 +2875 141 +2875 396 +2875 848 +2875 2313 +2875 3327 +2875 3894 +2875 4051 +2875 4357 +2875 4358 +2875 4359 +172 127 +172 128 +172 129 +172 145 +172 174 +172 177 +172 247 +172 353 +172 1246 +172 1317 +582 412 +582 715 +582 1068 +582 1541 +582 1854 +582 2354 +582 2414 +582 2535 +582 2536 +582 2537 +1250 193 +1250 308 +1250 878 +1250 935 +1250 1415 +1250 1524 +1250 2157 +1250 2179 +1250 3112 +1250 3113 +1541 3 +1541 122 +1541 325 +1541 548 +1541 679 +1541 1245 +1541 2039 +1541 3096 +1541 3323 +1541 3347 +3726 30 +3726 152 +3726 1917 +3726 2186 +3726 2646 +3726 2922 +3726 3259 +3726 3411 +3726 4913 +3726 4914 +3179 282 +3179 303 +3179 728 +3179 822 +3179 1143 +3179 1505 +3179 2528 +3179 2885 +3179 3769 +3179 4075 +3519 648 +3519 895 +3519 1227 +3519 4872 +3519 4883 +3549 190 +3549 227 +3549 260 +3549 412 +3549 637 +3549 979 +3549 1689 +3549 1702 +3549 2984 +3549 3136 +3757 123 +3757 127 +3757 147 +3757 249 +3757 251 +3757 368 +3757 423 +3757 718 +3757 1245 +769 1024 +769 1335 +769 2547 +769 2579 +769 2670 +769 2700 +769 2701 +769 2702 +769 2703 +769 2704 +1341 63 +1341 435 +1341 740 +1341 1754 +1341 2125 +1341 2217 +1341 2524 +1341 2740 +1341 3204 +1341 3205 +2847 244 +2847 498 +2847 510 +2847 527 +2847 747 +2847 1817 +2847 2535 +2847 3912 +2847 4335 +2847 4336 +3737 660 +3738 587 +3738 1216 +3738 1424 +3738 1792 +3738 2010 +3738 3084 +3738 4788 +3738 4915 +3738 4916 +2279 401 +2279 1273 +2279 1337 +2279 1587 +2279 1797 +2279 3397 +2279 3964 +2279 3965 +2279 3966 +2279 3967 +155 5 +155 121 +155 126 +155 128 +155 129 +155 175 +155 238 +155 353 +155 1317 +2020 5 +2020 126 +2020 144 +2020 145 +2020 149 +2020 176 +2020 247 +2020 249 +2020 251 +2020 352 +3742 979 +3742 1730 +3742 2204 +3742 2215 +3742 2556 +3742 3020 +3742 3523 +3742 4285 +3742 4408 +3742 4411 +694 174 +694 175 +694 265 +694 351 +694 695 +694 696 +694 697 +694 698 +694 699 +694 700 +1590 710 +1590 894 +1590 1179 +1590 1688 +1590 1886 +1590 2643 +1590 3104 +1590 3369 +1590 3370 +3744 3149 +3747 496 +3747 621 +3747 678 +3747 2875 +3747 2973 +3747 3993 +3747 4641 +3747 4877 +3747 4917 +693 1628 +693 2602 +693 2603 +693 2604 +693 2605 +693 2606 +693 2607 +693 2608 +693 2609 +693 2610 +955 690 +955 711 +955 781 +955 908 +955 1337 +955 1541 +955 1901 +955 2214 +955 2422 +955 2428 +955 2805 +955 2837 +955 2838 +955 2839 +955 2840 +955 2841 +955 2842 +955 2843 +3733 118 +3733 241 +3733 1086 +3733 2119 +3733 2364 +3733 2502 +3733 3260 +3733 4910 +3733 4911 +3733 4912 +3734 5 +3734 125 +3734 145 +3734 179 +3734 390 +3734 422 +3734 424 +3734 558 +3734 667 +3734 856 +76 77 +76 78 +76 79 +76 80 +76 81 +76 82 +76 83 +76 84 +76 85 +76 86 +80 2014 +81 1067 +81 1916 +81 1984 +81 1985 +81 1986 +81 1987 +81 1988 +81 1989 +81 1990 +81 1991 +83 7 +83 8 +83 9 +83 148 +83 351 +83 426 +83 762 +83 946 +83 2000 +83 2001 +2205 938 +2205 1608 +2205 1849 +2205 3109 +2205 4080 +2205 5310 +2205 5724 +2205 6000 +2205 6001 +2014 21 +2014 2304 +2014 3038 +2014 3052 +2014 3377 +2014 3574 +2014 3790 +2014 3791 +2014 3792 +2014 3793 +1984 255 +1984 361 +1984 2113 +1984 2721 +1984 3554 +1986 1103 +1987 227 +1987 2292 +1987 2528 +1987 2914 +1987 3709 +1987 5541 +1987 5584 +1987 5795 +1987 5796 +1987 5797 +1988 3768 +1989 848 +1989 1792 +1989 1845 +1989 2354 +1989 5177 +5724 3 +5724 7 +5724 122 +5724 123 +5724 124 +5724 125 +5724 145 +5724 177 +5724 352 +5724 427 +3038 308 +3038 1001 +3038 1239 +3038 1766 +3038 2490 +3038 3516 +3038 3564 +3038 3781 +3038 4471 +3038 4472 +3790 256 +3790 413 +3790 459 +3790 1305 +3790 1940 +3790 2113 +3790 2841 +3790 3288 +3790 4160 +3790 4581 +3791 174 +3791 823 +3791 2032 +3791 2971 +3791 3185 +3791 4419 +3791 4526 +3791 4894 +3791 4928 +3791 4929 +2721 959 +2721 1526 +2721 2341 +2721 2397 +2721 2524 +2721 3215 +2721 3441 +2721 3695 +2721 4290 +2292 298 +2292 667 +2292 1044 +2292 1259 +2292 1762 +2292 2497 +2292 3329 +2292 3982 +2292 3983 +2292 3984 +1792 1001 +1792 1203 +1792 2377 +1792 3000 +1792 3104 +1792 3536 +1792 3537 +1792 3538 +1792 3539 +1792 3540 +5177 1438 +5177 3109 +5177 4930 +5177 5681 +5177 5682 +5177 5683 +5177 5684 +5177 5685 +5177 5686 +5177 5687 +355 49 +355 117 +355 968 +355 2308 +355 2309 +355 2310 +355 2311 +355 2312 +355 2313 +355 2314 +356 572 +356 980 +356 1212 +356 2321 +356 2322 +356 2323 +356 2324 +356 2325 +356 2326 +356 2327 +359 520 +359 633 +359 1334 +359 1451 +359 2332 +359 2333 +359 2334 +359 2335 +359 2336 +359 2337 +253 219 +253 254 +253 255 +253 256 +253 257 +253 258 +253 259 +253 260 +253 261 +253 262 +2281 344 +2281 930 +2281 1744 +2281 2275 +2281 2292 +2281 2498 +2281 3296 +2281 3569 +2281 3962 +2281 3963 +3771 184 +3771 215 +3771 286 +3771 1979 +3771 2748 +3771 4301 +3771 4840 +3771 4926 +3771 4927 +3771 4928 +3772 2414 +87 88 +87 89 +87 90 +87 91 +87 92 +87 93 +87 94 +87 95 +87 96 +87 97 +89 211 +89 914 +89 1476 +89 1776 +89 1906 +89 1976 +89 2010 +89 2011 +89 2012 +89 2013 +211 494 +211 621 +211 1358 +211 1412 +211 2161 +211 2162 +211 2163 +211 2164 +211 2165 +211 2166 +1476 686 +1476 1390 +1476 3017 +1476 3077 +1476 3317 +1476 3318 +1476 3319 +1476 3320 +1476 3321 +1476 3322 +2164 57 +2164 453 +2164 851 +2164 1049 +2164 2423 +2164 2648 +2164 2669 +2164 2906 +2164 3468 +2164 3906 +686 1162 +686 1309 +686 1573 +686 1958 +686 2587 +686 2588 +686 2589 +686 2590 +686 2591 +686 2592 +3077 3 +3077 127 +3077 147 +3077 264 +3077 352 +3077 368 +3077 390 +3077 423 +3077 427 +3077 1245 +3317 4678 +3321 1913 +3321 1926 +3321 2433 +3321 4014 +3321 4675 +1564 3 +1564 127 +1564 144 +1564 146 +1564 149 +1564 176 +1564 177 +1564 238 +1564 247 +1564 367 +2195 244 +2195 1087 +2195 2697 +2195 2981 +2195 3205 +2195 3319 +2195 3916 +2195 3917 +2195 3918 +98 99 +98 100 +98 101 +98 102 +98 103 +98 104 +98 105 +98 106 +98 107 +98 108 +100 2017 +104 2025 +105 363 +105 820 +105 1041 +105 1240 +105 2019 +105 2020 +105 2021 +105 2022 +105 2023 +105 2024 +108 324 +108 365 +108 1486 +108 2037 +108 2038 +108 2039 +108 2040 +108 2041 +108 2042 +108 2043 +2017 96 +2017 1914 +2017 2750 +2017 2794 +2017 3713 +2017 3807 +2017 3808 +2017 3809 +2017 3810 +2017 3811 +820 3 +820 5 +820 7 +820 125 +820 126 +820 128 +820 145 +820 369 +820 424 +820 1317 +1041 69 +1041 529 +1041 621 +1041 789 +1041 1042 +1041 1043 +1041 1044 +1041 1045 +1041 1046 +1041 1047 +2022 2344 +2023 38 +2023 281 +2023 369 +2023 2152 +2023 2728 +2023 3487 +2023 3489 +2023 3595 +2023 3797 +2023 3798 +2024 29 +2024 53 +2024 56 +2024 1034 +2024 1230 +2024 1556 +2024 3489 +2024 3794 +2024 3795 +2024 3796 +324 568 +2037 148 +2037 176 +2037 179 +2037 238 +2037 265 +2037 369 +2037 424 +2037 426 +2037 1317 +2037 2098 +2038 266 +2038 390 +2038 422 +2038 423 +2038 559 +2038 736 +2038 754 +2038 856 +2038 886 +2038 2018 +2039 348 +2039 1033 +2039 3465 +2039 4438 +2039 5170 +2039 5171 +2039 5172 +2039 5173 +2039 5174 +2039 5175 +2043 125 +2043 191 +2043 449 +2043 2621 +2043 3010 +2043 3817 +2043 3818 +2043 3819 +2043 3820 +2043 3821 +2794 513 +2794 1042 +2794 1509 +2794 2001 +2794 2292 +2794 2615 +2794 3215 +2794 3907 +2794 4306 +3810 1471 +3810 1591 +3810 2037 +3810 2038 +3810 2625 +3810 3822 +3810 4213 +3810 4932 +3810 4933 +2396 20 +2396 1162 +2396 1670 +2396 2173 +2396 3059 +2396 4004 +2396 4082 +2396 4083 +2396 4084 +2398 2792 +2398 3019 +2398 3721 +2398 3813 +2398 4087 +2399 59 +2399 730 +2399 1904 +2399 2395 +2399 2398 +2399 2551 +2399 3328 +2399 3921 +2399 4085 +2399 4086 +756 127 +756 262 +756 531 +756 757 +756 758 +756 759 +756 760 +756 761 +756 762 +756 763 +759 77 +759 464 +759 568 +759 1454 +759 2707 +759 2708 +759 2709 +759 2710 +759 2711 +759 2712 +821 32 +821 928 +821 1223 +821 1224 +821 1231 +821 1873 +821 2734 +821 2735 +821 2736 +821 2737 +823 563 +823 894 +823 1264 +823 1322 +823 1323 +823 1324 +823 1325 +823 1326 +823 1327 +823 1328 +1043 3146 +1043 4264 +1046 3 +1046 17 +1046 31 +1046 146 +1046 147 +1046 175 +1046 250 +1046 368 +1046 1245 +2728 121 +2728 129 +2728 174 +2728 183 +2728 238 +2728 353 +2728 424 +2728 427 +2728 717 +2728 2338 +3797 788 +3797 1954 +3797 2127 +3797 3017 +3797 3600 +3797 5089 +3797 5891 +3797 5892 +3797 5893 +3797 5894 +3798 1313 +3798 2375 +3798 2378 +3798 2612 +3798 3211 +3798 3479 +3798 3563 +3798 4209 +3798 4534 +3798 4931 +1230 586 +1230 862 +1230 1061 +1230 1900 +1230 1923 +1230 2723 +1230 3670 +1230 4540 +3796 110 +3796 563 +3796 884 +3796 1313 +3796 2170 +3796 2216 +3796 3269 +3796 4930 +736 443 +736 737 +736 738 +736 739 +736 740 +736 741 +736 742 +736 743 +736 744 +736 745 +886 329 +886 887 +886 888 +886 889 +886 890 +886 891 +886 892 +886 893 +886 894 +886 895 +348 751 +348 930 +348 1322 +348 1364 +348 1366 +348 2004 +348 2292 +348 2293 +348 2294 +348 2295 +1033 281 +1033 554 +1033 659 +1033 1034 +1033 1035 +1033 1036 +1033 1037 +1033 1038 +1033 1039 +1033 1040 +4438 631 +4438 769 +4438 812 +4438 1317 +4438 1374 +4438 2906 +4438 3617 +4438 3635 +4438 4873 +4438 5275 +5171 795 +5171 1180 +5171 1338 +5171 2348 +5171 3453 +5171 3801 +5171 5642 +5171 5675 +5171 5676 +5171 5677 +5175 804 +5175 1770 +5175 2004 +5175 2214 +5175 3109 +5175 3596 +5175 3846 +5175 4912 +5175 5633 +5175 5638 +191 77 +191 2190 +191 2365 +191 2366 +191 2367 +191 2368 +191 2369 +191 2370 +191 2371 +191 2372 +449 4 +449 126 +449 129 +449 145 +449 147 +449 238 +449 266 +449 368 +449 1246 +2621 4 +2621 146 +2621 368 +2621 390 +2621 422 +2621 423 +2621 856 +2621 1245 +2621 1317 +2621 2001 +3010 31 +3010 709 +3010 845 +3010 1544 +3010 3056 +3010 4425 +3010 4449 +3010 4450 +3010 4451 +3010 4452 +3817 909 +3818 953 +3818 1021 +3818 1392 +3818 1798 +3818 2035 +3818 2285 +3818 4103 +3818 4936 +3818 4937 +3818 4938 +3819 432 +3819 514 +3819 730 +3819 1441 +3819 1538 +3819 2785 +3819 3249 +3819 3916 +3819 4484 +3819 4520 +3820 3 +3820 8 +3820 122 +3820 127 +3820 129 +3820 143 +3820 146 +3820 147 +3820 369 +3820 1245 +109 110 +109 111 +109 112 +109 113 +109 114 +109 115 +109 116 +109 117 +109 118 +109 119 +110 1332 +110 1361 +110 2029 +110 2030 +110 2031 +110 2032 +110 2033 +110 2034 +110 2035 +110 2036 +111 1419 +111 1561 +111 1670 +111 1787 +111 1846 +111 2065 +111 2066 +111 2067 +111 2068 +111 2069 +113 17 +113 143 +113 144 +113 145 +113 179 +113 368 +113 424 +113 754 +113 1317 +113 2018 +116 510 +116 1089 +116 2013 +116 2030 +116 2051 +116 2052 +116 2053 +116 2054 +116 2055 +116 2056 +1361 62 +1361 706 +1361 710 +1361 1814 +1361 2209 +1361 3237 +1361 3238 +1361 3239 +1361 3240 +1361 3241 +2032 3 +2032 121 +2032 125 +2032 179 +2032 249 +2032 251 +2032 264 +2032 423 +2032 427 +2032 717 +1419 740 +1419 1085 +1419 1131 +1419 1271 +1419 1420 +1419 1421 +1419 1422 +1419 1423 +1419 1424 +1419 1425 +1561 122 +1561 127 +1561 129 +1561 176 +1561 177 +1561 238 +1561 251 +1561 352 +1561 353 +1561 1245 +1670 113 +1670 473 +1670 1049 +1670 1321 +1670 1540 +1670 2298 +1670 2896 +1670 3014 +1670 3166 +1670 3572 +2065 585 +2066 4 +2066 17 +2066 144 +2066 145 +2066 148 +2066 149 +2066 179 +2066 424 +2066 559 +2066 856 +2068 119 +2068 1240 +2068 1415 +2068 1709 +2068 2664 +2068 3741 +2068 3879 +2069 347 +2069 1840 +2069 2051 +2069 2658 +2069 3357 +2069 3463 +2069 3637 +2069 3988 +2069 3989 +2069 3990 +2046 7 +2046 9 +2046 122 +2046 127 +2046 145 +2046 248 +2046 249 +2046 251 +2046 353 +2046 369 +2047 5 +2047 145 +2047 149 +2047 175 +2047 177 +2047 180 +2047 266 +2047 353 +2047 424 +2047 1246 +2049 740 +2049 1299 +2049 2684 +2049 2768 +2049 2903 +2049 3004 +2049 3039 +2049 3814 +2049 3815 +2049 3816 +2050 136 +2050 458 +2050 1414 +2050 1661 +2050 1747 +2050 2630 +2050 3822 +2050 3823 +2050 3824 +2050 3825 +1089 96 +1089 727 +1089 944 +1089 1313 +1089 2523 +1089 2872 +1089 3109 +2052 7 +2052 143 +2052 145 +2052 367 +2052 390 +2052 558 +2052 856 +2052 1040 +2052 1245 +2053 252 +2053 368 +2053 369 +2053 390 +2053 423 +2053 1208 +2053 2621 +2053 3675 +2053 3826 +2053 3827 +2055 31 +2055 489 +2055 2065 +2055 3290 +2055 3828 +2055 3829 +2055 3830 +2055 3831 +2055 3832 +2055 3833 +2056 10 +2056 127 +2056 145 +2056 175 +2056 176 +2056 247 +2056 353 +2056 369 +2056 629 +2056 993 +706 3501 +706 4623 +706 4624 +1814 442 +1814 1328 +1814 1817 +1814 2193 +1814 3204 +1814 3546 +1814 3547 +1814 3548 +1814 3549 +1814 3550 +740 124 +740 174 +740 1255 +740 1487 +740 1531 +740 1557 +740 1609 +740 2385 +740 2663 +740 4539 +1424 200 +1424 621 +1424 2261 +1424 2858 +1424 3282 +1424 3283 +1424 3284 +1424 3285 +1424 3286 +1424 3287 +473 1193 +473 1509 +473 3205 +473 3309 +473 4207 +473 4282 +473 4828 +473 4829 +473 4830 +1540 111 +1540 676 +1540 1023 +1540 1050 +1540 1167 +1540 1541 +1540 1542 +1540 1543 +1540 1544 +1540 1545 +3014 274 +3014 937 +3014 1016 +3014 1305 +3014 1503 +3014 1608 +3014 1800 +3014 1947 +3014 3706 +3014 4458 +3700 803 +3700 1050 +3700 1317 +3700 1396 +3700 1437 +3700 1481 +3700 2054 +3700 2114 +3700 4017 +3700 4899 +1415 17 +1415 455 +1415 747 +1415 2119 +1415 2311 +1415 2897 +1415 2975 +1415 3271 +1415 3272 +1415 3273 +1709 248 +1709 587 +1709 1306 +1709 1476 +1709 1509 +1709 1591 +1709 2291 +1709 2429 +1709 3007 +1709 3459 +3988 712 +3988 2209 +3988 2391 +3988 2523 +3988 3119 +3988 3362 +3988 4838 +3988 5024 +3988 5025 +3989 2705 +3989 3908 +3989 4103 +3989 4677 +3989 5028 +2852 159 +2852 288 +2852 422 +2852 554 +2852 576 +2852 837 +2852 1199 +2852 1429 +2852 1583 +2852 1591 +2852 1980 +2852 2547 +2852 2918 +2852 3105 +2852 3139 +2852 3921 +2852 4344 +2852 4345 +2852 4346 +2852 4347 +2852 4348 +2852 4349 +2852 4350 +2852 4351 +2852 4352 +2852 4353 +2852 4354 +2852 4355 +3149 1258 +3149 2007 +3149 2039 +3149 2067 +3149 2197 +3149 2218 +3149 2888 +3149 4380 +3149 4549 +3149 4550 +3813 491 +3813 637 +3813 1150 +3813 1338 +3813 1540 +3813 1947 +3813 4789 +3813 4895 +3813 4934 +3813 4935 +2903 117 +2903 380 +2903 716 +2903 1043 +2903 1706 +2903 1780 +2903 2761 +2903 3146 +2903 4387 +2903 4388 +3004 1900 +3004 1983 +3004 3463 +3004 4584 +3039 584 +3039 4599 +3815 178 +3815 1377 +3815 1614 +3815 2200 +3815 2901 +3815 3217 +3815 3225 +3815 3619 +3815 4207 +3815 4733 +136 57 +136 470 +136 852 +136 2480 +136 2984 +136 3219 +136 4463 +136 4944 +136 4945 +458 459 +458 460 +458 461 +458 462 +458 463 +458 464 +458 465 +458 466 +458 467 +458 468 +1414 9 +1414 17 +1414 31 +1414 126 +1414 180 +1414 266 +1414 424 +1414 666 +1414 697 +1414 2018 +3823 1085 +3823 1089 +3823 1794 +3823 1888 +3823 2625 +3823 3829 +3823 4940 +3823 4941 +3823 4942 +3823 4943 +3824 3149 +1534 303 +1534 424 +1534 771 +1534 804 +1534 1457 +1534 2288 +1534 3170 +1534 3282 +1534 4172 +1534 4301 +1534 4359 +1534 4793 +1534 4818 +1534 4891 +1534 5414 +1534 5895 +1534 5916 +1534 6061 +1534 6062 +2362 327 +2362 684 +2362 1954 +2362 2360 +2362 2666 +2362 4045 +2362 4046 +2362 4047 +2362 4048 +2362 4049 +3163 1021 +3163 2048 +3163 2476 +3163 2787 +3163 3617 +3163 4291 +3163 4566 +3163 4567 +3163 4568 +727 152 +2523 257 +2523 469 +2523 586 +2523 693 +2523 1356 +2523 1454 +2523 2500 +2523 3995 +2523 4158 +2523 4159 +558 7 +558 17 +558 122 +558 144 +558 146 +558 250 +558 353 +558 698 +558 5570 +558 5571 +1040 1023 +1040 1055 +1040 2254 +1040 2962 +1040 2963 +1040 2964 +1040 2965 +1040 2966 +1040 2967 +489 224 +489 490 +489 491 +489 492 +489 493 +489 494 +489 495 +489 496 +489 497 +489 498 +3831 33 +3831 1729 +3831 2357 +3831 3258 +3831 3259 +3831 4072 +3831 4363 +3831 4655 +3831 4946 +3831 4947 +3833 414 +3833 1168 +3833 1415 +3833 2257 +3833 4037 +3833 4948 +3833 4949 +3833 4950 +3833 4951 +3833 4952 +629 323 +629 336 +629 1067 +629 1426 +629 1427 +629 1428 +629 1429 +629 1430 +629 1431 +629 1432 +120 3 +120 121 +120 122 +120 123 +120 124 +120 125 +120 126 +120 127 +120 128 +120 129 +2060 3551 +132 5 +132 9 +132 147 +132 250 +132 353 +132 629 +132 753 +132 856 +132 1317 +132 2077 +2070 45 +2070 658 +2070 1425 +2070 2167 +2070 2595 +2070 2966 +2070 3834 +2070 3835 +2070 3836 +2070 3837 +2075 219 +2075 668 +2075 1575 +2075 1647 +2075 1786 +2075 1913 +2075 2229 +2075 2418 +2075 3586 +2075 3838 +3551 3 +3551 122 +3551 125 +3551 126 +3551 144 +3551 145 +3551 174 +3551 248 +3551 264 +3551 367 +285 134 +285 311 +285 712 +285 873 +285 955 +285 1197 +285 1227 +285 2218 +285 2219 +285 2243 +3337 32 +3337 1018 +3337 1061 +3337 1675 +3337 2723 +3337 3617 +3337 4286 +3337 4679 +3337 4680 +3337 4681 +5048 5566 +5338 4 +5338 122 +5338 143 +5338 180 +5338 252 +5338 266 +5338 368 +5338 369 +5338 427 +5338 754 +5940 376 +5941 110 +5941 858 +5941 1169 +5941 1509 +5941 2111 +5941 3249 +5941 5978 +5941 6073 +5941 6074 +5941 6075 +391 122 +391 124 +391 146 +391 248 +391 353 +391 422 +391 427 +391 717 +391 718 +391 2338 +392 814 +392 944 +392 1846 +392 2381 +392 2382 +392 2383 +392 2384 +392 2385 +392 2386 +392 2387 +398 176 +398 977 +398 1947 +398 2374 +398 2375 +398 2376 +398 2377 +398 2378 +398 2379 +398 2380 +668 669 +668 670 +668 671 +668 672 +668 673 +668 674 +668 675 +668 676 +668 677 +668 678 +1647 5 +1647 147 +1647 149 +1647 175 +1647 252 +1647 667 +1647 856 +1647 1245 +1647 2018 +3838 606 +3838 814 +3838 1701 +3838 2285 +3838 3371 +3838 4132 +3838 4954 +3838 4955 +3838 4956 +3838 4957 +3066 816 +3066 926 +3066 1568 +3066 1671 +3066 4640 +3066 4714 +3066 5001 +3066 5403 +3066 5404 +3066 5405 +3344 455 +3344 1317 +3344 3894 +3344 4688 +3344 4689 +3849 8 +3849 123 +3849 129 +3849 174 +3849 248 +3849 352 +3849 369 +3849 424 +3849 1317 +3849 2338 +4539 1651 +4539 2166 +4539 3352 +4539 3781 +4539 4553 +4539 5068 +4539 5085 +4539 5572 +4539 5868 +4539 5884 +1193 5 +1193 250 +1193 265 +1193 4711 +1193 5518 +1193 5519 +1193 5520 +1531 125 +1531 1257 +1531 1532 +1531 1533 +1531 1534 +1531 1535 +1531 1536 +1531 1537 +1531 1538 +1531 1539 +2084 3 +2084 8 +2084 128 +2084 176 +2084 238 +2084 247 +2084 266 +2084 390 +2084 424 +2084 856 +2087 30 +2087 364 +2087 1034 +2087 2681 +2087 3350 +2087 3376 +2087 3847 +2087 3848 +2087 3849 +2087 3850 +2088 131 +2088 267 +2088 532 +2088 1431 +2088 2066 +2088 2819 +2088 2966 +2088 3280 +2088 3516 +2088 3846 +198 412 +198 604 +198 870 +198 1466 +198 1556 +198 2147 +198 2148 +198 2149 +198 2150 +198 2151 +1333 386 +1333 604 +1333 837 +1333 2011 +1333 2093 +1333 2776 +1333 2871 +1333 3175 +1333 3176 +1333 3177 +1850 21 +1850 191 +1850 585 +1850 2041 +1850 3039 +1850 3595 +1850 3596 +1850 3597 +1850 3598 +1850 3599 +2114 979 +2114 1569 +2114 1581 +2114 1637 +2114 1770 +2114 1873 +2114 2409 +2114 2449 +2114 2547 +2114 3779 +3228 294 +3228 1511 +3228 2024 +3228 2677 +3228 2935 +3228 2936 +3228 3908 +3228 4614 +3228 4615 +3228 4616 +3851 850 +2424 8 +2424 63 +2424 1691 +2424 1901 +2424 1956 +2424 2231 +2424 2838 +2424 2842 +2653 2403 +2653 2764 +2653 2973 +2653 3576 +2653 4237 +2653 4426 +2653 5289 +2653 5417 +2653 5418 +3448 123 +3448 127 +3448 129 +3448 143 +3448 146 +3448 176 +3448 247 +3448 249 +3448 352 +3448 717 +3839 4063 +130 131 +130 132 +130 133 +130 134 +130 135 +130 136 +130 137 +130 138 +130 139 +130 140 +131 93 +131 1466 +131 1831 +131 1994 +131 2092 +131 2093 +131 2094 +131 2095 +131 2096 +131 2097 +135 34 +135 132 +135 786 +135 1150 +135 1274 +135 2099 +135 2100 +135 2101 +135 2102 +135 2103 +137 1728 +138 23 +138 446 +138 842 +138 1096 +138 1598 +138 1752 +138 2089 +138 2090 +138 2091 +1466 132 +1466 214 +1466 451 +1466 1162 +1466 2013 +1466 2524 +1466 3313 +1466 3314 +1466 3315 +1466 3316 +1831 3568 +2092 133 +2092 266 +2092 666 +2092 1531 +2092 1866 +2092 3124 +2092 3855 +2092 3856 +2092 3857 +2092 3858 +2093 427 +2093 484 +2093 958 +2093 1426 +2093 1529 +2093 1688 +2093 2244 +2093 3046 +2093 3769 +2093 3863 +2094 629 +2094 685 +2094 2317 +2094 2494 +2094 2540 +2094 2776 +2094 3594 +2094 3859 +2094 3860 +2094 3861 +2095 3862 +2096 7 +2096 147 +2096 248 +2096 250 +2096 289 +2096 353 +2096 390 +2096 753 +2096 754 +2096 762 +786 15 +786 331 +786 1300 +786 1326 +786 2091 +786 2714 +786 2715 +786 2716 +786 2717 +786 2718 +2102 1766 +2102 1956 +2102 2218 +2102 2841 +2102 3786 +2102 3869 +2102 3870 +2102 3871 +2102 3872 +2102 3873 +4463 81 +4463 637 +4463 697 +4463 2875 +4463 3813 +4463 5100 +4463 5306 +4463 5307 +4944 390 +4944 427 +4944 777 +4944 1842 +4944 2269 +4944 2862 +4944 3658 +4944 4578 +4944 5581 +4944 5582 +1752 83 +1752 690 +1752 1022 +1752 2198 +1752 2311 +1752 3272 +1752 3516 +1752 3517 +1752 3518 +1752 3519 +2091 681 +2091 979 +2091 1212 +2091 2326 +2091 2385 +2091 2395 +2091 3460 +2091 3864 +2091 3865 +2091 3866 +1162 452 +1162 453 +1162 460 +1162 563 +1162 803 +1162 847 +1162 1163 +1162 1164 +1162 1165 +1162 1166 +3315 1362 +3315 2087 +3315 2425 +3315 2999 +3315 3156 +3315 3849 +3315 4375 +3315 4559 +3315 4671 +3315 4672 +3568 43 +3568 221 +3568 918 +3568 1311 +3568 1934 +3568 2862 +3568 3614 +3568 4802 +3568 4836 +3568 4837 +3856 4 +3856 7 +3856 144 +3856 149 +3856 238 +3856 247 +3856 353 +3856 717 +3856 1317 +3856 2018 +3858 2081 +3858 2519 +3858 2762 +3858 3247 +3858 4439 +3858 4441 +3858 4828 +3858 4877 +484 337 +484 532 +484 786 +484 1352 +484 1764 +484 2493 +484 2494 +484 2495 +484 2496 +484 2497 +958 180 +958 558 +958 584 +958 1249 +958 1540 +958 3491 +958 4123 +958 4892 +958 4973 +958 4974 +1426 92 +1426 368 +1426 425 +1426 799 +1426 1339 +1426 2015 +1426 2588 +1426 3951 +1426 4635 +1426 4970 +1529 541 +1529 892 +1529 1385 +1529 2347 +1529 2854 +1529 2886 +1529 3330 +1529 3331 +1529 3332 +1529 3333 +2244 532 +2244 1219 +2244 1354 +2244 1776 +2244 1842 +2244 2650 +2244 2995 +2244 3943 +2244 3944 +2244 3945 +3046 715 +3046 1762 +3046 1865 +3046 2358 +3046 2563 +3046 2700 +3046 3109 +3046 4012 +3046 4658 +3046 5634 +3863 804 +3863 2399 +3863 3489 +3863 3543 +3863 3813 +3863 4333 +3863 4395 +3863 5229 +3863 5264 +3863 5337 +3594 363 +3594 1138 +3594 2498 +3594 2747 +3594 4846 +3594 4847 +3594 4848 +3594 4849 +3594 4850 +3594 4851 +3859 133 +3859 391 +3859 855 +3859 2676 +3859 3618 +3859 4285 +3859 4297 +3859 4960 +3859 4961 +3859 4962 +1427 2377 +1429 336 +1429 1546 +1429 2203 +1429 2319 +1429 2405 +1429 3266 +1429 3295 +1429 3296 +1429 3297 +1430 125 +1430 126 +1430 144 +1430 149 +1430 250 +1430 422 +1430 423 +1430 718 +1430 754 +1430 856 +1431 123 +1431 127 +1431 238 +1431 247 +1431 249 +1431 251 +1431 367 +1431 717 +1431 1245 +1431 3290 +257 69 +257 1137 +257 1233 +257 1300 +257 1301 +257 1302 +257 1303 +257 1304 +257 1305 +257 1306 +1533 85 +1533 279 +1533 529 +1533 1255 +1533 1401 +1533 1822 +1533 1920 +1533 2332 +1533 2884 +1533 2891 +1536 1050 +1537 5 +1537 9 +1537 128 +1537 145 +1537 148 +1537 176 +1537 179 +1537 248 +1537 352 +1537 424 +381 30 +381 279 +381 382 +381 383 +381 384 +381 385 +381 386 +381 387 +381 388 +381 389 +3843 17 +3843 143 +3843 148 +3843 175 +3843 250 +3843 266 +3843 423 +3843 697 +3843 754 +3843 1245 +3844 14 +3844 50 +3844 102 +3844 199 +3844 814 +3844 1749 +3844 2344 +3844 2486 +3844 2563 +3844 4958 +2681 222 +2681 325 +2681 1022 +2681 1064 +2681 1109 +2681 2885 +2681 3217 +2681 3252 +2681 3572 +2681 3848 +3350 648 +3350 1454 +3350 1812 +3350 2177 +3350 2825 +3350 3363 +3350 4657 +3350 4690 +3350 4691 +3350 4692 +3848 3212 +3850 125 +3850 129 +3850 146 +3850 249 +3850 251 +267 414 +267 813 +267 1050 +267 1749 +267 2229 +267 2230 +267 2231 +267 2232 +267 2233 +267 2234 +532 1329 +532 1330 +2819 5 +2819 144 +2819 148 +2819 149 +2819 252 +2819 266 +2819 422 +2819 559 +2819 856 +2819 2098 +3846 491 +3846 4241 +3846 4625 +3846 4893 +3846 5155 +3846 5229 +3846 5267 +3846 5937 +3846 5938 +3846 5939 +2715 285 +2715 693 +2715 1310 +2715 1592 +2715 1792 +2715 2476 +2715 2595 +2715 2891 +2715 3335 +2715 4061 +2716 196 +2716 524 +2716 1765 +2716 2452 +2716 3058 +2716 3138 +2716 4274 +2716 4275 +2716 4276 +2716 4277 +2718 748 +2718 2127 +2718 2293 +2718 2614 +2718 3558 +2718 3913 +2718 4052 +2718 4281 +2718 4282 +2718 4283 +1766 2218 +1766 2370 +1766 3680 +1766 3681 +5306 129 +5306 1509 +5306 1912 +5306 3566 +5306 5156 +5306 5369 +5306 5747 +5306 5767 +5306 5768 +777 352 +777 778 +777 779 +777 780 +777 781 +777 782 +777 783 +777 784 +777 785 +777 786 +2269 738 +2269 2500 +2269 3798 +2269 3855 +2269 3952 +2269 3953 +2269 3954 +2269 3955 +2269 3956 +2269 3957 +2862 455 +2862 633 +2862 1931 +2862 2407 +2862 3594 +2862 4280 +2862 4337 +2862 4338 +2862 4339 +2862 4340 +3658 520 +3658 1036 +3658 1587 +3658 1797 +3658 2334 +3658 3094 +3658 3473 +3658 4879 +3658 4880 +1212 665 +1212 777 +1212 840 +1212 1385 +1212 1402 +1212 1724 +1212 2790 +1212 3079 +1212 3080 +2326 3343 +2326 4130 +3865 23 +3865 1235 +3865 2036 +3865 4173 +3865 4904 +3865 4963 +3865 4964 +3865 4965 +3865 4966 +3865 4967 +3866 1549 +3866 2305 +3866 2310 +3866 2493 +3866 2806 +3866 3355 +3866 3960 +3866 4302 +3866 4968 +3866 4969 +141 7 +141 142 +141 143 +141 144 +141 145 +141 146 +141 147 +141 148 +141 149 +141 150 +2578 490 +2578 1775 +2578 2096 +2578 3405 +2578 3616 +2578 3967 +2578 4129 +2578 4222 +2578 4223 +2578 4224 +2581 129 +2581 171 +2581 889 +2581 2553 +2581 3109 +2581 4009 +2581 4201 +2581 4202 +2581 4203 +2581 4204 +311 127 +311 143 +311 251 +311 252 +311 264 +311 369 +311 753 +311 1245 +311 3677 +2243 9 +2243 123 +2243 125 +2243 126 +2243 129 +2243 144 +2243 176 +2243 352 +2243 367 +2243 427 +1675 214 +1675 281 +1675 322 +1675 402 +1675 554 +1675 776 +1675 829 +1675 858 +1675 898 +1675 1026 +1675 1087 +1675 1139 +1675 1575 +1675 1647 +1675 1671 +1675 1706 +1675 1787 +1675 1812 +1675 1952 +1675 2069 +1675 2278 +1675 2548 +1675 2585 +1675 2643 +1675 2964 +1675 3006 +1675 3170 +1675 3419 +1675 3420 +1675 3421 +1675 3422 +1675 3423 +1675 3424 +1675 3425 +1675 3426 +1675 3427 +1675 3428 +1675 3429 +1675 3430 +1675 3431 +1675 3432 +1675 3433 +1675 3434 +1675 3435 +1675 3436 +1675 3437 +1675 3438 +2723 661 +2723 814 +2723 1025 +2723 2038 +2723 2943 +2723 3613 +2723 4082 +2723 4284 +2723 4285 +2723 4286 +4680 1900 +4680 2477 +4680 3590 +4680 4080 +4680 4625 +1338 178 +1338 725 +1338 892 +1338 1530 +1338 2057 +1338 2570 +1338 2671 +1338 2786 +1338 3178 +1338 3179 +2348 1087 +3801 235 +3801 342 +3801 1120 +3801 1591 +3801 1592 +3801 2476 +3801 2612 +3801 3096 +3801 4131 +5675 2302 +5675 5474 +5675 5729 +5675 5933 +5675 5934 +5677 2625 +5677 3046 +5677 3292 +5677 4295 +5677 4806 +5677 5237 +5677 5315 +5677 5468 +5677 5935 +858 38 +858 263 +858 307 +858 412 +858 1704 +858 1705 +858 1706 +858 1707 +858 1708 +858 1709 +5978 124 +5978 238 +5978 266 +5978 353 +5978 367 +5978 422 +5978 423 +5978 427 +5978 559 +5978 717 +2184 3923 +2184 3924 +2184 3925 +2184 3926 +2184 3927 +158 411 +158 813 +158 1688 +158 2104 +158 2105 +158 2106 +158 2107 +158 2108 +160 13 +160 2053 +160 2056 +160 2109 +160 2110 +160 2111 +160 2112 +160 2113 +160 2114 +160 2115 +411 96 +411 835 +411 1256 +411 1814 +411 2266 +411 2839 +411 3306 +411 5013 +411 5014 +411 5015 +2112 463 +2112 803 +2112 1492 +2112 2091 +2112 2111 +2112 2115 +2112 2287 +2112 2818 +2112 2941 +2112 3868 +2115 123 +2115 199 +2115 751 +2115 1506 +2115 2474 +2115 2805 +2115 3365 +2115 3595 +2115 3886 +2115 3887 +1256 3114 +5014 124 +5014 129 +5014 146 +5014 247 +5014 249 +5014 353 +5014 368 +5014 369 +5014 390 +5014 1245 +1569 65 +1569 373 +1569 1153 +1569 1570 +1569 1571 +1569 1572 +1569 1573 +1569 1574 +1569 1575 +1569 1576 +1637 363 +1637 779 +1637 998 +1637 1503 +1637 1538 +1637 1976 +1637 2299 +1637 3386 +1637 3387 +1637 3388 +1770 2322 +751 31 +751 124 +751 146 +751 266 +751 367 +751 427 +751 559 +751 667 +751 856 +751 2001 +1506 1090 +1506 1507 +1506 1508 +1506 1509 +1506 1510 +1506 1511 +1506 1512 +1506 1513 +1506 1514 +1506 1515 +2474 330 +2474 534 +2474 970 +2474 1511 +2474 1764 +2474 1845 +2474 2300 +2474 5449 +2474 5450 +3886 451 +3886 478 +3886 677 +3886 1020 +3886 1230 +3886 2215 +3886 3275 +3886 4126 +3886 4977 +3886 4978 +3887 690 +3887 744 +3887 1300 +3887 1730 +3887 3053 +3887 4373 +3887 4984 +3887 4985 +3887 4986 +3887 4987 +162 163 +162 164 +162 165 +162 166 +162 167 +162 168 +162 169 +162 170 +162 171 +162 172 +165 102 +165 108 +165 531 +165 703 +165 1165 +165 1390 +165 1561 +165 1865 +165 2123 +165 2124 +169 818 +169 872 +169 1264 +169 1539 +169 2116 +169 2117 +169 2118 +169 2119 +169 2120 +169 2121 +531 80 +531 343 +531 346 +531 571 +531 572 +531 573 +531 574 +531 575 +531 576 +1165 535 +1165 1163 +1165 2089 +1165 2204 +1165 2561 +1165 2795 +1165 3055 +1165 3056 +1165 3057 +1165 3058 +2116 510 +2116 1018 +2116 1633 +2116 2069 +2116 2130 +2116 3724 +2116 3875 +2116 3876 +2116 3877 +2116 3878 +571 721 +571 765 +571 804 +571 1913 +571 2358 +571 2474 +571 2521 +571 2522 +571 2523 +571 2524 +572 584 +572 818 +572 979 +572 1353 +572 2119 +572 2306 +572 2337 +572 2892 +572 4318 +572 4319 +573 228 +573 2520 +574 31 +574 125 +574 175 +574 179 +574 180 +574 250 +574 266 +574 390 +574 424 +576 1827 +576 2481 +576 2953 +576 3171 +576 4846 +576 5235 +576 5236 +576 5237 +576 5238 +576 5239 +1163 632 +1163 1882 +1163 2593 +1163 3617 +1163 4494 +1163 4495 +1163 4496 +1163 4497 +1163 4498 +1163 4499 +387 825 +387 1733 +387 1961 +387 2001 +387 2353 +387 2354 +387 2355 +387 2356 +2322 376 +2322 2303 +2322 2528 +2322 4014 +2322 4015 +2322 4016 +2322 4017 +2322 4018 +2322 4019 +2322 4020 +2904 531 +2904 820 +2904 930 +2904 1608 +2904 1845 +2904 1956 +2904 4156 +2904 4399 +2904 4400 +2904 4401 +3232 56 +3232 811 +3232 2489 +3232 2524 +3232 3460 +3232 3994 +3232 4010 +3232 4617 +3232 4618 +3232 4619 +3233 8 +3233 122 +3233 144 +3233 148 +3233 174 +3233 179 +3233 424 +3233 427 +3233 1317 +3233 2338 +3234 4709 +1633 83 +1633 831 +1633 1634 +1633 1635 +1633 1636 +1633 1637 +1633 1638 +1633 1639 +1633 1640 +3877 478 +173 124 +173 128 +173 144 +173 174 +173 175 +173 176 +173 177 +173 178 +173 179 +173 180 +2133 86 +2133 433 +2133 1378 +2133 2451 +2133 2637 +2133 3185 +2133 3862 +2133 3880 +2133 3881 +2133 3882 +2134 710 +2134 712 +2134 2847 +2134 3166 +2134 3410 +2134 3756 +2134 3863 +2134 3883 +2134 3884 +2134 3885 +816 1048 +816 1129 +816 2237 +816 2548 +816 4695 +816 4844 +816 4878 +816 5224 +816 5628 +816 5629 +926 241 +926 347 +926 356 +926 478 +926 572 +926 2300 +926 2337 +926 2821 +926 2822 +926 2823 +5404 1143 +5404 2583 +5404 2658 +5404 2885 +5404 2961 +5404 5749 +5404 5763 +5404 5764 +5404 5805 +455 2038 +455 2188 +455 2241 +455 2441 +455 2442 +4689 924 +4689 1199 +4689 1288 +4689 1424 +4689 1866 +4689 1867 +4689 1868 +4689 2558 +4689 5423 +4689 5424 +4002 3 +4002 121 +4002 123 +4002 124 +4002 128 +4002 247 +4002 367 +4002 717 +4002 1246 +4002 2098 +4839 356 +4839 572 +4839 1137 +4839 1287 +4839 1671 +4839 2324 +4839 2475 +4839 2648 +4839 2822 +4839 4754 +4896 263 +4896 733 +4896 878 +4896 1031 +4896 2449 +4896 2779 +4896 3553 +4896 5080 +4896 5568 +4896 5569 +2338 256 +2338 840 +2338 1031 +2338 1457 +2338 1509 +2338 2785 +2338 3006 +2338 3743 +2338 5056 +2338 5645 +1651 129 +1651 262 +1651 855 +1651 1318 +1651 1974 +1651 2974 +1651 3399 +1651 3400 +1651 3401 +1651 3402 +4553 3 +4553 124 +4553 146 +4553 251 +4553 266 +4553 422 +4553 667 +4553 856 +4553 2001 +4553 2018 +5572 56 +5572 206 +5572 787 +5572 788 +5572 4293 +5572 4676 +5572 5063 +5572 5879 +5572 5880 +5572 5881 +5884 6040 +1441 567 +1441 1957 +1441 2493 +1441 3093 +1441 3187 +1441 3298 +1441 3299 +1441 3300 +1441 3301 +1589 156 +1589 1056 +1589 1203 +1589 1327 +1589 2304 +1589 3364 +1589 3365 +1589 3366 +1589 3367 +1589 3368 +2599 665 +2599 1175 +2599 1866 +2599 1867 +2599 2563 +2599 3033 +2599 3980 +2599 4199 +2599 4200 +584 585 +584 586 +584 587 +2615 453 +2615 1273 +2615 1656 +2615 2787 +2615 3053 +2615 3509 +2615 4143 +2615 4219 +2615 4220 +2615 4221 +2617 215 +2617 1313 +2617 1803 +2617 2443 +2617 2643 +2617 2654 +2617 3558 +2617 4037 +1547 1023 +1547 1339 +1547 1636 +1547 2499 +1547 3169 +1547 3342 +1547 3343 +1547 3344 +1547 3345 +1547 3346 +2148 1048 +2148 2067 +2148 2179 +2148 3134 +2148 3196 +2148 3891 +2148 3892 +2148 3893 +2148 3894 +2148 3895 +4516 282 +4516 665 +4516 1143 +4516 1988 +4516 2961 +4516 3777 +4516 5333 +4516 5334 +4516 5335 +433 20 +433 1370 +433 1565 +433 1824 +433 2433 +3881 528 +3881 756 +3881 874 +3881 3023 +3881 3205 +3881 3271 +3881 3488 +3881 4841 +3881 4975 +3881 4976 +3883 8 +3883 123 +3883 146 +3883 247 +3883 248 +3883 249 +3883 266 +3883 369 +3883 427 +3883 667 +3885 2051 +3885 2164 +3885 2708 +3885 3362 +3885 3587 +181 182 +181 183 +181 184 +181 185 +181 186 +181 187 +181 188 +181 189 +181 190 +181 191 +192 38 +192 193 +192 194 +192 195 +192 196 +193 2062 +193 2222 +193 2388 +193 2389 +193 2390 +193 2391 +194 86 +194 139 +194 1020 +194 2135 +194 2136 +194 2137 +194 2138 +194 2139 +194 2140 +194 2141 +195 4 +195 124 +195 143 +195 176 +195 368 +195 422 +195 558 +195 736 +195 1245 +196 246 +196 424 +196 659 +196 809 +196 2120 +196 2142 +196 2143 +196 2144 +196 2145 +196 2146 +2388 261 +2388 937 +2388 1229 +2388 2225 +2388 2595 +2388 2948 +2388 3205 +2388 4072 +2388 4073 +2388 4074 +2391 478 +2391 986 +2391 1370 +2391 3457 +2391 3487 +2391 4075 +2391 4076 +2391 4077 +2391 4078 +2391 4079 +2136 3888 +2143 494 +2143 1068 +2143 1402 +2143 1545 +2143 2165 +2143 2166 +2143 2215 +2143 2646 +2143 3889 +2143 3890 +2145 262 +2145 1407 +2145 1637 +2145 1926 +2145 3900 +2145 3901 +2145 3902 +2145 3903 +2145 3904 +2145 3905 +2146 4 +2146 5 +2146 9 +2146 10 +2146 147 +2146 266 +2146 368 +2146 423 +2146 1245 +937 5 +937 7 +937 143 +937 145 +937 146 +937 249 +937 251 +937 367 +937 666 +937 1317 +1229 1916 +1229 2140 +1229 2949 +1229 2984 +1229 3084 +1229 3085 +1229 3086 +1229 3087 +1229 3088 +2948 355 +2948 607 +2948 823 +2948 1466 +2948 3855 +2948 4424 +2948 4425 +2948 4426 +2948 4427 +2948 4428 +4072 4854 +4073 134 +4073 1224 +4073 1250 +4073 1739 +4073 1862 +4073 2050 +4073 3460 +4073 4262 +4073 5072 +4073 5073 +478 479 +478 480 +478 481 +478 482 +478 483 +478 484 +478 485 +478 486 +478 487 +478 488 +986 145 +986 146 +986 251 +986 264 +986 367 +986 559 +986 666 +986 667 +986 1245 +1370 825 +1370 1371 +1370 1372 +1370 1373 +1370 1374 +1370 1375 +1370 1376 +1370 1377 +1370 1378 +4076 175 +4076 251 +4076 252 +4076 266 +4076 292 +4076 390 +4076 422 +4076 558 +4076 856 +4076 3933 +4078 387 +4078 584 +4078 674 +4078 1670 +4078 2091 +4078 3091 +4078 4328 +4078 4467 +4078 5070 +4078 5071 +737 898 +737 1539 +737 2516 +737 2659 +737 2660 +737 2661 +737 2662 +737 2663 +739 1380 +739 1609 +739 2664 +739 2665 +739 2666 +741 31 +741 538 +741 1575 +741 2272 +741 2538 +741 2719 +741 2720 +741 2721 +741 2722 +741 2723 +742 1476 +742 1975 +742 2412 +742 2453 +742 2678 +742 2679 +742 2680 +742 2681 +742 2682 +742 2683 +1084 49 +1084 184 +1084 505 +1084 725 +1084 1085 +1084 1086 +1084 1087 +1084 1088 +1084 1089 +1084 1090 +1870 71 +1870 642 +1870 706 +1870 1705 +1870 1714 +1870 1871 +1870 1872 +1870 1873 +1870 1874 +1870 1875 +2295 76 +2295 612 +2295 1512 +2295 2348 +2295 2403 +2295 2868 +2295 3082 +2295 3127 +2295 3794 +2576 111 +2576 3699 +2576 4004 +2576 4175 +2576 4176 +2577 330 +2577 388 +2577 553 +2577 962 +2577 1306 +2577 2010 +2577 3179 +2577 4177 +2577 4178 +2577 4179 +1545 1837 +2646 1544 +2646 1854 +2646 1936 +2646 3105 +2646 3608 +2646 3731 +2646 4236 +2646 4237 +3890 3 +3890 123 +3890 129 +3890 251 +3890 264 +3890 367 +3890 426 +3890 427 +3890 718 +3890 2717 +3900 158 +3900 1243 +3900 1331 +3900 2024 +3900 3416 +3900 4752 +3900 4916 +3900 4988 +3900 4989 +3900 4990 +3903 690 +3903 902 +3903 2325 +3903 2942 +3903 3106 +3903 3563 +3903 4847 +3903 4981 +3903 4982 +3903 4983 +3904 312 +3904 1656 +3904 2175 +3904 3489 +3904 4091 +3904 4718 +3904 4998 +3904 4999 +3904 5000 +3904 5001 +197 198 +197 199 +197 200 +197 201 +197 202 +197 203 +197 204 +197 205 +197 206 +197 207 +201 714 +201 2152 +201 2153 +201 2154 +201 2155 +201 2156 +201 2157 +201 2158 +201 2159 +201 2160 +412 769 +412 2253 +412 2532 +412 3029 +412 3215 +412 3485 +412 4254 +412 5484 +412 5501 +412 5502 +2153 1219 +2153 2847 +2153 3804 +2153 3856 +2153 3908 +2153 3909 +2153 3910 +2153 3911 +2153 3912 +2153 3913 +2156 1016 +2156 2309 +2156 2354 +2156 3300 +2156 3431 +2156 5343 +2156 5468 +2156 5958 +2156 5959 +2156 5960 +2158 262 +2158 1021 +2158 1115 +2158 2002 +2158 3433 +2158 3467 +2158 3896 +2158 3897 +2158 3898 +2158 3899 +2253 113 +2253 222 +2253 382 +2253 411 +2253 1157 +2253 2169 +2253 2552 +2253 3949 +2253 3950 +2532 665 +2532 774 +2532 924 +2532 1709 +2532 1859 +2532 2767 +2532 3136 +2532 3682 +2532 3698 +2532 4160 +859 671 +859 860 +859 861 +859 862 +859 863 +859 864 +859 865 +859 866 +859 867 +859 868 +3373 4 +3373 9 +3373 251 +3373 698 +3373 2599 +3373 4250 +3373 4710 +3373 4711 +3373 4712 +3373 4713 +3374 1090 +3374 1528 +3374 1816 +3374 2474 +3374 2524 +3374 3067 +3374 3108 +3374 3233 +3374 3755 +3374 4210 +3910 122 +3910 124 +3910 127 +3910 143 +3910 247 +3910 264 +3910 352 +3910 353 +3910 390 +3910 1245 +3912 889 +3912 1367 +3912 3266 +3912 3856 +3912 4735 +3912 4894 +3912 4991 +3912 4992 +3912 4993 +3912 4994 +3913 204 +3913 607 +3913 804 +3913 1072 +3913 1605 +3913 1728 +3913 1780 +3913 3339 +3913 4995 +2309 1333 +2309 2017 +2309 2138 +2309 2667 +2309 3124 +2309 3841 +2309 4004 +2309 4005 +2309 4006 +2309 4007 +3431 2077 +3431 2411 +3431 4824 +5343 946 +5343 2414 +5343 2563 +5343 2780 +5343 3930 +5343 4245 +5343 4675 +5343 5300 +5343 5781 +5343 5782 +5960 3304 +3433 105 +3433 231 +3433 424 +3433 833 +3433 921 +3433 2911 +3433 3170 +3433 3497 +3433 4461 +3433 4472 +3897 1223 +3897 3695 +3897 3981 +3897 4059 +3897 4371 +892 2200 +892 2959 +892 2960 +892 2961 +218 219 +218 220 +218 221 +218 222 +218 223 +218 224 +218 225 +218 226 +218 227 +225 199 +225 221 +225 893 +225 1343 +225 1749 +225 1861 +225 2177 +225 2178 +225 2179 +225 2180 +226 168 +226 314 +226 1114 +226 1564 +226 2171 +226 2172 +226 2173 +226 2174 +226 2175 +226 2176 +1343 351 +1343 1168 +1343 1504 +1343 1764 +1343 1765 +1343 2585 +1343 3195 +1343 3196 +1343 3197 +1343 3198 +2178 17 +2178 31 +2178 123 +2178 126 +2178 145 +2178 149 +2178 176 +2178 697 +2178 1317 +314 121 +314 147 +314 177 +314 248 +314 249 +314 252 +314 264 +314 266 +314 423 +314 1245 +2171 3907 +2172 96 +2172 604 +2172 828 +2172 1291 +2172 1575 +2172 1961 +2172 2533 +2172 2555 +2172 3020 +2172 3713 +2173 2569 +2174 1144 +2176 3 +2176 175 +2176 266 +2176 368 +2176 390 +2176 423 +2176 427 +2176 697 +2176 1245 +1168 1909 +1168 1912 +1168 2574 +1168 2791 +1168 2797 +1168 3045 +1168 3046 +1168 3047 +1168 3048 +1168 3049 +1504 127 +1504 128 +1504 179 +1504 249 +1504 353 +1504 424 +1504 426 +1504 1354 +1504 3326 +1504 3327 +1765 839 +1765 2420 +1765 2477 +1765 3086 +1765 3185 +1765 3193 +1765 3197 +1765 3301 +1765 3527 +3197 585 +3197 1036 +3197 1730 +3197 1797 +3197 2556 +3197 2997 +3197 3619 +3197 3808 +3197 4582 +3197 4583 +863 202 +863 513 +863 649 +863 1481 +863 1775 +863 2125 +863 2740 +863 2741 +863 2742 +863 2743 +1094 121 +1094 124 +1094 127 +1094 128 +1094 144 +1094 145 +1094 174 +1094 179 +1094 247 +1094 1246 +2743 14 +2743 1022 +2743 1278 +2743 1352 +2743 2726 +2743 2974 +2743 3312 +2743 4151 +2743 4296 +2743 4297 +3507 738 +3507 1251 +3507 1458 +3507 1509 +3507 2077 +3507 2825 +3507 3249 +3507 4679 +3507 4789 +3507 4790 +2569 79 +2569 164 +2569 243 +2569 296 +2569 455 +2569 1289 +2569 2641 +2569 2740 +2569 3735 +2569 4172 +228 176 +228 182 +228 229 +228 230 +228 231 +228 232 +228 233 +228 234 +228 235 +229 840 +229 1123 +229 1194 +229 1726 +229 2217 +229 2218 +229 2219 +229 2220 +229 2221 +229 2222 +232 2223 +2217 5 +2217 9 +2217 149 +2217 177 +2217 238 +2217 247 +2217 249 +2217 369 +2217 424 +2217 1317 +2221 152 +2221 219 +2221 976 +2221 1044 +2221 1235 +2221 2248 +2221 2673 +2221 3589 +2221 3929 +2223 107 +2223 883 +2223 1021 +2223 1048 +2223 1175 +2223 1269 +2223 1936 +2223 2414 +2223 3868 +2223 3930 +1235 123 +1235 143 +1235 176 +1235 264 +1235 352 +1235 353 +1235 390 +1235 423 +1235 718 +1235 2338 +2248 117 +2248 485 +2248 820 +2248 2353 +2248 3671 +2248 4067 +2248 5114 +2248 5115 +2248 5116 +2248 5117 +3929 76 +3929 513 +3929 550 +3929 604 +3929 712 +3929 1940 +3929 1955 +3929 1969 +3929 3022 +3929 3509 +3930 1228 +3930 1777 +3930 1928 +3930 2933 +3930 3331 +3930 4461 +3930 5004 +3930 5005 +3930 5006 +3930 5007 +236 24 +236 237 +236 238 +236 239 +236 240 +236 241 +236 242 +236 243 +236 244 +236 245 +241 2010 +241 2186 +241 2187 +241 2188 +244 338 +244 612 +244 1264 +244 1284 +244 2197 +244 2198 +244 2199 +244 2200 +244 2201 +244 2202 +1284 148 +1284 174 +1284 266 +1284 368 +1284 369 +1284 423 +1284 427 +1284 559 +1284 1245 +1284 1317 +2199 322 +2199 412 +2199 527 +2199 2940 +2199 3593 +2199 3697 +2199 3919 +2199 3920 +2199 3921 +2199 3922 +307 711 +307 883 +307 1018 +307 2260 +307 2261 +307 2262 +307 2263 +307 2264 +307 2265 +307 2266 +2546 2 +2546 3 +2546 8 +2546 147 +2546 247 +2546 351 +2546 1317 +2546 2064 +2546 4161 +2546 4162 +2554 534 +2554 1400 +2554 2843 +2554 3684 +2554 3781 +2554 4166 +2554 4167 +2554 4168 +2554 4169 +3919 7 +3919 219 +3919 256 +3919 424 +3919 1602 +3919 2119 +3919 2364 +3919 3120 +3919 4756 +3919 4996 +3920 49 +3920 1056 +3920 1512 +3920 1739 +3920 2789 +3920 3322 +3920 4412 +3920 4597 +3920 4716 +3920 4997 +3921 312 +3921 837 +3921 894 +3921 897 +3921 942 +3921 1016 +3921 1267 +3921 1524 +3921 3612 +3921 4889 +3922 21 +3922 3144 +3922 3963 +3922 4022 +2974 50 +2974 892 +2974 1077 +2974 1203 +2974 2089 +2974 2562 +2974 2861 +2974 3749 +2974 4436 +2974 4437 +1004 106 +1004 693 +1004 1591 +1004 1760 +1004 2212 +1004 2552 +1004 2903 +1004 2904 +1004 2905 +1004 2906 +2278 152 +2278 1313 +2278 1901 +2278 1997 +2278 2200 +2278 2602 +2278 2975 +2278 3968 +2278 3969 +2278 3970 +2284 4105 +1393 4 +1393 5 +1393 145 +1393 147 +1393 149 +1393 183 +1393 252 +1393 390 +1393 423 +1393 667 +1396 266 +1396 437 +1396 459 +1396 1178 +1396 1409 +1396 1504 +1396 1800 +1396 1842 +1396 2871 +1396 3281 +3394 1724 +3394 2066 +3394 2275 +3394 3660 +3394 4603 +3394 4727 +3394 4728 +3394 4729 +3394 4730 +1273 330 +1273 2868 +1273 3120 +1273 3121 +1273 3122 +1273 3123 +1273 3124 +1273 3125 +1273 3126 +1273 3127 +1336 260 +2392 21 +2392 503 +2392 804 +2392 808 +2392 1339 +2392 1547 +2392 2839 +2392 3346 +2392 4080 +2392 4081 +2757 1829 +2757 3882 +2757 4405 +2757 4406 +1137 83 +1137 2086 +1137 2657 +1137 2966 +1137 3003 +1137 3004 +1137 3005 +1137 3006 +1137 3007 +1137 3008 +1301 866 +1301 1305 +1301 1345 +1301 1346 +1301 1347 +1301 1348 +1301 1349 +1301 1350 +1301 1351 +1305 67 +1305 124 +1305 176 +1305 339 +1305 427 +1305 1669 +1305 1749 +1305 3150 +1305 3151 +1305 3152 +2657 1245 +2657 2687 +2657 2866 +2657 3488 +2657 3680 +2657 3886 +2657 4074 +2657 4240 +2657 4241 +2657 4242 +3003 219 +3003 1087 +3003 1761 +3003 1930 +3003 2645 +3003 2787 +3003 2871 +3003 3207 +3003 4082 +3003 4445 +866 162 +866 416 +866 635 +866 1351 +866 1408 +866 1860 +866 2326 +866 2763 +866 2764 +866 2765 +1346 1730 +1346 1766 +1346 2503 +1346 2708 +1346 3177 +1346 3187 +1346 3188 +1346 3189 +1346 3190 +1346 3191 +339 4 +339 5 +339 7 +339 148 +339 264 +339 364 +339 559 +339 1317 +339 1755 +339 2278 +3152 769 +3152 1078 +3152 1409 +3152 2374 +3152 4116 +3152 4316 +3152 4442 +3152 4553 +3152 4554 +3152 4555 +263 4 +263 126 +263 146 +263 147 +263 264 +263 265 +263 266 +263 267 +263 268 +263 269 +2231 132 +2231 686 +2231 970 +2231 1598 +2231 2802 +2231 3938 +2231 3939 +2231 3940 +2231 3941 +2231 3942 +1129 5 +1129 7 +1129 145 +1129 248 +1129 353 +1129 426 +1129 629 +1129 753 +1129 2077 +1129 3002 +3235 255 +3235 542 +3235 884 +3235 1313 +3235 1538 +3235 2726 +3235 2758 +3235 4620 +3235 4621 +3235 4622 +3931 566 +3931 3212 +3931 3352 +3931 5051 +1143 172 +1143 1556 +1143 1766 +1143 1852 +1143 1890 +1143 2384 +1143 2544 +1143 2666 +1143 3032 +1143 3033 +3933 45 +3933 219 +3933 425 +3933 1056 +3933 2344 +3933 2781 +3933 3995 +3933 4361 +3933 4720 +3933 5008 +1173 412 +1173 1001 +1173 1060 +1173 1441 +1173 2683 +1173 2746 +1173 3781 +1173 3865 +1173 5009 +2358 215 +2358 1522 +2358 2443 +2358 4056 +2358 4281 +2358 4844 +2358 6168 +2358 6232 +3934 15 +3934 855 +3934 1212 +3934 2563 +3934 4629 +3934 4950 +3934 5088 +3934 5414 +3934 5889 +3934 5890 +3937 4 +3937 125 +3937 143 +3937 144 +3937 146 +3937 147 +3937 175 +3937 179 +3937 180 +3937 558 +270 190 +270 271 +270 272 +270 273 +270 274 +270 275 +270 276 +270 277 +270 278 +276 272 +276 274 +276 600 +276 1583 +276 1800 +276 2247 +276 2248 +276 2249 +485 8 +485 121 +485 123 +485 148 +485 179 +485 249 +485 251 +485 353 +485 369 +485 1317 +280 318 +280 552 +280 790 +280 967 +280 1202 +280 1259 +280 1412 +280 1620 +280 1933 +280 2235 +283 552 +283 632 +283 779 +283 838 +283 1321 +283 1371 +283 1571 +283 1891 +283 1892 +283 2236 +284 32 +284 503 +284 1699 +284 1789 +284 2237 +284 2238 +284 2239 +284 2240 +284 2241 +284 2242 +288 92 +288 209 +288 1917 +288 1946 +288 1957 +288 2015 +288 2244 +288 2245 +288 2246 +967 15 +967 440 +967 669 +967 2855 +967 2856 +967 2857 +967 2858 +967 2859 +967 2860 +967 2861 +1202 3105 +1259 5 +1259 126 +1259 148 +1259 149 +1259 174 +1259 176 +1259 249 +1259 251 +1259 265 +1259 352 +1891 199 +1891 538 +1891 725 +1891 852 +1891 1397 +1891 2914 +1891 3166 +1891 3670 +1891 3671 +1891 3672 +2241 3 +2241 163 +2241 1056 +2241 1362 +2241 1539 +2241 2097 +2241 2579 +2241 3946 +2241 3947 +2241 3948 +2245 4092 +2859 571 +2859 609 +2859 695 +2859 802 +2859 864 +2859 870 +2859 2638 +2859 3109 +2859 4334 +2859 4356 +2860 122 +2860 127 +2860 143 +2860 177 +2860 179 +2860 367 +2860 369 +2860 390 +2860 422 +2860 718 +2861 7 +2861 143 +2861 147 +2861 174 +2861 175 +2861 368 +2861 559 +2861 666 +2861 754 +2861 2018 +1658 92 +1658 860 +1658 963 +1658 1767 +1658 2015 +1658 2880 +1658 2953 +1658 3409 +1658 3410 +1658 3411 +2262 2354 +2262 2385 +2262 2687 +2262 2881 +2262 3951 +2612 726 +2612 1571 +2612 1789 +2612 2274 +2612 2630 +2612 3423 +2612 3570 +2612 3951 +2612 4210 +2612 4211 +3382 1547 +3382 2331 +3382 2348 +3382 3194 +3382 3617 +3382 4665 +3382 4719 +3382 4720 +3382 4721 +3383 835 +3383 1003 +3383 1288 +3383 2788 +3383 2867 +3383 4625 +3383 4722 +3383 4723 +3383 4724 +3670 406 +3670 933 +3670 1787 +3670 2344 +3670 2595 +3670 3699 +3670 3922 +3670 4540 +3670 4870 +3670 4882 +3946 124 +3946 249 +3946 251 +3946 264 +3946 367 +3946 422 +3946 667 +3946 718 +3946 856 +3948 124 +3948 127 +3948 143 +3948 247 +3948 251 +3948 264 +3948 367 +3948 390 +3948 718 +3948 1245 +908 648 +908 697 +908 942 +908 1512 +908 1842 +908 2786 +908 2787 +908 2788 +908 2789 +908 2790 +2428 451 +2428 532 +2428 1766 +2428 2068 +2428 2069 +2428 2193 +2428 4028 +2428 4095 +2428 4096 +2428 4097 +1354 163 +1354 1642 +1354 1741 +1354 2134 +1354 2329 +1354 2683 +1354 2880 +1354 3202 +1354 3203 +3943 2539 +3943 2744 +3943 2747 +3943 2859 +3943 2898 +3943 3779 +3943 4613 +3943 5010 +3943 5011 +3943 5012 +3945 122 +3945 123 +3945 124 +3945 126 +3945 149 +3945 177 +3945 247 +3945 698 +299 175 +299 378 +299 443 +299 774 +299 1573 +299 1704 +299 2035 +299 2250 +299 2251 +299 2252 +378 121 +378 122 +378 123 +378 127 +378 143 +378 251 +378 390 +378 667 +378 717 +378 1245 +1704 9 +1704 121 +1704 126 +1704 149 +1704 176 +1704 352 +1704 423 +1704 424 +1704 427 +1704 667 +2252 3 +2252 7 +2252 8 +2252 123 +2252 128 +2252 148 +2252 176 +2252 179 +2252 424 +2252 717 +490 356 +490 520 +490 852 +490 2069 +490 2167 +490 2214 +490 2403 +490 2464 +490 2465 +490 2466 +496 164 +496 418 +496 633 +496 762 +496 1471 +496 2358 +496 2376 +496 2472 +496 2473 +496 2474 +3408 462 +3408 582 +3408 940 +3408 1530 +3408 2795 +3408 3717 +3408 4237 +3408 4519 +3408 4752 +3408 4753 +300 218 +300 301 +300 302 +300 303 +300 304 +300 305 +300 306 +300 307 +300 308 +300 309 +302 1233 +302 2519 +303 309 +303 341 +303 764 +303 909 +303 1061 +303 1093 +303 1095 +303 2253 +303 2254 +303 2255 +305 587 +305 710 +305 838 +305 1498 +305 1776 +305 1850 +305 2256 +305 2257 +305 2258 +305 2259 +341 370 +341 862 +341 1591 +341 1805 +341 1891 +341 2177 +341 2288 +341 2289 +341 2290 +341 2291 +764 765 +764 766 +764 767 +764 768 +764 769 +764 770 +764 771 +764 772 +764 773 +764 774 +2260 38 +2260 1688 +2260 2191 +2260 2941 +2260 3804 +2260 4501 +2260 4894 +2260 5909 +2260 6108 +2260 6181 +2261 122 +2261 124 +2261 128 +2261 129 +2261 176 +2261 249 +2261 264 +2261 367 +2261 368 +2261 369 +370 371 +370 372 +370 373 +370 374 +370 375 +370 376 +370 377 +370 378 +370 379 +370 380 +2290 10 +2290 121 +2290 128 +2290 145 +2290 266 +2290 352 +2290 422 +2290 559 +2290 666 +2290 1317 +766 17 +766 262 +766 1332 +766 1689 +766 1956 +766 2330 +766 2569 +766 2697 +766 2698 +766 2699 +767 1618 +767 1863 +767 2550 +767 2690 +767 2691 +767 2692 +767 2693 +767 2694 +767 2695 +767 2696 +771 507 +771 838 +771 1003 +771 1402 +771 1717 +771 1896 +771 1968 +771 2689 +771 2705 +771 2706 +773 2907 +382 996 +382 1969 +382 2345 +382 2346 +382 2347 +382 2348 +382 2349 +382 2350 +382 2351 +382 2352 +5909 282 +5909 342 +5909 1805 +5909 2612 +5909 3963 +5909 4170 +5909 4333 +5909 4365 +5909 5729 +6108 76 +6108 131 +6108 1023 +6108 1863 +6108 2080 +6108 2127 +6108 3677 +6108 3962 +6108 4260 +6108 6182 +6181 8 +6181 122 +6181 177 +6181 247 +6181 249 +6181 251 +6181 266 +6181 353 +6181 422 +6181 718 +2881 4 +2881 144 +2881 148 +2881 175 +2881 180 +2881 266 +2881 424 +2881 666 +2881 886 +2881 2018 +310 311 +310 312 +310 313 +310 314 +310 315 +310 316 +310 317 +310 318 +310 319 +310 320 +316 2267 +2267 855 +2267 1323 +2267 1439 +2267 1808 +2267 3568 +2267 4275 +2267 4738 +2267 4806 +2267 6121 +2267 6122 +855 249 +855 251 +855 266 +855 322 +855 367 +855 558 +855 667 +855 856 +855 857 +855 858 +1323 137 +1323 557 +1323 1039 +1323 1728 +1323 2646 +1323 3079 +1323 3199 +1323 3200 +1323 3201 +4275 4 +4275 122 +4275 143 +4275 146 +4275 266 +4275 367 +4275 666 +4275 667 +4275 754 +4275 856 +4738 77 +4738 586 +4738 672 +4738 1980 +4738 2147 +4738 3138 +4738 5016 +4738 5303 +4738 5451 +4738 5452 +4806 5451 +321 32 +321 322 +321 323 +321 324 +321 325 +321 326 +321 327 +321 328 +321 329 +321 330 +325 82 +325 1507 +325 1669 +325 2159 +325 2187 +325 2268 +325 2269 +325 2270 +325 2271 +325 2272 +327 8 +327 96 +327 627 +327 681 +327 822 +327 2179 +327 2273 +327 2274 +327 2275 +327 2276 +2275 587 +2275 989 +2275 1435 +2275 2412 +2275 2726 +2275 3768 +2275 3958 +2275 3959 +2275 3960 +2275 3961 +2500 297 +2500 660 +2500 1573 +2500 2221 +2500 3057 +2500 3705 +2500 4148 +2500 4149 +2500 4150 +2500 4151 +3952 4706 +401 122 +401 124 +401 127 +401 146 +401 247 +401 264 +401 422 +401 423 +401 427 +401 559 +3397 4304 +3966 788 +3966 944 +3966 1163 +3966 1313 +3966 2068 +3966 3524 +3966 4371 +3966 4694 +3966 4801 +3966 5021 +3967 1123 +3967 1195 +3967 1288 +3967 1833 +3967 2035 +3967 2529 +3967 2755 +3967 4330 +3967 5019 +3967 5020 +344 881 +930 5 +930 7 +930 147 +930 148 +930 367 +930 368 +930 422 +930 559 +930 1317 +2498 819 +2498 2502 +2498 3129 +2498 3489 +2498 4107 +2498 4143 +2498 4144 +2498 4145 +2498 4146 +2498 4147 +3296 918 +3296 2027 +3296 2067 +3296 3714 +3296 4204 +3296 4657 +3296 4658 +3296 4659 +3296 4660 +3296 4661 +3962 1122 +3962 1557 +3962 1992 +3962 2380 +3962 2383 +3962 3350 +3962 3981 +3962 4434 +3962 4693 +3962 5018 +3963 23 +3963 96 +3963 350 +3963 1322 +3963 1664 +3963 1798 +3963 3144 +3963 4022 +3963 4890 +989 8 +989 49 +989 53 +989 108 +989 751 +989 756 +989 986 +989 990 +989 991 +989 1047 +989 1383 +989 1424 +989 2054 +989 2375 +989 2399 +989 2525 +989 2606 +989 2890 +989 2891 +989 2892 +989 2893 +989 2894 +989 2895 +989 2896 +989 2897 +334 268 +334 376 +334 843 +334 1587 +334 1888 +334 2053 +334 2285 +334 2286 +334 2287 +335 81 +335 141 +335 494 +335 1052 +335 2023 +335 2319 +335 3590 +335 4152 +335 4153 +335 4154 +1888 345 +1888 846 +1888 1251 +1888 1826 +1888 1889 +1888 1890 +1888 1891 +1888 1892 +1888 1893 +1888 1894 +2285 309 +2285 1019 +2285 1176 +2285 2848 +2285 3164 +2285 3457 +2285 3977 +2285 3979 +2285 3980 +2285 3981 +2286 123 +2286 124 +2286 179 +2286 238 +2286 367 +2286 423 +2286 427 +2286 853 +2286 2059 +2286 3764 +3590 4845 +4152 468 +4152 1655 +4152 2011 +4152 2645 +4152 3016 +4152 4197 +4152 4275 +4152 4438 +4152 4472 +4152 5092 +4154 586 +4154 1085 +4154 1859 +4154 2387 +4154 2894 +4154 4202 +4154 4628 +4154 5093 +4154 5094 +4154 5095 +345 126 +345 149 +345 177 +345 179 +345 248 +345 266 +345 424 +345 754 +345 2001 +1251 262 +1251 416 +1251 1057 +1251 1252 +1251 1253 +1251 1254 +1251 1255 +1251 1256 +1251 1257 +1251 1258 +1889 58 +1889 351 +1889 829 +1889 832 +1889 835 +1889 1306 +1889 1327 +1889 3636 +1889 3637 +1889 3638 +1890 39 +1890 158 +1890 1047 +1890 3341 +1890 3639 +1890 3640 +1890 3641 +1890 3642 +1890 3643 +1890 3644 +1890 3645 +1890 3646 +1890 3647 +1890 3648 +1890 3649 +1890 3650 +1890 3651 +1890 3652 +1890 3653 +1890 3654 +1890 3655 +1890 3656 +1890 3657 +1890 3658 +1890 3659 +1890 3660 +1890 3661 +1890 3662 +1890 3663 +1890 3664 +1890 3665 +1890 3666 +1890 3667 +1890 3668 +1893 1023 +1893 3136 +1019 551 +1019 898 +1019 945 +1019 1533 +1019 2018 +1019 2926 +1019 2927 +1019 2928 +1019 2929 +1019 2930 +1176 124 +1176 147 +1176 251 +1176 266 +1176 367 +1176 368 +1176 422 +1176 2001 +1176 2018 +3979 8 +3979 9 +3979 125 +3979 128 +3979 175 +3979 250 +3979 353 +3979 424 +3979 754 +3016 995 +3016 1034 +3016 2148 +3016 3070 +3016 3740 +3016 4532 +3016 5179 +3016 5324 +3016 5325 +3016 5326 +4197 5 +4197 31 +4197 126 +4197 143 +4197 180 +4197 250 +4197 368 +4197 697 +4197 856 +4197 1245 +4472 5 +4472 123 +4472 125 +4472 144 +4472 177 +4472 247 +4472 248 +4472 249 +4472 717 +4472 1317 +1859 23 +1859 56 +1859 125 +1859 1137 +1859 3093 +1859 3605 +1859 3606 +1859 3607 +1859 3608 +4628 68 +4628 831 +4628 1787 +4628 2355 +4628 2862 +4628 3304 +4628 3470 +4628 4889 +4628 5384 +4628 5385 +5093 2031 +340 341 +340 342 +340 343 +340 344 +340 345 +340 346 +340 347 +340 348 +340 349 +340 350 +349 473 +349 855 +349 946 +349 1716 +349 2296 +349 2297 +349 2298 +349 2299 +349 2300 +350 329 +350 378 +350 432 +350 558 +350 1734 +350 2264 +350 2328 +350 2329 +350 2330 +350 2331 +881 260 +881 667 +881 837 +881 1511 +881 2579 +881 2593 +881 2594 +881 2595 +881 2771 +881 2772 +1366 1152 +1366 2093 +1366 2215 +1366 2561 +1366 2789 +1366 3214 +1366 3215 +1366 3216 +1366 3217 +2293 118 +2293 717 +2293 771 +2293 1364 +2293 1365 +2293 1366 +2293 1946 +2293 2581 +2293 3985 +2293 3986 +2296 3987 +2299 424 +2299 2127 +2299 2330 +2299 2898 +2299 2907 +2299 2911 +2299 3991 +2299 3992 +2299 3993 +2299 3994 +2300 136 +2300 388 +2300 1456 +2300 1457 +2300 1677 +2300 1936 +2300 3995 +2300 3996 +2300 3997 +1734 157 +1734 351 +1734 554 +1734 814 +1734 1137 +1734 1808 +1734 2870 +1734 3566 +1734 5176 +2329 103 +2329 1631 +2329 2114 +2329 3283 +2329 3329 +2329 3466 +2329 4027 +2329 4028 +2329 4029 +2331 5437 +371 4 +371 7 +371 9 +371 148 +371 251 +371 264 +371 265 +371 367 +371 422 +371 1245 +372 231 +372 295 +372 1928 +372 2177 +372 2315 +372 2316 +372 2317 +372 2318 +372 2319 +372 2320 +377 127 +377 129 +377 176 +377 369 +377 423 +377 718 +377 856 +377 2018 +377 2338 +379 2373 +380 218 +380 1030 +380 1230 +380 1231 +380 1232 +380 1233 +380 1234 +380 1235 +380 1236 +1806 124 +1806 251 +1806 368 +1806 369 +1806 422 +1806 718 +1806 754 +1806 856 +1806 2018 +1806 3216 +1811 117 +1811 522 +1811 711 +1811 1636 +1811 1650 +1811 2792 +1811 3542 +1811 3543 +1811 3544 +1811 3545 +1813 146 +1813 176 +1813 246 +1813 252 +1813 264 +1813 368 +1813 369 +1813 390 +1813 667 +1813 718 +3975 57 +3976 149 +3976 266 +3976 368 +3976 423 +3976 424 +3976 559 +3976 718 +3976 856 +3976 1245 +2593 866 +2593 932 +2593 1303 +2593 1377 +2593 1492 +2593 4190 +2593 4191 +2593 4192 +2593 4193 +3982 108 +3982 503 +3982 534 +3982 1511 +3982 1805 +3982 2090 +3982 3461 +3982 4658 +3982 5022 +1365 1087 +1365 1361 +1365 1477 +1365 2082 +1365 3209 +1365 3210 +1365 3211 +1365 3212 +1365 3213 +3985 563 +3985 1846 +3985 2489 +3985 2517 +3985 3819 +3985 3863 +3985 3988 +3985 4241 +3985 4565 +3985 5023 +3986 531 +3986 749 +3986 1279 +3986 2207 +3986 2383 +3986 2864 +3986 4087 +3986 4734 +3986 5026 +3986 5027 +2868 167 +2868 1232 +2868 1451 +2868 2266 +2868 2723 +2868 2931 +2868 2941 +2868 3375 +2868 3981 +2868 4341 +3127 2157 +3127 2422 +3127 3185 +3127 4573 +3127 4640 +3127 4641 +3309 9 +3309 97 +3309 413 +3309 581 +3309 1023 +3309 1026 +3309 1533 +3309 3460 +3309 3786 +3309 3822 +4207 97 +4207 706 +4207 1685 +4207 1903 +4207 4231 +4282 125 +4282 824 +4282 1088 +4282 2220 +4282 3138 +4282 3468 +4282 4339 +4282 4414 +4282 4502 +4282 5182 +2898 932 +2898 1305 +2898 2353 +2898 2694 +2898 2770 +2898 3138 +2898 4058 +2898 4381 +2898 4382 +2898 4383 +2907 112 +2907 117 +2907 841 +2907 2154 +2907 3526 +2907 4082 +2907 4389 +2907 4390 +2907 4391 +2907 4392 +3991 289 +3991 1846 +3991 2330 +3991 3479 +3991 3632 +3991 4242 +3991 4503 +3991 4587 +3991 5036 +3991 5037 +3997 28 +3997 714 +3997 1861 +3997 2425 +3997 3343 +3997 3386 +3997 3471 +3997 3702 +3997 4189 +3997 4854 +2870 23 +2870 1431 +2870 1754 +2870 2344 +2870 2778 +2870 4360 +2870 4361 +2870 4362 +2870 4363 +2870 4364 +3566 828 +3566 1289 +3566 1491 +3566 2826 +3566 3928 +3566 4104 +3566 4655 +3566 4751 +3566 4825 +3566 4826 +968 739 +968 828 +968 889 +968 969 +968 970 +968 971 +968 972 +968 973 +968 974 +2312 148 +2312 174 +2312 251 +2312 264 +2312 367 +2312 368 +2312 390 +2312 422 +2312 718 +2312 1317 +2313 3 +2313 121 +2313 129 +2313 143 +2313 179 +2313 264 +2313 353 +2313 367 +2313 390 +2313 717 +2314 750 +2314 2067 +2314 2950 +2314 3097 +2314 4172 +2314 4373 +2314 5162 +2314 5163 +2314 5164 +2314 5165 +2325 3144 +2325 3894 +2325 3963 +2325 4021 +2325 4022 +2325 4023 +2325 4024 +2325 4025 +2325 4026 +2332 714 +2332 859 +2332 2515 +2332 2646 +2332 2729 +2332 2965 +2332 4031 +2332 4032 +2332 4033 +2336 158 +2336 1227 +2336 1892 +2336 2099 +2336 2528 +2336 2538 +2336 2799 +2336 2805 +2336 3136 +2336 4041 +2337 450 +2337 452 +2337 532 +2337 1239 +2337 1741 +2337 2381 +2337 2923 +2337 3102 +2337 3728 +972 469 +972 2229 +972 2862 +972 2863 +972 2864 +4004 682 +4004 2149 +4004 2442 +4004 5029 +4004 5030 +4004 5031 +4004 5032 +4004 5033 +4004 5034 +4004 5035 +4005 1228 +4005 1537 +4005 1587 +4005 2291 +4005 2547 +4005 2563 +4005 3846 +4005 5048 +4005 5049 +4005 5050 +750 385 +750 817 +750 1417 +750 2127 +750 2294 +750 2397 +750 2674 +750 2675 +750 2676 +750 2677 +2950 4435 +5163 1002 +5163 3595 +5163 3822 +5163 4607 +5163 4628 +5163 4734 +5163 4880 +5163 5036 +5163 5272 +5163 5671 +5165 5407 +2892 763 +2892 2052 +2892 2628 +2892 2773 +2892 4219 +2892 4372 +2892 4373 +2892 4374 +2892 4375 +2892 4376 +4319 720 +4319 866 +4319 1425 +4319 1719 +4319 2546 +4319 4251 +4319 5210 +4319 5211 +4319 5212 +4319 5213 +1385 69 +1385 191 +1385 616 +1385 3213 +1385 3248 +1385 3249 +1385 3250 +1385 3251 +1385 3252 +1385 3253 +2790 8 +2790 121 +2790 128 +2790 144 +2790 147 +2790 266 +2790 352 +2790 424 +2790 559 +2790 1317 +3080 38 +3080 706 +3080 1904 +3080 3334 +3080 3409 +3080 3679 +3080 3698 +3080 3849 +3080 4501 +3080 4502 +4016 9 +4016 124 +4016 125 +4016 144 +4016 145 +4016 148 +4016 247 +4016 352 +4016 353 +4016 424 +3257 235 +3257 364 +3257 422 +3257 962 +3257 1565 +3257 2699 +3257 2965 +3257 3605 +3257 4380 +3475 18 +3475 498 +3475 1476 +3475 1554 +3475 2383 +3475 3219 +3475 3717 +3475 4778 +3475 4779 +4021 156 +4021 476 +4021 802 +4021 921 +4021 1336 +4021 2347 +4021 2806 +4021 3053 +4021 3343 +4021 3866 +4026 1330 +4026 5124 +4026 5125 +4032 144 +4032 147 +4032 149 +4032 177 +4032 266 +4032 353 +4032 424 +4032 558 +4032 856 +4032 2338 +4033 21 +4033 385 +4033 1084 +4033 1137 +4033 1167 +4033 1342 +4033 2690 +4033 3829 +4033 4876 +4033 4915 +1706 8 +1706 121 +1706 123 +1706 128 +1706 179 +1706 238 +1706 247 +1706 248 +1706 264 +1706 353 +3096 654 +3096 1289 +3096 1860 +3096 4459 +3096 4512 +3096 4517 +3096 4518 +3096 4519 +3096 4520 +4041 924 +4041 1199 +4041 1213 +4041 1608 +4041 1867 +4041 1868 +4041 1915 +4041 3336 +4041 4412 +4041 5052 +450 38 +450 203 +450 451 +450 452 +450 453 +450 454 +450 455 +450 456 +450 457 +2381 193 +2381 924 +2381 1243 +2381 1297 +2381 1515 +2381 1868 +2381 2213 +2381 4066 +2381 4067 +2381 4068 +3102 815 +3102 1066 +3102 2067 +3102 2234 +3102 3916 +3102 4017 +3102 4257 +3102 4478 +3102 4535 +3102 4536 +360 65 +360 361 +360 362 +360 363 +360 364 +360 365 +366 3 +366 124 +366 147 +366 177 +366 251 +366 264 +366 266 +366 367 +366 368 +366 369 +2315 458 +2315 869 +2315 881 +2315 1447 +2315 2886 +2315 3547 +2315 4000 +2315 4001 +2315 4002 +2315 4003 +2318 1021 +2318 2538 +2318 3763 +2318 3789 +2318 4008 +2318 4009 +2318 4010 +2318 4011 +2318 4012 +2318 4013 +1232 263 +1232 1854 +1232 1881 +1232 2493 +1232 3089 +1232 3090 +1232 3091 +1232 3092 +1232 3093 +1232 3094 +1234 228 +1234 342 +1234 1023 +1234 2093 +1234 2612 +1234 2678 +1234 2871 +1234 3095 +1234 3096 +1234 3097 +2886 121 +2886 125 +2886 129 +2886 146 +2886 176 +2886 238 +2886 248 +2886 264 +2886 352 +2886 427 +3547 711 +4000 294 +4000 2964 +4000 4658 +4000 4961 +4000 5038 +4003 3 +4003 8 +4003 127 +4003 143 +4003 177 +4003 248 +4003 352 +4003 353 +4003 367 +4003 424 +4008 1199 +4008 1297 +4008 1867 +4008 2664 +4008 3071 +4008 3801 +4008 4723 +4008 5042 +4008 5043 +4008 5044 +4010 110 +4010 2795 +4010 3003 +4010 3404 +4010 4533 +4010 4904 +4010 5045 +4010 5046 +4010 5047 +4012 1010 +4012 1300 +4012 1571 +4012 2230 +4012 2377 +4012 2887 +4012 3185 +4012 3781 +4012 4655 +4012 4847 +5645 57 +5645 271 +5645 2249 +5645 3675 +5645 4077 +5645 5923 +5645 5924 +5645 5925 +5645 5926 +2693 82 +2693 1536 +2693 1734 +2693 2039 +2693 2433 +2693 2820 +2693 4262 +2693 4263 +2693 4264 +2693 4265 +2944 1240 +2944 1425 +2944 1731 +2944 4537 +2944 4538 +2946 1787 +2946 1939 +2946 2190 +2946 4005 +2946 4007 +2946 4354 +2946 4429 +2946 4430 +2946 4431 +2946 4432 +2949 163 +2949 264 +2949 667 +2949 708 +2949 1903 +2949 1926 +2949 2035 +2949 3365 +2949 4402 +2949 4421 +1854 575 +1854 1290 +1854 1291 +1854 1731 +1854 2049 +1854 2394 +1854 3599 +1854 3602 +1854 3603 +1854 3604 +1881 263 +1881 1085 +1881 1456 +1881 2397 +1881 3392 +1881 3479 +1881 3632 +1881 3633 +1881 3634 +1881 3635 +3092 1424 +3092 1524 +3092 2257 +3092 3053 +3092 3096 +3092 3105 +3092 3269 +3092 3716 +3092 4130 +3092 4532 +2678 2314 +2678 2481 +2678 2788 +2678 2828 +2678 3279 +2678 4251 +2678 4252 +2678 4253 +2678 4254 +2678 4255 +3095 369 +3095 493 +3095 553 +3095 1599 +3095 1796 +3095 2211 +3095 3220 +3095 4521 +3095 4522 +3095 4523 +3095 4524 +3095 4525 +3095 4526 +3095 4527 +3095 4528 +3095 4529 +3095 4530 +3095 4531 +385 23 +385 314 +385 1741 +385 2162 +385 2339 +385 2340 +385 2341 +385 2342 +385 2343 +385 2344 +386 389 +386 609 +386 1077 +386 1451 +386 2035 +386 2360 +386 2361 +386 2362 +386 2363 +386 2364 +389 693 +389 882 +389 951 +389 1383 +389 1538 +389 1792 +389 2271 +389 2357 +389 2358 +389 2359 +996 77 +996 997 +996 998 +2345 510 +2345 881 +2345 3034 +2345 3184 +2345 3547 +2345 4001 +2345 4002 +2345 4042 +2345 4043 +2345 4044 +2347 38 +2347 540 +2347 554 +2347 584 +2347 1424 +2347 1940 +2347 2086 +2347 2653 +2347 4034 +2350 4 +2350 5 +2350 17 +2350 121 +2350 122 +2350 126 +2350 180 +2350 247 +2350 250 +2350 424 +2351 1248 +2351 1335 +2351 1779 +2351 2669 +2351 2792 +2351 3172 +2351 3580 +2351 3935 +2351 4035 +2352 63 +2352 738 +2352 1556 +2352 1949 +2352 2279 +2352 2699 +2352 3204 +2352 3863 +2352 4039 +2352 4040 +2343 338 +2343 1196 +2343 1198 +2343 1766 +2343 2320 +2343 2889 +2343 3113 +2343 3301 +2343 3565 +2343 3566 +1077 1022 +2360 740 +2360 925 +2360 1062 +2360 1245 +2360 3550 +2360 3626 +2360 4053 +2360 4054 +2360 4055 +2360 4056 +2361 325 +2361 2662 +2361 2911 +2361 3384 +2361 4088 +2364 1999 +2364 4050 +2364 4051 +2364 4052 +825 826 +825 827 +825 828 +825 829 +825 830 +825 831 +825 832 +825 833 +825 834 +825 835 +1733 73 +1733 407 +1733 830 +1733 2350 +1733 3491 +1733 3492 +1733 3493 +1733 3494 +1733 3495 +1733 3496 +2356 38 +2356 215 +2356 962 +2356 1522 +2356 2007 +2356 4035 +2356 4036 +2356 4037 +2356 4038 +882 2774 +997 522 +997 1332 +997 1829 +997 2061 +997 2383 +997 2507 +997 2902 +998 181 +998 668 +998 1536 +998 1735 +998 2023 +998 2451 +998 2898 +998 2899 +998 2900 +998 2901 +3034 127 +3034 289 +3034 1223 +3034 3035 +3034 3795 +3034 4292 +3034 4388 +3034 4466 +3034 4467 +4043 744 +4043 749 +4043 946 +4043 2040 +4043 2286 +4043 2912 +4043 4432 +4043 4675 +4043 5054 +4043 5055 +2699 3 +2699 122 +2699 127 +2699 143 +2699 146 +2699 177 +2699 238 +2699 249 +2699 352 +2699 856 +3550 748 +3550 813 +3550 1587 +3550 1766 +3550 2198 +3550 2744 +3550 2859 +3550 3080 +3550 4280 +3550 4815 +3626 102 +3626 1262 +3626 1647 +3626 3615 +3626 4412 +2662 4250 +684 93 +684 1376 +684 1955 +684 2227 +684 2300 +684 2421 +684 2630 +684 2631 +684 2632 +684 2633 +2666 8 +2666 1036 +2666 1482 +2666 1485 +2666 2035 +2666 4868 +2666 5154 +2666 5806 +2666 5807 +2666 5808 +4051 122 +4051 175 +4051 250 +4051 252 +4051 266 +4051 367 +4051 423 +4051 558 +4051 754 +4051 2001 +830 4 +830 31 +830 148 +830 179 +830 180 +830 368 +830 666 +830 736 +830 886 +830 2018 +407 412 +407 1217 +407 1749 +407 2392 +3495 3 +3495 145 +3495 174 +3495 176 +3495 177 +3495 249 +3495 251 +3495 353 +3495 1317 +3495 3995 +3496 566 +3496 645 +3496 674 +3496 884 +3496 1926 +3496 2302 +3496 2857 +3496 3768 +3496 4655 +1522 140 +1522 609 +1522 693 +1522 730 +1522 1249 +1522 1313 +1522 1349 +1522 2032 +1522 3328 +1522 3329 +4036 813 +4036 842 +4036 924 +4036 2904 +4036 2928 +4036 3058 +4036 3109 +4036 4248 +4036 4978 +4038 2236 +2604 4166 +2606 7 +2606 123 +2606 125 +2606 145 +2606 148 +2606 177 +2606 179 +2606 247 +2606 559 +2606 2018 +2607 357 +2607 1092 +2607 1866 +2607 2279 +2607 4150 +2607 4205 +2607 4206 +2607 4207 +2607 4208 +2607 4209 +2774 2440 +1001 614 +1001 788 +1001 1071 +1001 1100 +1001 1291 +1001 2198 +1001 2931 +1001 2932 +1001 2933 +1001 2934 +1001 2935 +1001 2936 +3536 751 +3536 1802 +3536 3795 +3536 3918 +3536 4804 +3536 4805 +3536 4806 +3536 4807 +3537 123 +3537 126 +3537 145 +3537 149 +3537 177 +3537 352 +3537 353 +3537 424 +3537 558 +3537 754 +3539 47 +3539 503 +3539 1342 +3539 3460 +3539 4199 +3539 4281 +3539 4727 +3539 4808 +3539 4809 +3539 4810 +2374 5 +2374 125 +2374 129 +2374 145 +2374 247 +2374 249 +2374 367 +2374 424 +2374 427 +2374 1317 +2375 2035 +2375 2298 +2375 3112 +2375 3695 +2375 4057 +2375 4058 +2375 4059 +2375 4060 +2375 4061 +2375 4062 +2376 94 +2376 522 +2376 802 +2376 1332 +2376 1738 +2376 2658 +2376 2906 +2376 3357 +2376 4065 +1243 138 +1243 982 +1243 988 +1243 1787 +1243 2465 +1243 2663 +1243 3106 +1243 3107 +1243 3108 +4068 113 +4068 363 +4068 828 +4068 2414 +4068 4885 +4068 4904 +4068 4953 +4068 5060 +4068 5061 +4068 5062 +2420 503 +2420 614 +2420 1763 +2420 2298 +2420 3014 +2420 3071 +2420 3439 +2420 3860 +2420 4093 +2420 4094 +4070 633 +4070 989 +4070 1726 +4070 2207 +4070 2615 +4070 2641 +4070 5059 +4070 5063 +4070 5064 +4070 5065 +2866 364 +2866 619 +2866 706 +2866 1620 +2866 1787 +2866 2089 +2866 3017 +2866 3156 +2866 3930 +2866 4368 +4057 459 +4057 1034 +4057 1054 +4057 1374 +4057 2833 +4057 5066 +4057 5067 +4057 5068 +4057 5069 +4058 550 +4058 628 +4058 1750 +4058 2649 +4058 5056 +4058 5057 +4059 3789 +4060 1571 +4060 1918 +4060 2543 +4060 2571 +4060 2745 +4060 2935 +4060 3153 +4060 4172 +4060 4492 +4060 4919 +4062 1787 +4062 2901 +4062 3058 +4062 3334 +4062 3672 +4062 4871 +4062 4880 +4062 5058 +4062 5059 +500 59 +500 1475 +500 1476 +2798 177 +2798 261 +2798 266 +2798 1134 +2798 1529 +2798 3304 +2798 3590 +2798 4307 +2798 4308 +2798 4309 +399 400 +399 401 +399 402 +399 403 +399 404 +399 405 +399 406 +399 407 +399 408 +399 409 +406 1999 +409 3 +409 146 +409 147 +409 175 +409 247 +409 248 +409 266 +409 368 +409 422 +409 2018 +1217 554 +1217 1424 +1217 1670 +1217 1749 +1217 2341 +1217 2672 +1217 2839 +1217 3081 +1217 3082 +1217 3083 +3081 9 +3081 549 +3081 1480 +3081 2089 +3081 2385 +3081 2719 +3081 3039 +3081 4278 +3081 4503 +3081 4504 +804 778 +804 805 +804 806 +804 807 +804 808 +804 809 +804 810 +804 811 +804 812 +804 813 +804 814 +804 815 +804 816 +804 817 +1339 377 +3346 75 +3346 759 +3346 1583 +3346 2248 +3346 2490 +3346 3966 +3346 4281 +3346 4464 +3346 4683 +3346 4684 +4081 541 +4081 760 +4081 937 +4081 1022 +4081 1929 +4081 1940 +4081 3738 +4081 4402 +4081 5076 +410 411 +410 412 +410 413 +410 414 +410 415 +410 416 +410 417 +410 418 +410 419 +410 420 +413 2393 +415 156 +415 427 +415 676 +415 799 +415 803 +415 1018 +415 1019 +415 1020 +415 1021 +416 640 +416 1002 +416 1477 +416 2013 +416 2327 +416 2434 +416 2435 +416 2436 +416 2437 +416 2438 +418 763 +418 1541 +418 1944 +418 2467 +418 2468 +418 2469 +418 2470 +418 2471 +1002 20 +1002 95 +1002 341 +1002 478 +1002 798 +1002 892 +1002 1408 +1002 1439 +1002 1440 +1002 1441 +1477 3 +1477 4 +1477 17 +1477 122 +1477 176 +1477 264 +1477 422 +1477 666 +1477 856 +2471 57 +2471 272 +2471 274 +2471 834 +2471 1583 +2471 2102 +2471 2141 +2471 2635 +2471 4120 +1328 1249 +1328 2377 +1328 2413 +1328 2448 +1328 3169 +1328 3170 +1328 3171 +1328 3172 +1328 3173 +1328 3174 +2670 4 +2670 121 +2670 145 +2670 148 +2670 174 +2670 252 +2670 265 +2670 422 +2670 559 +2670 666 +2702 351 +2702 2419 +2702 2566 +2702 3007 +2702 3797 +2702 3953 +2702 4266 +2702 4267 +2702 4268 +2702 4269 +2704 837 +2767 8 +2767 9 +2767 127 +2767 128 +2767 238 +2767 248 +2767 352 +2767 427 +2767 1317 +2767 4303 +4160 3 +4160 7 +4160 9 +4160 124 +4160 125 +4160 126 +4160 128 +4160 176 +4160 247 +4160 424 +551 586 +551 765 +551 955 +551 982 +551 1288 +551 1311 +551 2336 +551 2516 +551 2517 +551 2518 +945 336 +945 660 +945 801 +945 940 +945 1095 +945 2846 +945 3777 +945 4409 +945 4410 +945 4411 +2926 664 +2927 868 +2927 963 +2927 1749 +2927 2298 +2927 3717 +2927 4265 +2927 5777 +2927 5778 +2927 5779 +2927 5780 +2930 2158 +1440 292 +1440 1177 +1440 1557 +1440 1718 +1440 2656 +1440 3302 +1440 3303 +1440 3304 +1440 3305 +1440 3306 +548 469 +548 549 +548 550 +548 551 +548 552 +548 553 +548 554 +548 555 +548 556 +679 270 +679 680 +679 681 +679 682 +679 683 +679 684 +679 685 +679 686 +679 687 +679 688 +3323 122 +3323 127 +3323 145 +3323 148 +3323 176 +3323 177 +3323 249 +3323 424 +3323 427 +3323 1246 +421 8 +421 122 +421 123 +421 125 +421 264 +421 352 +421 390 +421 422 +421 423 +421 424 +4083 4317 +425 8 +425 121 +425 122 +425 128 +425 147 +425 177 +425 251 +425 422 +425 426 +425 427 +2596 1491 +2596 1689 +2596 2083 +2596 3681 +2596 3953 +2596 4194 +2596 4195 +2596 4196 +2596 4197 +2596 4198 +428 429 +428 430 +428 431 +428 432 +428 433 +428 434 +428 435 +428 436 +428 437 +428 438 +430 826 +430 1415 +430 2235 +430 2373 +430 2416 +430 2417 +430 2418 +430 2419 +430 2420 +430 2421 +431 487 +431 2214 +431 2311 +431 2422 +431 2423 +431 2424 +431 2425 +431 2426 +431 2427 +431 2428 +434 4 +434 5 +434 7 +434 127 +434 145 +434 148 +434 266 +434 559 +434 1317 +434 2018 +435 127 +437 1090 +437 1486 +437 2500 +438 156 +438 456 +438 1383 +438 1522 +438 2094 +438 2220 +438 2443 +438 2444 +438 2445 +438 2446 +2425 108 +2425 354 +2425 1968 +2425 2155 +2425 2964 +2425 3046 +2425 4098 +2425 4099 +2425 4100 +2425 4101 +1090 1374 +1090 1516 +1090 1568 +1090 1861 +1090 2078 +1090 2222 +1090 2430 +1090 3110 +1090 3111 +2444 478 +2444 2288 +2444 2420 +2444 2657 +2444 2690 +2444 3698 +2444 3700 +2444 4102 +2444 4103 +2444 4104 +747 2051 +747 2427 +747 2648 +747 2667 +747 2668 +747 2669 +747 2670 +747 2671 +747 2672 +747 2673 +2897 262 +2897 396 +2897 1397 +2897 4307 +2897 4366 +2897 4377 +2897 4378 +2897 4379 +2897 4380 +3273 623 +3273 962 +3273 1177 +3273 2337 +3273 2427 +3273 3981 +3273 4645 +3273 4646 +3273 4647 +1691 3669 +4098 762 +4098 2593 +4098 3956 +4098 4118 +4098 4871 +4095 38 +4095 257 +4095 573 +4095 2274 +4095 3299 +4095 3409 +4095 4164 +4095 4230 +4095 4695 +4095 5077 +4096 1772 +1377 247 +1377 963 +1377 1135 +1377 2006 +1377 2237 +1377 3082 +1377 3105 +1377 3224 +1377 3225 +1377 3226 +4149 5105 +4151 5091 +4102 50 +4102 2557 +4103 9 +4103 17 +4103 175 +4103 252 +4103 390 +4103 422 +4103 559 +4103 856 +4103 1245 +4103 1770 +439 440 +439 441 +439 442 +439 443 +439 444 +439 445 +439 446 +439 447 +439 448 +439 449 +448 108 +448 128 +448 148 +448 878 +448 1317 +448 1376 +448 1556 +448 1912 +448 2439 +448 2440 +2492 64 +2492 813 +2492 852 +2492 1608 +2492 1868 +2492 3196 +2492 3421 +2492 3617 +2492 4040 +4781 679 +4781 963 +4781 1359 +4781 5478 +4781 5479 +4781 5480 +4781 5481 +4781 5482 +4781 5483 +4781 5484 +878 59 +878 202 +878 510 +878 879 +878 880 +878 881 +878 882 +878 883 +878 884 +878 885 +2440 1881 +2440 4957 +2440 5304 +2440 5305 +963 1054 +963 1124 +963 1831 +963 2287 +963 2291 +963 2686 +963 2851 +963 2852 +963 2853 +963 2854 +5478 122 +5478 123 +5478 145 +5478 148 +5478 238 +5478 353 +5478 424 +5478 697 +5478 736 +5478 2001 +5479 2697 +5479 4065 +5479 5882 +885 2773 +5304 113 +5304 2313 +5304 2932 +5304 3017 +5304 3134 +5304 4702 +5304 5281 +5304 5299 +5304 5510 +5304 5657 +466 2447 +466 2448 +466 2449 +466 2450 +466 2451 +4121 732 +4121 960 +4121 1430 +4121 2259 +4121 2655 +4121 3937 +4121 4348 +4121 5083 +4121 5084 +4121 5085 +4122 77 +4122 1030 +4122 1721 +4122 1947 +4122 1982 +4122 2377 +4122 2448 +4122 2523 +4122 3153 +4122 3171 +469 41 +469 102 +469 470 +469 471 +469 472 +469 473 +469 474 +469 475 +469 476 +469 477 +475 1670 +475 1915 +475 2480 +475 2481 +475 2482 +475 2483 +475 2484 +475 2485 +475 2486 +475 2487 +581 2538 +1685 222 +1685 521 +1685 779 +1685 1652 +1685 1686 +1685 1687 +1685 1688 +1685 1689 +1685 1690 +1685 1691 +4502 125 +4502 174 +4502 424 +4502 503 +4502 1142 +4502 1516 +4502 2537 +4502 4170 +4502 5331 +4502 5332 +2654 836 +2654 908 +2654 1412 +2654 2076 +2654 2461 +2654 2660 +2654 3767 +2654 3995 +2654 4243 +2654 4244 +4124 1208 +4124 2474 +4124 2636 +4124 3404 +4124 3733 +4124 3806 +4124 4687 +4124 5087 +4124 5088 +4124 5089 +479 2452 +479 2453 +479 2454 +479 2455 +479 2456 +479 2457 +479 2458 +479 2459 +479 2460 +479 2461 +480 382 +480 507 +480 722 +480 726 +480 1048 +480 2319 +480 2358 +480 2462 +480 2463 +481 4 +481 124 +481 265 +481 353 +481 368 +481 369 +481 695 +481 700 +481 946 +481 947 +483 1812 +2452 77 +2452 1027 +2452 1321 +2452 1925 +2452 2373 +2452 3156 +2452 3849 +2452 4106 +2452 4107 +2452 4108 +2453 125 +2453 126 +2453 128 +2453 145 +2453 179 +2453 180 +2453 250 +2453 856 +2453 2001 +2454 586 +2459 215 +2459 856 +2459 960 +2459 1103 +2459 1152 +2459 1402 +2459 1709 +2459 3165 +2459 3866 +2459 4109 +2460 892 +2460 1019 +2460 1342 +2460 1476 +2460 2530 +2460 2531 +2460 2532 +2460 3874 +2460 4110 +2460 4111 +2461 559 +2461 1005 +2461 1081 +2461 1425 +2461 1549 +2461 2791 +2461 2796 +2461 4044 +2461 4112 +2461 4113 +507 3 +507 127 +507 143 +507 249 +507 251 +507 252 +507 427 +507 2491 +507 2492 +722 2713 +726 152 +726 406 +726 540 +726 3459 +726 3654 +726 3726 +726 4072 +726 5137 +726 5138 +726 5139 +2463 5 +2463 933 +2463 2592 +2463 2797 +2463 2798 +2463 3105 +2463 3927 +2463 4084 +2463 4114 +2463 4115 +1352 124 +1352 126 +1352 145 +1352 174 +1352 179 +1352 423 +1352 667 +1352 1353 +1352 1354 +1352 1355 +3156 477 +3156 710 +3156 2347 +3156 2540 +3156 3489 +3156 4344 +3156 4563 +3156 4564 +3156 4565 +4106 452 +4106 453 +4106 1587 +4106 3404 +4106 5081 +4107 652 +4107 816 +4107 1097 +4107 3714 +4107 3904 +4107 4012 +4107 4122 +4107 5078 +4107 5079 +4107 5080 +4109 795 +4109 843 +4109 979 +4109 1172 +4109 2085 +4109 2561 +4109 3925 +4109 4075 +4109 4183 +4109 5082 +2530 63 +2530 933 +2530 1220 +2530 1618 +2530 2579 +2530 2626 +2530 3758 +2530 4155 +2530 4156 +2530 4157 +4111 5 +4111 31 +4111 149 +4111 177 +4111 179 +4111 250 +4111 352 +4111 558 +4111 697 +4111 1317 +1081 512 +1081 922 +1081 940 +1081 1720 +1081 2978 +1081 2979 +1081 2980 +1081 2981 +1081 2982 +1081 2983 +1549 130 +1549 1009 +1549 1629 +1549 2230 +1549 2587 +1549 2673 +1549 3341 +2796 3 +2796 5 +2796 7 +2796 8 +2796 125 +2796 126 +2796 149 +2796 247 +2796 249 +2796 424 +4112 7 +4112 8 +4112 145 +4112 148 +4112 174 +4112 266 +4112 424 +4112 856 +4112 2338 +4113 123 +4113 127 +4113 176 +4113 179 +4113 248 +4113 249 +4113 352 +4113 422 +4113 427 +4113 667 +3654 586 +3654 1089 +3654 1280 +3654 1923 +3654 2723 +3654 4009 +3654 4124 +3654 4584 +3654 4877 +3654 4878 +5137 125 +5137 129 +5137 144 +5137 147 +5137 148 +5137 179 +5137 352 +5137 1246 +5137 1317 +5137 2001 +5138 2383 +1055 257 +1055 1347 +1055 2207 +1055 2411 +1055 2802 +1055 2968 +1055 2969 +1055 2970 +1055 2971 +2797 5 +2797 17 +2797 125 +2797 126 +2797 143 +2797 149 +2797 175 +2797 754 +2797 856 +4114 124 +4114 127 +4114 251 +4114 264 +4114 390 +4114 427 +4114 559 +4114 667 +4114 1245 +4114 2018 +1433 121 +1433 124 +1433 129 +1433 143 +1433 146 +1433 147 +1433 183 +1433 266 +1433 559 +1433 718 +2464 182 +2464 652 +2464 892 +2464 1988 +2464 2448 +2464 2982 +2464 4116 +2464 4117 +2464 4118 +2464 4119 +2465 3 +2465 31 +2465 124 +2465 146 +2465 175 +2465 180 +2465 247 +2465 266 +2465 367 +2465 2001 +652 175 +652 389 +652 424 +652 732 +652 1326 +652 2199 +652 2572 +652 2573 +652 2574 +652 2575 +4117 5086 +2961 345 +2961 415 +2961 937 +2961 1001 +2961 2377 +2961 3242 +2961 3906 +2961 4192 +2961 4433 +2961 4434 +499 71 +499 466 +499 500 +499 501 +499 502 +499 503 +499 504 +499 505 +499 506 +499 507 +504 3 +504 123 +504 125 +504 146 +504 264 +504 352 +504 353 +504 427 +504 1245 +504 1246 +505 5 +505 125 +505 145 +505 148 +505 174 +505 264 +505 368 +505 422 +505 1317 +505 2018 +508 260 +508 452 +508 487 +508 509 +508 510 +508 511 +508 512 +508 513 +508 514 +508 515 +509 14 +509 193 +509 363 +509 503 +509 828 +509 840 +509 2447 +509 2488 +509 2489 +509 2490 +2489 2661 +516 350 +516 517 +516 518 +516 519 +516 520 +516 521 +516 522 +516 523 +516 524 +516 525 +521 27 +521 117 +521 325 +521 577 +521 578 +521 579 +521 580 +521 581 +521 582 +521 583 +577 164 +577 584 +577 642 +577 977 +577 1610 +577 2506 +577 2525 +577 2526 +577 2527 +577 2528 +580 3 +580 910 +580 1275 +580 1427 +580 1782 +580 1792 +580 2539 +580 2540 +580 2541 +580 2542 +1610 60 +1610 234 +1610 269 +1610 721 +1610 1539 +1610 1611 +1610 1612 +1610 1613 +1610 1614 +1610 1615 +2506 983 +2506 2223 +2506 2646 +2506 2733 +2506 3569 +2506 3772 +2506 3894 +2506 4061 +2506 4141 +2506 4142 +2529 11 +2529 1904 +2529 2061 +2529 3080 +2529 3487 +2529 3849 +2529 4263 +2529 4980 +2529 5159 +2529 5600 +715 638 +715 834 +715 1068 +715 1195 +715 2472 +715 2645 +715 2646 +715 2647 +715 2648 +715 2649 +2536 2254 +526 56 +526 527 +528 17 +528 241 +528 529 +528 530 +528 531 +528 532 +528 533 +528 534 +528 535 +528 536 +533 1482 +533 1512 +533 1607 +533 2498 +533 2499 +533 2500 +533 2501 +533 2502 +533 2503 +533 2504 +536 1132 +2501 5 +2501 123 +2501 125 +2501 126 +2501 129 +2501 144 +2501 148 +2501 149 +2501 248 +2501 1317 +2503 132 +2503 181 +2503 397 +2503 707 +2503 1786 +2503 2750 +2503 2751 +2503 3801 +2503 3995 +2503 4136 +2504 894 +2504 1248 +2504 2653 +2504 3555 +2504 3775 +2504 4131 +2504 4132 +2504 4133 +2504 4134 +2504 4135 +1827 434 +1827 979 +1827 1697 +1827 1828 +1827 1829 +1827 1830 +1827 1831 +1827 1832 +1827 1833 +3171 113 +3171 870 +3171 997 +3171 3995 +3171 4017 +3171 4120 +3171 4206 +3171 4402 +3171 4569 +3171 4570 +4846 926 +4846 1258 +4846 1382 +4846 1706 +4846 3062 +4846 3064 +4846 4170 +4846 4339 +4846 5881 +5236 125 +5236 143 +5236 145 +5236 146 +5236 147 +5236 367 +5236 368 +5236 422 +5236 559 +5236 754 +5238 208 +5238 347 +5238 724 +5238 3129 +5238 3823 +5238 4764 +5238 5726 +5238 5727 +5238 5728 +5238 5729 +3129 334 +3129 2360 +3129 3634 +3129 3962 +3129 4548 +4143 685 +4143 1036 +4143 1797 +4143 2334 +4143 3562 +4144 322 +4144 462 +4144 1447 +4144 1481 +4144 1615 +4144 4214 +4144 4307 +4144 4955 +4144 5097 +4144 5098 +4146 621 +4146 2347 +4146 2537 +4146 3372 +4146 3485 +4146 3498 +4146 3608 +4146 4397 +4146 5103 +707 115 +707 1047 +707 1107 +707 1503 +707 1656 +707 1803 +707 2641 +707 2642 +707 2643 +707 2644 +3555 1039 +3555 1792 +3555 2314 +3555 4148 +3555 4350 +3555 4362 +3555 4675 +3555 4818 +3555 4819 +3555 4820 +537 538 +537 539 +537 540 +537 541 +537 542 +537 543 +537 544 +537 545 +537 546 +537 547 +541 200 +541 710 +541 2534 +544 522 +544 2505 +544 2506 +544 2507 +544 2508 +544 2509 +544 2510 +544 2511 +544 2512 +544 2513 +547 117 +547 335 +547 824 +547 1790 +547 2078 +547 2151 +547 2240 +547 2418 +547 2514 +547 2515 +2505 23 +2505 133 +2505 916 +2505 3594 +2505 4137 +2510 49 +2510 101 +2510 1339 +2510 1628 +2510 2114 +2510 2231 +2510 3077 +2510 4138 +2510 4139 +2510 4140 +4137 264 +4137 385 +4137 1227 +4137 1281 +4137 1310 +4137 3266 +4137 4077 +4137 4345 +4137 4362 +4137 4739 +4139 268 +4139 487 +4139 1339 +4139 2220 +4139 2898 +4139 4307 +4139 4328 +4139 4382 +4139 4841 +4139 4993 +4140 248 +4140 344 +4140 387 +4140 894 +4140 1942 +4140 2383 +4140 2394 +4140 3921 +4140 4210 +4140 5090 +553 2 +553 4 +553 175 +553 251 +553 554 +553 695 +553 696 +553 697 +553 946 +553 2077 +1636 197 +1636 1553 +1636 1672 +1636 2629 +1636 3033 +1636 3389 +1636 3390 +1636 3391 +1636 3392 +1636 3393 +2695 3 +2695 124 +2695 127 +2695 264 +2695 353 +2695 718 +2695 1245 +2695 1670 +2695 1878 +2695 1989 +4669 141 +4669 289 +4669 2227 +4669 2353 +4669 2625 +4669 3162 +4669 3562 +4669 5414 +4669 5415 +4669 5416 +557 124 +557 127 +557 147 +557 248 +557 251 +557 252 +557 390 +557 423 +557 558 +557 559 +760 38 +760 528 +760 536 +760 1688 +760 2026 +760 2152 +760 2517 +760 2687 +760 2688 +760 2689 +2710 163 +2710 464 +2710 919 +2710 2911 +2710 2948 +2710 3196 +2710 4272 +2710 4273 +2712 8 +2712 17 +2712 31 +2712 126 +2712 144 +2712 145 +2712 149 +2712 174 +2712 559 +2712 717 +928 2652 +1223 651 +1223 751 +1223 1800 +1223 1827 +1223 3156 +1223 3905 +1223 3981 +1223 5192 +1223 5311 +1223 5312 +2735 92 +2735 487 +2735 892 +2735 1718 +2735 2952 +2735 3163 +2735 3169 +2735 3471 +2735 4291 +2735 4292 +563 1575 +563 2582 +563 2583 +563 2584 +1325 731 +560 561 +560 562 +560 563 +560 564 +560 565 +560 566 +560 567 +560 568 +560 569 +560 570 +805 57 +805 106 +805 528 +805 637 +805 686 +805 769 +805 770 +805 1644 +805 2738 +805 2739 +811 643 +811 712 +811 965 +811 1151 +811 2176 +811 2729 +811 2730 +811 2731 +811 2732 +811 2733 +1356 48 +1356 270 +1356 281 +1356 472 +1356 1357 +1356 1358 +1356 1359 +1356 1360 +1356 1361 +4158 584 +4158 770 +4158 2229 +4158 3982 +4158 4739 +4158 4783 +4158 5099 +4158 5100 +4158 5101 +4158 5102 +4159 230 +4159 1425 +4159 2058 +4159 2869 +4159 3759 +4159 3786 +4159 4068 +4159 4270 +4159 5361 +4159 5788 +1318 756 +1318 1272 +1318 1273 +1318 1541 +1318 1955 +1318 2758 +1318 3159 +1318 3160 +1318 3161 +1318 3162 +1319 121 +1319 147 +1319 248 +1319 252 +1319 264 +1319 390 +1319 423 +1319 559 +1319 667 +1319 1245 +2773 557 +2773 583 +2773 810 +2773 832 +2773 1728 +2773 1866 +2773 2974 +2773 4304 +2773 4305 +720 4 +720 5 +720 8 +720 126 +720 145 +720 149 +720 353 +720 424 +720 2001 +720 2018 +5211 115 +5211 279 +5211 1597 +5211 2547 +5211 2594 +5211 3021 +5211 3912 +5211 4894 +5211 5121 +5211 5703 +5213 253 +5213 2330 +5213 2552 +5213 3883 +5213 5501 +5213 5705 +5213 5706 +5213 5707 +1832 604 +1832 1154 +1832 1408 +1832 1754 +1832 1888 +1832 1967 +1832 1984 +1832 1985 +1832 3583 +1832 3584 +4206 123 +4206 369 +4206 504 +4206 1442 +4206 1487 +4206 2060 +4206 3304 +4206 5146 +4206 5147 +4206 5148 +4402 190 +4402 3895 +4402 5220 +4402 5345 +4569 581 +4569 1026 +4569 2965 +4569 4455 +4569 4516 +4569 4821 +4569 4844 +4569 5359 +4569 5360 +4569 5361 +1258 145 +1258 149 +1258 177 +1258 247 +1258 699 +1258 856 +1258 1317 +1258 2063 +1258 3002 +1258 3118 +5881 6039 +724 152 +724 215 +724 725 +724 1313 +724 1424 +724 1434 +724 2443 +724 2653 +724 2654 +5726 4 +5726 9 +5726 17 +5726 126 +5726 149 +5726 175 +5726 422 +5726 559 +5726 754 +5727 1531 +5727 2241 +5727 2804 +5727 3334 +5727 5844 +5727 5947 +5727 5948 +5727 5949 +5727 5950 +5727 5951 +5729 586 +5729 898 +5729 2198 +5729 2227 +5729 2789 +5729 3275 +5729 4280 +5729 5756 +5729 5952 +5729 5953 +1612 1724 +1612 2222 +1612 3377 +1612 3378 +4263 11 +4263 20 +4263 1389 +4263 2628 +4263 2668 +4263 3080 +4263 3177 +4263 3945 +4263 4876 +4263 4980 +5600 4943 +2626 4227 +4157 5096 +2803 633 +2803 942 +2803 2095 +2803 2307 +2803 2327 +2803 2870 +2803 2927 +2803 3204 +2803 3808 +2803 4310 +1276 901 +1276 2075 +1276 2585 +1276 2874 +1276 3128 +1276 3153 +1276 3154 +1276 3155 +1276 3156 +1276 3157 +1278 412 +1278 1299 +1278 1947 +1278 1974 +1278 2035 +1278 2228 +1278 2547 +1278 3709 +1278 3841 +1278 5199 +1279 1227 +1279 1787 +1279 1993 +1279 2626 +1279 3017 +1279 3128 +1279 3129 +1279 3130 +1279 3131 +1279 3132 +1281 483 +1281 833 +1281 1431 +1281 1509 +1281 2034 +1281 2236 +1281 3133 +1281 3134 +1281 3135 +1281 3136 +1585 281 +1585 562 +1585 1586 +1585 1587 +1585 1588 +1585 1589 +1585 1590 +1585 1591 +1585 1592 +1585 1593 +3531 38 +3531 412 +3531 2266 +3531 2583 +3531 3441 +3531 3619 +3531 3671 +3531 3674 +3531 3868 +3531 4033 +1290 176 +1290 177 +1290 179 +1290 248 +1290 249 +1290 352 +1290 422 +1290 427 +1290 717 +1290 1317 +588 589 +588 590 +588 591 +588 592 +588 593 +588 594 +588 595 +588 596 +588 597 +588 598 +599 437 +599 564 +599 581 +599 600 +599 601 +599 602 +599 603 +599 604 +599 605 +599 606 +605 8 +605 121 +605 127 +605 147 +605 176 +605 238 +605 352 +605 353 +605 422 +605 424 +606 87 +606 820 +606 1040 +606 1097 +606 1439 +606 1644 +606 1730 +606 2555 +606 2556 +606 2557 +2962 823 +2962 1457 +2962 2397 +2962 2637 +2962 2873 +2962 2898 +2962 3127 +2962 3992 +2962 4443 +607 608 +607 609 +607 610 +607 611 +607 612 +607 613 +607 614 +607 615 +607 616 +608 2026 +610 881 +610 1217 +610 1392 +610 1990 +610 2273 +610 2558 +610 2559 +610 2560 +610 2561 +610 2562 +611 532 +611 586 +611 740 +611 808 +611 1500 +611 2265 +611 2480 +611 2543 +611 2544 +611 2545 +613 1631 +613 2337 +613 2453 +613 2546 +613 2547 +613 2548 +613 2549 +613 2550 +613 2551 +2559 43 +2559 788 +2559 2069 +2559 4170 +2559 4171 +2562 529 +2562 541 +2562 1787 +2562 1892 +2562 3280 +2562 3489 +2562 3779 +2562 4182 +2562 4183 +2562 4184 +2544 8 +2544 282 +2544 837 +2544 1048 +2544 2086 +2544 3032 +2544 4163 +2544 4164 +2544 4165 +2548 17 +2548 146 +2548 175 +2548 266 +2548 423 +2548 558 +2548 559 +2548 667 +2548 697 +2548 1245 +2549 5 +2549 126 +2549 148 +2549 149 +2549 179 +2549 180 +2549 266 +2549 754 +2549 1245 +2549 2018 +2550 2163 +4183 463 +4183 1235 +4183 2500 +4183 2823 +4183 4321 +4183 5109 +4183 5110 +4183 5111 +4183 5112 +4183 5113 +1255 148 +1255 150 +1255 179 +1255 352 +1255 390 +1255 906 +1255 1317 +1255 3115 +1255 3116 +1255 3117 +1557 367 +1557 562 +1557 931 +1557 943 +1557 1122 +1557 1177 +1557 1558 +1557 1559 +1557 1560 +1557 1561 +2663 107 +2663 325 +2663 1412 +2663 1504 +2663 2862 +2663 3204 +2663 3292 +2663 4247 +2663 4248 +2663 4249 +3032 125 +3032 128 +3032 148 +3032 248 +3032 353 +3032 424 +3032 559 +3032 1317 +3032 2001 +4164 8 +4164 121 +4164 127 +4164 146 +4164 177 +4164 353 +4164 369 +4164 422 +4164 427 +4164 717 +617 618 +617 619 +617 620 +617 621 +617 622 +617 623 +617 624 +617 625 +617 626 +617 627 +620 396 +620 409 +620 469 +620 534 +620 1583 +620 2272 +620 2385 +620 2552 +620 2553 +620 2554 +1400 326 +1400 657 +1400 922 +1400 3262 +1400 3263 +1400 3264 +1400 3265 +1400 3266 +1400 3267 +1400 3268 +4167 1026 +4167 1898 +4167 2784 +4167 2826 +4167 2886 +4167 3001 +4167 3220 +4167 3858 +4167 4102 +4167 5104 +4635 443 +4635 664 +4635 828 +4635 942 +4635 2772 +4635 4066 +4635 4333 +4635 4439 +4635 5396 +1546 1547 +1546 1548 +1546 1549 +1546 1550 +1546 1551 +1546 1552 +1546 1553 +1546 1554 +1546 1555 +1546 1556 +3266 651 +3266 1935 +3266 2032 +3266 2724 +3266 2948 +3266 3066 +3266 4638 +3266 4639 +3295 925 +3295 1387 +3295 1451 +3295 1587 +3295 2322 +3295 2430 +3295 2790 +3295 3586 +3295 4288 +3295 4663 +3297 921 +631 15 +631 632 +631 633 +631 634 +631 635 +634 308 +634 503 +634 717 +634 2941 +634 2968 +634 3112 +634 5880 +634 6131 +634 6132 +634 6133 +635 367 +635 404 +635 474 +635 668 +635 746 +635 747 +635 748 +635 749 +635 750 +635 751 +6132 3 +6132 125 +6132 176 +6132 249 +6132 251 +6132 353 +6132 559 +6132 754 +6132 1317 +6132 3371 +3371 265 +3371 385 +3371 4707 +3371 4708 +1417 8 +1417 121 +1417 122 +1417 123 +1417 127 +1417 147 +1417 177 +1417 246 +1417 251 +1417 353 +2676 63 +636 475 +636 507 +636 637 +636 638 +636 639 +636 640 +636 641 +636 642 +636 643 +1367 3218 +644 645 +645 330 +645 2223 +645 2430 +645 2563 +645 2564 +647 216 +647 585 +647 648 +647 649 +647 650 +647 651 +647 652 +647 653 +647 654 +647 655 +654 798 +654 1023 +654 1365 +654 2475 +654 2516 +654 2559 +654 2568 +654 2569 +654 2570 +654 2571 +655 1032 +655 1246 +655 1378 +655 1411 +655 1836 +655 1999 +655 2200 +655 2565 +655 2566 +655 2567 +2575 484 +2575 548 +2575 568 +2575 690 +2575 756 +2575 872 +2575 1025 +2575 2897 +2575 4173 +2575 4174 +1411 558 +1411 576 +1411 1412 +1411 1413 +1411 1414 +1411 1415 +1411 1416 +1411 1417 +1411 1418 +3192 2 +3192 8 +3192 248 +3192 390 +3192 554 +3192 697 +3192 946 +3192 1317 +3192 2001 +3192 2077 +3194 4587 +4174 8 +4174 122 +4174 143 +4174 146 +4174 174 +4174 196 +4174 352 +4174 353 +4174 369 +4174 424 +3210 691 +3210 2055 +3210 2691 +3210 2935 +3210 3221 +3210 4594 +3210 4595 +3210 4596 +3210 4597 +3210 4598 +1289 1043 +1289 1916 +1289 2944 +1289 2966 +1289 3142 +1289 3143 +1289 3144 +1289 3145 +1289 3146 +1413 1171 +1413 2575 +1413 2582 +1413 2640 +1413 2672 +1413 2828 +1413 2960 +1413 3035 +1413 3269 +1413 3270 +656 514 +656 568 +656 657 +656 658 +656 659 +656 660 +656 661 +656 662 +656 663 +656 664 +1086 152 +1086 219 +1086 424 +1086 1457 +1086 1824 +1086 2124 +1086 2984 +1086 2985 +1086 2986 +1714 824 +1714 1034 +1714 1037 +1714 1715 +1714 1716 +1714 1717 +1714 1718 +1714 1719 +1714 1720 +1714 1721 +1871 3491 +1872 356 +1872 458 +1872 1209 +1872 2383 +1872 3539 +1872 3619 +1872 3620 +1872 3621 +1872 3622 +1872 3623 +4175 5209 +4176 2205 +4176 2222 +4176 3318 +4176 3418 +4176 3563 +4176 4006 +4176 5494 +4176 5814 +4176 5815 +4179 3 +4179 123 +4179 127 +4179 144 +4179 145 +4179 238 +4179 251 +4179 352 +4179 369 +4179 2338 +3405 732 +3405 1947 +3405 2751 +3405 3232 +3405 3237 +3405 4223 +3405 4735 +3405 4736 +3405 4737 +3405 4738 +3616 321 +3616 699 +3616 3115 +3616 3934 +3616 4858 +3616 4859 +3616 4860 +3616 4861 +3616 4862 +3616 4863 +4222 156 +4222 582 +4222 726 +4222 892 +4222 894 +4222 904 +4222 1203 +4222 1559 +4222 1670 +4222 2536 +4203 875 +4203 1675 +4203 4118 +4203 4277 +4203 4917 +4203 5129 +4203 5130 +4204 202 +4204 989 +4204 2337 +4204 3367 +4204 3931 +4204 4248 +4204 5047 +4204 5131 +4204 5132 +680 144 +680 145 +680 251 +680 630 +680 1841 +680 1842 +680 1843 +680 1844 +680 1845 +680 1846 +682 309 +682 690 +682 712 +682 851 +682 1337 +682 1347 +682 2411 +682 2585 +682 2586 +1843 567 +1843 892 +1843 1021 +1843 2033 +1843 2853 +1843 3307 +1843 3573 +1843 3574 +1843 3575 +1843 3576 +1844 50 +1844 586 +1844 1064 +1844 1528 +1844 2221 +1844 3585 +1844 3586 +1844 3587 +1844 3588 +1844 3589 +2589 4185 +2590 57 +2590 1376 +2590 2248 +2590 4186 +2591 1162 +2591 2463 +2591 3677 +2591 4082 +2591 4083 +2591 4133 +2591 4187 +2591 4188 +2591 4189 +3573 184 +3573 412 +3573 725 +3573 2119 +3573 2461 +3573 3602 +3573 4382 +3573 4445 +3573 4834 +3573 4835 +3575 1842 +3587 94 +3587 352 +3587 2628 +3587 3109 +3587 3469 +3587 4141 +3587 4170 +3587 4455 +3587 4784 +3587 4844 +3588 4813 +4187 31 +4187 144 +4187 145 +4187 146 +4187 149 +4187 180 +4187 266 +4187 423 +4187 856 +4187 1317 +4189 107 +4189 298 +4189 1396 +4189 1718 +4189 1890 +4189 3543 +4189 4094 +4189 5118 +4189 5119 +4189 5120 +689 609 +689 690 +689 691 +689 692 +689 693 +4205 1501 +4208 252 +4208 1068 +4208 2564 +4208 3620 +4208 4071 +4208 5022 +4208 5133 +4208 5134 +4208 5135 +4208 5136 +699 529 +699 693 +699 1027 +699 1653 +699 1702 +699 2289 +699 2546 +699 2611 +699 2612 +699 2613 +2611 1956 +4191 370 +4191 432 +4191 495 +4191 503 +4191 2537 +4191 3004 +4191 3808 +4191 4293 +4191 4617 +4191 5121 +4193 365 +4193 787 +4193 995 +4193 1447 +4193 2601 +4193 2746 +4193 3499 +4193 3840 +4193 3896 +4193 4332 +4194 180 +4194 870 +4194 2432 +4194 3328 +4194 4589 +4196 127 +4196 248 +4196 423 +4196 559 +4196 667 +4196 717 +4196 856 +4196 1041 +4196 4638 +4196 5122 +4198 345 +4198 1318 +4198 1424 +4198 1814 +4198 3033 +4198 3205 +4198 4035 +4198 4960 +4198 5123 +3364 135 +3364 840 +3364 968 +3364 1740 +3364 1741 +3364 3132 +3364 3334 +3364 4705 +3364 4706 +3607 852 +3607 1457 +3607 2752 +3607 2820 +3607 4866 +3033 1476 +3033 1894 +3033 2361 +3033 2532 +3033 3173 +3033 3806 +3033 3833 +3033 3918 +3033 4464 +3033 4465 +4200 429 +4200 432 +4200 1288 +4200 1564 +4200 1573 +4200 1652 +4200 2202 +4200 3813 +1750 158 +1750 231 +1750 1216 +1750 1217 +1750 1424 +1750 1717 +1750 2385 +1750 3510 +1750 3511 +1750 3512 +2952 1374 +2952 1507 +2952 2035 +2952 2916 +2952 2953 +2952 3017 +2952 3134 +2952 3629 +2952 4422 +2952 4423 +3403 7 +3403 123 +3403 125 +3403 144 +3403 149 +3403 248 +3403 251 +3403 367 +3403 424 +3403 1317 +4211 4 +4211 10 +4211 122 +4211 251 +4211 265 +4211 369 +4211 426 +4211 427 +4211 698 +4211 946 +4213 477 +4213 579 +4213 856 +4213 1824 +4213 2214 +4213 2366 +4213 2463 +4213 4293 +4213 4894 +4213 5140 +4215 532 +4215 620 +4215 1067 +4215 1089 +4215 1799 +4215 3526 +4215 3682 +4215 4583 +4215 5149 +4216 11 +4216 325 +4216 649 +4216 1300 +4216 1592 +4216 2475 +4216 2928 +4216 4166 +4216 5141 +4216 5142 +4217 5 +4217 265 +4217 823 +4217 1947 +4217 4711 +4217 4712 +4217 4861 +4217 5143 +4217 5144 +4217 5145 +4220 143 +4220 146 +4220 248 +4220 249 +4220 367 +4220 390 +4220 423 +4220 427 +4220 717 +4220 1245 +3558 307 +3558 690 +3558 983 +3558 1367 +3558 3266 +3558 3737 +3558 3856 +3558 4686 +3558 4827 +701 118 +701 499 +701 506 +701 702 +701 703 +701 704 +701 705 +701 706 +701 707 +701 708 +704 612 +704 702 +704 851 +704 1531 +704 1539 +704 2621 +704 2622 +704 2623 +704 2624 +705 226 +705 352 +705 1594 +705 1600 +705 1641 +705 2625 +705 2626 +705 2627 +705 2628 +705 2629 +2622 889 +2622 892 +2622 1824 +2622 2193 +2622 2194 +2622 3076 +2622 3244 +2622 3999 +2622 4225 +2622 4226 +1594 1595 +1600 127 +1600 248 +1600 264 +1600 367 +1600 390 +1600 422 +1600 423 +1600 559 +1600 666 +1600 667 +1641 604 +1641 1077 +1641 1097 +1641 1642 +1641 1643 +1641 1644 +1641 1645 +1641 1646 +1641 1647 +2627 9 +2627 144 +2627 146 +2627 148 +2627 149 +2627 175 +2627 264 +2627 390 +2627 1245 +2629 127 +2629 128 +2629 129 +2629 176 +2629 229 +2629 353 +2629 1317 +2629 2115 +2629 3102 +2629 4228 +1107 998 +2642 813 +2642 4315 +3409 288 +3409 325 +3409 707 +3409 1120 +3409 1211 +3409 1904 +3409 3439 +3409 3849 +3409 4369 +3409 4754 +1265 2377 +1584 1036 +1602 121 +1602 122 +1602 123 +1602 143 +1602 246 +1602 247 +1602 249 +1602 264 +1602 352 +1602 1245 +4239 2184 +4230 781 +4230 1106 +4230 3119 +4230 3344 +4230 3683 +4230 4156 +4230 5000 +4230 5151 +4230 5152 +4230 5153 +4232 962 +4232 2338 +4232 2361 +4232 2885 +4232 5053 +4234 146 +4234 177 +4234 238 +4234 264 +4234 352 +4234 424 +4234 427 +4234 2098 +4235 1516 +4235 1698 +4235 1786 +4235 1804 +4235 2218 +4235 2400 +4235 3129 +4235 3362 +4235 3473 +4235 5154 +3244 120 +3244 257 +3244 456 +3244 872 +3244 1492 +3244 1651 +3244 1758 +3244 4626 +3244 4627 +3244 4628 +4227 123 +4227 127 +4227 176 +4227 238 +4227 367 +4227 422 +4227 427 +4227 667 +4227 717 +4227 2338 +4228 20 +4228 179 +4228 238 +4228 346 +4228 347 +4228 2337 +4228 3229 +4228 3480 +4228 4132 +4228 5150 +709 200 +709 205 +709 541 +709 552 +709 710 +709 711 +709 712 +709 713 +709 714 +709 715 +1544 3337 +1544 3338 +1544 3339 +1544 3340 +4236 1505 +4236 1645 +4236 5105 +4236 5155 +4236 5156 +716 124 +716 128 +716 174 +716 176 +716 177 +716 179 +716 353 +716 390 +716 717 +716 718 +719 479 +719 720 +719 721 +719 722 +719 723 +719 724 +719 725 +719 726 +719 727 +1434 78 +1434 309 +1434 762 +1434 891 +1434 1019 +1434 1317 +1434 1435 +1434 1436 +1434 1437 +1434 1438 +3284 452 +3284 453 +3284 1688 +3284 2354 +3284 2653 +3284 3408 +3284 4288 +3284 4654 +3284 4655 +3284 4656 +3285 17 +3285 1768 +3285 1827 +3285 1972 +3285 2244 +3285 3047 +3285 5638 +3285 6036 +3285 6037 +3285 6038 +1438 173 +1438 202 +1438 222 +1438 685 +1438 1421 +1438 1534 +1438 3291 +1438 3292 +1438 3293 +1438 3294 +5417 892 +5417 1107 +5417 1330 +5417 1617 +5417 1757 +5417 2112 +5417 3926 +5417 5415 +5417 5812 +5417 5813 +5418 7 +5418 124 +5418 144 +5418 146 +5418 148 +5418 266 +5418 698 +5418 754 +5418 1297 +5418 2803 +836 837 +836 838 +836 839 +836 840 +836 841 +836 842 +836 843 +836 844 +836 845 +2660 1840 +4244 904 +4244 918 +4244 986 +4244 1157 +4244 1547 +4244 3006 +4244 4628 +4244 4966 +4244 5157 +4244 5158 +2922 178 +2922 252 +2922 264 +2922 367 +2922 390 +2922 422 +2922 423 +2922 559 +2922 754 +2922 2001 +3259 1090 +3259 2049 +3259 2050 +3259 2566 +3259 3014 +3259 3815 +3259 4282 +3259 4633 +3259 4634 +3259 4635 +3411 440 +3411 793 +3411 892 +3411 1120 +3411 1439 +3411 1507 +3411 2769 +3411 4750 +3411 4751 +4914 125 +4914 498 +4914 1211 +4914 2798 +4914 3249 +4914 3819 +4914 4006 +4914 4474 +4914 5566 +4914 5567 +728 45 +728 89 +728 298 +728 729 +728 730 +728 731 +728 732 +728 733 +728 734 +728 735 +731 649 +731 982 +731 1156 +731 1258 +731 2053 +731 2176 +731 2655 +731 2656 +731 2657 +731 2658 +734 623 +734 893 +734 1412 +734 1734 +734 2015 +734 2582 +734 2631 +734 2684 +734 2685 +734 2686 +4242 407 +4242 651 +4242 1194 +4242 1369 +4242 1575 +4242 3250 +4242 3491 +4242 4072 +4242 4603 +4242 5161 +2659 945 +2659 1489 +2659 2086 +2659 2411 +2659 2982 +2659 3684 +2659 4245 +2659 4246 +1380 41 +1380 385 +1380 1437 +1380 1899 +1380 2054 +1380 2272 +1380 3076 +1380 3156 +1380 3235 +1380 3236 +2679 10 +2679 148 +2679 265 +2679 369 +2679 427 +2679 698 +2679 754 +2679 947 +2679 2064 +2679 4257 +2680 1466 +2680 1685 +2680 2881 +2680 3023 +2680 3207 +2680 3247 +2680 4095 +2680 4237 +2680 4256 +2682 4173 +2683 152 +2683 1695 +2683 2354 +2683 2385 +2683 3109 +2683 3343 +2683 3710 +2683 3879 +2683 3981 +2683 4170 +4245 437 +4245 481 +4245 505 +4245 870 +4245 1137 +4245 1741 +4245 1780 +4245 2114 +4245 2535 +4245 4166 +4246 496 +4246 1224 +4246 2058 +4246 2068 +4246 2744 +4246 3117 +4246 3133 +4246 3277 +4246 5159 +4246 5160 +3236 17 +3236 145 +3236 175 +3236 179 +3236 180 +3236 424 +3236 717 +3236 736 +3236 754 +3236 2001 +5154 49 +5154 803 +5154 1219 +5154 1255 +5154 2285 +5154 3017 +5154 3133 +5154 5023 +5154 5463 +5154 5670 +5807 648 +5807 1845 +5807 2264 +5807 3205 +5807 4170 +5807 5403 +5807 5992 +5807 5997 +5807 5998 +5807 5999 +3115 262 +3115 1100 +3115 1415 +3115 1845 +3115 1889 +3115 2113 +3115 3699 +3115 4539 +3115 4540 +3115 4541 +3117 308 +3117 860 +3117 1376 +3117 1457 +3117 1767 +3117 2305 +3117 2419 +3117 2712 +3117 2898 +3117 4545 +1559 144 +1559 145 +1559 147 +1559 251 +1559 252 +1559 264 +1559 266 +1559 368 +1559 667 +1209 325 +1209 583 +1209 1210 +1209 1211 +1209 1212 +1209 1213 +1209 1214 +1209 1215 +1209 1216 +1209 1217 +1442 575 +4279 5 +4279 121 +4279 125 +4279 129 +4279 148 +4279 174 +4279 176 +4279 369 +4279 424 +4279 717 +4280 464 +4280 759 +4280 828 +4280 2709 +4280 2948 +4280 3081 +4280 3859 +4280 4133 +4280 4584 +4280 5181 +3441 803 +3441 1750 +3441 2299 +3441 2646 +3441 3024 +3441 3439 +3441 3440 +3441 3654 +3441 4838 +3441 4839 +3441 4840 +3441 4841 +3441 4842 +3441 4843 +3613 944 +3613 2269 +3613 2621 +3613 3412 +3613 3904 +3613 4553 +3613 4856 +3613 4857 +4285 92 +4285 158 +4285 1645 +4285 1815 +4285 1929 +4285 3551 +4285 4007 +4285 4081 +4285 5183 +4285 5184 +4285 5185 +4285 5186 +4285 5187 +4285 5188 +4285 5189 +4285 5190 +4285 5191 +2828 113 +2828 256 +2828 518 +2828 2196 +2828 2322 +2828 2992 +2828 3963 +2828 4124 +2828 4325 +4252 115 +4252 760 +4252 1672 +4252 1838 +4252 1955 +4252 2690 +4252 4301 +4252 4961 +4252 4976 +4253 5169 +4255 1146 +4255 1635 +4255 2694 +4255 2936 +4255 3181 +4255 3813 +4255 4578 +4255 5166 +4255 5167 +4255 5168 +4257 9 +4257 123 +4257 126 +4257 145 +4257 148 +4257 149 +4257 248 +4257 369 +4257 1245 +4257 1317 +3207 54 +3207 219 +3207 318 +3207 554 +3207 883 +3207 1935 +3207 3209 +3207 3995 +3207 4591 +3247 321 +3247 452 +3247 453 +3247 531 +3247 736 +3247 1947 +3247 2035 +3247 2689 +3247 3095 +3247 4625 +4256 2613 +2885 129 +2885 176 +2885 177 +2885 180 +2885 266 +2885 368 +2885 390 +2885 427 +2885 667 +2885 856 +752 5 +752 180 +752 247 +752 250 +752 351 +752 426 +752 554 +752 753 +752 754 +752 755 +2698 470 +2698 802 +2698 928 +2698 958 +2698 1067 +2698 1590 +2698 3995 +2698 4137 +2698 4270 +2698 4271 +2694 3363 +1717 257 +1717 541 +1717 852 +1717 1441 +1717 1702 +1717 2356 +1717 2553 +1717 3484 +1717 3485 +1717 3486 +1493 1227 +2823 1089 +2823 1915 +2823 2021 +2823 2884 +2823 3119 +2823 4165 +2823 4321 +2823 4322 +2823 4323 +2823 4324 +4260 3 +4260 9 +4260 123 +4260 124 +4260 149 +4260 238 +4260 249 +4260 352 +4260 367 +4260 369 +4264 1157 +3363 990 +3363 2444 +3363 2689 +3363 3293 +3363 4221 +3363 4700 +3363 4701 +3363 4702 +3363 4703 +3363 4704 +4269 4797 +1444 5490 +1444 5491 +3258 124 +3258 127 +3258 128 +3258 143 +3258 147 +3258 247 +3258 251 +3258 266 +3258 369 +3258 1245 +3260 1212 +3260 1830 +3260 1845 +3260 1936 +3260 2108 +3260 2470 +3260 2563 +3260 2729 +3260 3601 +3526 3 +3526 8 +3526 121 +3526 122 +3526 123 +3526 129 +3526 367 +3526 422 +3526 424 +3526 667 +4389 208 +4389 1173 +4389 1362 +4389 4164 +4389 5248 +4389 5249 +4390 339 +4390 527 +4390 1339 +4390 2066 +4390 2839 +4390 2973 +4390 3524 +4390 3661 +4390 4723 +4390 5250 +4391 1894 +775 776 +1310 9 +1310 122 +1310 123 +1310 124 +1310 128 +1310 179 +1310 367 +1310 369 +1310 427 +1310 1317 +4274 164 +4274 230 +4274 424 +4274 2017 +4274 2148 +4274 2787 +4274 3523 +4274 3988 +4274 4813 +4274 5178 +4276 5 +4276 7 +4276 125 +4276 126 +4276 147 +4276 149 +4276 175 +4276 266 +4276 667 +4276 754 +4277 227 +4277 1698 +4277 1787 +4277 2115 +4277 3058 +4277 4026 +4277 4275 +4277 5179 +4277 5180 +787 276 +787 788 +787 789 +787 790 +787 791 +787 792 +787 793 +787 794 +787 795 +787 796 +797 289 +797 420 +797 460 +797 463 +797 798 +797 799 +797 800 +797 801 +797 802 +797 803 +801 940 +801 1866 +801 1867 +801 2036 +801 2200 +801 2724 +801 2725 +801 2726 +801 2727 +801 2728 +3676 102 +3676 327 +3676 551 +3676 707 +3676 825 +3676 979 +3676 1010 +3676 1115 +3676 3423 +3676 4295 +3615 155 +3615 2324 +3615 2502 +3615 2504 +3615 3345 +3615 4145 +3615 4864 +3615 4865 +2732 227 +2732 717 +2732 1735 +2732 1749 +2732 1862 +2732 2497 +2732 3009 +2732 4293 +2732 4294 +2732 4295 +4695 131 +4695 190 +4695 697 +4695 942 +4695 1730 +4695 1922 +4695 2423 +4695 5189 +4695 5428 +4695 5429 +5224 391 +5224 717 +5224 1542 +5224 1787 +5224 1881 +5224 2892 +5224 4490 +5224 4741 +5224 5720 +5629 92 +5629 133 +5629 177 +5629 731 +5629 2443 +5629 2779 +5629 4111 +5629 4646 +5629 5775 +1735 103 +1735 298 +1735 982 +1735 1332 +1735 1736 +1735 1737 +1735 1738 +1735 1739 +1735 1740 +1735 1741 +1862 748 +1862 1377 +1862 3799 +1862 3800 +1862 3801 +1862 3802 +1862 3803 +1862 3804 +1862 3805 +1862 3806 +3009 17 +3009 144 +3009 175 +3009 1245 +3009 1317 +3009 1667 +3009 2018 +3009 2627 +3009 4457 +4293 54 +4293 2253 +4293 4062 +4293 4636 +4293 5193 +4293 5194 +4293 5195 +4293 5196 +4293 5197 +4293 5198 +4295 96 +4295 346 +4295 509 +4295 1632 +4295 1942 +4295 2175 +4295 3292 +4295 4032 +4295 4286 +4295 4533 +5429 651 +5429 1534 +5429 1720 +5429 2690 +5429 4306 +5429 4439 +5429 4961 +5429 5040 +5429 5827 +5429 5828 +4490 810 +4490 981 +4490 1199 +4490 1297 +4490 1342 +4490 1607 +4490 1608 +4490 1867 +4490 3617 +4490 5320 +4741 1658 +4741 1974 +4741 2358 +4741 3127 +4741 3224 +4741 3860 +4741 4303 +4741 4306 +4741 5459 +4741 5460 +5720 5890 +2779 7 +2779 124 +2779 125 +2779 144 +2779 148 +2779 149 +2779 248 +2779 249 +2779 251 +2779 367 +5775 376 +5775 710 +5775 779 +5775 1122 +5775 1272 +5775 1375 +5775 2015 +5775 2422 +5775 2634 +5775 3335 +5775 4316 +5775 5850 +5775 5879 +5775 6008 +5775 6009 +5775 6010 +5775 6011 +5312 5278 +4291 5017 +4292 103 +4292 1061 +4292 1425 +4292 1827 +4292 1923 +4292 2480 +4292 3021 +4292 3055 +4292 4075 +4292 5192 +1039 1176 +1039 1651 +1039 1956 +1039 2271 +1039 2787 +1039 2955 +1039 2956 +1039 2957 +1039 2958 +3200 924 +3200 1517 +3200 2773 +3200 2916 +3200 2943 +3200 3516 +3200 4289 +3200 4478 +3200 4585 +3200 4586 +3174 262 +3174 344 +3174 2613 +3174 2994 +3174 4571 +887 1671 +887 1688 +887 1786 +887 1805 +887 2361 +887 2662 +887 2775 +887 2776 +887 2777 +887 2778 +845 127 +845 144 +845 145 +845 176 +845 177 +845 247 +845 265 +845 630 +845 698 +845 762 +941 6087 +4300 11 +4300 133 +4300 1492 +4300 2119 +4300 2479 +4300 3699 +4300 5202 +4300 5203 +4300 5204 +4301 165 +4301 1800 +4301 1868 +4301 2324 +4301 3462 +1707 1956 +1707 2246 +1707 2465 +1707 3477 +1707 3478 +1707 3479 +1707 3480 +1707 3481 +1707 3482 +1707 3483 +3478 1539 +3479 572 +3479 1085 +3479 1456 +3479 3015 +3479 3392 +3479 3634 +3479 3781 +3479 4405 +3479 4780 +3480 341 +3480 343 +3480 347 +3480 2306 +3480 2307 +3480 2337 +3480 3343 +3480 4170 +3480 4628 +3480 4663 +868 732 +868 1145 +868 1146 +868 1147 +868 1148 +868 1149 +868 1150 +868 1151 +868 1152 +868 1153 +2770 5 +2770 8 +2770 123 +2770 145 +2770 148 +2770 238 +2770 353 +2770 424 +2770 427 +2770 2338 +1146 2430 +1146 3180 +4297 4 +4297 9 +4297 125 +4297 143 +4297 145 +4297 148 +4297 264 +4297 368 +4297 1317 +3176 3 +3176 8 +3176 127 +3176 129 +3176 146 +3176 176 +3176 246 +3176 426 +3176 1245 +3176 2098 +4303 31 +4303 121 +4303 124 +4303 148 +4303 177 +4303 180 +4303 352 +4303 427 +4303 736 +4303 2001 +4405 3 +4405 124 +4405 177 +4405 249 +4405 251 +4405 252 +4405 264 +4405 368 +4405 559 +4405 2018 +4304 5157 +2777 1103 +2777 3292 +2777 5452 +2777 6039 +2777 6279 +5452 8 +5452 122 +5452 126 +5452 145 +5452 149 +5452 174 +5452 179 +5452 424 +5452 427 +5452 1317 +6039 202 +6039 503 +6039 810 +6039 814 +6039 1915 +6039 2149 +6039 2719 +6039 2755 +6039 2978 +6039 3275 +6039 3293 +6039 3325 +6039 3488 +6039 5049 +6039 5395 +6039 5554 +6039 5816 +6039 5888 +6039 5952 +6039 5966 +6039 6022 +6039 6157 +6039 6158 +6039 6159 +6039 6160 +6039 6161 +6039 6162 +6039 6163 +6039 6164 +6039 6165 +6039 6166 +6279 115 +6279 1845 +6279 5529 +6279 5970 +6279 6011 +6279 6284 +6279 6285 +6279 6286 +6279 6287 +6279 6288 +4433 8 +4433 1345 +4433 1890 +4433 3362 +4433 3677 +4434 352 +4434 777 +4434 926 +4434 2086 +4434 3932 +4434 3983 +4434 4757 +4434 4980 +4434 5273 +4434 5274 +896 563 +896 897 +896 898 +896 899 +896 900 +896 901 +896 902 +896 903 +896 904 +896 905 +902 1272 +902 2409 +902 2626 +902 2663 +902 2779 +902 2780 +902 2781 +902 2782 +902 2783 +902 2784 +904 492 +904 749 +904 1790 +904 2737 +904 2791 +904 2792 +904 2793 +904 2794 +904 2795 +904 2796 +2781 1980 +4306 4 +4306 143 +4306 175 +4306 249 +4306 251 +4306 264 +4306 369 +4306 422 +4306 856 +3276 5 +3276 8 +3276 31 +3276 149 +3276 176 +3276 352 +3276 353 +3276 558 +3276 754 +4312 280 +4312 492 +4312 704 +4312 1084 +4312 1862 +4312 2847 +4312 3717 +4312 5206 +4312 5207 +4312 5208 +4317 1511 +1134 164 +3304 125 +3304 174 +3304 180 +3304 252 +3304 264 +3304 266 +3304 368 +3304 390 +3304 422 +3304 559 +4308 1299 +4308 1533 +4308 1609 +4308 1872 +4308 1926 +4308 1955 +4308 3455 +4308 4078 +4308 4485 +4308 5205 +2821 73 +2821 176 +2821 353 +2821 354 +2821 367 +2821 667 +2821 823 +2821 1091 +2821 1267 +2821 4320 +2822 3 +2822 4 +2822 7 +2822 144 +2822 183 +2822 264 +2822 265 +2822 266 +2822 423 +2822 667 +1091 95 +1091 309 +1091 434 +1091 909 +1091 1092 +1091 1093 +1091 1094 +1091 1095 +1091 1096 +1091 1097 +4324 92 +4324 315 +4324 2200 +4324 3095 +4324 3136 +4324 3843 +4324 4721 +4324 5214 +4324 5215 +4324 5216 +929 335 +929 930 +929 931 +929 932 +929 933 +929 934 +929 935 +929 936 +929 937 +948 31 +948 862 +948 949 +948 950 +948 951 +949 1028 +949 1661 +949 2697 +949 2829 +949 2830 +949 2831 +949 2832 +949 2833 +949 2834 +949 2835 +950 870 +950 1570 +950 1631 +950 1747 +950 2793 +950 2824 +950 2825 +950 2826 +950 2827 +950 2828 +2829 43 +2829 122 +2829 123 +2829 251 +2829 423 +2829 1228 +2829 1245 +2829 1679 +2829 1721 +2829 4334 +2831 133 +2831 397 +2831 398 +2831 982 +2831 3221 +2831 3981 +2831 4326 +2831 4327 +2831 4328 +2831 4329 +2835 815 +2835 1197 +2835 1234 +2835 2821 +2835 3351 +2835 4191 +2835 4330 +2835 4331 +2835 4332 +2835 4333 +2826 249 +2826 1400 +2826 2287 +2826 2541 +2826 2558 +2826 2923 +2826 4336 +2826 5277 +2826 5516 +2826 5517 +1721 211 +1721 706 +1721 1104 +1721 2127 +1721 2373 +1721 2430 +1721 2720 +1721 3006 +1721 3476 +4334 57 +4334 3756 +4334 4036 +4334 4242 +4334 4397 +4334 4684 +4334 4814 +4334 5116 +4334 5220 +4334 5221 +4330 31 +4330 126 +4330 146 +4330 148 +4330 174 +4330 250 +4330 559 +4330 856 +4330 1245 +4330 3779 +4332 435 +4332 1219 +4332 2006 +4332 2042 +4332 2197 +4332 2776 +4332 3329 +4332 5217 +4332 5218 +4332 5219 +4336 4491 +5277 25 +5277 228 +5277 1227 +5277 3096 +5277 5758 +2992 928 +2992 1054 +2992 2906 +2992 2995 +2992 3681 +2992 4438 +2992 4439 +2992 4440 +2992 4441 +2992 4442 +952 749 +952 796 +952 953 +952 954 +952 955 +952 956 +952 957 +952 958 +952 959 +952 960 +956 2836 +4892 212 +4892 458 +4892 2272 +4892 3054 +4892 3931 +4892 4074 +4892 4563 +4892 5554 +4892 5555 +4973 140 +4973 350 +4973 1066 +4973 3417 +4973 4324 +4973 4501 +4973 4752 +4973 5310 +4973 5463 +4973 5521 +1167 274 +1167 1168 +1167 1169 +1167 1170 +1167 1171 +4752 2 +4752 5 +4752 8 +4752 174 +4752 699 +4752 753 +4752 762 +4752 946 +4752 2063 +4752 4257 +961 8 +961 262 +961 280 +961 560 +961 962 +961 963 +961 964 +961 965 +961 966 +961 967 +964 364 +964 697 +964 2213 +964 2844 +964 2845 +964 2846 +964 2847 +964 2848 +964 2849 +964 2850 +1124 360 +1124 1061 +1124 1064 +1124 1125 +1124 1126 +1124 1127 +1124 1128 +1124 1129 +1124 1130 +1124 1131 +1124 1132 +1124 1133 +1666 325 +1666 633 +1666 1339 +1666 2275 +1666 3228 +1666 3385 +1666 4109 +1666 4499 +1666 4803 +3535 32 +1126 3147 +1126 3148 +1130 2938 +1133 3158 +4344 684 +4344 1943 +4344 3861 +4344 4766 +4344 4973 +4344 5226 +4344 5227 +4344 5228 +4344 5229 +4344 5230 +4353 4 +4353 5 +4353 123 +4353 125 +4353 126 +4353 144 +4353 177 +4353 180 +4353 754 +4353 1317 +4355 202 +4355 472 +4355 867 +4355 1213 +4355 1929 +4355 4081 +4355 5185 +4355 5186 +4355 5240 +4355 5241 +4343 169 +4343 1050 +4343 1317 +4343 1437 +4343 3223 +4343 3362 +4343 4731 +4343 5200 +4343 5231 +3327 124 +3327 151 +3327 368 +3327 424 +3327 1317 +3327 1903 +3327 2086 +3327 3243 +3327 3994 +3327 4368 +4358 124 +4358 250 +4358 264 +4358 266 +4358 368 +4358 423 +4358 427 +4358 559 +4358 2018 +4359 113 +4359 190 +4359 363 +4359 1056 +4359 1805 +4359 2984 +4359 3275 +4359 4018 +4359 4589 +4359 5004 +4356 2927 +4356 3376 +4356 3916 +4356 4940 +4356 5323 +2864 352 +4337 165 +4337 1787 +4337 2539 +4337 4895 +4337 5222 +4338 56 +4338 363 +4338 432 +4338 554 +4338 1859 +4338 3608 +4338 4143 +4338 4151 +4338 4929 +4338 5225 +4340 1255 +4340 1300 +4340 1591 +4340 1792 +4340 2112 +4340 2164 +4340 3893 +4340 5141 +4340 5223 +4340 5224 +2879 5 +2879 31 +2879 125 +2879 126 +2879 148 +2879 175 +2879 179 +2879 238 +2879 353 +2879 558 +2883 337 +2883 409 +2883 1289 +2883 1473 +2883 2321 +2883 2744 +2883 3565 +2883 4365 +2883 4366 +2883 4367 +4360 381 +4360 1239 +4360 2568 +4360 3212 +4360 3566 +4360 4828 +4360 5232 +4360 5233 +4360 5234 +4362 437 +4362 906 +4362 2779 +4362 3687 +4362 3886 +4362 4286 +4362 5242 +4362 5243 +4362 5244 +4362 5245 +3160 2734 +3160 3138 +3160 4510 +3160 4556 +3160 4557 +3160 4558 +3160 4559 +3160 4560 +3160 4561 +3160 4562 +1473 9 +1473 121 +1473 127 +1473 128 +1473 144 +1473 149 +1473 238 +1473 247 +1473 426 +1473 1317 +988 138 +988 163 +988 870 +988 1610 +988 2474 +988 2630 +988 2767 +988 2887 +988 2888 +988 2889 +990 127 +990 148 +990 183 +990 249 +990 252 +990 264 +990 265 +990 266 +990 368 +990 666 +2887 177 +2887 411 +2887 586 +2887 706 +2887 1588 +2887 3363 +2887 4369 +2887 4370 +2887 4371 +2888 527 +2888 652 +2888 1738 +2888 2304 +2888 3017 +2888 4327 +2888 4393 +2888 4394 +2888 4395 +2888 4396 +2890 56 +2890 442 +2890 1279 +2890 2220 +2890 3156 +2890 3794 +2890 4368 +2890 4397 +2890 4398 +4369 3694 +4369 5186 +4369 5252 +4369 5253 +4369 5254 +4369 5255 +4369 5256 +4369 5257 +4369 5258 +4369 5259 +4378 255 +4378 363 +4378 741 +4378 869 +4378 1456 +4378 1762 +4378 2485 +4378 3109 +4378 4854 +4378 5251 +992 3 +992 174 +992 251 +992 265 +992 351 +992 369 +992 390 +992 697 +992 947 +992 993 +994 995 +2901 3 +2901 8 +2901 123 +2901 128 +2901 146 +2901 177 +2901 179 +2901 248 +2901 390 +2901 1245 +1737 710 +1737 740 +1737 2246 +1737 2758 +1737 3093 +1737 3236 +1737 3243 +1737 3528 +1737 3529 +1739 3 +1739 123 +1739 125 +1739 179 +1739 251 +1739 352 +1739 353 +1739 369 +1739 427 +1739 1317 +1740 38 +1740 106 +1740 605 +1740 1133 +1740 1209 +1740 1631 +1740 3273 +1740 3497 +1740 3498 +1740 3499 +4381 89 +4381 691 +4381 3189 +4381 3314 +4381 3849 +4381 4344 +4381 4788 +4381 4934 +4381 5246 +4382 4 +4382 124 +4382 146 +4382 247 +4382 249 +4382 367 +4382 427 +4382 559 +4382 718 +4382 754 +3142 124 +3142 129 +3142 177 +3142 248 +3142 249 +3142 266 +3142 667 +3142 717 +3142 856 +3142 1245 +3544 3 +3544 121 +3544 124 +3544 143 +3544 174 +3544 177 +3544 264 +3544 426 +3544 427 +3544 717 +999 716 +999 1000 +999 1001 +999 1002 +999 1003 +999 1004 +999 1005 +999 1006 +999 1007 +999 1008 +2936 534 +2936 2414 +2936 3772 +2936 4412 +2936 4413 +2936 4414 +3305 115 +3305 911 +3305 2189 +3305 2955 +3305 3189 +3305 3486 +3305 3524 +3305 3537 +3305 4469 +3305 4662 +4388 213 +4388 265 +4388 369 +4388 427 +4388 554 +4388 695 +4388 754 +4388 2914 +4388 3028 +4388 5247 +4399 5 +4399 125 +4399 127 +4399 179 +4399 248 +4399 250 +4399 559 +4399 667 +4399 717 +4399 2018 +4400 762 +4400 1647 +4400 2170 +4400 2579 +4400 2599 +4400 4097 +4400 4867 +4400 5260 +4400 5261 +4400 5262 +4403 202 +4403 280 +4403 1021 +4403 2251 +4403 2296 +4403 4117 +4403 4382 +4403 5263 +4403 5264 +1009 77 +1009 784 +1009 1010 +1009 1011 +1009 1012 +1009 1013 +1009 1014 +1009 1015 +1009 1016 +1009 1017 +1010 1191 +1010 1517 +1010 2411 +1010 2538 +1010 2920 +1010 2921 +1010 2922 +1010 2923 +1010 2924 +1010 2925 +1011 3044 +1013 302 +1013 406 +1013 435 +1013 2119 +1013 2909 +1013 2912 +1013 2913 +1013 2914 +1013 2915 +1015 503 +1015 535 +1015 673 +1015 840 +1015 979 +1015 2916 +1015 2917 +1015 2918 +1015 2919 +1191 116 +1191 1076 +1191 1079 +1191 1331 +1191 1339 +1191 1340 +1191 1341 +1191 1342 +1191 1343 +1191 1344 +2921 296 +2921 828 +2921 944 +2921 1456 +2921 2354 +2921 3139 +2921 3779 +2921 4248 +2921 4407 +2921 4408 +1331 390 +1331 548 +1331 892 +1331 1332 +1331 1333 +1331 1334 +1331 1335 +1331 1336 +1331 1337 +1331 1338 +1344 1219 +1344 1288 +1344 1309 +1344 2650 +1344 2744 +1344 2966 +1344 3018 +1344 3184 +1344 3185 +1344 3186 +4407 169 +4407 1342 +4407 2001 +4407 2046 +4407 3362 +4407 5265 +4407 5266 +4407 5267 +4407 5268 +1401 510 +1401 677 +1401 736 +1401 2546 +1401 3169 +1401 3254 +1401 3255 +1401 3256 +1401 3257 +3191 101 +3191 1171 +3191 1235 +3191 2335 +3191 2575 +3191 3134 +3191 3140 +3191 3339 +3191 4580 +3191 4581 +5106 1027 +5106 1940 +5106 2005 +5106 2429 +5106 2497 +5106 3238 +5106 4934 +5106 5244 +5106 5639 +5106 5640 +2938 486 +2938 494 +2938 534 +2938 924 +2938 1297 +2938 1559 +2938 1940 +2938 2650 +2938 4124 +2939 802 +2939 1866 +2939 2275 +2939 2412 +2939 2948 +2939 3636 +2939 4170 +2939 4418 +2939 4419 +2939 4420 +4761 159 +4761 813 +4761 2494 +4761 3306 +4761 4759 +4762 3497 +4766 21 +4766 892 +4766 940 +4766 1116 +4766 1658 +4766 1872 +4766 4754 +4766 5348 +4766 5469 +4766 5470 +4419 8 +4419 31 +4419 126 +4419 144 +4419 148 +4419 175 +4419 179 +4419 247 +4419 558 +4419 697 +4420 224 +4420 281 +4420 386 +4420 1401 +4420 3358 +4420 3448 +4420 3590 +4420 5270 +4420 5271 +1216 1591 +1216 1749 +4423 8 +4423 77 +4423 282 +4423 1143 +4423 1571 +4423 1765 +4423 2961 +4423 3138 +4423 4801 +4423 5282 +4416 122 +4416 527 +4416 571 +4416 894 +4416 1027 +4416 2563 +4416 2615 +4416 4373 +4416 4719 +4416 5269 +4417 95 +4417 1197 +4417 1619 +4417 2079 +4417 2114 +4417 3253 +4417 3598 +4417 4303 +4417 4950 +4417 5175 +4431 296 +4431 1434 +4431 2427 +4431 2643 +4431 5276 +4432 92 +4432 892 +4432 1217 +4432 1404 +4432 1989 +4432 4004 +4432 4031 +4432 4058 +4432 5277 +4432 5278 +4424 110 +4424 498 +4424 1804 +4424 2708 +4424 4885 +4424 5279 +4424 5280 +4424 5281 +4424 5282 +4424 5283 +4428 179 +4428 247 +4428 251 +4428 266 +4428 368 +4428 422 +4428 423 +4428 424 +4428 667 +4428 717 +4421 124 +4421 381 +4421 477 +4421 1655 +4421 2055 +4421 2169 +4421 2254 +4421 4129 +4421 5266 +4421 5272 +2958 458 +2958 669 +2958 852 +2958 1115 +2958 1786 +2958 1798 +2958 2255 +2958 2571 +2958 4136 +4443 173 +4443 489 +4443 1896 +4443 1974 +4443 2646 +4443 3114 +4443 3806 +4443 4036 +4443 4275 +4443 5284 +1057 164 +1057 1058 +1057 1059 +1057 1060 +1057 1061 +1057 1062 +1057 1063 +1057 1064 +1057 1065 +1057 1066 +1059 3 +1059 8 +1059 121 +1059 125 +1059 128 +1059 174 +1059 179 +1059 247 +1059 424 +1059 717 +1063 2493 +1063 2987 +1063 2988 +1063 2989 +1063 2990 +1063 2991 +1063 2992 +1063 2993 +1063 2994 +1063 2995 +2988 1396 +2988 1598 +2988 1821 +2988 2069 +2988 2276 +2988 3188 +2988 3433 +2988 3563 +2988 3974 +2988 4422 +2989 2232 +2989 2448 +2991 1335 +2991 2394 +2991 2663 +2991 2787 +2991 3244 +2991 3815 +2991 4423 +2991 4446 +2991 4447 +2991 4448 +1821 112 +1821 690 +1821 703 +1821 1636 +1821 1703 +1821 1822 +1821 1823 +1821 1824 +1821 1825 +1821 1826 +4446 4733 +4447 416 +4447 1287 +4447 2621 +4447 2886 +4447 4260 +4447 4462 +4447 4921 +4447 5288 +4447 5289 +4447 5290 +4441 76 +4441 1087 +4441 1726 +4441 2583 +4441 2762 +4441 3487 +4441 3511 +4441 3823 +4441 5287 +4442 522 +4442 837 +4442 1034 +4442 2670 +4442 3110 +4442 3141 +4442 3448 +4442 3737 +4442 5291 +1075 116 +1075 1076 +1075 1077 +1075 1078 +1075 1079 +1075 1080 +1075 1081 +1075 1082 +1075 1083 +1080 2868 +1082 3 +1082 7 +1082 8 +1082 124 +1082 126 +1082 144 +1082 238 +1082 248 +1082 352 +1082 427 +2986 3 +2986 121 +2986 128 +2986 143 +2986 147 +2986 176 +2986 177 +2986 264 +2986 422 +2986 718 +1098 1051 +1098 1099 +1098 1100 +1098 1101 +1098 1102 +1098 1103 +1098 1104 +1098 1105 +1098 1106 +1108 467 +1108 1109 +1108 1110 +1108 1111 +1108 1112 +1108 1113 +1108 1114 +1108 1115 +1108 1116 +1111 435 +1111 1618 +1111 1645 +1111 1982 +1111 2163 +1111 3018 +1111 3019 +1111 3020 +1111 3021 +1111 3022 +1113 4 +1113 124 +1113 249 +1113 266 +1113 367 +1113 368 +1113 369 +1113 423 +1113 1245 +1117 29 +1117 124 +1117 126 +1117 496 +1117 1118 +1117 1119 +1117 1120 +1117 1121 +1117 1122 +1117 1123 +2997 738 +2997 1635 +2997 1650 +2997 2312 +2997 2337 +2997 2414 +2997 2554 +2997 2858 +2997 3772 +2997 4444 +3001 200 +1650 526 +1650 876 +1650 1135 +1650 1565 +1650 1651 +1650 1652 +1650 1653 +1650 1654 +1650 1655 +1650 1656 +4444 769 +4444 770 +4444 1528 +4444 1744 +4444 3852 +4444 4062 +4444 4551 +4444 5182 +4444 5285 +4444 5286 +3148 3301 +1135 4 +1135 147 +1135 176 +1135 246 +1135 249 +1135 251 +1135 252 +1135 264 +1135 266 +1135 718 +1136 553 +1136 856 +1136 1137 +1136 1138 +1136 1139 +1136 1140 +1136 1141 +1136 1142 +1136 1143 +1136 1144 +1138 152 +1138 2013 +1138 2221 +1138 2770 +1138 2785 +1138 2848 +1138 3015 +1138 3016 +1138 3017 +1139 83 +1139 229 +1139 645 +1139 2359 +1139 3009 +1139 3010 +1139 3011 +1139 3012 +1139 3013 +1139 3014 +1141 162 +1141 490 +1141 1122 +1141 1949 +1141 2353 +1141 3023 +1141 3024 +1141 3025 +1141 3026 +1141 3027 +3011 94 +3011 352 +3011 466 +3011 1022 +3011 2628 +3011 3587 +3011 4453 +3011 4454 +3011 4455 +3011 4456 +3024 352 +3024 1139 +3024 1721 +3024 2790 +3024 3995 +3024 4460 +3024 4461 +3024 4462 +3024 4463 +3025 3221 +3025 3271 +3025 3335 +3025 4473 +3025 4474 +3026 3 +3026 123 +3026 128 +3026 129 +3026 143 +3026 146 +3026 177 +3026 251 +3026 367 +3026 1245 +4445 4 +4445 127 +4445 143 +4445 247 +4445 249 +4445 250 +4445 369 +4445 559 +4445 667 +4445 2001 +4532 4 +4532 127 +4532 143 +4532 248 +4532 266 +4532 390 +4532 422 +4532 423 +4532 667 +5326 701 +5326 703 +5326 1430 +5326 2149 +5326 3017 +5326 3027 +5326 4297 +5326 5268 +5326 5339 +5326 5352 +4449 162 +4449 199 +4449 290 +4449 757 +4449 2151 +4449 5292 +4449 5293 +4449 5294 +4449 5295 +4449 5296 +4452 228 +4452 554 +4452 789 +4452 1957 +4452 2153 +4452 2612 +4452 3083 +4452 3539 +4452 3919 +4452 5297 +4456 9 +4456 126 +4456 143 +4456 144 +4456 145 +4456 148 +4456 179 +4456 423 +4456 697 +4458 47 +4458 491 +4458 541 +4458 2869 +4458 3779 +4458 5118 +4458 5298 +4458 5299 +4458 5300 +4458 5301 +1184 2259 +4459 2139 +4459 2425 +4459 2431 +4459 2570 +4459 4507 +4459 5017 +4459 5116 +4459 5150 +4459 5302 +4459 5303 +4469 548 +4469 1160 +4469 2126 +4469 2499 +4469 2690 +4469 3574 +4469 3917 +4469 5308 +4469 5309 +4469 5310 +4470 4 +4470 7 +4470 126 +4470 143 +4470 147 +4470 266 +4470 422 +4470 558 +4470 754 +4470 856 +3341 18 +3341 551 +3341 952 +3341 1388 +3341 3421 +3341 3852 +3341 4043 +3341 4685 +3341 4686 +3341 4687 +3660 3 +3660 122 +3660 459 +3660 1252 +3660 1849 +3660 2077 +3660 3178 +3660 4170 +3660 4772 +3660 4881 +4465 143 +4465 175 +4465 176 +4465 252 +4465 367 +4465 368 +4465 422 +4465 2001 +4465 2018 +1154 538 +1154 738 +1154 744 +1154 921 +1154 1155 +1154 1156 +1154 1157 +1154 1158 +1154 1159 +1154 1160 +1155 823 +1155 824 +1155 955 +1155 2394 +1155 2966 +1155 3034 +1155 3035 +1155 3036 +1155 3037 +1155 3038 +3037 1212 +3037 2051 +3037 2782 +3037 2796 +3037 3740 +3037 4434 +3037 4477 +3037 4478 +3037 4479 +3037 4480 +3040 4 +3040 5 +3040 122 +3040 123 +3040 128 +3040 144 +3040 175 +3040 176 +3040 424 +3041 134 +3041 365 +3041 1061 +3041 3207 +3041 3819 +3041 3867 +3041 4136 +3041 4193 +3041 4484 +3041 4485 +3042 3 +3042 124 +3042 175 +3042 249 +3042 250 +3042 266 +3042 367 +3042 558 +3042 697 +3042 754 +3043 9 +3043 126 +3043 145 +3043 147 +3043 148 +3043 252 +3043 266 +3043 352 +3043 559 +3043 856 +4467 2345 +4467 3097 +4467 3260 +4467 3314 +4467 5037 +4478 1052 +4478 1146 +4478 1961 +4478 3418 +4478 4009 +4478 4364 +4478 5313 +4478 5314 +4478 5315 +4478 5316 +4479 183 +4479 604 +4479 913 +4479 2039 +4479 2291 +4479 3318 +4479 4378 +4479 5317 +4479 5318 +4479 5319 +3564 854 +3564 1123 +3564 1573 +3564 3409 +3564 4158 +3564 4339 +3564 4718 +3564 4823 +1161 3 +1161 5 +1161 8 +1161 121 +1161 122 +1161 124 +1161 144 +1161 145 +1161 177 +1161 248 +1882 486 +1882 1531 +1882 1862 +1882 1930 +1882 2337 +1882 3624 +1882 3625 +1882 3626 +1882 3627 +1882 3628 +3627 3022 +3627 3699 +3627 4867 +3627 4868 +3627 4869 +3628 352 +4482 3 +4482 8 +4482 127 +4482 143 +4482 176 +4482 177 +4482 248 +4482 352 +4482 353 +4482 367 +3045 42 +3045 125 +3045 219 +3045 550 +3045 614 +3045 2004 +3045 2499 +3045 3104 +3045 4475 +3045 4476 +4658 1973 +1172 296 +1172 1173 +1172 1174 +1172 1175 +1172 1176 +1172 1177 +1172 1178 +1172 1179 +1172 1180 +1174 1178 +1174 1233 +1174 1439 +1174 1491 +1174 1946 +1174 3050 +1174 3051 +1174 3052 +1174 3053 +4923 5428 +4967 1303 +4967 1989 +4967 2769 +4967 3245 +4967 4330 +4967 4337 +4967 5074 +4967 5507 +4967 5587 +1181 1182 +1181 1183 +1181 1184 +1181 1185 +1181 1186 +1181 1187 +1181 1188 +1181 1189 +1181 1190 +1181 1191 +1189 3054 +1192 338 +1192 834 +1192 900 +1192 1193 +1192 1194 +1192 1195 +1192 1196 +1192 1197 +1192 1198 +3552 2 +3552 123 +3552 147 +3552 177 +3552 250 +3552 251 +3552 351 +3552 946 +3552 983 +3552 2077 +4825 838 +4825 839 +4825 1716 +4825 2211 +4825 2226 +4825 4388 +4825 4915 +4825 5513 +4825 5514 +4825 5515 +5241 198 +5241 1192 +5241 1969 +5241 2776 +5241 2888 +5241 3395 +5241 4251 +5241 4641 +5241 4992 +5241 5725 +5487 5858 +5785 121 +5785 123 +5785 144 +5785 149 +5785 176 +5785 180 +5785 352 +5785 754 +5785 1317 +5788 1173 +5788 1487 +5788 1544 +5788 3531 +5788 4885 +5788 5546 +5788 5655 +5788 5980 +5788 5981 +5788 5982 +4487 842 +4487 1103 +4487 1141 +4487 1481 +4487 2201 +4487 2453 +4487 3207 +4487 3327 +4487 3714 +4487 4111 +4492 573 +4492 1138 +4492 1177 +4492 1212 +4492 1940 +4492 3343 +4492 3860 +4492 4254 +4492 5321 +4492 5322 +1200 229 +1200 341 +1200 1201 +1200 1202 +1200 1203 +1200 1204 +1200 1205 +1200 1206 +1200 1207 +1200 1208 +1204 1097 +1204 1322 +1204 2887 +1204 3098 +1204 3099 +1204 3100 +1204 3101 +1204 3102 +1204 3103 +1204 3104 +1205 141 +1205 1849 +1205 1850 +1205 2996 +1205 3065 +1205 3066 +1205 3067 +1205 3068 +1205 3069 +1205 3070 +1207 1749 +1207 2739 +1207 3071 +1207 3072 +1207 3073 +1207 3074 +1207 3075 +1207 3076 +1207 3077 +1207 3078 +3098 308 +3098 480 +3098 1376 +3098 2199 +3098 2362 +3098 2995 +3098 3273 +3098 4355 +3098 4533 +3098 4534 +3100 303 +3100 1017 +3100 1221 +3100 1941 +3100 2932 +3100 3123 +3100 3722 +3100 3788 +3100 4171 +3100 4544 +3067 318 +3067 908 +3067 1267 +3067 1412 +3067 2162 +3067 3487 +3067 3767 +3067 4489 +3067 4490 +3067 4491 +3074 289 +3074 979 +3074 1228 +3074 4288 +3074 4493 +3078 75 +3078 108 +3078 272 +3078 274 +3078 477 +3078 814 +3078 1542 +3078 2248 +3078 4019 +3078 4500 +4533 103 +4533 112 +4533 1382 +4533 1541 +4533 1741 +4533 2201 +4533 2312 +4533 2758 +4533 5338 +4533 5339 +4536 56 +4536 158 +4536 1199 +4536 1341 +4536 2304 +4536 4096 +4536 5081 +4536 5340 +4536 5341 +4489 3813 +4489 5392 +4500 120 +4500 1666 +4500 1884 +4500 4002 +4500 4799 +4500 4841 +4500 5187 +4500 5283 +4500 5315 +4500 5327 +1211 1800 +3250 1903 +3490 4781 +1218 58 +1218 165 +1218 292 +1218 514 +1218 941 +1218 1000 +1218 1219 +1218 1220 +1218 1221 +1222 49 +1222 78 +1222 468 +1222 1223 +1222 1224 +1222 1225 +1222 1226 +1222 1227 +1222 1228 +1222 1229 +3086 327 +3086 1087 +3086 1689 +3086 2195 +3086 3823 +3086 4505 +3086 4506 +3086 4507 +3086 4508 +3086 4509 +3087 38 +3087 2571 +3087 2948 +3087 4134 +3087 4420 +3087 4510 +3087 4511 +3087 4512 +3087 4513 +3087 4514 +3088 121 +3088 122 +3088 123 +3088 125 +3088 127 +3088 144 +3088 174 +3088 352 +3088 369 +3088 1317 +3557 23 +3557 113 +3557 1123 +3557 1227 +3557 1501 +3557 2214 +3557 2276 +3557 4371 +3557 4816 +3557 4817 +4793 105 +4793 127 +4793 423 +4793 442 +4793 918 +4793 1540 +4793 2445 +4793 4664 +4793 5497 +6241 424 +6241 1800 +6241 3712 +6241 5128 +6241 5182 +6241 6119 +6241 6120 +6241 6255 +6241 6256 +6241 6257 +4505 3456 +4506 5316 +4508 125 +4508 129 +4508 145 +4508 174 +4508 180 +4508 353 +4508 559 +4508 697 +4508 717 +4508 1317 +4510 157 +4510 158 +4510 442 +4510 1317 +4510 4177 +4510 4958 +4510 5328 +4510 5329 +4510 5330 +4513 904 +4513 1524 +4513 2164 +4513 2710 +4513 3241 +4513 3303 +4513 3478 +4513 5191 +4513 5336 +4513 5337 +3634 1052 +3634 1067 +3634 2479 +3634 2528 +3634 3524 +3634 3677 +3634 4371 +3634 4641 +3634 4870 +3634 4871 +3635 1144 +3635 2170 +3635 2332 +3635 3860 +3635 4136 +3635 4872 +3635 4873 +3635 4874 +3635 4875 +3635 4876 +3269 5 +3269 17 +3269 126 +3269 143 +3269 149 +3269 250 +3269 266 +3269 423 +3269 424 +3269 559 +1237 842 +1237 852 +1237 1238 +1237 1239 +1237 1240 +1237 1241 +1237 1242 +1237 1243 +1237 1244 +1241 1492 +3106 2543 +1247 158 +1247 582 +1247 583 +1247 955 +1247 1032 +1247 1068 +1247 1070 +1247 1248 +1247 1249 +1247 1250 +1253 13 +1253 750 +1253 2359 +1253 3119 +1254 813 +1254 1890 +1254 2207 +1254 2997 +1254 3007 +4541 495 +4541 1213 +4541 1214 +4541 1577 +4541 2661 +4541 3721 +4541 4038 +4541 4158 +4541 4735 +4541 5344 +1767 1084 +1767 1768 +1767 1769 +1767 1770 +1767 1771 +1767 1772 +1767 1773 +1767 1774 +1767 1775 +1767 1776 +1260 301 +1260 1084 +1260 1086 +1260 1261 +1260 1262 +1260 1263 +1260 1264 +1260 1265 +1260 1266 +1266 906 +3120 178 +3120 253 +3120 263 +3120 553 +3120 2325 +3120 2497 +3120 3826 +3120 3942 +3120 4542 +3120 4543 +3126 113 +3135 283 +3135 476 +3135 1511 +3135 1714 +3135 2860 +3135 3343 +3135 3463 +3135 4419 +3135 4551 +3135 4552 +4551 63 +4551 260 +4551 562 +4551 870 +4551 2236 +4551 3397 +4551 4407 +4551 4970 +4551 5348 +4551 5349 +4552 3813 +1286 391 +1286 1056 +1286 1100 +1286 1287 +1286 1288 +1286 1289 +1286 1290 +1286 1291 +1286 1292 +1286 1293 +1387 860 +1387 1454 +1387 1457 +1387 1509 +1387 3220 +1387 3221 +1387 3280 +5931 731 +5931 1129 +5931 5228 +5931 5686 +5931 5999 +6071 364 +6071 3298 +6071 5014 +6071 5081 +6071 5179 +6071 5980 +6071 6249 +6071 6250 +6071 6251 +6071 6252 +1294 148 +1294 369 +1294 438 +1294 690 +1294 1069 +1294 1295 +1294 1296 +1294 1297 +1294 1298 +1294 1299 +3326 418 +3326 1021 +3326 1030 +3326 1240 +3326 3478 +3326 3499 +3326 4430 +3326 4583 +3326 4673 +3326 4674 +3190 123 +3190 124 +3190 367 +3190 368 +3190 667 +3190 857 +3190 1208 +3190 4577 +3190 4578 +3190 4579 +1409 5 +1409 127 +1409 148 +1409 183 +1409 252 +1409 264 +1409 559 +1409 666 +1409 1317 +1307 240 +1307 1308 +1307 1309 +1307 1310 +1307 1311 +1307 1312 +1307 1313 +1307 1314 +1307 1315 +1307 1316 +1308 2661 +1308 2922 +1308 3181 +1308 3182 +1308 3183 +4891 249 +4891 290 +4891 1456 +4891 2149 +4891 2949 +4891 4639 +4891 5106 +4891 5550 +4891 5551 +4891 5552 +5414 855 +5895 122 +5895 123 +5895 128 +5895 129 +5895 249 +5895 251 +5895 266 +5895 368 +5895 427 +5895 718 +6061 6150 +6062 1956 +6062 2761 +6062 3587 +6062 4577 +6062 4818 +6062 5554 +6062 6013 +6062 6151 +6062 6152 +6062 6153 +4566 92 +4566 163 +4566 1129 +4566 1808 +4566 3524 +4566 3636 +4566 4431 +4566 4776 +4566 5277 +4566 5353 +4567 149 +4567 261 +4567 649 +4567 1042 +4567 1060 +4567 1867 +4567 1922 +4567 5350 +4567 5351 +4567 5352 +4568 202 +4568 1330 +4568 2791 +4568 5354 +4568 5355 +4568 5356 +4568 5357 +4568 5358 +4557 41 +4557 804 +4557 2247 +4557 2536 +4557 3996 +4557 4459 +4557 5162 +4557 5300 +4557 5346 +4557 5347 +4585 158 +4585 229 +4585 1591 +4585 2893 +4585 3316 +4585 3906 +4585 4098 +4585 4784 +4585 4839 +4585 5366 +4587 462 +4587 1359 +4587 1457 +4587 1688 +4587 2875 +4587 3038 +4587 3858 +4587 4880 +4587 5367 +4587 5368 +3178 1948 +3178 2119 +3178 3325 +3178 3457 +3178 4419 +3178 4572 +3178 4573 +3178 4574 +3178 4575 +3178 4576 +4572 5376 +4574 392 +4574 617 +4574 1616 +4574 1937 +4574 1987 +4574 3446 +4574 4960 +4574 5362 +4574 5363 +4574 5364 +4583 1068 +4583 1227 +4583 2036 +4583 3087 +4583 4194 +4583 4793 +4583 5281 +4583 5285 +4583 5382 +4583 5383 +4577 8 +4577 282 +4577 822 +4577 1143 +4577 1780 +4577 2016 +4577 3081 +4577 5128 +4577 5365 +3202 267 +3202 1466 +3202 2869 +3202 3488 +3202 3708 +3202 3796 +3202 3818 +3202 4165 +3202 4322 +3202 4590 +1360 968 +1360 1561 +1360 2356 +1360 2918 +1360 3223 +3206 2909 +3206 3403 +3206 3489 +3206 4588 +3206 4589 +3208 559 +3208 1037 +3208 1122 +3208 1175 +3208 2018 +3208 2524 +3208 4005 +3208 4508 +3208 4592 +3208 4593 +3223 1327 +3223 2265 +3223 3720 +3223 4609 +3223 4610 +4592 5380 +4593 227 +4593 727 +4593 802 +4593 945 +4593 1347 +4593 1956 +4593 2884 +4593 3485 +4593 4324 +4593 5369 +1369 256 +1369 308 +1369 860 +1369 1457 +1369 1767 +1369 1817 +1369 3219 +1369 3220 +1369 3221 +1369 3222 +3222 296 +3222 413 +3222 1903 +3222 1939 +3222 4603 +3222 4604 +3222 4605 +3222 4606 +3222 4607 +3222 4608 +4596 133 +4596 3949 +4596 4426 +4596 5308 +4596 5370 +4596 5371 +4596 5372 +4596 5373 +4596 5374 +4596 5375 +4598 4 +4598 146 +4598 180 +4598 250 +4598 368 +4598 390 +4598 697 +4598 1245 +4598 1317 +4603 5381 +4606 862 +4606 1458 +4606 1900 +4606 3220 +4606 3221 +4606 4287 +4606 4586 +4606 5377 +4606 5378 +4606 5379 +3224 2516 +3225 108 +3225 756 +3225 763 +3225 2911 +3225 3438 +3225 3679 +3225 3748 +3225 4611 +3225 4612 +3225 4613 +1379 602 +1379 1274 +1379 1380 +1379 1381 +1379 1382 +1379 1383 +1379 1384 +1379 1385 +1379 1386 +1379 1387 +4620 2645 +5515 8 +5515 123 +5515 124 +5515 127 +5515 179 +5515 247 +5515 367 +5515 390 +5515 423 +5515 1246 +5858 612 +5655 1608 +5980 563 +5980 762 +5980 789 +5980 835 +5980 977 +5980 1122 +5980 1903 +5980 1913 +5980 3956 +5980 6096 +5981 111 +5981 830 +5981 1811 +5981 2163 +5981 2193 +5981 3861 +5981 3953 +5981 4332 +5981 6094 +5981 6095 +5982 243 +5982 2260 +5982 3093 +5982 3231 +5982 4592 +5982 5569 +5982 5645 +5982 6097 +5982 6098 +5982 6099 +1388 122 +1388 123 +1388 147 +1388 176 +1388 177 +1388 246 +1388 264 +1388 422 +1388 1245 +3281 3070 +3281 3122 +3281 3326 +3281 4581 +3281 4641 +3281 4648 +3281 4649 +3281 4650 +3281 4651 +3281 4652 +4617 3716 +4617 3949 +4617 4783 +4617 5175 +4617 5211 +4617 5386 +4617 5387 +4617 5388 +4617 5389 +4617 5390 +4619 381 +4619 778 +4619 1592 +4619 1900 +4619 2166 +4619 2234 +4619 2646 +4619 2875 +4619 3327 +4619 4812 +4650 605 +4650 835 +4650 1430 +4650 2970 +4650 3369 +4650 5407 +4650 5408 +4650 5409 +4650 5410 +1398 554 +1398 736 +1398 1022 +1398 1399 +1398 1400 +1398 1401 +1398 1402 +1399 387 +1399 416 +1399 765 +1399 806 +1399 3242 +1399 3243 +1399 3244 +1399 3245 +1399 3246 +1399 3247 +3246 268 +3246 576 +3246 840 +3246 1797 +3246 3956 +3246 4608 +3246 4629 +3246 4630 +3246 4631 +3246 4632 +3254 1067 +3255 127 +3255 146 +3255 250 +3255 367 +3255 369 +3255 423 +3255 697 +3255 754 +3255 856 +1758 1135 +1758 2805 +1758 3126 +1758 3520 +1758 3521 +1758 3522 +1758 3523 +1758 3524 +1758 3525 +1758 3526 +4629 151 +4629 281 +4629 491 +4629 2360 +4629 2781 +4629 3576 +4629 3891 +4629 5328 +4629 5391 +4631 251 +4631 664 +4631 803 +4631 2218 +4631 2285 +4631 2309 +4631 4137 +4631 5393 +4631 5394 +4631 5395 +4638 159 +4638 828 +4638 1604 +4638 2886 +4638 5357 +4638 5399 +4638 5400 +4638 5401 +4638 5402 +4639 472 +4639 576 +4639 2060 +4639 4158 +4639 5406 +3358 132 +3358 1801 +3358 1900 +3358 2224 +3358 3039 +3358 3606 +3358 4533 +3358 4697 +3358 4698 +3358 4699 +4636 5 +4636 9 +4636 148 +4636 179 +4636 390 +4636 422 +4636 558 +4636 697 +4636 754 +4636 856 +3605 731 +4633 199 +4633 474 +4633 476 +4633 637 +4633 2269 +4633 3105 +4633 3227 +4633 4646 +4633 5397 +4633 5398 +1403 132 +1403 188 +1403 926 +1403 1404 +1403 1405 +1403 1406 +1403 1407 +1403 1408 +1403 1409 +1403 1410 +1404 228 +1404 2429 +1404 2477 +1404 2755 +1404 3274 +1404 3275 +1404 3276 +1404 3277 +1404 3278 +1404 3279 +3274 4644 +3270 522 +3270 4150 +3270 4365 +3270 4642 +3270 4643 +4643 538 +4643 1575 +4643 1731 +4643 2214 +4643 2784 +4643 3566 +4643 4336 +4643 5342 +4643 5343 +4654 1137 +4654 1239 +4654 1509 +4654 1616 +4654 1803 +4654 3141 +4654 3699 +4654 3807 +4654 4655 +4654 5852 +4654 5954 +4654 5955 +6036 474 +6036 810 +6036 1332 +6036 1458 +6036 1842 +6036 3213 +6036 3411 +6036 3658 +6036 3913 +6036 6137 +6038 50 +6038 190 +6038 1376 +6038 1557 +6038 1689 +6038 2254 +6038 2354 +6038 2414 +6038 2657 +6038 2750 +1550 126 +1550 145 +1550 149 +1550 183 +1550 246 +1550 390 +1550 423 +1550 667 +1550 718 +1550 856 +3524 330 +3524 945 +3524 1047 +3524 1797 +3524 2397 +3524 2705 +3524 3017 +3524 3235 +3524 3583 +3524 4802 +4662 828 +4662 1195 +4662 2698 +4662 2773 +4662 2891 +4662 3595 +4662 4770 +4662 4848 +4662 5392 +4662 5411 +1443 1444 +1445 326 +1445 502 +1445 578 +1445 1446 +1445 1447 +1445 1448 +1445 1449 +1445 1450 +1445 1451 +1445 1452 +1453 221 +1453 476 +1453 1195 +1453 1295 +1453 1454 +1453 1455 +1453 1456 +1453 1457 +1453 1458 +1453 1459 +4664 3635 +4664 5434 +4664 5435 +4664 5436 +4665 110 +4665 566 +4665 928 +4665 2254 +4665 2666 +4665 2744 +4665 2859 +4665 3097 +4665 5159 +4665 5412 +4666 15 +4666 1158 +4666 1278 +4666 1383 +4666 2558 +4666 3062 +4666 4296 +4666 4297 +4666 4988 +4666 5413 +4667 458 +4667 1482 +4667 1524 +4667 1599 +4667 2887 +4667 3046 +4667 3675 +4667 5101 +4667 5373 +1460 1461 +1462 1463 +1462 1464 +1462 1465 +1462 1466 +1462 1467 +1462 1468 +1462 1469 +1462 1470 +1462 1471 +1462 1472 +1474 158 +1478 110 +1478 798 +1478 1095 +1478 1215 +1478 1479 +1478 1480 +1478 1481 +1478 1482 +1478 1483 +1478 1484 +1484 1581 +1484 2071 +1484 2516 +1484 2532 +1484 3079 +1484 3200 +1484 3323 +1484 3324 +1484 3325 +1494 5 +1494 7 +1494 125 +1494 144 +1494 149 +1494 174 +1494 179 +1494 424 +1494 559 +1494 667 +1495 1496 +1497 125 +1497 828 +1497 1498 +1497 1499 +1497 1500 +1497 1501 +1497 1502 +1497 1503 +1497 1504 +1497 1505 +3499 788 +4674 5283 +1518 1519 +1519 561 +1519 725 +1519 756 +1519 982 +1519 1061 +1519 1120 +1519 1422 +1519 3348 +1519 3349 +1519 3350 +3348 124 +3348 128 +3348 146 +3348 147 +3348 176 +3348 238 +3348 249 +3348 264 +3348 368 +3348 718 +4692 532 +4692 2916 +4692 4371 +4692 4402 +4692 5425 +1520 609 +1520 614 +1520 883 +1520 958 +1520 1521 +1520 1522 +1520 1523 +1520 1524 +1520 1525 +1520 1526 +1527 3 +1527 454 +1527 462 +1527 691 +1527 970 +1527 1025 +1527 1492 +1527 1528 +1527 1529 +1527 1530 +3333 211 +3333 331 +3333 651 +3333 2125 +3333 2129 +3333 2377 +3333 3951 +3333 4249 +3333 4676 +3333 4677 +4676 524 +4676 3050 +4676 3780 +4676 4109 +5497 41 +5497 143 +5497 266 +5497 491 +5497 911 +5497 2202 +5497 3599 +5497 4652 +5497 5845 +5497 5846 +5552 353 +5552 785 +5552 849 +5552 918 +5552 1103 +5552 3618 +5552 4812 +5552 5040 +5552 5405 +5552 5873 +6152 371 +6152 762 +6152 1330 +6152 1797 +6152 2531 +6152 3305 +6152 3503 +6152 3900 +6152 4981 +6152 6171 +3338 133 +3338 1808 +3338 2971 +3338 3808 +3338 4281 +3338 4356 +3338 4412 +3338 4682 +3360 418 +1672 1673 +3390 661 +3390 976 +3390 1023 +3390 1313 +3390 1530 +3390 1802 +3390 2981 +3390 3727 +3390 4725 +3390 4726 +3393 646 +3393 1251 +3393 1487 +3393 1618 +3393 3223 +3393 3463 +3393 4731 +3393 4732 +4684 970 +4684 1731 +4684 3837 +4684 4176 +4684 4735 +4684 5343 +4684 5419 +4684 5420 +4686 315 +4686 337 +4686 353 +4686 629 +4686 1491 +4686 3571 +4686 4915 +4686 5300 +4686 5421 +4686 5422 +1816 628 +1816 820 +1816 1258 +1816 2873 +1816 2975 +1816 3262 +1816 3446 +1816 3551 +1816 3552 +1816 3553 +1562 391 +1562 405 +1562 824 +1562 1105 +1562 1563 +1562 1564 +1562 1565 +1562 1566 +1562 1567 +1562 1568 +1566 297 +1566 338 +1566 1192 +1566 1425 +1566 2450 +1566 3351 +1566 3352 +1566 3353 +1566 3354 +1566 3355 +3355 584 +3355 1837 +3355 2629 +3355 3035 +3355 3319 +3355 3335 +3355 4693 +3355 4694 +3355 4695 +3355 4696 +4693 416 +4693 705 +4693 1651 +4693 1968 +4693 2399 +4693 2848 +4693 3733 +4693 4640 +4693 5426 +4693 5427 +4694 1047 +4694 2449 +4694 3293 +4694 3929 +4694 4164 +4694 5430 +4694 5431 +4694 5432 +4694 5433 +1572 1127 +1572 1273 +1572 1550 +1572 1961 +1572 2400 +1572 2465 +1572 3356 +1572 3357 +1572 3358 +1572 3359 +3356 127 +3356 128 +3356 246 +3356 248 +3356 352 +3356 353 +3356 422 +3356 427 +3356 667 +3356 856 +3359 997 +1577 550 +1577 1578 +1579 391 +1579 602 +1579 1240 +1579 1246 +1579 1385 +1579 1580 +1579 1581 +1579 1582 +1579 1583 +1582 355 +1582 1791 +1582 1797 +1582 2285 +1582 2309 +1582 2799 +1582 3282 +1582 3371 +1582 3372 +1586 4 +1586 8 +1586 147 +1586 148 +1586 174 +1586 352 +1586 368 +1586 424 +1586 856 +1586 2098 +3369 104 +3369 391 +3369 860 +3369 1855 +3369 3014 +3369 4093 +3369 4120 +3369 4298 +3369 4714 +3369 4715 +4705 5 +4705 144 +4705 148 +4705 249 +4705 252 +4705 264 +4705 266 +4705 367 +4705 666 +4705 1245 +1855 161 +1855 473 +1855 552 +1855 1670 +1855 1731 +1855 2563 +1855 3364 +1855 3572 +1855 3600 +1855 3601 +1596 298 +1596 465 +1596 1597 +1596 1598 +1596 1599 +1596 1600 +1596 1601 +1596 1602 +1596 1603 +1596 1604 +1603 5 +1603 8 +1603 9 +1603 147 +1603 149 +1603 179 +1603 252 +1603 426 +1603 856 +1603 2098 +1605 102 +1605 430 +1605 472 +1605 1024 +1605 1297 +1605 1381 +1605 1606 +1605 1607 +1605 1608 +1605 1609 +3378 2875 +1616 288 +1616 1595 +1616 1617 +1616 1618 +1616 1619 +1616 1620 +1616 1621 +1616 1622 +1616 1623 +1616 1624 +4720 131 +4720 133 +4720 400 +4720 883 +4720 4031 +4720 4373 +4720 4400 +4720 4871 +4720 4951 +4720 5438 +4721 51 +4721 472 +4721 1411 +4721 1926 +4721 3552 +4721 4160 +4721 5159 +4721 5439 +4721 5440 +4721 5441 +4723 529 +4723 649 +4723 2358 +4723 3220 +4723 4670 +4723 4676 +4723 4844 +4723 5241 +4723 5428 +4723 5442 +4724 63 +4724 514 +4724 1694 +4724 4296 +4724 5155 +4724 5443 +4724 5444 +4724 5445 +4724 5446 +1625 29 +1625 303 +1625 364 +1625 1061 +1625 1626 +1625 1627 +1625 1628 +1625 1629 +1625 1630 +1625 1631 +1627 364 +1627 442 +1627 2278 +1627 3384 +1627 3385 +3380 248 +3380 487 +3380 910 +3380 1801 +3380 2002 +3380 3350 +3380 4716 +3380 4717 +3380 4718 +1632 1481 +1638 2017 +1673 389 +1673 503 +1673 1513 +1673 1940 +1673 2216 +1673 2359 +1673 2634 +1673 2636 +1673 3448 +1673 3449 +4725 255 +4725 381 +4725 2226 +4725 3181 +4725 5456 +4726 804 +4726 1507 +4726 2292 +4726 2697 +4726 3496 +4726 3516 +4726 3949 +4726 4042 +4726 5261 +4731 2554 +4731 3120 +4731 4770 +4731 5155 +4732 132 +4732 433 +4732 459 +4732 2060 +4732 2097 +4732 2332 +4732 2408 +4732 3312 +4732 3635 +4732 4667 +4728 102 +4728 126 +4728 144 +4728 145 +4728 179 +4728 266 +4728 483 +4728 1827 +4728 3290 +4728 4643 +4729 4986 +4730 2519 +4730 2776 +4730 2844 +4730 4273 +4730 4438 +4730 4441 +4730 4664 +4730 4944 +4730 5231 +4730 5453 +1648 1649 +1649 297 +1649 324 +1649 1044 +1649 1157 +1649 2793 +1649 3396 +1649 3397 +1649 3398 +3396 163 +3396 266 +3396 894 +3396 2196 +3396 2221 +3396 2443 +3396 4402 +3396 4689 +3396 4733 +3396 4734 +3398 341 +3398 1859 +3398 1955 +3398 2891 +3398 2905 +3398 3788 +3398 3822 +3398 4743 +3398 4744 +3398 4745 +4733 178 +4733 983 +4733 1679 +4733 2569 +4733 3590 +4733 3730 +4733 4526 +4733 4876 +4733 5447 +4733 5448 +4734 43 +4745 56 +4745 738 +4745 823 +4745 898 +4745 1568 +4745 2024 +4745 3681 +4745 4337 +4745 4769 +4745 5461 +1654 997 +1654 1023 +1654 2552 +1654 2825 +1654 2876 +1654 3282 +1654 3404 +1654 3405 +1654 3406 +1654 3407 +3406 1367 +3406 3292 +3406 3991 +3406 4739 +3406 4740 +3407 1246 +3407 1503 +3407 1650 +3407 1845 +3407 2343 +3407 3303 +3407 4206 +3407 4264 +3407 4741 +3407 4742 +4735 606 +4735 2249 +4735 3993 +4735 5473 +4735 5474 +4735 5475 +4739 260 +4739 762 +4739 1333 +4739 3475 +4739 3504 +4739 3807 +4739 3851 +4739 5454 +4739 5455 +4740 908 +4740 942 +4740 991 +4740 1412 +4740 2162 +4740 2708 +4740 3767 +4740 4113 +4740 5457 +4740 5458 +1657 89 +1657 547 +1657 1340 +1657 1658 +1657 1659 +1657 1660 +1657 1661 +1657 1662 +1657 1663 +1657 1664 +1663 266 +1663 1152 +1663 2257 +1663 2429 +1663 3140 +1663 3571 +3412 112 +3412 1636 +3412 2430 +3412 3760 +3412 4002 +3412 4402 +3412 4746 +3412 4747 +3412 4748 +3412 4749 +3571 199 +3571 293 +3571 364 +3571 659 +3571 1259 +3571 1266 +3571 2020 +3571 4831 +3571 4832 +3571 4833 +4754 115 +4754 124 +4754 483 +4754 521 +4754 1413 +4754 1654 +4754 1768 +4754 4113 +4754 4914 +4754 5467 +4751 8 +4751 122 +4751 129 +4751 177 +4751 249 +4751 251 +4751 352 +4751 353 +4751 367 +4751 856 +4746 798 +4746 2443 +4746 2635 +4746 2639 +4746 3071 +4746 3854 +4746 4811 +4746 5369 +4746 5462 +4746 5463 +4748 1337 +4748 1981 +4748 2383 +4748 3775 +4748 3810 +4748 4598 +4748 5102 +4748 5464 +4748 5465 +4748 5466 +4833 1056 +4833 1539 +4833 1974 +4833 2020 +4833 2114 +4833 2755 +4833 3277 +4833 4810 +4833 5521 +4833 5522 +1665 126 +1665 251 +1665 264 +1665 265 +1665 266 +1665 368 +1665 666 +1665 667 +1665 1666 +1665 1667 +4803 495 +4803 2497 +4803 3088 +4803 3422 +4803 4036 +4803 4187 +4803 4882 +4803 5043 +4803 5507 +4803 5508 +5082 348 +5082 731 +5082 1233 +5082 1323 +5082 1506 +5082 3213 +5082 3356 +5082 3468 +5082 4893 +5082 5373 +5043 2557 +5508 547 +5508 1301 +5508 2376 +5508 3813 +5508 4067 +5508 4382 +5508 5856 +5508 5857 +1668 71 +1668 1353 +1668 1669 +1668 1670 +1668 1671 +1674 513 +1674 1587 +1674 1675 +1674 1676 +1674 1677 +1674 1678 +1674 1679 +1674 1680 +1674 1681 +1674 1682 +1676 3 +1676 5 +1676 7 +1676 8 +1676 122 +1676 123 +1676 149 +1676 174 +1676 251 +1676 717 +1680 2131 +3428 1235 +3428 1539 +3428 1776 +3428 1947 +3428 3136 +3428 4373 +3428 4675 +3428 4755 +3428 4756 +3428 4757 +3430 4758 +4755 5 +4755 7 +4755 121 +4755 125 +4755 127 +4755 148 +4755 174 +4755 177 +4755 251 +4755 427 +4758 365 +4758 1321 +4758 1808 +4758 2304 +4758 3092 +4758 4031 +4758 4063 +4758 5451 +4758 5468 +1683 1684 +1687 721 +1687 1115 +1687 2359 +1687 3070 +1687 3100 +1687 3230 +1687 3439 +1687 3440 +1687 3441 +1687 3442 +4842 249 +1692 191 +1692 280 +1692 1084 +1692 1256 +1692 1693 +1692 1694 +1692 1695 +1692 1696 +1692 1697 +1692 1698 +1694 246 +1694 942 +1694 3032 +1694 3443 +1694 3444 +1694 3445 +1694 3446 +1694 3447 +1698 2026 +1698 2551 +1698 2850 +1698 2980 +1698 3220 +1698 3450 +1698 3451 +1698 3452 +1698 3453 +1698 3454 +3451 833 +3451 1599 +3451 1845 +3451 1881 +3451 1889 +3451 3218 +3451 3446 +3451 4541 +3451 4759 +3451 4760 +3452 9 +3452 17 +3452 143 +3452 144 +3452 147 +3452 149 +3452 179 +3452 424 +3452 559 +3452 2018 +4768 989 +4768 5477 +4769 983 +4769 2670 +4769 2986 +4769 3038 +4769 3337 +4769 4203 +4769 5085 +4769 5140 +4769 5471 +4769 5472 +4771 804 +4771 1090 +4771 1426 +4771 3951 +4771 4422 +1710 1711 +1712 1713 +1713 469 +1713 514 +1713 1219 +1713 1252 +1713 1776 +1713 2163 +1713 3472 +1713 3473 +1713 3474 +1713 3475 +4778 712 +4778 1034 +4778 1345 +4778 1743 +4778 1807 +4778 2391 +4778 3110 +4778 4003 +4778 5485 +4778 5486 +1722 1723 +1723 4 +1723 7 +1723 149 +1723 175 +1723 179 +1723 252 +1723 266 +1723 352 +1723 424 +1729 23 +1729 1058 +1729 1594 +1729 1647 +1729 1679 +1729 1730 +1729 1731 +1729 1732 +1729 1733 +1729 1734 +1732 9 +1732 128 +1732 148 +1732 149 +1732 175 +1732 179 +1732 238 +1732 352 +1732 353 +1732 559 +4826 230 +4826 1192 +4826 2217 +4826 2360 +4826 3903 +4826 4112 +4826 4215 +4826 5300 +4826 5523 +4826 5524 +3528 305 +3528 707 +3528 2285 +3528 2869 +3528 4726 +3528 4797 +3528 4798 +3528 4799 +3528 4800 +3528 4801 +3529 127 +3529 146 +3529 180 +3529 249 +3529 266 +3529 559 +3529 754 +3529 1245 +3529 2001 +4798 821 +4798 1456 +4798 1842 +4798 1955 +4798 2866 +4798 2889 +4798 3233 +4798 3805 +4798 5499 +4798 5500 +4799 1456 +4799 1618 +4799 2234 +4799 2896 +4799 4876 +4799 4883 +4799 5463 +4799 5498 +4800 1240 +4800 1559 +4800 1766 +4800 3205 +4800 3672 +4800 3678 +4800 4942 +4800 5503 +4800 5504 +4800 5505 +1742 577 +1742 813 +1742 938 +1742 1408 +1742 1600 +1742 1743 +1742 1744 +1742 1745 +1742 1746 +1742 1747 +1743 849 +1743 2016 +1743 2648 +1743 2735 +1743 2781 +1743 2836 +1743 3188 +1743 3500 +1743 3501 +1743 3502 +1746 255 +1746 406 +1746 538 +1746 889 +1746 2084 +1746 2314 +1746 2547 +1746 3503 +1746 3504 +1746 3505 +3500 2127 +3500 2420 +3500 4185 +3500 4626 +3500 4782 +3500 4783 +3500 4784 +3500 4785 +3500 4786 +3500 4787 +3503 176 +3503 937 +3503 1275 +3503 1387 +3503 2829 +3503 3596 +3503 4097 +3503 4445 +3503 4606 +3503 4788 +3505 3 +3505 143 +3505 145 +3505 177 +3505 251 +3505 353 +3505 753 +3505 754 +3505 3002 +3505 3132 +4782 1947 +4782 2524 +4782 2787 +4782 3140 +4782 3283 +4782 3288 +4782 3766 +4782 5487 +4782 5488 +4782 5489 +4783 51 +4783 651 +4783 1563 +4783 2186 +4783 2377 +4783 2452 +4783 2579 +4783 3418 +4783 3917 +4783 4293 +4784 122 +4784 123 +4784 124 +4784 127 +4784 129 +4784 248 +4784 845 +4784 2381 +4784 3305 +4784 5492 +4788 1909 +4788 1942 +4788 2068 +4788 4183 +4788 4216 +4788 4653 +4788 5115 +4788 5304 +4788 5493 +4788 5494 +1748 255 +1748 916 +1748 1028 +1748 1044 +1748 1564 +1748 1749 +1748 1750 +1748 1751 +1748 1752 +1751 103 +1751 123 +1751 3513 +1751 3514 +1751 3515 +3514 921 +3514 1160 +3514 1429 +3514 1898 +3514 2479 +3514 2555 +3514 3574 +3514 4600 +3514 4791 +3514 4792 +4790 547 +4790 909 +4790 1007 +4790 1812 +4790 2928 +4790 3033 +4790 4558 +4790 5050 +4790 5495 +4790 5496 +4792 769 +4792 874 +4792 1227 +4792 1894 +4792 2538 +4792 2670 +4792 4199 +4792 4338 +4792 4578 +4792 5327 +1753 182 +1753 1754 +1753 1755 +1753 1756 +1753 1757 +1753 1758 +1753 1759 +1753 1760 +1753 1761 +1753 1762 +3521 629 +3521 711 +3521 1049 +3521 2594 +3521 2650 +3521 2779 +3521 4096 +3521 4794 +3521 4795 +3521 4796 +3522 179 +3522 1089 +3522 1604 +3522 4096 +3522 4360 +3522 4362 +3522 4487 +3522 4516 +3522 4793 +1785 174 +1785 1574 +1785 1786 +1785 1787 +1785 1788 +1785 1789 +1785 1790 +1785 1791 +1785 1792 +1785 1793 +1793 1248 +1793 1901 +1793 2336 +1793 2543 +1793 2713 +1793 2818 +1793 2838 +1793 3541 +4805 55 +4805 325 +4805 490 +4805 963 +4805 1287 +4805 1370 +4805 1423 +4805 3577 +4805 5506 +4810 5 +4810 143 +4810 145 +4810 368 +4810 667 +4810 740 +4810 1548 +4810 2718 +4810 3002 +4810 3048 +1794 271 +1794 458 +1794 818 +1794 1250 +1794 1538 +1794 1766 +1794 1795 +1794 1796 +1794 1797 +1794 1798 +1799 554 +1799 655 +1799 661 +1799 853 +1799 1026 +1799 1800 +1799 1801 +1799 1802 +1799 1803 +1799 1804 +3542 470 +3542 2304 +3542 4625 +3542 4788 +3542 4793 +3542 4811 +3542 4812 +3542 4813 +3542 4814 +4811 3003 +4813 300 +4813 1434 +4813 1487 +4813 1730 +4813 2541 +4813 2787 +4813 2881 +4813 5510 +4815 463 +4815 1676 +4815 2274 +4815 2860 +4815 2900 +4815 3149 +4815 3295 +4815 4352 +4815 5509 +1818 18 +1818 270 +1818 725 +1818 1157 +1818 1575 +1818 3174 +1818 3413 +1818 3554 +1818 3555 +1818 3556 +1819 996 +1819 1492 +1819 2486 +1819 2869 +1819 3327 +1819 3563 +1819 3564 +1819 3565 +1819 3566 +1819 3567 +1820 894 +1820 1022 +1820 1139 +1820 2358 +1820 3557 +1820 3558 +1820 3559 +1820 3560 +1820 3561 +1820 3562 +3553 5 +3553 121 +3553 125 +3553 126 +3553 148 +3553 179 +3553 265 +3553 352 +3553 422 +3553 666 +3560 126 +3560 224 +3560 756 +3560 820 +3560 821 +3560 1362 +3560 3105 +3560 4450 +3560 4821 +3560 4822 +4822 1054 +4822 1561 +4822 1619 +4822 2310 +4822 2652 +4822 2713 +4822 2981 +4822 4598 +4822 5511 +4822 5512 +4837 5525 +1834 224 +1834 275 +1834 1287 +1834 1835 +1834 1836 +1834 1837 +1834 1838 +1834 1839 +1834 1840 +1839 53 +1839 222 +1839 818 +1839 2359 +1839 2377 +1839 2683 +1839 2767 +1839 3590 +1839 3591 +1839 3592 +1847 141 +1847 977 +1847 1848 +1847 1849 +1847 1850 +1847 1851 +1847 1852 +1847 1853 +1847 1854 +1847 1855 +1848 167 +1848 276 +1848 368 +1848 2127 +1848 2571 +1848 2787 +1848 2996 +1848 3593 +1848 3594 +4847 350 +4847 1040 +4847 1054 +4847 1512 +4847 2752 +4847 3417 +4847 4080 +4847 4251 +4847 4551 +4847 5526 +4852 554 +4852 763 +4852 1400 +4852 1881 +4852 4447 +4852 4645 +4852 5110 +4852 5527 +4852 5528 +4852 5529 +1856 289 +1856 1211 +1856 1857 +1856 1858 +1856 1859 +1856 1860 +1856 1861 +1856 1862 +1856 1863 +1857 757 +1857 758 +1857 884 +1857 2176 +1857 3609 +1857 3610 +1857 3611 +1857 3612 +1857 3613 +1857 3614 +3802 478 +3805 2059 +3805 2238 +3805 4508 +3805 5001 +3805 5848 +3805 5849 +3805 5850 +3805 5851 +3805 5852 +3805 5853 +4856 508 +4856 5393 +4856 5531 +4856 5532 +4857 114 +4857 387 +4857 473 +4857 531 +4857 588 +4857 1821 +4857 3511 +4857 4215 +4857 5530 +1864 58 +1864 924 +1864 1297 +1864 1606 +1864 1608 +1864 1865 +1864 1866 +1864 1867 +1864 1868 +1864 1869 +4864 141 +4864 279 +4864 1143 +4864 1443 +4864 2961 +4864 3452 +4864 5533 +4864 5534 +4864 5535 +4864 5536 +3621 4159 +1876 1288 +1877 477 +1877 534 +1877 1733 +1877 1878 +1877 1879 +1877 1880 +1877 1881 +1877 1882 +1877 1883 +1877 1884 +1880 219 +1880 363 +1880 846 +1880 925 +1880 1001 +1880 2563 +1880 3105 +1880 3629 +1880 3630 +1880 3631 +1883 534 +1883 621 +1883 944 +1883 1060 +1883 1261 +1883 2252 +1883 2789 +1883 3188 +1883 3673 +1883 3674 +1884 122 +1884 123 +1884 124 +1884 125 +1884 127 +1884 128 +1884 129 +1884 144 +1884 264 +1884 427 +3631 788 +3673 123 +3673 127 +3673 177 +3673 246 +3673 264 +3673 353 +3673 422 +3673 717 +3673 856 +3673 1245 +4874 123 +4874 249 +4874 250 +4874 251 +4874 264 +4874 422 +4874 427 +4874 1245 +4874 2001 +4875 107 +4875 1229 +4875 2093 +4875 2350 +4875 2408 +4875 2890 +4875 3395 +4875 3542 +4875 4158 +4875 5333 +4867 493 +4867 600 +4867 725 +4867 1034 +4867 2347 +4867 3968 +4867 5283 +4867 5543 +4867 5544 +4880 1598 +4880 4333 +4880 4395 +4880 5295 +4880 5545 +4880 5546 +4880 5547 +4880 5548 +4880 5549 +4881 5672 +4890 223 +4890 1029 +4890 1524 +4890 1695 +4890 1956 +4890 2911 +4890 3489 +4890 3590 +4890 3695 +4890 5553 +4900 5 +4900 8 +4900 121 +4900 129 +4900 149 +4900 174 +4900 179 +4900 249 +4900 251 +4900 352 +4902 996 +4902 2868 +4902 3188 +4902 3580 +4902 3804 +4902 4563 +4902 4903 +4902 5556 +4902 5557 +4902 5558 +4903 2679 +4903 3195 +4903 3822 +4903 4732 +4903 5056 +4903 5559 +4903 5560 +4903 5561 +4903 5562 +4908 424 +4908 5314 +4908 5563 +4908 5564 +4908 5565 +6138 129 +6138 143 +6138 146 +6138 177 +6138 249 +6138 367 +6138 369 +6138 423 +6138 424 +6138 2338 +5682 364 +5682 852 +5682 1700 +5682 1910 +5682 1945 +5682 2085 +5682 3299 +5682 4891 +5682 5116 +5682 5837 +4921 219 +4921 1798 +4921 2129 +4921 2235 +4921 4468 +4918 5577 +4932 1943 +4932 2276 +4932 2723 +4932 3786 +4932 4623 +4932 5572 +4932 5573 +4932 5574 +4932 5575 +4932 5576 +5089 3981 +5892 6049 +5893 8 +5893 124 +5893 238 +5893 248 +5893 249 +5893 251 +5893 352 +5893 422 +5893 423 +5893 667 +4937 1412 +4937 2162 +4937 2500 +4937 4012 +4937 4589 +4937 4811 +4937 4825 +4937 4889 +4937 5349 +4937 5578 +4935 1136 +4935 2151 +4935 2785 +4935 3849 +4935 3856 +4935 4103 +4935 5388 +4935 5448 +4935 5585 +4935 5586 +4940 988 +4940 1273 +4940 1480 +4940 2148 +4940 2201 +4940 2787 +4940 3169 +4940 3636 +4940 5579 +4940 5580 +4948 5583 +4949 31 +4949 127 +4949 143 +4949 368 +4949 422 +4949 427 +4949 558 +4949 856 +4949 2001 +4951 748 +4951 780 +4951 803 +4951 1280 +4951 2236 +4951 2285 +4951 2568 +4951 2583 +4951 4641 +4951 4799 +5024 114 +5028 156 +5028 1037 +5028 1129 +5028 1203 +5028 2752 +5028 3064 +5028 3797 +5028 5353 +5028 5605 +5267 3 +5267 9 +5267 122 +5267 125 +5267 126 +5267 145 +5267 149 +5267 174 +5267 247 +5267 1317 +5937 817 +5937 1652 +5937 3083 +5937 4075 +5937 5614 +5939 325 +5939 1007 +5939 1952 +5939 2477 +5939 3124 +5939 3416 +5939 3543 +5939 4877 +5939 5896 +5939 6072 +4986 200 +4986 1038 +4986 1044 +4986 2036 +4986 2425 +4986 3566 +4986 3794 +4986 4262 +4986 5588 +4986 5589 +4988 5 +4988 9 +4988 126 +4988 148 +4988 174 +4988 264 +4988 390 +4988 558 +4988 559 +4999 123 +4999 149 +4999 179 +4999 427 +4995 800 +4995 1590 +4995 1600 +4995 1872 +4995 2860 +4995 2930 +4995 3674 +4995 5291 +4995 5590 +5003 2916 +5003 2964 +5003 2981 +5003 3629 +5003 4247 +5003 5220 +5003 5507 +5003 5591 +5003 5592 +5003 5593 +5007 1880 +5007 2841 +5007 3460 +5007 4111 +5007 4619 +5007 5594 +5007 5595 +5007 5596 +5007 5597 +5007 5598 +5008 31 +5008 123 +5008 176 +5008 250 +5008 1317 +5008 1518 +5008 3781 +5008 3934 +5008 4754 +5008 5599 +5890 285 +5012 266 +5012 440 +5012 826 +5012 852 +5012 2394 +5012 2552 +5012 3334 +5012 3456 +5012 4281 +5021 5604 +5026 1050 +5026 1447 +5026 1590 +5026 1689 +5026 1912 +5026 2194 +5026 2337 +5026 4133 +5026 5602 +5026 5603 +5037 2765 +5037 5611 +5029 146 +5029 177 +5029 353 +5029 1047 +5029 1135 +5029 2130 +5029 2338 +5029 3503 +5029 4453 +5029 5617 +5030 281 +5030 1168 +5030 1447 +5030 1451 +5030 1590 +5030 2353 +5030 2885 +5030 3069 +5030 4687 +5030 4877 +5034 3029 +5035 2857 +5035 3681 +5035 3727 +5035 3772 +5035 4663 +5035 5606 +5035 5607 +5035 5608 +5035 5609 +5035 5610 +5272 203 +5272 852 +5272 1614 +5272 1797 +5272 2652 +5272 2706 +5272 5735 +5272 5736 +5272 5737 +5042 2968 +5044 122 +5044 123 +5044 125 +5044 144 +5044 174 +5044 352 +5044 369 +5044 424 +5044 427 +5044 2338 +5045 1015 +5045 2869 +5045 3084 +5045 5056 +5045 5080 +5045 5096 +5045 5425 +5045 5614 +5045 5615 +5045 5616 +5052 198 +5052 356 +5052 558 +5052 2234 +5052 2285 +5052 2354 +5052 3035 +5052 3133 +5052 4892 +5052 5618 +5924 276 +5924 619 +5924 1568 +5924 1983 +5924 2276 +5924 3173 +5924 3891 +5924 4052 +5924 5911 +5924 6071 +5925 125 +5925 229 +5925 3257 +5925 3852 +5925 4882 +5925 4894 +5925 5086 +5925 5128 +5925 5229 +5925 6070 +5066 164 +5066 523 +5066 815 +5066 2155 +5066 2237 +5066 2548 +5066 3407 +5066 4319 +5066 5159 +5066 5620 +5067 804 +5067 940 +5067 1710 +5067 2844 +5067 3407 +5067 4364 +5067 5434 +5067 5631 +5067 5632 +5067 5633 +5069 5623 +5058 85 +5058 153 +5058 919 +5058 1956 +5058 2112 +5058 2410 +5058 2414 +5058 4735 +5058 5196 +5058 5452 +5060 363 +5063 574 +5063 2006 +5063 2375 +5063 2704 +5063 3900 +5063 4114 +5063 5083 +5063 5301 +5063 5475 +5063 5619 +5065 21 +5065 503 +5065 997 +5065 3296 +5065 3931 +5065 4324 +5065 4801 +5065 4826 +5065 5621 +5065 5622 +5073 363 +5073 462 +5073 518 +5073 1047 +5073 2127 +5073 2612 +5073 3083 +5073 4408 +5073 5624 +5073 5625 +5074 311 +5074 1362 +5074 1539 +5074 2087 +5074 2204 +5074 2354 +5074 2579 +5074 3205 +5074 5546 +5075 462 +5075 1454 +5075 1587 +5075 1846 +5075 1903 +5075 2511 +5075 3570 +5075 3586 +5075 5626 +5075 5627 +5077 837 +5077 2842 +5077 3743 +5077 4270 +5077 5634 +5281 7 +5281 174 +5281 390 +5281 699 +5281 753 +5281 754 +5281 762 +5281 2064 +5281 2077 +5281 3118 +5510 122 +5510 175 +5510 247 +5510 249 +5510 250 +5510 251 +5510 367 +5510 390 +5510 422 +5510 667 +5657 667 +5657 1923 +5657 2005 +5657 3083 +5657 3200 +5657 4234 +5657 4324 +5657 5016 +5657 5922 +5083 211 +5083 581 +5083 599 +5083 605 +5083 1486 +5083 1855 +5083 2500 +5083 3251 +5083 3402 +5083 3982 +5078 531 +5078 605 +5078 810 +5078 813 +5078 924 +5078 1867 +5078 1868 +5078 2677 +5078 3336 +5078 5630 +5090 122 +5090 123 +5090 129 +5090 143 +5090 147 +5090 177 +5090 367 +5090 368 +5090 390 +5090 1245 +5102 23 +5102 1022 +5102 1044 +5102 1867 +5102 3414 +5102 3488 +5102 4039 +5102 5475 +5102 5637 +5102 5638 +5361 2035 +5361 4945 +5361 5115 +5361 5352 +5361 5789 +5361 5790 +5361 5791 +5361 5792 +5361 5793 +5361 5794 +5291 5660 +5291 5661 +5291 5662 +5291 5663 +5291 5664 +5291 5665 +5291 5666 +5291 5667 +5291 5668 +5291 5669 +5928 4 +5928 127 +5928 143 +5928 146 +5928 175 +5928 264 +5928 390 +5928 427 +5928 558 +5096 145 +5096 359 +5096 427 +5096 605 +5096 881 +5096 1861 +5096 3402 +5096 3550 +5096 5635 +5096 5636 +5104 23 +5104 689 +5104 910 +5104 967 +5104 1424 +5104 2552 +5104 2787 +5104 3487 +5104 4400 +5104 5277 +5110 38 +5110 2018 +5110 2148 +5110 2666 +5110 3895 +5110 3935 +5110 4838 +5110 4855 +5110 5642 +5110 5643 +5113 893 +5113 1407 +5113 1590 +5113 1772 +5113 1862 +5113 2269 +5113 3716 +5113 4432 +5113 5291 +5113 5641 +5129 848 +5129 1150 +5129 1956 +5129 2094 +5129 3283 +5129 3781 +5129 4256 +5129 4874 +5129 5293 +5129 5644 +5131 823 +5131 1787 +5131 2288 +5131 2566 +5131 3109 +5131 3797 +5131 4248 +5131 4895 +5131 5645 +5131 5646 +5120 626 +5147 123 +5147 1321 +5147 3052 +5147 4213 +5147 4929 +5147 4998 +5147 5301 +5147 5653 +5147 5654 +5147 5655 +5135 184 +5135 613 +5135 2973 +5135 4111 +5135 5647 +5135 5648 +5135 5649 +5135 5650 +5135 5651 +5135 5652 +5149 802 +5149 2125 +5149 2499 +5149 5656 +5149 5657 +5151 219 +5151 459 +5151 612 +5151 1102 +5151 2403 +5151 3017 +5151 5510 +5151 5658 +5151 5659 +5152 380 +5152 666 +5152 1540 +5152 1751 +5152 2577 +5152 3174 +5152 3658 +5152 4578 +5152 5199 +5152 5581 +5053 116 +5053 906 +5053 1250 +5053 1541 +5053 1859 +5053 3114 +5053 3319 +5053 3726 +5053 4189 +5156 3370 +5158 4402 +5160 201 +5160 400 +5160 459 +5160 1484 +5160 2023 +5160 2492 +5160 3594 +5160 3715 +5160 3849 +5160 4487 +5670 268 +5670 522 +5670 2538 +5670 2735 +5670 4969 +5670 5149 +5670 5887 +5670 5930 +5670 5931 +5670 5932 +5167 1886 +5167 1940 +5167 1980 +5167 2569 +5167 3069 +5167 3125 +5167 4125 +5167 5672 +5167 5673 +5167 5674 +5168 229 +5168 1039 +5168 1192 +5168 1458 +5168 2127 +5168 2974 +5168 4563 +5168 5678 +5168 5679 +5168 5680 +5183 363 +5183 1706 +5183 1711 +5183 2055 +5183 2481 +5183 4436 +5183 4559 +5183 5094 +5183 5494 +5183 5688 +5187 302 +5187 1184 +5187 1946 +5187 3023 +5187 3414 +5187 3988 +5187 5065 +5187 5184 +5187 5689 +5187 5690 +5190 1056 +5191 2693 +5191 4129 +5191 4809 +5191 5051 +5191 5508 +5191 5691 +5191 5692 +5191 5693 +5191 5694 +5195 521 +5195 1070 +5195 3782 +5195 3962 +5195 3977 +5195 4031 +5195 5434 +5195 5604 +5195 5700 +5195 5701 +5196 107 +5196 326 +5196 1928 +5196 2313 +5196 3598 +5196 4082 +5196 4423 +5196 5695 +5196 5696 +5196 5697 +5197 48 +5197 968 +5197 1814 +5197 2055 +5197 2164 +5197 3112 +5197 5441 +5197 5475 +5197 5698 +5197 5699 +5202 158 +5202 202 +5202 255 +5202 532 +5202 553 +5202 573 +5202 823 +5202 883 +5202 914 +5202 923 +5202 979 +5202 1047 +5202 1213 +5202 1615 +5202 1708 +5202 1789 +5202 1805 +5202 1808 +5202 1868 +5202 1881 +5202 2015 +5202 2035 +5202 2555 +5202 2664 +5202 2693 +5202 2721 +5202 2905 +5202 3153 +5202 3288 +5202 3351 +5202 3479 +5202 3511 +5202 3740 +5202 3861 +5202 4093 +5202 4333 +5202 4453 +5202 4563 +5202 4623 +5202 4873 +5202 4912 +5202 5029 +5202 5051 +5202 5321 +5202 5629 +5202 5702 +5200 605 +5200 1714 +5200 2017 +5200 3142 +5200 3402 +5200 4176 +5200 5710 +5200 5711 +5200 5712 +5200 5713 +5201 127 +5201 129 +5201 146 +5201 176 +5201 238 +5201 264 +5201 352 +5201 717 +5201 1245 +5201 2338 +5952 714 +5952 1627 +5952 2047 +5952 2475 +5952 3232 +5952 4012 +5952 5287 +5952 5508 +5952 5815 +5952 6080 +6163 491 +6163 744 +6163 851 +6163 2202 +6163 2583 +6163 3089 +6163 3601 +6163 5826 +6163 6041 +6163 6233 +6165 255 +6165 376 +6165 777 +6165 1229 +6165 3190 +6165 3683 +6165 4757 +6165 4885 +6165 5593 +6165 5801 +5529 345 +5529 2377 +5529 3285 +5529 3334 +5529 4160 +5529 4735 +5529 4986 +5529 5168 +5529 5866 +5529 5867 +5970 86 +5970 477 +5970 586 +5970 1240 +5970 1770 +5970 4756 +5970 4844 +5970 5627 +5970 6090 +6288 77 +6288 5097 +6288 5211 +6288 6287 +6288 6296 +5206 43 +5206 169 +5206 219 +5206 246 +5206 2652 +5206 3058 +5206 3601 +5206 3925 +5206 3944 +5206 5704 +5207 544 +5207 816 +5207 1504 +5207 1764 +5207 1765 +5207 2069 +5207 4846 +5207 5499 +5207 5708 +5207 5709 +5214 1193 +5214 1926 +5214 2236 +5214 2337 +5214 2847 +5214 4018 +5214 5081 +5214 5235 +5214 5714 +5220 1168 +5220 1480 +5220 2823 +5220 4137 +5220 4740 +5220 4929 +5220 5715 +5220 5716 +5220 5717 +5220 5718 +5221 96 +5221 292 +5221 334 +5221 400 +5221 1122 +5221 1177 +5221 1377 +5221 2322 +5221 3306 +5221 5719 +5226 748 +5226 1316 +5226 1326 +5226 1487 +5226 2414 +5226 2639 +5226 2901 +5226 3192 +5226 3849 +5226 4765 +5227 480 +5227 1039 +5227 1654 +5227 3348 +5227 5138 +5227 5427 +5227 5721 +5227 5722 +5227 5723 +5227 5724 +5228 136 +5222 3301 +5245 123 +5245 127 +5245 146 +5245 147 +5245 175 +5245 247 +5245 250 +5245 369 +5245 423 +5253 976 +5253 1787 +5253 1809 +5253 2156 +5253 2309 +5253 3185 +5253 4448 +5253 4641 +5253 4793 +5254 450 +5254 2308 +5254 3488 +5254 4426 +5254 4654 +5254 4998 +5254 5474 +5254 5594 +5254 5731 +5254 5732 +5255 147 +5255 248 +5255 422 +5255 427 +5255 2001 +5255 2018 +5255 2968 +5255 3804 +5255 5636 +5255 5730 +5257 76 +5257 726 +5257 3877 +5257 3903 +5257 5734 +5259 4540 +5251 5368 +5251 5738 +5251 5739 +5251 5740 +5251 5741 +5251 5742 +5251 5743 +5251 5744 +5251 5745 +5251 5746 +5263 124 +5263 143 +5263 147 +5263 247 +5263 390 +5263 422 +5263 423 +5263 427 +5263 2001 +5250 5733 +5270 2398 +5270 3350 +5270 3385 +5270 4375 +5270 5482 +5276 235 +5276 342 +5276 1591 +5276 3205 +5276 3428 +5276 4041 +5276 4740 +5276 5321 +5276 5747 +5276 5748 +5279 1402 +5279 2035 +5279 3080 +5279 4882 +5279 5749 +5273 680 +5273 1267 +5273 2268 +5273 2465 +5273 5757 +5290 3476 +5285 3440 +5285 5296 +5285 5748 +5285 5750 +5285 5751 +5285 5752 +5285 5753 +5285 5754 +5285 5755 +5285 5756 +5292 1240 +5292 3029 +5292 4641 +5292 5159 +5292 5766 +5294 64 +5294 2633 +5294 3205 +5294 3218 +5294 4205 +5294 4939 +5294 5759 +5294 5760 +5294 5761 +5294 5762 +5296 1001 +5296 1948 +5296 4735 +5296 4788 +5296 5073 +5296 5398 +5296 5504 +5296 5763 +5296 5764 +5296 5765 +5339 124 +5339 147 +5339 175 +5339 247 +5339 250 +5339 367 +5339 368 +5339 369 +5339 559 +5339 754 +5352 149 +5352 266 +5352 1317 +5352 1414 +5352 2197 +5352 2837 +5352 3614 +5352 4427 +5352 4844 +5352 5767 +5315 63 +5315 2927 +5315 3346 +5315 4771 +5315 5161 +5315 5578 +5315 5769 +5315 5770 +5315 5771 +5315 5772 +5318 346 +5318 1861 +5318 1922 +5318 2353 +5318 2360 +5318 2456 +5318 3190 +5318 3418 +5318 5773 +5318 5774 +5321 255 +5321 1115 +5321 1845 +5321 1928 +5321 3933 +5321 4074 +5321 4129 +5321 5510 +5321 5775 +5321 5776 +5763 2583 +5763 3359 +5763 3797 +5763 3992 +5763 5118 +5763 5719 +5763 5971 +5763 5972 +5332 121 +5332 129 +5332 352 +5332 424 +5332 5731 +6249 1402 +6249 4068 +6249 4281 +6249 4311 +6249 4540 +6249 4854 +6249 6151 +6249 6268 +6249 6269 +6249 6270 +6251 554 +6251 1524 +6251 1956 +6251 2023 +6251 2777 +6251 3038 +6251 4629 +6251 6102 +6251 6262 +6251 6263 +6252 2015 +6252 3509 +6252 3991 +6252 4691 +6252 5528 +6252 6098 +6252 6264 +6252 6265 +6252 6266 +6252 6267 +5347 20 +5347 54 +5347 146 +5347 534 +5347 749 +5347 1901 +5347 2616 +5347 3292 +5347 4051 +5347 5224 +5347 5348 +5347 5462 +5347 5542 +5347 5616 +5347 5632 +5347 5783 +5347 5784 +5356 685 +5356 2002 +5356 2036 +5356 3407 +5356 3455 +5357 1516 +5357 5474 +5357 5816 +5359 4 +5359 125 +5359 175 +5359 352 +5359 368 +5359 558 +5359 717 +5359 856 +5359 1317 +5359 2338 +5366 942 +5366 1456 +5366 2230 +5366 2366 +5366 2612 +5366 2841 +5366 2982 +5366 3707 +5366 5798 +5380 1001 +5372 2594 +5373 204 +5373 1049 +5373 1685 +5373 2088 +5373 4013 +5373 4317 +5373 4659 +5373 4909 +5373 5633 +5373 5799 +5378 296 +5378 352 +5378 1358 +5378 3221 +5378 3446 +5378 3519 +5378 5432 +5378 5612 +5378 5800 +5379 2579 +5386 5 +5386 125 +5386 129 +5386 174 +5386 238 +5386 248 +5386 250 +5386 252 +5386 1084 +5389 2634 +5385 309 +5385 1120 +5385 1511 +5385 2007 +5385 2090 +5385 5074 +5385 5636 +5385 5729 +5385 5801 +5385 5802 +5406 38 +5406 740 +5406 1956 +5406 2060 +5406 2391 +5406 4170 +5406 5096 +5406 5510 +5406 5803 +5406 5804 +5410 275 +5410 605 +5410 1123 +5410 1430 +5410 1818 +5410 2721 +5410 3919 +5410 5809 +5410 5810 +5410 5811 +5436 1956 +5413 1310 +5413 1883 +5413 3621 +5413 4694 +5413 4723 +5413 4727 +5413 5542 +5413 5820 +5413 5821 +5413 5822 +5421 2146 +5423 285 +5423 582 +5423 707 +5423 1044 +5423 3202 +5423 4368 +5423 4828 +5423 5100 +5423 5442 +5423 5685 +5425 415 +5425 1158 +5425 1383 +5425 2059 +5425 2677 +5425 2869 +5425 3213 +5425 3516 +5425 4377 +5425 5616 +5432 379 +5432 418 +5432 513 +5432 882 +5432 2354 +5432 2684 +5432 4779 +5432 5344 +5432 5734 +5432 5817 +5440 196 +5440 558 +5440 1021 +5440 1088 +5440 1447 +5440 3374 +5440 4885 +5440 5245 +5440 5818 +5440 5819 +5443 898 +5443 1115 +5443 1227 +5443 3217 +5443 4128 +5443 5823 +5443 5824 +5443 5825 +5443 5826 +5457 438 +5457 908 +5457 991 +5457 3767 +5457 4486 +5457 4487 +5457 5554 +5457 5829 +5457 5830 +5458 2719 +5459 385 +5459 870 +5459 1048 +5459 1980 +5459 4793 +5459 5831 +5459 5832 +5459 5833 +5459 5834 +5464 2005 +5464 2532 +5464 2862 +5464 3564 +5464 3860 +5464 4633 +5464 5155 +5464 5425 +5464 5823 +5464 5835 +5472 866 +5472 1288 +5472 1433 +5472 3061 +5472 3796 +5472 4166 +5472 4382 +5472 4866 +5472 5211 +5472 5839 +5486 1056 +5486 1160 +5486 1199 +5486 2709 +5486 3489 +5486 3977 +5486 4332 +5486 5836 +5486 5837 +5486 5838 +5492 163 +5492 1968 +5492 2648 +5492 4844 +5492 5475 +5492 5767 +5492 5841 +5492 5842 +5492 5843 +5492 5844 +5495 183 +5495 610 +5495 1848 +5495 2044 +5495 3471 +5495 3516 +5495 4940 +5495 5118 +5495 5211 +5495 5847 +5499 3635 +5499 4128 +5499 4462 +5499 4670 +5499 5828 +5500 2059 +5498 144 +5498 145 +5498 147 +5498 148 +5498 149 +5498 175 +5498 367 +5498 390 +5498 718 +5504 505 +5504 3293 +5504 3778 +5504 4293 +5504 4458 +5504 5121 +5504 5703 +5504 5792 +5504 5854 +5504 5855 +5505 295 +5509 1405 +5509 2218 +5509 3288 +5509 4501 +5509 4854 +5509 5859 +5509 5860 +5509 5861 +5509 5862 +5523 241 +5528 2716 +5528 4483 +5528 4660 +5528 4771 +5528 4929 +5528 4970 +5528 5863 +5528 5864 +5528 5865 +5531 1945 +5531 1955 +5531 2062 +5531 2399 +5531 2617 +5531 2850 +5531 2874 +5531 5405 +5531 5902 +5531 5903 +5532 8 +5532 17 +5532 126 +5532 129 +5532 147 +5532 250 +5532 422 +5532 424 +5532 3937 +5535 2499 +5535 2670 +5535 2958 +5535 3067 +5535 3629 +5535 3674 +5535 4276 +5535 4840 +5535 5811 +5535 5835 +5543 123 +5543 146 +5543 249 +5543 264 +5543 352 +5543 369 +5543 422 +5543 423 +5543 427 +5543 2338 +5545 63 +5545 629 +5545 1034 +5545 1384 +5545 2078 +5545 2249 +5545 2386 +5545 2698 +5545 2780 +5545 3110 +5545 3517 +5545 4503 +5545 4838 +5545 6292 +5545 6293 +5545 6294 +5545 6295 +5548 4453 +5548 5012 +5548 5634 +5548 5871 +5548 5872 +5568 894 +5568 1420 +5568 1575 +5568 4368 +5568 4804 +5565 705 +5565 1029 +5565 1084 +5565 3765 +5565 3818 +5565 5874 +5565 5875 +5565 5876 +5565 5877 +5565 5878 +6049 157 +6049 500 +6049 664 +6049 1017 +6049 1715 +6049 2991 +6049 3293 +6049 6140 +6049 6141 +6049 6142 +5585 106 +5585 1949 +5585 2593 +5585 2594 +5585 2595 +5585 2892 +5585 3343 +5585 4613 +5585 5887 +5585 5888 +5578 1511 +5578 1762 +5578 2090 +5578 5580 +5578 5883 +5580 2881 +5614 4415 +5587 5300 +5589 203 +5589 697 +5589 750 +5589 913 +5589 2716 +5589 4156 +5589 4189 +5589 5407 +5589 5449 +5590 706 +5590 800 +5590 1600 +5590 1766 +5590 5885 +5597 419 +5597 1025 +5597 1728 +5597 4779 +5597 5886 +6255 757 +5602 1085 +5602 1333 +5603 1094 +5603 1495 +5603 1597 +5603 1608 +5603 1788 +5603 2689 +5603 3053 +5603 4295 +5603 4702 +5603 5895 +5613 1454 +5613 2191 +5613 3328 +5613 3574 +5613 4885 +5613 5576 +5613 5704 +5613 5784 +5613 5887 +5613 5896 +5608 65 +5608 311 +5608 612 +5608 2308 +5608 2566 +5608 3539 +5608 5004 +5608 5897 +5608 5898 +5608 5899 +5615 1082 +5615 1923 +5615 2005 +5615 2207 +5615 2726 +5615 3125 +5615 3376 +5615 4854 +5615 5900 +5615 5901 +5616 133 +5616 813 +5616 1533 +5616 2215 +5616 2391 +5616 2625 +5616 2847 +5616 3836 +5616 4484 +5618 637 +5618 969 +5618 1039 +5618 1311 +5618 1541 +5618 2444 +5618 2646 +5618 4798 +5618 5904 +5618 5905 +5623 212 +5623 531 +5623 1094 +5623 1665 +5623 2298 +5623 2468 +5623 5378 +5623 5906 +5623 5907 +5623 5908 +5619 261 +5619 391 +5619 898 +5619 1212 +5619 1866 +5619 1867 +5619 2149 +5619 2973 +5619 3982 +5619 4237 +5625 686 +5625 1863 +5625 1940 +5625 2794 +5625 3193 +5625 3205 +5625 4891 +5625 5912 +5625 5913 +5626 584 +5626 1203 +5626 1509 +5626 3253 +5626 4037 +5626 4632 +5626 5837 +5626 5909 +5626 5910 +5626 5911 +5630 290 +5630 380 +5630 3299 +5630 5914 +5630 5915 +5792 3 +5792 123 +5792 126 +5792 127 +5792 129 +5792 144 +5792 179 +5792 351 +5792 353 +5792 1317 +5793 436 +5793 551 +5793 1458 +5793 1509 +5793 2804 +5793 3233 +5793 5837 +5793 5983 +5793 5984 +5793 5985 +5794 771 +5794 1637 +5794 1940 +5794 5429 +5794 5986 +5794 5987 +5794 5988 +5794 5989 +5794 5990 +5794 5991 +5643 5918 +5644 643 +5644 877 +5644 1316 +5644 1335 +5644 1928 +5644 3027 +5644 4101 +5644 5916 +5644 5917 +5654 3 +5654 123 +5654 124 +5654 127 +5654 247 +5654 369 +5654 390 +5654 666 +5654 667 +5654 856 +5650 5921 +5651 290 +5651 2379 +5651 2898 +5651 3367 +5651 3489 +5651 5288 +5651 5887 +5651 5919 +5651 5920 +5656 442 +5680 531 +5680 678 +5680 3124 +5680 3232 +5680 3571 +5680 4006 +5680 4193 +5680 4307 +5680 5589 +5680 5936 +5691 3481 +5701 603 +5701 1552 +5701 1720 +5701 2081 +5701 2177 +5701 2933 +5701 3224 +5701 3543 +5701 3743 +5701 5406 +5695 1384 +5695 2219 +5695 5254 +5695 5975 +5708 5943 +5703 789 +5707 823 +5716 206 +5716 941 +5716 2037 +5716 2823 +5716 4639 +5716 4694 +5716 4809 +5716 5944 +5716 5945 +5716 5946 +5740 2018 +5742 381 +5742 448 +5742 1311 +5742 1850 +5742 2663 +5742 3460 +5742 3801 +5742 4365 +5742 5677 +5742 5961 +5735 1120 +5735 1375 +5735 2027 +5735 3109 +5735 3335 +5735 3930 +5735 4986 +5735 5956 +5735 5957 +5757 4570 +5750 487 +5750 491 +5750 811 +5750 862 +5750 1509 +5750 1757 +5750 2127 +5750 4287 +5750 5962 +5750 5963 +5751 5168 +5753 244 +5753 835 +5753 1321 +5753 1890 +5753 3446 +5753 4639 +5753 4881 +5753 5368 +5753 5966 +5753 5967 +5754 870 +5754 1048 +5754 2537 +5754 3563 +5754 3993 +5754 4622 +5754 5729 +5754 5920 +5754 5964 +5754 5965 +5755 3509 +5759 704 +5759 837 +5759 1137 +5759 1928 +5759 4095 +5759 5230 +5759 5931 +5759 5968 +5759 5969 +5761 1388 +5761 2176 +5761 2385 +5761 3018 +5761 3516 +5761 4776 +5761 5050 +5761 5567 +5761 5826 +5761 5970 +5542 495 +5542 1194 +5542 1261 +5542 1587 +5542 2089 +5542 2384 +5542 2541 +5542 4782 +5542 4813 +5542 4945 +5783 351 +5783 996 +5783 3249 +5783 5779 +5783 5823 +5783 5976 +5783 5977 +5783 5978 +5783 5979 +5802 4273 +5804 1538 +5804 3345 +5804 3702 +5804 4939 +5804 5988 +5804 5992 +5804 5993 +5804 5994 +5804 5995 +5804 5996 +5809 4 +5809 7 +5809 8 +5809 126 +5809 129 +5809 144 +5809 175 +5809 179 +5809 1317 +5811 222 +5811 342 +5811 2324 +5811 2445 +5811 2475 +5811 2612 +5811 4131 +5811 4597 +5811 4885 +5820 1831 +5820 2472 +5820 2627 +5820 4060 +5820 5501 +5820 5657 +5820 6002 +5820 6003 +5820 6004 +5820 6005 +5821 491 +5821 858 +5821 983 +5821 1313 +5821 1458 +5821 3388 +5821 5534 +5821 5837 +5821 6006 +5821 6007 +5827 3077 +5827 3964 +5827 4614 +5827 5323 +5827 6059 +5827 6060 +5828 122 +5828 246 +5828 264 +5819 123 +5819 143 +5819 177 +5819 179 +5819 247 +5819 264 +5819 367 +5819 369 +5819 422 +5819 1246 +5824 1592 +5824 1993 +5824 2267 +5824 2650 +5824 2672 +5824 2720 +5824 4128 +5824 5771 +5824 5958 +5824 5974 +5829 3480 +5830 529 +5830 942 +5830 2622 +5830 2797 +5830 2798 +5830 4469 +5830 5593 +5830 6023 +5830 6024 +5830 6025 +5831 8 +5831 36 +5831 57 +5831 75 +5831 102 +5831 252 +5831 311 +5831 383 +5831 582 +5831 583 +5831 611 +5831 634 +5831 654 +5831 1157 +5831 1173 +5831 1477 +5831 1872 +5831 1890 +5831 1931 +5831 2248 +5831 2746 +5831 2767 +5831 2931 +5831 2941 +5831 3115 +5831 3161 +5831 3343 +5831 3981 +5831 4115 +5831 4159 +5831 4303 +5831 5184 +5831 5528 +5831 5872 +5831 5931 +5831 5932 +5831 6012 +5831 6013 +5831 6014 +5831 6015 +5831 6016 +5831 6017 +5831 6018 +5831 6019 +5831 6020 +5831 6021 +5831 6022 +5831 6023 +5834 124 +5834 177 +5834 248 +5834 249 +5834 1245 +5882 261 +5882 337 +5882 442 +5882 1530 +5882 1952 +5882 3732 +5882 3989 +5882 5086 +5882 5261 +5882 5546 +5847 518 +5847 1240 +5847 1691 +5847 5511 +5847 6026 +5847 6027 +5847 6028 +5847 6029 +5847 6030 +5854 1087 +5854 3084 +5854 4068 +5854 5556 +5854 5626 +5854 5976 +5854 5977 +5854 5979 +5854 6031 +5854 6032 +5855 171 +5855 788 +5855 3378 +5855 3385 +5855 5523 +5855 5735 +5855 5850 +5855 6033 +5855 6034 +5855 6035 +5866 2232 +5866 3481 +6293 117 +6293 274 +6293 788 +6293 1100 +6293 2249 +6293 2635 +6293 3344 +6293 5155 +6293 5685 +6293 6300 +5887 1240 +5887 2690 +5887 3946 +5887 6042 +5887 6043 +5887 6044 +5887 6045 +5887 6046 +5887 6047 +5887 6048 +5886 285 +5886 1592 +5886 1761 +5886 2563 +5886 2646 +5886 5487 +5886 5617 +5886 5941 +5886 6023 +5886 6041 +5897 758 +5897 918 +5897 919 +5897 1865 +5897 5562 +5897 5576 +5897 6050 +5897 6051 +5897 6052 +5897 6053 +5899 17 +5899 96 +5899 3376 +5899 4024 +5899 4987 +5899 5230 +5899 5341 +5899 6056 +5899 6057 +5899 6058 +5901 664 +5901 2663 +5901 3415 +5901 3906 +5901 5407 +5901 5415 +5901 5781 +5901 6054 +5901 6055 +5905 130 +5905 570 +5905 1261 +5905 1511 +5905 1921 +5905 3722 +5905 4485 +5905 4875 +5905 4979 +5905 5723 +5907 796 +5907 1380 +5907 1892 +5907 4131 +5907 4268 +5907 5442 +5907 6063 +5907 6064 +5907 6065 +5915 1255 +5915 1677 +5915 2161 +5915 2612 +5915 2622 +5915 3194 +5915 3954 +5915 4754 +5915 6066 +5915 6067 +5921 1064 +5921 2450 +5921 2552 +5921 3698 +5921 4109 +5921 4507 +5921 4793 +5921 5788 +5921 6068 +5921 6069 +5932 552 +5936 31 +5936 485 +5936 1127 +5936 2424 +5936 3214 +5936 3771 +5936 4016 +5936 4128 +5936 4526 +5936 5378 +5944 969 +5944 2090 +5944 3488 +5944 3903 +5944 5536 +5944 5607 +5944 6001 +5944 6005 +5944 6076 +5944 6077 +5950 9 +5950 147 +5950 149 +5950 238 +5950 252 +5950 266 +5950 426 +5950 666 +5950 717 +5950 2018 +5951 870 +5951 2348 +5951 3165 +5951 3550 +5951 3733 +5951 4093 +5951 5129 +5951 5644 +5951 6078 +5951 6079 +5961 1460 +5961 2881 +5961 2933 +5961 6108 +5956 503 +5956 2154 +5956 2373 +5956 2378 +5956 2385 +5956 4944 +5956 5429 +5956 6081 +5956 6082 +5956 6083 +5957 86 +5957 1246 +5957 2008 +5957 4353 +5957 4368 +5957 5504 +5957 5715 +5957 6084 +5957 6085 +5957 6086 +5962 249 +5962 266 +5962 367 +5962 422 +5962 559 +5962 695 +5962 736 +5962 754 +5962 3677 +5965 179 +5965 1335 +5965 2361 +5965 2487 +5965 3388 +5965 5514 +5965 5626 +5965 5989 +5965 6088 +5965 6089 +5971 6091 +5976 337 +5976 1541 +5976 1952 +5976 2417 +5976 3385 +5976 3732 +5976 4668 +5976 5086 +5976 5688 +5976 6092 +5977 243 +5977 424 +5977 1893 +5977 2448 +5977 3171 +5977 3344 +5977 3756 +5977 4213 +5977 6007 +5977 6093 +5987 529 +5987 981 +5987 2776 +5987 3140 +5987 4225 +5987 6100 +5987 6101 +5987 6102 +5987 6103 +5987 6104 +5988 5 +5988 9 +5988 126 +5988 175 +5988 180 +5988 252 +5988 266 +5988 368 +5988 3677 +5990 547 +5990 996 +5990 1451 +5990 1888 +5990 3039 +5990 5628 +5990 5913 +5990 6109 +5990 6110 +5990 6111 +5994 38 +5994 132 +5994 747 +5994 1130 +5994 2556 +5994 3460 +5994 5879 +5994 6105 +5994 6106 +5994 6107 +5995 122 +6004 583 +6004 1058 +6004 5292 +6004 5940 +6004 6112 +6004 6113 +6004 6114 +6004 6115 +6004 6116 +6006 230 +6006 1458 +6006 2649 +6006 3389 +6006 3794 +6006 6117 +6006 6118 +6006 6119 +6006 6120 +6059 683 +6060 174 +6060 179 +6060 251 +6060 351 +6060 983 +6023 78 +6023 350 +6023 1168 +6023 4303 +6023 4423 +6023 5350 +6023 6134 +6023 6135 +6023 6136 +6012 2023 +6012 2024 +6012 3988 +6012 4058 +6012 5469 +6012 5498 +6012 6123 +6012 6124 +6012 6125 +6012 6126 +6015 235 +6015 1402 +6015 1846 +6015 1860 +6015 2086 +6015 2325 +6015 3486 +6015 3820 +6015 4754 +6015 6127 +6016 1042 +6016 1203 +6016 1255 +6016 1430 +6016 2492 +6016 3630 +6016 6041 +6016 6128 +6016 6129 +6016 6130 +6018 443 +6031 4966 +5537 477 +5537 1194 +5537 1365 +5537 2345 +5537 2955 +5537 5538 +5537 5539 +5537 5540 +5537 5541 +5537 5542 +5538 162 +5538 223 +5538 477 +5538 2345 +5538 3081 +5538 3989 +5538 5058 +5538 5868 +5538 5869 +5538 5870 +5539 125 +6045 5338 +6046 73 +6046 177 +6046 1974 +6046 3022 +6046 3088 +6046 4465 +6046 4511 +6046 4580 +6046 5962 +6046 6139 +6047 5754 +6050 307 +6050 1173 +6050 2220 +6050 6143 +6050 6144 +6050 6145 +6050 6146 +6050 6147 +6050 6148 +6050 6149 +6057 3218 +6063 255 +6063 275 +6063 456 +6063 527 +6063 1375 +6063 2126 +6063 5216 +6063 5288 +6063 5406 +6063 5556 +6066 86 +6066 1246 +6066 2008 +6066 3138 +6066 3515 +6066 6071 +6066 6086 +6066 6154 +6066 6155 +6066 6156 +6067 17 +6067 123 +6067 175 +6067 249 +6067 390 +6067 423 +6067 695 +6067 697 +6067 856 +6070 1087 +6070 1512 +6070 2857 +6070 3593 +6070 3841 +6070 3948 +6070 4159 +6070 4844 +6070 5373 +6070 5436 +6069 158 +6069 490 +6069 650 +6069 1522 +6069 3205 +6069 5133 +6069 5469 +6069 6167 +6069 6168 +6077 9 +6077 125 +6077 148 +6077 174 +6077 179 +6077 352 +6077 353 +6077 424 +6077 736 +6077 753 +6078 14 +6078 36 +6078 1100 +6078 1291 +6078 1824 +6078 1859 +6078 2275 +6078 3035 +6078 4813 +6078 6169 +6079 458 +6079 944 +6079 983 +6079 3981 +6079 5016 +6079 5115 +6079 5790 +6079 5802 +6079 6170 +6081 129 +6081 219 +6081 864 +6081 1812 +6081 2079 +6081 4107 +6081 4319 +6081 6046 +6088 220 +6088 2181 +6088 2773 +6088 3858 +6088 3989 +6088 5815 +6088 6027 +6088 6099 +6088 6171 +6089 6237 +6092 4 +6092 8 +6092 126 +6092 129 +6092 144 +6092 179 +6092 1317 +6092 3022 +6092 5911 +6093 253 +6093 2292 +6093 2445 +6093 3963 +6093 4872 +6093 5269 +6093 6166 +6093 6172 +6093 6173 +6096 5254 +6094 1006 +6094 1323 +6094 1333 +6094 2026 +6094 4254 +6094 4297 +6094 6095 +6094 6174 +6094 6175 +6094 6176 +6095 380 +6095 2295 +6095 3021 +6095 3675 +6095 3804 +6095 4363 +6095 5449 +6095 5603 +6095 6177 +6095 6178 +6099 106 +6099 1637 +6099 1915 +6099 2015 +6099 4893 +6099 5714 +6099 5901 +6099 6166 +6099 6179 +6099 6180 +6102 570 +6102 1537 +6102 1838 +6102 1882 +6102 4227 +6102 5508 +6102 6096 +6102 6280 +6102 6281 +6110 1084 +6110 2117 +6110 2276 +6110 3252 +6110 3257 +6110 3531 +6110 5557 +6110 5600 +6110 6195 +6110 6196 +6111 554 +6111 839 +6111 967 +6111 1267 +6111 3227 +6111 3327 +6111 3481 +6111 4914 +6111 5601 +6105 6179 +6114 424 +6114 858 +6114 1629 +6114 5962 +6114 6189 +6114 6190 +6114 6191 +6114 6192 +6114 6193 +6114 6194 +6134 3960 +6123 523 +6123 524 +6123 1038 +6123 2046 +6123 2821 +6123 3331 +6123 4301 +6123 4383 +6123 5765 +6123 5844 +6124 311 +6124 510 +6124 962 +6124 2136 +6124 2151 +6124 4885 +6124 4915 +6124 4978 +6124 6176 +6124 6183 +6125 1377 +6125 3125 +6125 3264 +6125 3981 +6125 5535 +6125 6184 +6125 6185 +6125 6186 +6125 6187 +6125 6188 +6139 187 +6139 257 +6139 301 +6139 558 +6139 1017 +6139 1052 +6139 1797 +6139 3837 +6139 5765 +6139 6197 +6139 6198 +6139 6199 +6139 6200 +6139 6201 +6139 6202 +6139 6203 +6139 6204 +6139 6205 +6139 6206 +6139 6207 +6139 6208 +6139 6209 +6139 6210 +6139 6211 +6139 6212 +6139 6213 +6139 6214 +6139 6215 +6139 6216 +6139 6217 +6139 6218 +6139 6219 +6139 6220 +6139 6221 +6139 6222 +6139 6223 +6139 6224 +6139 6225 +6139 6226 +6139 6227 +6139 6228 +6141 213 +6141 1762 +6141 2179 +6141 2234 +6141 2272 +6141 2449 +6141 2797 +6141 3557 +6141 4815 +6141 6229 +6155 2394 +6155 2487 +6155 3768 +6155 4080 +6155 4503 +6155 4883 +6155 5086 +6155 6230 +6155 6231 +6169 83 +6169 969 +6169 1679 +6169 3190 +6169 3304 +6169 4654 +6169 4762 +6169 6065 +6169 6234 +6169 6235 +6170 717 +6170 803 +6170 1401 +6170 2621 +6170 3076 +6170 3477 +6170 3485 +6170 6238 +6170 6239 +6170 6240 +6171 311 +6171 809 +6171 1022 +6171 1694 +6171 3403 +6171 3677 +6171 4014 +6171 4518 +6171 5988 +6171 6236 +6174 5 +6174 7 +6174 8 +6174 121 +6174 149 +6174 247 +6174 353 +6174 424 +6174 754 +6174 1317 +6175 4 +6175 125 +6175 148 +6175 559 +6175 697 +6175 754 +6175 856 +6175 1317 +6175 5710 +6180 129 +6180 1351 +6180 2068 +6180 2360 +6180 3886 +6180 4009 +6180 5729 +6180 6243 +6180 6244 +6180 6245 +6196 124 +6196 1396 +6196 1845 +6196 1971 +6196 2235 +6196 5110 +6196 5204 +6196 5263 +6196 6247 +6196 6248 +6191 2237 +6193 1287 +6193 2403 +6193 2868 +6193 3448 +6193 3728 +6193 5101 +6193 5615 +6193 5975 +6193 6246 +6194 4934 +6194 5049 +6194 5850 +6194 6289 +6186 57 +6186 440 +6186 1221 +6186 1618 +6186 2823 +6186 4076 +6186 5261 +6186 5824 +6186 5988 +6186 6091 +6187 4170 +6229 983 +6229 1602 +6229 1719 +6229 2693 +6229 3798 +6229 4169 +6229 4235 +6229 6186 +6229 6253 +6229 6254 +6269 76 +6269 760 +6269 1611 +6269 1862 +6269 2416 +6269 3767 +6269 6282 +6269 6283 +6262 898 +6262 3501 +6262 3629 +6262 3846 +6262 3968 +6262 4141 +6262 4397 +6262 5369 +6262 5779 +6264 31 +6264 165 +6264 174 +6264 250 +6264 353 +6264 697 +6264 1379 +6264 3056 +6264 5615 +6264 5617 +6266 169 +6266 892 +6266 2378 +6266 2789 +6266 5633 +6266 5923 +6266 6039 +6266 6237 +6266 6274 +6266 6275 +6234 5552 +6239 2397 +6239 2854 +6239 5369 +6239 5475 +6239 5960 +6239 6118 +6239 6258 +6239 6259 +6239 6260 +6239 6261 +6243 3243 +6244 3270 +6244 3808 +6245 187 +6245 367 +6245 469 +6245 474 +6245 3227 +6245 4196 +6245 4503 +6245 4985 +6245 5788 +6245 5988 +6258 1531 +6258 1882 +6258 2500 +6258 2693 +6258 5253 +6258 5514 +6258 5529 +6258 6271 +6258 6272 +6258 6273 +6273 1437 +6273 2413 +6273 2984 +6273 3733 +6273 3981 +6273 5911 +6273 6276 +6273 6277 +6273 6278 +6282 3992 +6282 6291 +6276 810 +6276 3488 +6276 3632 +6276 4926 +6276 5395 +6276 5545 +6276 5627 +6276 5710 +6276 6159 +6276 6172 +6277 1798 +6277 5040 +6277 5791 +6277 5911 +6277 6290 +6296 798 +6296 849 +6296 1325 +6296 2058 +6296 5076 +6296 5236 +6296 6297 +6296 6298 +6296 6299 diff --git a/snap-python/source/examples/stackoverflow/doJoin.py b/snap-python/source/examples/stackoverflow/doJoin.py new file mode 100644 index 0000000000000000000000000000000000000000..decac94cbeed3441fbf314e7af2b9204110394da --- /dev/null +++ b/snap-python/source/examples/stackoverflow/doJoin.py @@ -0,0 +1,74 @@ +# +# join two files on a common value +# +# First, read values from a column in the first file. Next, read +# the second file and and print out lines where a column value +# matches a value from the first file. +# + +import os +import snap +import sys + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print "Usage: %s " % (sys.argv[0]) + sys.exit(1) + + fname1 = sys.argv[1] + fname2 = sys.argv[2] + col1 = int(sys.argv[3]) - 1 + col2 = int(sys.argv[4]) - 1 + + + # read the first file and create the hash table + f1 = open(fname1) + h = snap.TStrStrH() + + for line in f1: + cline = line.split("\n")[0] + #print str(cline) + + words = cline.split("\t") + #print len(words), str(words) + + # skip lines with not enough columns + if len(words) <= col1: + continue + + key = words[col1] + h[key] = cline + + f1.close() + + #print len(h) + + # read the second file and print out matching lines + f2 = open(fname2) + + for line in f2: + cline = line.split("\n")[0] + #print str(cline) + + words = cline.split("\t") + #print len(words), str(words) + + # skip lines with not enough columns + if len(words) <= col2: + continue + + key = words[col2] + #print key, cline + + if not h.IsKey(key): + continue + + line = [] + line.append(cline) + line.append(h[key]) + + print "\t".join(line) + + f2.close() + diff --git a/snap-python/source/examples/stackoverflow/getAnswers.py b/snap-python/source/examples/stackoverflow/getAnswers.py new file mode 100644 index 0000000000000000000000000000000000000000..0a7402e6039edc5636182dccd08ed1adea157adc --- /dev/null +++ b/snap-python/source/examples/stackoverflow/getAnswers.py @@ -0,0 +1,62 @@ + +# +# parse a StackOverflow posts file and print out answers in a TSV format, +# one answer per line. +# Output fields: +# post id +# owner +# + +import sys +import xml.sax + +answerId = "2" + +class StackContentHandler(xml.sax.ContentHandler): + + def __init__(self): + xml.sax.ContentHandler.__init__(self) + + def startElement(self, name, attrs): + ''' + finds posts that are answers, then prints id and owner + ''' + + # only 'row' elements are relevant, skip elements that are not rows + if name != "row": + return + + # get post type + ptype = "__none__" + if attrs.has_key("PostTypeId"): + ptype = attrs.getValue("PostTypeId") + + # only answers are relevant, skip elements with PostTypeId != answerId + if ptype != answerId: + return + + # extract post id and owner + id = "__none__" + if attrs.has_key("Id"): + id = attrs.getValue("Id") + owner = "__none__" + if attrs.has_key("OwnerUserId"): + owner = attrs.getValue("OwnerUserId") + + line = [] + line.append(id) + line.append(owner) + print "\t".join(line) + +if __name__ == '__main__': + + if len(sys.argv) < 2: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + fname = sys.argv[1] + #print fname + + f = open(fname) + xml.sax.parse(f, StackContentHandler()) + diff --git a/snap-python/source/examples/stackoverflow/getQuestions.py b/snap-python/source/examples/stackoverflow/getQuestions.py new file mode 100644 index 0000000000000000000000000000000000000000..7a8b4340bd0ed340913e380fb334e05dab1c6eaa --- /dev/null +++ b/snap-python/source/examples/stackoverflow/getQuestions.py @@ -0,0 +1,67 @@ + +# +# parse a StackOverflow posts file and print out questions in a TSV format, +# one question per line. +# Output fields: +# post id +# owner +# accepted answer +# + +import sys +import xml.sax + +questionId = "1" + +class StackContentHandler(xml.sax.ContentHandler): + + def __init__(self): + xml.sax.ContentHandler.__init__(self) + + def startElement(self, name, attrs): + ''' + finds posts that are questions, then prints id, owner and accepted answer + ''' + + # only 'row' elements are relevant, skip elements that are not rows + if name != "row": + return + + # get post type + ptype = "__none__" + if attrs.has_key("PostTypeId"): + ptype = attrs.getValue("PostTypeId") + + # only questions are relevant, skip elements with PostTypeId != questionId + if ptype != questionId: + return + + # extract post id, owner, and accepted answer + id = "__none__" + if attrs.has_key("Id"): + id = attrs.getValue("Id") + owner = "__none__" + if attrs.has_key("OwnerUserId"): + owner = attrs.getValue("OwnerUserId") + accepted = "__none__" + if attrs.has_key("AcceptedAnswerId"): + accepted = attrs.getValue("AcceptedAnswerId") + + line = [] + line.append(id) + line.append(owner) + line.append(accepted) + print "\t".join(line) + +if __name__ == '__main__': + + if len(sys.argv) < 2: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + fname = sys.argv[1] + #print fname + + f = open(fname) + xml.sax.parse(f, StackContentHandler()) + diff --git a/snap-python/source/examples/stackoverflow/getStats.py b/snap-python/source/examples/stackoverflow/getStats.py new file mode 100644 index 0000000000000000000000000000000000000000..50994fb1c816ad30593e6a6ef6b2ac889b610e13 --- /dev/null +++ b/snap-python/source/examples/stackoverflow/getStats.py @@ -0,0 +1,67 @@ +# +# build a graph and calculate various graph properties + +import os +import snap +import sys + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print "Usage: %s " % (sys.argv[0]) + sys.exit(1) + + fname = sys.argv[1] + col1 = int(sys.argv[2]) - 1 + col2 = int(sys.argv[3]) - 1 + + G = snap.LoadEdgeList(snap.PNGraph, fname, col1, col2) + print "\ngraph nodes %d, edges %d" % (G.GetNodes(), G.GetEdges()) + + WccV = snap.TIntPrV() + snap.GetWccSzCnt(G, WccV) + + print "\n# of connected component sizes", WccV.Len() + for comp in WccV: + print "size %d, number of components %d" % (comp.GetVal1(), comp.GetVal2()) + + MxWcc = snap.GetMxWcc(G) + print "\nmax wcc nodes %d, edges %d" % (MxWcc.GetNodes(), MxWcc.GetEdges()) + + InDegCntV = snap.TIntPrV() + snap.GetInDegCnt(G, InDegCntV) + + print "\n# of different in-degrees", InDegCntV.Len() + for item in InDegCntV: + print "in-degree %d, number of nodes %d" % (item.GetVal1(), item.GetVal2()) + + OutDegCntV = snap.TIntPrV() + snap.GetOutDegCnt(G, OutDegCntV) + + print "\n# of different out-degrees", OutDegCntV.Len() + for item in OutDegCntV: + print "out-degree %d, number of nodes %d" % (item.GetVal1(), item.GetVal2()) + + PRankH = snap.TIntFltH() + snap.GetPageRank(G, PRankH) + #for item in PRankH: + # print item, PRankH[item] + + slist = sorted(PRankH, key = lambda key: PRankH[key], reverse = True) + print "\ntop 10 experts by PageRank" + for item in slist[:10]: + print "id %7s, pagerank %.6f" % (item, PRankH[item]) + + NIdHubH = snap.TIntFltH() + NIdAuthH = snap.TIntFltH() + snap.GetHits(G, NIdHubH, NIdAuthH) + slist = sorted(NIdAuthH, key = lambda key: NIdAuthH[key], reverse = True) + print "\ntop 10 experts by Hits" + for item in slist[:10]: + print "id %7s, authority rank %.6f" % (item, NIdAuthH[item]) + + slist = sorted(NIdHubH, key = lambda key: NIdHubH[key], reverse = True) + print "\ntop 10 learners by Hits" + for item in slist[:10]: + print "id %7s, hub rank %.6f" % (item, NIdHubH[item]) + diff --git a/snap-python/source/examples/stackoverflow/getTag.py b/snap-python/source/examples/stackoverflow/getTag.py new file mode 100644 index 0000000000000000000000000000000000000000..7d6ebefd5a450517fff8db1b44515a98468f054a --- /dev/null +++ b/snap-python/source/examples/stackoverflow/getTag.py @@ -0,0 +1,69 @@ + +# +# parse a StackOverflow posts file and print out answers in a TSV format, +# one answer per line. +# Output fields: +# post id +# owner +# + +import sys +import xml.sax + +questionId = "1" + +class StackContentHandler(xml.sax.ContentHandler): + + def __init__(self, tag): + xml.sax.ContentHandler.__init__(self) + self.tag = "<" + tag + ">" + + def startElement(self, name, attrs): + ''' + finds posts that are answers, then prints id and owner + ''' + + # only 'row' elements are relevant, skip elements that are not rows + if name != "row": + return + + # get post type + ptype = "__none__" + if attrs.has_key("PostTypeId"): + ptype = attrs.getValue("PostTypeId") + + # only answers are relevant, skip elements with PostTypeId != answerId + if ptype != questionId: + return + + # extract post id and tags + id = "__none__" + if attrs.has_key("Id"): + id = attrs.getValue("Id") + tags = "__none__" + if attrs.has_key("Tags"): + tags = attrs.getValue("Tags") + + #print "__tags__", tags + + # skip posts without a matching tag + if not self.tag in tags: + return + + line = [] + line.append(id) + print "\t".join(line) + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + fname = sys.argv[1] + tag = sys.argv[2] + #print fname + + f = open(fname) + xml.sax.parse(f, StackContentHandler(tag)) + diff --git a/snap-python/source/examples/stackoverflow/stack.bat b/snap-python/source/examples/stackoverflow/stack.bat new file mode 100644 index 0000000000000000000000000000000000000000..3cbace4af6a48d583ad6e4ac689beb611dce4bfb --- /dev/null +++ b/snap-python/source/examples/stackoverflow/stack.bat @@ -0,0 +1,38 @@ +REM +REM the script takes a file with StackOverflow posts, +REM builds a graph of users posting questions and answers, and +REM calculates some basic graph statistics +REM +REM requirements: +REM python installed +REM Snap.py installed, http://snap.stanford.edu +REM Posts.xml, https://archive.org/download/stackexchange/stackoverflow.com-Posts.7z, uncompress + +echo ... "START analysis of StackOverflow" + +REM get all the question posts and accepted answers (15min) +echo ... "extracting questions ..." +python getQuestions.py Posts.xml > questions.txt + +REM get all the answer posts (15min) +echo ... "extracting answers ..." +python getAnswers.py Posts.xml > answers.txt + +REM get all the Java question posts, id only (15min) +echo ... "identifying Java questions ..." +python getTag.py Posts.xml java > java.txt + +REM select questions with a Java tag (20s) +echo ... "selecting Java questions ..." +python doJoin.py java.txt questions.txt 1 1 > java-posts.txt + +REM identify users of accepted answers (40s) +echo ... "finding owners of accepted answers ..." +python doJoin.py answers.txt java-posts.txt 1 3 > qa.txt + +REM create a graph and find top users (5s) +echo ... "building a QA graph and calculating statistics ..." +python getStats.py qa.txt 2 6 + +echo ... "END analysis of StackOverflow" + diff --git a/snap-python/source/examples/stackoverflow/stackoverflow.sh b/snap-python/source/examples/stackoverflow/stackoverflow.sh new file mode 100644 index 0000000000000000000000000000000000000000..d4ee7c5a9abbccbdc7559cc6239b2e4f48158ae3 --- /dev/null +++ b/snap-python/source/examples/stackoverflow/stackoverflow.sh @@ -0,0 +1,38 @@ +# +# the script takes a file with StackOverflow posts, +# builds a graph of users posting questions and answers, and +# calculates some basic graph statistics +# +# requirements: +# python installed +# Snap.py installed, http://snap.stanford.edu +# Posts.xml, https://archive.org/download/stackexchange/stackoverflow.com-Posts.7z, uncompress + +echo `date` ... "START analysis of StackOverflow" + +# get all the question posts and accepted answers (15min) +echo `date` ... "extracting questions ..." +python getQuestions.py Posts.xml > questions.txt + +# get all the answer posts (15min) +echo `date` ... "extracting answers ..." +python getAnswers.py Posts.xml > answers.txt + +# get all the Java question posts, id only (15min) +echo `date` ... "identifying Java questions ..." +python getTag.py Posts.xml java > java.txt + +# select questions with a Java tag (20s) +echo `date` ... "selecting Java questions ..." +python doJoin.py java.txt questions.txt 1 1 > java-posts.txt + +# identify users of accepted answers (40s) +echo `date` ... "finding owners of accepted answers ..." +python doJoin.py answers.txt java-posts.txt 1 3 > qa.txt + +# create a graph and find top users (5s) +echo `date` ... "building a QA graph and calculating statistics ..." +python getStats.py qa.txt 2 6 + +echo `date` ... "END analysis of StackOverflow" + diff --git a/snap-python/source/examples/tneanet.py b/snap-python/source/examples/tneanet.py new file mode 100644 index 0000000000000000000000000000000000000000..b84645d2b96f87f55ed8a380e8436de4bd2cee84 --- /dev/null +++ b/snap-python/source/examples/tneanet.py @@ -0,0 +1,334 @@ +import random +import sys +sys.path.append("../swig") +from snap import * + +def PrintGStats(s, Graph): + ''' + Print graph statistics + ''' + + print "graph %s, nodes %d, edges %d, empty %s" % ( + s, Graph.GetNodes(), Graph.GetEdges(), + "yes" if Graph.Empty() else "no") + +def DefaultConstructor(): + ''' + Test the default constructor + ''' + + Graph = TNEANet() + PrintGStats("DefaultConstructor:Graph", Graph) + +def ManipulateNodesEdges(): + ''' + Test node, edge creation + ''' + + NNodes = 10000 + NEdges = 100000 + FName = "test.graph" + + Graph = TNEANet() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1", Graph) + + # get all the nodes + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + # get all the edges for all the nodes + ECount1 = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + ECount1 += NI.GetOutDeg() + NI.Next() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0 + EI = Graph.BegEI() + while EI < Graph.EndEI(): + ECount2 += 1 + EI.Next() + + print "graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d"\ + % (NCount, ECount1, ECount2) + + # assignment + Graph1 = Graph + PrintGStats("ManipulateNodesEdges:Graph3", Graph1) + + # save the graph + print "graph type = ", type(Graph) + FOut = TFOut(TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + FIn = TFIn(TStr(FName)) + Graph2 = TNEANet(FIn) + PrintGStats("ManipulateNodesEdges:Graph4" , Graph2) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5" , Graph) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6" , Graph1) + +def ManipulateNodeEdgeAttributes(): + ''' + Test node attribute functionality + ''' + + NNodes = 1000 + NEdges = 1000 + + Graph = TNEANet() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + print "Added nodes" + + # create attributes and fill all nodes + attr1 = TStr("str") + attr2 = TStr("int") + attr3 = TStr("float") + attr4 = TStr("default") + + # Test verticaliterator for node 3, 50, 700, 900 + # Check if we can set defaults to 0 fordata. + Graph.AddIntAttrN(attr2, 0) + Graph.AddIntAttrDatN(3, 3*2, attr2) + Graph.AddIntAttrDatN(50, 50*2, attr2) + Graph.AddIntAttrDatN(700, 700*2, attr2) + Graph.AddIntAttrDatN(900, 900*2, attr2) + + print "Added attributes" + + NodeId = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + if NI.GetDat() != 0: + print "Attribute: %s, Node: %i, Val: %d" % (attr2(), NodeId, NI.GetDat()) + NodeId += 1 + NI.Next() + + # Test vertical flt iterator for node 3, 50, 700, 900 + Graph.AddFltAttrDatN(5, 3.41, attr3) + Graph.AddFltAttrDatN(50, 2.718, attr3) + Graph.AddFltAttrDatN(300, 150.0, attr3) + + Graph.AddFltAttrDatN(653, 653, attr3) + NodeId = 0 + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + NI = Graph.BegNAFltI(attr3) + NodeId = 0 + while NI < Graph.EndNAFltI(attr3): + if NI.GetDat() != TFlt.Mn: + print "Attribute: %s, Node: %i, Val: %f" % (attr3(), NodeId, NI.GetDat()) + NodeId += 1 + NI.Next() + + # Test vertical str iterator for node 3, 50, 700, 900 + Graph.AddStrAttrDatN(10, TStr("abc"), attr1) + Graph.AddStrAttrDatN(20, TStr("def"), attr1) + Graph.AddStrAttrDatN(400, TStr("ghi"), attr1) + # this does not show since ""=null + Graph.AddStrAttrDatN(455, TStr(""), attr1) + NodeId = 0 + + NI = Graph.BegNAStrI(attr1) + NodeId = 0 + while NI < Graph.EndNAStrI(attr1): + if NI.GetDat() != TStr.GetNullStr(): + print "Attribute: %s, Node: %i, Val: %s" % (attr1(), NodeId, NI.GetDat()) + NodeId += 1 + NI.Next() + + # Test vertical iterator over many types (must skip default/deleted attr) + NId = 55 + Graph.AddStrAttrDatN(NId, TStr("aaa"), attr1) + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.AddFltAttrDatN(NId, 3.41, attr3) + Graph.AddStrAttrDatN(80, TStr("dont appear"), attr4) # should not show up + NIdAttrName = TStrV() + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Node: %i, Attr: %s" % (NId, NIdAttrName.GetI(i)()) + + Graph.DelAttrDatN(NId, attr2) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Node (no int) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)()) + + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.DelAttrN(attr1) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Node (no str) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)()) + + NIdAttrValue = TStrV() + Graph.AttrValueNI(NId, NIdAttrValue) + AttrLen = NIdAttrValue.Len() + for i in range(AttrLen): + print "Vertical Node (no str) : %i, Attr_Val: %s" % (NId, NIdAttrName.GetI(i)()) + + for i in range(NNodes): + Graph.AddIntAttrDatN(i, 70, attr2) + + total = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + total += NI.GetDat() + NI.Next() + + print "Average: %i (should be 70)" % (total/NNodes) + + # Test verticaliterator for edge + Graph.AddIntAttrDatE(3, 3*2, attr2) + Graph.AddIntAttrDatE(55, 55*2, attr2) + Graph.AddIntAttrDatE(705, 705*2, attr2) + Graph.AddIntAttrDatE(905, 905*2, attr2) + EdgeId = 0 + EI = Graph.BegEAIntI(attr2) + while EI < Graph.EndEAIntI(attr2): + if EI.GetDat() != TInt.Mn: + print "E Attribute: %s, Edge: %i, Val: %i"\ + % (attr2(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test vertical flt iterator for edge + Graph.AddFltAttrE(attr3, 0.00) + Graph.AddFltAttrDatE(5, 4.41, attr3) + Graph.AddFltAttrDatE(50, 3.718, attr3) + Graph.AddFltAttrDatE(300, 151.0, attr3) + Graph.AddFltAttrDatE(653, 654, attr3) + EdgeId = 0 + EI = Graph.BegEAFltI(attr3) + while EI < Graph.EndEAFltI(attr3): + # Check if defaults are set to 0. + if EI.GetDat() != 0: + print "E Attribute: %s, Edge: %i, Val: %f" % \ + (attr3(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test vertical str iterator for edge + Graph.AddStrAttrDatE(10, TStr("abc"), attr1) + Graph.AddStrAttrDatE(20, TStr("def"), attr1) + Graph.AddStrAttrDatE(400, TStr("ghi"), attr1) + # this does not show since ""=null + Graph.AddStrAttrDatE(455, TStr(""), attr1) + EdgeId = 0 + EI = Graph.BegEAStrI(attr1) + while EI < Graph.EndEAStrI(attr1): + if EI.GetDat() != TStr.GetNullStr(): + print "E Attribute: %s, Edge: %i, Val: %s" %\ + (attr1(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test vertical iterator over many types (must skip default/deleted attr) + EId = 55 + Graph.AddStrAttrDatE(EId, TStr("aaa"), attr1) + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.AddFltAttrDatE(EId, 3.41, attr3) + Graph.AddStrAttrDatE(80, TStr("dont appear"), attr4) # should not show up + EIdAttrName = TStrV() +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Edge: %i, Attr: %s" % (EId, EIdAttrName.GetI(i)) + + Graph.DelAttrDatE(EId, attr2) +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Edge (no int) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i)) + + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.DelAttrE(attr1) +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print "Vertical Edge (no str) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i)()) + + EIdAttrValue = TStrV() + Graph.AttrValueEI(TInt(EId), EIdAttrValue) + AttrLen = EIdAttrValue.Len() + for i in range(AttrLen): + print "Vertical Edge (no str) : %i, Attr_Val: %s" % (EId, EIdAttrValue.GetI(i)()) + + for i in range(NEdges): + Graph.AddIntAttrDatE(i, 70, attr2) + + total = 0 + EI = Graph.BegNAIntI(attr2) + while EI < Graph.EndNAIntI(attr2): + total += EI.GetDat() + EI.Next() + + print "Average: %i (should be 70)" % (total/NEdges) + + Graph.Clr() + +if __name__ == '__main__': + print "----- DefaultConstructor -----" + DefaultConstructor() + print "----- ManipulateNodesEdges -----" + ManipulateNodesEdges() + print "----- ManipulateNodesEdgesAttributes -----" + ManipulateNodeEdgeAttributes() + diff --git a/snap-python/source/hellotest/hellotest.c b/snap-python/source/hellotest/hellotest.c new file mode 100644 index 0000000000000000000000000000000000000000..28c762bec540558d8b619b93f5223c26a80b74c6 --- /dev/null +++ b/snap-python/source/hellotest/hellotest.c @@ -0,0 +1,40 @@ +#include + +#if PY_MAJOR_VERSION >= 3 +#define PY3VER +#endif + +static PyObject* hello(PyObject* self, PyObject* args) { + printf("Hello World\n"); + return Py_None; +} + +static PyMethodDef helloMethods[] = { + { "helloworld", hello, METH_NOARGS, "Prints Hello World" }, + { NULL, NULL, 0, NULL } +}; + +#ifdef PY3VER + +static struct PyModuleDef hellotest = { + PyModuleDef_HEAD_INIT, + "hellotest", + "Hello Test Module", + -1, + helloMethods +}; + +PyMODINIT_FUNC PyInit_hellotest(void) { + return PyModule_Create(&hellotest); +} + +#else + +// module initializer for python2 +PyMODINIT_FUNC inithellotest() { + Py_InitModule3("hellotest", helloMethods, "Hello Test Module"); +} + +#endif + + diff --git a/snap-python/source/hellotest/setup.py b/snap-python/source/hellotest/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..0753281f79c7e46a2af18d1e499ffbe4bea2ec2f --- /dev/null +++ b/snap-python/source/hellotest/setup.py @@ -0,0 +1,4 @@ +from distutils.core import setup, Extension +setup(name='hellotest', version='1.0', \ + ext_modules=[Extension('hellotest', ['hellotest.c'])]) + diff --git a/snap-python/source/scripts/build-package27-win.bat b/snap-python/source/scripts/build-package27-win.bat new file mode 100644 index 0000000000000000000000000000000000000000..06bcc30b80176621e1d54fff11f39daff0aabbb4 --- /dev/null +++ b/snap-python/source/scripts/build-package27-win.bat @@ -0,0 +1,35 @@ +set CommonProgramFiles=C:\Program Files\Common Files +set CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files +set CommonProgramW6432=C:\Program Files\Common Files +set PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC +set PROCESSOR_ARCHITECTURE=AMD64 +set PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 10, GenuineIntel +set PROCESSOR_LEVEL=6 +set PROCESSOR_REVISION=9e0a +set ProgramData=C:\ProgramData +set ProgramFiles=C:\Program Files +set ProgramFiles(x86)=C:\Program Files (x86) +set ProgramW6432=C:\Program Files +set SystemRoot=C:\Windows +set TEMP=%LOCALAPPDATA%\Temp +set TMP=%LOCALAPPDATA%\Temp +set windir=C:\Windows + +subst S: C:\cygwin64\%WORKDIR%\snap +subst P: C:\cygwin64\%WORKDIR%\snap-python + +del _snap.* +del x64\Release\*.obj +del x64\Release\*.pdb + +SET PATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x86;C:\Program Files (x86)\Windows Kits\10\bin\10.0.18362.0\x86;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\tools;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\ide;C:\Program Files (x86)\HTML Help Workshop;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin;C:\Windows\Microsoft.NET\Framework\v4.0.30319\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Python27;"C:\Program Files\gnuplot\bin";"C:\Program Files (x86)\Graphviz2.38\bin";%LOCALAPPDATA%\Microsoft\WindowsApps; +SET LIB=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\lib\x64;;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\ucrt\x64;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\lib;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\um\x64;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\lib\um\x64;;Lib\um\x64 +SET LIBPATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64; +SET INCLUDE=S:\snap-core;S:\glib-core;S:\snap-adv;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\include;;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\winrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\cppwinrt;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\Include\um; +SET VS_UNICODE_OUTPUT=792 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Python27\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj "..\..\snap\snap-adv\agm.cpp" "..\..\snap\snap-adv\agmfast.cpp" "..\..\snap\snap-adv\agmfit.cpp" "..\..\snap\snap-adv\cliques.cpp" "..\..\snap\snap-adv\biasedrandomwalk.cpp" "..\..\snap\snap-adv\word2vec.cpp" "..\..\snap\snap-adv\n2v.cpp" "..\..\snap\snap-core\Snap.cpp" +SET VS_UNICODE_OUTPUT=780 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Python27\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj snap_wrap.cxx +SET VS_UNICODE_OUTPUT=1324 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\link.exe" /ERRORREPORT:PROMPT /OUT:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pyd" /INCREMENTAL:NO /NOLOGO /LIBPATH:"C:\Python27\libs" python27.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pdb" /SUBSYSTEM:WINDOWS /OPT:REF /OPT:ICF /LTCG:incremental /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.lib" /MACHINE:X64 /DLL x64\Release\agm.obj x64\Release\agmfast.obj x64\Release\agmfit.obj x64\Release\cliques.obj x64\Release\biasedrandomwalk.obj x64\Release\word2vec.obj x64\Release\n2v.obj x64\Release\Snap.obj x64\Release\snap_wrap.obj + diff --git a/snap-python/source/scripts/build-package35-win.bat b/snap-python/source/scripts/build-package35-win.bat new file mode 100644 index 0000000000000000000000000000000000000000..19b9de39a2341556af1efbd585cbb918779fb0f1 --- /dev/null +++ b/snap-python/source/scripts/build-package35-win.bat @@ -0,0 +1,35 @@ +set CommonProgramFiles=C:\Program Files\Common Files +set CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files +set CommonProgramW6432=C:\Program Files\Common Files +set PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC +set PROCESSOR_ARCHITECTURE=AMD64 +set PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 10, GenuineIntel +set PROCESSOR_LEVEL=6 +set PROCESSOR_REVISION=9e0a +set ProgramData=C:\ProgramData +set ProgramFiles=C:\Program Files +set ProgramFiles(x86)=C:\Program Files (x86) +set ProgramW6432=C:\Program Files +set SystemRoot=C:\Windows +set TEMP=%LOCALAPPDATA%\Temp +set TMP=%LOCALAPPDATA%\Temp +set windir=C:\Windows + +subst S: C:\cygwin64\%WORKDIR%\snap +subst P: C:\cygwin64\%WORKDIR%\snap-python + +del _snap.* +del x64\Release\*.obj +del x64\Release\*.pdb + +SET PATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x86;C:\Program Files (x86)\Windows Kits\10\bin\10.0.18362.0\x86;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\tools;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\ide;C:\Program Files (x86)\HTML Help Workshop;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin;C:\Windows\Microsoft.NET\Framework\v4.0.30319\;;C:\Program Files\Python35\Scripts\;C:\Program Files\Python35\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Python27;"C:\Program Files\gnuplot\bin";"C:\Program Files (x86)\Graphviz2.38\bin";%LOCALAPPDATA%\Microsoft\WindowsApps; +SET LIB=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\lib\x64;;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\ucrt\x64;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\lib;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\um\x64;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\lib\um\x64;;Lib\um\x64 +SET LIBPATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64; +SET INCLUDE=S:\snap-core;S:\glib-core;S:\snap-adv;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\include;;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\winrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\cppwinrt;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\Include\um; +SET VS_UNICODE_OUTPUT=792 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python35\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj "..\..\snap\snap-adv\agm.cpp" "..\..\snap\snap-adv\agmfast.cpp" "..\..\snap\snap-adv\agmfit.cpp" "..\..\snap\snap-adv\cliques.cpp" "..\..\snap\snap-adv\biasedrandomwalk.cpp" "..\..\snap\snap-adv\word2vec.cpp" "..\..\snap\snap-adv\n2v.cpp" "..\..\snap\snap-core\Snap.cpp" +SET VS_UNICODE_OUTPUT=780 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python35\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj snap_wrap.cxx +SET VS_UNICODE_OUTPUT=1324 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\link.exe" /ERRORREPORT:PROMPT /OUT:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pyd" /INCREMENTAL:NO /NOLOGO /LIBPATH:"C:\Program Files\Python35\libs" python35.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pdb" /SUBSYSTEM:WINDOWS /OPT:REF /OPT:ICF /LTCG:incremental /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.lib" /MACHINE:X64 /DLL x64\Release\agm.obj x64\Release\agmfast.obj x64\Release\agmfit.obj x64\Release\cliques.obj x64\Release\biasedrandomwalk.obj x64\Release\word2vec.obj x64\Release\n2v.obj x64\Release\Snap.obj x64\Release\snap_wrap.obj + diff --git a/snap-python/source/scripts/build-package36-win.bat b/snap-python/source/scripts/build-package36-win.bat new file mode 100644 index 0000000000000000000000000000000000000000..d728291f5cd728ae8442f4d98dcb4b2e1c6b237e --- /dev/null +++ b/snap-python/source/scripts/build-package36-win.bat @@ -0,0 +1,35 @@ +set CommonProgramFiles=C:\Program Files\Common Files +set CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files +set CommonProgramW6432=C:\Program Files\Common Files +set PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC +set PROCESSOR_ARCHITECTURE=AMD64 +set PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 10, GenuineIntel +set PROCESSOR_LEVEL=6 +set PROCESSOR_REVISION=9e0a +set ProgramData=C:\ProgramData +set ProgramFiles=C:\Program Files +set ProgramFiles(x86)=C:\Program Files (x86) +set ProgramW6432=C:\Program Files +set SystemRoot=C:\Windows +set TEMP=%LOCALAPPDATA%\Temp +set TMP=%LOCALAPPDATA%\Temp +set windir=C:\Windows + +subst S: C:\cygwin64\%WORKDIR%\snap +subst P: C:\cygwin64\%WORKDIR%\snap-python + +del _snap.* +del x64\Release\*.obj +del x64\Release\*.pdb + +SET PATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x86;C:\Program Files (x86)\Windows Kits\10\bin\10.0.18362.0\x86;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\tools;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\ide;C:\Program Files (x86)\HTML Help Workshop;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin;C:\Windows\Microsoft.NET\Framework\v4.0.30319\;;C:\Program Files\Python36\Scripts\;C:\Program Files\Python36\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Python27;"C:\Program Files\gnuplot\bin";"C:\Program Files (x86)\Graphviz2.38\bin";%LOCALAPPDATA%\Microsoft\WindowsApps; +SET LIB=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\lib\x64;;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\ucrt\x64;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\lib;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\um\x64;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\lib\um\x64;;Lib\um\x64 +SET LIBPATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64; +SET INCLUDE=S:\snap-core;S:\glib-core;S:\snap-adv;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\include;;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\winrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\cppwinrt;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\Include\um; +SET VS_UNICODE_OUTPUT=792 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python36\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj "..\..\snap\snap-adv\agm.cpp" "..\..\snap\snap-adv\agmfast.cpp" "..\..\snap\snap-adv\agmfit.cpp" "..\..\snap\snap-adv\cliques.cpp" "..\..\snap\snap-adv\biasedrandomwalk.cpp" "..\..\snap\snap-adv\word2vec.cpp" "..\..\snap\snap-adv\n2v.cpp" "..\..\snap\snap-core\Snap.cpp" +SET VS_UNICODE_OUTPUT=780 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python36\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj snap_wrap.cxx +SET VS_UNICODE_OUTPUT=1324 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\link.exe" /ERRORREPORT:PROMPT /OUT:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pyd" /INCREMENTAL:NO /NOLOGO /LIBPATH:"C:\Program Files\Python36\libs" python36.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pdb" /SUBSYSTEM:WINDOWS /OPT:REF /OPT:ICF /LTCG:incremental /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.lib" /MACHINE:X64 /DLL x64\Release\agm.obj x64\Release\agmfast.obj x64\Release\agmfit.obj x64\Release\cliques.obj x64\Release\biasedrandomwalk.obj x64\Release\word2vec.obj x64\Release\n2v.obj x64\Release\Snap.obj x64\Release\snap_wrap.obj + diff --git a/snap-python/source/scripts/build-package37-win.bat b/snap-python/source/scripts/build-package37-win.bat new file mode 100644 index 0000000000000000000000000000000000000000..b29cd679c9c97196aba03dab88c328a7d5ad6d82 --- /dev/null +++ b/snap-python/source/scripts/build-package37-win.bat @@ -0,0 +1,34 @@ +set CommonProgramFiles=C:\Program Files\Common Files +set CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files +set CommonProgramW6432=C:\Program Files\Common Files +set PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC +set PROCESSOR_ARCHITECTURE=AMD64 +set PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 10, GenuineIntel +set PROCESSOR_LEVEL=6 +set PROCESSOR_REVISION=9e0a +set ProgramData=C:\ProgramData +set ProgramFiles=C:\Program Files +set ProgramFiles(x86)=C:\Program Files (x86) +set ProgramW6432=C:\Program Files +set SystemRoot=C:\Windows +set TEMP=%LOCALAPPDATA%\Temp +set TMP=%LOCALAPPDATA%\Temp +set windir=C:\Windows + +subst S: C:\cygwin64\%WORKDIR%\snap +subst P: C:\cygwin64\%WORKDIR%\snap-python + +del _snap.* +del x64\Release\*.obj +del x64\Release\*.pdb + +SET PATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x86;C:\Program Files (x86)\Windows Kits\10\bin\10.0.18362.0\x86;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\tools;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\ide;C:\Program Files (x86)\HTML Help Workshop;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin;C:\Windows\Microsoft.NET\Framework\v4.0.30319\;;C:\Program Files\Python37\Scripts\;C:\Program Files\Python37\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Python27;"C:\Program Files\gnuplot\bin";"C:\Program Files (x86)\Graphviz2.38\bin";%LOCALAPPDATA%\Microsoft\WindowsApps; +SET LIB=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\lib\x64;;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\ucrt\x64;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\lib;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\um\x64;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\lib\um\x64;;Lib\um\x64 +SET LIBPATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64; +SET INCLUDE=S:\snap-core;S:\glib-core;S:\snap-adv;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\include;;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\winrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\cppwinrt;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\Include\um; +SET VS_UNICODE_OUTPUT=792 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python37\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj "..\..\snap\snap-adv\agm.cpp" "..\..\snap\snap-adv\agmfast.cpp" "..\..\snap\snap-adv\agmfit.cpp" "..\..\snap\snap-adv\cliques.cpp" "..\..\snap\snap-adv\biasedrandomwalk.cpp" "..\..\snap\snap-adv\word2vec.cpp" "..\..\snap\snap-adv\n2v.cpp" "..\..\snap\snap-core\Snap.cpp" +SET VS_UNICODE_OUTPUT=780 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python37\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj snap_wrap.cxx +SET VS_UNICODE_OUTPUT=1324 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\link.exe" /ERRORREPORT:PROMPT /OUT:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pyd" /INCREMENTAL:NO /NOLOGO /LIBPATH:"C:\Program Files\Python37\libs" python37.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pdb" /SUBSYSTEM:WINDOWS /OPT:REF /OPT:ICF /LTCG:incremental /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.lib" /MACHINE:X64 /DLL x64\Release\agm.obj x64\Release\agmfast.obj x64\Release\agmfit.obj x64\Release\cliques.obj x64\Release\biasedrandomwalk.obj x64\Release\word2vec.obj x64\Release\n2v.obj x64\Release\Snap.obj x64\Release\snap_wrap.obj diff --git a/snap-python/source/scripts/build-package38-win.bat b/snap-python/source/scripts/build-package38-win.bat new file mode 100644 index 0000000000000000000000000000000000000000..901f6e283e22478b12fbe72b7b43836d6e36d1b1 --- /dev/null +++ b/snap-python/source/scripts/build-package38-win.bat @@ -0,0 +1,35 @@ +set CommonProgramFiles=C:\Program Files\Common Files +set CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files +set CommonProgramW6432=C:\Program Files\Common Files +set PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC +set PROCESSOR_ARCHITECTURE=AMD64 +set PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 10, GenuineIntel +set PROCESSOR_LEVEL=6 +set PROCESSOR_REVISION=9e0a +set ProgramData=C:\ProgramData +set ProgramFiles=C:\Program Files +set ProgramFiles(x86)=C:\Program Files (x86) +set ProgramW6432=C:\Program Files +set SystemRoot=C:\Windows +set TEMP=%LOCALAPPDATA%\Temp +set TMP=%LOCALAPPDATA%\Temp +set windir=C:\Windows + +subst S: C:\cygwin64\%WORKDIR%\snap +subst P: C:\cygwin64\%WORKDIR%\snap-python + +del _snap.* +del x64\Release\*.obj +del x64\Release\*.pdb + +SET PATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x86;C:\Program Files (x86)\Windows Kits\10\bin\10.0.18362.0\x86;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\tools;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\ide;C:\Program Files (x86)\HTML Help Workshop;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin;C:\Windows\Microsoft.NET\Framework\v4.0.30319\;;C:\Program Files\Python38\Scripts\;C:\Program Files\Python38\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Python27;"C:\Program Files\gnuplot\bin";"C:\Program Files (x86)\Graphviz2.38\bin";%LOCALAPPDATA%\Microsoft\WindowsApps; +SET LIB=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\lib\x64;;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\ucrt\x64;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\lib;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\um\x64;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\lib\um\x64;;Lib\um\x64 +SET LIBPATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64; +SET INCLUDE=S:\snap-core;S:\glib-core;S:\snap-adv;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\include;;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\winrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\cppwinrt;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\Include\um; +SET VS_UNICODE_OUTPUT=792 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python38\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj "..\..\snap\snap-adv\agm.cpp" "..\..\snap\snap-adv\agmfast.cpp" "..\..\snap\snap-adv\agmfit.cpp" "..\..\snap\snap-adv\cliques.cpp" "..\..\snap\snap-adv\biasedrandomwalk.cpp" "..\..\snap\snap-adv\word2vec.cpp" "..\..\snap\snap-adv\n2v.cpp" "..\..\snap\snap-core\Snap.cpp" +SET VS_UNICODE_OUTPUT=780 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python38\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj snap_wrap.cxx +SET VS_UNICODE_OUTPUT=1324 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\link.exe" /ERRORREPORT:PROMPT /OUT:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pyd" /INCREMENTAL:NO /NOLOGO /LIBPATH:"C:\Program Files\Python38\libs" python38.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pdb" /SUBSYSTEM:WINDOWS /OPT:REF /OPT:ICF /LTCG:incremental /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.lib" /MACHINE:X64 /DLL x64\Release\agm.obj x64\Release\agmfast.obj x64\Release\agmfit.obj x64\Release\cliques.obj x64\Release\biasedrandomwalk.obj x64\Release\word2vec.obj x64\Release\n2v.obj x64\Release\Snap.obj x64\Release\snap_wrap.obj + diff --git a/snap-python/source/scripts/build-package39-win.bat b/snap-python/source/scripts/build-package39-win.bat new file mode 100644 index 0000000000000000000000000000000000000000..0ed482042bf3a51ab2abe2780fa8f42299fa6b9f --- /dev/null +++ b/snap-python/source/scripts/build-package39-win.bat @@ -0,0 +1,35 @@ +set CommonProgramFiles=C:\Program Files\Common Files +set CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files +set CommonProgramW6432=C:\Program Files\Common Files +set PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC +set PROCESSOR_ARCHITECTURE=AMD64 +set PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 10, GenuineIntel +set PROCESSOR_LEVEL=6 +set PROCESSOR_REVISION=9e0a +set ProgramData=C:\ProgramData +set ProgramFiles=C:\Program Files +set ProgramFiles(x86)=C:\Program Files (x86) +set ProgramW6432=C:\Program Files +set SystemRoot=C:\Windows +set TEMP=%LOCALAPPDATA%\Temp +set TMP=%LOCALAPPDATA%\Temp +set windir=C:\Windows + +subst S: C:\cygwin64\%WORKDIR%\snap +subst P: C:\cygwin64\%WORKDIR%\snap-python + +del _snap.* +del x64\Release\*.obj +del x64\Release\*.pdb + +SET PATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x86;C:\Program Files (x86)\Windows Kits\10\bin\10.0.18362.0\x86;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\tools;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\ide;C:\Program Files (x86)\HTML Help Workshop;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Current\Bin;C:\Windows\Microsoft.NET\Framework\v4.0.30319\;;C:\Program Files\Python39\Scripts\;C:\Program Files\Python39\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Python27;"C:\Program Files\gnuplot\bin";"C:\Program Files (x86)\Graphviz2.38\bin";%LOCALAPPDATA%\Microsoft\WindowsApps; +SET LIB=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\lib\x64;;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\ucrt\x64;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\lib;C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\um\x64;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\lib\um\x64;;Lib\um\x64 +SET LIBPATH=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\lib\x64;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\lib\x64; +SET INCLUDE=S:\snap-core;S:\glib-core;S:\snap-adv;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\atlmfc\include;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\include;;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\ucrt;;;C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\VS\UnitTest\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\shared;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\winrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.18362.0\cppwinrt;C:\Program Files (x86)\Windows Kits\NETFXSDK\4.6.1\Include\um; +SET VS_UNICODE_OUTPUT=792 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python39\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj "..\..\snap\snap-adv\agm.cpp" "..\..\snap\snap-adv\agmfast.cpp" "..\..\snap\snap-adv\agmfit.cpp" "..\..\snap\snap-adv\cliques.cpp" "..\..\snap\snap-adv\biasedrandomwalk.cpp" "..\..\snap\snap-adv\word2vec.cpp" "..\..\snap\snap-adv\n2v.cpp" "..\..\snap\snap-core\Snap.cpp" +SET VS_UNICODE_OUTPUT=780 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\CL.exe" /c /IP:\swig /I"S:\glib-core" /I"S:\snap-core" /I"C:\Program Files\Python39\include" /Zi /nologo /W3 /WX- /diagnostics:column /sdl /O2 /Oi /GL /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D WIN32 /D NDEBUG /D SW_SNAPPY /D _WINDOWS /D _WINDLL /D _MBCS /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"x64\Release\\" /Fd"x64\Release\vc142.pdb" /Gd /TP /FC /errorReport:prompt /bigobj snap_wrap.cxx +SET VS_UNICODE_OUTPUT=1324 +"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.22.27905\bin\HostX86\x64\link.exe" /ERRORREPORT:PROMPT /OUT:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pyd" /INCREMENTAL:NO /NOLOGO /LIBPATH:"C:\Program Files\Python39\libs" python39.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.pdb" /SUBSYSTEM:WINDOWS /OPT:REF /OPT:ICF /LTCG:incremental /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"C:\cygwin64\%WORKDIR%\snap-python\swig\_snap.lib" /MACHINE:X64 /DLL x64\Release\agm.obj x64\Release\agmfast.obj x64\Release\agmfit.obj x64\Release\cliques.obj x64\Release\biasedrandomwalk.obj x64\Release\word2vec.obj x64\Release\n2v.obj x64\Release\Snap.obj x64\Release\snap_wrap.obj + diff --git a/snap-python/source/scripts/build-packages-linux.sh b/snap-python/source/scripts/build-packages-linux.sh new file mode 100644 index 0000000000000000000000000000000000000000..bbd3a91ca01209792e5a35586ab92b51959b0c18 --- /dev/null +++ b/snap-python/source/scripts/build-packages-linux.sh @@ -0,0 +1,40 @@ +#!/bin/bash + +# go to the working swig directory +cd /src/snap-python/swig + +# compile Python 2.7m +export SNAP_PY=2.7m +make clean-obj +time make whldist + +# compile Python 2.7mu +export SNAP_PY=2.7mu +make clean-obj +time make whldist + +# compile Python 3.5 +export SNAP_PY=3.5 +make clean-obj +time make whldist3 + +# compile Python 3.6 +export SNAP_PY=3.6 +make clean-obj +time make whldist3 + +# compile Python 3.7 +export SNAP_PY=3.7 +make clean-obj +time make whldist3 + +# compile Python 3.8 +export SNAP_PY=3.8 +make clean-obj +time make whldist3 + +# compile Python 3.9 +export SNAP_PY=3.9 +make clean-obj +time make whldist3 + diff --git a/snap-python/source/scripts/build-snappy-linux.sh b/snap-python/source/scripts/build-snappy-linux.sh new file mode 100644 index 0000000000000000000000000000000000000000..b7d63acc0aeac2a3b3e715e2788f7ba79b125d9d --- /dev/null +++ b/snap-python/source/scripts/build-snappy-linux.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +# +# compiles snap.py Linux packages for python 2.7, 3.5 .. 3.9 +# requirements: +# SWIG, current 4.0.2 +# docker +# quay.io/pypa/manylinux1_x86_64 (docker container) +# + +export WORKDIR=$HOME/build + +mkdir -p $WORKDIR +cd $WORKDIR + +# get a fresh copy of SNAP repositories, rename any existing repositories +rm -rf snap.bak snap-python.bak +mv -f snap snap.bak +mv -f snap-python snap-python.bak +git clone git@github.com:snap-stanford/snap.git +git clone git@github.com:snap-stanford/snap-python.git + +# run SWIG, it is required only once +cd $WORKDIR/snap-python/swig +make snap_wrap3.cxx + +# compile the extensions and build all the wheels +docker run -it -v $WORKDIR:/src --user "$(id -u):$(id -g)" quay.io/pypa/manylinux1_x86_64 /src/snap-python/scripts/build-packages-linux.sh + diff --git a/snap-python/source/scripts/build-snappy-macos.sh b/snap-python/source/scripts/build-snappy-macos.sh new file mode 100644 index 0000000000000000000000000000000000000000..7fcd698ccf284bdafc1ccf7eb99ec1b47a41d04d --- /dev/null +++ b/snap-python/source/scripts/build-snappy-macos.sh @@ -0,0 +1,60 @@ +#!/bin/bash + +# +# compiles snap.py Windows packages for python 2.7, 3.5 .. 3.9 +# requirements: +# SWIG, current 4.0.2 +# pyenv +# +export WORKDIR=$HOME/build + +mkdir -p $WORKDIR +cd $WORKDIR + +# get a fresh copy of SNAP repositories, rename any existing repositories +rm -rf snap.bak snap-python.bak +mv -f snap snap.bak +mv -f snap-python snap-python.bak +git clone git@github.com:snap-stanford/snap.git +git clone git@github.com:snap-stanford/snap-python.git + +# run SWIG, it is required only once +cd $WORKDIR/snap-python/swig +make snap_wrap3.cxx + +# compile Python 2.7 +export SNAP_PY=2.7 +pyenv global 2.7.18 +make clean-obj +time make whldist + +# compile Python 3.5 +export SNAP_PY=3.5 +pyenv global 3.5.10 +make clean-obj +time make whldist3 + +# compile Python 3.6 +export SNAP_PY=3.6 +pyenv global 3.6.12 +make clean-obj +time make whldist3 + +# compile Python 3.7 +export SNAP_PY=3.7 +pyenv global 3.7.9 +make clean-obj +time make whldist3 + +# compile Python 3.8 +export SNAP_PY=3.8 +pyenv global 3.8.6 +make clean-obj +time make whldist3 + +# compile Python 3.9 +export SNAP_PY=3.9 +pyenv global 3.9.0 +make clean-obj +time make whldist3 + diff --git a/snap-python/source/scripts/build-snappy-win.sh b/snap-python/source/scripts/build-snappy-win.sh new file mode 100644 index 0000000000000000000000000000000000000000..23abb9788f6fc53e7c653143fc96d9f320423bd6 --- /dev/null +++ b/snap-python/source/scripts/build-snappy-win.sh @@ -0,0 +1,59 @@ +#!/bin/bash + +# +# compiles snap.py Windows packages for python 2.7, 3.5 .. 3.9 +# requirements: +# cygwin +# SWIG, current 4.0.2 +# Visual Studio 2019 +# +export WORKDIR=$HOME/build + +mkdir -p $WORKDIR +cd $WORKDIR + +# get a fresh copy of SNAP repositories, rename any existing repositories +rm -rf snap.bak snap-python.bak +mv -f snap snap.bak +mv -f snap-python snap-python.bak +git clone git@github.com:snap-stanford/snap.git +git clone git@github.com:snap-stanford/snap-python.git + +# run SWIG, it is required only once +cd $WORKDIR/snap-python/swig +make snap_wrap3.cxx + +# go to the working swig directory +cd $WORKDIR/snap-python/swig +mkdir -p x64/Release + +# compile Python 2.7 +export SNAP_PY=2.7 +$WORKDIR/snap-python/scripts/build-package27-win.bat +time make whldist-win + +# compile Python 3.5 +export SNAP_PY=3.5 +$WORKDIR/snap-python/scripts/build-package35-win.bat +time make whldist-win + +# compile Python 3.6 +export SNAP_PY=3.6 +$WORKDIR/snap-python/scripts/build-package36-win.bat +time make whldist-win + +# compile Python 3.7 +export SNAP_PY=3.7 +$WORKDIR/snap-python/scripts/build-package37-win.bat +time make whldist-win + +# compile Python 3.8 +export SNAP_PY=3.8 +$WORKDIR/snap-python/scripts/build-package38-win.bat +time make whldist-win + +# compile Python 3.9 +export SNAP_PY=3.9 +$WORKDIR/snap-python/scripts/build-package39-win.bat +time make whldist-win + diff --git a/snap-python/source/setup.py b/snap-python/source/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..1c1240a7f84c8c7d3476a54f09bb0bc7357c7264 --- /dev/null +++ b/snap-python/source/setup.py @@ -0,0 +1,59 @@ +""" +setup.py file for SNAP (Stanford Network Analysis Platform) Python + Linux version, generated on CentOS, tested on Ubuntu as well +""" +import os +import shutil +import subprocess + +from setuptools import Extension, setup +from setuptools.command.build_ext import build_ext + + +SNAPPY_VERSION = "5.1.0.dev0" + + +class SwigExtension(Extension): + def __init__(self, name, sourcedir=''): + Extension.__init__(self, name, sources=[]) + self.sourcedir = os.path.abspath(sourcedir) + + +class SwigBuild(build_ext): + def run(self): + for ext in self.extensions: + self.build_extension(ext) + + def build_extension(self, ext): + extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name))) + + subprocess.check_call(['make']) + + if not os.path.exists(extdir): + os.makedirs(extdir) + + shutil.copy('swig/_snap.so', extdir) + shutil.copy('swig/snap.py', extdir) + + +with open('README.md') as f: + LONG_DESCRIPTION = f.read() + +setup( + name='snap-stanford', + version=SNAPPY_VERSION, + author="snap.stanford.edu", + description="SNAP (Stanford Network Analysis Platform) Python", + long_description=LONG_DESCRIPTION, + url="http://snap.stanford.edu", + classifiers=[ + "Programming Language :: Python :: 2", + "Programming Language :: Python :: 3", + "Operating System :: MacOS", + "Operating System :: Microsoft :: Windows", + "Operating System :: POSIX :: Linux" + ], + zip_safe=False, + cmdclass=dict(build_ext=SwigBuild), + ext_modules=[SwigExtension('snap._snap2')], +) diff --git a/snap-python/source/setup/MANIFEST b/snap-python/source/setup/MANIFEST new file mode 100644 index 0000000000000000000000000000000000000000..9b8a374b985f552765f7eeca501d83a1a29e01fb --- /dev/null +++ b/snap-python/source/setup/MANIFEST @@ -0,0 +1,3 @@ +setup.py +snap.py +_snap.so diff --git a/snap-python/source/setup/Makefile b/snap-python/source/setup/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..f45f04d2bc6c04062d7656bc3e455c948019c37b --- /dev/null +++ b/snap-python/source/setup/Makefile @@ -0,0 +1,45 @@ +# +# Makefile for compilation of SNAP Python from SWIG output +# + +SNAPVER = 2.x + +# set the path to your SNAP directory here +#SNAPROOT = ../Snap-$(SNAPVER) +SNAPROOT = ../../snap +SNAPDIR = $(SNAPROOT)/$(SNAP) +GLIBDIR = $(SNAPROOT)/$(GLIB) + +SWIGDIR = ../swig + +# include compilation parameters +include $(SNAPROOT)/Makefile.config +include ../Makefile.config + +all: _snap.so + +snap_wrap.o: snap_wrap.cxx + @if [ -r Version ] && ! diff Version $(SNAPROOT)/Version >/dev/null ; then echo "*** Error: SNAP versions do not match"; exit 1; fi + g++ $(CXXFLAGS) -c snap_wrap.cxx -I$(SWIGDIR) -I$(SNAPDIR) -I$(GLIBDIR) -I/usr/include/python2.6 -I/usr/include/python2.7 + +Snap.o: + @if [ -r Version ] && ! diff Version $(SNAPROOT)/Version >/dev/null ; then echo "*** Error: SNAP versions do not match"; exit 1; fi + $(CC) $(CXXFLAGS) -c $(SNAPDIR)/Snap.cpp -I$(SNAPDIR) -I$(GLIBDIR) + +_snap.so: snap_wrap.o Snap.o + g++ $(LDFLAGS) $(CXXFLAGS) snap_wrap.o Snap.o $(LIBS) -o _snap.so + +snap.py: snap_wrap.cxx + +install: setup.py snap.py _snap.so + sudo python setup.py install + +dist: setup.py snap.py _snap.so + python setup.py sdist + +build: + swig -python -c++ -w302,312,317,325,362,383,384,389,401,503,508,509 -O -D_CMPWARN -outcurrentdir -I$(SWIGDIR) -I$(SNAPDIR) -I$(GLIBDIR) $(SWIGDIR)/snap.i + cp $(SNAPROOT)/Version . + +clean: + rm -f *.o _*.so *.pyc diff --git a/snap-python/source/setup/Version b/snap-python/source/setup/Version new file mode 100644 index 0000000000000000000000000000000000000000..ad7aa1e802489670d24d856921f4be66434afa0c --- /dev/null +++ b/snap-python/source/setup/Version @@ -0,0 +1 @@ +Snap-2.0-20130513-163356 diff --git a/snap-python/source/setup/__init__.py b/snap-python/source/setup/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/setup/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/setup/setup.py b/snap-python/source/setup/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..dab995c0f0ae92633508c0c2d904007176d40879 --- /dev/null +++ b/snap-python/source/setup/setup.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python + +""" +setup.py file for SNAP (Stanford Network Analysis Platform) Python + CentOS version +""" + +import inspect +import os +import platform +import sys + +from distutils.core import setup, Extension + +# +# determine package parameters: +# snap-py version, python version, os version, architecture +# +snappy_version = "0.7" + +# snap-py version +snap_version = "dev" +try: + f = open("Version","r") + content = f.read() + f.close() + w = content.split("-") + snap_version = w[1].strip() +except: + pass + +# python version +python_version = "py" + str(sys.version_info[0]) + "." + str(sys.version_info[1]) + +# os version +uname = platform.uname() +os_version = "unknown-x.x" + +if uname[0] == "Linux": + try: + f = open("/etc/centos-release","r") + except: + try: + f = open("/etc/redhat-release","r") + except: + pass + + try: + content = f.read() + f.close() + w = content.split(" ") + os_version = (w[0] + w[2]).lower() + except: + pass + + obj_name = "_snap.so" + +elif uname[0] == "Darwin": + os.system("sw_vers -productVersion > OSX-Release") + try: + f = open("OSX-Release","r") + content = f.read() + f.close() + os_version = "macosx" + content.strip() + except: + pass + + obj_name = "_snap.so" + +elif uname[0].find("CYGWIN") == 0: + w = uname[0].rsplit("-",1) + os_version = w[0].lower() + obj_name = "_snap.so" + +elif uname[0].find("Windows") == 0: + os_version = "Win" + obj_name = "_snap.pyd" + +# architecture +arch = "i386" +# x86_64 on Linux, Mac OS X, i686 on Cygwin +if uname[4] == "x86_64" or uname[4] == "i686" or uname[4] == "AMD64": + arch = "x64" + +pkg_version = "-".join([snappy_version, snap_version, + os_version, arch, python_version]) + +#print "pkg_version", pkg_version +#print "obj_name", obj_name +#sys.exit(0) + +# +# get the installation directory +# + +# get the system Python directory +sys_install = os.path.join( + os.path.dirname(inspect.getfile(inspect)), + "site-packages") + +# check for an alternative Python user directory +user_install = sys_install +for p in sys.path: + n = p.find("site-packages") + if n > 0: + user_install = os.path.join(p[:n],"site-packages") + break + +# +# setup configuration +# + +setup (name = 'snap', + py_modules = ["snap"], + #ext_modules = [snap_module], + data_files = [(user_install, [obj_name])], + version = pkg_version, + author = "snap.stanford.edu", + description = """SNAP (Stanford Network Analysis Platform) Python""", + ) + diff --git a/snap-python/source/setup/snap.py b/snap-python/source/setup/snap.py new file mode 100644 index 0000000000000000000000000000000000000000..596461e334164b90797601a3b24c89163514bde0 --- /dev/null +++ b/snap-python/source/setup/snap.py @@ -0,0 +1,25444 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.9 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + + + +from sys import version_info +if version_info >= (3,0,0): + new_instancemethod = lambda func, inst, cls: _snap.SWIG_PyInstanceMethod_New(func) +else: + from new import instancemethod as new_instancemethod +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_snap', [dirname(__file__)]) + except ImportError: + import _snap + return _snap + if fp is not None: + try: + _mod = imp.load_module('_snap', fp, pathname, description) + finally: + fp.close() + return _mod + _snap = swig_import_helper() + del swig_import_helper +else: + import _snap +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +def _swig_setattr_nondynamic_method(set): + def set_attr(self,name,value): + if (name == "thisown"): return self.this.own(value) + if hasattr(self,name) or (name == "this"): + set(self,name,value) + else: + raise AttributeError("You cannot add attributes to %s" % self) + return set_attr + + + +def CalcEffDiam(*args): + """ + CalcEffDiam(TIntFltKdV const & DistNbrsCdfV, double const & Percentile=0.9) -> double + + Parameters: + DistNbrsCdfV: TIntFltKdV const & + Percentile: double const & + + CalcEffDiam(TIntFltKdV const & DistNbrsCdfV) -> double + + Parameters: + DistNbrsCdfV: TIntFltKdV const & + + CalcEffDiam(TFltPrV const & DistNbrsCdfV, double const & Percentile=0.9) -> double + + Parameters: + DistNbrsCdfV: TFltPrV const & + Percentile: double const & + + CalcEffDiam(TFltPrV const & DistNbrsCdfV) -> double + + Parameters: + DistNbrsCdfV: TFltPrV const & + + """ + return _snap.CalcEffDiam(*args) + +def CalcEffDiamPdf(*args): + """ + CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV, double const & Percentile=0.9) -> double + + Parameters: + DistNbrsPdfV: TIntFltKdV const & + Percentile: double const & + + CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double + + Parameters: + DistNbrsPdfV: TIntFltKdV const & + + CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV, double const & Percentile=0.9) -> double + + Parameters: + DistNbrsPdfV: TFltPrV const & + Percentile: double const & + + CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV) -> double + + Parameters: + DistNbrsPdfV: TFltPrV const & + + """ + return _snap.CalcEffDiamPdf(*args) + +def CalcAvgDiamPdf(*args): + """ + CalcAvgDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double + + Parameters: + DistNbrsPdfV: TIntFltKdV const & + + CalcAvgDiamPdf(TFltPrV const & DistNbrsPdfV) -> double + + Parameters: + DistNbrsPdfV: TFltPrV const & + + """ + return _snap.CalcAvgDiamPdf(*args) +lUndef = _snap.lUndef +lUs = _snap.lUs +lSi = _snap.lSi + +def WrNotify(*args): + """ + WrNotify(char const * CaptionCStr, char const * NotifyCStr) + + Parameters: + CaptionCStr: char const * + NotifyCStr: char const * + + """ + return _snap.WrNotify(*args) + +def SaveToErrLog(*args): + """ + SaveToErrLog(char const * MsgCStr) + + Parameters: + MsgCStr: char const * + + """ + return _snap.SaveToErrLog(*args) + +def InfoNotify(*args): + """ + InfoNotify(char const * NotifyCStr) + + Parameters: + NotifyCStr: char const * + + """ + return _snap.InfoNotify(*args) + +def WarnNotify(*args): + """ + WarnNotify(char const * NotifyCStr) + + Parameters: + NotifyCStr: char const * + + """ + return _snap.WarnNotify(*args) + +def ErrNotify(*args): + """ + ErrNotify(char const * NotifyCStr) + + Parameters: + NotifyCStr: char const * + + """ + return _snap.ErrNotify(*args) + +def StatNotify(*args): + """ + StatNotify(char const * NotifyCStr) + + Parameters: + NotifyCStr: char const * + + """ + return _snap.StatNotify(*args) + +def ExeStop(*args): + """ + ExeStop(char const * MsgStr, char const * ReasonStr, char const * CondStr, char const * FNm, + int const & LnN) + + Parameters: + MsgStr: char const * + ReasonStr: char const * + CondStr: char const * + FNm: char const * + LnN: int const & + + """ + return _snap.ExeStop(*args) +loUndef = _snap.loUndef +loNot = _snap.loNot +loAnd = _snap.loAnd +loOr = _snap.loOr +roUndef = _snap.roUndef +roLs = _snap.roLs +roLEq = _snap.roLEq +roEq = _snap.roEq +roNEq = _snap.roNEq +roGEq = _snap.roGEq +roGt = _snap.roGt +class TCRef(object): + """Proxy of C++ TCRef class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + """__init__(TCRef self) -> TCRef""" + _snap.TCRef_swiginit(self,_snap.new_TCRef()) + __swig_destroy__ = _snap.delete_TCRef + def MkRef(self): + """ + MkRef(TCRef self) + + Parameters: + self: TCRef * + + """ + return _snap.TCRef_MkRef(self) + + def UnRef(self): + """ + UnRef(TCRef self) + + Parameters: + self: TCRef * + + """ + return _snap.TCRef_UnRef(self) + + def NoRef(self): + """ + NoRef(TCRef self) -> bool + + Parameters: + self: TCRef const * + + """ + return _snap.TCRef_NoRef(self) + + def GetRefs(self): + """ + GetRefs(TCRef self) -> int + + Parameters: + self: TCRef const * + + """ + return _snap.TCRef_GetRefs(self) + +TCRef.MkRef = new_instancemethod(_snap.TCRef_MkRef,None,TCRef) +TCRef.UnRef = new_instancemethod(_snap.TCRef_UnRef,None,TCRef) +TCRef.NoRef = new_instancemethod(_snap.TCRef_NoRef,None,TCRef) +TCRef.GetRefs = new_instancemethod(_snap.TCRef_GetRefs,None,TCRef) +TCRef_swigregister = _snap.TCRef_swigregister +TCRef_swigregister(TCRef) + +class TSStr(object): + """Proxy of C++ TSStr class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TSStr self) -> TSStr + __init__(TSStr self, TSStr SStr) -> TSStr + + Parameters: + SStr: TSStr const & + + __init__(TSStr self, char const * _Bf) -> TSStr + + Parameters: + _Bf: char const * + + """ + _snap.TSStr_swiginit(self,_snap.new_TSStr(*args)) + __swig_destroy__ = _snap.delete_TSStr + def CStr(self, *args): + """ + CStr(TSStr self) -> char + CStr(TSStr self) -> char const * + + Parameters: + self: TSStr const * + + """ + return _snap.TSStr_CStr(self, *args) + + def Empty(self): + """ + Empty(TSStr self) -> bool + + Parameters: + self: TSStr const * + + """ + return _snap.TSStr_Empty(self) + + def Len(self): + """ + Len(TSStr self) -> int + + Parameters: + self: TSStr const * + + """ + return _snap.TSStr_Len(self) + +TSStr.CStr = new_instancemethod(_snap.TSStr_CStr,None,TSStr) +TSStr.Empty = new_instancemethod(_snap.TSStr_Empty,None,TSStr) +TSStr.Len = new_instancemethod(_snap.TSStr_Len,None,TSStr) +TSStr_swigregister = _snap.TSStr_swigregister +TSStr_swigregister(TSStr) + +class TConv_Pt64Ints32(object): + """Proxy of C++ TConv_Pt64Ints32 class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TConv_Pt64Ints32 self) -> TConv_Pt64Ints32 + __init__(TConv_Pt64Ints32 self, void * Pt) -> TConv_Pt64Ints32 + + Parameters: + Pt: void * + + __init__(TConv_Pt64Ints32 self, uint const & Ms, uint const & Ls) -> TConv_Pt64Ints32 + + Parameters: + Ms: uint const & + Ls: uint const & + + """ + _snap.TConv_Pt64Ints32_swiginit(self,_snap.new_TConv_Pt64Ints32(*args)) + def PutPt(self, *args): + """ + PutPt(TConv_Pt64Ints32 self, void * Pt) + + Parameters: + Pt: void * + + """ + return _snap.TConv_Pt64Ints32_PutPt(self, *args) + + def GetPt(self): + """ + GetPt(TConv_Pt64Ints32 self) -> void * + + Parameters: + self: TConv_Pt64Ints32 const * + + """ + return _snap.TConv_Pt64Ints32_GetPt(self) + + def PutUInt64(self, *args): + """ + PutUInt64(TConv_Pt64Ints32 self, uint64 const & _UInt64) + + Parameters: + _UInt64: uint64 const & + + """ + return _snap.TConv_Pt64Ints32_PutUInt64(self, *args) + + def GetUInt64(self): + """ + GetUInt64(TConv_Pt64Ints32 self) -> uint64 + + Parameters: + self: TConv_Pt64Ints32 const * + + """ + return _snap.TConv_Pt64Ints32_GetUInt64(self) + + def PutMsUInt32(self, *args): + """ + PutMsUInt32(TConv_Pt64Ints32 self, uint const & Ms) + + Parameters: + Ms: uint const & + + """ + return _snap.TConv_Pt64Ints32_PutMsUInt32(self, *args) + + def GetMsUInt32(self): + """ + GetMsUInt32(TConv_Pt64Ints32 self) -> uint + + Parameters: + self: TConv_Pt64Ints32 const * + + """ + return _snap.TConv_Pt64Ints32_GetMsUInt32(self) + + def PutLsUInt32(self, *args): + """ + PutLsUInt32(TConv_Pt64Ints32 self, uint const & Ls) + + Parameters: + Ls: uint const & + + """ + return _snap.TConv_Pt64Ints32_PutLsUInt32(self, *args) + + def GetLsUInt32(self): + """ + GetLsUInt32(TConv_Pt64Ints32 self) -> uint + + Parameters: + self: TConv_Pt64Ints32 const * + + """ + return _snap.TConv_Pt64Ints32_GetLsUInt32(self) + + __swig_destroy__ = _snap.delete_TConv_Pt64Ints32 +TConv_Pt64Ints32.PutPt = new_instancemethod(_snap.TConv_Pt64Ints32_PutPt,None,TConv_Pt64Ints32) +TConv_Pt64Ints32.GetPt = new_instancemethod(_snap.TConv_Pt64Ints32_GetPt,None,TConv_Pt64Ints32) +TConv_Pt64Ints32.PutUInt64 = new_instancemethod(_snap.TConv_Pt64Ints32_PutUInt64,None,TConv_Pt64Ints32) +TConv_Pt64Ints32.GetUInt64 = new_instancemethod(_snap.TConv_Pt64Ints32_GetUInt64,None,TConv_Pt64Ints32) +TConv_Pt64Ints32.PutMsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_PutMsUInt32,None,TConv_Pt64Ints32) +TConv_Pt64Ints32.GetMsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_GetMsUInt32,None,TConv_Pt64Ints32) +TConv_Pt64Ints32.PutLsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_PutLsUInt32,None,TConv_Pt64Ints32) +TConv_Pt64Ints32.GetLsUInt32 = new_instancemethod(_snap.TConv_Pt64Ints32_GetLsUInt32,None,TConv_Pt64Ints32) +TConv_Pt64Ints32_swigregister = _snap.TConv_Pt64Ints32_swigregister +TConv_Pt64Ints32_swigregister(TConv_Pt64Ints32) + +class TPairHashImpl1(object): + """Proxy of C++ TPairHashImpl1 class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def GetHashCd(*args): + """ + GetHashCd(int const hc1, int const hc2) -> int + + Parameters: + hc1: int const + hc2: int const + + """ + return _snap.TPairHashImpl1_GetHashCd(*args) + + GetHashCd = staticmethod(GetHashCd) + def __init__(self): + """__init__(TPairHashImpl1 self) -> TPairHashImpl1""" + _snap.TPairHashImpl1_swiginit(self,_snap.new_TPairHashImpl1()) + __swig_destroy__ = _snap.delete_TPairHashImpl1 +TPairHashImpl1_swigregister = _snap.TPairHashImpl1_swigregister +TPairHashImpl1_swigregister(TPairHashImpl1) + +def TPairHashImpl1_GetHashCd(*args): + """ + TPairHashImpl1_GetHashCd(int const hc1, int const hc2) -> int + + Parameters: + hc1: int const + hc2: int const + + """ + return _snap.TPairHashImpl1_GetHashCd(*args) + +class TPairHashImpl2(object): + """Proxy of C++ TPairHashImpl2 class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def GetHashCd(*args): + """ + GetHashCd(int const hc1, int const hc2) -> int + + Parameters: + hc1: int const + hc2: int const + + """ + return _snap.TPairHashImpl2_GetHashCd(*args) + + GetHashCd = staticmethod(GetHashCd) + def __init__(self): + """__init__(TPairHashImpl2 self) -> TPairHashImpl2""" + _snap.TPairHashImpl2_swiginit(self,_snap.new_TPairHashImpl2()) + __swig_destroy__ = _snap.delete_TPairHashImpl2 +TPairHashImpl2_swigregister = _snap.TPairHashImpl2_swigregister +TPairHashImpl2_swigregister(TPairHashImpl2) + +def TPairHashImpl2_GetHashCd(*args): + """ + TPairHashImpl2_GetHashCd(int const hc1, int const hc2) -> int + + Parameters: + hc1: int const + hc2: int const + + """ + return _snap.TPairHashImpl2_GetHashCd(*args) + + +def GetDegreeCentr(*args): + """ + GetDegreeCentr(PUNGraph const & Graph, int const & NId) -> double + + Parameters: + Graph: PUNGraph const & + NId: int const & + + """ + return _snap.GetDegreeCentr(*args) + +def GetFarnessCentr(*args): + """ + GetFarnessCentr(PUNGraph const & Graph, int const & NId) -> double + + Parameters: + Graph: PUNGraph const & + NId: int const & + + """ + return _snap.GetFarnessCentr(*args) + +def GetClosenessCentr(*args): + """ + GetClosenessCentr(PUNGraph const & Graph, int const & NId) -> double + + Parameters: + Graph: PUNGraph const & + NId: int const & + + """ + return _snap.GetClosenessCentr(*args) + +def GetBetweennessCentr(*args): + """ + GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, double const & NodeFrac=1.0) + + Parameters: + Graph: PUNGraph const & + NIdBtwH: TIntFltH & + NodeFrac: double const & + + GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH) + + Parameters: + Graph: PUNGraph const & + NIdBtwH: TIntFltH & + + GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0) + + Parameters: + Graph: PUNGraph const & + EdgeBtwH: TIntPrFltH & + NodeFrac: double const & + + GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH) + + Parameters: + Graph: PUNGraph const & + EdgeBtwH: TIntPrFltH & + + GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0) + + Parameters: + Graph: PUNGraph const & + NIdBtwH: TIntFltH & + EdgeBtwH: TIntPrFltH & + NodeFrac: double const & + + GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH) + + Parameters: + Graph: PUNGraph const & + NIdBtwH: TIntFltH & + EdgeBtwH: TIntPrFltH & + + GetBetweennessCentr(PUNGraph const & Graph, TIntV BtwNIdV, TIntFltH & NodeBtwH, bool const & DoNodeCent, + TIntPrFltH & EdgeBtwH, bool const & DoEdgeCent) + + Parameters: + Graph: PUNGraph const & + BtwNIdV: TIntV const & + NodeBtwH: TIntFltH & + DoNodeCent: bool const & + EdgeBtwH: TIntPrFltH & + DoEdgeCent: bool const & + + """ + return _snap.GetBetweennessCentr(*args) + +def GetEigenVectorCentr(*args): + """ + GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4, int const & MaxIter=100) + + Parameters: + Graph: PUNGraph const & + NIdEigenH: TIntFltH & + Eps: double const & + MaxIter: int const & + + GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4) + + Parameters: + Graph: PUNGraph const & + NIdEigenH: TIntFltH & + Eps: double const & + + GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH) + + Parameters: + Graph: PUNGraph const & + NIdEigenH: TIntFltH & + + """ + return _snap.GetEigenVectorCentr(*args) + +def CommunityGirvanNewman(*args): + """ + CommunityGirvanNewman(PUNGraph & Graph, TCnComV & CmtyV) -> double + + Parameters: + Graph: PUNGraph & + CmtyV: TCnComV & + + """ + return _snap.CommunityGirvanNewman(*args) + +def CommunityCNM(*args): + """ + CommunityCNM(PUNGraph const & Graph, TCnComV & CmtyV) -> double + + Parameters: + Graph: PUNGraph const & + CmtyV: TCnComV & + + """ + return _snap.CommunityCNM(*args) + +def CmtyGirvanNewmanStep(*args): + """ + CmtyGirvanNewmanStep(PUNGraph & Graph, TIntV Cmty1, TIntV Cmty2) + + Parameters: + Graph: PUNGraph & + Cmty1: TIntV & + Cmty2: TIntV & + + """ + return _snap.CmtyGirvanNewmanStep(*args) + +def GetBiConSzCnt(*args): + """ + GetBiConSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV) + + Parameters: + Graph: PUNGraph const & + SzCntV: TIntPrV & + + """ + return _snap.GetBiConSzCnt(*args) + +def GetBiCon(*args): + """ + GetBiCon(PUNGraph const & Graph, TCnComV & BiCnComV) + + Parameters: + Graph: PUNGraph const & + BiCnComV: TCnComV & + + """ + return _snap.GetBiCon(*args) + +def GetArtPoints(*args): + """ + GetArtPoints(PUNGraph const & Graph, TIntV ArtNIdV) + + Parameters: + Graph: PUNGraph const & + ArtNIdV: TIntV & + + """ + return _snap.GetArtPoints(*args) + +def GetEdgeBridges(*args): + """ + GetEdgeBridges(PUNGraph const & Graph, TIntPrV & EdgeV) + + Parameters: + Graph: PUNGraph const & + EdgeV: TIntPrV & + + """ + return _snap.GetEdgeBridges(*args) + +def Get1CnComSzCnt(*args): + """ + Get1CnComSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV) + + Parameters: + Graph: PUNGraph const & + SzCntV: TIntPrV & + + """ + return _snap.Get1CnComSzCnt(*args) + +def Get1CnCom(*args): + """ + Get1CnCom(PUNGraph const & Graph, TCnComV & Cn1ComV) + + Parameters: + Graph: PUNGraph const & + Cn1ComV: TCnComV & + + """ + return _snap.Get1CnCom(*args) +class TCnCom(object): + """Proxy of C++ TCnCom class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + NIdV = _swig_property(_snap.TCnCom_NIdV_get, _snap.TCnCom_NIdV_set) + def __init__(self, *args): + """ + __init__(TCnCom self) -> TCnCom + __init__(TCnCom self, TIntV NodeIdV) -> TCnCom + + Parameters: + NodeIdV: TIntV const & + + __init__(TCnCom self, TCnCom CC) -> TCnCom + + Parameters: + CC: TCnCom const & + + __init__(TCnCom self, TSIn SIn) -> TCnCom + + Parameters: + SIn: TSIn & + + """ + _snap.TCnCom_swiginit(self,_snap.new_TCnCom(*args)) + def Save(self, *args): + """ + Save(TCnCom self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TCnCom_Save(self, *args) + + def __eq__(self, *args): + """ + __eq__(TCnCom self, TCnCom CC) -> bool + + Parameters: + CC: TCnCom const & + + """ + return _snap.TCnCom___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TCnCom self, TCnCom CC) -> bool + + Parameters: + CC: TCnCom const & + + """ + return _snap.TCnCom___lt__(self, *args) + + def Len(self): + """ + Len(TCnCom self) -> int + + Parameters: + self: TCnCom const * + + """ + return _snap.TCnCom_Len(self) + + def Empty(self): + """ + Empty(TCnCom self) -> bool + + Parameters: + self: TCnCom const * + + """ + return _snap.TCnCom_Empty(self) + + def Clr(self): + """ + Clr(TCnCom self) + + Parameters: + self: TCnCom * + + """ + return _snap.TCnCom_Clr(self) + + def Add(self, *args): + """ + Add(TCnCom self, int const & NodeId) + + Parameters: + NodeId: int const & + + """ + return _snap.TCnCom_Add(self, *args) + + def __call__(self, *args): + """ + __call__(TCnCom self) -> TIntV + __call__(TCnCom self) -> TIntV + + Parameters: + self: TCnCom * + + """ + return _snap.TCnCom___call__(self, *args) + + def Sort(self, Asc=True): + """ + Sort(TCnCom self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + Sort(TCnCom self) + + Parameters: + self: TCnCom * + + """ + return _snap.TCnCom_Sort(self, Asc) + + def IsNIdIn(self, *args): + """ + IsNIdIn(TCnCom self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TCnCom_IsNIdIn(self, *args) + + def GetRndNId(self): + """ + GetRndNId(TCnCom self) -> TInt + + Parameters: + self: TCnCom const * + + """ + return _snap.TCnCom_GetRndNId(self) + + def Dump(*args): + """ + Dump(TCnComV const & CnComV, TStr Desc=TStr()) + + Parameters: + CnComV: TCnComV const & + Desc: TStr const & + + Dump(TCnComV const & CnComV) + + Parameters: + CnComV: TCnComV const & + + """ + return _snap.TCnCom_Dump(*args) + + Dump = staticmethod(Dump) + def SaveTxt(*args): + """ + SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr()) + + Parameters: + CnComV: TCnComV const & + FNm: TStr const & + Desc: TStr const & + + SaveTxt(TCnComV const & CnComV, TStr FNm) + + Parameters: + CnComV: TCnComV const & + FNm: TStr const & + + """ + return _snap.TCnCom_SaveTxt(*args) + + SaveTxt = staticmethod(SaveTxt) + __swig_destroy__ = _snap.delete_TCnCom +TCnCom.Save = new_instancemethod(_snap.TCnCom_Save,None,TCnCom) +TCnCom.__eq__ = new_instancemethod(_snap.TCnCom___eq__,None,TCnCom) +TCnCom.__lt__ = new_instancemethod(_snap.TCnCom___lt__,None,TCnCom) +TCnCom.Len = new_instancemethod(_snap.TCnCom_Len,None,TCnCom) +TCnCom.Empty = new_instancemethod(_snap.TCnCom_Empty,None,TCnCom) +TCnCom.Clr = new_instancemethod(_snap.TCnCom_Clr,None,TCnCom) +TCnCom.Add = new_instancemethod(_snap.TCnCom_Add,None,TCnCom) +TCnCom.__call__ = new_instancemethod(_snap.TCnCom___call__,None,TCnCom) +TCnCom.Sort = new_instancemethod(_snap.TCnCom_Sort,None,TCnCom) +TCnCom.IsNIdIn = new_instancemethod(_snap.TCnCom_IsNIdIn,None,TCnCom) +TCnCom.GetRndNId = new_instancemethod(_snap.TCnCom_GetRndNId,None,TCnCom) +TCnCom_swigregister = _snap.TCnCom_swigregister +TCnCom_swigregister(TCnCom) + +def TCnCom_Dump(*args): + """ + Dump(TCnComV const & CnComV, TStr Desc=TStr()) + + Parameters: + CnComV: TCnComV const & + Desc: TStr const & + + TCnCom_Dump(TCnComV const & CnComV) + + Parameters: + CnComV: TCnComV const & + + """ + return _snap.TCnCom_Dump(*args) + +def TCnCom_SaveTxt(*args): + """ + SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr()) + + Parameters: + CnComV: TCnComV const & + FNm: TStr const & + Desc: TStr const & + + TCnCom_SaveTxt(TCnComV const & CnComV, TStr FNm) + + Parameters: + CnComV: TCnComV const & + FNm: TStr const & + + """ + return _snap.TCnCom_SaveTxt(*args) + +class TArtPointVisitor(object): + """Proxy of C++ TArtPointVisitor class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + VnLowH = _swig_property(_snap.TArtPointVisitor_VnLowH_get, _snap.TArtPointVisitor_VnLowH_set) + ParentH = _swig_property(_snap.TArtPointVisitor_ParentH_get, _snap.TArtPointVisitor_ParentH_set) + ArtSet = _swig_property(_snap.TArtPointVisitor_ArtSet_get, _snap.TArtPointVisitor_ArtSet_set) + Time = _swig_property(_snap.TArtPointVisitor_Time_get, _snap.TArtPointVisitor_Time_set) + def __init__(self, *args): + """ + __init__(TArtPointVisitor self) -> TArtPointVisitor + __init__(TArtPointVisitor self, int const & Nodes) -> TArtPointVisitor + + Parameters: + Nodes: int const & + + """ + _snap.TArtPointVisitor_swiginit(self,_snap.new_TArtPointVisitor(*args)) + def DiscoverNode(self, *args): + """ + DiscoverNode(TArtPointVisitor self, int NId) + + Parameters: + NId: int + + """ + return _snap.TArtPointVisitor_DiscoverNode(self, *args) + + def FinishNode(self, *args): + """ + FinishNode(TArtPointVisitor self, int const & NId) + + Parameters: + NId: int const & + + """ + return _snap.TArtPointVisitor_FinishNode(self, *args) + + def ExamineEdge(self, *args): + """ + ExamineEdge(TArtPointVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TArtPointVisitor_ExamineEdge(self, *args) + + def TreeEdge(self, *args): + """ + TreeEdge(TArtPointVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TArtPointVisitor_TreeEdge(self, *args) + + def BackEdge(self, *args): + """ + BackEdge(TArtPointVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TArtPointVisitor_BackEdge(self, *args) + + def FwdEdge(self, *args): + """ + FwdEdge(TArtPointVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TArtPointVisitor_FwdEdge(self, *args) + + __swig_destroy__ = _snap.delete_TArtPointVisitor +TArtPointVisitor.DiscoverNode = new_instancemethod(_snap.TArtPointVisitor_DiscoverNode,None,TArtPointVisitor) +TArtPointVisitor.FinishNode = new_instancemethod(_snap.TArtPointVisitor_FinishNode,None,TArtPointVisitor) +TArtPointVisitor.ExamineEdge = new_instancemethod(_snap.TArtPointVisitor_ExamineEdge,None,TArtPointVisitor) +TArtPointVisitor.TreeEdge = new_instancemethod(_snap.TArtPointVisitor_TreeEdge,None,TArtPointVisitor) +TArtPointVisitor.BackEdge = new_instancemethod(_snap.TArtPointVisitor_BackEdge,None,TArtPointVisitor) +TArtPointVisitor.FwdEdge = new_instancemethod(_snap.TArtPointVisitor_FwdEdge,None,TArtPointVisitor) +TArtPointVisitor_swigregister = _snap.TArtPointVisitor_swigregister +TArtPointVisitor_swigregister(TArtPointVisitor) + +class TBiConVisitor(object): + """Proxy of C++ TBiConVisitor class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + VnLowH = _swig_property(_snap.TBiConVisitor_VnLowH_get, _snap.TBiConVisitor_VnLowH_set) + ParentH = _swig_property(_snap.TBiConVisitor_ParentH_get, _snap.TBiConVisitor_ParentH_set) + Stack = _swig_property(_snap.TBiConVisitor_Stack_get, _snap.TBiConVisitor_Stack_set) + CnComV = _swig_property(_snap.TBiConVisitor_CnComV_get, _snap.TBiConVisitor_CnComV_set) + NSet = _swig_property(_snap.TBiConVisitor_NSet_get, _snap.TBiConVisitor_NSet_set) + Time = _swig_property(_snap.TBiConVisitor_Time_get, _snap.TBiConVisitor_Time_set) + def __init__(self, *args): + """ + __init__(TBiConVisitor self) -> TBiConVisitor + __init__(TBiConVisitor self, int const & Nodes) -> TBiConVisitor + + Parameters: + Nodes: int const & + + """ + _snap.TBiConVisitor_swiginit(self,_snap.new_TBiConVisitor(*args)) + def DiscoverNode(self, *args): + """ + DiscoverNode(TBiConVisitor self, int NId) + + Parameters: + NId: int + + """ + return _snap.TBiConVisitor_DiscoverNode(self, *args) + + def FinishNode(self, *args): + """ + FinishNode(TBiConVisitor self, int const & NId) + + Parameters: + NId: int const & + + """ + return _snap.TBiConVisitor_FinishNode(self, *args) + + def ExamineEdge(self, *args): + """ + ExamineEdge(TBiConVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TBiConVisitor_ExamineEdge(self, *args) + + def TreeEdge(self, *args): + """ + TreeEdge(TBiConVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TBiConVisitor_TreeEdge(self, *args) + + def BackEdge(self, *args): + """ + BackEdge(TBiConVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TBiConVisitor_BackEdge(self, *args) + + def FwdEdge(self, *args): + """ + FwdEdge(TBiConVisitor self, int const & NId1, int const & NId2) + + Parameters: + NId1: int const & + NId2: int const & + + """ + return _snap.TBiConVisitor_FwdEdge(self, *args) + + __swig_destroy__ = _snap.delete_TBiConVisitor +TBiConVisitor.DiscoverNode = new_instancemethod(_snap.TBiConVisitor_DiscoverNode,None,TBiConVisitor) +TBiConVisitor.FinishNode = new_instancemethod(_snap.TBiConVisitor_FinishNode,None,TBiConVisitor) +TBiConVisitor.ExamineEdge = new_instancemethod(_snap.TBiConVisitor_ExamineEdge,None,TBiConVisitor) +TBiConVisitor.TreeEdge = new_instancemethod(_snap.TBiConVisitor_TreeEdge,None,TBiConVisitor) +TBiConVisitor.BackEdge = new_instancemethod(_snap.TBiConVisitor_BackEdge,None,TBiConVisitor) +TBiConVisitor.FwdEdge = new_instancemethod(_snap.TBiConVisitor_FwdEdge,None,TBiConVisitor) +TBiConVisitor_swigregister = _snap.TBiConVisitor_swigregister +TBiConVisitor_swigregister(TBiConVisitor) + +class TForestFire(object): + """Proxy of C++ TForestFire class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TForestFire self) -> TForestFire + __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, + double const & DecayProb=1.0, int const & RndSeed=1) -> TForestFire + + Parameters: + GraphPt: PNGraph const & + ForwBurnProb: double const & + BackBurnProb: double const & + DecayProb: double const & + RndSeed: int const & + + __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, + double const & DecayProb=1.0) -> TForestFire + + Parameters: + GraphPt: PNGraph const & + ForwBurnProb: double const & + BackBurnProb: double const & + DecayProb: double const & + + __init__(TForestFire self, PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb) -> TForestFire + + Parameters: + GraphPt: PNGraph const & + ForwBurnProb: double const & + BackBurnProb: double const & + + """ + _snap.TForestFire_swiginit(self,_snap.new_TForestFire(*args)) + def SetGraph(self, *args): + """ + SetGraph(TForestFire self, PNGraph const & GraphPt) + + Parameters: + GraphPt: PNGraph const & + + """ + return _snap.TForestFire_SetGraph(self, *args) + + def GetGraph(self): + """ + GetGraph(TForestFire self) -> PNGraph + + Parameters: + self: TForestFire const * + + """ + return _snap.TForestFire_GetGraph(self) + + def SetBurnProb(self, *args): + """ + SetBurnProb(TForestFire self, double const & ForwBurnProb, double const & BackBurnProb) + + Parameters: + ForwBurnProb: double const & + BackBurnProb: double const & + + """ + return _snap.TForestFire_SetBurnProb(self, *args) + + def SetProbDecay(self, *args): + """ + SetProbDecay(TForestFire self, double const & DecayProb) + + Parameters: + DecayProb: double const & + + """ + return _snap.TForestFire_SetProbDecay(self, *args) + + def Infect(self, *args): + """ + Infect(TForestFire self, int const & NodeId) + + Parameters: + NodeId: int const & + + Infect(TForestFire self, TIntV InfectedNIdV) + + Parameters: + InfectedNIdV: TIntV const & + + """ + return _snap.TForestFire_Infect(self, *args) + + def InfectAll(self): + """ + InfectAll(TForestFire self) + + Parameters: + self: TForestFire * + + """ + return _snap.TForestFire_InfectAll(self) + + def InfectRnd(self, *args): + """ + InfectRnd(TForestFire self, int const & NInfect) + + Parameters: + NInfect: int const & + + """ + return _snap.TForestFire_InfectRnd(self, *args) + + def BurnExpFire(self): + """ + BurnExpFire(TForestFire self) + + Parameters: + self: TForestFire * + + """ + return _snap.TForestFire_BurnExpFire(self) + + def BurnGeoFire(self): + """ + BurnGeoFire(TForestFire self) + + Parameters: + self: TForestFire * + + """ + return _snap.TForestFire_BurnGeoFire(self) + + def GetFireTm(self): + """ + GetFireTm(TForestFire self) -> int + + Parameters: + self: TForestFire const * + + """ + return _snap.TForestFire_GetFireTm(self) + + def GetBurned(self): + """ + GetBurned(TForestFire self) -> int + + Parameters: + self: TForestFire const * + + """ + return _snap.TForestFire_GetBurned(self) + + def GetBurnedNId(self, *args): + """ + GetBurnedNId(TForestFire self, int const & NIdN) -> int + + Parameters: + NIdN: int const & + + """ + return _snap.TForestFire_GetBurnedNId(self, *args) + + def GetBurnedNIdV(self, *args): + """ + GetBurnedNIdV(TForestFire self) -> TIntV + GetBurnedNIdV(TForestFire self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TForestFire_GetBurnedNIdV(self, *args) + + def PlotFire(self, *args): + """ + PlotFire(TForestFire self, TStr FNmPref, TStr Desc, bool const & PlotAllBurned=False) + + Parameters: + FNmPref: TStr const & + Desc: TStr const & + PlotAllBurned: bool const & + + PlotFire(TForestFire self, TStr FNmPref, TStr Desc) + + Parameters: + FNmPref: TStr const & + Desc: TStr const & + + """ + return _snap.TForestFire_PlotFire(self, *args) + + def GenGraph(*args): + """ + GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph + + Parameters: + Nodes: int const & + FwdProb: double const & + BckProb: double const & + + """ + return _snap.TForestFire_GenGraph(*args) + + GenGraph = staticmethod(GenGraph) + __swig_destroy__ = _snap.delete_TForestFire +TForestFire.SetGraph = new_instancemethod(_snap.TForestFire_SetGraph,None,TForestFire) +TForestFire.GetGraph = new_instancemethod(_snap.TForestFire_GetGraph,None,TForestFire) +TForestFire.SetBurnProb = new_instancemethod(_snap.TForestFire_SetBurnProb,None,TForestFire) +TForestFire.SetProbDecay = new_instancemethod(_snap.TForestFire_SetProbDecay,None,TForestFire) +TForestFire.Infect = new_instancemethod(_snap.TForestFire_Infect,None,TForestFire) +TForestFire.InfectAll = new_instancemethod(_snap.TForestFire_InfectAll,None,TForestFire) +TForestFire.InfectRnd = new_instancemethod(_snap.TForestFire_InfectRnd,None,TForestFire) +TForestFire.BurnExpFire = new_instancemethod(_snap.TForestFire_BurnExpFire,None,TForestFire) +TForestFire.BurnGeoFire = new_instancemethod(_snap.TForestFire_BurnGeoFire,None,TForestFire) +TForestFire.GetFireTm = new_instancemethod(_snap.TForestFire_GetFireTm,None,TForestFire) +TForestFire.GetBurned = new_instancemethod(_snap.TForestFire_GetBurned,None,TForestFire) +TForestFire.GetBurnedNId = new_instancemethod(_snap.TForestFire_GetBurnedNId,None,TForestFire) +TForestFire.GetBurnedNIdV = new_instancemethod(_snap.TForestFire_GetBurnedNIdV,None,TForestFire) +TForestFire.PlotFire = new_instancemethod(_snap.TForestFire_PlotFire,None,TForestFire) +TForestFire_swigregister = _snap.TForestFire_swigregister +TForestFire_swigregister(TForestFire) + +def TForestFire_GenGraph(*args): + """ + TForestFire_GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph + + Parameters: + Nodes: int const & + FwdProb: double const & + BckProb: double const & + + """ + return _snap.TForestFire_GenGraph(*args) + +class TFfGGen(object): + """Proxy of C++ TFfGGen class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + srUndef = _snap.TFfGGen_srUndef + srOk = _snap.TFfGGen_srOk + srFlood = _snap.TFfGGen_srFlood + srTimeLimit = _snap.TFfGGen_srTimeLimit + TimeLimitSec = _swig_property(_snap.TFfGGen_TimeLimitSec_get, _snap.TFfGGen_TimeLimitSec_set) + def __init__(self, *args): + """ + __init__(TFfGGen self, bool const & BurnExpFireP, int const & StartNNodes, double const & ForwBurnProb, + double const & BackBurnProb, double const & DecayProb, double const & Take2AmbasPrb, + double const & OrphanPrb) -> TFfGGen + + Parameters: + BurnExpFireP: bool const & + StartNNodes: int const & + ForwBurnProb: double const & + BackBurnProb: double const & + DecayProb: double const & + Take2AmbasPrb: double const & + OrphanPrb: double const & + + """ + _snap.TFfGGen_swiginit(self,_snap.new_TFfGGen(*args)) + def GetGraph(self): + """ + GetGraph(TFfGGen self) -> PNGraph + + Parameters: + self: TFfGGen const * + + """ + return _snap.TFfGGen_GetGraph(self) + + def SetGraph(self, *args): + """ + SetGraph(TFfGGen self, PNGraph const & NGraph) + + Parameters: + NGraph: PNGraph const & + + """ + return _snap.TFfGGen_SetGraph(self, *args) + + def Clr(self): + """ + Clr(TFfGGen self) + + Parameters: + self: TFfGGen * + + """ + return _snap.TFfGGen_Clr(self) + + def GetParamStr(self): + """ + GetParamStr(TFfGGen self) -> TStr + + Parameters: + self: TFfGGen const * + + """ + return _snap.TFfGGen_GetParamStr(self) + + def AddNodes(self, *args): + """ + AddNodes(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + FloodStop: bool const & + + AddNodes(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + + """ + return _snap.TFfGGen_AddNodes(self, *args) + + def GenGraph(self, *args): + """ + GenGraph(TFfGGen self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + FloodStop: bool const & + + GenGraph(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + + GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat, bool const & FloodStop=True) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + EvolStat: PGStatVec & + FloodStop: bool const & + + GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + EvolStat: PGStatVec & + + """ + return _snap.TFfGGen_GenGraph(self, *args) + + def PlotFireSize(self, *args): + """ + PlotFireSize(TFfGGen self, TStr FNmPref, TStr DescStr) + + Parameters: + FNmPref: TStr const & + DescStr: TStr const & + + """ + return _snap.TFfGGen_PlotFireSize(self, *args) + + def GenFFGraphs(*args): + """ + GenFFGraphs(double const & FProb, double const & BProb, TStr FNm) + + Parameters: + FProb: double const & + BProb: double const & + FNm: TStr const & + + """ + return _snap.TFfGGen_GenFFGraphs(*args) + + GenFFGraphs = staticmethod(GenFFGraphs) + __swig_destroy__ = _snap.delete_TFfGGen +TFfGGen.GetGraph = new_instancemethod(_snap.TFfGGen_GetGraph,None,TFfGGen) +TFfGGen.SetGraph = new_instancemethod(_snap.TFfGGen_SetGraph,None,TFfGGen) +TFfGGen.Clr = new_instancemethod(_snap.TFfGGen_Clr,None,TFfGGen) +TFfGGen.GetParamStr = new_instancemethod(_snap.TFfGGen_GetParamStr,None,TFfGGen) +TFfGGen.AddNodes = new_instancemethod(_snap.TFfGGen_AddNodes,None,TFfGGen) +TFfGGen.GenGraph = new_instancemethod(_snap.TFfGGen_GenGraph,None,TFfGGen) +TFfGGen.PlotFireSize = new_instancemethod(_snap.TFfGGen_PlotFireSize,None,TFfGGen) +TFfGGen_swigregister = _snap.TFfGGen_swigregister +TFfGGen_swigregister(TFfGGen) +cvar = _snap.cvar + +def TFfGGen_GenFFGraphs(*args): + """ + TFfGGen_GenFFGraphs(double const & FProb, double const & BProb, TStr FNm) + + Parameters: + FProb: double const & + BProb: double const & + FNm: TStr const & + + """ + return _snap.TFfGGen_GenFFGraphs(*args) + +class TUndirFFire(object): + """Proxy of C++ TUndirFFire class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, _BurnProb=0.3): + """ + __init__(TUndirFFire self, double const & _BurnProb=0.3) -> TUndirFFire + + Parameters: + _BurnProb: double const & + + __init__(TUndirFFire self) -> TUndirFFire + """ + _snap.TUndirFFire_swiginit(self,_snap.new_TUndirFFire(_BurnProb)) + def SetGraph(self, *args): + """ + SetGraph(TUndirFFire self, PUNGraph const & GraphPt) + + Parameters: + GraphPt: PUNGraph const & + + """ + return _snap.TUndirFFire_SetGraph(self, *args) + + def GetGraph(self): + """ + GetGraph(TUndirFFire self) -> PUNGraph + + Parameters: + self: TUndirFFire const * + + """ + return _snap.TUndirFFire_GetGraph(self) + + def GetNBurned(self): + """ + GetNBurned(TUndirFFire self) -> int + + Parameters: + self: TUndirFFire const * + + """ + return _snap.TUndirFFire_GetNBurned(self) + + def GetBurnedNId(self, *args): + """ + GetBurnedNId(TUndirFFire self, int const & n) -> int + + Parameters: + n: int const & + + """ + return _snap.TUndirFFire_GetBurnedNId(self, *args) + + def BurnGeoFire(self, *args): + """ + BurnGeoFire(TUndirFFire self, int const & StartNId) -> int + + Parameters: + StartNId: int const & + + """ + return _snap.TUndirFFire_BurnGeoFire(self, *args) + + def AddNodes(self, *args): + """ + AddNodes(TUndirFFire self, int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + FloodStop: bool const & + + AddNodes(TUndirFFire self, int const & GraphNodes) -> TFfGGen::TStopReason + + Parameters: + GraphNodes: int const & + + """ + return _snap.TUndirFFire_AddNodes(self, *args) + + __swig_destroy__ = _snap.delete_TUndirFFire +TUndirFFire.SetGraph = new_instancemethod(_snap.TUndirFFire_SetGraph,None,TUndirFFire) +TUndirFFire.GetGraph = new_instancemethod(_snap.TUndirFFire_GetGraph,None,TUndirFFire) +TUndirFFire.GetNBurned = new_instancemethod(_snap.TUndirFFire_GetNBurned,None,TUndirFFire) +TUndirFFire.GetBurnedNId = new_instancemethod(_snap.TUndirFFire_GetBurnedNId,None,TUndirFFire) +TUndirFFire.BurnGeoFire = new_instancemethod(_snap.TUndirFFire_BurnGeoFire,None,TUndirFFire) +TUndirFFire.AddNodes = new_instancemethod(_snap.TUndirFFire_AddNodes,None,TUndirFFire) +TUndirFFire_swigregister = _snap.TUndirFFire_swigregister +TUndirFFire_swigregister(TUndirFFire) + +class TCs(object): + """Proxy of C++ TCs class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TCs self) -> TCs + __init__(TCs self, TCs Cs) -> TCs + + Parameters: + Cs: TCs const & + + __init__(TCs self, int const & Int) -> TCs + + Parameters: + Int: int const & + + """ + _snap.TCs_swiginit(self,_snap.new_TCs(*args)) + def __eq__(self, *args): + """ + __eq__(TCs self, TCs Cs) -> bool + + Parameters: + Cs: TCs const & + + """ + return _snap.TCs___eq__(self, *args) + + def __iadd__(self, *args): + """ + __iadd__(TCs self, TCs Cs) -> TCs + + Parameters: + Cs: TCs const & + + __iadd__(TCs self, char const & Ch) -> TCs + + Parameters: + Ch: char const & + + __iadd__(TCs self, int const & Int) -> TCs + + Parameters: + Int: int const & + + """ + return _snap.TCs___iadd__(self, *args) + + def Get(self): + """ + Get(TCs self) -> int + + Parameters: + self: TCs const * + + """ + return _snap.TCs_Get(self) + + def GetCsFromBf(*args): + """ + GetCsFromBf(char * Bf, int const & BfL) -> TCs + + Parameters: + Bf: char * + BfL: int const & + + """ + return _snap.TCs_GetCsFromBf(*args) + + GetCsFromBf = staticmethod(GetCsFromBf) + __swig_destroy__ = _snap.delete_TCs +TCs.__eq__ = new_instancemethod(_snap.TCs___eq__,None,TCs) +TCs.__iadd__ = new_instancemethod(_snap.TCs___iadd__,None,TCs) +TCs.Get = new_instancemethod(_snap.TCs_Get,None,TCs) +TCs_swigregister = _snap.TCs_swigregister +TCs_swigregister(TCs) + +def TCs_GetCsFromBf(*args): + """ + TCs_GetCsFromBf(char * Bf, int const & BfL) -> TCs + + Parameters: + Bf: char * + BfL: int const & + + """ + return _snap.TCs_GetCsFromBf(*args) + +class TSOutMnp(object): + """Proxy of C++ TSOutMnp class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + def __call__(self, *args): + """ + __call__(TSOutMnp self, TSOut SOut) -> TSOut + + Parameters: + SOut: TSOut & + + """ + return _snap.TSOutMnp___call__(self, *args) + + __swig_destroy__ = _snap.delete_TSOutMnp +TSOutMnp.__call__ = new_instancemethod(_snap.TSOutMnp___call__,None,TSOutMnp) +TSOutMnp_swigregister = _snap.TSOutMnp_swigregister +TSOutMnp_swigregister(TSOutMnp) + +class TSBase(object): + """Proxy of C++ TSBase class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TSBase self, TSStr Nm) -> TSBase + + Parameters: + Nm: TSStr const & + + """ + _snap.TSBase_swiginit(self,_snap.new_TSBase(*args)) + __swig_destroy__ = _snap.delete_TSBase + def GetSNm(self): + """ + GetSNm(TSBase self) -> TStr + + Parameters: + self: TSBase const * + + """ + return _snap.TSBase_GetSNm(self) + +TSBase.GetSNm = new_instancemethod(_snap.TSBase_GetSNm,None,TSBase) +TSBase_swigregister = _snap.TSBase_swigregister +TSBase_swigregister(TSBase) + +class TSIn(TSBase): + """Proxy of C++ TSIn class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TSIn + def Eof(self): + """ + Eof(TSIn self) -> bool + + Parameters: + self: TSIn * + + """ + return _snap.TSIn_Eof(self) + + def Len(self): + """ + Len(TSIn self) -> int + + Parameters: + self: TSIn const * + + """ + return _snap.TSIn_Len(self) + + def GetCh(self): + """ + GetCh(TSIn self) -> char + + Parameters: + self: TSIn * + + """ + return _snap.TSIn_GetCh(self) + + def PeekCh(self): + """ + PeekCh(TSIn self) -> char + + Parameters: + self: TSIn * + + """ + return _snap.TSIn_PeekCh(self) + + def GetBf(self, *args): + """ + GetBf(TSIn self, void const * Bf, TSize const & BfL) -> int + + Parameters: + Bf: void const * + BfL: TSize const & + + """ + return _snap.TSIn_GetBf(self, *args) + + def GetNextLnBf(self, *args): + """ + GetNextLnBf(TSIn self, TChA LnChA) -> bool + + Parameters: + LnChA: TChA & + + """ + return _snap.TSIn_GetNextLnBf(self, *args) + + def Reset(self): + """ + Reset(TSIn self) + + Parameters: + self: TSIn * + + """ + return _snap.TSIn_Reset(self) + + def IsFastMode(self): + """ + IsFastMode(TSIn self) -> bool + + Parameters: + self: TSIn const * + + """ + return _snap.TSIn_IsFastMode(self) + + def SetFastMode(self, *args): + """ + SetFastMode(TSIn self, bool const & _FastMode) + + Parameters: + _FastMode: bool const & + + """ + return _snap.TSIn_SetFastMode(self, *args) + + def LoadCs(self): + """ + LoadCs(TSIn self) + + Parameters: + self: TSIn * + + """ + return _snap.TSIn_LoadCs(self) + + def LoadBf(self, *args): + """ + LoadBf(TSIn self, void const * Bf, TSize const & BfL) + + Parameters: + Bf: void const * + BfL: TSize const & + + """ + return _snap.TSIn_LoadBf(self, *args) + + def LoadNewBf(self, *args): + """ + LoadNewBf(TSIn self, int const & BfL) -> void * + + Parameters: + BfL: int const & + + """ + return _snap.TSIn_LoadNewBf(self, *args) + + def Load(self, *args): + """ + Load(TSIn self, bool & Bool) + + Parameters: + Bool: bool & + + Load(TSIn self, uchar & UCh) + + Parameters: + UCh: uchar & + + Load(TSIn self, char & Ch) + + Parameters: + Ch: char & + + Load(TSIn self, short & Short) + + Parameters: + Short: short & + + Load(TSIn self, ushort & UShort) + + Parameters: + UShort: ushort & + + Load(TSIn self, int & Int) + + Parameters: + Int: int & + + Load(TSIn self, uint & UInt) + + Parameters: + UInt: uint & + + Load(TSIn self, int64 & Int) + + Parameters: + Int: int64 & + + Load(TSIn self, uint64 & UInt) + + Parameters: + UInt: uint64 & + + Load(TSIn self, double & Flt) + + Parameters: + Flt: double & + + Load(TSIn self, sdouble & SFlt) + + Parameters: + SFlt: sdouble & + + Load(TSIn self, ldouble & LFlt) + + Parameters: + LFlt: ldouble & + + Load(TSIn self, char *& CStr, int const & MxCStrLen, int const & CStrLen) + + Parameters: + CStr: char *& + MxCStrLen: int const & + CStrLen: int const & + + Load(TSIn self, char *& CStr) + + Parameters: + CStr: char *& + + """ + return _snap.TSIn_Load(self, *args) + + def __rshift__(self, *args): + """ + __rshift__(TSIn self, bool & Bool) -> TSIn + + Parameters: + Bool: bool & + + __rshift__(TSIn self, uchar & UCh) -> TSIn + + Parameters: + UCh: uchar & + + __rshift__(TSIn self, char & Ch) -> TSIn + + Parameters: + Ch: char & + + __rshift__(TSIn self, short & Sh) -> TSIn + + Parameters: + Sh: short & + + __rshift__(TSIn self, ushort & USh) -> TSIn + + Parameters: + USh: ushort & + + __rshift__(TSIn self, int & Int) -> TSIn + + Parameters: + Int: int & + + __rshift__(TSIn self, uint & UInt) -> TSIn + + Parameters: + UInt: uint & + + __rshift__(TSIn self, int64 & Int) -> TSIn + + Parameters: + Int: int64 & + + __rshift__(TSIn self, uint64 & UInt) -> TSIn + + Parameters: + UInt: uint64 & + + __rshift__(TSIn self, float & Flt) -> TSIn + + Parameters: + Flt: float & + + __rshift__(TSIn self, double & Double) -> TSIn + + Parameters: + Double: double & + + __rshift__(TSIn self, long double & LDouble) -> TSIn + + Parameters: + LDouble: long double & + + """ + return _snap.TSIn___rshift__(self, *args) + + def GetNextLn(self, *args): + """ + GetNextLn(TSIn self, TStr LnStr) -> bool + + Parameters: + LnStr: TStr & + + GetNextLn(TSIn self, TChA LnChA) -> bool + + Parameters: + LnChA: TChA & + + """ + return _snap.TSIn_GetNextLn(self, *args) + +TSIn.Eof = new_instancemethod(_snap.TSIn_Eof,None,TSIn) +TSIn.Len = new_instancemethod(_snap.TSIn_Len,None,TSIn) +TSIn.GetCh = new_instancemethod(_snap.TSIn_GetCh,None,TSIn) +TSIn.PeekCh = new_instancemethod(_snap.TSIn_PeekCh,None,TSIn) +TSIn.GetBf = new_instancemethod(_snap.TSIn_GetBf,None,TSIn) +TSIn.GetNextLnBf = new_instancemethod(_snap.TSIn_GetNextLnBf,None,TSIn) +TSIn.Reset = new_instancemethod(_snap.TSIn_Reset,None,TSIn) +TSIn.IsFastMode = new_instancemethod(_snap.TSIn_IsFastMode,None,TSIn) +TSIn.SetFastMode = new_instancemethod(_snap.TSIn_SetFastMode,None,TSIn) +TSIn.LoadCs = new_instancemethod(_snap.TSIn_LoadCs,None,TSIn) +TSIn.LoadBf = new_instancemethod(_snap.TSIn_LoadBf,None,TSIn) +TSIn.LoadNewBf = new_instancemethod(_snap.TSIn_LoadNewBf,None,TSIn) +TSIn.Load = new_instancemethod(_snap.TSIn_Load,None,TSIn) +TSIn.__rshift__ = new_instancemethod(_snap.TSIn___rshift__,None,TSIn) +TSIn.GetNextLn = new_instancemethod(_snap.TSIn_GetNextLn,None,TSIn) +TSIn_swigregister = _snap.TSIn_swigregister +TSIn_swigregister(TSIn) +TSIn.StdIn = _snap.cvar.TSIn_StdIn + +class TSOut(TSBase): + """Proxy of C++ TSOut class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TSOut + def EnableLnTrunc(self, *args): + """ + EnableLnTrunc(TSOut self, int const & _MxLnLen) + + Parameters: + _MxLnLen: int const & + + """ + return _snap.TSOut_EnableLnTrunc(self, *args) + + def DisableLnTrunc(self): + """ + DisableLnTrunc(TSOut self) + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_DisableLnTrunc(self) + + def PutBf(self, *args): + """ + PutBf(TSOut self, void const * LBf, TSize const & LBfL) -> int + + Parameters: + LBf: void const * + LBfL: TSize const & + + """ + return _snap.TSOut_PutBf(self, *args) + + def Flush(self): + """ + Flush(TSOut self) + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_Flush(self) + + def GetFileId(self): + """ + GetFileId(TSOut self) -> TFileId + + Parameters: + self: TSOut const * + + """ + return _snap.TSOut_GetFileId(self) + + def PutMem(self, *args): + """ + PutMem(TSOut self, TMem Mem) -> int + + Parameters: + Mem: TMem const & + + """ + return _snap.TSOut_PutMem(self, *args) + + def PutCh(self, *args): + """ + PutCh(TSOut self, char const & Ch) -> int + + Parameters: + Ch: char const & + + PutCh(TSOut self, char const & Ch, int const & Chs) -> int + + Parameters: + Ch: char const & + Chs: int const & + + """ + return _snap.TSOut_PutCh(self, *args) + + def PutBool(self, *args): + """ + PutBool(TSOut self, bool const & Bool) -> int + + Parameters: + Bool: bool const & + + """ + return _snap.TSOut_PutBool(self, *args) + + def PutInt(self, *args): + """ + PutInt(TSOut self, int const & Int) -> int + + Parameters: + Int: int const & + + PutInt(TSOut self, int const & Int, char const * FmtStr) -> int + + Parameters: + Int: int const & + FmtStr: char const * + + """ + return _snap.TSOut_PutInt(self, *args) + + def PutUInt(self, *args): + """ + PutUInt(TSOut self, uint const & Int) -> int + + Parameters: + Int: uint const & + + PutUInt(TSOut self, uint const & Int, char const * FmtStr) -> int + + Parameters: + Int: uint const & + FmtStr: char const * + + """ + return _snap.TSOut_PutUInt(self, *args) + + def PutFlt(self, *args): + """ + PutFlt(TSOut self, double const & Flt) -> int + + Parameters: + Flt: double const & + + PutFlt(TSOut self, double const & Flt, char const * FmtStr) -> int + + Parameters: + Flt: double const & + FmtStr: char const * + + """ + return _snap.TSOut_PutFlt(self, *args) + + def PutStr(self, *args): + """ + PutStr(TSOut self, char const * CStr) -> int + + Parameters: + CStr: char const * + + PutStr(TSOut self, TChA ChA) -> int + + Parameters: + ChA: TChA const & + + PutStr(TSOut self, TStr Str, char const * FmtStr) -> int + + Parameters: + Str: TStr const & + FmtStr: char const * + + PutStr(TSOut self, TStr Str, bool const & ForceInLn=False) -> int + + Parameters: + Str: TStr const & + ForceInLn: bool const & + + PutStr(TSOut self, TStr Str) -> int + + Parameters: + Str: TStr const & + + """ + return _snap.TSOut_PutStr(self, *args) + + def PutStrLn(self, *args): + """ + PutStrLn(TSOut self, TStr Str, bool const & ForceInLn=False) -> int + + Parameters: + Str: TStr const & + ForceInLn: bool const & + + PutStrLn(TSOut self, TStr Str) -> int + + Parameters: + Str: TStr const & + + """ + return _snap.TSOut_PutStrLn(self, *args) + + def PutStrFmt(self, *args): + """ + PutStrFmt(TSOut self, char const * FmtStr) -> int + + Parameters: + FmtStr: char const * + + """ + return _snap.TSOut_PutStrFmt(self, *args) + + def PutStrFmtLn(self, *args): + """ + PutStrFmtLn(TSOut self, char const * FmtStr) -> int + + Parameters: + FmtStr: char const * + + """ + return _snap.TSOut_PutStrFmtLn(self, *args) + + def PutIndent(self, IndentLev=1): + """ + PutIndent(TSOut self, int const & IndentLev=1) -> int + + Parameters: + IndentLev: int const & + + PutIndent(TSOut self) -> int + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_PutIndent(self, IndentLev) + + def PutLn(self, Lns=1): + """ + PutLn(TSOut self, int const & Lns=1) -> int + + Parameters: + Lns: int const & + + PutLn(TSOut self) -> int + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_PutLn(self, Lns) + + def PutDosLn(self, Lns=1): + """ + PutDosLn(TSOut self, int const & Lns=1) -> int + + Parameters: + Lns: int const & + + PutDosLn(TSOut self) -> int + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_PutDosLn(self, Lns) + + def PutSep(self, NextStrLen=0): + """ + PutSep(TSOut self, int const & NextStrLen=0) -> int + + Parameters: + NextStrLen: int const & + + PutSep(TSOut self) -> int + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_PutSep(self, NextStrLen) + + def PutSepLn(self, Lns=0): + """ + PutSepLn(TSOut self, int const & Lns=0) -> int + + Parameters: + Lns: int const & + + PutSepLn(TSOut self) -> int + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_PutSepLn(self, Lns) + + def SaveCs(self): + """ + SaveCs(TSOut self) + + Parameters: + self: TSOut * + + """ + return _snap.TSOut_SaveCs(self) + + def SaveBf(self, *args): + """ + SaveBf(TSOut self, void const * Bf, TSize const & BfL) + + Parameters: + Bf: void const * + BfL: TSize const & + + """ + return _snap.TSOut_SaveBf(self, *args) + + def Save(self, *args): + """ + Save(TSOut self, bool const & Bool) + + Parameters: + Bool: bool const & + + Save(TSOut self, char const & Ch) + + Parameters: + Ch: char const & + + Save(TSOut self, uchar const & UCh) + + Parameters: + UCh: uchar const & + + Save(TSOut self, short const & Short) + + Parameters: + Short: short const & + + Save(TSOut self, ushort const & UShort) + + Parameters: + UShort: ushort const & + + Save(TSOut self, int const & Int) + + Parameters: + Int: int const & + + Save(TSOut self, uint const & UInt) + + Parameters: + UInt: uint const & + + Save(TSOut self, int64 const & Int) + + Parameters: + Int: int64 const & + + Save(TSOut self, uint64 const & UInt) + + Parameters: + UInt: uint64 const & + + Save(TSOut self, double const & Flt) + + Parameters: + Flt: double const & + + Save(TSOut self, sdouble const & SFlt) + + Parameters: + SFlt: sdouble const & + + Save(TSOut self, ldouble const & LFlt) + + Parameters: + LFlt: ldouble const & + + Save(TSOut self, char const * CStr, TSize const & CStrLen) + + Parameters: + CStr: char const * + CStrLen: TSize const & + + Save(TSOut self, char const * CStr) + + Parameters: + CStr: char const * + + Save(TSOut self, TSIn SIn, TSize const & BfL=-1) + + Parameters: + SIn: TSIn & + BfL: TSize const & + + Save(TSOut self, TSIn SIn) + + Parameters: + SIn: TSIn & + + Save(TSOut self, PSIn const & SIn, TSize const & BfL=-1) + + Parameters: + SIn: PSIn const & + BfL: TSize const & + + Save(TSOut self, PSIn const & SIn) + + Parameters: + SIn: PSIn const & + + Save(TSOut self, void const * Bf, TSize const & BfL) + + Parameters: + Bf: void const * + BfL: TSize const & + + """ + return _snap.TSOut_Save(self, *args) + + def __lshift__(self, *args): + """ + __lshift__(TSOut self, bool const & Bool) -> TSOut + + Parameters: + Bool: bool const & + + __lshift__(TSOut self, uchar const & UCh) -> TSOut + + Parameters: + UCh: uchar const & + + __lshift__(TSOut self, char const & Ch) -> TSOut + + Parameters: + Ch: char const & + + __lshift__(TSOut self, short const & Sh) -> TSOut + + Parameters: + Sh: short const & + + __lshift__(TSOut self, ushort const & USh) -> TSOut + + Parameters: + USh: ushort const & + + __lshift__(TSOut self, int const & Int) -> TSOut + + Parameters: + Int: int const & + + __lshift__(TSOut self, uint const & Int) -> TSOut + + Parameters: + Int: uint const & + + __lshift__(TSOut self, int64 const & Int) -> TSOut + + Parameters: + Int: int64 const & + + __lshift__(TSOut self, uint64 const & UInt) -> TSOut + + Parameters: + UInt: uint64 const & + + __lshift__(TSOut self, float const & Flt) -> TSOut + + Parameters: + Flt: float const & + + __lshift__(TSOut self, double const & Double) -> TSOut + + Parameters: + Double: double const & + + __lshift__(TSOut self, long double const & LDouble) -> TSOut + + Parameters: + LDouble: long double const & + + __lshift__(TSOut self, TSOutMnp Mnp) -> TSOut + + Parameters: + Mnp: TSOutMnp const & + + __lshift__(TSOut self, TSOut &(*)(TSOut &) FuncPt) -> TSOut + + Parameters: + FuncPt: TSOut &(*)(TSOut &) + + __lshift__(TSOut self, TSIn SIn) -> TSOut + + Parameters: + SIn: TSIn & + + __lshift__(TSOut self, PSIn & SIn) -> TSOut + + Parameters: + SIn: PSIn & + + """ + return _snap.TSOut___lshift__(self, *args) + +TSOut.EnableLnTrunc = new_instancemethod(_snap.TSOut_EnableLnTrunc,None,TSOut) +TSOut.DisableLnTrunc = new_instancemethod(_snap.TSOut_DisableLnTrunc,None,TSOut) +TSOut.PutBf = new_instancemethod(_snap.TSOut_PutBf,None,TSOut) +TSOut.Flush = new_instancemethod(_snap.TSOut_Flush,None,TSOut) +TSOut.GetFileId = new_instancemethod(_snap.TSOut_GetFileId,None,TSOut) +TSOut.PutMem = new_instancemethod(_snap.TSOut_PutMem,None,TSOut) +TSOut.PutCh = new_instancemethod(_snap.TSOut_PutCh,None,TSOut) +TSOut.PutBool = new_instancemethod(_snap.TSOut_PutBool,None,TSOut) +TSOut.PutInt = new_instancemethod(_snap.TSOut_PutInt,None,TSOut) +TSOut.PutUInt = new_instancemethod(_snap.TSOut_PutUInt,None,TSOut) +TSOut.PutFlt = new_instancemethod(_snap.TSOut_PutFlt,None,TSOut) +TSOut.PutStr = new_instancemethod(_snap.TSOut_PutStr,None,TSOut) +TSOut.PutStrLn = new_instancemethod(_snap.TSOut_PutStrLn,None,TSOut) +TSOut.PutStrFmt = new_instancemethod(_snap.TSOut_PutStrFmt,None,TSOut) +TSOut.PutStrFmtLn = new_instancemethod(_snap.TSOut_PutStrFmtLn,None,TSOut) +TSOut.PutIndent = new_instancemethod(_snap.TSOut_PutIndent,None,TSOut) +TSOut.PutLn = new_instancemethod(_snap.TSOut_PutLn,None,TSOut) +TSOut.PutDosLn = new_instancemethod(_snap.TSOut_PutDosLn,None,TSOut) +TSOut.PutSep = new_instancemethod(_snap.TSOut_PutSep,None,TSOut) +TSOut.PutSepLn = new_instancemethod(_snap.TSOut_PutSepLn,None,TSOut) +TSOut.SaveCs = new_instancemethod(_snap.TSOut_SaveCs,None,TSOut) +TSOut.SaveBf = new_instancemethod(_snap.TSOut_SaveBf,None,TSOut) +TSOut.Save = new_instancemethod(_snap.TSOut_Save,None,TSOut) +TSOut.__lshift__ = new_instancemethod(_snap.TSOut___lshift__,None,TSOut) +TSOut_swigregister = _snap.TSOut_swigregister +TSOut_swigregister(TSOut) +TSOut.StdOut = _snap.cvar.TSOut_StdOut + +class TSInOut(TSIn,TSOut): + """Proxy of C++ TSInOut class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TSInOut + def SetPos(self, *args): + """ + SetPos(TSInOut self, int const & Pos) + + Parameters: + Pos: int const & + + """ + return _snap.TSInOut_SetPos(self, *args) + + def MovePos(self, *args): + """ + MovePos(TSInOut self, int const & DPos) + + Parameters: + DPos: int const & + + """ + return _snap.TSInOut_MovePos(self, *args) + + def GetPos(self): + """ + GetPos(TSInOut self) -> int + + Parameters: + self: TSInOut const * + + """ + return _snap.TSInOut_GetPos(self) + + def GetSize(self): + """ + GetSize(TSInOut self) -> int + + Parameters: + self: TSInOut const * + + """ + return _snap.TSInOut_GetSize(self) + + def Clr(self): + """ + Clr(TSInOut self) + + Parameters: + self: TSInOut * + + """ + return _snap.TSInOut_Clr(self) + +TSInOut.SetPos = new_instancemethod(_snap.TSInOut_SetPos,None,TSInOut) +TSInOut.MovePos = new_instancemethod(_snap.TSInOut_MovePos,None,TSInOut) +TSInOut.GetPos = new_instancemethod(_snap.TSInOut_GetPos,None,TSInOut) +TSInOut.GetSize = new_instancemethod(_snap.TSInOut_GetSize,None,TSInOut) +TSInOut.Clr = new_instancemethod(_snap.TSInOut_Clr,None,TSInOut) +TSInOut_swigregister = _snap.TSInOut_swigregister +TSInOut_swigregister(TSInOut) + +class TStdIn(TSIn): + """Proxy of C++ TStdIn class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + """__init__(TStdIn self) -> TStdIn""" + _snap.TStdIn_swiginit(self,_snap.new_TStdIn()) + def New(): + """New() -> TPt< TSIn >""" + return _snap.TStdIn_New() + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TStdIn +TStdIn_swigregister = _snap.TStdIn_swigregister +TStdIn_swigregister(TStdIn) + +def TStdIn_New(): + """TStdIn_New() -> TPt< TSIn >""" + return _snap.TStdIn_New() + +class TStdOut(TSOut): + """Proxy of C++ TStdOut class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + """__init__(TStdOut self) -> TStdOut""" + _snap.TStdOut_swiginit(self,_snap.new_TStdOut()) + def New(): + """New() -> TPt< TSOut >""" + return _snap.TStdOut_New() + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TStdOut +TStdOut_swigregister = _snap.TStdOut_swigregister +TStdOut_swigregister(TStdOut) + +def TStdOut_New(): + """TStdOut_New() -> TPt< TSOut >""" + return _snap.TStdOut_New() + +class TFIn(TSIn): + """Proxy of C++ TFIn class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TFIn self, TStr FNm) -> TFIn + + Parameters: + FNm: TStr const & + + __init__(TFIn self, TStr FNm, bool & OpenedP) -> TFIn + + Parameters: + FNm: TStr const & + OpenedP: bool & + + """ + _snap.TFIn_swiginit(self,_snap.new_TFIn(*args)) + def New(*args): + """ + New(TStr FNm) -> PSIn + + Parameters: + FNm: TStr const & + + New(TStr FNm, bool & OpenedP) -> PSIn + + Parameters: + FNm: TStr const & + OpenedP: bool & + + """ + return _snap.TFIn_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TFIn +TFIn_swigregister = _snap.TFIn_swigregister +TFIn_swigregister(TFIn) + +def TFIn_New(*args): + """ + New(TStr FNm) -> PSIn + + Parameters: + FNm: TStr const & + + TFIn_New(TStr FNm, bool & OpenedP) -> PSIn + + Parameters: + FNm: TStr const & + OpenedP: bool & + + """ + return _snap.TFIn_New(*args) + +class TFOut(TSOut): + """Proxy of C++ TFOut class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TFOut self, TStr _FNm, bool const & Append=False) -> TFOut + + Parameters: + _FNm: TStr const & + Append: bool const & + + __init__(TFOut self, TStr _FNm) -> TFOut + + Parameters: + _FNm: TStr const & + + __init__(TFOut self, TStr _FNm, bool const & Append, bool & OpenedP) -> TFOut + + Parameters: + _FNm: TStr const & + Append: bool const & + OpenedP: bool & + + """ + _snap.TFOut_swiginit(self,_snap.new_TFOut(*args)) + def New(*args): + """ + New(TStr FNm, bool const & Append=False) -> PSOut + + Parameters: + FNm: TStr const & + Append: bool const & + + New(TStr FNm) -> PSOut + + Parameters: + FNm: TStr const & + + New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut + + Parameters: + FNm: TStr const & + Append: bool const & + OpenedP: bool & + + """ + return _snap.TFOut_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TFOut +TFOut_swigregister = _snap.TFOut_swigregister +TFOut_swigregister(TFOut) + +def TFOut_New(*args): + """ + New(TStr FNm, bool const & Append=False) -> PSOut + + Parameters: + FNm: TStr const & + Append: bool const & + + New(TStr FNm) -> PSOut + + Parameters: + FNm: TStr const & + + TFOut_New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut + + Parameters: + FNm: TStr const & + Append: bool const & + OpenedP: bool & + + """ + return _snap.TFOut_New(*args) + +faUndef = _snap.faUndef +faCreate = _snap.faCreate +faUpdate = _snap.faUpdate +faAppend = _snap.faAppend +faRdOnly = _snap.faRdOnly +faRestore = _snap.faRestore +class TMIn(TSIn): + """Proxy of C++ TMIn class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TMIn self, void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> TMIn + + Parameters: + _Bf: void const * + _BfL: int const & + TakeBf: bool const & + + __init__(TMIn self, void const * _Bf, int const & _BfL) -> TMIn + + Parameters: + _Bf: void const * + _BfL: int const & + + __init__(TMIn self, TSIn SIn) -> TMIn + + Parameters: + SIn: TSIn & + + __init__(TMIn self, char const * CStr) -> TMIn + + Parameters: + CStr: char const * + + __init__(TMIn self, TStr Str) -> TMIn + + Parameters: + Str: TStr const & + + __init__(TMIn self, TChA ChA) -> TMIn + + Parameters: + ChA: TChA const & + + """ + _snap.TMIn_swiginit(self,_snap.new_TMIn(*args)) + def New(*args): + """ + New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn + + Parameters: + _Bf: void const * + _BfL: int const & + TakeBf: bool const & + + New(void const * _Bf, int const & _BfL) -> PSIn + + Parameters: + _Bf: void const * + _BfL: int const & + + New(char const * CStr) -> PSIn + + Parameters: + CStr: char const * + + New(TStr Str) -> PSIn + + Parameters: + Str: TStr const & + + New(TChA ChA) -> PSIn + + Parameters: + ChA: TChA const & + + """ + return _snap.TMIn_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TMIn + def GetBfAddr(self): + """ + GetBfAddr(TMIn self) -> char * + + Parameters: + self: TMIn * + + """ + return _snap.TMIn_GetBfAddr(self) + +TMIn.GetBfAddr = new_instancemethod(_snap.TMIn_GetBfAddr,None,TMIn) +TMIn_swigregister = _snap.TMIn_swigregister +TMIn_swigregister(TMIn) + +def TMIn_New(*args): + """ + New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn + + Parameters: + _Bf: void const * + _BfL: int const & + TakeBf: bool const & + + New(void const * _Bf, int const & _BfL) -> PSIn + + Parameters: + _Bf: void const * + _BfL: int const & + + New(char const * CStr) -> PSIn + + Parameters: + CStr: char const * + + New(TStr Str) -> PSIn + + Parameters: + Str: TStr const & + + TMIn_New(TChA ChA) -> PSIn + + Parameters: + ChA: TChA const & + + """ + return _snap.TMIn_New(*args) + +class TMOut(TSOut): + """Proxy of C++ TMOut class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def New(MxBfL=1024): + """ + New(int const & MxBfL=1024) -> PSOut + + Parameters: + MxBfL: int const & + + New() -> PSOut + """ + return _snap.TMOut_New(MxBfL) + + New = staticmethod(New) + def __init__(self, *args): + """ + __init__(TMOut self, int const & _MxBfL=1024) -> TMOut + + Parameters: + _MxBfL: int const & + + __init__(TMOut self) -> TMOut + __init__(TMOut self, char * _Bf, int const & _MxBfL) -> TMOut + + Parameters: + _Bf: char * + _MxBfL: int const & + + """ + _snap.TMOut_swiginit(self,_snap.new_TMOut(*args)) + __swig_destroy__ = _snap.delete_TMOut + def AppendBf(self, *args): + """ + AppendBf(TMOut self, void const * LBf, TSize const & LBfL) + + Parameters: + LBf: void const * + LBfL: TSize const & + + """ + return _snap.TMOut_AppendBf(self, *args) + + def Len(self): + """ + Len(TMOut self) -> int + + Parameters: + self: TMOut const * + + """ + return _snap.TMOut_Len(self) + + def Clr(self): + """ + Clr(TMOut self) + + Parameters: + self: TMOut * + + """ + return _snap.TMOut_Clr(self) + + def GetCh(self, *args): + """ + GetCh(TMOut self, int const & ChN) -> char + + Parameters: + ChN: int const & + + """ + return _snap.TMOut_GetCh(self, *args) + + def GetAsStr(self): + """ + GetAsStr(TMOut self) -> TStr + + Parameters: + self: TMOut const * + + """ + return _snap.TMOut_GetAsStr(self) + + def CutBf(self, *args): + """ + CutBf(TMOut self, int const & CutBfL) + + Parameters: + CutBfL: int const & + + """ + return _snap.TMOut_CutBf(self, *args) + + def GetSIn(self, *args): + """ + GetSIn(TMOut self, bool const & IsCut=True, int const & CutBfL=-1) -> PSIn + + Parameters: + IsCut: bool const & + CutBfL: int const & + + GetSIn(TMOut self, bool const & IsCut=True) -> PSIn + + Parameters: + IsCut: bool const & + + GetSIn(TMOut self) -> PSIn + + Parameters: + self: TMOut * + + """ + return _snap.TMOut_GetSIn(self, *args) + + def GetBfAddr(self): + """ + GetBfAddr(TMOut self) -> char * + + Parameters: + self: TMOut const * + + """ + return _snap.TMOut_GetBfAddr(self) + + def IsCrLfLn(self): + """ + IsCrLfLn(TMOut self) -> bool + + Parameters: + self: TMOut const * + + """ + return _snap.TMOut_IsCrLfLn(self) + + def GetCrLfLn(self): + """ + GetCrLfLn(TMOut self) -> TStr + + Parameters: + self: TMOut * + + """ + return _snap.TMOut_GetCrLfLn(self) + + def IsEolnLn(self): + """ + IsEolnLn(TMOut self) -> bool + + Parameters: + self: TMOut const * + + """ + return _snap.TMOut_IsEolnLn(self) + + def GetEolnLn(self, *args): + """ + GetEolnLn(TMOut self, bool const & DoAddEoln, bool const & DoCutBf) -> TStr + + Parameters: + DoAddEoln: bool const & + DoCutBf: bool const & + + """ + return _snap.TMOut_GetEolnLn(self, *args) + + def MkEolnLn(self): + """ + MkEolnLn(TMOut self) + + Parameters: + self: TMOut * + + """ + return _snap.TMOut_MkEolnLn(self) + +TMOut.AppendBf = new_instancemethod(_snap.TMOut_AppendBf,None,TMOut) +TMOut.Len = new_instancemethod(_snap.TMOut_Len,None,TMOut) +TMOut.Clr = new_instancemethod(_snap.TMOut_Clr,None,TMOut) +TMOut.GetCh = new_instancemethod(_snap.TMOut_GetCh,None,TMOut) +TMOut.GetAsStr = new_instancemethod(_snap.TMOut_GetAsStr,None,TMOut) +TMOut.CutBf = new_instancemethod(_snap.TMOut_CutBf,None,TMOut) +TMOut.GetSIn = new_instancemethod(_snap.TMOut_GetSIn,None,TMOut) +TMOut.GetBfAddr = new_instancemethod(_snap.TMOut_GetBfAddr,None,TMOut) +TMOut.IsCrLfLn = new_instancemethod(_snap.TMOut_IsCrLfLn,None,TMOut) +TMOut.GetCrLfLn = new_instancemethod(_snap.TMOut_GetCrLfLn,None,TMOut) +TMOut.IsEolnLn = new_instancemethod(_snap.TMOut_IsEolnLn,None,TMOut) +TMOut.GetEolnLn = new_instancemethod(_snap.TMOut_GetEolnLn,None,TMOut) +TMOut.MkEolnLn = new_instancemethod(_snap.TMOut_MkEolnLn,None,TMOut) +TMOut_swigregister = _snap.TMOut_swigregister +TMOut_swigregister(TMOut) + +def TMOut_New(MxBfL=1024): + """ + New(int const & MxBfL=1024) -> PSOut + + Parameters: + MxBfL: int const & + + TMOut_New() -> PSOut + """ + return _snap.TMOut_New(MxBfL) + +class TChRet(object): + """Proxy of C++ TChRet class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TChRet self, PSIn const & _SIn, char const & _EofCh=0) -> TChRet + + Parameters: + _SIn: PSIn const & + _EofCh: char const & + + __init__(TChRet self, PSIn const & _SIn) -> TChRet + + Parameters: + _SIn: PSIn const & + + """ + _snap.TChRet_swiginit(self,_snap.new_TChRet(*args)) + def Eof(self): + """ + Eof(TChRet self) -> bool + + Parameters: + self: TChRet const * + + """ + return _snap.TChRet_Eof(self) + + def GetCh(self): + """ + GetCh(TChRet self) -> char + + Parameters: + self: TChRet * + + """ + return _snap.TChRet_GetCh(self) + + def __call__(self): + """ + __call__(TChRet self) -> char + + Parameters: + self: TChRet * + + """ + return _snap.TChRet___call__(self) + + __swig_destroy__ = _snap.delete_TChRet +TChRet.Eof = new_instancemethod(_snap.TChRet_Eof,None,TChRet) +TChRet.GetCh = new_instancemethod(_snap.TChRet_GetCh,None,TChRet) +TChRet.__call__ = new_instancemethod(_snap.TChRet___call__,None,TChRet) +TChRet_swigregister = _snap.TChRet_swigregister +TChRet_swigregister(TChRet) + +class TLnRet(object): + """Proxy of C++ TLnRet class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TLnRet self, PSIn const & _SIn) -> TLnRet + + Parameters: + _SIn: PSIn const & + + """ + _snap.TLnRet_swiginit(self,_snap.new_TLnRet(*args)) + def NextLn(self, *args): + """ + NextLn(TLnRet self, TStr LnStr) -> bool + + Parameters: + LnStr: TStr & + + """ + return _snap.TLnRet_NextLn(self, *args) + + __swig_destroy__ = _snap.delete_TLnRet +TLnRet.NextLn = new_instancemethod(_snap.TLnRet_NextLn,None,TLnRet) +TLnRet_swigregister = _snap.TLnRet_swigregister +TLnRet_swigregister(TLnRet) + +class TFile(object): + """Proxy of C++ TFile class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def Exists(*args): + """ + Exists(TStr FNm) -> bool + + Parameters: + FNm: TStr const & + + """ + return _snap.TFile_Exists(*args) + + Exists = staticmethod(Exists) + def Del(*args): + """ + Del(TStr FNm, bool const & ThrowExceptP=True) + + Parameters: + FNm: TStr const & + ThrowExceptP: bool const & + + Del(TStr FNm) + + Parameters: + FNm: TStr const & + + """ + return _snap.TFile_Del(*args) + + Del = staticmethod(Del) + def DelWc(*args): + """ + DelWc(TStr WcStr, bool const & RecurseDirP=False) + + Parameters: + WcStr: TStr const & + RecurseDirP: bool const & + + DelWc(TStr WcStr) + + Parameters: + WcStr: TStr const & + + """ + return _snap.TFile_DelWc(*args) + + DelWc = staticmethod(DelWc) + def Rename(*args): + """ + Rename(TStr SrcFNm, TStr DstFNm) + + Parameters: + SrcFNm: TStr const & + DstFNm: TStr const & + + """ + return _snap.TFile_Rename(*args) + + Rename = staticmethod(Rename) + def GetUniqueFNm(*args): + """ + GetUniqueFNm(TStr FNm) -> TStr + + Parameters: + FNm: TStr const & + + """ + return _snap.TFile_GetUniqueFNm(*args) + + GetUniqueFNm = staticmethod(GetUniqueFNm) + def __init__(self): + """__init__(TFile self) -> TFile""" + _snap.TFile_swiginit(self,_snap.new_TFile()) + __swig_destroy__ = _snap.delete_TFile +TFile_swigregister = _snap.TFile_swigregister +TFile_swigregister(TFile) +TFile.TxtFExt = _snap.cvar.TFile_TxtFExt +TFile.HtmlFExt = _snap.cvar.TFile_HtmlFExt +TFile.HtmFExt = _snap.cvar.TFile_HtmFExt +TFile.GifFExt = _snap.cvar.TFile_GifFExt +TFile.JarFExt = _snap.cvar.TFile_JarFExt + +def TFile_Exists(*args): + """ + TFile_Exists(TStr FNm) -> bool + + Parameters: + FNm: TStr const & + + """ + return _snap.TFile_Exists(*args) + +def TFile_Del(*args): + """ + Del(TStr FNm, bool const & ThrowExceptP=True) + + Parameters: + FNm: TStr const & + ThrowExceptP: bool const & + + TFile_Del(TStr FNm) + + Parameters: + FNm: TStr const & + + """ + return _snap.TFile_Del(*args) + +def TFile_DelWc(*args): + """ + DelWc(TStr WcStr, bool const & RecurseDirP=False) + + Parameters: + WcStr: TStr const & + RecurseDirP: bool const & + + TFile_DelWc(TStr WcStr) + + Parameters: + WcStr: TStr const & + + """ + return _snap.TFile_DelWc(*args) + +def TFile_Rename(*args): + """ + TFile_Rename(TStr SrcFNm, TStr DstFNm) + + Parameters: + SrcFNm: TStr const & + DstFNm: TStr const & + + """ + return _snap.TFile_Rename(*args) + +def TFile_GetUniqueFNm(*args): + """ + TFile_GetUniqueFNm(TStr FNm) -> TStr + + Parameters: + FNm: TStr const & + + """ + return _snap.TFile_GetUniqueFNm(*args) + +class TUNGraph(object): + """Proxy of C++ TUNGraph class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TUNGraph self) -> TUNGraph + __init__(TUNGraph self, int const & Nodes, int const & Edges) -> TUNGraph + + Parameters: + Nodes: int const & + Edges: int const & + + __init__(TUNGraph self, TUNGraph Graph) -> TUNGraph + + Parameters: + Graph: TUNGraph const & + + __init__(TUNGraph self, TSIn SIn) -> TUNGraph + + Parameters: + SIn: TSIn & + + """ + _snap.TUNGraph_swiginit(self,_snap.new_TUNGraph(*args)) + def Save(self, *args): + """ + Save(TUNGraph self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TUNGraph_Save(self, *args) + + def New(*args): + """ + New() -> PUNGraph + New(int const & Nodes, int const & Edges) -> PUNGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TUNGraph_New(*args) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn) -> PUNGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TUNGraph_Load(*args) + + Load = staticmethod(Load) + def HasFlag(self, *args): + """ + HasFlag(TUNGraph self, TGraphFlag const & Flag) -> bool + + Parameters: + Flag: TGraphFlag const & + + """ + return _snap.TUNGraph_HasFlag(self, *args) + + def GetNodes(self): + """ + GetNodes(TUNGraph self) -> int + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_GetNodes(self) + + def AddNode(self, *args): + """ + AddNode(TUNGraph self, int NId=-1) -> int + + Parameters: + NId: int + + AddNode(TUNGraph self) -> int + AddNode(TUNGraph self, TUNGraph::TNodeI const & NodeI) -> int + + Parameters: + NodeI: TUNGraph::TNodeI const & + + AddNode(TUNGraph self, int const & NId, TIntV NbrNIdV) -> int + + Parameters: + NId: int const & + NbrNIdV: TIntV const & + + AddNode(TUNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & NIdVId) -> int + + Parameters: + NId: int const & + Pool: TVecPool< TInt > const & + NIdVId: int const & + + """ + return _snap.TUNGraph_AddNode(self, *args) + + def DelNode(self, *args): + """ + DelNode(TUNGraph self, int const & NId) + + Parameters: + NId: int const & + + DelNode(TUNGraph self, TUNGraph::TNode const & NodeI) + + Parameters: + NodeI: TUNGraph::TNode const & + + """ + return _snap.TUNGraph_DelNode(self, *args) + + def IsNode(self, *args): + """ + IsNode(TUNGraph self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TUNGraph_IsNode(self, *args) + + def BegNI(self): + """ + BegNI(TUNGraph self) -> TUNGraph::TNodeI + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_BegNI(self) + + def EndNI(self): + """ + EndNI(TUNGraph self) -> TUNGraph::TNodeI + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_EndNI(self) + + def GetNI(self, *args): + """ + GetNI(TUNGraph self, int const & NId) -> TUNGraph::TNodeI + + Parameters: + NId: int const & + + """ + return _snap.TUNGraph_GetNI(self, *args) + + def GetMxNId(self): + """ + GetMxNId(TUNGraph self) -> int + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_GetMxNId(self) + + def GetEdges(self): + """ + GetEdges(TUNGraph self) -> int + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_GetEdges(self) + + def AddEdge(self, *args): + """ + AddEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + AddEdge(TUNGraph self, TUNGraph::TEdgeI const & EdgeI) -> int + + Parameters: + EdgeI: TUNGraph::TEdgeI const & + + """ + return _snap.TUNGraph_AddEdge(self, *args) + + def DelEdge(self, *args): + """ + DelEdge(TUNGraph self, int const & SrcNId, int const & DstNId) + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TUNGraph_DelEdge(self, *args) + + def IsEdge(self, *args): + """ + IsEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TUNGraph_IsEdge(self, *args) + + def BegEI(self): + """ + BegEI(TUNGraph self) -> TUNGraph::TEdgeI + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_BegEI(self) + + def EndEI(self): + """ + EndEI(TUNGraph self) -> TUNGraph::TEdgeI + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_EndEI(self) + + def GetEI(self, *args): + """ + GetEI(TUNGraph self, int const & SrcNId, int const & DstNId) -> TUNGraph::TEdgeI + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TUNGraph_GetEI(self, *args) + + def GetRndNId(self, *args): + """ + GetRndNId(TUNGraph self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndNId(TUNGraph self) -> int + + Parameters: + self: TUNGraph * + + """ + return _snap.TUNGraph_GetRndNId(self, *args) + + def GetRndNI(self, *args): + """ + GetRndNI(TUNGraph self, TRnd Rnd=Rnd) -> TUNGraph::TNodeI + + Parameters: + Rnd: TRnd & + + GetRndNI(TUNGraph self) -> TUNGraph::TNodeI + + Parameters: + self: TUNGraph * + + """ + return _snap.TUNGraph_GetRndNI(self, *args) + + def GetNIdV(self, *args): + """ + GetNIdV(TUNGraph self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TUNGraph_GetNIdV(self, *args) + + def Empty(self): + """ + Empty(TUNGraph self) -> bool + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_Empty(self) + + def Clr(self): + """ + Clr(TUNGraph self) + + Parameters: + self: TUNGraph * + + """ + return _snap.TUNGraph_Clr(self) + + def Reserve(self, *args): + """ + Reserve(TUNGraph self, int const & Nodes, int const & Edges) + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TUNGraph_Reserve(self, *args) + + def ReserveNIdDeg(self, *args): + """ + ReserveNIdDeg(TUNGraph self, int const & NId, int const & Deg) + + Parameters: + NId: int const & + Deg: int const & + + """ + return _snap.TUNGraph_ReserveNIdDeg(self, *args) + + def Defrag(self, OnlyNodeLinks=False): + """ + Defrag(TUNGraph self, bool const & OnlyNodeLinks=False) + + Parameters: + OnlyNodeLinks: bool const & + + Defrag(TUNGraph self) + + Parameters: + self: TUNGraph * + + """ + return _snap.TUNGraph_Defrag(self, OnlyNodeLinks) + + def IsOk(self, ThrowExcept=True): + """ + IsOk(TUNGraph self, bool const & ThrowExcept=True) -> bool + + Parameters: + ThrowExcept: bool const & + + IsOk(TUNGraph self) -> bool + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_IsOk(self, ThrowExcept) + + def Dump(self, *args): + """ + Dump(TUNGraph self, FILE * OutF=stdout) + + Parameters: + OutF: FILE * + + Dump(TUNGraph self) + + Parameters: + self: TUNGraph const * + + """ + return _snap.TUNGraph_Dump(self, *args) + + def GetSmallGraph(): + """GetSmallGraph() -> PUNGraph""" + return _snap.TUNGraph_GetSmallGraph() + + GetSmallGraph = staticmethod(GetSmallGraph) + __swig_destroy__ = _snap.delete_TUNGraph +TUNGraph.Save = new_instancemethod(_snap.TUNGraph_Save,None,TUNGraph) +TUNGraph.HasFlag = new_instancemethod(_snap.TUNGraph_HasFlag,None,TUNGraph) +TUNGraph.GetNodes = new_instancemethod(_snap.TUNGraph_GetNodes,None,TUNGraph) +TUNGraph.AddNode = new_instancemethod(_snap.TUNGraph_AddNode,None,TUNGraph) +TUNGraph.DelNode = new_instancemethod(_snap.TUNGraph_DelNode,None,TUNGraph) +TUNGraph.IsNode = new_instancemethod(_snap.TUNGraph_IsNode,None,TUNGraph) +TUNGraph.BegNI = new_instancemethod(_snap.TUNGraph_BegNI,None,TUNGraph) +TUNGraph.EndNI = new_instancemethod(_snap.TUNGraph_EndNI,None,TUNGraph) +TUNGraph.GetNI = new_instancemethod(_snap.TUNGraph_GetNI,None,TUNGraph) +TUNGraph.GetMxNId = new_instancemethod(_snap.TUNGraph_GetMxNId,None,TUNGraph) +TUNGraph.GetEdges = new_instancemethod(_snap.TUNGraph_GetEdges,None,TUNGraph) +TUNGraph.AddEdge = new_instancemethod(_snap.TUNGraph_AddEdge,None,TUNGraph) +TUNGraph.DelEdge = new_instancemethod(_snap.TUNGraph_DelEdge,None,TUNGraph) +TUNGraph.IsEdge = new_instancemethod(_snap.TUNGraph_IsEdge,None,TUNGraph) +TUNGraph.BegEI = new_instancemethod(_snap.TUNGraph_BegEI,None,TUNGraph) +TUNGraph.EndEI = new_instancemethod(_snap.TUNGraph_EndEI,None,TUNGraph) +TUNGraph.GetEI = new_instancemethod(_snap.TUNGraph_GetEI,None,TUNGraph) +TUNGraph.GetRndNId = new_instancemethod(_snap.TUNGraph_GetRndNId,None,TUNGraph) +TUNGraph.GetRndNI = new_instancemethod(_snap.TUNGraph_GetRndNI,None,TUNGraph) +TUNGraph.GetNIdV = new_instancemethod(_snap.TUNGraph_GetNIdV,None,TUNGraph) +TUNGraph.Empty = new_instancemethod(_snap.TUNGraph_Empty,None,TUNGraph) +TUNGraph.Clr = new_instancemethod(_snap.TUNGraph_Clr,None,TUNGraph) +TUNGraph.Reserve = new_instancemethod(_snap.TUNGraph_Reserve,None,TUNGraph) +TUNGraph.ReserveNIdDeg = new_instancemethod(_snap.TUNGraph_ReserveNIdDeg,None,TUNGraph) +TUNGraph.Defrag = new_instancemethod(_snap.TUNGraph_Defrag,None,TUNGraph) +TUNGraph.IsOk = new_instancemethod(_snap.TUNGraph_IsOk,None,TUNGraph) +TUNGraph.Dump = new_instancemethod(_snap.TUNGraph_Dump,None,TUNGraph) +TUNGraph_swigregister = _snap.TUNGraph_swigregister +TUNGraph_swigregister(TUNGraph) + +def TUNGraph_New(*args): + """ + New() -> PUNGraph + TUNGraph_New(int const & Nodes, int const & Edges) -> PUNGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TUNGraph_New(*args) + +def TUNGraph_Load(*args): + """ + TUNGraph_Load(TSIn SIn) -> PUNGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TUNGraph_Load(*args) + +def TUNGraph_GetSmallGraph(): + """TUNGraph_GetSmallGraph() -> PUNGraph""" + return _snap.TUNGraph_GetSmallGraph() + +class TNGraph(object): + """Proxy of C++ TNGraph class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNGraph self) -> TNGraph + __init__(TNGraph self, int const & Nodes, int const & Edges) -> TNGraph + + Parameters: + Nodes: int const & + Edges: int const & + + __init__(TNGraph self, TNGraph Graph) -> TNGraph + + Parameters: + Graph: TNGraph const & + + __init__(TNGraph self, TSIn SIn) -> TNGraph + + Parameters: + SIn: TSIn & + + """ + _snap.TNGraph_swiginit(self,_snap.new_TNGraph(*args)) + def Save(self, *args): + """ + Save(TNGraph self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TNGraph_Save(self, *args) + + def New(*args): + """ + New() -> PNGraph + New(int const & Nodes, int const & Edges) -> PNGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNGraph_New(*args) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn) -> PNGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TNGraph_Load(*args) + + Load = staticmethod(Load) + def HasFlag(self, *args): + """ + HasFlag(TNGraph self, TGraphFlag const & Flag) -> bool + + Parameters: + Flag: TGraphFlag const & + + """ + return _snap.TNGraph_HasFlag(self, *args) + + def GetNodes(self): + """ + GetNodes(TNGraph self) -> int + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_GetNodes(self) + + def AddNode(self, *args): + """ + AddNode(TNGraph self, int NId=-1) -> int + + Parameters: + NId: int + + AddNode(TNGraph self) -> int + AddNode(TNGraph self, TNGraph::TNodeI const & NodeId) -> int + + Parameters: + NodeId: TNGraph::TNodeI const & + + AddNode(TNGraph self, int const & NId, TIntV InNIdV, TIntV OutNIdV) -> int + + Parameters: + NId: int const & + InNIdV: TIntV const & + OutNIdV: TIntV const & + + AddNode(TNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & SrcVId, int const & DstVId) -> int + + Parameters: + NId: int const & + Pool: TVecPool< TInt > const & + SrcVId: int const & + DstVId: int const & + + """ + return _snap.TNGraph_AddNode(self, *args) + + def DelNode(self, *args): + """ + DelNode(TNGraph self, int const & NId) + + Parameters: + NId: int const & + + DelNode(TNGraph self, TNGraph::TNode const & NodeI) + + Parameters: + NodeI: TNGraph::TNode const & + + """ + return _snap.TNGraph_DelNode(self, *args) + + def IsNode(self, *args): + """ + IsNode(TNGraph self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNGraph_IsNode(self, *args) + + def BegNI(self): + """ + BegNI(TNGraph self) -> TNGraph::TNodeI + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_BegNI(self) + + def EndNI(self): + """ + EndNI(TNGraph self) -> TNGraph::TNodeI + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_EndNI(self) + + def GetNI(self, *args): + """ + GetNI(TNGraph self, int const & NId) -> TNGraph::TNodeI + + Parameters: + NId: int const & + + """ + return _snap.TNGraph_GetNI(self, *args) + + def GetMxNId(self): + """ + GetMxNId(TNGraph self) -> int + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_GetMxNId(self) + + def GetEdges(self): + """ + GetEdges(TNGraph self) -> int + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_GetEdges(self) + + def AddEdge(self, *args): + """ + AddEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + AddEdge(TNGraph self, TNGraph::TEdgeI const & EdgeI) -> int + + Parameters: + EdgeI: TNGraph::TEdgeI const & + + """ + return _snap.TNGraph_AddEdge(self, *args) + + def DelEdge(self, *args): + """ + DelEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + DelEdge(TNGraph self, int const & SrcNId, int const & DstNId) + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNGraph_DelEdge(self, *args) + + def IsEdge(self, *args): + """ + IsEdge(TNGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + IsEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNGraph_IsEdge(self, *args) + + def BegEI(self): + """ + BegEI(TNGraph self) -> TNGraph::TEdgeI + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_BegEI(self) + + def EndEI(self): + """ + EndEI(TNGraph self) -> TNGraph::TEdgeI + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_EndEI(self) + + def GetEI(self, *args): + """ + GetEI(TNGraph self, int const & SrcNId, int const & DstNId) -> TNGraph::TEdgeI + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNGraph_GetEI(self, *args) + + def GetRndNId(self, *args): + """ + GetRndNId(TNGraph self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndNId(TNGraph self) -> int + + Parameters: + self: TNGraph * + + """ + return _snap.TNGraph_GetRndNId(self, *args) + + def GetRndNI(self, *args): + """ + GetRndNI(TNGraph self, TRnd Rnd=Rnd) -> TNGraph::TNodeI + + Parameters: + Rnd: TRnd & + + GetRndNI(TNGraph self) -> TNGraph::TNodeI + + Parameters: + self: TNGraph * + + """ + return _snap.TNGraph_GetRndNI(self, *args) + + def GetNIdV(self, *args): + """ + GetNIdV(TNGraph self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TNGraph_GetNIdV(self, *args) + + def Empty(self): + """ + Empty(TNGraph self) -> bool + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_Empty(self) + + def Clr(self): + """ + Clr(TNGraph self) + + Parameters: + self: TNGraph * + + """ + return _snap.TNGraph_Clr(self) + + def Reserve(self, *args): + """ + Reserve(TNGraph self, int const & Nodes, int const & Edges) + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNGraph_Reserve(self, *args) + + def ReserveNIdInDeg(self, *args): + """ + ReserveNIdInDeg(TNGraph self, int const & NId, int const & InDeg) + + Parameters: + NId: int const & + InDeg: int const & + + """ + return _snap.TNGraph_ReserveNIdInDeg(self, *args) + + def ReserveNIdOutDeg(self, *args): + """ + ReserveNIdOutDeg(TNGraph self, int const & NId, int const & OutDeg) + + Parameters: + NId: int const & + OutDeg: int const & + + """ + return _snap.TNGraph_ReserveNIdOutDeg(self, *args) + + def Defrag(self, OnlyNodeLinks=False): + """ + Defrag(TNGraph self, bool const & OnlyNodeLinks=False) + + Parameters: + OnlyNodeLinks: bool const & + + Defrag(TNGraph self) + + Parameters: + self: TNGraph * + + """ + return _snap.TNGraph_Defrag(self, OnlyNodeLinks) + + def IsOk(self, ThrowExcept=True): + """ + IsOk(TNGraph self, bool const & ThrowExcept=True) -> bool + + Parameters: + ThrowExcept: bool const & + + IsOk(TNGraph self) -> bool + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_IsOk(self, ThrowExcept) + + def Dump(self, *args): + """ + Dump(TNGraph self, FILE * OutF=stdout) + + Parameters: + OutF: FILE * + + Dump(TNGraph self) + + Parameters: + self: TNGraph const * + + """ + return _snap.TNGraph_Dump(self, *args) + + def GetSmallGraph(): + """GetSmallGraph() -> PNGraph""" + return _snap.TNGraph_GetSmallGraph() + + GetSmallGraph = staticmethod(GetSmallGraph) + __swig_destroy__ = _snap.delete_TNGraph +TNGraph.Save = new_instancemethod(_snap.TNGraph_Save,None,TNGraph) +TNGraph.HasFlag = new_instancemethod(_snap.TNGraph_HasFlag,None,TNGraph) +TNGraph.GetNodes = new_instancemethod(_snap.TNGraph_GetNodes,None,TNGraph) +TNGraph.AddNode = new_instancemethod(_snap.TNGraph_AddNode,None,TNGraph) +TNGraph.DelNode = new_instancemethod(_snap.TNGraph_DelNode,None,TNGraph) +TNGraph.IsNode = new_instancemethod(_snap.TNGraph_IsNode,None,TNGraph) +TNGraph.BegNI = new_instancemethod(_snap.TNGraph_BegNI,None,TNGraph) +TNGraph.EndNI = new_instancemethod(_snap.TNGraph_EndNI,None,TNGraph) +TNGraph.GetNI = new_instancemethod(_snap.TNGraph_GetNI,None,TNGraph) +TNGraph.GetMxNId = new_instancemethod(_snap.TNGraph_GetMxNId,None,TNGraph) +TNGraph.GetEdges = new_instancemethod(_snap.TNGraph_GetEdges,None,TNGraph) +TNGraph.AddEdge = new_instancemethod(_snap.TNGraph_AddEdge,None,TNGraph) +TNGraph.DelEdge = new_instancemethod(_snap.TNGraph_DelEdge,None,TNGraph) +TNGraph.IsEdge = new_instancemethod(_snap.TNGraph_IsEdge,None,TNGraph) +TNGraph.BegEI = new_instancemethod(_snap.TNGraph_BegEI,None,TNGraph) +TNGraph.EndEI = new_instancemethod(_snap.TNGraph_EndEI,None,TNGraph) +TNGraph.GetEI = new_instancemethod(_snap.TNGraph_GetEI,None,TNGraph) +TNGraph.GetRndNId = new_instancemethod(_snap.TNGraph_GetRndNId,None,TNGraph) +TNGraph.GetRndNI = new_instancemethod(_snap.TNGraph_GetRndNI,None,TNGraph) +TNGraph.GetNIdV = new_instancemethod(_snap.TNGraph_GetNIdV,None,TNGraph) +TNGraph.Empty = new_instancemethod(_snap.TNGraph_Empty,None,TNGraph) +TNGraph.Clr = new_instancemethod(_snap.TNGraph_Clr,None,TNGraph) +TNGraph.Reserve = new_instancemethod(_snap.TNGraph_Reserve,None,TNGraph) +TNGraph.ReserveNIdInDeg = new_instancemethod(_snap.TNGraph_ReserveNIdInDeg,None,TNGraph) +TNGraph.ReserveNIdOutDeg = new_instancemethod(_snap.TNGraph_ReserveNIdOutDeg,None,TNGraph) +TNGraph.Defrag = new_instancemethod(_snap.TNGraph_Defrag,None,TNGraph) +TNGraph.IsOk = new_instancemethod(_snap.TNGraph_IsOk,None,TNGraph) +TNGraph.Dump = new_instancemethod(_snap.TNGraph_Dump,None,TNGraph) +TNGraph_swigregister = _snap.TNGraph_swigregister +TNGraph_swigregister(TNGraph) + +def TNGraph_New(*args): + """ + New() -> PNGraph + TNGraph_New(int const & Nodes, int const & Edges) -> PNGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNGraph_New(*args) + +def TNGraph_Load(*args): + """ + TNGraph_Load(TSIn SIn) -> PNGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TNGraph_Load(*args) + +def TNGraph_GetSmallGraph(): + """TNGraph_GetSmallGraph() -> PNGraph""" + return _snap.TNGraph_GetSmallGraph() + +class TNEGraph(object): + """Proxy of C++ TNEGraph class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNEGraph self) -> TNEGraph + __init__(TNEGraph self, int const & Nodes, int const & Edges) -> TNEGraph + + Parameters: + Nodes: int const & + Edges: int const & + + __init__(TNEGraph self, TNEGraph Graph) -> TNEGraph + + Parameters: + Graph: TNEGraph const & + + __init__(TNEGraph self, TSIn SIn) -> TNEGraph + + Parameters: + SIn: TSIn & + + """ + _snap.TNEGraph_swiginit(self,_snap.new_TNEGraph(*args)) + def Save(self, *args): + """ + Save(TNEGraph self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TNEGraph_Save(self, *args) + + def New(*args): + """ + New() -> PNEGraph + New(int const & Nodes, int const & Edges) -> PNEGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNEGraph_New(*args) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn) -> PNEGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TNEGraph_Load(*args) + + Load = staticmethod(Load) + def HasFlag(self, *args): + """ + HasFlag(TNEGraph self, TGraphFlag const & Flag) -> bool + + Parameters: + Flag: TGraphFlag const & + + """ + return _snap.TNEGraph_HasFlag(self, *args) + + def GetNodes(self): + """ + GetNodes(TNEGraph self) -> int + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_GetNodes(self) + + def AddNode(self, *args): + """ + AddNode(TNEGraph self, int NId=-1) -> int + + Parameters: + NId: int + + AddNode(TNEGraph self) -> int + AddNode(TNEGraph self, TNEGraph::TNodeI const & NodeId) -> int + + Parameters: + NodeId: TNEGraph::TNodeI const & + + """ + return _snap.TNEGraph_AddNode(self, *args) + + def DelNode(self, *args): + """ + DelNode(TNEGraph self, int const & NId) + + Parameters: + NId: int const & + + DelNode(TNEGraph self, TNEGraph::TNode const & NodeI) + + Parameters: + NodeI: TNEGraph::TNode const & + + """ + return _snap.TNEGraph_DelNode(self, *args) + + def IsNode(self, *args): + """ + IsNode(TNEGraph self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNEGraph_IsNode(self, *args) + + def BegNI(self): + """ + BegNI(TNEGraph self) -> TNEGraph::TNodeI + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_BegNI(self) + + def EndNI(self): + """ + EndNI(TNEGraph self) -> TNEGraph::TNodeI + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_EndNI(self) + + def GetNI(self, *args): + """ + GetNI(TNEGraph self, int const & NId) -> TNEGraph::TNodeI + + Parameters: + NId: int const & + + """ + return _snap.TNEGraph_GetNI(self, *args) + + def GetMxNId(self): + """ + GetMxNId(TNEGraph self) -> int + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_GetMxNId(self) + + def GetEdges(self): + """ + GetEdges(TNEGraph self) -> int + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_GetEdges(self) + + def AddEdge(self, *args): + """ + AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int EId=-1) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int + + AddEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + AddEdge(TNEGraph self, TNEGraph::TEdgeI const & EdgeI) -> int + + Parameters: + EdgeI: TNEGraph::TEdgeI const & + + """ + return _snap.TNEGraph_AddEdge(self, *args) + + def DelEdge(self, *args): + """ + DelEdge(TNEGraph self, int const & EId) + + Parameters: + EId: int const & + + DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId) + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNEGraph_DelEdge(self, *args) + + def IsEdge(self, *args): + """ + IsEdge(TNEGraph self, int const & EId) -> bool + + Parameters: + EId: int const & + + IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + + IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int & + IsDir: bool const & + + IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int & + + """ + return _snap.TNEGraph_IsEdge(self, *args) + + def GetEId(self, *args): + """ + GetEId(TNEGraph self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNEGraph_GetEId(self, *args) + + def BegEI(self): + """ + BegEI(TNEGraph self) -> TNEGraph::TEdgeI + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_BegEI(self) + + def EndEI(self): + """ + EndEI(TNEGraph self) -> TNEGraph::TEdgeI + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_EndEI(self) + + def GetEI(self, *args): + """ + GetEI(TNEGraph self, int const & EId) -> TNEGraph::TEdgeI + + Parameters: + EId: int const & + + GetEI(TNEGraph self, int const & SrcNId, int const & DstNId) -> TNEGraph::TEdgeI + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNEGraph_GetEI(self, *args) + + def GetRndNId(self, *args): + """ + GetRndNId(TNEGraph self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndNId(TNEGraph self) -> int + + Parameters: + self: TNEGraph * + + """ + return _snap.TNEGraph_GetRndNId(self, *args) + + def GetRndNI(self, *args): + """ + GetRndNI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TNodeI + + Parameters: + Rnd: TRnd & + + GetRndNI(TNEGraph self) -> TNEGraph::TNodeI + + Parameters: + self: TNEGraph * + + """ + return _snap.TNEGraph_GetRndNI(self, *args) + + def GetRndEId(self, *args): + """ + GetRndEId(TNEGraph self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndEId(TNEGraph self) -> int + + Parameters: + self: TNEGraph * + + """ + return _snap.TNEGraph_GetRndEId(self, *args) + + def GetRndEI(self, *args): + """ + GetRndEI(TNEGraph self, TRnd Rnd=Rnd) -> TNEGraph::TEdgeI + + Parameters: + Rnd: TRnd & + + GetRndEI(TNEGraph self) -> TNEGraph::TEdgeI + + Parameters: + self: TNEGraph * + + """ + return _snap.TNEGraph_GetRndEI(self, *args) + + def GetNIdV(self, *args): + """ + GetNIdV(TNEGraph self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TNEGraph_GetNIdV(self, *args) + + def GetEIdV(self, *args): + """ + GetEIdV(TNEGraph self, TIntV EIdV) + + Parameters: + EIdV: TIntV & + + """ + return _snap.TNEGraph_GetEIdV(self, *args) + + def Empty(self): + """ + Empty(TNEGraph self) -> bool + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_Empty(self) + + def Clr(self): + """ + Clr(TNEGraph self) + + Parameters: + self: TNEGraph * + + """ + return _snap.TNEGraph_Clr(self) + + def Reserve(self, *args): + """ + Reserve(TNEGraph self, int const & Nodes, int const & Edges) + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNEGraph_Reserve(self, *args) + + def Defrag(self, OnlyNodeLinks=False): + """ + Defrag(TNEGraph self, bool const & OnlyNodeLinks=False) + + Parameters: + OnlyNodeLinks: bool const & + + Defrag(TNEGraph self) + + Parameters: + self: TNEGraph * + + """ + return _snap.TNEGraph_Defrag(self, OnlyNodeLinks) + + def IsOk(self, ThrowExcept=True): + """ + IsOk(TNEGraph self, bool const & ThrowExcept=True) -> bool + + Parameters: + ThrowExcept: bool const & + + IsOk(TNEGraph self) -> bool + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_IsOk(self, ThrowExcept) + + def Dump(self, *args): + """ + Dump(TNEGraph self, FILE * OutF=stdout) + + Parameters: + OutF: FILE * + + Dump(TNEGraph self) + + Parameters: + self: TNEGraph const * + + """ + return _snap.TNEGraph_Dump(self, *args) + + __swig_destroy__ = _snap.delete_TNEGraph +TNEGraph.Save = new_instancemethod(_snap.TNEGraph_Save,None,TNEGraph) +TNEGraph.HasFlag = new_instancemethod(_snap.TNEGraph_HasFlag,None,TNEGraph) +TNEGraph.GetNodes = new_instancemethod(_snap.TNEGraph_GetNodes,None,TNEGraph) +TNEGraph.AddNode = new_instancemethod(_snap.TNEGraph_AddNode,None,TNEGraph) +TNEGraph.DelNode = new_instancemethod(_snap.TNEGraph_DelNode,None,TNEGraph) +TNEGraph.IsNode = new_instancemethod(_snap.TNEGraph_IsNode,None,TNEGraph) +TNEGraph.BegNI = new_instancemethod(_snap.TNEGraph_BegNI,None,TNEGraph) +TNEGraph.EndNI = new_instancemethod(_snap.TNEGraph_EndNI,None,TNEGraph) +TNEGraph.GetNI = new_instancemethod(_snap.TNEGraph_GetNI,None,TNEGraph) +TNEGraph.GetMxNId = new_instancemethod(_snap.TNEGraph_GetMxNId,None,TNEGraph) +TNEGraph.GetEdges = new_instancemethod(_snap.TNEGraph_GetEdges,None,TNEGraph) +TNEGraph.AddEdge = new_instancemethod(_snap.TNEGraph_AddEdge,None,TNEGraph) +TNEGraph.DelEdge = new_instancemethod(_snap.TNEGraph_DelEdge,None,TNEGraph) +TNEGraph.IsEdge = new_instancemethod(_snap.TNEGraph_IsEdge,None,TNEGraph) +TNEGraph.GetEId = new_instancemethod(_snap.TNEGraph_GetEId,None,TNEGraph) +TNEGraph.BegEI = new_instancemethod(_snap.TNEGraph_BegEI,None,TNEGraph) +TNEGraph.EndEI = new_instancemethod(_snap.TNEGraph_EndEI,None,TNEGraph) +TNEGraph.GetEI = new_instancemethod(_snap.TNEGraph_GetEI,None,TNEGraph) +TNEGraph.GetRndNId = new_instancemethod(_snap.TNEGraph_GetRndNId,None,TNEGraph) +TNEGraph.GetRndNI = new_instancemethod(_snap.TNEGraph_GetRndNI,None,TNEGraph) +TNEGraph.GetRndEId = new_instancemethod(_snap.TNEGraph_GetRndEId,None,TNEGraph) +TNEGraph.GetRndEI = new_instancemethod(_snap.TNEGraph_GetRndEI,None,TNEGraph) +TNEGraph.GetNIdV = new_instancemethod(_snap.TNEGraph_GetNIdV,None,TNEGraph) +TNEGraph.GetEIdV = new_instancemethod(_snap.TNEGraph_GetEIdV,None,TNEGraph) +TNEGraph.Empty = new_instancemethod(_snap.TNEGraph_Empty,None,TNEGraph) +TNEGraph.Clr = new_instancemethod(_snap.TNEGraph_Clr,None,TNEGraph) +TNEGraph.Reserve = new_instancemethod(_snap.TNEGraph_Reserve,None,TNEGraph) +TNEGraph.Defrag = new_instancemethod(_snap.TNEGraph_Defrag,None,TNEGraph) +TNEGraph.IsOk = new_instancemethod(_snap.TNEGraph_IsOk,None,TNEGraph) +TNEGraph.Dump = new_instancemethod(_snap.TNEGraph_Dump,None,TNEGraph) +TNEGraph_swigregister = _snap.TNEGraph_swigregister +TNEGraph_swigregister(TNEGraph) + +def TNEGraph_New(*args): + """ + New() -> PNEGraph + TNEGraph_New(int const & Nodes, int const & Edges) -> PNEGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNEGraph_New(*args) + +def TNEGraph_Load(*args): + """ + TNEGraph_Load(TSIn SIn) -> PNEGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TNEGraph_Load(*args) + +class TBPGraph(object): + """Proxy of C++ TBPGraph class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + bgsUndef = _snap.TBPGraph_bgsUndef + bgsLeft = _snap.TBPGraph_bgsLeft + bgsRight = _snap.TBPGraph_bgsRight + bgsBoth = _snap.TBPGraph_bgsBoth + def __init__(self, *args): + """ + __init__(TBPGraph self) -> TBPGraph + __init__(TBPGraph self, int const & Nodes, int const & Edges) -> TBPGraph + + Parameters: + Nodes: int const & + Edges: int const & + + __init__(TBPGraph self, TBPGraph BPGraph) -> TBPGraph + + Parameters: + BPGraph: TBPGraph const & + + __init__(TBPGraph self, TSIn SIn) -> TBPGraph + + Parameters: + SIn: TSIn & + + """ + _snap.TBPGraph_swiginit(self,_snap.new_TBPGraph(*args)) + def Save(self, *args): + """ + Save(TBPGraph self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TBPGraph_Save(self, *args) + + def New(*args): + """ + New() -> PBPGraph + New(int const & Nodes, int const & Edges) -> PBPGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TBPGraph_New(*args) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn) -> PBPGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TBPGraph_Load(*args) + + Load = staticmethod(Load) + def GetNodes(self): + """ + GetNodes(TBPGraph self) -> int + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_GetNodes(self) + + def GetLNodes(self): + """ + GetLNodes(TBPGraph self) -> int + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_GetLNodes(self) + + def GetRNodes(self): + """ + GetRNodes(TBPGraph self) -> int + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_GetRNodes(self) + + def AddNode(self, *args): + """ + AddNode(TBPGraph self, int NId=-1, bool const & LeftNode=True) -> int + + Parameters: + NId: int + LeftNode: bool const & + + AddNode(TBPGraph self, int NId=-1) -> int + + Parameters: + NId: int + + AddNode(TBPGraph self) -> int + AddNode(TBPGraph self, TBPGraph::TNodeI const & NodeI) -> int + + Parameters: + NodeI: TBPGraph::TNodeI const & + + """ + return _snap.TBPGraph_AddNode(self, *args) + + def DelNode(self, *args): + """ + DelNode(TBPGraph self, int const & NId) + + Parameters: + NId: int const & + + DelNode(TBPGraph self, TBPGraph::TNode const & NodeI) + + Parameters: + NodeI: TBPGraph::TNode const & + + """ + return _snap.TBPGraph_DelNode(self, *args) + + def IsNode(self, *args): + """ + IsNode(TBPGraph self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TBPGraph_IsNode(self, *args) + + def IsLNode(self, *args): + """ + IsLNode(TBPGraph self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TBPGraph_IsLNode(self, *args) + + def IsRNode(self, *args): + """ + IsRNode(TBPGraph self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TBPGraph_IsRNode(self, *args) + + def GetMxNId(self): + """ + GetMxNId(TBPGraph self) -> int + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_GetMxNId(self) + + def BegNI(self): + """ + BegNI(TBPGraph self) -> TBPGraph::TNodeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_BegNI(self) + + def EndNI(self): + """ + EndNI(TBPGraph self) -> TBPGraph::TNodeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_EndNI(self) + + def GetNI(self, *args): + """ + GetNI(TBPGraph self, int const & NId) -> TBPGraph::TNodeI + + Parameters: + NId: int const & + + """ + return _snap.TBPGraph_GetNI(self, *args) + + def BegLNI(self): + """ + BegLNI(TBPGraph self) -> TBPGraph::TNodeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_BegLNI(self) + + def EndLNI(self): + """ + EndLNI(TBPGraph self) -> TBPGraph::TNodeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_EndLNI(self) + + def BegRNI(self): + """ + BegRNI(TBPGraph self) -> TBPGraph::TNodeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_BegRNI(self) + + def EndRNI(self): + """ + EndRNI(TBPGraph self) -> TBPGraph::TNodeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_EndRNI(self) + + def GetEdges(self): + """ + GetEdges(TBPGraph self) -> int + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_GetEdges(self) + + def AddEdge(self, *args): + """ + AddEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> int + + Parameters: + LeftNId: int const & + RightNId: int const & + + AddEdge(TBPGraph self, TBPGraph::TEdgeI const & EdgeI) -> int + + Parameters: + EdgeI: TBPGraph::TEdgeI const & + + """ + return _snap.TBPGraph_AddEdge(self, *args) + + def DelEdge(self, *args): + """ + DelEdge(TBPGraph self, int const & LeftNId, int const & RightNId) + + Parameters: + LeftNId: int const & + RightNId: int const & + + """ + return _snap.TBPGraph_DelEdge(self, *args) + + def IsEdge(self, *args): + """ + IsEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> bool + + Parameters: + LeftNId: int const & + RightNId: int const & + + """ + return _snap.TBPGraph_IsEdge(self, *args) + + def BegEI(self): + """ + BegEI(TBPGraph self) -> TBPGraph::TEdgeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_BegEI(self) + + def EndEI(self): + """ + EndEI(TBPGraph self) -> TBPGraph::TEdgeI + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_EndEI(self) + + def GetEI(self, *args): + """ + GetEI(TBPGraph self, int const & LeftNId, int const & RightNId) -> TBPGraph::TEdgeI + + Parameters: + LeftNId: int const & + RightNId: int const & + + """ + return _snap.TBPGraph_GetEI(self, *args) + + def GetRndNId(self, *args): + """ + GetRndNId(TBPGraph self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndNId(TBPGraph self) -> int + + Parameters: + self: TBPGraph * + + """ + return _snap.TBPGraph_GetRndNId(self, *args) + + def GetRndLNId(self, *args): + """ + GetRndLNId(TBPGraph self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndLNId(TBPGraph self) -> int + + Parameters: + self: TBPGraph * + + """ + return _snap.TBPGraph_GetRndLNId(self, *args) + + def GetRndRNId(self, *args): + """ + GetRndRNId(TBPGraph self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndRNId(TBPGraph self) -> int + + Parameters: + self: TBPGraph * + + """ + return _snap.TBPGraph_GetRndRNId(self, *args) + + def GetRndNI(self, *args): + """ + GetRndNI(TBPGraph self, TRnd Rnd=Rnd) -> TBPGraph::TNodeI + + Parameters: + Rnd: TRnd & + + GetRndNI(TBPGraph self) -> TBPGraph::TNodeI + + Parameters: + self: TBPGraph * + + """ + return _snap.TBPGraph_GetRndNI(self, *args) + + def GetNIdV(self, *args): + """ + GetNIdV(TBPGraph self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TBPGraph_GetNIdV(self, *args) + + def GetLNIdV(self, *args): + """ + GetLNIdV(TBPGraph self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TBPGraph_GetLNIdV(self, *args) + + def GetRNIdV(self, *args): + """ + GetRNIdV(TBPGraph self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TBPGraph_GetRNIdV(self, *args) + + def Empty(self): + """ + Empty(TBPGraph self) -> bool + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_Empty(self) + + def Clr(self): + """ + Clr(TBPGraph self) + + Parameters: + self: TBPGraph * + + """ + return _snap.TBPGraph_Clr(self) + + def Reserve(self, *args): + """ + Reserve(TBPGraph self, int const & Nodes, int const & Edges) + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TBPGraph_Reserve(self, *args) + + def Defrag(self, OnlyNodeLinks=False): + """ + Defrag(TBPGraph self, bool const & OnlyNodeLinks=False) + + Parameters: + OnlyNodeLinks: bool const & + + Defrag(TBPGraph self) + + Parameters: + self: TBPGraph * + + """ + return _snap.TBPGraph_Defrag(self, OnlyNodeLinks) + + def IsOk(self, ThrowExcept=True): + """ + IsOk(TBPGraph self, bool const & ThrowExcept=True) -> bool + + Parameters: + ThrowExcept: bool const & + + IsOk(TBPGraph self) -> bool + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_IsOk(self, ThrowExcept) + + def Dump(self, *args): + """ + Dump(TBPGraph self, FILE * OutF=stdout) + + Parameters: + OutF: FILE * + + Dump(TBPGraph self) + + Parameters: + self: TBPGraph const * + + """ + return _snap.TBPGraph_Dump(self, *args) + + def GetSmallGraph(): + """GetSmallGraph() -> PBPGraph""" + return _snap.TBPGraph_GetSmallGraph() + + GetSmallGraph = staticmethod(GetSmallGraph) + __swig_destroy__ = _snap.delete_TBPGraph +TBPGraph.Save = new_instancemethod(_snap.TBPGraph_Save,None,TBPGraph) +TBPGraph.GetNodes = new_instancemethod(_snap.TBPGraph_GetNodes,None,TBPGraph) +TBPGraph.GetLNodes = new_instancemethod(_snap.TBPGraph_GetLNodes,None,TBPGraph) +TBPGraph.GetRNodes = new_instancemethod(_snap.TBPGraph_GetRNodes,None,TBPGraph) +TBPGraph.AddNode = new_instancemethod(_snap.TBPGraph_AddNode,None,TBPGraph) +TBPGraph.DelNode = new_instancemethod(_snap.TBPGraph_DelNode,None,TBPGraph) +TBPGraph.IsNode = new_instancemethod(_snap.TBPGraph_IsNode,None,TBPGraph) +TBPGraph.IsLNode = new_instancemethod(_snap.TBPGraph_IsLNode,None,TBPGraph) +TBPGraph.IsRNode = new_instancemethod(_snap.TBPGraph_IsRNode,None,TBPGraph) +TBPGraph.GetMxNId = new_instancemethod(_snap.TBPGraph_GetMxNId,None,TBPGraph) +TBPGraph.BegNI = new_instancemethod(_snap.TBPGraph_BegNI,None,TBPGraph) +TBPGraph.EndNI = new_instancemethod(_snap.TBPGraph_EndNI,None,TBPGraph) +TBPGraph.GetNI = new_instancemethod(_snap.TBPGraph_GetNI,None,TBPGraph) +TBPGraph.BegLNI = new_instancemethod(_snap.TBPGraph_BegLNI,None,TBPGraph) +TBPGraph.EndLNI = new_instancemethod(_snap.TBPGraph_EndLNI,None,TBPGraph) +TBPGraph.BegRNI = new_instancemethod(_snap.TBPGraph_BegRNI,None,TBPGraph) +TBPGraph.EndRNI = new_instancemethod(_snap.TBPGraph_EndRNI,None,TBPGraph) +TBPGraph.GetEdges = new_instancemethod(_snap.TBPGraph_GetEdges,None,TBPGraph) +TBPGraph.AddEdge = new_instancemethod(_snap.TBPGraph_AddEdge,None,TBPGraph) +TBPGraph.DelEdge = new_instancemethod(_snap.TBPGraph_DelEdge,None,TBPGraph) +TBPGraph.IsEdge = new_instancemethod(_snap.TBPGraph_IsEdge,None,TBPGraph) +TBPGraph.BegEI = new_instancemethod(_snap.TBPGraph_BegEI,None,TBPGraph) +TBPGraph.EndEI = new_instancemethod(_snap.TBPGraph_EndEI,None,TBPGraph) +TBPGraph.GetEI = new_instancemethod(_snap.TBPGraph_GetEI,None,TBPGraph) +TBPGraph.GetRndNId = new_instancemethod(_snap.TBPGraph_GetRndNId,None,TBPGraph) +TBPGraph.GetRndLNId = new_instancemethod(_snap.TBPGraph_GetRndLNId,None,TBPGraph) +TBPGraph.GetRndRNId = new_instancemethod(_snap.TBPGraph_GetRndRNId,None,TBPGraph) +TBPGraph.GetRndNI = new_instancemethod(_snap.TBPGraph_GetRndNI,None,TBPGraph) +TBPGraph.GetNIdV = new_instancemethod(_snap.TBPGraph_GetNIdV,None,TBPGraph) +TBPGraph.GetLNIdV = new_instancemethod(_snap.TBPGraph_GetLNIdV,None,TBPGraph) +TBPGraph.GetRNIdV = new_instancemethod(_snap.TBPGraph_GetRNIdV,None,TBPGraph) +TBPGraph.Empty = new_instancemethod(_snap.TBPGraph_Empty,None,TBPGraph) +TBPGraph.Clr = new_instancemethod(_snap.TBPGraph_Clr,None,TBPGraph) +TBPGraph.Reserve = new_instancemethod(_snap.TBPGraph_Reserve,None,TBPGraph) +TBPGraph.Defrag = new_instancemethod(_snap.TBPGraph_Defrag,None,TBPGraph) +TBPGraph.IsOk = new_instancemethod(_snap.TBPGraph_IsOk,None,TBPGraph) +TBPGraph.Dump = new_instancemethod(_snap.TBPGraph_Dump,None,TBPGraph) +TBPGraph_swigregister = _snap.TBPGraph_swigregister +TBPGraph_swigregister(TBPGraph) + +def TBPGraph_New(*args): + """ + New() -> PBPGraph + TBPGraph_New(int const & Nodes, int const & Edges) -> PBPGraph + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TBPGraph_New(*args) + +def TBPGraph_Load(*args): + """ + TBPGraph_Load(TSIn SIn) -> PBPGraph + + Parameters: + SIn: TSIn & + + """ + return _snap.TBPGraph_Load(*args) + +def TBPGraph_GetSmallGraph(): + """TBPGraph_GetSmallGraph() -> PBPGraph""" + return _snap.TBPGraph_GetSmallGraph() + +class TNGraphMtx(object): + """Proxy of C++ TNGraphMtx class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNGraphMtx self, PNGraph const & GraphPt) -> TNGraphMtx + + Parameters: + GraphPt: PNGraph const & + + __init__(TNGraphMtx self, TNGraphMtx GraphMtx) -> TNGraphMtx + + Parameters: + GraphMtx: TNGraphMtx const & + + """ + _snap.TNGraphMtx_swiginit(self,_snap.new_TNGraphMtx(*args)) + def PGetRows(self): + """ + PGetRows(TNGraphMtx self) -> int + + Parameters: + self: TNGraphMtx const * + + """ + return _snap.TNGraphMtx_PGetRows(self) + + def PGetCols(self): + """ + PGetCols(TNGraphMtx self) -> int + + Parameters: + self: TNGraphMtx const * + + """ + return _snap.TNGraphMtx_PGetCols(self) + + def PMultiply(self, *args): + """ + PMultiply(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result) + + Parameters: + B: TFltVV const & + ColId: int + Result: TFltV & + + PMultiply(TNGraphMtx self, TFltV const & Vec, TFltV & Result) + + Parameters: + Vec: TFltV const & + Result: TFltV & + + """ + return _snap.TNGraphMtx_PMultiply(self, *args) + + def PMultiplyT(self, *args): + """ + PMultiplyT(TNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result) + + Parameters: + B: TFltVV const & + ColId: int + Result: TFltV & + + PMultiplyT(TNGraphMtx self, TFltV const & Vec, TFltV & Result) + + Parameters: + Vec: TFltV const & + Result: TFltV & + + """ + return _snap.TNGraphMtx_PMultiplyT(self, *args) + + __swig_destroy__ = _snap.delete_TNGraphMtx +TNGraphMtx.PGetRows = new_instancemethod(_snap.TNGraphMtx_PGetRows,None,TNGraphMtx) +TNGraphMtx.PGetCols = new_instancemethod(_snap.TNGraphMtx_PGetCols,None,TNGraphMtx) +TNGraphMtx.PMultiply = new_instancemethod(_snap.TNGraphMtx_PMultiply,None,TNGraphMtx) +TNGraphMtx.PMultiplyT = new_instancemethod(_snap.TNGraphMtx_PMultiplyT,None,TNGraphMtx) +TNGraphMtx_swigregister = _snap.TNGraphMtx_swigregister +TNGraphMtx_swigregister(TNGraphMtx) + +class TUNGraphMtx(object): + """Proxy of C++ TUNGraphMtx class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TUNGraphMtx self, PUNGraph const & GraphPt) -> TUNGraphMtx + + Parameters: + GraphPt: PUNGraph const & + + __init__(TUNGraphMtx self, TUNGraphMtx GraphMtx) -> TUNGraphMtx + + Parameters: + GraphMtx: TUNGraphMtx const & + + """ + _snap.TUNGraphMtx_swiginit(self,_snap.new_TUNGraphMtx(*args)) + def PGetRows(self): + """ + PGetRows(TUNGraphMtx self) -> int + + Parameters: + self: TUNGraphMtx const * + + """ + return _snap.TUNGraphMtx_PGetRows(self) + + def PGetCols(self): + """ + PGetCols(TUNGraphMtx self) -> int + + Parameters: + self: TUNGraphMtx const * + + """ + return _snap.TUNGraphMtx_PGetCols(self) + + def PMultiply(self, *args): + """ + PMultiply(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result) + + Parameters: + B: TFltVV const & + ColId: int + Result: TFltV & + + PMultiply(TUNGraphMtx self, TFltV const & Vec, TFltV & Result) + + Parameters: + Vec: TFltV const & + Result: TFltV & + + """ + return _snap.TUNGraphMtx_PMultiply(self, *args) + + def PMultiplyT(self, *args): + """ + PMultiplyT(TUNGraphMtx self, TFltVV const & B, int ColId, TFltV & Result) + + Parameters: + B: TFltVV const & + ColId: int + Result: TFltV & + + PMultiplyT(TUNGraphMtx self, TFltV const & Vec, TFltV & Result) + + Parameters: + Vec: TFltV const & + Result: TFltV & + + """ + return _snap.TUNGraphMtx_PMultiplyT(self, *args) + + __swig_destroy__ = _snap.delete_TUNGraphMtx +TUNGraphMtx.PGetRows = new_instancemethod(_snap.TUNGraphMtx_PGetRows,None,TUNGraphMtx) +TUNGraphMtx.PGetCols = new_instancemethod(_snap.TUNGraphMtx_PGetCols,None,TUNGraphMtx) +TUNGraphMtx.PMultiply = new_instancemethod(_snap.TUNGraphMtx_PMultiply,None,TUNGraphMtx) +TUNGraphMtx.PMultiplyT = new_instancemethod(_snap.TUNGraphMtx_PMultiplyT,None,TUNGraphMtx) +TUNGraphMtx_swigregister = _snap.TUNGraphMtx_swigregister +TUNGraphMtx_swigregister(TUNGraphMtx) + + +def GetSngVals(*args): + """ + GetSngVals(PNGraph const & Graph, int const & SngVals, TFltV & SngValV) + + Parameters: + Graph: PNGraph const & + SngVals: int const & + SngValV: TFltV & + + """ + return _snap.GetSngVals(*args) + +def GetSngVec(*args): + """ + GetSngVec(PNGraph const & Graph, TFltV & LeftSV, TFltV & RightSV) + + Parameters: + Graph: PNGraph const & + LeftSV: TFltV & + RightSV: TFltV & + + GetSngVec(PNGraph const & Graph, int const & SngVecs, TFltV & SngValV, TVec< TFltV > & LeftSV, + TVec< TFltV > & RightSV) + + Parameters: + Graph: PNGraph const & + SngVecs: int const & + SngValV: TFltV & + LeftSV: TVec< TFltV > & + RightSV: TVec< TFltV > & + + """ + return _snap.GetSngVec(*args) + +def GetEigVals(*args): + """ + GetEigVals(PUNGraph const & Graph, int const & EigVals, TFltV & EigValV) + + Parameters: + Graph: PUNGraph const & + EigVals: int const & + EigValV: TFltV & + + """ + return _snap.GetEigVals(*args) + +def GetEigVec(*args): + """ + GetEigVec(PUNGraph const & Graph, TFltV & EigVecV) + + Parameters: + Graph: PUNGraph const & + EigVecV: TFltV & + + GetEigVec(PUNGraph const & Graph, int const & EigVecs, TFltV & EigValV, TVec< TFltV > & EigVecV) + + Parameters: + Graph: PUNGraph const & + EigVecs: int const & + EigValV: TFltV & + EigVecV: TVec< TFltV > & + + """ + return _snap.GetEigVec(*args) + +def GetInvParticipRat(*args): + """ + GetInvParticipRat(PUNGraph const & Graph, int MaxEigVecs, int TimeLimit, TFltPrV & EigValIprV) + + Parameters: + Graph: PUNGraph const & + MaxEigVecs: int + TimeLimit: int + EigValIprV: TFltPrV & + + """ + return _snap.GetInvParticipRat(*args) + +def GetInvParticipRatEig(*args): + """ + GetInvParticipRatEig(TFltV const & EigVec) -> double + + Parameters: + EigVec: TFltV const & + + """ + return _snap.GetInvParticipRatEig(*args) + +def LoadDyNet(*args): + """ + LoadDyNet(TStr FNm) -> PNGraph + + Parameters: + FNm: TStr const & + + """ + return _snap.LoadDyNet(*args) + +def LoadDyNetGraphV(*args): + """ + LoadDyNetGraphV(TStr FNm) -> TVec< PNGraph > + + Parameters: + FNm: TStr const & + + """ + return _snap.LoadDyNetGraphV(*args) +gvlDot = _snap.gvlDot +gvlNeato = _snap.gvlNeato +gvlTwopi = _snap.gvlTwopi +gvlCirco = _snap.gvlCirco + +def GVizDoLayout(*args): + """ + GVizDoLayout(TStr GraphInFNm, TStr OutFNm, TGVizLayout const & Layout) + + Parameters: + GraphInFNm: TStr const & + OutFNm: TStr + Layout: TGVizLayout const & + + """ + return _snap.GVizDoLayout(*args) + +def GVizGetLayoutStr(*args): + """ + GVizGetLayoutStr(TGVizLayout const & Layout) -> TStr + + Parameters: + Layout: TGVizLayout const & + + """ + return _snap.GVizGetLayoutStr(*args) +class TBigStrPool(object): + """Proxy of C++ TBigStrPool class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TBigStrPool self, TSize MxBfLen=0, uint _GrowBy=16*1024*1024) -> TBigStrPool + + Parameters: + MxBfLen: TSize + _GrowBy: uint + + __init__(TBigStrPool self, TSize MxBfLen=0) -> TBigStrPool + + Parameters: + MxBfLen: TSize + + __init__(TBigStrPool self) -> TBigStrPool + __init__(TBigStrPool self, TSIn SIn, bool LoadCompact=True) -> TBigStrPool + + Parameters: + SIn: TSIn & + LoadCompact: bool + + __init__(TBigStrPool self, TSIn SIn) -> TBigStrPool + + Parameters: + SIn: TSIn & + + __init__(TBigStrPool self, TBigStrPool Pool) -> TBigStrPool + + Parameters: + Pool: TBigStrPool const & + + """ + _snap.TBigStrPool_swiginit(self,_snap.new_TBigStrPool(*args)) + __swig_destroy__ = _snap.delete_TBigStrPool + def New(*args): + """ + New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool + + Parameters: + _MxBfLen: TSize + _GrowBy: uint + + New(TSize _MxBfLen=0) -> PBigStrPool + + Parameters: + _MxBfLen: TSize + + New() -> PBigStrPool + New(TSIn SIn) -> PBigStrPool + + Parameters: + SIn: TSIn & + + New(TStr fileName) -> PBigStrPool + + Parameters: + fileName: TStr const & + + """ + return _snap.TBigStrPool_New(*args) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool + + Parameters: + SIn: TSIn & + LoadCompacted: bool + + Load(TSIn SIn) -> PBigStrPool + + Parameters: + SIn: TSIn & + + """ + return _snap.TBigStrPool_Load(*args) + + Load = staticmethod(Load) + def Save(self, *args): + """ + Save(TBigStrPool self, TSOut SOut) + + Parameters: + SOut: TSOut & + + Save(TBigStrPool self, TStr fileName) + + Parameters: + fileName: TStr const & + + """ + return _snap.TBigStrPool_Save(self, *args) + + def GetStrs(self): + """ + GetStrs(TBigStrPool self) -> int + + Parameters: + self: TBigStrPool const * + + """ + return _snap.TBigStrPool_GetStrs(self) + + def Len(self): + """ + Len(TBigStrPool self) -> TSize + + Parameters: + self: TBigStrPool const * + + """ + return _snap.TBigStrPool_Len(self) + + def Size(self): + """ + Size(TBigStrPool self) -> TSize + + Parameters: + self: TBigStrPool const * + + """ + return _snap.TBigStrPool_Size(self) + + def Empty(self): + """ + Empty(TBigStrPool self) -> bool + + Parameters: + self: TBigStrPool const * + + """ + return _snap.TBigStrPool_Empty(self) + + def __call__(self): + """ + __call__(TBigStrPool self) -> char * + + Parameters: + self: TBigStrPool const * + + """ + return _snap.TBigStrPool___call__(self) + + def AddStr(self, *args): + """ + AddStr(TBigStrPool self, char const * Str, uint Len) -> int + + Parameters: + Str: char const * + Len: uint + + AddStr(TBigStrPool self, char const * Str) -> int + + Parameters: + Str: char const * + + AddStr(TBigStrPool self, TStr Str) -> int + + Parameters: + Str: TStr const & + + """ + return _snap.TBigStrPool_AddStr(self, *args) + + def GetCStr(self, *args): + """ + GetCStr(TBigStrPool self, int const & StrId) -> char const * + + Parameters: + StrId: int const & + + """ + return _snap.TBigStrPool_GetCStr(self, *args) + + def GetStrFromOffset(self, *args): + """ + GetStrFromOffset(TBigStrPool self, TSize const & Offset) -> TStr + + Parameters: + Offset: TSize const & + + """ + return _snap.TBigStrPool_GetStrFromOffset(self, *args) + + def GetCStrFromOffset(self, *args): + """ + GetCStrFromOffset(TBigStrPool self, TSize const & Offset) -> char const * + + Parameters: + Offset: TSize const & + + """ + return _snap.TBigStrPool_GetCStrFromOffset(self, *args) + + def Clr(self, DoDel=False): + """ + Clr(TBigStrPool self, bool DoDel=False) + + Parameters: + DoDel: bool + + Clr(TBigStrPool self) + + Parameters: + self: TBigStrPool * + + """ + return _snap.TBigStrPool_Clr(self, DoDel) + + def Cmp(self, *args): + """ + Cmp(TBigStrPool self, int const & StrId, char const * Str) -> int + + Parameters: + StrId: int const & + Str: char const * + + """ + return _snap.TBigStrPool_Cmp(self, *args) + + def GetPrimHashCd(self, *args): + """ + GetPrimHashCd(TBigStrPool self, char const * CStr) -> int + + Parameters: + CStr: char const * + + GetPrimHashCd(TBigStrPool self, int const & StrId) -> int + + Parameters: + StrId: int const & + + """ + return _snap.TBigStrPool_GetPrimHashCd(self, *args) + + def GetSecHashCd(self, *args): + """ + GetSecHashCd(TBigStrPool self, char const * CStr) -> int + + Parameters: + CStr: char const * + + GetSecHashCd(TBigStrPool self, int const & StrId) -> int + + Parameters: + StrId: int const & + + """ + return _snap.TBigStrPool_GetSecHashCd(self, *args) + +TBigStrPool.Save = new_instancemethod(_snap.TBigStrPool_Save,None,TBigStrPool) +TBigStrPool.GetStrs = new_instancemethod(_snap.TBigStrPool_GetStrs,None,TBigStrPool) +TBigStrPool.Len = new_instancemethod(_snap.TBigStrPool_Len,None,TBigStrPool) +TBigStrPool.Size = new_instancemethod(_snap.TBigStrPool_Size,None,TBigStrPool) +TBigStrPool.Empty = new_instancemethod(_snap.TBigStrPool_Empty,None,TBigStrPool) +TBigStrPool.__call__ = new_instancemethod(_snap.TBigStrPool___call__,None,TBigStrPool) +TBigStrPool.AddStr = new_instancemethod(_snap.TBigStrPool_AddStr,None,TBigStrPool) +TBigStrPool.GetCStr = new_instancemethod(_snap.TBigStrPool_GetCStr,None,TBigStrPool) +TBigStrPool.GetStrFromOffset = new_instancemethod(_snap.TBigStrPool_GetStrFromOffset,None,TBigStrPool) +TBigStrPool.GetCStrFromOffset = new_instancemethod(_snap.TBigStrPool_GetCStrFromOffset,None,TBigStrPool) +TBigStrPool.Clr = new_instancemethod(_snap.TBigStrPool_Clr,None,TBigStrPool) +TBigStrPool.Cmp = new_instancemethod(_snap.TBigStrPool_Cmp,None,TBigStrPool) +TBigStrPool.GetPrimHashCd = new_instancemethod(_snap.TBigStrPool_GetPrimHashCd,None,TBigStrPool) +TBigStrPool.GetSecHashCd = new_instancemethod(_snap.TBigStrPool_GetSecHashCd,None,TBigStrPool) +TBigStrPool_swigregister = _snap.TBigStrPool_swigregister +TBigStrPool_swigregister(TBigStrPool) + +def TBigStrPool_New(*args): + """ + New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool + + Parameters: + _MxBfLen: TSize + _GrowBy: uint + + New(TSize _MxBfLen=0) -> PBigStrPool + + Parameters: + _MxBfLen: TSize + + New() -> PBigStrPool + New(TSIn SIn) -> PBigStrPool + + Parameters: + SIn: TSIn & + + TBigStrPool_New(TStr fileName) -> PBigStrPool + + Parameters: + fileName: TStr const & + + """ + return _snap.TBigStrPool_New(*args) + +def TBigStrPool_Load(*args): + """ + Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool + + Parameters: + SIn: TSIn & + LoadCompacted: bool + + TBigStrPool_Load(TSIn SIn) -> PBigStrPool + + Parameters: + SIn: TSIn & + + """ + return _snap.TBigStrPool_Load(*args) + +class TStrHashF_OldGLib(object): + """Proxy of C++ TStrHashF_OldGLib class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def GetPrimHashCd(*args): + """ + GetPrimHashCd(char const * p) -> int + + Parameters: + p: char const * + + GetPrimHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_OldGLib_GetPrimHashCd(*args) + + GetPrimHashCd = staticmethod(GetPrimHashCd) + def GetSecHashCd(*args): + """ + GetSecHashCd(char const * p) -> int + + Parameters: + p: char const * + + GetSecHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_OldGLib_GetSecHashCd(*args) + + GetSecHashCd = staticmethod(GetSecHashCd) + def __init__(self): + """__init__(TStrHashF_OldGLib self) -> TStrHashF_OldGLib""" + _snap.TStrHashF_OldGLib_swiginit(self,_snap.new_TStrHashF_OldGLib()) + __swig_destroy__ = _snap.delete_TStrHashF_OldGLib +TStrHashF_OldGLib_swigregister = _snap.TStrHashF_OldGLib_swigregister +TStrHashF_OldGLib_swigregister(TStrHashF_OldGLib) + +def TStrHashF_OldGLib_GetPrimHashCd(*args): + """ + GetPrimHashCd(char const * p) -> int + + Parameters: + p: char const * + + TStrHashF_OldGLib_GetPrimHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_OldGLib_GetPrimHashCd(*args) + +def TStrHashF_OldGLib_GetSecHashCd(*args): + """ + GetSecHashCd(char const * p) -> int + + Parameters: + p: char const * + + TStrHashF_OldGLib_GetSecHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_OldGLib_GetSecHashCd(*args) + +class TStrHashF_Md5(object): + """Proxy of C++ TStrHashF_Md5 class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def GetPrimHashCd(*args): + """ + GetPrimHashCd(char const * p) -> int + + Parameters: + p: char const * + + GetPrimHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_Md5_GetPrimHashCd(*args) + + GetPrimHashCd = staticmethod(GetPrimHashCd) + def GetSecHashCd(*args): + """ + GetSecHashCd(char const * p) -> int + + Parameters: + p: char const * + + GetSecHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_Md5_GetSecHashCd(*args) + + GetSecHashCd = staticmethod(GetSecHashCd) + def __init__(self): + """__init__(TStrHashF_Md5 self) -> TStrHashF_Md5""" + _snap.TStrHashF_Md5_swiginit(self,_snap.new_TStrHashF_Md5()) + __swig_destroy__ = _snap.delete_TStrHashF_Md5 +TStrHashF_Md5_swigregister = _snap.TStrHashF_Md5_swigregister +TStrHashF_Md5_swigregister(TStrHashF_Md5) + +def TStrHashF_Md5_GetPrimHashCd(*args): + """ + GetPrimHashCd(char const * p) -> int + + Parameters: + p: char const * + + TStrHashF_Md5_GetPrimHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_Md5_GetPrimHashCd(*args) + +def TStrHashF_Md5_GetSecHashCd(*args): + """ + GetSecHashCd(char const * p) -> int + + Parameters: + p: char const * + + TStrHashF_Md5_GetSecHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_Md5_GetSecHashCd(*args) + +class TStrHashF_DJB(object): + """Proxy of C++ TStrHashF_DJB class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def GetPrimHashCd(*args): + """ + GetPrimHashCd(char const * p) -> int + + Parameters: + p: char const * + + GetPrimHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_DJB_GetPrimHashCd(*args) + + GetPrimHashCd = staticmethod(GetPrimHashCd) + def GetSecHashCd(*args): + """ + GetSecHashCd(char const * p) -> int + + Parameters: + p: char const * + + GetSecHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_DJB_GetSecHashCd(*args) + + GetSecHashCd = staticmethod(GetSecHashCd) + def __init__(self): + """__init__(TStrHashF_DJB self) -> TStrHashF_DJB""" + _snap.TStrHashF_DJB_swiginit(self,_snap.new_TStrHashF_DJB()) + __swig_destroy__ = _snap.delete_TStrHashF_DJB +TStrHashF_DJB_swigregister = _snap.TStrHashF_DJB_swigregister +TStrHashF_DJB_swigregister(TStrHashF_DJB) + +def TStrHashF_DJB_GetPrimHashCd(*args): + """ + GetPrimHashCd(char const * p) -> int + + Parameters: + p: char const * + + TStrHashF_DJB_GetPrimHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_DJB_GetPrimHashCd(*args) + +def TStrHashF_DJB_GetSecHashCd(*args): + """ + GetSecHashCd(char const * p) -> int + + Parameters: + p: char const * + + TStrHashF_DJB_GetSecHashCd(TStr s) -> int + + Parameters: + s: TStr const & + + """ + return _snap.TStrHashF_DJB_GetSecHashCd(*args) + + +def GenRndBipart(*args): + """ + GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges, TRnd Rnd=Rnd) -> PBPGraph + + Parameters: + LeftNodes: int const & + RightNodes: int const & + Edges: int const & + Rnd: TRnd & + + GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges) -> PBPGraph + + Parameters: + LeftNodes: int const & + RightNodes: int const & + Edges: int const & + + """ + return _snap.GenRndBipart(*args) + +def GenRndDegK(*args): + """ + GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + Nodes: int const & + NodeDeg: int const & + NSwitch: int const & + Rnd: TRnd & + + GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100) -> PUNGraph + + Parameters: + Nodes: int const & + NodeDeg: int const & + NSwitch: int const & + + GenRndDegK(int const & Nodes, int const & NodeDeg) -> PUNGraph + + Parameters: + Nodes: int const & + NodeDeg: int const & + + """ + return _snap.GenRndDegK(*args) + +def GenRndPowerLaw(*args): + """ + GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + Nodes: int const & + PowerExp: double const & + ConfModel: bool const & + Rnd: TRnd & + + GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True) -> PUNGraph + + Parameters: + Nodes: int const & + PowerExp: double const & + ConfModel: bool const & + + GenRndPowerLaw(int const & Nodes, double const & PowerExp) -> PUNGraph + + Parameters: + Nodes: int const & + PowerExp: double const & + + """ + return _snap.GenRndPowerLaw(*args) + +def GenDegSeq(*args): + """ + GenDegSeq(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + DegSeqV: TIntV const & + Rnd: TRnd & + + GenDegSeq(TIntV DegSeqV) -> PUNGraph + + Parameters: + DegSeqV: TIntV const & + + """ + return _snap.GenDegSeq(*args) + +def GenPrefAttach(*args): + """ + GenPrefAttach(int const & Nodes, int const & NodeOutDeg, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + Nodes: int const & + NodeOutDeg: int const & + Rnd: TRnd & + + GenPrefAttach(int const & Nodes, int const & NodeOutDeg) -> PUNGraph + + Parameters: + Nodes: int const & + NodeOutDeg: int const & + + """ + return _snap.GenPrefAttach(*args) + +def GenGeoPrefAttach(*args): + """ + GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + Nodes: int const & + OutDeg: int const & + Beta: double const & + Rnd: TRnd & + + GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta) -> PUNGraph + + Parameters: + Nodes: int const & + OutDeg: int const & + Beta: double const & + + """ + return _snap.GenGeoPrefAttach(*args) + +def GenSmallWorld(*args): + """ + GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + Nodes: int const & + NodeOutDeg: int const & + RewireProb: double const & + Rnd: TRnd & + + GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb) -> PUNGraph + + Parameters: + Nodes: int const & + NodeOutDeg: int const & + RewireProb: double const & + + """ + return _snap.GenSmallWorld(*args) + +def GenForestFire(*args): + """ + GenForestFire(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph + + Parameters: + Nodes: int const & + FwdProb: double const & + BckProb: double const & + + """ + return _snap.GenForestFire(*args) + +def GenCopyModel(*args): + """ + GenCopyModel(int const & Nodes, double const & Beta, TRnd Rnd=Rnd) -> PNGraph + + Parameters: + Nodes: int const & + Beta: double const & + Rnd: TRnd & + + GenCopyModel(int const & Nodes, double const & Beta) -> PNGraph + + Parameters: + Nodes: int const & + Beta: double const & + + """ + return _snap.GenCopyModel(*args) + +def GenRMat(*args): + """ + GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C, + TRnd Rnd=Rnd) -> PNGraph + + Parameters: + Nodes: int const & + Edges: int const & + A: double const & + B: double const & + C: double const & + Rnd: TRnd & + + GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C) -> PNGraph + + Parameters: + Nodes: int const & + Edges: int const & + A: double const & + B: double const & + C: double const & + + """ + return _snap.GenRMat(*args) + +def GenRMatEpinions(): + """GenRMatEpinions() -> PNGraph""" + return _snap.GenRMatEpinions() + +def GenRewire(*args): + """ + GenRewire(PUNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + Graph: PUNGraph const & + NSwitch: int const & + Rnd: TRnd & + + GenRewire(PUNGraph const & Graph, int const & NSwitch=100) -> PUNGraph + + Parameters: + Graph: PUNGraph const & + NSwitch: int const & + + GenRewire(PUNGraph const & Graph) -> PUNGraph + + Parameters: + Graph: PUNGraph const & + + GenRewire(PNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PNGraph + + Parameters: + Graph: PNGraph const & + NSwitch: int const & + Rnd: TRnd & + + GenRewire(PNGraph const & Graph, int const & NSwitch=100) -> PNGraph + + Parameters: + Graph: PNGraph const & + NSwitch: int const & + + GenRewire(PNGraph const & Graph) -> PNGraph + + Parameters: + Graph: PNGraph const & + + GenRewire(PBPGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PBPGraph + + Parameters: + Graph: PBPGraph const & + NSwitch: int const & + Rnd: TRnd & + + GenRewire(PBPGraph const & Graph, int const & NSwitch=100) -> PBPGraph + + Parameters: + Graph: PBPGraph const & + NSwitch: int const & + + GenRewire(PBPGraph const & Graph) -> PBPGraph + + Parameters: + Graph: PBPGraph const & + + """ + return _snap.GenRewire(*args) + +def GenConfModel(*args): + """ + GenConfModel(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph + + Parameters: + DegSeqV: TIntV const & + Rnd: TRnd & + + GenConfModel(TIntV DegSeqV) -> PUNGraph + + Parameters: + DegSeqV: TIntV const & + + GenConfModel(PUNGraph const & G) -> PUNGraph + + Parameters: + G: PUNGraph const & + + """ + return _snap.GenConfModel(*args) + +def GetSubGraph(*args): + """ + GetSubGraph(PUNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PUNGraph + + Parameters: + Graph: PUNGraph const & + NIdV: TIntV const & + RenumberNodes: bool const & + + GetSubGraph(PUNGraph const & Graph, TIntV NIdV) -> PUNGraph + + Parameters: + Graph: PUNGraph const & + NIdV: TIntV const & + + GetSubGraph(PNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PNGraph + + Parameters: + Graph: PNGraph const & + NIdV: TIntV const & + RenumberNodes: bool const & + + GetSubGraph(PNGraph const & Graph, TIntV NIdV) -> PNGraph + + Parameters: + Graph: PNGraph const & + NIdV: TIntV const & + + """ + return _snap.GetSubGraph(*args) +class TGUtil(object): + """Proxy of C++ TGUtil class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def GetCdf(*args): + """ + GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV) + + Parameters: + PdfV: TIntPrV const & + CdfV: TIntPrV & + + GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV) + + Parameters: + PdfV: TFltPrV const & + CdfV: TFltPrV & + + GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV) + + Parameters: + PdfV: TIntFltKdV const & + CdfV: TIntFltKdV & + + GetCdf(TIntPrV const & PdfV) -> TIntPrV + + Parameters: + PdfV: TIntPrV const & + + GetCdf(TFltPrV const & PdfV) -> TFltPrV + + Parameters: + PdfV: TFltPrV const & + + """ + return _snap.TGUtil_GetCdf(*args) + + GetCdf = staticmethod(GetCdf) + def GetCCdf(*args): + """ + GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV) + + Parameters: + PdfV: TIntPrV const & + CCdfV: TIntPrV & + + GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV) + + Parameters: + PdfV: TFltPrV const & + CCdfV: TFltPrV & + + GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV) + + Parameters: + PdfV: TIntFltKdV const & + CCdfV: TIntFltKdV & + + GetCCdf(TIntPrV const & PdfV) -> TIntPrV + + Parameters: + PdfV: TIntPrV const & + + GetCCdf(TFltPrV const & PdfV) -> TFltPrV + + Parameters: + PdfV: TFltPrV const & + + """ + return _snap.TGUtil_GetCCdf(*args) + + GetCCdf = staticmethod(GetCCdf) + def GetPdf(*args): + """ + GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV) + + Parameters: + CdfV: TIntPrV const & + PdfV: TIntPrV & + + GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV) + + Parameters: + CdfV: TFltPrV const & + PdfV: TFltPrV & + + GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV) + + Parameters: + CdfV: TIntFltKdV const & + PdfV: TIntFltKdV & + + """ + return _snap.TGUtil_GetPdf(*args) + + GetPdf = staticmethod(GetPdf) + def Normalize(*args): + """ + Normalize(TFltPrV & PdfV) + + Parameters: + PdfV: TFltPrV & + + Normalize(TIntFltKdV & PdfV) + + Parameters: + PdfV: TIntFltKdV & + + """ + return _snap.TGUtil_Normalize(*args) + + Normalize = staticmethod(Normalize) + def MakeExpBins(*args): + """ + MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1) + + Parameters: + XYValV: TFltPrV const & + ExpXYValV: TFltPrV & + BinFactor: double const & + MinYVal: double const & + + MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2) + + Parameters: + XYValV: TFltPrV const & + ExpXYValV: TFltPrV & + BinFactor: double const & + + MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV) + + Parameters: + XYValV: TFltPrV const & + ExpXYValV: TFltPrV & + + MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1) + + Parameters: + XYValV: TFltKdV const & + ExpXYValV: TFltKdV & + BinFactor: double const & + MinYVal: double const & + + MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2) + + Parameters: + XYValV: TFltKdV const & + ExpXYValV: TFltKdV & + BinFactor: double const & + + MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV) + + Parameters: + XYValV: TFltKdV const & + ExpXYValV: TFltKdV & + + MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01) + + Parameters: + YValV: TFltV const & + ExpYValV: TFltV & + BinFactor: double const & + + MakeExpBins(TFltV const & YValV, TFltV & ExpYValV) + + Parameters: + YValV: TFltV const & + ExpYValV: TFltV & + + MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01) + + Parameters: + YValV: TIntV const & + ExpYValV: TIntV & + BinFactor: double const & + + MakeExpBins(TIntV YValV, TIntV ExpYValV) + + Parameters: + YValV: TIntV const & + ExpYValV: TIntV & + + """ + return _snap.TGUtil_MakeExpBins(*args) + + MakeExpBins = staticmethod(MakeExpBins) + def __init__(self): + """__init__(TGUtil self) -> TGUtil""" + _snap.TGUtil_swiginit(self,_snap.new_TGUtil()) + __swig_destroy__ = _snap.delete_TGUtil +TGUtil_swigregister = _snap.TGUtil_swigregister +TGUtil_swigregister(TGUtil) + +def TGUtil_GetCdf(*args): + """ + GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV) + + Parameters: + PdfV: TIntPrV const & + CdfV: TIntPrV & + + GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV) + + Parameters: + PdfV: TFltPrV const & + CdfV: TFltPrV & + + GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV) + + Parameters: + PdfV: TIntFltKdV const & + CdfV: TIntFltKdV & + + GetCdf(TIntPrV const & PdfV) -> TIntPrV + + Parameters: + PdfV: TIntPrV const & + + TGUtil_GetCdf(TFltPrV const & PdfV) -> TFltPrV + + Parameters: + PdfV: TFltPrV const & + + """ + return _snap.TGUtil_GetCdf(*args) + +def TGUtil_GetCCdf(*args): + """ + GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV) + + Parameters: + PdfV: TIntPrV const & + CCdfV: TIntPrV & + + GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV) + + Parameters: + PdfV: TFltPrV const & + CCdfV: TFltPrV & + + GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV) + + Parameters: + PdfV: TIntFltKdV const & + CCdfV: TIntFltKdV & + + GetCCdf(TIntPrV const & PdfV) -> TIntPrV + + Parameters: + PdfV: TIntPrV const & + + TGUtil_GetCCdf(TFltPrV const & PdfV) -> TFltPrV + + Parameters: + PdfV: TFltPrV const & + + """ + return _snap.TGUtil_GetCCdf(*args) + +def TGUtil_GetPdf(*args): + """ + GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV) + + Parameters: + CdfV: TIntPrV const & + PdfV: TIntPrV & + + GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV) + + Parameters: + CdfV: TFltPrV const & + PdfV: TFltPrV & + + TGUtil_GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV) + + Parameters: + CdfV: TIntFltKdV const & + PdfV: TIntFltKdV & + + """ + return _snap.TGUtil_GetPdf(*args) + +def TGUtil_Normalize(*args): + """ + Normalize(TFltPrV & PdfV) + + Parameters: + PdfV: TFltPrV & + + TGUtil_Normalize(TIntFltKdV & PdfV) + + Parameters: + PdfV: TIntFltKdV & + + """ + return _snap.TGUtil_Normalize(*args) + +def TGUtil_MakeExpBins(*args): + """ + MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1) + + Parameters: + XYValV: TFltPrV const & + ExpXYValV: TFltPrV & + BinFactor: double const & + MinYVal: double const & + + MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2) + + Parameters: + XYValV: TFltPrV const & + ExpXYValV: TFltPrV & + BinFactor: double const & + + MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV) + + Parameters: + XYValV: TFltPrV const & + ExpXYValV: TFltPrV & + + MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1) + + Parameters: + XYValV: TFltKdV const & + ExpXYValV: TFltKdV & + BinFactor: double const & + MinYVal: double const & + + MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2) + + Parameters: + XYValV: TFltKdV const & + ExpXYValV: TFltKdV & + BinFactor: double const & + + MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV) + + Parameters: + XYValV: TFltKdV const & + ExpXYValV: TFltKdV & + + MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01) + + Parameters: + YValV: TFltV const & + ExpYValV: TFltV & + BinFactor: double const & + + MakeExpBins(TFltV const & YValV, TFltV & ExpYValV) + + Parameters: + YValV: TFltV const & + ExpYValV: TFltV & + + MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01) + + Parameters: + YValV: TIntV const & + ExpYValV: TIntV & + BinFactor: double const & + + TGUtil_MakeExpBins(TIntV YValV, TIntV ExpYValV) + + Parameters: + YValV: TIntV const & + ExpYValV: TIntV & + + """ + return _snap.TGUtil_MakeExpBins(*args) + +class TStrUtil(object): + """Proxy of C++ TStrUtil class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def GetXmlTagVal(*args): + """ + GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA + + Parameters: + XmlLx: TXmlLx & + TagNm: TChA const & + + """ + return _snap.TStrUtil_GetXmlTagVal(*args) + + GetXmlTagVal = staticmethod(GetXmlTagVal) + def GetXmlTagNmVal(*args): + """ + GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal) + + Parameters: + XmlLx: TXmlLx & + TagNm: TChA & + TagVal: TChA & + + """ + return _snap.TStrUtil_GetXmlTagNmVal(*args) + + GetXmlTagNmVal = staticmethod(GetXmlTagNmVal) + def GetXmlTagNmVal2(*args): + """ + GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool + + Parameters: + XmlLx: TXmlLx & + TagNm: TChA & + TagVal: TChA & + TakeTagNms: bool const & + + """ + return _snap.TStrUtil_GetXmlTagNmVal2(*args) + + GetXmlTagNmVal2 = staticmethod(GetXmlTagNmVal2) + def GetDomNm(*args): + """ + GetDomNm(TChA UrlChA) -> TChA + + Parameters: + UrlChA: TChA const & + + """ + return _snap.TStrUtil_GetDomNm(*args) + + GetDomNm = staticmethod(GetDomNm) + def GetDomNm2(*args): + """ + GetDomNm2(TChA UrlChA) -> TChA + + Parameters: + UrlChA: TChA const & + + """ + return _snap.TStrUtil_GetDomNm2(*args) + + GetDomNm2 = staticmethod(GetDomNm2) + def GetWebsiteNm(*args): + """ + GetWebsiteNm(TChA UrlChA) -> TChA + + Parameters: + UrlChA: TChA const & + + """ + return _snap.TStrUtil_GetWebsiteNm(*args) + + GetWebsiteNm = staticmethod(GetWebsiteNm) + def GetNormalizedUrl(*args): + """ + GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool + + Parameters: + UrlIn: TChA const & + BaseUrl: TChA const & + UrlOut: TChA & + + """ + return _snap.TStrUtil_GetNormalizedUrl(*args) + + GetNormalizedUrl = staticmethod(GetNormalizedUrl) + def StripEnd(*args): + """ + StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool + + Parameters: + Str: TChA const & + SearchStr: TChA const & + NewStr: TChA & + + """ + return _snap.TStrUtil_StripEnd(*args) + + StripEnd = staticmethod(StripEnd) + def GetShorStr(*args): + """ + GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA + + Parameters: + LongStr: TChA const & + MaxLen: int const + + GetShorStr(TChA LongStr) -> TChA + + Parameters: + LongStr: TChA const & + + """ + return _snap.TStrUtil_GetShorStr(*args) + + GetShorStr = staticmethod(GetShorStr) + def GetCleanStr(*args): + """ + GetCleanStr(TChA ChA) -> TChA + + Parameters: + ChA: TChA const & + + """ + return _snap.TStrUtil_GetCleanStr(*args) + + GetCleanStr = staticmethod(GetCleanStr) + def GetCleanWrdStr(*args): + """ + GetCleanWrdStr(TChA ChA) -> TChA + + Parameters: + ChA: TChA const & + + """ + return _snap.TStrUtil_GetCleanWrdStr(*args) + + GetCleanWrdStr = staticmethod(GetCleanWrdStr) + def CountWords(*args): + """ + CountWords(char const * CStr) -> int + + Parameters: + CStr: char const * + + CountWords(TChA ChA) -> int + + Parameters: + ChA: TChA const & + + CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int + + Parameters: + ChA: TChA const & + StopWordH: TStrHash< TInt > const & + + """ + return _snap.TStrUtil_CountWords(*args) + + CountWords = staticmethod(CountWords) + def SplitWords(*args): + """ + SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + SplitOnWs: bool const & + + SplitWords(TChA ChA, TVec< char * > & WrdV) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + + """ + return _snap.TStrUtil_SplitWords(*args) + + SplitWords = staticmethod(SplitWords) + def SplitOnCh(*args): + """ + SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + Ch: char const & + SkipEmpty: bool const & + + SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + Ch: char const & + + """ + return _snap.TStrUtil_SplitOnCh(*args) + + SplitOnCh = staticmethod(SplitOnCh) + def SplitLines(*args): + """ + SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int + + Parameters: + ChA: TChA & + LineV: TVec< char * > & + SkipEmpty: bool const & + + SplitLines(TChA ChA, TVec< char * > & LineV) -> int + + Parameters: + ChA: TChA & + LineV: TVec< char * > & + + """ + return _snap.TStrUtil_SplitLines(*args) + + SplitLines = staticmethod(SplitLines) + def SplitSentences(*args): + """ + SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int + + Parameters: + ChA: TChA & + SentenceV: TVec< char * > & + + """ + return _snap.TStrUtil_SplitSentences(*args) + + SplitSentences = staticmethod(SplitSentences) + def RemoveHtmlTags(*args): + """ + RemoveHtmlTags(TChA HtmlStr, TChA TextStr) + + Parameters: + HtmlStr: TChA const & + TextStr: TChA & + + """ + return _snap.TStrUtil_RemoveHtmlTags(*args) + + RemoveHtmlTags = staticmethod(RemoveHtmlTags) + def IsLatinStr(*args): + """ + IsLatinStr(TChA Str, double const & MinAlFrac) -> bool + + Parameters: + Str: TChA const & + MinAlFrac: double const & + + """ + return _snap.TStrUtil_IsLatinStr(*args) + + IsLatinStr = staticmethod(IsLatinStr) + def GetWIdV(*args): + """ + GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV) + + Parameters: + StrH: TStrHash< TInt > const & + CStr: char const * + WIdV: TIntV & + + """ + return _snap.TStrUtil_GetWIdV(*args) + + GetWIdV = staticmethod(GetWIdV) + def GetAddWIdV(*args): + """ + GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV) + + Parameters: + StrH: TStrHash< TInt > & + CStr: char const * + WIdV: TIntV & + + """ + return _snap.TStrUtil_GetAddWIdV(*args) + + GetAddWIdV = staticmethod(GetAddWIdV) + def GetTmFromStr(*args): + """ + GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool + + Parameters: + TmStr: char const * + Tm: TSecTm & + + """ + return _snap.TStrUtil_GetTmFromStr(*args) + + GetTmFromStr = staticmethod(GetTmFromStr) + def GetStdName(*args): + """ + GetStdName(TStr AuthorName) -> TStr + + Parameters: + AuthorName: TStr + + """ + return _snap.TStrUtil_GetStdName(*args) + + GetStdName = staticmethod(GetStdName) + def GetStdNameV(*args): + """ + GetStdNameV(TStr AuthorNames, TStrV StdNameV) + + Parameters: + AuthorNames: TStr + StdNameV: TStrV & + + """ + return _snap.TStrUtil_GetStdNameV(*args) + + GetStdNameV = staticmethod(GetStdNameV) + def __init__(self): + """__init__(TStrUtil self) -> TStrUtil""" + _snap.TStrUtil_swiginit(self,_snap.new_TStrUtil()) + __swig_destroy__ = _snap.delete_TStrUtil +TStrUtil_swigregister = _snap.TStrUtil_swigregister +TStrUtil_swigregister(TStrUtil) + +def TStrUtil_GetXmlTagVal(*args): + """ + TStrUtil_GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA + + Parameters: + XmlLx: TXmlLx & + TagNm: TChA const & + + """ + return _snap.TStrUtil_GetXmlTagVal(*args) + +def TStrUtil_GetXmlTagNmVal(*args): + """ + TStrUtil_GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal) + + Parameters: + XmlLx: TXmlLx & + TagNm: TChA & + TagVal: TChA & + + """ + return _snap.TStrUtil_GetXmlTagNmVal(*args) + +def TStrUtil_GetXmlTagNmVal2(*args): + """ + TStrUtil_GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool + + Parameters: + XmlLx: TXmlLx & + TagNm: TChA & + TagVal: TChA & + TakeTagNms: bool const & + + """ + return _snap.TStrUtil_GetXmlTagNmVal2(*args) + +def TStrUtil_GetDomNm(*args): + """ + TStrUtil_GetDomNm(TChA UrlChA) -> TChA + + Parameters: + UrlChA: TChA const & + + """ + return _snap.TStrUtil_GetDomNm(*args) + +def TStrUtil_GetDomNm2(*args): + """ + TStrUtil_GetDomNm2(TChA UrlChA) -> TChA + + Parameters: + UrlChA: TChA const & + + """ + return _snap.TStrUtil_GetDomNm2(*args) + +def TStrUtil_GetWebsiteNm(*args): + """ + TStrUtil_GetWebsiteNm(TChA UrlChA) -> TChA + + Parameters: + UrlChA: TChA const & + + """ + return _snap.TStrUtil_GetWebsiteNm(*args) + +def TStrUtil_GetNormalizedUrl(*args): + """ + TStrUtil_GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool + + Parameters: + UrlIn: TChA const & + BaseUrl: TChA const & + UrlOut: TChA & + + """ + return _snap.TStrUtil_GetNormalizedUrl(*args) + +def TStrUtil_StripEnd(*args): + """ + TStrUtil_StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool + + Parameters: + Str: TChA const & + SearchStr: TChA const & + NewStr: TChA & + + """ + return _snap.TStrUtil_StripEnd(*args) + +def TStrUtil_GetShorStr(*args): + """ + GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA + + Parameters: + LongStr: TChA const & + MaxLen: int const + + TStrUtil_GetShorStr(TChA LongStr) -> TChA + + Parameters: + LongStr: TChA const & + + """ + return _snap.TStrUtil_GetShorStr(*args) + +def TStrUtil_GetCleanStr(*args): + """ + TStrUtil_GetCleanStr(TChA ChA) -> TChA + + Parameters: + ChA: TChA const & + + """ + return _snap.TStrUtil_GetCleanStr(*args) + +def TStrUtil_GetCleanWrdStr(*args): + """ + TStrUtil_GetCleanWrdStr(TChA ChA) -> TChA + + Parameters: + ChA: TChA const & + + """ + return _snap.TStrUtil_GetCleanWrdStr(*args) + +def TStrUtil_CountWords(*args): + """ + CountWords(char const * CStr) -> int + + Parameters: + CStr: char const * + + CountWords(TChA ChA) -> int + + Parameters: + ChA: TChA const & + + TStrUtil_CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int + + Parameters: + ChA: TChA const & + StopWordH: TStrHash< TInt > const & + + """ + return _snap.TStrUtil_CountWords(*args) + +def TStrUtil_SplitWords(*args): + """ + SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + SplitOnWs: bool const & + + TStrUtil_SplitWords(TChA ChA, TVec< char * > & WrdV) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + + """ + return _snap.TStrUtil_SplitWords(*args) + +def TStrUtil_SplitOnCh(*args): + """ + SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + Ch: char const & + SkipEmpty: bool const & + + TStrUtil_SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int + + Parameters: + ChA: TChA & + WrdV: TVec< char * > & + Ch: char const & + + """ + return _snap.TStrUtil_SplitOnCh(*args) + +def TStrUtil_SplitLines(*args): + """ + SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int + + Parameters: + ChA: TChA & + LineV: TVec< char * > & + SkipEmpty: bool const & + + TStrUtil_SplitLines(TChA ChA, TVec< char * > & LineV) -> int + + Parameters: + ChA: TChA & + LineV: TVec< char * > & + + """ + return _snap.TStrUtil_SplitLines(*args) + +def TStrUtil_SplitSentences(*args): + """ + TStrUtil_SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int + + Parameters: + ChA: TChA & + SentenceV: TVec< char * > & + + """ + return _snap.TStrUtil_SplitSentences(*args) + +def TStrUtil_RemoveHtmlTags(*args): + """ + TStrUtil_RemoveHtmlTags(TChA HtmlStr, TChA TextStr) + + Parameters: + HtmlStr: TChA const & + TextStr: TChA & + + """ + return _snap.TStrUtil_RemoveHtmlTags(*args) + +def TStrUtil_IsLatinStr(*args): + """ + TStrUtil_IsLatinStr(TChA Str, double const & MinAlFrac) -> bool + + Parameters: + Str: TChA const & + MinAlFrac: double const & + + """ + return _snap.TStrUtil_IsLatinStr(*args) + +def TStrUtil_GetWIdV(*args): + """ + TStrUtil_GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV) + + Parameters: + StrH: TStrHash< TInt > const & + CStr: char const * + WIdV: TIntV & + + """ + return _snap.TStrUtil_GetWIdV(*args) + +def TStrUtil_GetAddWIdV(*args): + """ + TStrUtil_GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV) + + Parameters: + StrH: TStrHash< TInt > & + CStr: char const * + WIdV: TIntV & + + """ + return _snap.TStrUtil_GetAddWIdV(*args) + +def TStrUtil_GetTmFromStr(*args): + """ + TStrUtil_GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool + + Parameters: + TmStr: char const * + Tm: TSecTm & + + """ + return _snap.TStrUtil_GetTmFromStr(*args) + +def TStrUtil_GetStdName(*args): + """ + TStrUtil_GetStdName(TStr AuthorName) -> TStr + + Parameters: + AuthorName: TStr + + """ + return _snap.TStrUtil_GetStdName(*args) + +def TStrUtil_GetStdNameV(*args): + """ + TStrUtil_GetStdNameV(TStr AuthorNames, TStrV StdNameV) + + Parameters: + AuthorNames: TStr + StdNameV: TStrV & + + """ + return _snap.TStrUtil_GetStdNameV(*args) + +class TRnd(object): + """Proxy of C++ TRnd class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TRnd self, int const & _Seed=1, int const & Steps=0) -> TRnd + + Parameters: + _Seed: int const & + Steps: int const & + + __init__(TRnd self, int const & _Seed=1) -> TRnd + + Parameters: + _Seed: int const & + + __init__(TRnd self) -> TRnd + __init__(TRnd self, TSIn SIn) -> TRnd + + Parameters: + SIn: TSIn & + + """ + _snap.TRnd_swiginit(self,_snap.new_TRnd(*args)) + def Save(self, *args): + """ + Save(TRnd self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TRnd_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TRnd self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TRnd_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TRnd self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TRnd_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TRnd self, TRnd arg2) -> bool + + Parameters: + arg2: TRnd const & + + """ + return _snap.TRnd___eq__(self, *args) + + def GetUniDev(self): + """ + GetUniDev(TRnd self) -> double + + Parameters: + self: TRnd * + + """ + return _snap.TRnd_GetUniDev(self) + + def GetUniDevInt(self, *args): + """ + GetUniDevInt(TRnd self, int const & Range=0) -> int + + Parameters: + Range: int const & + + GetUniDevInt(TRnd self) -> int + GetUniDevInt(TRnd self, int const & MnVal, int const & MxVal) -> int + + Parameters: + MnVal: int const & + MxVal: int const & + + """ + return _snap.TRnd_GetUniDevInt(self, *args) + + def GetUniDevUInt(self, Range=0): + """ + GetUniDevUInt(TRnd self, uint const & Range=0) -> uint + + Parameters: + Range: uint const & + + GetUniDevUInt(TRnd self) -> uint + + Parameters: + self: TRnd * + + """ + return _snap.TRnd_GetUniDevUInt(self, Range) + + def GetUniDevInt64(self, Range=0): + """ + GetUniDevInt64(TRnd self, int64 const & Range=0) -> int64 + + Parameters: + Range: int64 const & + + GetUniDevInt64(TRnd self) -> int64 + + Parameters: + self: TRnd * + + """ + return _snap.TRnd_GetUniDevInt64(self, Range) + + def GetUniDevUInt64(self, Range=0): + """ + GetUniDevUInt64(TRnd self, uint64 const & Range=0) -> uint64 + + Parameters: + Range: uint64 const & + + GetUniDevUInt64(TRnd self) -> uint64 + + Parameters: + self: TRnd * + + """ + return _snap.TRnd_GetUniDevUInt64(self, Range) + + def GetNrmDev(self, *args): + """ + GetNrmDev(TRnd self) -> double + GetNrmDev(TRnd self, double const & Mean, double const & SDev, double const & Mn, double const & Mx) -> double + + Parameters: + Mean: double const & + SDev: double const & + Mn: double const & + Mx: double const & + + """ + return _snap.TRnd_GetNrmDev(self, *args) + + def GetExpDev(self, *args): + """ + GetExpDev(TRnd self) -> double + GetExpDev(TRnd self, double const & Lambda) -> double + + Parameters: + Lambda: double const & + + """ + return _snap.TRnd_GetExpDev(self, *args) + + def GetGammaDev(self, *args): + """ + GetGammaDev(TRnd self, int const & Order) -> double + + Parameters: + Order: int const & + + """ + return _snap.TRnd_GetGammaDev(self, *args) + + def GetPoissonDev(self, *args): + """ + GetPoissonDev(TRnd self, double const & Mean) -> double + + Parameters: + Mean: double const & + + """ + return _snap.TRnd_GetPoissonDev(self, *args) + + def GetBinomialDev(self, *args): + """ + GetBinomialDev(TRnd self, double const & Prb, int const & Trials) -> double + + Parameters: + Prb: double const & + Trials: int const & + + """ + return _snap.TRnd_GetBinomialDev(self, *args) + + def GetGeoDev(self, *args): + """ + GetGeoDev(TRnd self, double const & Prb) -> int + + Parameters: + Prb: double const & + + """ + return _snap.TRnd_GetGeoDev(self, *args) + + def GetPowerDev(self, *args): + """ + GetPowerDev(TRnd self, double const & AlphaSlope) -> double + + Parameters: + AlphaSlope: double const & + + """ + return _snap.TRnd_GetPowerDev(self, *args) + + def GetRayleigh(self, *args): + """ + GetRayleigh(TRnd self, double const & Sigma) -> double + + Parameters: + Sigma: double const & + + """ + return _snap.TRnd_GetRayleigh(self, *args) + + def GetWeibull(self, *args): + """ + GetWeibull(TRnd self, double const & K, double const & Lambda) -> double + + Parameters: + K: double const & + Lambda: double const & + + """ + return _snap.TRnd_GetWeibull(self, *args) + + def PutSeed(self, *args): + """ + PutSeed(TRnd self, int const & _Seed) + + Parameters: + _Seed: int const & + + """ + return _snap.TRnd_PutSeed(self, *args) + + def GetSeed(self): + """ + GetSeed(TRnd self) -> int + + Parameters: + self: TRnd const * + + """ + return _snap.TRnd_GetSeed(self) + + def Randomize(self): + """ + Randomize(TRnd self) + + Parameters: + self: TRnd * + + """ + return _snap.TRnd_Randomize(self) + + def Move(self, *args): + """ + Move(TRnd self, int const & Steps) + + Parameters: + Steps: int const & + + """ + return _snap.TRnd_Move(self, *args) + + def Check(self): + """ + Check(TRnd self) -> bool + + Parameters: + self: TRnd * + + """ + return _snap.TRnd_Check(self) + + def GetUniDevStep(*args): + """ + GetUniDevStep(int const & Seed, int const & Steps) -> double + + Parameters: + Seed: int const & + Steps: int const & + + """ + return _snap.TRnd_GetUniDevStep(*args) + + GetUniDevStep = staticmethod(GetUniDevStep) + def GetNrmDevStep(*args): + """ + GetNrmDevStep(int const & Seed, int const & Steps) -> double + + Parameters: + Seed: int const & + Steps: int const & + + """ + return _snap.TRnd_GetNrmDevStep(*args) + + GetNrmDevStep = staticmethod(GetNrmDevStep) + def GetExpDevStep(*args): + """ + GetExpDevStep(int const & Seed, int const & Steps) -> double + + Parameters: + Seed: int const & + Steps: int const & + + """ + return _snap.TRnd_GetExpDevStep(*args) + + GetExpDevStep = staticmethod(GetExpDevStep) + def LoadTxt(*args): + """ + LoadTxt(TILx & Lx) -> TRnd + + Parameters: + Lx: TILx & + + """ + return _snap.TRnd_LoadTxt(*args) + + LoadTxt = staticmethod(LoadTxt) + def SaveTxt(self, *args): + """ + SaveTxt(TRnd self, TOLx & Lx) + + Parameters: + Lx: TOLx & + + """ + return _snap.TRnd_SaveTxt(self, *args) + + __swig_destroy__ = _snap.delete_TRnd +TRnd.Save = new_instancemethod(_snap.TRnd_Save,None,TRnd) +TRnd.LoadXml = new_instancemethod(_snap.TRnd_LoadXml,None,TRnd) +TRnd.SaveXml = new_instancemethod(_snap.TRnd_SaveXml,None,TRnd) +TRnd.__eq__ = new_instancemethod(_snap.TRnd___eq__,None,TRnd) +TRnd.GetUniDev = new_instancemethod(_snap.TRnd_GetUniDev,None,TRnd) +TRnd.GetUniDevInt = new_instancemethod(_snap.TRnd_GetUniDevInt,None,TRnd) +TRnd.GetUniDevUInt = new_instancemethod(_snap.TRnd_GetUniDevUInt,None,TRnd) +TRnd.GetUniDevInt64 = new_instancemethod(_snap.TRnd_GetUniDevInt64,None,TRnd) +TRnd.GetUniDevUInt64 = new_instancemethod(_snap.TRnd_GetUniDevUInt64,None,TRnd) +TRnd.GetNrmDev = new_instancemethod(_snap.TRnd_GetNrmDev,None,TRnd) +TRnd.GetExpDev = new_instancemethod(_snap.TRnd_GetExpDev,None,TRnd) +TRnd.GetGammaDev = new_instancemethod(_snap.TRnd_GetGammaDev,None,TRnd) +TRnd.GetPoissonDev = new_instancemethod(_snap.TRnd_GetPoissonDev,None,TRnd) +TRnd.GetBinomialDev = new_instancemethod(_snap.TRnd_GetBinomialDev,None,TRnd) +TRnd.GetGeoDev = new_instancemethod(_snap.TRnd_GetGeoDev,None,TRnd) +TRnd.GetPowerDev = new_instancemethod(_snap.TRnd_GetPowerDev,None,TRnd) +TRnd.GetRayleigh = new_instancemethod(_snap.TRnd_GetRayleigh,None,TRnd) +TRnd.GetWeibull = new_instancemethod(_snap.TRnd_GetWeibull,None,TRnd) +TRnd.PutSeed = new_instancemethod(_snap.TRnd_PutSeed,None,TRnd) +TRnd.GetSeed = new_instancemethod(_snap.TRnd_GetSeed,None,TRnd) +TRnd.Randomize = new_instancemethod(_snap.TRnd_Randomize,None,TRnd) +TRnd.Move = new_instancemethod(_snap.TRnd_Move,None,TRnd) +TRnd.Check = new_instancemethod(_snap.TRnd_Check,None,TRnd) +TRnd.SaveTxt = new_instancemethod(_snap.TRnd_SaveTxt,None,TRnd) +TRnd_swigregister = _snap.TRnd_swigregister +TRnd_swigregister(TRnd) +TRnd.RndSeed = _snap.cvar.TRnd_RndSeed + +def TRnd_GetUniDevStep(*args): + """ + TRnd_GetUniDevStep(int const & Seed, int const & Steps) -> double + + Parameters: + Seed: int const & + Steps: int const & + + """ + return _snap.TRnd_GetUniDevStep(*args) + +def TRnd_GetNrmDevStep(*args): + """ + TRnd_GetNrmDevStep(int const & Seed, int const & Steps) -> double + + Parameters: + Seed: int const & + Steps: int const & + + """ + return _snap.TRnd_GetNrmDevStep(*args) + +def TRnd_GetExpDevStep(*args): + """ + TRnd_GetExpDevStep(int const & Seed, int const & Steps) -> double + + Parameters: + Seed: int const & + Steps: int const & + + """ + return _snap.TRnd_GetExpDevStep(*args) + +def TRnd_LoadTxt(*args): + """ + TRnd_LoadTxt(TILx & Lx) -> TRnd + + Parameters: + Lx: TILx & + + """ + return _snap.TRnd_LoadTxt(*args) + +class TMem(object): + """Proxy of C++ TMem class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def New(*args): + """ + New(int const & MxBfL=0) -> PMem + + Parameters: + MxBfL: int const & + + New() -> PMem + New(void const * Bf, int const & BfL) -> PMem + + Parameters: + Bf: void const * + BfL: int const & + + New(TMem Mem) -> PMem + + Parameters: + Mem: TMem const & + + New(PMem const & Mem) -> PMem + + Parameters: + Mem: PMem const & + + New(TStr Str) -> PMem + + Parameters: + Str: TStr const & + + """ + return _snap.TMem_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TMem + def __init__(self, *args): + """ + __init__(TMem self, int const & _MxBfL=0) -> TMem + + Parameters: + _MxBfL: int const & + + __init__(TMem self) -> TMem + __init__(TMem self, void const * _Bf, int const & _BfL) -> TMem + + Parameters: + _Bf: void const * + _BfL: int const & + + __init__(TMem self, TMem Mem) -> TMem + + Parameters: + Mem: TMem const & + + __init__(TMem self, TStr Str) -> TMem + + Parameters: + Str: TStr const & + + __init__(TMem self, TSIn SIn) -> TMem + + Parameters: + SIn: TSIn & + + """ + _snap.TMem_swiginit(self,_snap.new_TMem(*args)) + def Save(self, *args): + """ + Save(TMem self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TMem_Save(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TMem self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TMem_SaveXml(self, *args) + + def __call__(self): + """ + __call__(TMem self) -> char * + + Parameters: + self: TMem const * + + """ + return _snap.TMem___call__(self) + + def __iadd__(self, *args): + """ + __iadd__(TMem self, char const & Ch) -> TMem + + Parameters: + Ch: char const & + + __iadd__(TMem self, TMem Mem) -> TMem + + Parameters: + Mem: TMem const & + + __iadd__(TMem self, TStr Str) -> TMem + + Parameters: + Str: TStr const & + + __iadd__(TMem self, PSIn const & SIn) -> TMem + + Parameters: + SIn: PSIn const & + + """ + return _snap.TMem___iadd__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TMem self) -> int + + Parameters: + self: TMem const * + + """ + return _snap.TMem_GetMemUsed(self) + + def Gen(self, *args): + """ + Gen(TMem self, int const & _BfL) + + Parameters: + _BfL: int const & + + """ + return _snap.TMem_Gen(self, *args) + + def GenZeros(self, *args): + """ + GenZeros(TMem self, int const & _BfL) + + Parameters: + _BfL: int const & + + """ + return _snap.TMem_GenZeros(self, *args) + + def Reserve(self, *args): + """ + Reserve(TMem self, int const & _MxBfL, bool const & DoClr=True) + + Parameters: + _MxBfL: int const & + DoClr: bool const & + + Reserve(TMem self, int const & _MxBfL) + + Parameters: + _MxBfL: int const & + + """ + return _snap.TMem_Reserve(self, *args) + + def Del(self, *args): + """ + Del(TMem self, int const & BChN, int const & EChN) + + Parameters: + BChN: int const & + EChN: int const & + + """ + return _snap.TMem_Del(self, *args) + + def Clr(self, DoDel=True): + """ + Clr(TMem self, bool const & DoDel=True) + + Parameters: + DoDel: bool const & + + Clr(TMem self) + + Parameters: + self: TMem * + + """ + return _snap.TMem_Clr(self, DoDel) + + def Len(self): + """ + Len(TMem self) -> int + + Parameters: + self: TMem const * + + """ + return _snap.TMem_Len(self) + + def Empty(self): + """ + Empty(TMem self) -> bool + + Parameters: + self: TMem const * + + """ + return _snap.TMem_Empty(self) + + def Trunc(self, *args): + """ + Trunc(TMem self, int const & _BfL) + + Parameters: + _BfL: int const & + + """ + return _snap.TMem_Trunc(self, *args) + + def Push(self, *args): + """ + Push(TMem self, char const & Ch) + + Parameters: + Ch: char const & + + """ + return _snap.TMem_Push(self, *args) + + def Pop(self): + """ + Pop(TMem self) -> char + + Parameters: + self: TMem * + + """ + return _snap.TMem_Pop(self) + + def DoFitStr(self, *args): + """ + DoFitStr(TMem self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TMem_DoFitStr(self, *args) + + def AddBf(self, *args): + """ + AddBf(TMem self, void const * Bf, int const & BfL) + + Parameters: + Bf: void const * + BfL: int const & + + """ + return _snap.TMem_AddBf(self, *args) + + def GetBf(self): + """ + GetBf(TMem self) -> char * + + Parameters: + self: TMem const * + + """ + return _snap.TMem_GetBf(self) + + def GetAsStr(self, NewNullCh='\0'): + """ + GetAsStr(TMem self, char const & NewNullCh='\0') -> TStr + + Parameters: + NewNullCh: char const & + + GetAsStr(TMem self) -> TStr + + Parameters: + self: TMem const * + + """ + return _snap.TMem_GetAsStr(self, NewNullCh) + + def GetSIn(self): + """ + GetSIn(TMem self) -> PSIn + + Parameters: + self: TMem const * + + """ + return _snap.TMem_GetSIn(self) + + def LoadMem(*args): + """ + LoadMem(PSIn const & SIn, TMem Mem) + + Parameters: + SIn: PSIn const & + Mem: TMem & + + LoadMem(PSIn const & SIn, PMem const & Mem) + + Parameters: + SIn: PSIn const & + Mem: PMem const & + + """ + return _snap.TMem_LoadMem(*args) + + LoadMem = staticmethod(LoadMem) + def SaveMem(self, *args): + """ + SaveMem(TMem self, PSOut const & SOut) + + Parameters: + SOut: PSOut const & + + """ + return _snap.TMem_SaveMem(self, *args) + +TMem.Save = new_instancemethod(_snap.TMem_Save,None,TMem) +TMem.SaveXml = new_instancemethod(_snap.TMem_SaveXml,None,TMem) +TMem.__call__ = new_instancemethod(_snap.TMem___call__,None,TMem) +TMem.__iadd__ = new_instancemethod(_snap.TMem___iadd__,None,TMem) +TMem.GetMemUsed = new_instancemethod(_snap.TMem_GetMemUsed,None,TMem) +TMem.Gen = new_instancemethod(_snap.TMem_Gen,None,TMem) +TMem.GenZeros = new_instancemethod(_snap.TMem_GenZeros,None,TMem) +TMem.Reserve = new_instancemethod(_snap.TMem_Reserve,None,TMem) +TMem.Del = new_instancemethod(_snap.TMem_Del,None,TMem) +TMem.Clr = new_instancemethod(_snap.TMem_Clr,None,TMem) +TMem.Len = new_instancemethod(_snap.TMem_Len,None,TMem) +TMem.Empty = new_instancemethod(_snap.TMem_Empty,None,TMem) +TMem.Trunc = new_instancemethod(_snap.TMem_Trunc,None,TMem) +TMem.Push = new_instancemethod(_snap.TMem_Push,None,TMem) +TMem.Pop = new_instancemethod(_snap.TMem_Pop,None,TMem) +TMem.DoFitStr = new_instancemethod(_snap.TMem_DoFitStr,None,TMem) +TMem.AddBf = new_instancemethod(_snap.TMem_AddBf,None,TMem) +TMem.GetBf = new_instancemethod(_snap.TMem_GetBf,None,TMem) +TMem.GetAsStr = new_instancemethod(_snap.TMem_GetAsStr,None,TMem) +TMem.GetSIn = new_instancemethod(_snap.TMem_GetSIn,None,TMem) +TMem.SaveMem = new_instancemethod(_snap.TMem_SaveMem,None,TMem) +TMem_swigregister = _snap.TMem_swigregister +TMem_swigregister(TMem) + +def TMem_New(*args): + """ + New(int const & MxBfL=0) -> PMem + + Parameters: + MxBfL: int const & + + New() -> PMem + New(void const * Bf, int const & BfL) -> PMem + + Parameters: + Bf: void const * + BfL: int const & + + New(TMem Mem) -> PMem + + Parameters: + Mem: TMem const & + + New(PMem const & Mem) -> PMem + + Parameters: + Mem: PMem const & + + TMem_New(TStr Str) -> PMem + + Parameters: + Str: TStr const & + + """ + return _snap.TMem_New(*args) + +def TMem_LoadMem(*args): + """ + LoadMem(PSIn const & SIn, TMem Mem) + + Parameters: + SIn: PSIn const & + Mem: TMem & + + TMem_LoadMem(PSIn const & SIn, PMem const & Mem) + + Parameters: + SIn: PSIn const & + Mem: PMem const & + + """ + return _snap.TMem_LoadMem(*args) + +class TMemIn(TSIn): + """Proxy of C++ TMemIn class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TMemIn self, TMem _Mem, int const & _BfC=0) -> TMemIn + + Parameters: + _Mem: TMem const & + _BfC: int const & + + __init__(TMemIn self, TMem _Mem) -> TMemIn + + Parameters: + _Mem: TMem const & + + """ + _snap.TMemIn_swiginit(self,_snap.new_TMemIn(*args)) + def New(*args): + """ + New(TMem Mem) -> PSIn + + Parameters: + Mem: TMem const & + + New(PMem const & Mem) -> PSIn + + Parameters: + Mem: PMem const & + + """ + return _snap.TMemIn_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TMemIn +TMemIn_swigregister = _snap.TMemIn_swigregister +TMemIn_swigregister(TMemIn) + +def TMemIn_New(*args): + """ + New(TMem Mem) -> PSIn + + Parameters: + Mem: TMem const & + + TMemIn_New(PMem const & Mem) -> PSIn + + Parameters: + Mem: PMem const & + + """ + return _snap.TMemIn_New(*args) + +class TMemOut(TSOut): + """Proxy of C++ TMemOut class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TMemOut self, PMem const & _Mem) -> TMemOut + + Parameters: + _Mem: PMem const & + + """ + _snap.TMemOut_swiginit(self,_snap.new_TMemOut(*args)) + def New(*args): + """ + New(PMem const & Mem) -> PSOut + + Parameters: + Mem: PMem const & + + """ + return _snap.TMemOut_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TMemOut +TMemOut_swigregister = _snap.TMemOut_swigregister +TMemOut_swigregister(TMemOut) + +def TMemOut_New(*args): + """ + TMemOut_New(PMem const & Mem) -> PSOut + + Parameters: + Mem: PMem const & + + """ + return _snap.TMemOut_New(*args) + +class TChA(object): + """Proxy of C++ TChA class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TChA + def __init__(self, *args): + """ + __init__(TChA self, int const & _MxBfL=256) -> TChA + + Parameters: + _MxBfL: int const & + + __init__(TChA self) -> TChA + __init__(TChA self, char const * CStr) -> TChA + + Parameters: + CStr: char const * + + __init__(TChA self, char const * CStr, int const & StrLen) -> TChA + + Parameters: + CStr: char const * + StrLen: int const & + + __init__(TChA self, TChA ChA) -> TChA + + Parameters: + ChA: TChA const & + + __init__(TChA self, TStr Str) -> TChA + + Parameters: + Str: TStr const & + + __init__(TChA self, TMem Mem) -> TChA + + Parameters: + Mem: TMem const & + + __init__(TChA self, TSIn SIn) -> TChA + + Parameters: + SIn: TSIn & + + """ + _snap.TChA_swiginit(self,_snap.new_TChA(*args)) + def Load(self, *args): + """ + Load(TChA self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TChA_Load(self, *args) + + def Save(self, *args): + """ + Save(TChA self, TSOut SOut, bool const & SaveCompact=True) + + Parameters: + SOut: TSOut & + SaveCompact: bool const & + + Save(TChA self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TChA_Save(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TChA self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TChA_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TChA self, TChA ChA) -> bool + + Parameters: + ChA: TChA const & + + __eq__(TChA self, char const * _CStr) -> bool + + Parameters: + _CStr: char const * + + __eq__(TChA self, char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TChA___eq__(self, *args) + + def __ne__(self, *args): + """ + __ne__(TChA self, TChA ChA) -> bool + + Parameters: + ChA: TChA const & + + __ne__(TChA self, char const * _CStr) -> bool + + Parameters: + _CStr: char const * + + __ne__(TChA self, char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TChA___ne__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TChA self, TChA ChA) -> bool + + Parameters: + ChA: TChA const & + + """ + return _snap.TChA___lt__(self, *args) + + def __iadd__(self, *args): + """ + __iadd__(TChA self, TMem Mem) -> TChA + + Parameters: + Mem: TMem const & + + __iadd__(TChA self, TChA ChA) -> TChA + + Parameters: + ChA: TChA const & + + __iadd__(TChA self, TStr Str) -> TChA + + Parameters: + Str: TStr const & + + __iadd__(TChA self, char const * CStr) -> TChA + + Parameters: + CStr: char const * + + __iadd__(TChA self, char const & Ch) -> TChA + + Parameters: + Ch: char const & + + """ + return _snap.TChA___iadd__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TChA self) -> int + + Parameters: + self: TChA const * + + """ + return _snap.TChA_GetMemUsed(self) + + def __call__(self, *args): + """ + __call__(TChA self) -> char + __call__(TChA self) -> char const * + + Parameters: + self: TChA const * + + """ + return _snap.TChA___call__(self, *args) + + def CStr(self, *args): + """ + CStr(TChA self) -> char + CStr(TChA self) -> char const * + + Parameters: + self: TChA const * + + """ + return _snap.TChA_CStr(self, *args) + + def Clr(self): + """ + Clr(TChA self) + + Parameters: + self: TChA * + + """ + return _snap.TChA_Clr(self) + + def Len(self): + """ + Len(TChA self) -> int + + Parameters: + self: TChA const * + + """ + return _snap.TChA_Len(self) + + def Empty(self): + """ + Empty(TChA self) -> bool + + Parameters: + self: TChA const * + + """ + return _snap.TChA_Empty(self) + + def Ins(self, *args): + """ + Ins(TChA self, int const & BChN, char const * CStr) + + Parameters: + BChN: int const & + CStr: char const * + + """ + return _snap.TChA_Ins(self, *args) + + def Del(self, *args): + """ + Del(TChA self, int const & ChN) + + Parameters: + ChN: int const & + + """ + return _snap.TChA_Del(self, *args) + + def DelLastCh(self): + """ + DelLastCh(TChA self) + + Parameters: + self: TChA * + + """ + return _snap.TChA_DelLastCh(self) + + def Push(self, *args): + """ + Push(TChA self, char const & Ch) + + Parameters: + Ch: char const & + + """ + return _snap.TChA_Push(self, *args) + + def Pop(self): + """ + Pop(TChA self) -> char + + Parameters: + self: TChA * + + """ + return _snap.TChA_Pop(self) + + def Trunc(self, *args): + """ + Trunc(TChA self) + Trunc(TChA self, int const & _BfL) + + Parameters: + _BfL: int const & + + """ + return _snap.TChA_Trunc(self, *args) + + def Reverse(self): + """ + Reverse(TChA self) + + Parameters: + self: TChA * + + """ + return _snap.TChA_Reverse(self) + + def AddCh(self, *args): + """ + AddCh(TChA self, char const & Ch, int const & MxLen=-1) + + Parameters: + Ch: char const & + MxLen: int const & + + AddCh(TChA self, char const & Ch) + + Parameters: + Ch: char const & + + """ + return _snap.TChA_AddCh(self, *args) + + def AddChTo(self, *args): + """ + AddChTo(TChA self, char const & Ch, int const & ToChN) + + Parameters: + Ch: char const & + ToChN: int const & + + """ + return _snap.TChA_AddChTo(self, *args) + + def AddBf(self, *args): + """ + AddBf(TChA self, char * NewBf, int const & BfS) + + Parameters: + NewBf: char * + BfS: int const & + + """ + return _snap.TChA_AddBf(self, *args) + + def PutCh(self, *args): + """ + PutCh(TChA self, int const & ChN, char const & Ch) + + Parameters: + ChN: int const & + Ch: char const & + + """ + return _snap.TChA_PutCh(self, *args) + + def GetCh(self, *args): + """ + GetCh(TChA self, int const & ChN) -> char + + Parameters: + ChN: int const & + + """ + return _snap.TChA_GetCh(self, *args) + + def LastCh(self): + """ + LastCh(TChA self) -> char + + Parameters: + self: TChA const * + + """ + return _snap.TChA_LastCh(self) + + def LastLastCh(self): + """ + LastLastCh(TChA self) -> char + + Parameters: + self: TChA const * + + """ + return _snap.TChA_LastLastCh(self) + + def GetSubStr(self, *args): + """ + GetSubStr(TChA self, int const & BChN, int const & EChN) -> TChA + + Parameters: + BChN: int const & + EChN: int const & + + """ + return _snap.TChA_GetSubStr(self, *args) + + def CountCh(self, *args): + """ + CountCh(TChA self, char const & Ch, int const & BChN=0) -> int + + Parameters: + Ch: char const & + BChN: int const & + + CountCh(TChA self, char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TChA_CountCh(self, *args) + + def SearchCh(self, *args): + """ + SearchCh(TChA self, char const & Ch, int const & BChN=0) -> int + + Parameters: + Ch: char const & + BChN: int const & + + SearchCh(TChA self, char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TChA_SearchCh(self, *args) + + def SearchChBack(self, *args): + """ + SearchChBack(TChA self, char const & Ch, int BChN=-1) -> int + + Parameters: + Ch: char const & + BChN: int + + SearchChBack(TChA self, char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TChA_SearchChBack(self, *args) + + def SearchStr(self, *args): + """ + SearchStr(TChA self, TChA Str, int const & BChN=0) -> int + + Parameters: + Str: TChA const & + BChN: int const & + + SearchStr(TChA self, TChA Str) -> int + + Parameters: + Str: TChA const & + + SearchStr(TChA self, TStr Str, int const & BChN=0) -> int + + Parameters: + Str: TStr const & + BChN: int const & + + SearchStr(TChA self, TStr Str) -> int + + Parameters: + Str: TStr const & + + SearchStr(TChA self, char const * CStr, int const & BChN=0) -> int + + Parameters: + CStr: char const * + BChN: int const & + + SearchStr(TChA self, char const * CStr) -> int + + Parameters: + CStr: char const * + + """ + return _snap.TChA_SearchStr(self, *args) + + def IsStrIn(self, *args): + """ + IsStrIn(TChA self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TChA_IsStrIn(self, *args) + + def IsPrefix(self, *args): + """ + IsPrefix(TChA self, char const * CStr, int const & BChN=0) -> bool + + Parameters: + CStr: char const * + BChN: int const & + + IsPrefix(TChA self, char const * CStr) -> bool + + Parameters: + CStr: char const * + + IsPrefix(TChA self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + IsPrefix(TChA self, TChA Str) -> bool + + Parameters: + Str: TChA const & + + """ + return _snap.TChA_IsPrefix(self, *args) + + def IsSuffix(self, *args): + """ + IsSuffix(TChA self, char const * CStr) -> bool + + Parameters: + CStr: char const * + + IsSuffix(TChA self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + IsSuffix(TChA self, TChA Str) -> bool + + Parameters: + Str: TChA const & + + """ + return _snap.TChA_IsSuffix(self, *args) + + def IsChIn(self, *args): + """ + IsChIn(TChA self, char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TChA_IsChIn(self, *args) + + def ChangeCh(self, *args): + """ + ChangeCh(TChA self, char const & SrcCh, char const & DstCh) + + Parameters: + SrcCh: char const & + DstCh: char const & + + """ + return _snap.TChA_ChangeCh(self, *args) + + def ToUc(self): + """ + ToUc(TChA self) -> TChA + + Parameters: + self: TChA * + + """ + return _snap.TChA_ToUc(self) + + def ToLc(self): + """ + ToLc(TChA self) -> TChA + + Parameters: + self: TChA * + + """ + return _snap.TChA_ToLc(self) + + def ToTrunc(self): + """ + ToTrunc(TChA self) -> TChA + + Parameters: + self: TChA * + + """ + return _snap.TChA_ToTrunc(self) + + def CompressWs(self): + """ + CompressWs(TChA self) + + Parameters: + self: TChA * + + """ + return _snap.TChA_CompressWs(self) + + def Swap(self, *args): + """ + Swap(TChA self, int const & ChN1, int const & ChN2) + + Parameters: + ChN1: int const & + ChN2: int const & + + Swap(TChA self, TChA ChA) + + Parameters: + ChA: TChA & + + """ + return _snap.TChA_Swap(self, *args) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TChA self) -> int + + Parameters: + self: TChA const * + + """ + return _snap.TChA_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TChA self) -> int + + Parameters: + self: TChA const * + + """ + return _snap.TChA_GetSecHashCd(self) + + def LoadTxt(*args): + """ + LoadTxt(PSIn const & SIn, TChA ChA) + + Parameters: + SIn: PSIn const & + ChA: TChA & + + """ + return _snap.TChA_LoadTxt(*args) + + LoadTxt = staticmethod(LoadTxt) + def SaveTxt(self, *args): + """ + SaveTxt(TChA self, PSOut const & SOut) + + Parameters: + SOut: PSOut const & + + """ + return _snap.TChA_SaveTxt(self, *args) + +TChA.Load = new_instancemethod(_snap.TChA_Load,None,TChA) +TChA.Save = new_instancemethod(_snap.TChA_Save,None,TChA) +TChA.SaveXml = new_instancemethod(_snap.TChA_SaveXml,None,TChA) +TChA.__eq__ = new_instancemethod(_snap.TChA___eq__,None,TChA) +TChA.__ne__ = new_instancemethod(_snap.TChA___ne__,None,TChA) +TChA.__lt__ = new_instancemethod(_snap.TChA___lt__,None,TChA) +TChA.__iadd__ = new_instancemethod(_snap.TChA___iadd__,None,TChA) +TChA.GetMemUsed = new_instancemethod(_snap.TChA_GetMemUsed,None,TChA) +TChA.__call__ = new_instancemethod(_snap.TChA___call__,None,TChA) +TChA.CStr = new_instancemethod(_snap.TChA_CStr,None,TChA) +TChA.Clr = new_instancemethod(_snap.TChA_Clr,None,TChA) +TChA.Len = new_instancemethod(_snap.TChA_Len,None,TChA) +TChA.Empty = new_instancemethod(_snap.TChA_Empty,None,TChA) +TChA.Ins = new_instancemethod(_snap.TChA_Ins,None,TChA) +TChA.Del = new_instancemethod(_snap.TChA_Del,None,TChA) +TChA.DelLastCh = new_instancemethod(_snap.TChA_DelLastCh,None,TChA) +TChA.Push = new_instancemethod(_snap.TChA_Push,None,TChA) +TChA.Pop = new_instancemethod(_snap.TChA_Pop,None,TChA) +TChA.Trunc = new_instancemethod(_snap.TChA_Trunc,None,TChA) +TChA.Reverse = new_instancemethod(_snap.TChA_Reverse,None,TChA) +TChA.AddCh = new_instancemethod(_snap.TChA_AddCh,None,TChA) +TChA.AddChTo = new_instancemethod(_snap.TChA_AddChTo,None,TChA) +TChA.AddBf = new_instancemethod(_snap.TChA_AddBf,None,TChA) +TChA.PutCh = new_instancemethod(_snap.TChA_PutCh,None,TChA) +TChA.GetCh = new_instancemethod(_snap.TChA_GetCh,None,TChA) +TChA.LastCh = new_instancemethod(_snap.TChA_LastCh,None,TChA) +TChA.LastLastCh = new_instancemethod(_snap.TChA_LastLastCh,None,TChA) +TChA.GetSubStr = new_instancemethod(_snap.TChA_GetSubStr,None,TChA) +TChA.CountCh = new_instancemethod(_snap.TChA_CountCh,None,TChA) +TChA.SearchCh = new_instancemethod(_snap.TChA_SearchCh,None,TChA) +TChA.SearchChBack = new_instancemethod(_snap.TChA_SearchChBack,None,TChA) +TChA.SearchStr = new_instancemethod(_snap.TChA_SearchStr,None,TChA) +TChA.IsStrIn = new_instancemethod(_snap.TChA_IsStrIn,None,TChA) +TChA.IsPrefix = new_instancemethod(_snap.TChA_IsPrefix,None,TChA) +TChA.IsSuffix = new_instancemethod(_snap.TChA_IsSuffix,None,TChA) +TChA.IsChIn = new_instancemethod(_snap.TChA_IsChIn,None,TChA) +TChA.ChangeCh = new_instancemethod(_snap.TChA_ChangeCh,None,TChA) +TChA.ToUc = new_instancemethod(_snap.TChA_ToUc,None,TChA) +TChA.ToLc = new_instancemethod(_snap.TChA_ToLc,None,TChA) +TChA.ToTrunc = new_instancemethod(_snap.TChA_ToTrunc,None,TChA) +TChA.CompressWs = new_instancemethod(_snap.TChA_CompressWs,None,TChA) +TChA.Swap = new_instancemethod(_snap.TChA_Swap,None,TChA) +TChA.GetPrimHashCd = new_instancemethod(_snap.TChA_GetPrimHashCd,None,TChA) +TChA.GetSecHashCd = new_instancemethod(_snap.TChA_GetSecHashCd,None,TChA) +TChA.SaveTxt = new_instancemethod(_snap.TChA_SaveTxt,None,TChA) +TChA_swigregister = _snap.TChA_swigregister +TChA_swigregister(TChA) + +def TChA_LoadTxt(*args): + """ + TChA_LoadTxt(PSIn const & SIn, TChA ChA) + + Parameters: + SIn: PSIn const & + ChA: TChA & + + """ + return _snap.TChA_LoadTxt(*args) + +class TChAIn(TSIn): + """Proxy of C++ TChAIn class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TChAIn self, TChA ChA, int const & _BfC=0) -> TChAIn + + Parameters: + ChA: TChA const & + _BfC: int const & + + __init__(TChAIn self, TChA ChA) -> TChAIn + + Parameters: + ChA: TChA const & + + """ + _snap.TChAIn_swiginit(self,_snap.new_TChAIn(*args)) + def New(*args): + """ + New(TChA ChA) -> PSIn + + Parameters: + ChA: TChA const & + + """ + return _snap.TChAIn_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TChAIn +TChAIn_swigregister = _snap.TChAIn_swigregister +TChAIn_swigregister(TChAIn) + +def TChAIn_New(*args): + """ + TChAIn_New(TChA ChA) -> PSIn + + Parameters: + ChA: TChA const & + + """ + return _snap.TChAIn_New(*args) + +class TRStr(object): + """Proxy of C++ TRStr class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Bf = _swig_property(_snap.TRStr_Bf_get, _snap.TRStr_Bf_set) + Refs = _swig_property(_snap.TRStr_Refs_get, _snap.TRStr_Refs_set) + __swig_destroy__ = _snap.delete_TRStr + def __init__(self, *args): + """ + __init__(TRStr self) -> TRStr + __init__(TRStr self, int const & Len) -> TRStr + + Parameters: + Len: int const & + + __init__(TRStr self, char const * CStr) -> TRStr + + Parameters: + CStr: char const * + + __init__(TRStr self, char const * CStr, int const & MxLen) -> TRStr + + Parameters: + CStr: char const * + MxLen: int const & + + __init__(TRStr self, char const * CStr1, char const * CStr2) -> TRStr + + Parameters: + CStr1: char const * + CStr2: char const * + + __init__(TRStr self, char const & Ch) -> TRStr + + Parameters: + Ch: char const & + + __init__(TRStr self, char const & Ch1, char const & Ch2) -> TRStr + + Parameters: + Ch1: char const & + Ch2: char const & + + __init__(TRStr self, TSIn SIn, bool const & IsSmall) -> TRStr + + Parameters: + SIn: TSIn & + IsSmall: bool const & + + """ + _snap.TRStr_swiginit(self,_snap.new_TRStr(*args)) + def Save(self, *args): + """ + Save(TRStr self, TSOut SOut, bool const & IsSmall) + + Parameters: + SOut: TSOut & + IsSmall: bool const & + + """ + return _snap.TRStr_Save(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TRStr self) -> int + + Parameters: + self: TRStr const * + + """ + return _snap.TRStr_GetMemUsed(self) + + def MkRef(self): + """ + MkRef(TRStr self) + + Parameters: + self: TRStr * + + """ + return _snap.TRStr_MkRef(self) + + def UnRef(self): + """ + UnRef(TRStr self) + + Parameters: + self: TRStr * + + """ + return _snap.TRStr_UnRef(self) + + def CStr(self, *args): + """ + CStr(TRStr self) -> char const + CStr(TRStr self) -> char * + + Parameters: + self: TRStr * + + """ + return _snap.TRStr_CStr(self, *args) + + def Empty(self): + """ + Empty(TRStr self) -> bool + + Parameters: + self: TRStr const * + + """ + return _snap.TRStr_Empty(self) + + def Len(self): + """ + Len(TRStr self) -> int + + Parameters: + self: TRStr const * + + """ + return _snap.TRStr_Len(self) + + def PutCh(self, *args): + """ + PutCh(TRStr self, int const & ChN, char const & Ch) + + Parameters: + ChN: int const & + Ch: char const & + + """ + return _snap.TRStr_PutCh(self, *args) + + def GetCh(self, *args): + """ + GetCh(TRStr self, int const & ChN) -> char + + Parameters: + ChN: int const & + + """ + return _snap.TRStr_GetCh(self, *args) + + def IsUc(self): + """ + IsUc(TRStr self) -> bool + + Parameters: + self: TRStr const * + + """ + return _snap.TRStr_IsUc(self) + + def ToUc(self): + """ + ToUc(TRStr self) + + Parameters: + self: TRStr * + + """ + return _snap.TRStr_ToUc(self) + + def IsLc(self): + """ + IsLc(TRStr self) -> bool + + Parameters: + self: TRStr const * + + """ + return _snap.TRStr_IsLc(self) + + def ToLc(self): + """ + ToLc(TRStr self) + + Parameters: + self: TRStr * + + """ + return _snap.TRStr_ToLc(self) + + def ToCap(self): + """ + ToCap(TRStr self) + + Parameters: + self: TRStr * + + """ + return _snap.TRStr_ToCap(self) + + def ConvUsFromYuAscii(self): + """ + ConvUsFromYuAscii(TRStr self) + + Parameters: + self: TRStr * + + """ + return _snap.TRStr_ConvUsFromYuAscii(self) + + def CmpI(*args): + """ + CmpI(char const * CStr1, char const * CStr2) -> int + + Parameters: + CStr1: char const * + CStr2: char const * + + """ + return _snap.TRStr_CmpI(*args) + + CmpI = staticmethod(CmpI) + def GetPrimHashCd(self): + """ + GetPrimHashCd(TRStr self) -> int + + Parameters: + self: TRStr const * + + """ + return _snap.TRStr_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TRStr self) -> int + + Parameters: + self: TRStr const * + + """ + return _snap.TRStr_GetSecHashCd(self) + + def GetNullRStr(): + """GetNullRStr() -> TRStr""" + return _snap.TRStr_GetNullRStr() + + GetNullRStr = staticmethod(GetNullRStr) +TRStr.Save = new_instancemethod(_snap.TRStr_Save,None,TRStr) +TRStr.GetMemUsed = new_instancemethod(_snap.TRStr_GetMemUsed,None,TRStr) +TRStr.MkRef = new_instancemethod(_snap.TRStr_MkRef,None,TRStr) +TRStr.UnRef = new_instancemethod(_snap.TRStr_UnRef,None,TRStr) +TRStr.CStr = new_instancemethod(_snap.TRStr_CStr,None,TRStr) +TRStr.Empty = new_instancemethod(_snap.TRStr_Empty,None,TRStr) +TRStr.Len = new_instancemethod(_snap.TRStr_Len,None,TRStr) +TRStr.PutCh = new_instancemethod(_snap.TRStr_PutCh,None,TRStr) +TRStr.GetCh = new_instancemethod(_snap.TRStr_GetCh,None,TRStr) +TRStr.IsUc = new_instancemethod(_snap.TRStr_IsUc,None,TRStr) +TRStr.ToUc = new_instancemethod(_snap.TRStr_ToUc,None,TRStr) +TRStr.IsLc = new_instancemethod(_snap.TRStr_IsLc,None,TRStr) +TRStr.ToLc = new_instancemethod(_snap.TRStr_ToLc,None,TRStr) +TRStr.ToCap = new_instancemethod(_snap.TRStr_ToCap,None,TRStr) +TRStr.ConvUsFromYuAscii = new_instancemethod(_snap.TRStr_ConvUsFromYuAscii,None,TRStr) +TRStr.GetPrimHashCd = new_instancemethod(_snap.TRStr_GetPrimHashCd,None,TRStr) +TRStr.GetSecHashCd = new_instancemethod(_snap.TRStr_GetSecHashCd,None,TRStr) +TRStr_swigregister = _snap.TRStr_swigregister +TRStr_swigregister(TRStr) + +def TRStr_CmpI(*args): + """ + TRStr_CmpI(char const * CStr1, char const * CStr2) -> int + + Parameters: + CStr1: char const * + CStr2: char const * + + """ + return _snap.TRStr_CmpI(*args) + +def TRStr_GetNullRStr(): + """TRStr_GetNullRStr() -> TRStr""" + return _snap.TRStr_GetNullRStr() + +class TStr(object): + """Proxy of C++ TStr class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TStr + def __init__(self, *args): + """ + __init__(TStr self) -> TStr + __init__(TStr self, TStr Str) -> TStr + + Parameters: + Str: TStr const & + + __init__(TStr self, TChA ChA) -> TStr + + Parameters: + ChA: TChA const & + + __init__(TStr self, TSStr SStr) -> TStr + + Parameters: + SStr: TSStr const & + + __init__(TStr self, char const * CStr) -> TStr + + Parameters: + CStr: char const * + + __init__(TStr self, char const & Ch) -> TStr + + Parameters: + Ch: char const & + + __init__(TStr self, TMem Mem) -> TStr + + Parameters: + Mem: TMem const & + + __init__(TStr self, PSIn const & SIn) -> TStr + + Parameters: + SIn: PSIn const & + + __init__(TStr self, TSIn SIn, bool const & IsSmall=False) -> TStr + + Parameters: + SIn: TSIn & + IsSmall: bool const & + + __init__(TStr self, TSIn SIn) -> TStr + + Parameters: + SIn: TSIn & + + """ + _snap.TStr_swiginit(self,_snap.new_TStr(*args)) + def Load(self, *args): + """ + Load(TStr self, TSIn SIn, bool const & IsSmall=False) + + Parameters: + SIn: TSIn & + IsSmall: bool const & + + Load(TStr self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TStr_Load(self, *args) + + def Save(self, *args): + """ + Save(TStr self, TSOut SOut, bool const & IsSmall=False) + + Parameters: + SOut: TSOut & + IsSmall: bool const & + + Save(TStr self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TStr_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TStr self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TStr_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TStr self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TStr_SaveXml(self, *args) + + def __iadd__(self, *args): + """ + __iadd__(TStr self, TStr Str) -> TStr + + Parameters: + Str: TStr const & + + __iadd__(TStr self, char const * CStr) -> TStr + + Parameters: + CStr: char const * + + """ + return _snap.TStr___iadd__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TStr self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + __eq__(TStr self, char const * CStr) -> bool + + Parameters: + CStr: char const * + + """ + return _snap.TStr___eq__(self, *args) + + def __ne__(self, *args): + """ + __ne__(TStr self, char const * CStr) -> bool + + Parameters: + CStr: char const * + + """ + return _snap.TStr___ne__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TStr self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TStr___lt__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TStr self) -> int + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetMemUsed(self) + + def CStr(self, *args): + """ + CStr(TStr self) -> char + CStr(TStr self) -> char const * + + Parameters: + self: TStr const * + + """ + return _snap.TStr_CStr(self, *args) + + def PutCh(self, *args): + """ + PutCh(TStr self, int const & ChN, char const & Ch) + + Parameters: + ChN: int const & + Ch: char const & + + """ + return _snap.TStr_PutCh(self, *args) + + def GetCh(self, *args): + """ + GetCh(TStr self, int const & ChN) -> char + + Parameters: + ChN: int const & + + """ + return _snap.TStr_GetCh(self, *args) + + def LastCh(self): + """ + LastCh(TStr self) -> char + + Parameters: + self: TStr const * + + """ + return _snap.TStr_LastCh(self) + + def Clr(self): + """ + Clr(TStr self) + + Parameters: + self: TStr * + + """ + return _snap.TStr_Clr(self) + + def Len(self): + """ + Len(TStr self) -> int + + Parameters: + self: TStr const * + + """ + return _snap.TStr_Len(self) + + def Empty(self): + """ + Empty(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_Empty(self) + + def IsUc(self): + """ + IsUc(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsUc(self) + + def ToUc(self): + """ + ToUc(TStr self) -> TStr + + Parameters: + self: TStr * + + """ + return _snap.TStr_ToUc(self) + + def GetUc(self): + """ + GetUc(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetUc(self) + + def CmpI(self, *args): + """ + CmpI(TStr self, TStr Str) -> int + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_CmpI(self, *args) + + def EqI(self, *args): + """ + EqI(TStr self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_EqI(self, *args) + + def IsLc(self): + """ + IsLc(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsLc(self) + + def ToLc(self): + """ + ToLc(TStr self) -> TStr + + Parameters: + self: TStr * + + """ + return _snap.TStr_ToLc(self) + + def GetLc(self): + """ + GetLc(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetLc(self) + + def ToCap(self): + """ + ToCap(TStr self) -> TStr + + Parameters: + self: TStr * + + """ + return _snap.TStr_ToCap(self) + + def GetCap(self): + """ + GetCap(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetCap(self) + + def ToTrunc(self): + """ + ToTrunc(TStr self) -> TStr + + Parameters: + self: TStr * + + """ + return _snap.TStr_ToTrunc(self) + + def GetTrunc(self): + """ + GetTrunc(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetTrunc(self) + + def ConvUsFromYuAscii(self): + """ + ConvUsFromYuAscii(TStr self) -> TStr + + Parameters: + self: TStr * + + """ + return _snap.TStr_ConvUsFromYuAscii(self) + + def GetUsFromYuAscii(self): + """ + GetUsFromYuAscii(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetUsFromYuAscii(self) + + def ToHex(self): + """ + ToHex(TStr self) -> TStr + + Parameters: + self: TStr * + + """ + return _snap.TStr_ToHex(self) + + def GetHex(self): + """ + GetHex(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetHex(self) + + def FromHex(self): + """ + FromHex(TStr self) -> TStr + + Parameters: + self: TStr * + + """ + return _snap.TStr_FromHex(self) + + def GetFromHex(self): + """ + GetFromHex(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetFromHex(self) + + def GetSubStr(self, *args): + """ + GetSubStr(TStr self, int const & BChN, int const & EChN) -> TStr + + Parameters: + BChN: int const & + EChN: int const & + + GetSubStr(TStr self, int const & BChN) -> TStr + + Parameters: + BChN: int const & + + """ + return _snap.TStr_GetSubStr(self, *args) + + def InsStr(self, *args): + """ + InsStr(TStr self, int const & BChN, TStr Str) + + Parameters: + BChN: int const & + Str: TStr const & + + """ + return _snap.TStr_InsStr(self, *args) + + def DelChAll(self, *args): + """ + DelChAll(TStr self, char const & Ch) + + Parameters: + Ch: char const & + + """ + return _snap.TStr_DelChAll(self, *args) + + def DelSubStr(self, *args): + """ + DelSubStr(TStr self, int const & BChN, int const & EChN) + + Parameters: + BChN: int const & + EChN: int const & + + """ + return _snap.TStr_DelSubStr(self, *args) + + def DelStr(self, *args): + """ + DelStr(TStr self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_DelStr(self, *args) + + def LeftOf(self, *args): + """ + LeftOf(TStr self, char const & SplitCh) -> TStr + + Parameters: + SplitCh: char const & + + """ + return _snap.TStr_LeftOf(self, *args) + + def LeftOfLast(self, *args): + """ + LeftOfLast(TStr self, char const & SplitCh) -> TStr + + Parameters: + SplitCh: char const & + + """ + return _snap.TStr_LeftOfLast(self, *args) + + def RightOf(self, *args): + """ + RightOf(TStr self, char const & SplitCh) -> TStr + + Parameters: + SplitCh: char const & + + """ + return _snap.TStr_RightOf(self, *args) + + def RightOfLast(self, *args): + """ + RightOfLast(TStr self, char const & SplitCh) -> TStr + + Parameters: + SplitCh: char const & + + """ + return _snap.TStr_RightOfLast(self, *args) + + def SplitOnCh(self, *args): + """ + SplitOnCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr) + + Parameters: + LStr: TStr & + SplitCh: char const & + RStr: TStr & + + """ + return _snap.TStr_SplitOnCh(self, *args) + + def SplitOnLastCh(self, *args): + """ + SplitOnLastCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr) + + Parameters: + LStr: TStr & + SplitCh: char const & + RStr: TStr & + + """ + return _snap.TStr_SplitOnLastCh(self, *args) + + def SplitOnAllCh(self, *args): + """ + SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV, bool const & SkipEmpty=True) + + Parameters: + SplitCh: char const & + StrV: TStrV & + SkipEmpty: bool const & + + SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV) + + Parameters: + SplitCh: char const & + StrV: TStrV & + + """ + return _snap.TStr_SplitOnAllCh(self, *args) + + def SplitOnAllAnyCh(self, *args): + """ + SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV, bool const & SkipEmpty=True) + + Parameters: + SplitChStr: TStr const & + StrV: TStrV & + SkipEmpty: bool const & + + SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV) + + Parameters: + SplitChStr: TStr const & + StrV: TStrV & + + """ + return _snap.TStr_SplitOnAllAnyCh(self, *args) + + def SplitOnWs(self, *args): + """ + SplitOnWs(TStr self, TStrV StrV) + + Parameters: + StrV: TStrV & + + """ + return _snap.TStr_SplitOnWs(self, *args) + + def SplitOnNonAlNum(self, *args): + """ + SplitOnNonAlNum(TStr self, TStrV StrV) + + Parameters: + StrV: TStrV & + + """ + return _snap.TStr_SplitOnNonAlNum(self, *args) + + def SplitOnStr(self, *args): + """ + SplitOnStr(TStr self, TStr SplitStr, TStrV StrV) + + Parameters: + SplitStr: TStr const & + StrV: TStrV & + + SplitOnStr(TStr self, TStr LeftStr, TStr MidStr, TStr RightStr) + + Parameters: + LeftStr: TStr & + MidStr: TStr const & + RightStr: TStr & + + """ + return _snap.TStr_SplitOnStr(self, *args) + + def Mid(self, *args): + """ + Mid(TStr self, int const & BChN, int const & Chs) -> TStr + + Parameters: + BChN: int const & + Chs: int const & + + Mid(TStr self, int const & BChN) -> TStr + + Parameters: + BChN: int const & + + """ + return _snap.TStr_Mid(self, *args) + + def Left(self, *args): + """ + Left(TStr self, int const & EChN) -> TStr + + Parameters: + EChN: int const & + + """ + return _snap.TStr_Left(self, *args) + + def Right(self, *args): + """ + Right(TStr self, int const & BChN) -> TStr + + Parameters: + BChN: int const & + + """ + return _snap.TStr_Right(self, *args) + + def Slice(self, *args): + """ + Slice(TStr self, int BChN, int EChNP1) -> TStr + + Parameters: + BChN: int + EChNP1: int + + """ + return _snap.TStr_Slice(self, *args) + + def __call__(self, *args): + """ + __call__(TStr self) -> char + __call__(TStr self) -> char const + __call__(TStr self, int const & BChN, int const & EChNP1) -> TStr + + Parameters: + BChN: int const & + EChNP1: int const & + + """ + return _snap.TStr___call__(self, *args) + + def CountCh(self, *args): + """ + CountCh(TStr self, char const & Ch, int const & BChN=0) -> int + + Parameters: + Ch: char const & + BChN: int const & + + CountCh(TStr self, char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TStr_CountCh(self, *args) + + def SearchCh(self, *args): + """ + SearchCh(TStr self, char const & Ch, int const & BChN=0) -> int + + Parameters: + Ch: char const & + BChN: int const & + + SearchCh(TStr self, char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TStr_SearchCh(self, *args) + + def SearchChBack(self, *args): + """ + SearchChBack(TStr self, char const & Ch, int BChN=-1) -> int + + Parameters: + Ch: char const & + BChN: int + + SearchChBack(TStr self, char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TStr_SearchChBack(self, *args) + + def SearchStr(self, *args): + """ + SearchStr(TStr self, TStr Str, int const & BChN=0) -> int + + Parameters: + Str: TStr const & + BChN: int const & + + SearchStr(TStr self, TStr Str) -> int + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_SearchStr(self, *args) + + def IsChIn(self, *args): + """ + IsChIn(TStr self, char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TStr_IsChIn(self, *args) + + def IsStrIn(self, *args): + """ + IsStrIn(TStr self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_IsStrIn(self, *args) + + def IsPrefix(self, *args): + """ + IsPrefix(TStr self, char const * Str) -> bool + + Parameters: + Str: char const * + + IsPrefix(TStr self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_IsPrefix(self, *args) + + def IsSuffix(self, *args): + """ + IsSuffix(TStr self, char const * Str) -> bool + + Parameters: + Str: char const * + + IsSuffix(TStr self, TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_IsSuffix(self, *args) + + def ChangeCh(self, *args): + """ + ChangeCh(TStr self, char const & SrcCh, char const & DstCh, int const & BChN=0) -> int + + Parameters: + SrcCh: char const & + DstCh: char const & + BChN: int const & + + ChangeCh(TStr self, char const & SrcCh, char const & DstCh) -> int + + Parameters: + SrcCh: char const & + DstCh: char const & + + """ + return _snap.TStr_ChangeCh(self, *args) + + def ChangeChAll(self, *args): + """ + ChangeChAll(TStr self, char const & SrcCh, char const & DstCh) -> int + + Parameters: + SrcCh: char const & + DstCh: char const & + + """ + return _snap.TStr_ChangeChAll(self, *args) + + def ChangeStr(self, *args): + """ + ChangeStr(TStr self, TStr SrcStr, TStr DstStr, int const & BChN=0) -> int + + Parameters: + SrcStr: TStr const & + DstStr: TStr const & + BChN: int const & + + ChangeStr(TStr self, TStr SrcStr, TStr DstStr) -> int + + Parameters: + SrcStr: TStr const & + DstStr: TStr const & + + """ + return _snap.TStr_ChangeStr(self, *args) + + def ChangeStrAll(self, *args): + """ + ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr, bool const & FromStartP=False) -> int + + Parameters: + SrcStr: TStr const & + DstStr: TStr const & + FromStartP: bool const & + + ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr) -> int + + Parameters: + SrcStr: TStr const & + DstStr: TStr const & + + """ + return _snap.TStr_ChangeStrAll(self, *args) + + def Reverse(self): + """ + Reverse(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_Reverse(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TStr self) -> int + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TStr self) -> int + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetSecHashCd(self) + + def IsBool(self, *args): + """ + IsBool(TStr self, bool & Val) -> bool + + Parameters: + Val: bool & + + """ + return _snap.TStr_IsBool(self, *args) + + def IsInt(self, *args): + """ + IsInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool + + Parameters: + Check: bool const & + MnVal: int const & + MxVal: int const & + Val: int & + + IsInt(TStr self, int & Val) -> bool + + Parameters: + Val: int & + + IsInt(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsInt(self, *args) + + def GetInt(self, *args): + """ + GetInt(TStr self) -> int + GetInt(TStr self, int const & DfVal) -> int + + Parameters: + DfVal: int const & + + """ + return _snap.TStr_GetInt(self, *args) + + def IsUInt(self, *args): + """ + IsUInt(TStr self, bool const & Check, uint const & MnVal, uint const & MxVal, uint & Val) -> bool + + Parameters: + Check: bool const & + MnVal: uint const & + MxVal: uint const & + Val: uint & + + IsUInt(TStr self, uint & Val) -> bool + + Parameters: + Val: uint & + + IsUInt(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsUInt(self, *args) + + def GetUInt(self, *args): + """ + GetUInt(TStr self) -> uint + GetUInt(TStr self, uint const & DfVal) -> uint + + Parameters: + DfVal: uint const & + + """ + return _snap.TStr_GetUInt(self, *args) + + def IsInt64(self, *args): + """ + IsInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool + + Parameters: + Check: bool const & + MnVal: int64 const & + MxVal: int64 const & + Val: int64 & + + IsInt64(TStr self, int64 & Val) -> bool + + Parameters: + Val: int64 & + + IsInt64(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsInt64(self, *args) + + def GetInt64(self, *args): + """ + GetInt64(TStr self) -> int64 + GetInt64(TStr self, int64 const & DfVal) -> int64 + + Parameters: + DfVal: int64 const & + + """ + return _snap.TStr_GetInt64(self, *args) + + def IsUInt64(self, *args): + """ + IsUInt64(TStr self, bool const & Check, uint64 const & MnVal, uint64 const & MxVal, uint64 & Val) -> bool + + Parameters: + Check: bool const & + MnVal: uint64 const & + MxVal: uint64 const & + Val: uint64 & + + IsUInt64(TStr self, uint64 & Val) -> bool + + Parameters: + Val: uint64 & + + IsUInt64(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsUInt64(self, *args) + + def GetUInt64(self, *args): + """ + GetUInt64(TStr self) -> uint64 + GetUInt64(TStr self, uint64 const & DfVal) -> uint64 + + Parameters: + DfVal: uint64 const & + + """ + return _snap.TStr_GetUInt64(self, *args) + + def IsHexInt(self, *args): + """ + IsHexInt(TStr self, bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool + + Parameters: + Check: bool const & + MnVal: int const & + MxVal: int const & + Val: int & + + IsHexInt(TStr self, int & Val) -> bool + + Parameters: + Val: int & + + IsHexInt(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsHexInt(self, *args) + + def GetHexInt(self, *args): + """ + GetHexInt(TStr self) -> int + GetHexInt(TStr self, int const & DfVal) -> int + + Parameters: + DfVal: int const & + + """ + return _snap.TStr_GetHexInt(self, *args) + + def IsHexInt64(self, *args): + """ + IsHexInt64(TStr self, bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool + + Parameters: + Check: bool const & + MnVal: int64 const & + MxVal: int64 const & + Val: int64 & + + IsHexInt64(TStr self, int64 & Val) -> bool + + Parameters: + Val: int64 & + + IsHexInt64(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsHexInt64(self, *args) + + def GetHexInt64(self, *args): + """ + GetHexInt64(TStr self) -> int64 + GetHexInt64(TStr self, int64 const & DfVal) -> int64 + + Parameters: + DfVal: int64 const & + + """ + return _snap.TStr_GetHexInt64(self, *args) + + def IsFlt(self, *args): + """ + IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val, char const & DecDelimCh='.') -> bool + + Parameters: + Check: bool const & + MnVal: double const & + MxVal: double const & + Val: double & + DecDelimCh: char const & + + IsFlt(TStr self, bool const & Check, double const & MnVal, double const & MxVal, double & Val) -> bool + + Parameters: + Check: bool const & + MnVal: double const & + MxVal: double const & + Val: double & + + IsFlt(TStr self, double & Val) -> bool + + Parameters: + Val: double & + + IsFlt(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsFlt(self, *args) + + def GetFlt(self, *args): + """ + GetFlt(TStr self) -> double + GetFlt(TStr self, double const & DfVal) -> double + + Parameters: + DfVal: double const & + + """ + return _snap.TStr_GetFlt(self, *args) + + def IsWord(self, WsPrefixP=True, FirstUcAllowedP=True): + """ + IsWord(TStr self, bool const & WsPrefixP=True, bool const & FirstUcAllowedP=True) -> bool + + Parameters: + WsPrefixP: bool const & + FirstUcAllowedP: bool const & + + IsWord(TStr self, bool const & WsPrefixP=True) -> bool + + Parameters: + WsPrefixP: bool const & + + IsWord(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsWord(self, WsPrefixP, FirstUcAllowedP) + + def IsWs(self): + """ + IsWs(TStr self) -> bool + + Parameters: + self: TStr const * + + """ + return _snap.TStr_IsWs(self) + + def IsWcMatch(self, *args): + """ + IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*', + char const & QuestCh='?') -> bool + + Parameters: + StrBChN: int const & + WcStr: TStr const & + WcStrBChN: int const & + StarStrV: TStrV & + StarCh: char const & + QuestCh: char const & + + IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*') -> bool + + Parameters: + StrBChN: int const & + WcStr: TStr const & + WcStrBChN: int const & + StarStrV: TStrV & + StarCh: char const & + + IsWcMatch(TStr self, int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV) -> bool + + Parameters: + StrBChN: int const & + WcStr: TStr const & + WcStrBChN: int const & + StarStrV: TStrV & + + IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*', char const & QuestCh='?') -> bool + + Parameters: + WcStr: TStr const & + StarStrV: TStrV & + StarCh: char const & + QuestCh: char const & + + IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV, char const & StarCh='*') -> bool + + Parameters: + WcStr: TStr const & + StarStrV: TStrV & + StarCh: char const & + + IsWcMatch(TStr self, TStr WcStr, TStrV StarStrV) -> bool + + Parameters: + WcStr: TStr const & + StarStrV: TStrV & + + IsWcMatch(TStr self, TStr WcStr, char const & StarCh, char const & QuestCh) -> bool + + Parameters: + WcStr: TStr const & + StarCh: char const & + QuestCh: char const & + + IsWcMatch(TStr self, TStr WcStr, int const & StarStrN, TStr StarStr) -> bool + + Parameters: + WcStr: TStr const & + StarStrN: int const & + StarStr: TStr & + + IsWcMatch(TStr self, TStr WcStr) -> bool + + Parameters: + WcStr: TStr const & + + """ + return _snap.TStr_IsWcMatch(self, *args) + + def GetWcMatch(self, *args): + """ + GetWcMatch(TStr self, TStr WcStr, int const & StarStrN=0) -> TStr + + Parameters: + WcStr: TStr const & + StarStrN: int const & + + GetWcMatch(TStr self, TStr WcStr) -> TStr + + Parameters: + WcStr: TStr const & + + """ + return _snap.TStr_GetWcMatch(self, *args) + + def GetFPath(self): + """ + GetFPath(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetFPath(self) + + def GetFBase(self): + """ + GetFBase(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetFBase(self) + + def GetFMid(self): + """ + GetFMid(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetFMid(self) + + def GetFExt(self): + """ + GetFExt(TStr self) -> TStr + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetFExt(self) + + def GetNrFPath(*args): + """ + GetNrFPath(TStr FPath) -> TStr + + Parameters: + FPath: TStr const & + + """ + return _snap.TStr_GetNrFPath(*args) + + GetNrFPath = staticmethod(GetNrFPath) + def GetNrFMid(*args): + """ + GetNrFMid(TStr FMid) -> TStr + + Parameters: + FMid: TStr const & + + """ + return _snap.TStr_GetNrFMid(*args) + + GetNrFMid = staticmethod(GetNrFMid) + def GetNrFExt(*args): + """ + GetNrFExt(TStr FExt) -> TStr + + Parameters: + FExt: TStr const & + + """ + return _snap.TStr_GetNrFExt(*args) + + GetNrFExt = staticmethod(GetNrFExt) + def GetNrNumFExt(*args): + """ + GetNrNumFExt(int const & FExtN) -> TStr + + Parameters: + FExtN: int const & + + """ + return _snap.TStr_GetNrNumFExt(*args) + + GetNrNumFExt = staticmethod(GetNrNumFExt) + def GetNrFNm(*args): + """ + GetNrFNm(TStr FNm) -> TStr + + Parameters: + FNm: TStr const & + + """ + return _snap.TStr_GetNrFNm(*args) + + GetNrFNm = staticmethod(GetNrFNm) + def GetNrAbsFPath(*args): + """ + GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr + + Parameters: + FPath: TStr const & + BaseFPath: TStr const & + + GetNrAbsFPath(TStr FPath) -> TStr + + Parameters: + FPath: TStr const & + + """ + return _snap.TStr_GetNrAbsFPath(*args) + + GetNrAbsFPath = staticmethod(GetNrAbsFPath) + def IsAbsFPath(*args): + """ + IsAbsFPath(TStr FPath) -> bool + + Parameters: + FPath: TStr const & + + """ + return _snap.TStr_IsAbsFPath(*args) + + IsAbsFPath = staticmethod(IsAbsFPath) + def PutFExt(*args): + """ + PutFExt(TStr FNm, TStr FExt) -> TStr + + Parameters: + FNm: TStr const & + FExt: TStr const & + + """ + return _snap.TStr_PutFExt(*args) + + PutFExt = staticmethod(PutFExt) + def PutFExtIfEmpty(*args): + """ + PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr + + Parameters: + FNm: TStr const & + FExt: TStr const & + + """ + return _snap.TStr_PutFExtIfEmpty(*args) + + PutFExtIfEmpty = staticmethod(PutFExtIfEmpty) + def PutFBase(*args): + """ + PutFBase(TStr FNm, TStr FBase) -> TStr + + Parameters: + FNm: TStr const & + FBase: TStr const & + + """ + return _snap.TStr_PutFBase(*args) + + PutFBase = staticmethod(PutFBase) + def PutFBaseIfEmpty(*args): + """ + PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr + + Parameters: + FNm: TStr const & + FBase: TStr const & + + """ + return _snap.TStr_PutFBaseIfEmpty(*args) + + PutFBaseIfEmpty = staticmethod(PutFBaseIfEmpty) + def AddToFMid(*args): + """ + AddToFMid(TStr FNm, TStr ExtFMid) -> TStr + + Parameters: + FNm: TStr const & + ExtFMid: TStr const & + + """ + return _snap.TStr_AddToFMid(*args) + + AddToFMid = staticmethod(AddToFMid) + def GetNumFNm(*args): + """ + GetNumFNm(TStr FNm, int const & Num) -> TStr + + Parameters: + FNm: TStr const & + Num: int const & + + """ + return _snap.TStr_GetNumFNm(*args) + + GetNumFNm = staticmethod(GetNumFNm) + def GetFNmStr(*args): + """ + GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr + + Parameters: + Str: TStr const & + AlNumOnlyP: bool const & + + GetFNmStr(TStr Str) -> TStr + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_GetFNmStr(*args) + + GetFNmStr = staticmethod(GetFNmStr) + def LoadTxt(*args): + """ + LoadTxt(PSIn const & SIn) -> TStr + + Parameters: + SIn: PSIn const & + + LoadTxt(TStr FNm) -> TStr + + Parameters: + FNm: TStr const & + + """ + return _snap.TStr_LoadTxt(*args) + + LoadTxt = staticmethod(LoadTxt) + def SaveTxt(self, *args): + """ + SaveTxt(TStr self, PSOut const & SOut) + + Parameters: + SOut: PSOut const & + + SaveTxt(TStr self, TStr FNm) + + Parameters: + FNm: TStr const & + + """ + return _snap.TStr_SaveTxt(self, *args) + + def GetChStr(*args): + """ + GetChStr(char const & Ch) -> TStr + + Parameters: + Ch: char const & + + """ + return _snap.TStr_GetChStr(*args) + + GetChStr = staticmethod(GetChStr) + def GetDChStr(*args): + """ + GetDChStr(char const & Ch1, char const & Ch2) -> TStr + + Parameters: + Ch1: char const & + Ch2: char const & + + """ + return _snap.TStr_GetDChStr(*args) + + GetDChStr = staticmethod(GetDChStr) + def Fmt(*args): + """ + Fmt(char const * FmtStr) -> TStr + + Parameters: + FmtStr: char const * + + """ + return _snap.TStr_Fmt(*args) + + Fmt = staticmethod(Fmt) + def GetSpaceStr(*args): + """ + GetSpaceStr(int const & Spaces) -> TStr + + Parameters: + Spaces: int const & + + """ + return _snap.TStr_GetSpaceStr(*args) + + GetSpaceStr = staticmethod(GetSpaceStr) + def GetCStr(self): + """ + GetCStr(TStr self) -> char * + + Parameters: + self: TStr const * + + """ + return _snap.TStr_GetCStr(self) + + def MkClone(*args): + """ + MkClone(TStr Str) -> TStr + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_MkClone(*args) + + MkClone = staticmethod(MkClone) + def GetNullStr(): + """GetNullStr() -> TStr""" + return _snap.TStr_GetNullStr() + + GetNullStr = staticmethod(GetNullStr) +TStr.Load = new_instancemethod(_snap.TStr_Load,None,TStr) +TStr.Save = new_instancemethod(_snap.TStr_Save,None,TStr) +TStr.LoadXml = new_instancemethod(_snap.TStr_LoadXml,None,TStr) +TStr.SaveXml = new_instancemethod(_snap.TStr_SaveXml,None,TStr) +TStr.__iadd__ = new_instancemethod(_snap.TStr___iadd__,None,TStr) +TStr.__eq__ = new_instancemethod(_snap.TStr___eq__,None,TStr) +TStr.__ne__ = new_instancemethod(_snap.TStr___ne__,None,TStr) +TStr.__lt__ = new_instancemethod(_snap.TStr___lt__,None,TStr) +TStr.GetMemUsed = new_instancemethod(_snap.TStr_GetMemUsed,None,TStr) +TStr.CStr = new_instancemethod(_snap.TStr_CStr,None,TStr) +TStr.PutCh = new_instancemethod(_snap.TStr_PutCh,None,TStr) +TStr.GetCh = new_instancemethod(_snap.TStr_GetCh,None,TStr) +TStr.LastCh = new_instancemethod(_snap.TStr_LastCh,None,TStr) +TStr.Clr = new_instancemethod(_snap.TStr_Clr,None,TStr) +TStr.Len = new_instancemethod(_snap.TStr_Len,None,TStr) +TStr.Empty = new_instancemethod(_snap.TStr_Empty,None,TStr) +TStr.IsUc = new_instancemethod(_snap.TStr_IsUc,None,TStr) +TStr.ToUc = new_instancemethod(_snap.TStr_ToUc,None,TStr) +TStr.GetUc = new_instancemethod(_snap.TStr_GetUc,None,TStr) +TStr.CmpI = new_instancemethod(_snap.TStr_CmpI,None,TStr) +TStr.EqI = new_instancemethod(_snap.TStr_EqI,None,TStr) +TStr.IsLc = new_instancemethod(_snap.TStr_IsLc,None,TStr) +TStr.ToLc = new_instancemethod(_snap.TStr_ToLc,None,TStr) +TStr.GetLc = new_instancemethod(_snap.TStr_GetLc,None,TStr) +TStr.ToCap = new_instancemethod(_snap.TStr_ToCap,None,TStr) +TStr.GetCap = new_instancemethod(_snap.TStr_GetCap,None,TStr) +TStr.ToTrunc = new_instancemethod(_snap.TStr_ToTrunc,None,TStr) +TStr.GetTrunc = new_instancemethod(_snap.TStr_GetTrunc,None,TStr) +TStr.ConvUsFromYuAscii = new_instancemethod(_snap.TStr_ConvUsFromYuAscii,None,TStr) +TStr.GetUsFromYuAscii = new_instancemethod(_snap.TStr_GetUsFromYuAscii,None,TStr) +TStr.ToHex = new_instancemethod(_snap.TStr_ToHex,None,TStr) +TStr.GetHex = new_instancemethod(_snap.TStr_GetHex,None,TStr) +TStr.FromHex = new_instancemethod(_snap.TStr_FromHex,None,TStr) +TStr.GetFromHex = new_instancemethod(_snap.TStr_GetFromHex,None,TStr) +TStr.GetSubStr = new_instancemethod(_snap.TStr_GetSubStr,None,TStr) +TStr.InsStr = new_instancemethod(_snap.TStr_InsStr,None,TStr) +TStr.DelChAll = new_instancemethod(_snap.TStr_DelChAll,None,TStr) +TStr.DelSubStr = new_instancemethod(_snap.TStr_DelSubStr,None,TStr) +TStr.DelStr = new_instancemethod(_snap.TStr_DelStr,None,TStr) +TStr.LeftOf = new_instancemethod(_snap.TStr_LeftOf,None,TStr) +TStr.LeftOfLast = new_instancemethod(_snap.TStr_LeftOfLast,None,TStr) +TStr.RightOf = new_instancemethod(_snap.TStr_RightOf,None,TStr) +TStr.RightOfLast = new_instancemethod(_snap.TStr_RightOfLast,None,TStr) +TStr.SplitOnCh = new_instancemethod(_snap.TStr_SplitOnCh,None,TStr) +TStr.SplitOnLastCh = new_instancemethod(_snap.TStr_SplitOnLastCh,None,TStr) +TStr.SplitOnAllCh = new_instancemethod(_snap.TStr_SplitOnAllCh,None,TStr) +TStr.SplitOnAllAnyCh = new_instancemethod(_snap.TStr_SplitOnAllAnyCh,None,TStr) +TStr.SplitOnWs = new_instancemethod(_snap.TStr_SplitOnWs,None,TStr) +TStr.SplitOnNonAlNum = new_instancemethod(_snap.TStr_SplitOnNonAlNum,None,TStr) +TStr.SplitOnStr = new_instancemethod(_snap.TStr_SplitOnStr,None,TStr) +TStr.Mid = new_instancemethod(_snap.TStr_Mid,None,TStr) +TStr.Left = new_instancemethod(_snap.TStr_Left,None,TStr) +TStr.Right = new_instancemethod(_snap.TStr_Right,None,TStr) +TStr.Slice = new_instancemethod(_snap.TStr_Slice,None,TStr) +TStr.__call__ = new_instancemethod(_snap.TStr___call__,None,TStr) +TStr.CountCh = new_instancemethod(_snap.TStr_CountCh,None,TStr) +TStr.SearchCh = new_instancemethod(_snap.TStr_SearchCh,None,TStr) +TStr.SearchChBack = new_instancemethod(_snap.TStr_SearchChBack,None,TStr) +TStr.SearchStr = new_instancemethod(_snap.TStr_SearchStr,None,TStr) +TStr.IsChIn = new_instancemethod(_snap.TStr_IsChIn,None,TStr) +TStr.IsStrIn = new_instancemethod(_snap.TStr_IsStrIn,None,TStr) +TStr.IsPrefix = new_instancemethod(_snap.TStr_IsPrefix,None,TStr) +TStr.IsSuffix = new_instancemethod(_snap.TStr_IsSuffix,None,TStr) +TStr.ChangeCh = new_instancemethod(_snap.TStr_ChangeCh,None,TStr) +TStr.ChangeChAll = new_instancemethod(_snap.TStr_ChangeChAll,None,TStr) +TStr.ChangeStr = new_instancemethod(_snap.TStr_ChangeStr,None,TStr) +TStr.ChangeStrAll = new_instancemethod(_snap.TStr_ChangeStrAll,None,TStr) +TStr.Reverse = new_instancemethod(_snap.TStr_Reverse,None,TStr) +TStr.GetPrimHashCd = new_instancemethod(_snap.TStr_GetPrimHashCd,None,TStr) +TStr.GetSecHashCd = new_instancemethod(_snap.TStr_GetSecHashCd,None,TStr) +TStr.IsBool = new_instancemethod(_snap.TStr_IsBool,None,TStr) +TStr.IsInt = new_instancemethod(_snap.TStr_IsInt,None,TStr) +TStr.GetInt = new_instancemethod(_snap.TStr_GetInt,None,TStr) +TStr.IsUInt = new_instancemethod(_snap.TStr_IsUInt,None,TStr) +TStr.GetUInt = new_instancemethod(_snap.TStr_GetUInt,None,TStr) +TStr.IsInt64 = new_instancemethod(_snap.TStr_IsInt64,None,TStr) +TStr.GetInt64 = new_instancemethod(_snap.TStr_GetInt64,None,TStr) +TStr.IsUInt64 = new_instancemethod(_snap.TStr_IsUInt64,None,TStr) +TStr.GetUInt64 = new_instancemethod(_snap.TStr_GetUInt64,None,TStr) +TStr.IsHexInt = new_instancemethod(_snap.TStr_IsHexInt,None,TStr) +TStr.GetHexInt = new_instancemethod(_snap.TStr_GetHexInt,None,TStr) +TStr.IsHexInt64 = new_instancemethod(_snap.TStr_IsHexInt64,None,TStr) +TStr.GetHexInt64 = new_instancemethod(_snap.TStr_GetHexInt64,None,TStr) +TStr.IsFlt = new_instancemethod(_snap.TStr_IsFlt,None,TStr) +TStr.GetFlt = new_instancemethod(_snap.TStr_GetFlt,None,TStr) +TStr.IsWord = new_instancemethod(_snap.TStr_IsWord,None,TStr) +TStr.IsWs = new_instancemethod(_snap.TStr_IsWs,None,TStr) +TStr.IsWcMatch = new_instancemethod(_snap.TStr_IsWcMatch,None,TStr) +TStr.GetWcMatch = new_instancemethod(_snap.TStr_GetWcMatch,None,TStr) +TStr.GetFPath = new_instancemethod(_snap.TStr_GetFPath,None,TStr) +TStr.GetFBase = new_instancemethod(_snap.TStr_GetFBase,None,TStr) +TStr.GetFMid = new_instancemethod(_snap.TStr_GetFMid,None,TStr) +TStr.GetFExt = new_instancemethod(_snap.TStr_GetFExt,None,TStr) +TStr.SaveTxt = new_instancemethod(_snap.TStr_SaveTxt,None,TStr) +TStr.GetCStr = new_instancemethod(_snap.TStr_GetCStr,None,TStr) +TStr_swigregister = _snap.TStr_swigregister +TStr_swigregister(TStr) + +def TStr_GetNrFPath(*args): + """ + TStr_GetNrFPath(TStr FPath) -> TStr + + Parameters: + FPath: TStr const & + + """ + return _snap.TStr_GetNrFPath(*args) + +def TStr_GetNrFMid(*args): + """ + TStr_GetNrFMid(TStr FMid) -> TStr + + Parameters: + FMid: TStr const & + + """ + return _snap.TStr_GetNrFMid(*args) + +def TStr_GetNrFExt(*args): + """ + TStr_GetNrFExt(TStr FExt) -> TStr + + Parameters: + FExt: TStr const & + + """ + return _snap.TStr_GetNrFExt(*args) + +def TStr_GetNrNumFExt(*args): + """ + TStr_GetNrNumFExt(int const & FExtN) -> TStr + + Parameters: + FExtN: int const & + + """ + return _snap.TStr_GetNrNumFExt(*args) + +def TStr_GetNrFNm(*args): + """ + TStr_GetNrFNm(TStr FNm) -> TStr + + Parameters: + FNm: TStr const & + + """ + return _snap.TStr_GetNrFNm(*args) + +def TStr_GetNrAbsFPath(*args): + """ + GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr + + Parameters: + FPath: TStr const & + BaseFPath: TStr const & + + TStr_GetNrAbsFPath(TStr FPath) -> TStr + + Parameters: + FPath: TStr const & + + """ + return _snap.TStr_GetNrAbsFPath(*args) + +def TStr_IsAbsFPath(*args): + """ + TStr_IsAbsFPath(TStr FPath) -> bool + + Parameters: + FPath: TStr const & + + """ + return _snap.TStr_IsAbsFPath(*args) + +def TStr_PutFExt(*args): + """ + TStr_PutFExt(TStr FNm, TStr FExt) -> TStr + + Parameters: + FNm: TStr const & + FExt: TStr const & + + """ + return _snap.TStr_PutFExt(*args) + +def TStr_PutFExtIfEmpty(*args): + """ + TStr_PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr + + Parameters: + FNm: TStr const & + FExt: TStr const & + + """ + return _snap.TStr_PutFExtIfEmpty(*args) + +def TStr_PutFBase(*args): + """ + TStr_PutFBase(TStr FNm, TStr FBase) -> TStr + + Parameters: + FNm: TStr const & + FBase: TStr const & + + """ + return _snap.TStr_PutFBase(*args) + +def TStr_PutFBaseIfEmpty(*args): + """ + TStr_PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr + + Parameters: + FNm: TStr const & + FBase: TStr const & + + """ + return _snap.TStr_PutFBaseIfEmpty(*args) + +def TStr_AddToFMid(*args): + """ + TStr_AddToFMid(TStr FNm, TStr ExtFMid) -> TStr + + Parameters: + FNm: TStr const & + ExtFMid: TStr const & + + """ + return _snap.TStr_AddToFMid(*args) + +def TStr_GetNumFNm(*args): + """ + TStr_GetNumFNm(TStr FNm, int const & Num) -> TStr + + Parameters: + FNm: TStr const & + Num: int const & + + """ + return _snap.TStr_GetNumFNm(*args) + +def TStr_GetFNmStr(*args): + """ + GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr + + Parameters: + Str: TStr const & + AlNumOnlyP: bool const & + + TStr_GetFNmStr(TStr Str) -> TStr + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_GetFNmStr(*args) + +def TStr_LoadTxt(*args): + """ + LoadTxt(PSIn const & SIn) -> TStr + + Parameters: + SIn: PSIn const & + + TStr_LoadTxt(TStr FNm) -> TStr + + Parameters: + FNm: TStr const & + + """ + return _snap.TStr_LoadTxt(*args) + +def TStr_GetChStr(*args): + """ + TStr_GetChStr(char const & Ch) -> TStr + + Parameters: + Ch: char const & + + """ + return _snap.TStr_GetChStr(*args) + +def TStr_GetDChStr(*args): + """ + TStr_GetDChStr(char const & Ch1, char const & Ch2) -> TStr + + Parameters: + Ch1: char const & + Ch2: char const & + + """ + return _snap.TStr_GetDChStr(*args) + +def TStr_Fmt(*args): + """ + TStr_Fmt(char const * FmtStr) -> TStr + + Parameters: + FmtStr: char const * + + """ + return _snap.TStr_Fmt(*args) + +def TStr_GetSpaceStr(*args): + """ + TStr_GetSpaceStr(int const & Spaces) -> TStr + + Parameters: + Spaces: int const & + + """ + return _snap.TStr_GetSpaceStr(*args) + +def TStr_MkClone(*args): + """ + TStr_MkClone(TStr Str) -> TStr + + Parameters: + Str: TStr const & + + """ + return _snap.TStr_MkClone(*args) + +def TStr_GetNullStr(): + """TStr_GetNullStr() -> TStr""" + return _snap.TStr_GetNullStr() + +class TStrIn(TSIn): + """Proxy of C++ TStrIn class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TStrIn self, TStr _Str) -> TStrIn + + Parameters: + _Str: TStr const & + + """ + _snap.TStrIn_swiginit(self,_snap.new_TStrIn(*args)) + def New(*args): + """ + New(TStr Str) -> PSIn + + Parameters: + Str: TStr const & + + """ + return _snap.TStrIn_New(*args) + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_TStrIn +TStrIn_swigregister = _snap.TStrIn_swigregister +TStrIn_swigregister(TStrIn) + +def TStrIn_New(*args): + """ + TStrIn_New(TStr Str) -> PSIn + + Parameters: + Str: TStr const & + + """ + return _snap.TStrIn_New(*args) + +class TDbStr(object): + """Proxy of C++ TDbStr class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Str1 = _swig_property(_snap.TDbStr_Str1_get, _snap.TDbStr_Str1_set) + Str2 = _swig_property(_snap.TDbStr_Str2_get, _snap.TDbStr_Str2_set) + def __init__(self, *args): + """ + __init__(TDbStr self) -> TDbStr + __init__(TDbStr self, TDbStr DbStr) -> TDbStr + + Parameters: + DbStr: TDbStr const & + + __init__(TDbStr self, TStr _Str1) -> TDbStr + + Parameters: + _Str1: TStr const & + + __init__(TDbStr self, TStr _Str1, TStr _Str2) -> TDbStr + + Parameters: + _Str1: TStr const & + _Str2: TStr const & + + __init__(TDbStr self, TSIn SIn) -> TDbStr + + Parameters: + SIn: TSIn & + + """ + _snap.TDbStr_swiginit(self,_snap.new_TDbStr(*args)) + def Save(self, *args): + """ + Save(TDbStr self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TDbStr_Save(self, *args) + + def __eq__(self, *args): + """ + __eq__(TDbStr self, TDbStr DbStr) -> bool + + Parameters: + DbStr: TDbStr const & + + """ + return _snap.TDbStr___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TDbStr self, TDbStr DbStr) -> bool + + Parameters: + DbStr: TDbStr const & + + """ + return _snap.TDbStr___lt__(self, *args) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TDbStr self) -> int + + Parameters: + self: TDbStr const * + + """ + return _snap.TDbStr_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TDbStr self) -> int + + Parameters: + self: TDbStr const * + + """ + return _snap.TDbStr_GetSecHashCd(self) + + def Empty(self): + """ + Empty(TDbStr self) -> bool + + Parameters: + self: TDbStr const * + + """ + return _snap.TDbStr_Empty(self) + + def Filled(self): + """ + Filled(TDbStr self) -> bool + + Parameters: + self: TDbStr const * + + """ + return _snap.TDbStr_Filled(self) + + __swig_destroy__ = _snap.delete_TDbStr +TDbStr.Save = new_instancemethod(_snap.TDbStr_Save,None,TDbStr) +TDbStr.__eq__ = new_instancemethod(_snap.TDbStr___eq__,None,TDbStr) +TDbStr.__lt__ = new_instancemethod(_snap.TDbStr___lt__,None,TDbStr) +TDbStr.GetPrimHashCd = new_instancemethod(_snap.TDbStr_GetPrimHashCd,None,TDbStr) +TDbStr.GetSecHashCd = new_instancemethod(_snap.TDbStr_GetSecHashCd,None,TDbStr) +TDbStr.Empty = new_instancemethod(_snap.TDbStr_Empty,None,TDbStr) +TDbStr.Filled = new_instancemethod(_snap.TDbStr_Filled,None,TDbStr) +TDbStr_swigregister = _snap.TDbStr_swigregister +TDbStr_swigregister(TDbStr) + +class TStrPool(object): + """Proxy of C++ TStrPool class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TStrPool self, uint const & MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> TStrPool + + Parameters: + MxBfLen: uint const & + _GrowBy: uint const & + + __init__(TStrPool self, uint const & MxBfLen=0) -> TStrPool + + Parameters: + MxBfLen: uint const & + + __init__(TStrPool self) -> TStrPool + __init__(TStrPool self, TSIn SIn, bool LoadCompact=True) -> TStrPool + + Parameters: + SIn: TSIn & + LoadCompact: bool + + __init__(TStrPool self, TSIn SIn) -> TStrPool + + Parameters: + SIn: TSIn & + + __init__(TStrPool self, TStrPool Pool) -> TStrPool + + Parameters: + Pool: TStrPool const & + + """ + _snap.TStrPool_swiginit(self,_snap.new_TStrPool(*args)) + __swig_destroy__ = _snap.delete_TStrPool + def New(*args): + """ + New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool + + Parameters: + _MxBfLen: uint const & + _GrowBy: uint const & + + New(uint const & _MxBfLen=0) -> PStrPool + + Parameters: + _MxBfLen: uint const & + + New() -> PStrPool + New(TSIn SIn) -> PStrPool + + Parameters: + SIn: TSIn & + + New(TStr fileName) -> PStrPool + + Parameters: + fileName: TStr const & + + """ + return _snap.TStrPool_New(*args) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool + + Parameters: + SIn: TSIn & + LoadCompacted: bool + + Load(TSIn SIn) -> PStrPool + + Parameters: + SIn: TSIn & + + """ + return _snap.TStrPool_Load(*args) + + Load = staticmethod(Load) + def Save(self, *args): + """ + Save(TStrPool self, TSOut SOut) + + Parameters: + SOut: TSOut & + + Save(TStrPool self, TStr FNm) + + Parameters: + FNm: TStr const & + + """ + return _snap.TStrPool_Save(self, *args) + + def Len(self): + """ + Len(TStrPool self) -> uint + + Parameters: + self: TStrPool const * + + """ + return _snap.TStrPool_Len(self) + + def Size(self): + """ + Size(TStrPool self) -> uint + + Parameters: + self: TStrPool const * + + """ + return _snap.TStrPool_Size(self) + + def Empty(self): + """ + Empty(TStrPool self) -> bool + + Parameters: + self: TStrPool const * + + """ + return _snap.TStrPool_Empty(self) + + def __call__(self): + """ + __call__(TStrPool self) -> char * + + Parameters: + self: TStrPool const * + + """ + return _snap.TStrPool___call__(self) + + def AddStr(self, *args): + """ + AddStr(TStrPool self, char const * Str, uint const & Len) -> uint + + Parameters: + Str: char const * + Len: uint const & + + AddStr(TStrPool self, char const * Str) -> uint + + Parameters: + Str: char const * + + AddStr(TStrPool self, TStr Str) -> uint + + Parameters: + Str: TStr const & + + """ + return _snap.TStrPool_AddStr(self, *args) + + def GetCStr(self, *args): + """ + GetCStr(TStrPool self, uint const & Offset) -> char const * + + Parameters: + Offset: uint const & + + """ + return _snap.TStrPool_GetCStr(self, *args) + + def Clr(self, DoDel=False): + """ + Clr(TStrPool self, bool DoDel=False) + + Parameters: + DoDel: bool + + Clr(TStrPool self) + + Parameters: + self: TStrPool * + + """ + return _snap.TStrPool_Clr(self, DoDel) + + def Cmp(self, *args): + """ + Cmp(TStrPool self, uint const & Offset, char const * Str) -> int + + Parameters: + Offset: uint const & + Str: char const * + + """ + return _snap.TStrPool_Cmp(self, *args) + + def GetPrimHashCd(self, *args): + """ + GetPrimHashCd(TStrPool self, char const * CStr) -> int + + Parameters: + CStr: char const * + + GetPrimHashCd(TStrPool self, uint const & Offset) -> int + + Parameters: + Offset: uint const & + + """ + return _snap.TStrPool_GetPrimHashCd(self, *args) + + def GetSecHashCd(self, *args): + """ + GetSecHashCd(TStrPool self, char const * CStr) -> int + + Parameters: + CStr: char const * + + GetSecHashCd(TStrPool self, uint const & Offset) -> int + + Parameters: + Offset: uint const & + + """ + return _snap.TStrPool_GetSecHashCd(self, *args) + +TStrPool.Save = new_instancemethod(_snap.TStrPool_Save,None,TStrPool) +TStrPool.Len = new_instancemethod(_snap.TStrPool_Len,None,TStrPool) +TStrPool.Size = new_instancemethod(_snap.TStrPool_Size,None,TStrPool) +TStrPool.Empty = new_instancemethod(_snap.TStrPool_Empty,None,TStrPool) +TStrPool.__call__ = new_instancemethod(_snap.TStrPool___call__,None,TStrPool) +TStrPool.AddStr = new_instancemethod(_snap.TStrPool_AddStr,None,TStrPool) +TStrPool.GetCStr = new_instancemethod(_snap.TStrPool_GetCStr,None,TStrPool) +TStrPool.Clr = new_instancemethod(_snap.TStrPool_Clr,None,TStrPool) +TStrPool.Cmp = new_instancemethod(_snap.TStrPool_Cmp,None,TStrPool) +TStrPool.GetPrimHashCd = new_instancemethod(_snap.TStrPool_GetPrimHashCd,None,TStrPool) +TStrPool.GetSecHashCd = new_instancemethod(_snap.TStrPool_GetSecHashCd,None,TStrPool) +TStrPool_swigregister = _snap.TStrPool_swigregister +TStrPool_swigregister(TStrPool) + +def TStrPool_New(*args): + """ + New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool + + Parameters: + _MxBfLen: uint const & + _GrowBy: uint const & + + New(uint const & _MxBfLen=0) -> PStrPool + + Parameters: + _MxBfLen: uint const & + + New() -> PStrPool + New(TSIn SIn) -> PStrPool + + Parameters: + SIn: TSIn & + + TStrPool_New(TStr fileName) -> PStrPool + + Parameters: + fileName: TStr const & + + """ + return _snap.TStrPool_New(*args) + +def TStrPool_Load(*args): + """ + Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool + + Parameters: + SIn: TSIn & + LoadCompacted: bool + + TStrPool_Load(TSIn SIn) -> PStrPool + + Parameters: + SIn: TSIn & + + """ + return _snap.TStrPool_Load(*args) + +class TStrPool64(object): + """Proxy of C++ TStrPool64 class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TStrPool64 self, ::TSize _MxBfL=0, ::TSize _GrowBy=16*1024*1024) -> TStrPool64 + + Parameters: + _MxBfL: ::TSize + _GrowBy: ::TSize + + __init__(TStrPool64 self, ::TSize _MxBfL=0) -> TStrPool64 + + Parameters: + _MxBfL: ::TSize + + __init__(TStrPool64 self) -> TStrPool64 + __init__(TStrPool64 self, TStrPool64 StrPool) -> TStrPool64 + + Parameters: + StrPool: TStrPool64 const & + + __init__(TStrPool64 self, TSIn SIn, bool LoadCompact=True) -> TStrPool64 + + Parameters: + SIn: TSIn & + LoadCompact: bool + + __init__(TStrPool64 self, TSIn SIn) -> TStrPool64 + + Parameters: + SIn: TSIn & + + """ + _snap.TStrPool64_swiginit(self,_snap.new_TStrPool64(*args)) + __swig_destroy__ = _snap.delete_TStrPool64 + def Save(self, *args): + """ + Save(TStrPool64 self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TStrPool64_Save(self, *args) + + def New(MxBfL=0, GrowBy=16*1024*1024): + """ + New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64 + + Parameters: + MxBfL: ::TSize + GrowBy: ::TSize + + New(::TSize MxBfL=0) -> PStrPool64 + + Parameters: + MxBfL: ::TSize + + New() -> PStrPool64 + """ + return _snap.TStrPool64_New(MxBfL, GrowBy) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64 + + Parameters: + SIn: TSIn & + LoadCompact: bool + + Load(TSIn SIn) -> PStrPool64 + + Parameters: + SIn: TSIn & + + """ + return _snap.TStrPool64_Load(*args) + + Load = staticmethod(Load) + def GetMemUsed(self): + """ + GetMemUsed(TStrPool64 self) -> uint64 + + Parameters: + self: TStrPool64 const * + + """ + return _snap.TStrPool64_GetMemUsed(self) + + def Empty(self): + """ + Empty(TStrPool64 self) -> bool + + Parameters: + self: TStrPool64 const * + + """ + return _snap.TStrPool64_Empty(self) + + def Len(self): + """ + Len(TStrPool64 self) -> uint64 + + Parameters: + self: TStrPool64 const * + + """ + return _snap.TStrPool64_Len(self) + + def Reserved(self): + """ + Reserved(TStrPool64 self) -> uint64 + + Parameters: + self: TStrPool64 const * + + """ + return _snap.TStrPool64_Reserved(self) + + def Clr(self, DoDel=False): + """ + Clr(TStrPool64 self, bool DoDel=False) + + Parameters: + DoDel: bool + + Clr(TStrPool64 self) + + Parameters: + self: TStrPool64 * + + """ + return _snap.TStrPool64_Clr(self, DoDel) + + def Cmp(self, *args): + """ + Cmp(TStrPool64 self, uint64 Offset, char const * Str) -> int + + Parameters: + Offset: uint64 + Str: char const * + + """ + return _snap.TStrPool64_Cmp(self, *args) + + def AddStr(self, *args): + """ + AddStr(TStrPool64 self, TStr Str) -> uint64 + + Parameters: + Str: TStr const & + + """ + return _snap.TStrPool64_AddStr(self, *args) + +TStrPool64.Save = new_instancemethod(_snap.TStrPool64_Save,None,TStrPool64) +TStrPool64.GetMemUsed = new_instancemethod(_snap.TStrPool64_GetMemUsed,None,TStrPool64) +TStrPool64.Empty = new_instancemethod(_snap.TStrPool64_Empty,None,TStrPool64) +TStrPool64.Len = new_instancemethod(_snap.TStrPool64_Len,None,TStrPool64) +TStrPool64.Reserved = new_instancemethod(_snap.TStrPool64_Reserved,None,TStrPool64) +TStrPool64.Clr = new_instancemethod(_snap.TStrPool64_Clr,None,TStrPool64) +TStrPool64.Cmp = new_instancemethod(_snap.TStrPool64_Cmp,None,TStrPool64) +TStrPool64.AddStr = new_instancemethod(_snap.TStrPool64_AddStr,None,TStrPool64) +TStrPool64_swigregister = _snap.TStrPool64_swigregister +TStrPool64_swigregister(TStrPool64) + +def TStrPool64_New(MxBfL=0, GrowBy=16*1024*1024): + """ + New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64 + + Parameters: + MxBfL: ::TSize + GrowBy: ::TSize + + New(::TSize MxBfL=0) -> PStrPool64 + + Parameters: + MxBfL: ::TSize + + TStrPool64_New() -> PStrPool64 + """ + return _snap.TStrPool64_New(MxBfL, GrowBy) + +def TStrPool64_Load(*args): + """ + Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64 + + Parameters: + SIn: TSIn & + LoadCompact: bool + + TStrPool64_Load(TSIn SIn) -> PStrPool64 + + Parameters: + SIn: TSIn & + + """ + return _snap.TStrPool64_Load(*args) + +class TVoid(object): + """Proxy of C++ TVoid class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TVoid self) -> TVoid + __init__(TVoid self, TSIn arg2) -> TVoid + + Parameters: + arg2: TSIn & + + """ + _snap.TVoid_swiginit(self,_snap.new_TVoid(*args)) + def Save(self, *args): + """ + Save(TVoid self, TSOut arg2) + + Parameters: + arg2: TSOut & + + """ + return _snap.TVoid_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TVoid self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TVoid_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TVoid self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TVoid_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TVoid self, TVoid arg2) -> bool + + Parameters: + arg2: TVoid const & + + """ + return _snap.TVoid___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TVoid self, TVoid arg2) -> bool + + Parameters: + arg2: TVoid const & + + """ + return _snap.TVoid___lt__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TVoid self) -> int + + Parameters: + self: TVoid const * + + """ + return _snap.TVoid_GetMemUsed(self) + + __swig_destroy__ = _snap.delete_TVoid +TVoid.Save = new_instancemethod(_snap.TVoid_Save,None,TVoid) +TVoid.LoadXml = new_instancemethod(_snap.TVoid_LoadXml,None,TVoid) +TVoid.SaveXml = new_instancemethod(_snap.TVoid_SaveXml,None,TVoid) +TVoid.__eq__ = new_instancemethod(_snap.TVoid___eq__,None,TVoid) +TVoid.__lt__ = new_instancemethod(_snap.TVoid___lt__,None,TVoid) +TVoid.GetMemUsed = new_instancemethod(_snap.TVoid_GetMemUsed,None,TVoid) +TVoid_swigregister = _snap.TVoid_swigregister +TVoid_swigregister(TVoid) + +class TBool(object): + """Proxy of C++ TBool class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TBool_Val_get, _snap.TBool_Val_set) + Rnd = _swig_property(_snap.TBool_Rnd_get, _snap.TBool_Rnd_set) + def __nonzero__(self): + return _snap.TBool___nonzero__(self) + __bool__ = __nonzero__ + + + def __init__(self, *args): + """ + __init__(TBool self) -> TBool + __init__(TBool self, bool const & _Val) -> TBool + + Parameters: + _Val: bool const & + + __init__(TBool self, TSIn SIn) -> TBool + + Parameters: + SIn: TSIn & + + """ + _snap.TBool_swiginit(self,_snap.new_TBool(*args)) + def Load(self, *args): + """ + Load(TBool self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TBool_Load(self, *args) + + def Save(self, *args): + """ + Save(TBool self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TBool_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TBool self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TBool_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TBool self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TBool_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TBool self, TBool Bool) -> bool + + Parameters: + Bool: TBool const & + + """ + return _snap.TBool___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TBool self, TBool Bool) -> bool + + Parameters: + Bool: TBool const & + + """ + return _snap.TBool___lt__(self, *args) + + def __call__(self): + """ + __call__(TBool self) -> bool + + Parameters: + self: TBool const * + + """ + return _snap.TBool___call__(self) + + def GetMemUsed(self): + """ + GetMemUsed(TBool self) -> int + + Parameters: + self: TBool const * + + """ + return _snap.TBool_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TBool self) -> int + + Parameters: + self: TBool const * + + """ + return _snap.TBool_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TBool self) -> int + + Parameters: + self: TBool const * + + """ + return _snap.TBool_GetSecHashCd(self) + + def GetRnd(): + """GetRnd() -> bool""" + return _snap.TBool_GetRnd() + + GetRnd = staticmethod(GetRnd) + def GetYNStr(*args): + """ + GetYNStr(bool const & Val) -> TStr + + Parameters: + Val: bool const & + + """ + return _snap.TBool_GetYNStr(*args) + + GetYNStr = staticmethod(GetYNStr) + def GetYesNoStr(*args): + """ + GetYesNoStr(bool const & Val) -> TStr + + Parameters: + Val: bool const & + + """ + return _snap.TBool_GetYesNoStr(*args) + + GetYesNoStr = staticmethod(GetYesNoStr) + def Get01Str(*args): + """ + Get01Str(bool const & Val) -> TStr + + Parameters: + Val: bool const & + + """ + return _snap.TBool_Get01Str(*args) + + Get01Str = staticmethod(Get01Str) + def IsValStr(*args): + """ + IsValStr(TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TBool_IsValStr(*args) + + IsValStr = staticmethod(IsValStr) + def GetValFromStr(*args): + """ + GetValFromStr(TStr Str) -> bool + + Parameters: + Str: TStr const & + + GetValFromStr(TStr Str, bool const & DfVal) -> bool + + Parameters: + Str: TStr const & + DfVal: bool const & + + """ + return _snap.TBool_GetValFromStr(*args) + + GetValFromStr = staticmethod(GetValFromStr) + __swig_destroy__ = _snap.delete_TBool +TBool.Load = new_instancemethod(_snap.TBool_Load,None,TBool) +TBool.Save = new_instancemethod(_snap.TBool_Save,None,TBool) +TBool.LoadXml = new_instancemethod(_snap.TBool_LoadXml,None,TBool) +TBool.SaveXml = new_instancemethod(_snap.TBool_SaveXml,None,TBool) +TBool.__eq__ = new_instancemethod(_snap.TBool___eq__,None,TBool) +TBool.__lt__ = new_instancemethod(_snap.TBool___lt__,None,TBool) +TBool.__call__ = new_instancemethod(_snap.TBool___call__,None,TBool) +TBool.GetMemUsed = new_instancemethod(_snap.TBool_GetMemUsed,None,TBool) +TBool.GetPrimHashCd = new_instancemethod(_snap.TBool_GetPrimHashCd,None,TBool) +TBool.GetSecHashCd = new_instancemethod(_snap.TBool_GetSecHashCd,None,TBool) +TBool_swigregister = _snap.TBool_swigregister +TBool_swigregister(TBool) +TBool.Mn = _snap.cvar.TBool_Mn +TBool.Mx = _snap.cvar.TBool_Mx +TBool.Vals = _snap.cvar.TBool_Vals +TBool.FalseStr = _snap.cvar.TBool_FalseStr +TBool.TrueStr = _snap.cvar.TBool_TrueStr +TBool.NStr = _snap.cvar.TBool_NStr +TBool.YStr = _snap.cvar.TBool_YStr +TBool.NoStr = _snap.cvar.TBool_NoStr +TBool.YesStr = _snap.cvar.TBool_YesStr + +def TBool_GetRnd(): + """TBool_GetRnd() -> bool""" + return _snap.TBool_GetRnd() + +def TBool_GetYNStr(*args): + """ + TBool_GetYNStr(bool const & Val) -> TStr + + Parameters: + Val: bool const & + + """ + return _snap.TBool_GetYNStr(*args) + +def TBool_GetYesNoStr(*args): + """ + TBool_GetYesNoStr(bool const & Val) -> TStr + + Parameters: + Val: bool const & + + """ + return _snap.TBool_GetYesNoStr(*args) + +def TBool_Get01Str(*args): + """ + TBool_Get01Str(bool const & Val) -> TStr + + Parameters: + Val: bool const & + + """ + return _snap.TBool_Get01Str(*args) + +def TBool_IsValStr(*args): + """ + TBool_IsValStr(TStr Str) -> bool + + Parameters: + Str: TStr const & + + """ + return _snap.TBool_IsValStr(*args) + +def TBool_GetValFromStr(*args): + """ + GetValFromStr(TStr Str) -> bool + + Parameters: + Str: TStr const & + + TBool_GetValFromStr(TStr Str, bool const & DfVal) -> bool + + Parameters: + Str: TStr const & + DfVal: bool const & + + """ + return _snap.TBool_GetValFromStr(*args) + +class TCh(object): + """Proxy of C++ TCh class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TCh_Val_get, _snap.TCh_Val_set) + def __init__(self, *args): + """ + __init__(TCh self) -> TCh + __init__(TCh self, char const & _Val) -> TCh + + Parameters: + _Val: char const & + + __init__(TCh self, TSIn SIn) -> TCh + + Parameters: + SIn: TSIn & + + """ + _snap.TCh_swiginit(self,_snap.new_TCh(*args)) + def Save(self, *args): + """ + Save(TCh self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TCh_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TCh self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TCh_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TCh self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TCh_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TCh self, TCh Ch) -> bool + + Parameters: + Ch: TCh const & + + """ + return _snap.TCh___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TCh self, TCh Ch) -> bool + + Parameters: + Ch: TCh const & + + """ + return _snap.TCh___lt__(self, *args) + + def __call__(self): + """ + __call__(TCh self) -> char + + Parameters: + self: TCh const * + + """ + return _snap.TCh___call__(self) + + def GetMemUsed(self): + """ + GetMemUsed(TCh self) -> int + + Parameters: + self: TCh const * + + """ + return _snap.TCh_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TCh self) -> int + + Parameters: + self: TCh const * + + """ + return _snap.TCh_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TCh self) -> int + + Parameters: + self: TCh const * + + """ + return _snap.TCh_GetSecHashCd(self) + + def IsWs(*args): + """ + IsWs(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsWs(*args) + + IsWs = staticmethod(IsWs) + def IsAlpha(*args): + """ + IsAlpha(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsAlpha(*args) + + IsAlpha = staticmethod(IsAlpha) + def IsNum(*args): + """ + IsNum(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsNum(*args) + + IsNum = staticmethod(IsNum) + def IsAlNum(*args): + """ + IsAlNum(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsAlNum(*args) + + IsAlNum = staticmethod(IsAlNum) + def GetNum(*args): + """ + GetNum(char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetNum(*args) + + GetNum = staticmethod(GetNum) + def IsHex(*args): + """ + IsHex(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsHex(*args) + + IsHex = staticmethod(IsHex) + def GetHex(*args): + """ + GetHex(char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetHex(*args) + + GetHex = staticmethod(GetHex) + def GetHexCh(*args): + """ + GetHexCh(int const & Val) -> char + + Parameters: + Val: int const & + + """ + return _snap.TCh_GetHexCh(*args) + + GetHexCh = staticmethod(GetHexCh) + def IsUc(*args): + """ + IsUc(char const & Ch) -> char + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsUc(*args) + + IsUc = staticmethod(IsUc) + def GetUc(*args): + """ + GetUc(char const & Ch) -> char + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetUc(*args) + + GetUc = staticmethod(GetUc) + def GetUsFromYuAscii(*args): + """ + GetUsFromYuAscii(char const & Ch) -> char + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetUsFromYuAscii(*args) + + GetUsFromYuAscii = staticmethod(GetUsFromYuAscii) + __swig_destroy__ = _snap.delete_TCh +TCh.Save = new_instancemethod(_snap.TCh_Save,None,TCh) +TCh.LoadXml = new_instancemethod(_snap.TCh_LoadXml,None,TCh) +TCh.SaveXml = new_instancemethod(_snap.TCh_SaveXml,None,TCh) +TCh.__eq__ = new_instancemethod(_snap.TCh___eq__,None,TCh) +TCh.__lt__ = new_instancemethod(_snap.TCh___lt__,None,TCh) +TCh.__call__ = new_instancemethod(_snap.TCh___call__,None,TCh) +TCh.GetMemUsed = new_instancemethod(_snap.TCh_GetMemUsed,None,TCh) +TCh.GetPrimHashCd = new_instancemethod(_snap.TCh_GetPrimHashCd,None,TCh) +TCh.GetSecHashCd = new_instancemethod(_snap.TCh_GetSecHashCd,None,TCh) +TCh_swigregister = _snap.TCh_swigregister +TCh_swigregister(TCh) +TCh.Mn = _snap.cvar.TCh_Mn +TCh.Mx = _snap.cvar.TCh_Mx +TCh.Vals = _snap.cvar.TCh_Vals +TCh.NullCh = _snap.cvar.TCh_NullCh +TCh.TabCh = _snap.cvar.TCh_TabCh +TCh.LfCh = _snap.cvar.TCh_LfCh +TCh.CrCh = _snap.cvar.TCh_CrCh +TCh.EofCh = _snap.cvar.TCh_EofCh +TCh.HashCh = _snap.cvar.TCh_HashCh + +def TCh_IsWs(*args): + """ + TCh_IsWs(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsWs(*args) + +def TCh_IsAlpha(*args): + """ + TCh_IsAlpha(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsAlpha(*args) + +def TCh_IsNum(*args): + """ + TCh_IsNum(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsNum(*args) + +def TCh_IsAlNum(*args): + """ + TCh_IsAlNum(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsAlNum(*args) + +def TCh_GetNum(*args): + """ + TCh_GetNum(char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetNum(*args) + +def TCh_IsHex(*args): + """ + TCh_IsHex(char const & Ch) -> bool + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsHex(*args) + +def TCh_GetHex(*args): + """ + TCh_GetHex(char const & Ch) -> int + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetHex(*args) + +def TCh_GetHexCh(*args): + """ + TCh_GetHexCh(int const & Val) -> char + + Parameters: + Val: int const & + + """ + return _snap.TCh_GetHexCh(*args) + +def TCh_IsUc(*args): + """ + TCh_IsUc(char const & Ch) -> char + + Parameters: + Ch: char const & + + """ + return _snap.TCh_IsUc(*args) + +def TCh_GetUc(*args): + """ + TCh_GetUc(char const & Ch) -> char + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetUc(*args) + +def TCh_GetUsFromYuAscii(*args): + """ + TCh_GetUsFromYuAscii(char const & Ch) -> char + + Parameters: + Ch: char const & + + """ + return _snap.TCh_GetUsFromYuAscii(*args) + +class TUCh(object): + """Proxy of C++ TUCh class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TUCh_Val_get, _snap.TUCh_Val_set) + def __init__(self, *args): + """ + __init__(TUCh self) -> TUCh + __init__(TUCh self, uchar const & _Val) -> TUCh + + Parameters: + _Val: uchar const & + + __init__(TUCh self, TSIn SIn) -> TUCh + + Parameters: + SIn: TSIn & + + """ + _snap.TUCh_swiginit(self,_snap.new_TUCh(*args)) + def Save(self, *args): + """ + Save(TUCh self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TUCh_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TUCh self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TUCh_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TUCh self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TUCh_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TUCh self, TUCh UCh) -> bool + + Parameters: + UCh: TUCh const & + + """ + return _snap.TUCh___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TUCh self, TUCh UCh) -> bool + + Parameters: + UCh: TUCh const & + + """ + return _snap.TUCh___lt__(self, *args) + + def __call__(self): + """ + __call__(TUCh self) -> uchar + + Parameters: + self: TUCh const * + + """ + return _snap.TUCh___call__(self) + + def GetMemUsed(self): + """ + GetMemUsed(TUCh self) -> int + + Parameters: + self: TUCh const * + + """ + return _snap.TUCh_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TUCh self) -> int + + Parameters: + self: TUCh const * + + """ + return _snap.TUCh_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TUCh self) -> int + + Parameters: + self: TUCh const * + + """ + return _snap.TUCh_GetSecHashCd(self) + + __swig_destroy__ = _snap.delete_TUCh +TUCh.Save = new_instancemethod(_snap.TUCh_Save,None,TUCh) +TUCh.LoadXml = new_instancemethod(_snap.TUCh_LoadXml,None,TUCh) +TUCh.SaveXml = new_instancemethod(_snap.TUCh_SaveXml,None,TUCh) +TUCh.__eq__ = new_instancemethod(_snap.TUCh___eq__,None,TUCh) +TUCh.__lt__ = new_instancemethod(_snap.TUCh___lt__,None,TUCh) +TUCh.__call__ = new_instancemethod(_snap.TUCh___call__,None,TUCh) +TUCh.GetMemUsed = new_instancemethod(_snap.TUCh_GetMemUsed,None,TUCh) +TUCh.GetPrimHashCd = new_instancemethod(_snap.TUCh_GetPrimHashCd,None,TUCh) +TUCh.GetSecHashCd = new_instancemethod(_snap.TUCh_GetSecHashCd,None,TUCh) +TUCh_swigregister = _snap.TUCh_swigregister +TUCh_swigregister(TUCh) +TUCh.Mn = _snap.cvar.TUCh_Mn +TUCh.Mx = _snap.cvar.TUCh_Mx +TUCh.Vals = _snap.cvar.TUCh_Vals + +class TSInt(object): + """Proxy of C++ TSInt class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TSInt_Val_get, _snap.TSInt_Val_set) + def __init__(self, *args): + """ + __init__(TSInt self) -> TSInt + __init__(TSInt self, int16 const & _Val) -> TSInt + + Parameters: + _Val: int16 const & + + __init__(TSInt self, TSIn SIn) -> TSInt + + Parameters: + SIn: TSIn & + + """ + _snap.TSInt_swiginit(self,_snap.new_TSInt(*args)) + def Load(self, *args): + """ + Load(TSInt self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TSInt_Load(self, *args) + + def Save(self, *args): + """ + Save(TSInt self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TSInt_Save(self, *args) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TSInt self) -> int + + Parameters: + self: TSInt const * + + """ + return _snap.TSInt_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TSInt self) -> int + + Parameters: + self: TSInt const * + + """ + return _snap.TSInt_GetSecHashCd(self) + + __swig_destroy__ = _snap.delete_TSInt +TSInt.Load = new_instancemethod(_snap.TSInt_Load,None,TSInt) +TSInt.Save = new_instancemethod(_snap.TSInt_Save,None,TSInt) +TSInt.GetPrimHashCd = new_instancemethod(_snap.TSInt_GetPrimHashCd,None,TSInt) +TSInt.GetSecHashCd = new_instancemethod(_snap.TSInt_GetSecHashCd,None,TSInt) +TSInt_swigregister = _snap.TSInt_swigregister +TSInt_swigregister(TSInt) + +class TInt(object): + """Proxy of C++ TInt class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TInt_Val_get, _snap.TInt_Val_set) + Rnd = _swig_property(_snap.TInt_Rnd_get, _snap.TInt_Rnd_set) + def __init__(self, *args): + """ + __init__(TInt self) -> TInt + __init__(TInt self, int const & _Val) -> TInt + + Parameters: + _Val: int const & + + __init__(TInt self, TSIn SIn) -> TInt + + Parameters: + SIn: TSIn & + + """ + _snap.TInt_swiginit(self,_snap.new_TInt(*args)) + def Load(self, *args): + """ + Load(TInt self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TInt_Load(self, *args) + + def Save(self, *args): + """ + Save(TInt self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TInt_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TInt self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TInt_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TInt self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TInt_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TInt self, TInt Int) -> bool + + Parameters: + Int: TInt const & + + __eq__(TInt self, int const & Int) -> bool + + Parameters: + Int: int const & + + """ + return _snap.TInt___eq__(self, *args) + + def __ne__(self, *args): + """ + __ne__(TInt self, int const & Int) -> bool + + Parameters: + Int: int const & + + """ + return _snap.TInt___ne__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TInt self, TInt Int) -> bool + + Parameters: + Int: TInt const & + + __lt__(TInt self, int const & Int) -> bool + + Parameters: + Int: int const & + + """ + return _snap.TInt___lt__(self, *args) + + def __call__(self): + """ + __call__(TInt self) -> int + + Parameters: + self: TInt const * + + """ + return _snap.TInt___call__(self) + + def __iadd__(self, *args): + """ + __iadd__(TInt self, int const & Int) -> TInt + + Parameters: + Int: int const & + + """ + return _snap.TInt___iadd__(self, *args) + + def __isub__(self, *args): + """ + __isub__(TInt self, int const & Int) -> TInt + + Parameters: + Int: int const & + + """ + return _snap.TInt___isub__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TInt self) -> int + + Parameters: + self: TInt const * + + """ + return _snap.TInt_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TInt self) -> int + + Parameters: + self: TInt const * + + """ + return _snap.TInt_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TInt self) -> int + + Parameters: + self: TInt const * + + """ + return _snap.TInt_GetSecHashCd(self) + + def Abs(*args): + """ + Abs(int const & Int) -> int + + Parameters: + Int: int const & + + """ + return _snap.TInt_Abs(*args) + + Abs = staticmethod(Abs) + def Sign(*args): + """ + Sign(int const & Int) -> int + + Parameters: + Int: int const & + + """ + return _snap.TInt_Sign(*args) + + Sign = staticmethod(Sign) + def Swap(*args): + """ + Swap(int & Int1, int & Int2) + + Parameters: + Int1: int & + Int2: int & + + """ + return _snap.TInt_Swap(*args) + + Swap = staticmethod(Swap) + def GetRnd(Range=0): + """ + GetRnd(int const & Range=0) -> int + + Parameters: + Range: int const & + + GetRnd() -> int + """ + return _snap.TInt_GetRnd(Range) + + GetRnd = staticmethod(GetRnd) + def IsOdd(*args): + """ + IsOdd(int const & Int) -> bool + + Parameters: + Int: int const & + + """ + return _snap.TInt_IsOdd(*args) + + IsOdd = staticmethod(IsOdd) + def IsEven(*args): + """ + IsEven(int const & Int) -> bool + + Parameters: + Int: int const & + + """ + return _snap.TInt_IsEven(*args) + + IsEven = staticmethod(IsEven) + def GetMn(*args): + """ + GetMn(int const & Int1, int const & Int2) -> int + + Parameters: + Int1: int const & + Int2: int const & + + GetMn(int const & Int1, int const & Int2, int const & Int3) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + + GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + Int4: int const & + + """ + return _snap.TInt_GetMn(*args) + + GetMn = staticmethod(GetMn) + def GetMx(*args): + """ + GetMx(int const & Int1, int const & Int2) -> int + + Parameters: + Int1: int const & + Int2: int const & + + GetMx(int const & Int1, int const & Int2, int const & Int3) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + + GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + Int4: int const & + + """ + return _snap.TInt_GetMx(*args) + + GetMx = staticmethod(GetMx) + def GetInRng(*args): + """ + GetInRng(int const & Val, int const & Mn, int const & Mx) -> int + + Parameters: + Val: int const & + Mn: int const & + Mx: int const & + + """ + return _snap.TInt_GetInRng(*args) + + GetInRng = staticmethod(GetInRng) + def GetHexStr(*args): + """ + GetHexStr(int const & Val) -> TStr + + Parameters: + Val: int const & + + GetHexStr(TInt Int) -> TStr + + Parameters: + Int: TInt const & + + """ + return _snap.TInt_GetHexStr(*args) + + GetHexStr = staticmethod(GetHexStr) + def GetKiloStr(*args): + """ + GetKiloStr(int const & Val) -> TStr + + Parameters: + Val: int const & + + """ + return _snap.TInt_GetKiloStr(*args) + + GetKiloStr = staticmethod(GetKiloStr) + def GetMegaStr(*args): + """ + GetMegaStr(int const & Val) -> TStr + + Parameters: + Val: int const & + + """ + return _snap.TInt_GetMegaStr(*args) + + GetMegaStr = staticmethod(GetMegaStr) + def SaveFrugalInt(*args): + """ + SaveFrugalInt(char * pDest, int i) -> char * + + Parameters: + pDest: char * + i: int + + """ + return _snap.TInt_SaveFrugalInt(*args) + + SaveFrugalInt = staticmethod(SaveFrugalInt) + def LoadFrugalInt(*args): + """ + LoadFrugalInt(char * pSrc, int & i) -> char * + + Parameters: + pSrc: char * + i: int & + + """ + return _snap.TInt_LoadFrugalInt(*args) + + LoadFrugalInt = staticmethod(LoadFrugalInt) + def TestFrugalInt(): + """TestFrugalInt()""" + return _snap.TInt_TestFrugalInt() + + TestFrugalInt = staticmethod(TestFrugalInt) + def SaveFrugalIntV(*args): + """ + SaveFrugalIntV(TSOut SOut, TIntV IntV) + + Parameters: + SOut: TSOut & + IntV: TVec< TInt,int > const & + + """ + return _snap.TInt_SaveFrugalIntV(*args) + + SaveFrugalIntV = staticmethod(SaveFrugalIntV) + def LoadFrugalIntV(*args): + """ + LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True) + + Parameters: + SIn: TSIn & + IntV: TVec< TInt,int > & + ClrP: bool + + LoadFrugalIntV(TSIn SIn, TIntV IntV) + + Parameters: + SIn: TSIn & + IntV: TVec< TInt,int > & + + """ + return _snap.TInt_LoadFrugalIntV(*args) + + LoadFrugalIntV = staticmethod(LoadFrugalIntV) + __swig_destroy__ = _snap.delete_TInt +TInt.Load = new_instancemethod(_snap.TInt_Load,None,TInt) +TInt.Save = new_instancemethod(_snap.TInt_Save,None,TInt) +TInt.LoadXml = new_instancemethod(_snap.TInt_LoadXml,None,TInt) +TInt.SaveXml = new_instancemethod(_snap.TInt_SaveXml,None,TInt) +TInt.__eq__ = new_instancemethod(_snap.TInt___eq__,None,TInt) +TInt.__ne__ = new_instancemethod(_snap.TInt___ne__,None,TInt) +TInt.__lt__ = new_instancemethod(_snap.TInt___lt__,None,TInt) +TInt.__call__ = new_instancemethod(_snap.TInt___call__,None,TInt) +TInt.__iadd__ = new_instancemethod(_snap.TInt___iadd__,None,TInt) +TInt.__isub__ = new_instancemethod(_snap.TInt___isub__,None,TInt) +TInt.GetMemUsed = new_instancemethod(_snap.TInt_GetMemUsed,None,TInt) +TInt.GetPrimHashCd = new_instancemethod(_snap.TInt_GetPrimHashCd,None,TInt) +TInt.GetSecHashCd = new_instancemethod(_snap.TInt_GetSecHashCd,None,TInt) +TInt_swigregister = _snap.TInt_swigregister +TInt_swigregister(TInt) +TInt.Mn = _snap.cvar.TInt_Mn +TInt.Mx = _snap.cvar.TInt_Mx +TInt.Kilo = _snap.cvar.TInt_Kilo +TInt.Mega = _snap.cvar.TInt_Mega +TInt.Giga = _snap.cvar.TInt_Giga + +def TInt_Abs(*args): + """ + TInt_Abs(int const & Int) -> int + + Parameters: + Int: int const & + + """ + return _snap.TInt_Abs(*args) + +def TInt_Sign(*args): + """ + TInt_Sign(int const & Int) -> int + + Parameters: + Int: int const & + + """ + return _snap.TInt_Sign(*args) + +def TInt_Swap(*args): + """ + TInt_Swap(int & Int1, int & Int2) + + Parameters: + Int1: int & + Int2: int & + + """ + return _snap.TInt_Swap(*args) + +def TInt_GetRnd(Range=0): + """ + GetRnd(int const & Range=0) -> int + + Parameters: + Range: int const & + + TInt_GetRnd() -> int + """ + return _snap.TInt_GetRnd(Range) + +def TInt_IsOdd(*args): + """ + TInt_IsOdd(int const & Int) -> bool + + Parameters: + Int: int const & + + """ + return _snap.TInt_IsOdd(*args) + +def TInt_IsEven(*args): + """ + TInt_IsEven(int const & Int) -> bool + + Parameters: + Int: int const & + + """ + return _snap.TInt_IsEven(*args) + +def TInt_GetMn(*args): + """ + GetMn(int const & Int1, int const & Int2) -> int + + Parameters: + Int1: int const & + Int2: int const & + + GetMn(int const & Int1, int const & Int2, int const & Int3) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + + TInt_GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + Int4: int const & + + """ + return _snap.TInt_GetMn(*args) + +def TInt_GetMx(*args): + """ + GetMx(int const & Int1, int const & Int2) -> int + + Parameters: + Int1: int const & + Int2: int const & + + GetMx(int const & Int1, int const & Int2, int const & Int3) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + + TInt_GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int + + Parameters: + Int1: int const & + Int2: int const & + Int3: int const & + Int4: int const & + + """ + return _snap.TInt_GetMx(*args) + +def TInt_GetInRng(*args): + """ + TInt_GetInRng(int const & Val, int const & Mn, int const & Mx) -> int + + Parameters: + Val: int const & + Mn: int const & + Mx: int const & + + """ + return _snap.TInt_GetInRng(*args) + +def TInt_GetHexStr(*args): + """ + GetHexStr(int const & Val) -> TStr + + Parameters: + Val: int const & + + TInt_GetHexStr(TInt Int) -> TStr + + Parameters: + Int: TInt const & + + """ + return _snap.TInt_GetHexStr(*args) + +def TInt_GetKiloStr(*args): + """ + TInt_GetKiloStr(int const & Val) -> TStr + + Parameters: + Val: int const & + + """ + return _snap.TInt_GetKiloStr(*args) + +def TInt_GetMegaStr(*args): + """ + TInt_GetMegaStr(int const & Val) -> TStr + + Parameters: + Val: int const & + + """ + return _snap.TInt_GetMegaStr(*args) + +def TInt_SaveFrugalInt(*args): + """ + TInt_SaveFrugalInt(char * pDest, int i) -> char * + + Parameters: + pDest: char * + i: int + + """ + return _snap.TInt_SaveFrugalInt(*args) + +def TInt_LoadFrugalInt(*args): + """ + TInt_LoadFrugalInt(char * pSrc, int & i) -> char * + + Parameters: + pSrc: char * + i: int & + + """ + return _snap.TInt_LoadFrugalInt(*args) + +def TInt_TestFrugalInt(): + """TInt_TestFrugalInt()""" + return _snap.TInt_TestFrugalInt() + +def TInt_SaveFrugalIntV(*args): + """ + TInt_SaveFrugalIntV(TSOut SOut, TIntV IntV) + + Parameters: + SOut: TSOut & + IntV: TVec< TInt,int > const & + + """ + return _snap.TInt_SaveFrugalIntV(*args) + +def TInt_LoadFrugalIntV(*args): + """ + LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True) + + Parameters: + SIn: TSIn & + IntV: TVec< TInt,int > & + ClrP: bool + + TInt_LoadFrugalIntV(TSIn SIn, TIntV IntV) + + Parameters: + SIn: TSIn & + IntV: TVec< TInt,int > & + + """ + return _snap.TInt_LoadFrugalIntV(*args) + +class TUInt(object): + """Proxy of C++ TUInt class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TUInt_Val_get, _snap.TUInt_Val_set) + Rnd = _swig_property(_snap.TUInt_Rnd_get, _snap.TUInt_Rnd_set) + def __init__(self, *args): + """ + __init__(TUInt self) -> TUInt + __init__(TUInt self, uint const & _Val) -> TUInt + + Parameters: + _Val: uint const & + + __init__(TUInt self, TSIn SIn) -> TUInt + + Parameters: + SIn: TSIn & + + """ + _snap.TUInt_swiginit(self,_snap.new_TUInt(*args)) + def Load(self, *args): + """ + Load(TUInt self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TUInt_Load(self, *args) + + def Save(self, *args): + """ + Save(TUInt self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TUInt_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TUInt self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TUInt_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TUInt self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TUInt_SaveXml(self, *args) + + def __call__(self, *args): + """ + __call__(TUInt self) -> uint + __call__(TUInt self) -> uint & + + Parameters: + self: TUInt * + + """ + return _snap.TUInt___call__(self, *args) + + def __invert__(self): + """ + __invert__(TUInt self) -> TUInt + + Parameters: + self: TUInt * + + """ + return _snap.TUInt___invert__(self) + + def __iand__(self, *args): + """ + __iand__(TUInt self, TUInt UInt) -> TUInt + + Parameters: + UInt: TUInt const & + + """ + return _snap.TUInt___iand__(self, *args) + + def __ior__(self, *args): + """ + __ior__(TUInt self, TUInt UInt) -> TUInt + + Parameters: + UInt: TUInt const & + + """ + return _snap.TUInt___ior__(self, *args) + + def __ixor__(self, *args): + """ + __ixor__(TUInt self, TUInt UInt) -> TUInt + + Parameters: + UInt: TUInt const & + + """ + return _snap.TUInt___ixor__(self, *args) + + def __irshift__(self, *args): + """ + __irshift__(TUInt self, int const & ShiftBits) -> TUInt + + Parameters: + ShiftBits: int const & + + """ + return _snap.TUInt___irshift__(self, *args) + + def __ilshift__(self, *args): + """ + __ilshift__(TUInt self, int const & ShiftBits) -> TUInt + + Parameters: + ShiftBits: int const & + + """ + return _snap.TUInt___ilshift__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TUInt self) -> int + + Parameters: + self: TUInt const * + + """ + return _snap.TUInt_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TUInt self) -> int + + Parameters: + self: TUInt const * + + """ + return _snap.TUInt_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TUInt self) -> int + + Parameters: + self: TUInt const * + + """ + return _snap.TUInt_GetSecHashCd(self) + + def GetRnd(Range=0): + """ + GetRnd(uint const & Range=0) -> uint + + Parameters: + Range: uint const & + + GetRnd() -> uint + """ + return _snap.TUInt_GetRnd(Range) + + GetRnd = staticmethod(GetRnd) + def GetKiloStr(*args): + """ + GetKiloStr(uint const & Val) -> TStr + + Parameters: + Val: uint const & + + """ + return _snap.TUInt_GetKiloStr(*args) + + GetKiloStr = staticmethod(GetKiloStr) + def GetMegaStr(*args): + """ + GetMegaStr(uint const & Val) -> TStr + + Parameters: + Val: uint const & + + """ + return _snap.TUInt_GetMegaStr(*args) + + GetMegaStr = staticmethod(GetMegaStr) + def JavaUIntToCppUInt(*args): + """ + JavaUIntToCppUInt(uint const & JavaUInt) -> uint + + Parameters: + JavaUInt: uint const & + + """ + return _snap.TUInt_JavaUIntToCppUInt(*args) + + JavaUIntToCppUInt = staticmethod(JavaUIntToCppUInt) + def IsIpStr(*args): + """ + IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool + + Parameters: + IpStr: TStr const & + Ip: uint & + SplitCh: char const & + + IsIpStr(TStr IpStr, uint & Ip) -> bool + + Parameters: + IpStr: TStr const & + Ip: uint & + + IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool + + Parameters: + IpStr: TStr const & + SplitCh: char const & + + IsIpStr(TStr IpStr) -> bool + + Parameters: + IpStr: TStr const & + + """ + return _snap.TUInt_IsIpStr(*args) + + IsIpStr = staticmethod(IsIpStr) + def GetUIntFromIpStr(*args): + """ + GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint + + Parameters: + IpStr: TStr const & + SplitCh: char const & + + GetUIntFromIpStr(TStr IpStr) -> uint + + Parameters: + IpStr: TStr const & + + """ + return _snap.TUInt_GetUIntFromIpStr(*args) + + GetUIntFromIpStr = staticmethod(GetUIntFromIpStr) + def GetStrFromIpUInt(*args): + """ + GetStrFromIpUInt(uint const & Ip) -> TStr + + Parameters: + Ip: uint const & + + """ + return _snap.TUInt_GetStrFromIpUInt(*args) + + GetStrFromIpUInt = staticmethod(GetStrFromIpUInt) + def IsIpv6Str(*args): + """ + IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool + + Parameters: + IpStr: TStr const & + SplitCh: char const & + + IsIpv6Str(TStr IpStr) -> bool + + Parameters: + IpStr: TStr const & + + """ + return _snap.TUInt_IsIpv6Str(*args) + + IsIpv6Str = staticmethod(IsIpv6Str) + __swig_destroy__ = _snap.delete_TUInt +TUInt.Load = new_instancemethod(_snap.TUInt_Load,None,TUInt) +TUInt.Save = new_instancemethod(_snap.TUInt_Save,None,TUInt) +TUInt.LoadXml = new_instancemethod(_snap.TUInt_LoadXml,None,TUInt) +TUInt.SaveXml = new_instancemethod(_snap.TUInt_SaveXml,None,TUInt) +TUInt.__call__ = new_instancemethod(_snap.TUInt___call__,None,TUInt) +TUInt.__invert__ = new_instancemethod(_snap.TUInt___invert__,None,TUInt) +TUInt.__iand__ = new_instancemethod(_snap.TUInt___iand__,None,TUInt) +TUInt.__ior__ = new_instancemethod(_snap.TUInt___ior__,None,TUInt) +TUInt.__ixor__ = new_instancemethod(_snap.TUInt___ixor__,None,TUInt) +TUInt.__irshift__ = new_instancemethod(_snap.TUInt___irshift__,None,TUInt) +TUInt.__ilshift__ = new_instancemethod(_snap.TUInt___ilshift__,None,TUInt) +TUInt.GetMemUsed = new_instancemethod(_snap.TUInt_GetMemUsed,None,TUInt) +TUInt.GetPrimHashCd = new_instancemethod(_snap.TUInt_GetPrimHashCd,None,TUInt) +TUInt.GetSecHashCd = new_instancemethod(_snap.TUInt_GetSecHashCd,None,TUInt) +TUInt_swigregister = _snap.TUInt_swigregister +TUInt_swigregister(TUInt) +TUInt.Mn = _snap.cvar.TUInt_Mn +TUInt.Mx = _snap.cvar.TUInt_Mx + +def TUInt_GetRnd(Range=0): + """ + GetRnd(uint const & Range=0) -> uint + + Parameters: + Range: uint const & + + TUInt_GetRnd() -> uint + """ + return _snap.TUInt_GetRnd(Range) + +def TUInt_GetKiloStr(*args): + """ + TUInt_GetKiloStr(uint const & Val) -> TStr + + Parameters: + Val: uint const & + + """ + return _snap.TUInt_GetKiloStr(*args) + +def TUInt_GetMegaStr(*args): + """ + TUInt_GetMegaStr(uint const & Val) -> TStr + + Parameters: + Val: uint const & + + """ + return _snap.TUInt_GetMegaStr(*args) + +def TUInt_JavaUIntToCppUInt(*args): + """ + TUInt_JavaUIntToCppUInt(uint const & JavaUInt) -> uint + + Parameters: + JavaUInt: uint const & + + """ + return _snap.TUInt_JavaUIntToCppUInt(*args) + +def TUInt_IsIpStr(*args): + """ + IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool + + Parameters: + IpStr: TStr const & + Ip: uint & + SplitCh: char const & + + IsIpStr(TStr IpStr, uint & Ip) -> bool + + Parameters: + IpStr: TStr const & + Ip: uint & + + IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool + + Parameters: + IpStr: TStr const & + SplitCh: char const & + + TUInt_IsIpStr(TStr IpStr) -> bool + + Parameters: + IpStr: TStr const & + + """ + return _snap.TUInt_IsIpStr(*args) + +def TUInt_GetUIntFromIpStr(*args): + """ + GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint + + Parameters: + IpStr: TStr const & + SplitCh: char const & + + TUInt_GetUIntFromIpStr(TStr IpStr) -> uint + + Parameters: + IpStr: TStr const & + + """ + return _snap.TUInt_GetUIntFromIpStr(*args) + +def TUInt_GetStrFromIpUInt(*args): + """ + TUInt_GetStrFromIpUInt(uint const & Ip) -> TStr + + Parameters: + Ip: uint const & + + """ + return _snap.TUInt_GetStrFromIpUInt(*args) + +def TUInt_IsIpv6Str(*args): + """ + IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool + + Parameters: + IpStr: TStr const & + SplitCh: char const & + + TUInt_IsIpv6Str(TStr IpStr) -> bool + + Parameters: + IpStr: TStr const & + + """ + return _snap.TUInt_IsIpv6Str(*args) + +class TUInt64(object): + """Proxy of C++ TUInt64 class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TUInt64_Val_get, _snap.TUInt64_Val_set) + def __init__(self, *args): + """ + __init__(TUInt64 self) -> TUInt64 + __init__(TUInt64 self, TUInt64 Int) -> TUInt64 + + Parameters: + Int: TUInt64 const & + + __init__(TUInt64 self, uint64 const & Int) -> TUInt64 + + Parameters: + Int: uint64 const & + + __init__(TUInt64 self, uint const & MsVal, uint const & LsVal) -> TUInt64 + + Parameters: + MsVal: uint const & + LsVal: uint const & + + __init__(TUInt64 self, void * Pt) -> TUInt64 + + Parameters: + Pt: void * + + __init__(TUInt64 self, TSIn SIn) -> TUInt64 + + Parameters: + SIn: TSIn & + + """ + _snap.TUInt64_swiginit(self,_snap.new_TUInt64(*args)) + def Load(self, *args): + """ + Load(TUInt64 self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TUInt64_Load(self, *args) + + def Save(self, *args): + """ + Save(TUInt64 self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TUInt64_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TUInt64 self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TUInt64_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TUInt64 self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TUInt64_SaveXml(self, *args) + + def __iadd__(self, *args): + """ + __iadd__(TUInt64 self, TUInt64 Int) -> TUInt64 + + Parameters: + Int: TUInt64 const & + + """ + return _snap.TUInt64___iadd__(self, *args) + + def __isub__(self, *args): + """ + __isub__(TUInt64 self, TUInt64 Int) -> TUInt64 + + Parameters: + Int: TUInt64 const & + + """ + return _snap.TUInt64___isub__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TUInt64 self) -> int + + Parameters: + self: TUInt64 const * + + """ + return _snap.TUInt64_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TUInt64 self) -> int + + Parameters: + self: TUInt64 const * + + """ + return _snap.TUInt64_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TUInt64 self) -> int + + Parameters: + self: TUInt64 const * + + """ + return _snap.TUInt64_GetSecHashCd(self) + + def GetMsVal(self): + """ + GetMsVal(TUInt64 self) -> uint + + Parameters: + self: TUInt64 const * + + """ + return _snap.TUInt64_GetMsVal(self) + + def GetLsVal(self): + """ + GetLsVal(TUInt64 self) -> uint + + Parameters: + self: TUInt64 const * + + """ + return _snap.TUInt64_GetLsVal(self) + + def GetHexStr(*args): + """ + GetHexStr(TUInt64 Int) -> TStr + + Parameters: + Int: TUInt64 const & + + """ + return _snap.TUInt64_GetHexStr(*args) + + GetHexStr = staticmethod(GetHexStr) + def GetKiloStr(*args): + """ + GetKiloStr(uint64 const & Val) -> TStr + + Parameters: + Val: uint64 const & + + """ + return _snap.TUInt64_GetKiloStr(*args) + + GetKiloStr = staticmethod(GetKiloStr) + def GetMegaStr(*args): + """ + GetMegaStr(uint64 const & Val) -> TStr + + Parameters: + Val: uint64 const & + + """ + return _snap.TUInt64_GetMegaStr(*args) + + GetMegaStr = staticmethod(GetMegaStr) + __swig_destroy__ = _snap.delete_TUInt64 +TUInt64.Load = new_instancemethod(_snap.TUInt64_Load,None,TUInt64) +TUInt64.Save = new_instancemethod(_snap.TUInt64_Save,None,TUInt64) +TUInt64.LoadXml = new_instancemethod(_snap.TUInt64_LoadXml,None,TUInt64) +TUInt64.SaveXml = new_instancemethod(_snap.TUInt64_SaveXml,None,TUInt64) +TUInt64.__iadd__ = new_instancemethod(_snap.TUInt64___iadd__,None,TUInt64) +TUInt64.__isub__ = new_instancemethod(_snap.TUInt64___isub__,None,TUInt64) +TUInt64.GetMemUsed = new_instancemethod(_snap.TUInt64_GetMemUsed,None,TUInt64) +TUInt64.GetPrimHashCd = new_instancemethod(_snap.TUInt64_GetPrimHashCd,None,TUInt64) +TUInt64.GetSecHashCd = new_instancemethod(_snap.TUInt64_GetSecHashCd,None,TUInt64) +TUInt64.GetMsVal = new_instancemethod(_snap.TUInt64_GetMsVal,None,TUInt64) +TUInt64.GetLsVal = new_instancemethod(_snap.TUInt64_GetLsVal,None,TUInt64) +TUInt64_swigregister = _snap.TUInt64_swigregister +TUInt64_swigregister(TUInt64) +TUInt64.Mn = _snap.cvar.TUInt64_Mn +TUInt64.Mx = _snap.cvar.TUInt64_Mx + +def TUInt64_GetHexStr(*args): + """ + TUInt64_GetHexStr(TUInt64 Int) -> TStr + + Parameters: + Int: TUInt64 const & + + """ + return _snap.TUInt64_GetHexStr(*args) + +def TUInt64_GetKiloStr(*args): + """ + TUInt64_GetKiloStr(uint64 const & Val) -> TStr + + Parameters: + Val: uint64 const & + + """ + return _snap.TUInt64_GetKiloStr(*args) + +def TUInt64_GetMegaStr(*args): + """ + TUInt64_GetMegaStr(uint64 const & Val) -> TStr + + Parameters: + Val: uint64 const & + + """ + return _snap.TUInt64_GetMegaStr(*args) + +class TFlt(object): + """Proxy of C++ TFlt class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TFlt_Val_get, _snap.TFlt_Val_set) + Rnd = _swig_property(_snap.TFlt_Rnd_get, _snap.TFlt_Rnd_set) + def __init__(self, *args): + """ + __init__(TFlt self) -> TFlt + __init__(TFlt self, double const & _Val) -> TFlt + + Parameters: + _Val: double const & + + __init__(TFlt self, TSIn SIn) -> TFlt + + Parameters: + SIn: TSIn & + + __init__(TFlt self, TSIn SIn, bool const & IsTxt) -> TFlt + + Parameters: + SIn: TSIn & + IsTxt: bool const & + + """ + _snap.TFlt_swiginit(self,_snap.new_TFlt(*args)) + def Load(self, *args): + """ + Load(TFlt self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TFlt_Load(self, *args) + + def Save(self, *args): + """ + Save(TFlt self, TSOut SOut) + + Parameters: + SOut: TSOut & + + Save(TFlt self, TSOut SOut, bool const & IsTxt) + + Parameters: + SOut: TSOut & + IsTxt: bool const & + + """ + return _snap.TFlt_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TFlt self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TFlt_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TFlt self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TFlt_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TFlt self, TFlt Flt) -> bool + + Parameters: + Flt: TFlt const & + + __eq__(TFlt self, double const & Flt) -> bool + + Parameters: + Flt: double const & + + """ + return _snap.TFlt___eq__(self, *args) + + def __ne__(self, *args): + """ + __ne__(TFlt self, double const & Flt) -> bool + + Parameters: + Flt: double const & + + """ + return _snap.TFlt___ne__(self, *args) + + def __call__(self): + """ + __call__(TFlt self) -> double + + Parameters: + self: TFlt const * + + """ + return _snap.TFlt___call__(self) + + def __iadd__(self, *args): + """ + __iadd__(TFlt self, double const & Flt) -> TFlt + + Parameters: + Flt: double const & + + """ + return _snap.TFlt___iadd__(self, *args) + + def __isub__(self, *args): + """ + __isub__(TFlt self, double const & Flt) -> TFlt + + Parameters: + Flt: double const & + + """ + return _snap.TFlt___isub__(self, *args) + + def __imul__(self, *args): + """ + __imul__(TFlt self, double const & Flt) -> TFlt + + Parameters: + Flt: double const & + + """ + return _snap.TFlt___imul__(self, *args) + + def __idiv__(self, *args): + """ + __idiv__(TFlt self, double const & Flt) -> TFlt + + Parameters: + Flt: double const & + + """ + return _snap.TFlt___idiv__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TFlt self) -> int + + Parameters: + self: TFlt const * + + """ + return _snap.TFlt_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TFlt self) -> int + + Parameters: + self: TFlt const * + + """ + return _snap.TFlt_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TFlt self) -> int + + Parameters: + self: TFlt const * + + """ + return _snap.TFlt_GetSecHashCd(self) + + def Abs(*args): + """ + Abs(double const & Flt) -> double + + Parameters: + Flt: double const & + + """ + return _snap.TFlt_Abs(*args) + + Abs = staticmethod(Abs) + def Sign(*args): + """ + Sign(double const & Flt) -> int + + Parameters: + Flt: double const & + + """ + return _snap.TFlt_Sign(*args) + + Sign = staticmethod(Sign) + def Round(*args): + """ + Round(double const & Flt) -> int + + Parameters: + Flt: double const & + + """ + return _snap.TFlt_Round(*args) + + Round = staticmethod(Round) + def GetRnd(): + """GetRnd() -> double""" + return _snap.TFlt_GetRnd() + + GetRnd = staticmethod(GetRnd) + def Eq6(*args): + """ + Eq6(double const & LFlt, double const & RFlt) -> bool + + Parameters: + LFlt: double const & + RFlt: double const & + + """ + return _snap.TFlt_Eq6(*args) + + Eq6 = staticmethod(Eq6) + def GetMn(*args): + """ + GetMn(double const & Flt1, double const & Flt2) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + + GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const & + + GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const & + Flt4: double const & + + """ + return _snap.TFlt_GetMn(*args) + + GetMn = staticmethod(GetMn) + def GetMx(*args): + """ + GetMx(double const & Flt1, double const & Flt2) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + + GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const + + GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const + Flt4: double const & + + """ + return _snap.TFlt_GetMx(*args) + + GetMx = staticmethod(GetMx) + def GetInRng(*args): + """ + GetInRng(double const & Val, double const & Mn, double const & Mx) -> double + + Parameters: + Val: double const & + Mn: double const & + Mx: double const & + + """ + return _snap.TFlt_GetInRng(*args) + + GetInRng = staticmethod(GetInRng) + def IsNum(self, *args): + """ + IsNum(TFlt self, double const & Val) -> bool + + Parameters: + Val: double const & + + IsNum(TFlt self) -> bool + + Parameters: + self: TFlt const * + + """ + return _snap.TFlt_IsNum(self, *args) + + def IsNan(self, *args): + """ + IsNan(TFlt self, double const & Val) -> bool + + Parameters: + Val: double const & + + IsNan(TFlt self) -> bool + + Parameters: + self: TFlt const * + + """ + return _snap.TFlt_IsNan(self, *args) + + def GetPrcStr(*args): + """ + GetPrcStr(double const & RelVal, double const & FullVal) -> TStr + + Parameters: + RelVal: double const & + FullVal: double const & + + """ + return _snap.TFlt_GetPrcStr(*args) + + GetPrcStr = staticmethod(GetPrcStr) + def GetKiloStr(*args): + """ + GetKiloStr(double const & Val) -> TStr + + Parameters: + Val: double const & + + """ + return _snap.TFlt_GetKiloStr(*args) + + GetKiloStr = staticmethod(GetKiloStr) + def GetMegaStr(*args): + """ + GetMegaStr(double const & Val) -> TStr + + Parameters: + Val: double const & + + """ + return _snap.TFlt_GetMegaStr(*args) + + GetMegaStr = staticmethod(GetMegaStr) + def GetGigaStr(*args): + """ + GetGigaStr(double const & Val) -> TStr + + Parameters: + Val: double const & + + """ + return _snap.TFlt_GetGigaStr(*args) + + GetGigaStr = staticmethod(GetGigaStr) + __swig_destroy__ = _snap.delete_TFlt +TFlt.Load = new_instancemethod(_snap.TFlt_Load,None,TFlt) +TFlt.Save = new_instancemethod(_snap.TFlt_Save,None,TFlt) +TFlt.LoadXml = new_instancemethod(_snap.TFlt_LoadXml,None,TFlt) +TFlt.SaveXml = new_instancemethod(_snap.TFlt_SaveXml,None,TFlt) +TFlt.__eq__ = new_instancemethod(_snap.TFlt___eq__,None,TFlt) +TFlt.__ne__ = new_instancemethod(_snap.TFlt___ne__,None,TFlt) +TFlt.__call__ = new_instancemethod(_snap.TFlt___call__,None,TFlt) +TFlt.__iadd__ = new_instancemethod(_snap.TFlt___iadd__,None,TFlt) +TFlt.__isub__ = new_instancemethod(_snap.TFlt___isub__,None,TFlt) +TFlt.__imul__ = new_instancemethod(_snap.TFlt___imul__,None,TFlt) +TFlt.__idiv__ = new_instancemethod(_snap.TFlt___idiv__,None,TFlt) +TFlt.GetMemUsed = new_instancemethod(_snap.TFlt_GetMemUsed,None,TFlt) +TFlt.GetPrimHashCd = new_instancemethod(_snap.TFlt_GetPrimHashCd,None,TFlt) +TFlt.GetSecHashCd = new_instancemethod(_snap.TFlt_GetSecHashCd,None,TFlt) +TFlt.IsNum = new_instancemethod(_snap.TFlt_IsNum,None,TFlt) +TFlt.IsNan = new_instancemethod(_snap.TFlt_IsNan,None,TFlt) +TFlt_swigregister = _snap.TFlt_swigregister +TFlt_swigregister(TFlt) +TFlt.Mn = _snap.cvar.TFlt_Mn +TFlt.Mx = _snap.cvar.TFlt_Mx +TFlt.NInf = _snap.cvar.TFlt_NInf +TFlt.PInf = _snap.cvar.TFlt_PInf +TFlt.Eps = _snap.cvar.TFlt_Eps +TFlt.EpsHalf = _snap.cvar.TFlt_EpsHalf + +def TFlt_Abs(*args): + """ + TFlt_Abs(double const & Flt) -> double + + Parameters: + Flt: double const & + + """ + return _snap.TFlt_Abs(*args) + +def TFlt_Sign(*args): + """ + TFlt_Sign(double const & Flt) -> int + + Parameters: + Flt: double const & + + """ + return _snap.TFlt_Sign(*args) + +def TFlt_Round(*args): + """ + TFlt_Round(double const & Flt) -> int + + Parameters: + Flt: double const & + + """ + return _snap.TFlt_Round(*args) + +def TFlt_GetRnd(): + """TFlt_GetRnd() -> double""" + return _snap.TFlt_GetRnd() + +def TFlt_Eq6(*args): + """ + TFlt_Eq6(double const & LFlt, double const & RFlt) -> bool + + Parameters: + LFlt: double const & + RFlt: double const & + + """ + return _snap.TFlt_Eq6(*args) + +def TFlt_GetMn(*args): + """ + GetMn(double const & Flt1, double const & Flt2) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + + GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const & + + TFlt_GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const & + Flt4: double const & + + """ + return _snap.TFlt_GetMn(*args) + +def TFlt_GetMx(*args): + """ + GetMx(double const & Flt1, double const & Flt2) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + + GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const + + TFlt_GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double + + Parameters: + Flt1: double const & + Flt2: double const & + Flt3: double const + Flt4: double const & + + """ + return _snap.TFlt_GetMx(*args) + +def TFlt_GetInRng(*args): + """ + TFlt_GetInRng(double const & Val, double const & Mn, double const & Mx) -> double + + Parameters: + Val: double const & + Mn: double const & + Mx: double const & + + """ + return _snap.TFlt_GetInRng(*args) + +def TFlt_GetPrcStr(*args): + """ + TFlt_GetPrcStr(double const & RelVal, double const & FullVal) -> TStr + + Parameters: + RelVal: double const & + FullVal: double const & + + """ + return _snap.TFlt_GetPrcStr(*args) + +def TFlt_GetKiloStr(*args): + """ + TFlt_GetKiloStr(double const & Val) -> TStr + + Parameters: + Val: double const & + + """ + return _snap.TFlt_GetKiloStr(*args) + +def TFlt_GetMegaStr(*args): + """ + TFlt_GetMegaStr(double const & Val) -> TStr + + Parameters: + Val: double const & + + """ + return _snap.TFlt_GetMegaStr(*args) + +def TFlt_GetGigaStr(*args): + """ + TFlt_GetGigaStr(double const & Val) -> TStr + + Parameters: + Val: double const & + + """ + return _snap.TFlt_GetGigaStr(*args) + +class TAscFlt(TFlt): + """Proxy of C++ TAscFlt class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TAscFlt self) -> TAscFlt + __init__(TAscFlt self, double const & Val) -> TAscFlt + + Parameters: + Val: double const & + + __init__(TAscFlt self, TSIn SIn) -> TAscFlt + + Parameters: + SIn: TSIn & + + """ + _snap.TAscFlt_swiginit(self,_snap.new_TAscFlt(*args)) + def Save(self, *args): + """ + Save(TAscFlt self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TAscFlt_Save(self, *args) + + __swig_destroy__ = _snap.delete_TAscFlt +TAscFlt.Save = new_instancemethod(_snap.TAscFlt_Save,None,TAscFlt) +TAscFlt_swigregister = _snap.TAscFlt_swigregister +TAscFlt_swigregister(TAscFlt) + +class TSFlt(object): + """Proxy of C++ TSFlt class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TSFlt_Val_get, _snap.TSFlt_Val_set) + def __init__(self, *args): + """ + __init__(TSFlt self) -> TSFlt + __init__(TSFlt self, sdouble const & _Val) -> TSFlt + + Parameters: + _Val: sdouble const & + + __init__(TSFlt self, TSIn SIn) -> TSFlt + + Parameters: + SIn: TSIn & + + """ + _snap.TSFlt_swiginit(self,_snap.new_TSFlt(*args)) + def Save(self, *args): + """ + Save(TSFlt self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TSFlt_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TSFlt self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TSFlt_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TSFlt self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TSFlt_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TSFlt self, TSFlt SFlt) -> bool + + Parameters: + SFlt: TSFlt const & + + __eq__(TSFlt self, double const & Flt) -> bool + + Parameters: + Flt: double const & + + """ + return _snap.TSFlt___eq__(self, *args) + + def __ne__(self, *args): + """ + __ne__(TSFlt self, double const & Flt) -> bool + + Parameters: + Flt: double const & + + """ + return _snap.TSFlt___ne__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TSFlt self, TSFlt SFlt) -> bool + + Parameters: + SFlt: TSFlt const & + + """ + return _snap.TSFlt___lt__(self, *args) + + def __call__(self): + """ + __call__(TSFlt self) -> sdouble + + Parameters: + self: TSFlt const * + + """ + return _snap.TSFlt___call__(self) + + def __iadd__(self, *args): + """ + __iadd__(TSFlt self, double const & SFlt) -> TSFlt + + Parameters: + SFlt: double const & + + """ + return _snap.TSFlt___iadd__(self, *args) + + def __isub__(self, *args): + """ + __isub__(TSFlt self, double const & SFlt) -> TSFlt + + Parameters: + SFlt: double const & + + """ + return _snap.TSFlt___isub__(self, *args) + + def __imul__(self, *args): + """ + __imul__(TSFlt self, double const & SFlt) -> TSFlt + + Parameters: + SFlt: double const & + + """ + return _snap.TSFlt___imul__(self, *args) + + def __idiv__(self, *args): + """ + __idiv__(TSFlt self, double const & SFlt) -> TSFlt + + Parameters: + SFlt: double const & + + """ + return _snap.TSFlt___idiv__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TSFlt self) -> int + + Parameters: + self: TSFlt const * + + """ + return _snap.TSFlt_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TSFlt self) -> int + + Parameters: + self: TSFlt const * + + """ + return _snap.TSFlt_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TSFlt self) -> int + + Parameters: + self: TSFlt const * + + """ + return _snap.TSFlt_GetSecHashCd(self) + + __swig_destroy__ = _snap.delete_TSFlt +TSFlt.Save = new_instancemethod(_snap.TSFlt_Save,None,TSFlt) +TSFlt.LoadXml = new_instancemethod(_snap.TSFlt_LoadXml,None,TSFlt) +TSFlt.SaveXml = new_instancemethod(_snap.TSFlt_SaveXml,None,TSFlt) +TSFlt.__eq__ = new_instancemethod(_snap.TSFlt___eq__,None,TSFlt) +TSFlt.__ne__ = new_instancemethod(_snap.TSFlt___ne__,None,TSFlt) +TSFlt.__lt__ = new_instancemethod(_snap.TSFlt___lt__,None,TSFlt) +TSFlt.__call__ = new_instancemethod(_snap.TSFlt___call__,None,TSFlt) +TSFlt.__iadd__ = new_instancemethod(_snap.TSFlt___iadd__,None,TSFlt) +TSFlt.__isub__ = new_instancemethod(_snap.TSFlt___isub__,None,TSFlt) +TSFlt.__imul__ = new_instancemethod(_snap.TSFlt___imul__,None,TSFlt) +TSFlt.__idiv__ = new_instancemethod(_snap.TSFlt___idiv__,None,TSFlt) +TSFlt.GetMemUsed = new_instancemethod(_snap.TSFlt_GetMemUsed,None,TSFlt) +TSFlt.GetPrimHashCd = new_instancemethod(_snap.TSFlt_GetPrimHashCd,None,TSFlt) +TSFlt.GetSecHashCd = new_instancemethod(_snap.TSFlt_GetSecHashCd,None,TSFlt) +TSFlt_swigregister = _snap.TSFlt_swigregister +TSFlt_swigregister(TSFlt) +TSFlt.Mn = _snap.cvar.TSFlt_Mn +TSFlt.Mx = _snap.cvar.TSFlt_Mx + +class TLFlt(object): + """Proxy of C++ TLFlt class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + Val = _swig_property(_snap.TLFlt_Val_get, _snap.TLFlt_Val_set) + def __init__(self, *args): + """ + __init__(TLFlt self) -> TLFlt + __init__(TLFlt self, ldouble const & _Val) -> TLFlt + + Parameters: + _Val: ldouble const & + + __init__(TLFlt self, TSIn SIn) -> TLFlt + + Parameters: + SIn: TSIn & + + """ + _snap.TLFlt_swiginit(self,_snap.new_TLFlt(*args)) + def Save(self, *args): + """ + Save(TLFlt self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TLFlt_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TLFlt self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TLFlt_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TLFlt self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TLFlt_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TLFlt self, TLFlt LFlt) -> bool + + Parameters: + LFlt: TLFlt const & + + __eq__(TLFlt self, ldouble const & LFlt) -> bool + + Parameters: + LFlt: ldouble const & + + """ + return _snap.TLFlt___eq__(self, *args) + + def __ne__(self, *args): + """ + __ne__(TLFlt self, ldouble const & LFlt) -> bool + + Parameters: + LFlt: ldouble const & + + """ + return _snap.TLFlt___ne__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TLFlt self, TLFlt LFlt) -> bool + + Parameters: + LFlt: TLFlt const & + + """ + return _snap.TLFlt___lt__(self, *args) + + def __call__(self): + """ + __call__(TLFlt self) -> ldouble + + Parameters: + self: TLFlt const * + + """ + return _snap.TLFlt___call__(self) + + def __iadd__(self, *args): + """ + __iadd__(TLFlt self, ldouble const & LFlt) -> TLFlt + + Parameters: + LFlt: ldouble const & + + """ + return _snap.TLFlt___iadd__(self, *args) + + def __isub__(self, *args): + """ + __isub__(TLFlt self, ldouble const & LFlt) -> TLFlt + + Parameters: + LFlt: ldouble const & + + """ + return _snap.TLFlt___isub__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TLFlt self) -> int + + Parameters: + self: TLFlt const * + + """ + return _snap.TLFlt_GetMemUsed(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TLFlt self) -> int + + Parameters: + self: TLFlt const * + + """ + return _snap.TLFlt_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TLFlt self) -> int + + Parameters: + self: TLFlt const * + + """ + return _snap.TLFlt_GetSecHashCd(self) + + __swig_destroy__ = _snap.delete_TLFlt +TLFlt.Save = new_instancemethod(_snap.TLFlt_Save,None,TLFlt) +TLFlt.LoadXml = new_instancemethod(_snap.TLFlt_LoadXml,None,TLFlt) +TLFlt.SaveXml = new_instancemethod(_snap.TLFlt_SaveXml,None,TLFlt) +TLFlt.__eq__ = new_instancemethod(_snap.TLFlt___eq__,None,TLFlt) +TLFlt.__ne__ = new_instancemethod(_snap.TLFlt___ne__,None,TLFlt) +TLFlt.__lt__ = new_instancemethod(_snap.TLFlt___lt__,None,TLFlt) +TLFlt.__call__ = new_instancemethod(_snap.TLFlt___call__,None,TLFlt) +TLFlt.__iadd__ = new_instancemethod(_snap.TLFlt___iadd__,None,TLFlt) +TLFlt.__isub__ = new_instancemethod(_snap.TLFlt___isub__,None,TLFlt) +TLFlt.GetMemUsed = new_instancemethod(_snap.TLFlt_GetMemUsed,None,TLFlt) +TLFlt.GetPrimHashCd = new_instancemethod(_snap.TLFlt_GetPrimHashCd,None,TLFlt) +TLFlt.GetSecHashCd = new_instancemethod(_snap.TLFlt_GetSecHashCd,None,TLFlt) +TLFlt_swigregister = _snap.TLFlt_swigregister +TLFlt_swigregister(TLFlt) +TLFlt.Mn = _snap.cvar.TLFlt_Mn +TLFlt.Mx = _snap.cvar.TLFlt_Mx + +class TFltRect(object): + """Proxy of C++ TFltRect class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + MnX = _swig_property(_snap.TFltRect_MnX_get, _snap.TFltRect_MnX_set) + MnY = _swig_property(_snap.TFltRect_MnY_get, _snap.TFltRect_MnY_set) + MxX = _swig_property(_snap.TFltRect_MxX_get, _snap.TFltRect_MxX_set) + MxY = _swig_property(_snap.TFltRect_MxY_get, _snap.TFltRect_MxY_set) + def __init__(self, *args): + """ + __init__(TFltRect self) -> TFltRect + __init__(TFltRect self, TFltRect FltRect) -> TFltRect + + Parameters: + FltRect: TFltRect const & + + __init__(TFltRect self, double const & _MnX, double const & _MnY, double const & _MxX, double const & _MxY) -> TFltRect + + Parameters: + _MnX: double const & + _MnY: double const & + _MxX: double const & + _MxY: double const & + + __init__(TFltRect self, TSIn SIn) -> TFltRect + + Parameters: + SIn: TSIn & + + """ + _snap.TFltRect_swiginit(self,_snap.new_TFltRect(*args)) + def Save(self, *args): + """ + Save(TFltRect self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TFltRect_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TFltRect self, PXmlTok const & XmlTok, TStr Nm) + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + """ + return _snap.TFltRect_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TFltRect self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TFltRect_SaveXml(self, *args) + + def GetMnX(self): + """ + GetMnX(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetMnX(self) + + def GetMnY(self): + """ + GetMnY(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetMnY(self) + + def GetMxX(self): + """ + GetMxX(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetMxX(self) + + def GetMxY(self): + """ + GetMxY(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetMxY(self) + + def GetXLen(self): + """ + GetXLen(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetXLen(self) + + def GetYLen(self): + """ + GetYLen(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetYLen(self) + + def GetXCenter(self): + """ + GetXCenter(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetXCenter(self) + + def GetYCenter(self): + """ + GetYCenter(TFltRect self) -> double + + Parameters: + self: TFltRect const * + + """ + return _snap.TFltRect_GetYCenter(self) + + def IsXYIn(self, *args): + """ + IsXYIn(TFltRect self, double const & X, double const & Y) -> bool + + Parameters: + X: double const & + Y: double const & + + """ + return _snap.TFltRect_IsXYIn(self, *args) + + def Intersection(*args): + """ + Intersection(TFltRect Rect1, TFltRect Rect2) -> bool + + Parameters: + Rect1: TFltRect const & + Rect2: TFltRect const & + + """ + return _snap.TFltRect_Intersection(*args) + + Intersection = staticmethod(Intersection) + __swig_destroy__ = _snap.delete_TFltRect +TFltRect.Save = new_instancemethod(_snap.TFltRect_Save,None,TFltRect) +TFltRect.LoadXml = new_instancemethod(_snap.TFltRect_LoadXml,None,TFltRect) +TFltRect.SaveXml = new_instancemethod(_snap.TFltRect_SaveXml,None,TFltRect) +TFltRect.GetMnX = new_instancemethod(_snap.TFltRect_GetMnX,None,TFltRect) +TFltRect.GetMnY = new_instancemethod(_snap.TFltRect_GetMnY,None,TFltRect) +TFltRect.GetMxX = new_instancemethod(_snap.TFltRect_GetMxX,None,TFltRect) +TFltRect.GetMxY = new_instancemethod(_snap.TFltRect_GetMxY,None,TFltRect) +TFltRect.GetXLen = new_instancemethod(_snap.TFltRect_GetXLen,None,TFltRect) +TFltRect.GetYLen = new_instancemethod(_snap.TFltRect_GetYLen,None,TFltRect) +TFltRect.GetXCenter = new_instancemethod(_snap.TFltRect_GetXCenter,None,TFltRect) +TFltRect.GetYCenter = new_instancemethod(_snap.TFltRect_GetYCenter,None,TFltRect) +TFltRect.IsXYIn = new_instancemethod(_snap.TFltRect_IsXYIn,None,TFltRect) +TFltRect_swigregister = _snap.TFltRect_swigregister +TFltRect_swigregister(TFltRect) + +def TFltRect_Intersection(*args): + """ + TFltRect_Intersection(TFltRect Rect1, TFltRect Rect2) -> bool + + Parameters: + Rect1: TFltRect const & + Rect2: TFltRect const & + + """ + return _snap.TFltRect_Intersection(*args) + +class TIntV(object): + """Proxy of C++ TVec<(TInt,int)> class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TIntV + def __init__(self, *args): + """ + __init__(TVec<(TInt,int)> self) -> TIntV + __init__(TVec<(TInt,int)> self, TIntV Vec) -> TIntV + + Parameters: + Vec: TVec< TInt,int > const & + + __init__(TVec<(TInt,int)> self, int const & _Vals) -> TIntV + + Parameters: + _Vals: int const & + + __init__(TVec<(TInt,int)> self, int const & _MxVals, int const & _Vals) -> TIntV + + Parameters: + _MxVals: int const & + _Vals: int const & + + __init__(TVec<(TInt,int)> self, TInt _ValT, int const & _Vals) -> TIntV + + Parameters: + _ValT: TInt * + _Vals: int const & + + __init__(TVec<(TInt,int)> self, TSIn SIn) -> TIntV + + Parameters: + SIn: TSIn & + + """ + _snap.TIntV_swiginit(self,_snap.new_TIntV(*args)) + def Load(self, *args): + """ + Load(TIntV self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TIntV_Load(self, *args) + + def Save(self, *args): + """ + Save(TIntV self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TIntV_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TIntV self, PXmlTok const & XmlTok, TStr Nm="") + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + LoadXml(TIntV self, PXmlTok const & XmlTok) + + Parameters: + XmlTok: PXmlTok const & + + """ + return _snap.TIntV_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TIntV self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TIntV_SaveXml(self, *args) + + def __add__(self, *args): + """ + __add__(TIntV self, TInt Val) -> TIntV + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV___add__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TIntV self, TIntV Vec) -> bool + + Parameters: + Vec: TVec< TInt,int > const & + + """ + return _snap.TIntV___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TIntV self, TIntV Vec) -> bool + + Parameters: + Vec: TVec< TInt,int > const & + + """ + return _snap.TIntV___lt__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_GetMemUsed(self) + + def GetMemSize(self): + """ + GetMemSize(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_GetMemSize(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_GetSecHashCd(self) + + def Gen(self, *args): + """ + Gen(TIntV self, int const & _Vals) + + Parameters: + _Vals: int const & + + Gen(TIntV self, int const & _MxVals, int const & _Vals) + + Parameters: + _MxVals: int const & + _Vals: int const & + + """ + return _snap.TIntV_Gen(self, *args) + + def GenExt(self, *args): + """ + GenExt(TIntV self, TInt _ValT, int const & _Vals) + + Parameters: + _ValT: TInt * + _Vals: int const & + + """ + return _snap.TIntV_GenExt(self, *args) + + def IsExt(self): + """ + IsExt(TIntV self) -> bool + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_IsExt(self) + + def Reserve(self, *args): + """ + Reserve(TIntV self, int const & _MxVals) + + Parameters: + _MxVals: int const & + + Reserve(TIntV self, int const & _MxVals, int const & _Vals) + + Parameters: + _MxVals: int const & + _Vals: int const & + + """ + return _snap.TIntV_Reserve(self, *args) + + def Clr(self, *args): + """ + Clr(TIntV self, bool const & DoDel=True, int const & NoDelLim=-1) + + Parameters: + DoDel: bool const & + NoDelLim: int const & + + Clr(TIntV self, bool const & DoDel=True) + + Parameters: + DoDel: bool const & + + Clr(TIntV self) + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_Clr(self, *args) + + def Trunc(self, *args): + """ + Trunc(TIntV self, int const & _Vals=-1) + + Parameters: + _Vals: int const & + + Trunc(TIntV self) + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_Trunc(self, *args) + + def Pack(self): + """ + Pack(TIntV self) + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_Pack(self) + + def MoveFrom(self, *args): + """ + MoveFrom(TIntV self, TIntV Vec) + + Parameters: + Vec: TVec< TInt,int > & + + """ + return _snap.TIntV_MoveFrom(self, *args) + + def Empty(self): + """ + Empty(TIntV self) -> bool + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_Empty(self) + + def Len(self): + """ + Len(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_Len(self) + + def Reserved(self): + """ + Reserved(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_Reserved(self) + + def Last(self, *args): + """ + Last(TIntV self) -> TInt + Last(TIntV self) -> TInt + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_Last(self, *args) + + def LastValN(self): + """ + LastValN(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_LastValN(self) + + def LastLast(self, *args): + """ + LastLast(TIntV self) -> TInt + LastLast(TIntV self) -> TInt + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_LastLast(self, *args) + + def BegI(self): + """ + BegI(TIntV self) -> TInt + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_BegI(self) + + def EndI(self): + """ + EndI(TIntV self) -> TInt + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_EndI(self) + + def GetI(self, *args): + """ + GetI(TIntV self, int const & ValN) -> TInt + + Parameters: + ValN: int const & + + """ + return _snap.TIntV_GetI(self, *args) + + def AddV(self, *args): + """ + AddV(TIntV self, TIntV ValV) -> int + + Parameters: + ValV: TVec< TInt,int > const & + + """ + return _snap.TIntV_AddV(self, *args) + + def AddSorted(self, *args): + """ + AddSorted(TIntV self, TInt Val, bool const & Asc=True, int const & _MxVals=-1) -> int + + Parameters: + Val: TInt const & + Asc: bool const & + _MxVals: int const & + + AddSorted(TIntV self, TInt Val, bool const & Asc=True) -> int + + Parameters: + Val: TInt const & + Asc: bool const & + + AddSorted(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_AddSorted(self, *args) + + def AddBackSorted(self, *args): + """ + AddBackSorted(TIntV self, TInt Val, bool const & Asc) -> int + + Parameters: + Val: TInt const & + Asc: bool const & + + """ + return _snap.TIntV_AddBackSorted(self, *args) + + def AddVMerged(self, *args): + """ + AddVMerged(TIntV self, TIntV ValV) -> int + + Parameters: + ValV: TVec< TInt,int > const & + + """ + return _snap.TIntV_AddVMerged(self, *args) + + def AddUnique(self, *args): + """ + AddUnique(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_AddUnique(self, *args) + + def GetVal(self, *args): + """ + GetVal(TIntV self, int const & ValN) -> TInt + + Parameters: + ValN: int const & + + GetVal(TIntV self, int const & ValN) -> TInt + + Parameters: + ValN: int const & + + """ + return _snap.TIntV_GetVal(self, *args) + + def GetSubValV(self, *args): + """ + GetSubValV(TIntV self, int const & BValN, int const & EValN, TIntV ValV) + + Parameters: + BValN: int const & + EValN: int const & + ValV: TVec< TInt,int > & + + """ + return _snap.TIntV_GetSubValV(self, *args) + + def Ins(self, *args): + """ + Ins(TIntV self, int const & ValN, TInt Val) + + Parameters: + ValN: int const & + Val: TInt const & + + """ + return _snap.TIntV_Ins(self, *args) + + def Del(self, *args): + """ + Del(TIntV self, int const & ValN) + + Parameters: + ValN: int const & + + Del(TIntV self, int const & MnValN, int const & MxValN) + + Parameters: + MnValN: int const & + MxValN: int const & + + """ + return _snap.TIntV_Del(self, *args) + + def DelLast(self): + """ + DelLast(TIntV self) + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_DelLast(self) + + def DelIfIn(self, *args): + """ + DelIfIn(TIntV self, TInt Val) -> bool + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_DelIfIn(self, *args) + + def DelAll(self, *args): + """ + DelAll(TIntV self, TInt Val) + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_DelAll(self, *args) + + def PutAll(self, *args): + """ + PutAll(TIntV self, TInt Val) + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_PutAll(self, *args) + + def Swap(self, *args): + """ + Swap(TIntV self, TIntV Vec) + + Parameters: + Vec: TVec< TInt,int > & + + Swap(TIntV self, int const & ValN1, int const & ValN2) + + Parameters: + ValN1: int const & + ValN2: int const & + + """ + return _snap.TIntV_Swap(self, *args) + + def SwapI(*args): + """ + SwapI(TInt LVal, TInt RVal) + + Parameters: + LVal: TVec< TInt,int >::TIter + RVal: TVec< TInt,int >::TIter + + """ + return _snap.TIntV_SwapI(*args) + + SwapI = staticmethod(SwapI) + def NextPerm(self): + """ + NextPerm(TIntV self) -> bool + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_NextPerm(self) + + def PrevPerm(self): + """ + PrevPerm(TIntV self) -> bool + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_PrevPerm(self) + + def GetPivotValN(self, *args): + """ + GetPivotValN(TIntV self, int const & LValN, int const & RValN) -> int + + Parameters: + LValN: int const & + RValN: int const & + + """ + return _snap.TIntV_GetPivotValN(self, *args) + + def BSort(self, *args): + """ + BSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntV_BSort(self, *args) + + def ISort(self, *args): + """ + ISort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntV_ISort(self, *args) + + def Partition(self, *args): + """ + Partition(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntV_Partition(self, *args) + + def QSort(self, *args): + """ + QSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntV_QSort(self, *args) + + def Sort(self, Asc=True): + """ + Sort(TIntV self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + Sort(TIntV self) + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_Sort(self, Asc) + + def IsSorted(self, Asc=True): + """ + IsSorted(TIntV self, bool const & Asc=True) -> bool + + Parameters: + Asc: bool const & + + IsSorted(TIntV self) -> bool + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_IsSorted(self, Asc) + + def Shuffle(self, *args): + """ + Shuffle(TIntV self, TRnd Rnd) + + Parameters: + Rnd: TRnd & + + """ + return _snap.TIntV_Shuffle(self, *args) + + def Reverse(self, *args): + """ + Reverse(TIntV self) + Reverse(TIntV self, int LValN, int RValN) + + Parameters: + LValN: int + RValN: int + + """ + return _snap.TIntV_Reverse(self, *args) + + def Merge(self): + """ + Merge(TIntV self) + + Parameters: + self: TVec< TInt,int > * + + """ + return _snap.TIntV_Merge(self) + + def Intrs(self, *args): + """ + Intrs(TIntV self, TIntV ValV) + + Parameters: + ValV: TVec< TInt,int > const & + + Intrs(TIntV self, TIntV ValV, TIntV DstValV) + + Parameters: + ValV: TVec< TInt,int > const & + DstValV: TVec< TInt,int > & + + """ + return _snap.TIntV_Intrs(self, *args) + + def Union(self, *args): + """ + Union(TIntV self, TIntV ValV) + + Parameters: + ValV: TVec< TInt,int > const & + + Union(TIntV self, TIntV ValV, TIntV DstValV) + + Parameters: + ValV: TVec< TInt,int > const & + DstValV: TVec< TInt,int > & + + """ + return _snap.TIntV_Union(self, *args) + + def Diff(self, *args): + """ + Diff(TIntV self, TIntV ValV) + + Parameters: + ValV: TVec< TInt,int > const & + + Diff(TIntV self, TIntV ValV, TIntV DstValV) + + Parameters: + ValV: TVec< TInt,int > const & + DstValV: TVec< TInt,int > & + + """ + return _snap.TIntV_Diff(self, *args) + + def IntrsLen(self, *args): + """ + IntrsLen(TIntV self, TIntV ValV) -> int + + Parameters: + ValV: TVec< TInt,int > const & + + """ + return _snap.TIntV_IntrsLen(self, *args) + + def UnionLen(self, *args): + """ + UnionLen(TIntV self, TIntV ValV) -> int + + Parameters: + ValV: TVec< TInt,int > const & + + """ + return _snap.TIntV_UnionLen(self, *args) + + def Count(self, *args): + """ + Count(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_Count(self, *args) + + def SearchBin(self, *args): + """ + SearchBin(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + SearchBin(TIntV self, TInt Val, int & InsValN) -> int + + Parameters: + Val: TInt const & + InsValN: int & + + """ + return _snap.TIntV_SearchBin(self, *args) + + def SearchForw(self, *args): + """ + SearchForw(TIntV self, TInt Val, int const & BValN=0) -> int + + Parameters: + Val: TInt const & + BValN: int const & + + SearchForw(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_SearchForw(self, *args) + + def SearchBack(self, *args): + """ + SearchBack(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_SearchBack(self, *args) + + def SearchVForw(self, *args): + """ + SearchVForw(TIntV self, TIntV ValV, int const & BValN=0) -> int + + Parameters: + ValV: TVec< TInt,int > const & + BValN: int const & + + SearchVForw(TIntV self, TIntV ValV) -> int + + Parameters: + ValV: TVec< TInt,int > const & + + """ + return _snap.TIntV_SearchVForw(self, *args) + + def IsIn(self, *args): + """ + IsIn(TIntV self, TInt Val) -> bool + + Parameters: + Val: TInt const & + + IsIn(TIntV self, TInt Val, int & ValN) -> bool + + Parameters: + Val: TInt const & + ValN: int & + + """ + return _snap.TIntV_IsIn(self, *args) + + def IsInBin(self, *args): + """ + IsInBin(TIntV self, TInt Val) -> bool + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_IsInBin(self, *args) + + def GetDat(self, *args): + """ + GetDat(TIntV self, TInt Val) -> TInt + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_GetDat(self, *args) + + def GetAddDat(self, *args): + """ + GetAddDat(TIntV self, TInt Val) -> TInt + + Parameters: + Val: TInt const & + + """ + return _snap.TIntV_GetAddDat(self, *args) + + def GetMxValN(self): + """ + GetMxValN(TIntV self) -> int + + Parameters: + self: TVec< TInt,int > const * + + """ + return _snap.TIntV_GetMxValN(self) + + def GetV(*args): + """ + GetV(TInt Val1) -> TIntV + + Parameters: + Val1: TInt const & + + GetV(TInt Val1, TInt Val2) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + Val7: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + Val7: TInt const & + Val8: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8, + TInt Val9) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + Val7: TInt const & + Val8: TInt const & + Val9: TInt const & + + """ + return _snap.TIntV_GetV(*args) + + GetV = staticmethod(GetV) + def Add(self, *args): + """ + Add(TIntV self) -> int + Add(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + Add(TIntV self, TInt Val, int const & ResizeLen) -> int + + Parameters: + Val: TInt const & + ResizeLen: int const & + + Add(TIntV self, int Val) -> int + + Parameters: + Val: int + + """ + return _snap.TIntV_Add(self, *args) + + def AddMerged(self, *args): + """ + AddMerged(TIntV self, TInt Val) -> int + + Parameters: + Val: TInt const & + + AddMerged(TIntV self, int Val) -> int + + Parameters: + Val: int + + """ + return _snap.TIntV_AddMerged(self, *args) + +TIntV.Load = new_instancemethod(_snap.TIntV_Load,None,TIntV) +TIntV.Save = new_instancemethod(_snap.TIntV_Save,None,TIntV) +TIntV.LoadXml = new_instancemethod(_snap.TIntV_LoadXml,None,TIntV) +TIntV.SaveXml = new_instancemethod(_snap.TIntV_SaveXml,None,TIntV) +TIntV.__add__ = new_instancemethod(_snap.TIntV___add__,None,TIntV) +TIntV.__eq__ = new_instancemethod(_snap.TIntV___eq__,None,TIntV) +TIntV.__lt__ = new_instancemethod(_snap.TIntV___lt__,None,TIntV) +TIntV.GetMemUsed = new_instancemethod(_snap.TIntV_GetMemUsed,None,TIntV) +TIntV.GetMemSize = new_instancemethod(_snap.TIntV_GetMemSize,None,TIntV) +TIntV.GetPrimHashCd = new_instancemethod(_snap.TIntV_GetPrimHashCd,None,TIntV) +TIntV.GetSecHashCd = new_instancemethod(_snap.TIntV_GetSecHashCd,None,TIntV) +TIntV.Gen = new_instancemethod(_snap.TIntV_Gen,None,TIntV) +TIntV.GenExt = new_instancemethod(_snap.TIntV_GenExt,None,TIntV) +TIntV.IsExt = new_instancemethod(_snap.TIntV_IsExt,None,TIntV) +TIntV.Reserve = new_instancemethod(_snap.TIntV_Reserve,None,TIntV) +TIntV.Clr = new_instancemethod(_snap.TIntV_Clr,None,TIntV) +TIntV.Trunc = new_instancemethod(_snap.TIntV_Trunc,None,TIntV) +TIntV.Pack = new_instancemethod(_snap.TIntV_Pack,None,TIntV) +TIntV.MoveFrom = new_instancemethod(_snap.TIntV_MoveFrom,None,TIntV) +TIntV.Empty = new_instancemethod(_snap.TIntV_Empty,None,TIntV) +TIntV.Len = new_instancemethod(_snap.TIntV_Len,None,TIntV) +TIntV.Reserved = new_instancemethod(_snap.TIntV_Reserved,None,TIntV) +TIntV.Last = new_instancemethod(_snap.TIntV_Last,None,TIntV) +TIntV.LastValN = new_instancemethod(_snap.TIntV_LastValN,None,TIntV) +TIntV.LastLast = new_instancemethod(_snap.TIntV_LastLast,None,TIntV) +TIntV.BegI = new_instancemethod(_snap.TIntV_BegI,None,TIntV) +TIntV.EndI = new_instancemethod(_snap.TIntV_EndI,None,TIntV) +TIntV.GetI = new_instancemethod(_snap.TIntV_GetI,None,TIntV) +TIntV.AddV = new_instancemethod(_snap.TIntV_AddV,None,TIntV) +TIntV.AddSorted = new_instancemethod(_snap.TIntV_AddSorted,None,TIntV) +TIntV.AddBackSorted = new_instancemethod(_snap.TIntV_AddBackSorted,None,TIntV) +TIntV.AddVMerged = new_instancemethod(_snap.TIntV_AddVMerged,None,TIntV) +TIntV.AddUnique = new_instancemethod(_snap.TIntV_AddUnique,None,TIntV) +TIntV.GetVal = new_instancemethod(_snap.TIntV_GetVal,None,TIntV) +TIntV.GetSubValV = new_instancemethod(_snap.TIntV_GetSubValV,None,TIntV) +TIntV.Ins = new_instancemethod(_snap.TIntV_Ins,None,TIntV) +TIntV.Del = new_instancemethod(_snap.TIntV_Del,None,TIntV) +TIntV.DelLast = new_instancemethod(_snap.TIntV_DelLast,None,TIntV) +TIntV.DelIfIn = new_instancemethod(_snap.TIntV_DelIfIn,None,TIntV) +TIntV.DelAll = new_instancemethod(_snap.TIntV_DelAll,None,TIntV) +TIntV.PutAll = new_instancemethod(_snap.TIntV_PutAll,None,TIntV) +TIntV.Swap = new_instancemethod(_snap.TIntV_Swap,None,TIntV) +TIntV.NextPerm = new_instancemethod(_snap.TIntV_NextPerm,None,TIntV) +TIntV.PrevPerm = new_instancemethod(_snap.TIntV_PrevPerm,None,TIntV) +TIntV.GetPivotValN = new_instancemethod(_snap.TIntV_GetPivotValN,None,TIntV) +TIntV.BSort = new_instancemethod(_snap.TIntV_BSort,None,TIntV) +TIntV.ISort = new_instancemethod(_snap.TIntV_ISort,None,TIntV) +TIntV.Partition = new_instancemethod(_snap.TIntV_Partition,None,TIntV) +TIntV.QSort = new_instancemethod(_snap.TIntV_QSort,None,TIntV) +TIntV.Sort = new_instancemethod(_snap.TIntV_Sort,None,TIntV) +TIntV.IsSorted = new_instancemethod(_snap.TIntV_IsSorted,None,TIntV) +TIntV.Shuffle = new_instancemethod(_snap.TIntV_Shuffle,None,TIntV) +TIntV.Reverse = new_instancemethod(_snap.TIntV_Reverse,None,TIntV) +TIntV.Merge = new_instancemethod(_snap.TIntV_Merge,None,TIntV) +TIntV.Intrs = new_instancemethod(_snap.TIntV_Intrs,None,TIntV) +TIntV.Union = new_instancemethod(_snap.TIntV_Union,None,TIntV) +TIntV.Diff = new_instancemethod(_snap.TIntV_Diff,None,TIntV) +TIntV.IntrsLen = new_instancemethod(_snap.TIntV_IntrsLen,None,TIntV) +TIntV.UnionLen = new_instancemethod(_snap.TIntV_UnionLen,None,TIntV) +TIntV.Count = new_instancemethod(_snap.TIntV_Count,None,TIntV) +TIntV.SearchBin = new_instancemethod(_snap.TIntV_SearchBin,None,TIntV) +TIntV.SearchForw = new_instancemethod(_snap.TIntV_SearchForw,None,TIntV) +TIntV.SearchBack = new_instancemethod(_snap.TIntV_SearchBack,None,TIntV) +TIntV.SearchVForw = new_instancemethod(_snap.TIntV_SearchVForw,None,TIntV) +TIntV.IsIn = new_instancemethod(_snap.TIntV_IsIn,None,TIntV) +TIntV.IsInBin = new_instancemethod(_snap.TIntV_IsInBin,None,TIntV) +TIntV.GetDat = new_instancemethod(_snap.TIntV_GetDat,None,TIntV) +TIntV.GetAddDat = new_instancemethod(_snap.TIntV_GetAddDat,None,TIntV) +TIntV.GetMxValN = new_instancemethod(_snap.TIntV_GetMxValN,None,TIntV) +TIntV.Add = new_instancemethod(_snap.TIntV_Add,None,TIntV) +TIntV.AddMerged = new_instancemethod(_snap.TIntV_AddMerged,None,TIntV) +TIntV_swigregister = _snap.TIntV_swigregister +TIntV_swigregister(TIntV) + +def TIntV_SwapI(*args): + """ + TIntV_SwapI(TInt LVal, TInt RVal) + + Parameters: + LVal: TVec< TInt,int >::TIter + RVal: TVec< TInt,int >::TIter + + """ + return _snap.TIntV_SwapI(*args) + +def TIntV_GetV(*args): + """ + GetV(TInt Val1) -> TIntV + + Parameters: + Val1: TInt const & + + GetV(TInt Val1, TInt Val2) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + Val7: TInt const & + + GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + Val7: TInt const & + Val8: TInt const & + + TIntV_GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8, + TInt Val9) -> TIntV + + Parameters: + Val1: TInt const & + Val2: TInt const & + Val3: TInt const & + Val4: TInt const & + Val5: TInt const & + Val6: TInt const & + Val7: TInt const & + Val8: TInt const & + Val9: TInt const & + + """ + return _snap.TIntV_GetV(*args) + +class TIntIntVV(object): + """Proxy of C++ TVec<(TVec<(TInt,int)>,int)> class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TIntIntVV + def __init__(self, *args): + """ + __init__(TVec<(TVec<(TInt,int)>,int)> self) -> TIntIntVV + __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntIntVV Vec) -> TIntIntVV + + Parameters: + Vec: TVec< TVec< TInt,int >,int > const & + + __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _Vals) -> TIntIntVV + + Parameters: + _Vals: int const & + + __init__(TVec<(TVec<(TInt,int)>,int)> self, int const & _MxVals, int const & _Vals) -> TIntIntVV + + Parameters: + _MxVals: int const & + _Vals: int const & + + __init__(TVec<(TVec<(TInt,int)>,int)> self, TIntV _ValT, int const & _Vals) -> TIntIntVV + + Parameters: + _ValT: TVec< TInt,int > * + _Vals: int const & + + __init__(TVec<(TVec<(TInt,int)>,int)> self, TSIn SIn) -> TIntIntVV + + Parameters: + SIn: TSIn & + + """ + _snap.TIntIntVV_swiginit(self,_snap.new_TIntIntVV(*args)) + def Load(self, *args): + """ + Load(TIntIntVV self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TIntIntVV_Load(self, *args) + + def Save(self, *args): + """ + Save(TIntIntVV self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TIntIntVV_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TIntIntVV self, PXmlTok const & XmlTok, TStr Nm="") + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + LoadXml(TIntIntVV self, PXmlTok const & XmlTok) + + Parameters: + XmlTok: PXmlTok const & + + """ + return _snap.TIntIntVV_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TIntIntVV self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TIntIntVV_SaveXml(self, *args) + + def __add__(self, *args): + """ + __add__(TIntIntVV self, TIntV Val) -> TIntIntVV + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV___add__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TIntIntVV self, TIntIntVV Vec) -> bool + + Parameters: + Vec: TVec< TVec< TInt,int >,int > const & + + """ + return _snap.TIntIntVV___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TIntIntVV self, TIntIntVV Vec) -> bool + + Parameters: + Vec: TVec< TVec< TInt,int >,int > const & + + """ + return _snap.TIntIntVV___lt__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_GetMemUsed(self) + + def GetMemSize(self): + """ + GetMemSize(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_GetMemSize(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_GetSecHashCd(self) + + def Gen(self, *args): + """ + Gen(TIntIntVV self, int const & _Vals) + + Parameters: + _Vals: int const & + + Gen(TIntIntVV self, int const & _MxVals, int const & _Vals) + + Parameters: + _MxVals: int const & + _Vals: int const & + + """ + return _snap.TIntIntVV_Gen(self, *args) + + def GenExt(self, *args): + """ + GenExt(TIntIntVV self, TIntV _ValT, int const & _Vals) + + Parameters: + _ValT: TVec< TInt,int > * + _Vals: int const & + + """ + return _snap.TIntIntVV_GenExt(self, *args) + + def IsExt(self): + """ + IsExt(TIntIntVV self) -> bool + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_IsExt(self) + + def Reserve(self, *args): + """ + Reserve(TIntIntVV self, int const & _MxVals) + + Parameters: + _MxVals: int const & + + Reserve(TIntIntVV self, int const & _MxVals, int const & _Vals) + + Parameters: + _MxVals: int const & + _Vals: int const & + + """ + return _snap.TIntIntVV_Reserve(self, *args) + + def Clr(self, *args): + """ + Clr(TIntIntVV self, bool const & DoDel=True, int const & NoDelLim=-1) + + Parameters: + DoDel: bool const & + NoDelLim: int const & + + Clr(TIntIntVV self, bool const & DoDel=True) + + Parameters: + DoDel: bool const & + + Clr(TIntIntVV self) + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_Clr(self, *args) + + def Trunc(self, *args): + """ + Trunc(TIntIntVV self, int const & _Vals=-1) + + Parameters: + _Vals: int const & + + Trunc(TIntIntVV self) + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_Trunc(self, *args) + + def Pack(self): + """ + Pack(TIntIntVV self) + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_Pack(self) + + def MoveFrom(self, *args): + """ + MoveFrom(TIntIntVV self, TIntIntVV Vec) + + Parameters: + Vec: TVec< TVec< TInt,int >,int > & + + """ + return _snap.TIntIntVV_MoveFrom(self, *args) + + def Empty(self): + """ + Empty(TIntIntVV self) -> bool + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_Empty(self) + + def Len(self): + """ + Len(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_Len(self) + + def Reserved(self): + """ + Reserved(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_Reserved(self) + + def Last(self, *args): + """ + Last(TIntIntVV self) -> TIntV + Last(TIntIntVV self) -> TIntV + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_Last(self, *args) + + def LastValN(self): + """ + LastValN(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_LastValN(self) + + def LastLast(self, *args): + """ + LastLast(TIntIntVV self) -> TIntV + LastLast(TIntIntVV self) -> TIntV + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_LastLast(self, *args) + + def BegI(self): + """ + BegI(TIntIntVV self) -> TIntV + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_BegI(self) + + def EndI(self): + """ + EndI(TIntIntVV self) -> TIntV + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_EndI(self) + + def GetI(self, *args): + """ + GetI(TIntIntVV self, int const & ValN) -> TIntV + + Parameters: + ValN: int const & + + """ + return _snap.TIntIntVV_GetI(self, *args) + + def AddV(self, *args): + """ + AddV(TIntIntVV self, TIntIntVV ValV) -> int + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + """ + return _snap.TIntIntVV_AddV(self, *args) + + def AddSorted(self, *args): + """ + AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True, int const & _MxVals=-1) -> int + + Parameters: + Val: TVec< TInt,int > const & + Asc: bool const & + _MxVals: int const & + + AddSorted(TIntIntVV self, TIntV Val, bool const & Asc=True) -> int + + Parameters: + Val: TVec< TInt,int > const & + Asc: bool const & + + AddSorted(TIntIntVV self, TIntV Val) -> int + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_AddSorted(self, *args) + + def AddBackSorted(self, *args): + """ + AddBackSorted(TIntIntVV self, TIntV Val, bool const & Asc) -> int + + Parameters: + Val: TVec< TInt,int > const & + Asc: bool const & + + """ + return _snap.TIntIntVV_AddBackSorted(self, *args) + + def AddVMerged(self, *args): + """ + AddVMerged(TIntIntVV self, TIntIntVV ValV) -> int + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + """ + return _snap.TIntIntVV_AddVMerged(self, *args) + + def AddUnique(self, *args): + """ + AddUnique(TIntIntVV self, TIntV Val) -> int + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_AddUnique(self, *args) + + def GetVal(self, *args): + """ + GetVal(TIntIntVV self, int const & ValN) -> TIntV + + Parameters: + ValN: int const & + + GetVal(TIntIntVV self, int const & ValN) -> TIntV + + Parameters: + ValN: int const & + + """ + return _snap.TIntIntVV_GetVal(self, *args) + + def GetSubValV(self, *args): + """ + GetSubValV(TIntIntVV self, int const & BValN, int const & EValN, TIntIntVV ValV) + + Parameters: + BValN: int const & + EValN: int const & + ValV: TVec< TVec< TInt,int >,int > & + + """ + return _snap.TIntIntVV_GetSubValV(self, *args) + + def Ins(self, *args): + """ + Ins(TIntIntVV self, int const & ValN, TIntV Val) + + Parameters: + ValN: int const & + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_Ins(self, *args) + + def Del(self, *args): + """ + Del(TIntIntVV self, int const & ValN) + + Parameters: + ValN: int const & + + Del(TIntIntVV self, int const & MnValN, int const & MxValN) + + Parameters: + MnValN: int const & + MxValN: int const & + + """ + return _snap.TIntIntVV_Del(self, *args) + + def DelLast(self): + """ + DelLast(TIntIntVV self) + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_DelLast(self) + + def DelIfIn(self, *args): + """ + DelIfIn(TIntIntVV self, TIntV Val) -> bool + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_DelIfIn(self, *args) + + def DelAll(self, *args): + """ + DelAll(TIntIntVV self, TIntV Val) + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_DelAll(self, *args) + + def PutAll(self, *args): + """ + PutAll(TIntIntVV self, TIntV Val) + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_PutAll(self, *args) + + def Swap(self, *args): + """ + Swap(TIntIntVV self, TIntIntVV Vec) + + Parameters: + Vec: TVec< TVec< TInt,int >,int > & + + Swap(TIntIntVV self, int const & ValN1, int const & ValN2) + + Parameters: + ValN1: int const & + ValN2: int const & + + """ + return _snap.TIntIntVV_Swap(self, *args) + + def SwapI(*args): + """ + SwapI(TIntV LVal, TIntV RVal) + + Parameters: + LVal: TVec< TVec< TInt,int >,int >::TIter + RVal: TVec< TVec< TInt,int >,int >::TIter + + """ + return _snap.TIntIntVV_SwapI(*args) + + SwapI = staticmethod(SwapI) + def NextPerm(self): + """ + NextPerm(TIntIntVV self) -> bool + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_NextPerm(self) + + def PrevPerm(self): + """ + PrevPerm(TIntIntVV self) -> bool + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_PrevPerm(self) + + def GetPivotValN(self, *args): + """ + GetPivotValN(TIntIntVV self, int const & LValN, int const & RValN) -> int + + Parameters: + LValN: int const & + RValN: int const & + + """ + return _snap.TIntIntVV_GetPivotValN(self, *args) + + def BSort(self, *args): + """ + BSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntIntVV_BSort(self, *args) + + def ISort(self, *args): + """ + ISort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntIntVV_ISort(self, *args) + + def Partition(self, *args): + """ + Partition(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntIntVV_Partition(self, *args) + + def QSort(self, *args): + """ + QSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TIntIntVV_QSort(self, *args) + + def Sort(self, Asc=True): + """ + Sort(TIntIntVV self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + Sort(TIntIntVV self) + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_Sort(self, Asc) + + def IsSorted(self, Asc=True): + """ + IsSorted(TIntIntVV self, bool const & Asc=True) -> bool + + Parameters: + Asc: bool const & + + IsSorted(TIntIntVV self) -> bool + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_IsSorted(self, Asc) + + def Shuffle(self, *args): + """ + Shuffle(TIntIntVV self, TRnd Rnd) + + Parameters: + Rnd: TRnd & + + """ + return _snap.TIntIntVV_Shuffle(self, *args) + + def Reverse(self, *args): + """ + Reverse(TIntIntVV self) + Reverse(TIntIntVV self, int LValN, int RValN) + + Parameters: + LValN: int + RValN: int + + """ + return _snap.TIntIntVV_Reverse(self, *args) + + def Merge(self): + """ + Merge(TIntIntVV self) + + Parameters: + self: TVec< TVec< TInt,int >,int > * + + """ + return _snap.TIntIntVV_Merge(self) + + def Intrs(self, *args): + """ + Intrs(TIntIntVV self, TIntIntVV ValV) + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + Intrs(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV) + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + DstValV: TVec< TVec< TInt,int >,int > & + + """ + return _snap.TIntIntVV_Intrs(self, *args) + + def Union(self, *args): + """ + Union(TIntIntVV self, TIntIntVV ValV) + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + Union(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV) + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + DstValV: TVec< TVec< TInt,int >,int > & + + """ + return _snap.TIntIntVV_Union(self, *args) + + def Diff(self, *args): + """ + Diff(TIntIntVV self, TIntIntVV ValV) + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + Diff(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV) + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + DstValV: TVec< TVec< TInt,int >,int > & + + """ + return _snap.TIntIntVV_Diff(self, *args) + + def IntrsLen(self, *args): + """ + IntrsLen(TIntIntVV self, TIntIntVV ValV) -> int + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + """ + return _snap.TIntIntVV_IntrsLen(self, *args) + + def UnionLen(self, *args): + """ + UnionLen(TIntIntVV self, TIntIntVV ValV) -> int + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + """ + return _snap.TIntIntVV_UnionLen(self, *args) + + def Count(self, *args): + """ + Count(TIntIntVV self, TIntV Val) -> int + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_Count(self, *args) + + def SearchBin(self, *args): + """ + SearchBin(TIntIntVV self, TIntV Val) -> int + + Parameters: + Val: TVec< TInt,int > const & + + SearchBin(TIntIntVV self, TIntV Val, int & InsValN) -> int + + Parameters: + Val: TVec< TInt,int > const & + InsValN: int & + + """ + return _snap.TIntIntVV_SearchBin(self, *args) + + def SearchForw(self, *args): + """ + SearchForw(TIntIntVV self, TIntV Val, int const & BValN=0) -> int + + Parameters: + Val: TVec< TInt,int > const & + BValN: int const & + + SearchForw(TIntIntVV self, TIntV Val) -> int + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_SearchForw(self, *args) + + def SearchBack(self, *args): + """ + SearchBack(TIntIntVV self, TIntV Val) -> int + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_SearchBack(self, *args) + + def SearchVForw(self, *args): + """ + SearchVForw(TIntIntVV self, TIntIntVV ValV, int const & BValN=0) -> int + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + BValN: int const & + + SearchVForw(TIntIntVV self, TIntIntVV ValV) -> int + + Parameters: + ValV: TVec< TVec< TInt,int >,int > const & + + """ + return _snap.TIntIntVV_SearchVForw(self, *args) + + def IsIn(self, *args): + """ + IsIn(TIntIntVV self, TIntV Val) -> bool + + Parameters: + Val: TVec< TInt,int > const & + + IsIn(TIntIntVV self, TIntV Val, int & ValN) -> bool + + Parameters: + Val: TVec< TInt,int > const & + ValN: int & + + """ + return _snap.TIntIntVV_IsIn(self, *args) + + def IsInBin(self, *args): + """ + IsInBin(TIntIntVV self, TIntV Val) -> bool + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_IsInBin(self, *args) + + def GetDat(self, *args): + """ + GetDat(TIntIntVV self, TIntV Val) -> TIntV + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_GetDat(self, *args) + + def GetAddDat(self, *args): + """ + GetAddDat(TIntIntVV self, TIntV Val) -> TIntV + + Parameters: + Val: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_GetAddDat(self, *args) + + def GetMxValN(self): + """ + GetMxValN(TIntIntVV self) -> int + + Parameters: + self: TVec< TVec< TInt,int >,int > const * + + """ + return _snap.TIntIntVV_GetMxValN(self) + + def GetV(*args): + """ + GetV(TIntV Val1) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + Val7: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, + TIntV Val8) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + Val7: TVec< TInt,int > const & + Val8: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, + TIntV Val8, TIntV Val9) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + Val7: TVec< TInt,int > const & + Val8: TVec< TInt,int > const & + Val9: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_GetV(*args) + + GetV = staticmethod(GetV) +TIntIntVV.Load = new_instancemethod(_snap.TIntIntVV_Load,None,TIntIntVV) +TIntIntVV.Save = new_instancemethod(_snap.TIntIntVV_Save,None,TIntIntVV) +TIntIntVV.LoadXml = new_instancemethod(_snap.TIntIntVV_LoadXml,None,TIntIntVV) +TIntIntVV.SaveXml = new_instancemethod(_snap.TIntIntVV_SaveXml,None,TIntIntVV) +TIntIntVV.__add__ = new_instancemethod(_snap.TIntIntVV___add__,None,TIntIntVV) +TIntIntVV.__eq__ = new_instancemethod(_snap.TIntIntVV___eq__,None,TIntIntVV) +TIntIntVV.__lt__ = new_instancemethod(_snap.TIntIntVV___lt__,None,TIntIntVV) +TIntIntVV.GetMemUsed = new_instancemethod(_snap.TIntIntVV_GetMemUsed,None,TIntIntVV) +TIntIntVV.GetMemSize = new_instancemethod(_snap.TIntIntVV_GetMemSize,None,TIntIntVV) +TIntIntVV.GetPrimHashCd = new_instancemethod(_snap.TIntIntVV_GetPrimHashCd,None,TIntIntVV) +TIntIntVV.GetSecHashCd = new_instancemethod(_snap.TIntIntVV_GetSecHashCd,None,TIntIntVV) +TIntIntVV.Gen = new_instancemethod(_snap.TIntIntVV_Gen,None,TIntIntVV) +TIntIntVV.GenExt = new_instancemethod(_snap.TIntIntVV_GenExt,None,TIntIntVV) +TIntIntVV.IsExt = new_instancemethod(_snap.TIntIntVV_IsExt,None,TIntIntVV) +TIntIntVV.Reserve = new_instancemethod(_snap.TIntIntVV_Reserve,None,TIntIntVV) +TIntIntVV.Clr = new_instancemethod(_snap.TIntIntVV_Clr,None,TIntIntVV) +TIntIntVV.Trunc = new_instancemethod(_snap.TIntIntVV_Trunc,None,TIntIntVV) +TIntIntVV.Pack = new_instancemethod(_snap.TIntIntVV_Pack,None,TIntIntVV) +TIntIntVV.MoveFrom = new_instancemethod(_snap.TIntIntVV_MoveFrom,None,TIntIntVV) +TIntIntVV.Empty = new_instancemethod(_snap.TIntIntVV_Empty,None,TIntIntVV) +TIntIntVV.Len = new_instancemethod(_snap.TIntIntVV_Len,None,TIntIntVV) +TIntIntVV.Reserved = new_instancemethod(_snap.TIntIntVV_Reserved,None,TIntIntVV) +TIntIntVV.Last = new_instancemethod(_snap.TIntIntVV_Last,None,TIntIntVV) +TIntIntVV.LastValN = new_instancemethod(_snap.TIntIntVV_LastValN,None,TIntIntVV) +TIntIntVV.LastLast = new_instancemethod(_snap.TIntIntVV_LastLast,None,TIntIntVV) +TIntIntVV.BegI = new_instancemethod(_snap.TIntIntVV_BegI,None,TIntIntVV) +TIntIntVV.EndI = new_instancemethod(_snap.TIntIntVV_EndI,None,TIntIntVV) +TIntIntVV.GetI = new_instancemethod(_snap.TIntIntVV_GetI,None,TIntIntVV) +TIntIntVV.AddV = new_instancemethod(_snap.TIntIntVV_AddV,None,TIntIntVV) +TIntIntVV.AddSorted = new_instancemethod(_snap.TIntIntVV_AddSorted,None,TIntIntVV) +TIntIntVV.AddBackSorted = new_instancemethod(_snap.TIntIntVV_AddBackSorted,None,TIntIntVV) +TIntIntVV.AddVMerged = new_instancemethod(_snap.TIntIntVV_AddVMerged,None,TIntIntVV) +TIntIntVV.AddUnique = new_instancemethod(_snap.TIntIntVV_AddUnique,None,TIntIntVV) +TIntIntVV.GetVal = new_instancemethod(_snap.TIntIntVV_GetVal,None,TIntIntVV) +TIntIntVV.GetSubValV = new_instancemethod(_snap.TIntIntVV_GetSubValV,None,TIntIntVV) +TIntIntVV.Ins = new_instancemethod(_snap.TIntIntVV_Ins,None,TIntIntVV) +TIntIntVV.Del = new_instancemethod(_snap.TIntIntVV_Del,None,TIntIntVV) +TIntIntVV.DelLast = new_instancemethod(_snap.TIntIntVV_DelLast,None,TIntIntVV) +TIntIntVV.DelIfIn = new_instancemethod(_snap.TIntIntVV_DelIfIn,None,TIntIntVV) +TIntIntVV.DelAll = new_instancemethod(_snap.TIntIntVV_DelAll,None,TIntIntVV) +TIntIntVV.PutAll = new_instancemethod(_snap.TIntIntVV_PutAll,None,TIntIntVV) +TIntIntVV.Swap = new_instancemethod(_snap.TIntIntVV_Swap,None,TIntIntVV) +TIntIntVV.NextPerm = new_instancemethod(_snap.TIntIntVV_NextPerm,None,TIntIntVV) +TIntIntVV.PrevPerm = new_instancemethod(_snap.TIntIntVV_PrevPerm,None,TIntIntVV) +TIntIntVV.GetPivotValN = new_instancemethod(_snap.TIntIntVV_GetPivotValN,None,TIntIntVV) +TIntIntVV.BSort = new_instancemethod(_snap.TIntIntVV_BSort,None,TIntIntVV) +TIntIntVV.ISort = new_instancemethod(_snap.TIntIntVV_ISort,None,TIntIntVV) +TIntIntVV.Partition = new_instancemethod(_snap.TIntIntVV_Partition,None,TIntIntVV) +TIntIntVV.QSort = new_instancemethod(_snap.TIntIntVV_QSort,None,TIntIntVV) +TIntIntVV.Sort = new_instancemethod(_snap.TIntIntVV_Sort,None,TIntIntVV) +TIntIntVV.IsSorted = new_instancemethod(_snap.TIntIntVV_IsSorted,None,TIntIntVV) +TIntIntVV.Shuffle = new_instancemethod(_snap.TIntIntVV_Shuffle,None,TIntIntVV) +TIntIntVV.Reverse = new_instancemethod(_snap.TIntIntVV_Reverse,None,TIntIntVV) +TIntIntVV.Merge = new_instancemethod(_snap.TIntIntVV_Merge,None,TIntIntVV) +TIntIntVV.Intrs = new_instancemethod(_snap.TIntIntVV_Intrs,None,TIntIntVV) +TIntIntVV.Union = new_instancemethod(_snap.TIntIntVV_Union,None,TIntIntVV) +TIntIntVV.Diff = new_instancemethod(_snap.TIntIntVV_Diff,None,TIntIntVV) +TIntIntVV.IntrsLen = new_instancemethod(_snap.TIntIntVV_IntrsLen,None,TIntIntVV) +TIntIntVV.UnionLen = new_instancemethod(_snap.TIntIntVV_UnionLen,None,TIntIntVV) +TIntIntVV.Count = new_instancemethod(_snap.TIntIntVV_Count,None,TIntIntVV) +TIntIntVV.SearchBin = new_instancemethod(_snap.TIntIntVV_SearchBin,None,TIntIntVV) +TIntIntVV.SearchForw = new_instancemethod(_snap.TIntIntVV_SearchForw,None,TIntIntVV) +TIntIntVV.SearchBack = new_instancemethod(_snap.TIntIntVV_SearchBack,None,TIntIntVV) +TIntIntVV.SearchVForw = new_instancemethod(_snap.TIntIntVV_SearchVForw,None,TIntIntVV) +TIntIntVV.IsIn = new_instancemethod(_snap.TIntIntVV_IsIn,None,TIntIntVV) +TIntIntVV.IsInBin = new_instancemethod(_snap.TIntIntVV_IsInBin,None,TIntIntVV) +TIntIntVV.GetDat = new_instancemethod(_snap.TIntIntVV_GetDat,None,TIntIntVV) +TIntIntVV.GetAddDat = new_instancemethod(_snap.TIntIntVV_GetAddDat,None,TIntIntVV) +TIntIntVV.GetMxValN = new_instancemethod(_snap.TIntIntVV_GetMxValN,None,TIntIntVV) +TIntIntVV_swigregister = _snap.TIntIntVV_swigregister +TIntIntVV_swigregister(TIntIntVV) + +def TIntIntVV_SwapI(*args): + """ + TIntIntVV_SwapI(TIntV LVal, TIntV RVal) + + Parameters: + LVal: TVec< TVec< TInt,int >,int >::TIter + RVal: TVec< TVec< TInt,int >,int >::TIter + + """ + return _snap.TIntIntVV_SwapI(*args) + +def TIntIntVV_GetV(*args): + """ + GetV(TIntV Val1) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + Val7: TVec< TInt,int > const & + + GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, + TIntV Val8) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + Val7: TVec< TInt,int > const & + Val8: TVec< TInt,int > const & + + TIntIntVV_GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, + TIntV Val8, TIntV Val9) -> TIntIntVV + + Parameters: + Val1: TVec< TInt,int > const & + Val2: TVec< TInt,int > const & + Val3: TVec< TInt,int > const & + Val4: TVec< TInt,int > const & + Val5: TVec< TInt,int > const & + Val6: TVec< TInt,int > const & + Val7: TVec< TInt,int > const & + Val8: TVec< TInt,int > const & + Val9: TVec< TInt,int > const & + + """ + return _snap.TIntIntVV_GetV(*args) + +class TIntIntVH(object): + """Proxy of C++ THash<(TInt,TVec<(TInt,int)>)> class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + HashPrimes = _snap.TIntIntVH_HashPrimes + def __init__(self, *args): + """ + __init__(THash<(TInt,TVec<(TInt,int)>)> self) -> TIntIntVH + __init__(THash<(TInt,TVec<(TInt,int)>)> self, TIntIntVH Hash) -> TIntIntVH + + Parameters: + Hash: THash< TInt,TVec< TInt,int > > const & + + __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntIntVH + + Parameters: + ExpectVals: int const & + _AutoSizeP: bool const & + + __init__(THash<(TInt,TVec<(TInt,int)>)> self, int const & ExpectVals) -> TIntIntVH + + Parameters: + ExpectVals: int const & + + __init__(THash<(TInt,TVec<(TInt,int)>)> self, TSIn SIn) -> TIntIntVH + + Parameters: + SIn: TSIn & + + """ + _snap.TIntIntVH_swiginit(self,_snap.new_TIntIntVH(*args)) + def Load(self, *args): + """ + Load(TIntIntVH self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TIntIntVH_Load(self, *args) + + def Save(self, *args): + """ + Save(TIntIntVH self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TIntIntVH_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TIntIntVH self, PXmlTok const & XmlTok, TStr Nm="") + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + LoadXml(TIntIntVH self, PXmlTok const & XmlTok) + + Parameters: + XmlTok: PXmlTok const & + + """ + return _snap.TIntIntVH_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TIntIntVH self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TIntIntVH_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TIntIntVH self, TIntIntVH Hash) -> bool + + Parameters: + Hash: THash< TInt,TVec< TInt,int > > const & + + """ + return _snap.TIntIntVH___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TIntIntVH self, TIntIntVH Hash) -> bool + + Parameters: + Hash: THash< TInt,TVec< TInt,int > > const & + + """ + return _snap.TIntIntVH___lt__(self, *args) + + def __call__(self, *args): + """ + __call__(TIntIntVH self, TInt Key) -> TIntV + + Parameters: + Key: TInt const & + + """ + return _snap.TIntIntVH___call__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TIntIntVH self) -> ::TSize + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_GetMemUsed(self) + + def BegI(self): + """ + BegI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_BegI(self) + + def EndI(self): + """ + EndI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_EndI(self) + + def GetI(self, *args): + """ + GetI(TIntIntVH self, TInt Key) -> THash< TInt,TVec< TInt,int > >::TIter + + Parameters: + Key: TInt const & + + """ + return _snap.TIntIntVH_GetI(self, *args) + + def Gen(self, *args): + """ + Gen(TIntIntVH self, int const & ExpectVals) + + Parameters: + ExpectVals: int const & + + """ + return _snap.TIntIntVH_Gen(self, *args) + + def Clr(self, *args): + """ + Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True) + + Parameters: + DoDel: bool const & + NoDelLim: int const & + ResetDat: bool const & + + Clr(TIntIntVH self, bool const & DoDel=True, int const & NoDelLim=-1) + + Parameters: + DoDel: bool const & + NoDelLim: int const & + + Clr(TIntIntVH self, bool const & DoDel=True) + + Parameters: + DoDel: bool const & + + Clr(TIntIntVH self) + + Parameters: + self: THash< TInt,TVec< TInt,int > > * + + """ + return _snap.TIntIntVH_Clr(self, *args) + + def Empty(self): + """ + Empty(TIntIntVH self) -> bool + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_Empty(self) + + def Len(self): + """ + Len(TIntIntVH self) -> int + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_Len(self) + + def GetPorts(self): + """ + GetPorts(TIntIntVH self) -> int + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_GetPorts(self) + + def IsAutoSize(self): + """ + IsAutoSize(TIntIntVH self) -> bool + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_IsAutoSize(self) + + def GetMxKeyIds(self): + """ + GetMxKeyIds(TIntIntVH self) -> int + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_GetMxKeyIds(self) + + def GetReservedKeyIds(self): + """ + GetReservedKeyIds(TIntIntVH self) -> int + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_GetReservedKeyIds(self) + + def IsKeyIdEqKeyN(self): + """ + IsKeyIdEqKeyN(TIntIntVH self) -> bool + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_IsKeyIdEqKeyN(self) + + def DelKey(self, *args): + """ + DelKey(TIntIntVH self, TInt Key) + + Parameters: + Key: TInt const & + + """ + return _snap.TIntIntVH_DelKey(self, *args) + + def DelIfKey(self, *args): + """ + DelIfKey(TIntIntVH self, TInt Key) -> bool + + Parameters: + Key: TInt const & + + """ + return _snap.TIntIntVH_DelIfKey(self, *args) + + def DelKeyId(self, *args): + """ + DelKeyId(TIntIntVH self, int const & KeyId) + + Parameters: + KeyId: int const & + + """ + return _snap.TIntIntVH_DelKeyId(self, *args) + + def DelKeyIdV(self, *args): + """ + DelKeyIdV(TIntIntVH self, TIntV KeyIdV) + + Parameters: + KeyIdV: TIntV const & + + """ + return _snap.TIntIntVH_DelKeyIdV(self, *args) + + def MarkDelKey(self, *args): + """ + MarkDelKey(TIntIntVH self, TInt Key) + + Parameters: + Key: TInt const & + + """ + return _snap.TIntIntVH_MarkDelKey(self, *args) + + def MarkDelKeyId(self, *args): + """ + MarkDelKeyId(TIntIntVH self, int const & KeyId) + + Parameters: + KeyId: int const & + + """ + return _snap.TIntIntVH_MarkDelKeyId(self, *args) + + def GetKey(self, *args): + """ + GetKey(TIntIntVH self, int const & KeyId) -> TInt + + Parameters: + KeyId: int const & + + """ + return _snap.TIntIntVH_GetKey(self, *args) + + def GetKeyId(self, *args): + """ + GetKeyId(TIntIntVH self, TInt Key) -> int + + Parameters: + Key: TInt const & + + """ + return _snap.TIntIntVH_GetKeyId(self, *args) + + def GetRndKeyId(self, *args): + """ + GetRndKeyId(TIntIntVH self, TRnd Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndKeyId(TIntIntVH self, TRnd Rnd, double const & EmptyFrac) -> int + + Parameters: + Rnd: TRnd & + EmptyFrac: double const & + + """ + return _snap.TIntIntVH_GetRndKeyId(self, *args) + + def IsKeyId(self, *args): + """ + IsKeyId(TIntIntVH self, int const & KeyId) -> bool + + Parameters: + KeyId: int const & + + """ + return _snap.TIntIntVH_IsKeyId(self, *args) + + def GetKeyDat(self, *args): + """ + GetKeyDat(TIntIntVH self, int const & KeyId, TInt Key, TIntV Dat) + + Parameters: + KeyId: int const & + Key: TInt & + Dat: TVec< TInt,int > & + + """ + return _snap.TIntIntVH_GetKeyDat(self, *args) + + def IsKeyGetDat(self, *args): + """ + IsKeyGetDat(TIntIntVH self, TInt Key, TIntV Dat) -> bool + + Parameters: + Key: TInt const & + Dat: TVec< TInt,int > & + + """ + return _snap.TIntIntVH_IsKeyGetDat(self, *args) + + def FFirstKeyId(self): + """ + FFirstKeyId(TIntIntVH self) -> int + + Parameters: + self: THash< TInt,TVec< TInt,int > > const * + + """ + return _snap.TIntIntVH_FFirstKeyId(self) + + def FNextKeyId(self, *args): + """ + FNextKeyId(TIntIntVH self, int & KeyId) -> bool + + Parameters: + KeyId: int & + + """ + return _snap.TIntIntVH_FNextKeyId(self, *args) + + def GetKeyV(self, *args): + """ + GetKeyV(TIntIntVH self, TIntV KeyV) + + Parameters: + KeyV: TVec< TInt > & + + """ + return _snap.TIntIntVH_GetKeyV(self, *args) + + def GetDatV(self, *args): + """ + GetDatV(TIntIntVH self, TIntIntVV DatV) + + Parameters: + DatV: TVec< TVec< TInt,int > > & + + """ + return _snap.TIntIntVH_GetDatV(self, *args) + + def GetKeyDatPrV(self, *args): + """ + GetKeyDatPrV(TIntIntVH self, TVec< TPair< TInt,TVec< TInt,int > > > & KeyDatPrV) + + Parameters: + KeyDatPrV: TVec< TPair< TInt,TVec< TInt,int > > > & + + """ + return _snap.TIntIntVH_GetKeyDatPrV(self, *args) + + def GetDatKeyPrV(self, *args): + """ + GetDatKeyPrV(TIntIntVH self, TVec< TPair< TVec< TInt,int >,TInt > > & DatKeyPrV) + + Parameters: + DatKeyPrV: TVec< TPair< TVec< TInt,int >,TInt > > & + + """ + return _snap.TIntIntVH_GetDatKeyPrV(self, *args) + + def GetKeyDatKdV(self, *args): + """ + GetKeyDatKdV(TIntIntVH self, TVec< TKeyDat< TInt,TVec< TInt,int > > > & KeyDatKdV) + + Parameters: + KeyDatKdV: TVec< TKeyDat< TInt,TVec< TInt,int > > > & + + """ + return _snap.TIntIntVH_GetKeyDatKdV(self, *args) + + def GetDatKeyKdV(self, *args): + """ + GetDatKeyKdV(TIntIntVH self, TVec< TKeyDat< TVec< TInt,int >,TInt > > & DatKeyKdV) + + Parameters: + DatKeyKdV: TVec< TKeyDat< TVec< TInt,int >,TInt > > & + + """ + return _snap.TIntIntVH_GetDatKeyKdV(self, *args) + + def Swap(self, *args): + """ + Swap(TIntIntVH self, TIntIntVH Hash) + + Parameters: + Hash: THash< TInt,TVec< TInt,int > > & + + """ + return _snap.TIntIntVH_Swap(self, *args) + + def Defrag(self): + """ + Defrag(TIntIntVH self) + + Parameters: + self: THash< TInt,TVec< TInt,int > > * + + """ + return _snap.TIntIntVH_Defrag(self) + + def Pack(self): + """ + Pack(TIntIntVH self) + + Parameters: + self: THash< TInt,TVec< TInt,int > > * + + """ + return _snap.TIntIntVH_Pack(self) + + def Sort(self, *args): + """ + Sort(TIntIntVH self, bool const & CmpKey, bool const & Asc) + + Parameters: + CmpKey: bool const & + Asc: bool const & + + """ + return _snap.TIntIntVH_Sort(self, *args) + + def SortByKey(self, Asc=True): + """ + SortByKey(TIntIntVH self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + SortByKey(TIntIntVH self) + + Parameters: + self: THash< TInt,TVec< TInt,int > > * + + """ + return _snap.TIntIntVH_SortByKey(self, Asc) + + def SortByDat(self, Asc=True): + """ + SortByDat(TIntIntVH self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + SortByDat(TIntIntVH self) + + Parameters: + self: THash< TInt,TVec< TInt,int > > * + + """ + return _snap.TIntIntVH_SortByDat(self, Asc) + + def AddKey(self, *args): + """ + AddKey(TIntIntVH self, TInt Key) -> int + + Parameters: + Key: TInt const & + + AddKey(TIntIntVH self, int Val) -> int + + Parameters: + Val: int + + """ + return _snap.TIntIntVH_AddKey(self, *args) + + def IsKey(self, *args): + """ + IsKey(TIntIntVH self, TInt Key) -> bool + + Parameters: + Key: TInt const & + + IsKey(TIntIntVH self, TInt Key, int & KeyId) -> bool + + Parameters: + Key: TInt const & + KeyId: int & + + IsKey(TIntIntVH self, int Val) -> int + + Parameters: + Val: int + + """ + return _snap.TIntIntVH_IsKey(self, *args) + + def GetDat(self, *args): + """ + GetDat(TIntIntVH self, TInt Key) -> TIntV + + Parameters: + Key: TInt const & + + GetDat(TIntIntVH self, TInt Key) -> TIntV + + Parameters: + Key: TInt const & + + GetDat(TIntIntVH self, int Val) -> TIntV + + Parameters: + Val: int + + """ + return _snap.TIntIntVH_GetDat(self, *args) + + __swig_destroy__ = _snap.delete_TIntIntVH +TIntIntVH.Load = new_instancemethod(_snap.TIntIntVH_Load,None,TIntIntVH) +TIntIntVH.Save = new_instancemethod(_snap.TIntIntVH_Save,None,TIntIntVH) +TIntIntVH.LoadXml = new_instancemethod(_snap.TIntIntVH_LoadXml,None,TIntIntVH) +TIntIntVH.SaveXml = new_instancemethod(_snap.TIntIntVH_SaveXml,None,TIntIntVH) +TIntIntVH.__eq__ = new_instancemethod(_snap.TIntIntVH___eq__,None,TIntIntVH) +TIntIntVH.__lt__ = new_instancemethod(_snap.TIntIntVH___lt__,None,TIntIntVH) +TIntIntVH.__call__ = new_instancemethod(_snap.TIntIntVH___call__,None,TIntIntVH) +TIntIntVH.GetMemUsed = new_instancemethod(_snap.TIntIntVH_GetMemUsed,None,TIntIntVH) +TIntIntVH.BegI = new_instancemethod(_snap.TIntIntVH_BegI,None,TIntIntVH) +TIntIntVH.EndI = new_instancemethod(_snap.TIntIntVH_EndI,None,TIntIntVH) +TIntIntVH.GetI = new_instancemethod(_snap.TIntIntVH_GetI,None,TIntIntVH) +TIntIntVH.Gen = new_instancemethod(_snap.TIntIntVH_Gen,None,TIntIntVH) +TIntIntVH.Clr = new_instancemethod(_snap.TIntIntVH_Clr,None,TIntIntVH) +TIntIntVH.Empty = new_instancemethod(_snap.TIntIntVH_Empty,None,TIntIntVH) +TIntIntVH.Len = new_instancemethod(_snap.TIntIntVH_Len,None,TIntIntVH) +TIntIntVH.GetPorts = new_instancemethod(_snap.TIntIntVH_GetPorts,None,TIntIntVH) +TIntIntVH.IsAutoSize = new_instancemethod(_snap.TIntIntVH_IsAutoSize,None,TIntIntVH) +TIntIntVH.GetMxKeyIds = new_instancemethod(_snap.TIntIntVH_GetMxKeyIds,None,TIntIntVH) +TIntIntVH.GetReservedKeyIds = new_instancemethod(_snap.TIntIntVH_GetReservedKeyIds,None,TIntIntVH) +TIntIntVH.IsKeyIdEqKeyN = new_instancemethod(_snap.TIntIntVH_IsKeyIdEqKeyN,None,TIntIntVH) +TIntIntVH.DelKey = new_instancemethod(_snap.TIntIntVH_DelKey,None,TIntIntVH) +TIntIntVH.DelIfKey = new_instancemethod(_snap.TIntIntVH_DelIfKey,None,TIntIntVH) +TIntIntVH.DelKeyId = new_instancemethod(_snap.TIntIntVH_DelKeyId,None,TIntIntVH) +TIntIntVH.DelKeyIdV = new_instancemethod(_snap.TIntIntVH_DelKeyIdV,None,TIntIntVH) +TIntIntVH.MarkDelKey = new_instancemethod(_snap.TIntIntVH_MarkDelKey,None,TIntIntVH) +TIntIntVH.MarkDelKeyId = new_instancemethod(_snap.TIntIntVH_MarkDelKeyId,None,TIntIntVH) +TIntIntVH.GetKey = new_instancemethod(_snap.TIntIntVH_GetKey,None,TIntIntVH) +TIntIntVH.GetKeyId = new_instancemethod(_snap.TIntIntVH_GetKeyId,None,TIntIntVH) +TIntIntVH.GetRndKeyId = new_instancemethod(_snap.TIntIntVH_GetRndKeyId,None,TIntIntVH) +TIntIntVH.IsKeyId = new_instancemethod(_snap.TIntIntVH_IsKeyId,None,TIntIntVH) +TIntIntVH.GetKeyDat = new_instancemethod(_snap.TIntIntVH_GetKeyDat,None,TIntIntVH) +TIntIntVH.IsKeyGetDat = new_instancemethod(_snap.TIntIntVH_IsKeyGetDat,None,TIntIntVH) +TIntIntVH.FFirstKeyId = new_instancemethod(_snap.TIntIntVH_FFirstKeyId,None,TIntIntVH) +TIntIntVH.FNextKeyId = new_instancemethod(_snap.TIntIntVH_FNextKeyId,None,TIntIntVH) +TIntIntVH.GetKeyV = new_instancemethod(_snap.TIntIntVH_GetKeyV,None,TIntIntVH) +TIntIntVH.GetDatV = new_instancemethod(_snap.TIntIntVH_GetDatV,None,TIntIntVH) +TIntIntVH.GetKeyDatPrV = new_instancemethod(_snap.TIntIntVH_GetKeyDatPrV,None,TIntIntVH) +TIntIntVH.GetDatKeyPrV = new_instancemethod(_snap.TIntIntVH_GetDatKeyPrV,None,TIntIntVH) +TIntIntVH.GetKeyDatKdV = new_instancemethod(_snap.TIntIntVH_GetKeyDatKdV,None,TIntIntVH) +TIntIntVH.GetDatKeyKdV = new_instancemethod(_snap.TIntIntVH_GetDatKeyKdV,None,TIntIntVH) +TIntIntVH.Swap = new_instancemethod(_snap.TIntIntVH_Swap,None,TIntIntVH) +TIntIntVH.Defrag = new_instancemethod(_snap.TIntIntVH_Defrag,None,TIntIntVH) +TIntIntVH.Pack = new_instancemethod(_snap.TIntIntVH_Pack,None,TIntIntVH) +TIntIntVH.Sort = new_instancemethod(_snap.TIntIntVH_Sort,None,TIntIntVH) +TIntIntVH.SortByKey = new_instancemethod(_snap.TIntIntVH_SortByKey,None,TIntIntVH) +TIntIntVH.SortByDat = new_instancemethod(_snap.TIntIntVH_SortByDat,None,TIntIntVH) +TIntIntVH.AddKey = new_instancemethod(_snap.TIntIntVH_AddKey,None,TIntIntVH) +TIntIntVH.IsKey = new_instancemethod(_snap.TIntIntVH_IsKey,None,TIntIntVH) +TIntIntVH.GetDat = new_instancemethod(_snap.TIntIntVH_GetDat,None,TIntIntVH) +TIntIntVH_swigregister = _snap.TIntIntVH_swigregister +TIntIntVH_swigregister(TIntIntVH) + +class TIntH(object): + """Proxy of C++ THash<(TInt,TInt)> class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + HashPrimes = _snap.TIntH_HashPrimes + def __init__(self, *args): + """ + __init__(THash<(TInt,TInt)> self) -> TIntH + __init__(THash<(TInt,TInt)> self, TIntH Hash) -> TIntH + + Parameters: + Hash: THash< TInt,TInt > const & + + __init__(THash<(TInt,TInt)> self, int const & ExpectVals, bool const & _AutoSizeP=False) -> TIntH + + Parameters: + ExpectVals: int const & + _AutoSizeP: bool const & + + __init__(THash<(TInt,TInt)> self, int const & ExpectVals) -> TIntH + + Parameters: + ExpectVals: int const & + + __init__(THash<(TInt,TInt)> self, TSIn SIn) -> TIntH + + Parameters: + SIn: TSIn & + + """ + _snap.TIntH_swiginit(self,_snap.new_TIntH(*args)) + def Load(self, *args): + """ + Load(TIntH self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TIntH_Load(self, *args) + + def Save(self, *args): + """ + Save(TIntH self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TIntH_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TIntH self, PXmlTok const & XmlTok, TStr Nm="") + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + LoadXml(TIntH self, PXmlTok const & XmlTok) + + Parameters: + XmlTok: PXmlTok const & + + """ + return _snap.TIntH_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TIntH self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TIntH_SaveXml(self, *args) + + def __eq__(self, *args): + """ + __eq__(TIntH self, TIntH Hash) -> bool + + Parameters: + Hash: THash< TInt,TInt > const & + + """ + return _snap.TIntH___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TIntH self, TIntH Hash) -> bool + + Parameters: + Hash: THash< TInt,TInt > const & + + """ + return _snap.TIntH___lt__(self, *args) + + def __call__(self, *args): + """ + __call__(TIntH self, TInt Key) -> TInt + + Parameters: + Key: TInt const & + + """ + return _snap.TIntH___call__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TIntH self) -> ::TSize + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_GetMemUsed(self) + + def BegI(self): + """ + BegI(TIntH self) -> TIntHI + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_BegI(self) + + def EndI(self): + """ + EndI(TIntH self) -> TIntHI + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_EndI(self) + + def GetI(self, *args): + """ + GetI(TIntH self, TInt Key) -> TIntHI + + Parameters: + Key: TInt const & + + """ + return _snap.TIntH_GetI(self, *args) + + def Gen(self, *args): + """ + Gen(TIntH self, int const & ExpectVals) + + Parameters: + ExpectVals: int const & + + """ + return _snap.TIntH_Gen(self, *args) + + def Clr(self, *args): + """ + Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True) + + Parameters: + DoDel: bool const & + NoDelLim: int const & + ResetDat: bool const & + + Clr(TIntH self, bool const & DoDel=True, int const & NoDelLim=-1) + + Parameters: + DoDel: bool const & + NoDelLim: int const & + + Clr(TIntH self, bool const & DoDel=True) + + Parameters: + DoDel: bool const & + + Clr(TIntH self) + + Parameters: + self: THash< TInt,TInt > * + + """ + return _snap.TIntH_Clr(self, *args) + + def Empty(self): + """ + Empty(TIntH self) -> bool + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_Empty(self) + + def Len(self): + """ + Len(TIntH self) -> int + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_Len(self) + + def GetPorts(self): + """ + GetPorts(TIntH self) -> int + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_GetPorts(self) + + def IsAutoSize(self): + """ + IsAutoSize(TIntH self) -> bool + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_IsAutoSize(self) + + def GetMxKeyIds(self): + """ + GetMxKeyIds(TIntH self) -> int + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_GetMxKeyIds(self) + + def GetReservedKeyIds(self): + """ + GetReservedKeyIds(TIntH self) -> int + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_GetReservedKeyIds(self) + + def IsKeyIdEqKeyN(self): + """ + IsKeyIdEqKeyN(TIntH self) -> bool + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_IsKeyIdEqKeyN(self) + + def AddDatId(self, *args): + """ + AddDatId(TIntH self, TInt Key) -> TInt + + Parameters: + Key: TInt const & + + """ + return _snap.TIntH_AddDatId(self, *args) + + def DelKey(self, *args): + """ + DelKey(TIntH self, TInt Key) + + Parameters: + Key: TInt const & + + """ + return _snap.TIntH_DelKey(self, *args) + + def DelIfKey(self, *args): + """ + DelIfKey(TIntH self, TInt Key) -> bool + + Parameters: + Key: TInt const & + + """ + return _snap.TIntH_DelIfKey(self, *args) + + def DelKeyId(self, *args): + """ + DelKeyId(TIntH self, int const & KeyId) + + Parameters: + KeyId: int const & + + """ + return _snap.TIntH_DelKeyId(self, *args) + + def DelKeyIdV(self, *args): + """ + DelKeyIdV(TIntH self, TIntV KeyIdV) + + Parameters: + KeyIdV: TIntV const & + + """ + return _snap.TIntH_DelKeyIdV(self, *args) + + def MarkDelKey(self, *args): + """ + MarkDelKey(TIntH self, TInt Key) + + Parameters: + Key: TInt const & + + """ + return _snap.TIntH_MarkDelKey(self, *args) + + def MarkDelKeyId(self, *args): + """ + MarkDelKeyId(TIntH self, int const & KeyId) + + Parameters: + KeyId: int const & + + """ + return _snap.TIntH_MarkDelKeyId(self, *args) + + def GetKey(self, *args): + """ + GetKey(TIntH self, int const & KeyId) -> TInt + + Parameters: + KeyId: int const & + + """ + return _snap.TIntH_GetKey(self, *args) + + def GetKeyId(self, *args): + """ + GetKeyId(TIntH self, TInt Key) -> int + + Parameters: + Key: TInt const & + + """ + return _snap.TIntH_GetKeyId(self, *args) + + def GetRndKeyId(self, *args): + """ + GetRndKeyId(TIntH self, TRnd Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndKeyId(TIntH self, TRnd Rnd, double const & EmptyFrac) -> int + + Parameters: + Rnd: TRnd & + EmptyFrac: double const & + + """ + return _snap.TIntH_GetRndKeyId(self, *args) + + def IsKeyId(self, *args): + """ + IsKeyId(TIntH self, int const & KeyId) -> bool + + Parameters: + KeyId: int const & + + """ + return _snap.TIntH_IsKeyId(self, *args) + + def GetKeyDat(self, *args): + """ + GetKeyDat(TIntH self, int const & KeyId, TInt Key, TInt Dat) + + Parameters: + KeyId: int const & + Key: TInt & + Dat: TInt & + + """ + return _snap.TIntH_GetKeyDat(self, *args) + + def IsKeyGetDat(self, *args): + """ + IsKeyGetDat(TIntH self, TInt Key, TInt Dat) -> bool + + Parameters: + Key: TInt const & + Dat: TInt & + + """ + return _snap.TIntH_IsKeyGetDat(self, *args) + + def FFirstKeyId(self): + """ + FFirstKeyId(TIntH self) -> int + + Parameters: + self: THash< TInt,TInt > const * + + """ + return _snap.TIntH_FFirstKeyId(self) + + def FNextKeyId(self, *args): + """ + FNextKeyId(TIntH self, int & KeyId) -> bool + + Parameters: + KeyId: int & + + """ + return _snap.TIntH_FNextKeyId(self, *args) + + def GetKeyV(self, *args): + """ + GetKeyV(TIntH self, TIntV KeyV) + + Parameters: + KeyV: TVec< TInt > & + + """ + return _snap.TIntH_GetKeyV(self, *args) + + def GetDatV(self, *args): + """ + GetDatV(TIntH self, TIntV DatV) + + Parameters: + DatV: TVec< TInt > & + + """ + return _snap.TIntH_GetDatV(self, *args) + + def GetKeyDatPrV(self, *args): + """ + GetKeyDatPrV(TIntH self, TVec< TPair< TInt,TInt > > & KeyDatPrV) + + Parameters: + KeyDatPrV: TVec< TPair< TInt,TInt > > & + + """ + return _snap.TIntH_GetKeyDatPrV(self, *args) + + def GetDatKeyPrV(self, *args): + """ + GetDatKeyPrV(TIntH self, TVec< TPair< TInt,TInt > > & DatKeyPrV) + + Parameters: + DatKeyPrV: TVec< TPair< TInt,TInt > > & + + """ + return _snap.TIntH_GetDatKeyPrV(self, *args) + + def GetKeyDatKdV(self, *args): + """ + GetKeyDatKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & KeyDatKdV) + + Parameters: + KeyDatKdV: TVec< TKeyDat< TInt,TInt > > & + + """ + return _snap.TIntH_GetKeyDatKdV(self, *args) + + def GetDatKeyKdV(self, *args): + """ + GetDatKeyKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & DatKeyKdV) + + Parameters: + DatKeyKdV: TVec< TKeyDat< TInt,TInt > > & + + """ + return _snap.TIntH_GetDatKeyKdV(self, *args) + + def Swap(self, *args): + """ + Swap(TIntH self, TIntH Hash) + + Parameters: + Hash: THash< TInt,TInt > & + + """ + return _snap.TIntH_Swap(self, *args) + + def Defrag(self): + """ + Defrag(TIntH self) + + Parameters: + self: THash< TInt,TInt > * + + """ + return _snap.TIntH_Defrag(self) + + def Pack(self): + """ + Pack(TIntH self) + + Parameters: + self: THash< TInt,TInt > * + + """ + return _snap.TIntH_Pack(self) + + def Sort(self, *args): + """ + Sort(TIntH self, bool const & CmpKey, bool const & Asc) + + Parameters: + CmpKey: bool const & + Asc: bool const & + + """ + return _snap.TIntH_Sort(self, *args) + + def SortByKey(self, Asc=True): + """ + SortByKey(TIntH self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + SortByKey(TIntH self) + + Parameters: + self: THash< TInt,TInt > * + + """ + return _snap.TIntH_SortByKey(self, Asc) + + def SortByDat(self, Asc=True): + """ + SortByDat(TIntH self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + SortByDat(TIntH self) + + Parameters: + self: THash< TInt,TInt > * + + """ + return _snap.TIntH_SortByDat(self, Asc) + + def AddKey(self, *args): + """ + AddKey(TIntH self, TInt Key) -> int + + Parameters: + Key: TInt const & + + AddKey(TIntH self, int Val) -> int + + Parameters: + Val: int + + """ + return _snap.TIntH_AddKey(self, *args) + + def IsKey(self, *args): + """ + IsKey(TIntH self, TInt Key) -> bool + + Parameters: + Key: TInt const & + + IsKey(TIntH self, TInt Key, int & KeyId) -> bool + + Parameters: + Key: TInt const & + KeyId: int & + + IsKey(TIntH self, int Val) -> int + + Parameters: + Val: int + + """ + return _snap.TIntH_IsKey(self, *args) + + def GetDat(self, *args): + """ + GetDat(TIntH self, TInt Key) -> TInt + + Parameters: + Key: TInt const & + + GetDat(TIntH self, TInt Key) -> TInt + + Parameters: + Key: TInt const & + + GetDat(TIntH self, int Val) -> TInt + + Parameters: + Val: int + + """ + return _snap.TIntH_GetDat(self, *args) + + def AddDat(self, *args): + """ + AddDat(TIntH self, TInt Key) -> TInt + + Parameters: + Key: TInt const & + + AddDat(TIntH self, TInt Key, TInt Dat) -> TInt + + Parameters: + Key: TInt const & + Dat: TInt const & + + AddDat(TIntH self, int Key, int Val) -> TInt + + Parameters: + Key: int + Val: int + + """ + return _snap.TIntH_AddDat(self, *args) + + __swig_destroy__ = _snap.delete_TIntH +TIntH.Load = new_instancemethod(_snap.TIntH_Load,None,TIntH) +TIntH.Save = new_instancemethod(_snap.TIntH_Save,None,TIntH) +TIntH.LoadXml = new_instancemethod(_snap.TIntH_LoadXml,None,TIntH) +TIntH.SaveXml = new_instancemethod(_snap.TIntH_SaveXml,None,TIntH) +TIntH.__eq__ = new_instancemethod(_snap.TIntH___eq__,None,TIntH) +TIntH.__lt__ = new_instancemethod(_snap.TIntH___lt__,None,TIntH) +TIntH.__call__ = new_instancemethod(_snap.TIntH___call__,None,TIntH) +TIntH.GetMemUsed = new_instancemethod(_snap.TIntH_GetMemUsed,None,TIntH) +TIntH.BegI = new_instancemethod(_snap.TIntH_BegI,None,TIntH) +TIntH.EndI = new_instancemethod(_snap.TIntH_EndI,None,TIntH) +TIntH.GetI = new_instancemethod(_snap.TIntH_GetI,None,TIntH) +TIntH.Gen = new_instancemethod(_snap.TIntH_Gen,None,TIntH) +TIntH.Clr = new_instancemethod(_snap.TIntH_Clr,None,TIntH) +TIntH.Empty = new_instancemethod(_snap.TIntH_Empty,None,TIntH) +TIntH.Len = new_instancemethod(_snap.TIntH_Len,None,TIntH) +TIntH.GetPorts = new_instancemethod(_snap.TIntH_GetPorts,None,TIntH) +TIntH.IsAutoSize = new_instancemethod(_snap.TIntH_IsAutoSize,None,TIntH) +TIntH.GetMxKeyIds = new_instancemethod(_snap.TIntH_GetMxKeyIds,None,TIntH) +TIntH.GetReservedKeyIds = new_instancemethod(_snap.TIntH_GetReservedKeyIds,None,TIntH) +TIntH.IsKeyIdEqKeyN = new_instancemethod(_snap.TIntH_IsKeyIdEqKeyN,None,TIntH) +TIntH.AddDatId = new_instancemethod(_snap.TIntH_AddDatId,None,TIntH) +TIntH.DelKey = new_instancemethod(_snap.TIntH_DelKey,None,TIntH) +TIntH.DelIfKey = new_instancemethod(_snap.TIntH_DelIfKey,None,TIntH) +TIntH.DelKeyId = new_instancemethod(_snap.TIntH_DelKeyId,None,TIntH) +TIntH.DelKeyIdV = new_instancemethod(_snap.TIntH_DelKeyIdV,None,TIntH) +TIntH.MarkDelKey = new_instancemethod(_snap.TIntH_MarkDelKey,None,TIntH) +TIntH.MarkDelKeyId = new_instancemethod(_snap.TIntH_MarkDelKeyId,None,TIntH) +TIntH.GetKey = new_instancemethod(_snap.TIntH_GetKey,None,TIntH) +TIntH.GetKeyId = new_instancemethod(_snap.TIntH_GetKeyId,None,TIntH) +TIntH.GetRndKeyId = new_instancemethod(_snap.TIntH_GetRndKeyId,None,TIntH) +TIntH.IsKeyId = new_instancemethod(_snap.TIntH_IsKeyId,None,TIntH) +TIntH.GetKeyDat = new_instancemethod(_snap.TIntH_GetKeyDat,None,TIntH) +TIntH.IsKeyGetDat = new_instancemethod(_snap.TIntH_IsKeyGetDat,None,TIntH) +TIntH.FFirstKeyId = new_instancemethod(_snap.TIntH_FFirstKeyId,None,TIntH) +TIntH.FNextKeyId = new_instancemethod(_snap.TIntH_FNextKeyId,None,TIntH) +TIntH.GetKeyV = new_instancemethod(_snap.TIntH_GetKeyV,None,TIntH) +TIntH.GetDatV = new_instancemethod(_snap.TIntH_GetDatV,None,TIntH) +TIntH.GetKeyDatPrV = new_instancemethod(_snap.TIntH_GetKeyDatPrV,None,TIntH) +TIntH.GetDatKeyPrV = new_instancemethod(_snap.TIntH_GetDatKeyPrV,None,TIntH) +TIntH.GetKeyDatKdV = new_instancemethod(_snap.TIntH_GetKeyDatKdV,None,TIntH) +TIntH.GetDatKeyKdV = new_instancemethod(_snap.TIntH_GetDatKeyKdV,None,TIntH) +TIntH.Swap = new_instancemethod(_snap.TIntH_Swap,None,TIntH) +TIntH.Defrag = new_instancemethod(_snap.TIntH_Defrag,None,TIntH) +TIntH.Pack = new_instancemethod(_snap.TIntH_Pack,None,TIntH) +TIntH.Sort = new_instancemethod(_snap.TIntH_Sort,None,TIntH) +TIntH.SortByKey = new_instancemethod(_snap.TIntH_SortByKey,None,TIntH) +TIntH.SortByDat = new_instancemethod(_snap.TIntH_SortByDat,None,TIntH) +TIntH.AddKey = new_instancemethod(_snap.TIntH_AddKey,None,TIntH) +TIntH.IsKey = new_instancemethod(_snap.TIntH_IsKey,None,TIntH) +TIntH.GetDat = new_instancemethod(_snap.TIntH_GetDat,None,TIntH) +TIntH.AddDat = new_instancemethod(_snap.TIntH_AddDat,None,TIntH) +TIntH_swigregister = _snap.TIntH_swigregister +TIntH_swigregister(TIntH) + +class TIntHI(object): + """Proxy of C++ THashKeyDatI<(TInt,TInt)> class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(THashKeyDatI<(TInt,TInt)> self) -> TIntHI + __init__(THashKeyDatI<(TInt,TInt)> self, TIntHI _HashKeyDatI) -> TIntHI + + Parameters: + _HashKeyDatI: THashKeyDatI< TInt,TInt > const & + + __init__(THashKeyDatI<(TInt,TInt)> self, THashKeyDatI< TInt,TInt >::THKeyDat const * _KeyDatI, THashKeyDatI< TInt,TInt >::THKeyDat const * _EndI) -> TIntHI + + Parameters: + _KeyDatI: THashKeyDatI< TInt,TInt >::THKeyDat const * + _EndI: THashKeyDatI< TInt,TInt >::THKeyDat const * + + """ + _snap.TIntHI_swiginit(self,_snap.new_TIntHI(*args)) + def __eq__(self, *args): + """ + __eq__(TIntHI self, TIntHI HashKeyDatI) -> bool + + Parameters: + HashKeyDatI: THashKeyDatI< TInt,TInt > const & + + """ + return _snap.TIntHI___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TIntHI self, TIntHI HashKeyDatI) -> bool + + Parameters: + HashKeyDatI: THashKeyDatI< TInt,TInt > const & + + """ + return _snap.TIntHI___lt__(self, *args) + + def __ref__(self): + """ + __ref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat & + + Parameters: + self: THashKeyDatI< TInt,TInt > const * + + """ + return _snap.TIntHI___ref__(self) + + def __call__(self): + """ + __call__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat & + + Parameters: + self: THashKeyDatI< TInt,TInt > const * + + """ + return _snap.TIntHI___call__(self) + + def __deref__(self): + """ + __deref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat * + + Parameters: + self: THashKeyDatI< TInt,TInt > const * + + """ + return _snap.TIntHI___deref__(self) + + def Next(self): + """ + Next(TIntHI self) -> TIntHI + + Parameters: + self: THashKeyDatI< TInt,TInt > * + + """ + return _snap.TIntHI_Next(self) + + def IsEmpty(self): + """ + IsEmpty(TIntHI self) -> bool + + Parameters: + self: THashKeyDatI< TInt,TInt > const * + + """ + return _snap.TIntHI_IsEmpty(self) + + def IsEnd(self): + """ + IsEnd(TIntHI self) -> bool + + Parameters: + self: THashKeyDatI< TInt,TInt > const * + + """ + return _snap.TIntHI_IsEnd(self) + + def GetKey(self): + """ + GetKey(TIntHI self) -> TInt + + Parameters: + self: THashKeyDatI< TInt,TInt > const * + + """ + return _snap.TIntHI_GetKey(self) + + def GetDat(self, *args): + """ + GetDat(TIntHI self) -> TInt + GetDat(TIntHI self) -> TInt + + Parameters: + self: THashKeyDatI< TInt,TInt > * + + """ + return _snap.TIntHI_GetDat(self, *args) + + __swig_destroy__ = _snap.delete_TIntHI +TIntHI.__eq__ = new_instancemethod(_snap.TIntHI___eq__,None,TIntHI) +TIntHI.__lt__ = new_instancemethod(_snap.TIntHI___lt__,None,TIntHI) +TIntHI.__ref__ = new_instancemethod(_snap.TIntHI___ref__,None,TIntHI) +TIntHI.__call__ = new_instancemethod(_snap.TIntHI___call__,None,TIntHI) +TIntHI.__deref__ = new_instancemethod(_snap.TIntHI___deref__,None,TIntHI) +TIntHI.Next = new_instancemethod(_snap.TIntHI_Next,None,TIntHI) +TIntHI.IsEmpty = new_instancemethod(_snap.TIntHI_IsEmpty,None,TIntHI) +TIntHI.IsEnd = new_instancemethod(_snap.TIntHI_IsEnd,None,TIntHI) +TIntHI.GetKey = new_instancemethod(_snap.TIntHI_GetKey,None,TIntHI) +TIntHI.GetDat = new_instancemethod(_snap.TIntHI_GetDat,None,TIntHI) +TIntHI_swigregister = _snap.TIntHI_swigregister +TIntHI_swigregister(TIntHI) + +class TStrV(object): + """Proxy of C++ TVec<(TStr,int)> class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + __swig_destroy__ = _snap.delete_TStrV + def __init__(self, *args): + """ + __init__(TVec<(TStr,int)> self) -> TStrV + __init__(TVec<(TStr,int)> self, TStrV Vec) -> TStrV + + Parameters: + Vec: TVec< TStr,int > const & + + __init__(TVec<(TStr,int)> self, int const & _Vals) -> TStrV + + Parameters: + _Vals: int const & + + __init__(TVec<(TStr,int)> self, int const & _MxVals, int const & _Vals) -> TStrV + + Parameters: + _MxVals: int const & + _Vals: int const & + + __init__(TVec<(TStr,int)> self, TStr _ValT, int const & _Vals) -> TStrV + + Parameters: + _ValT: TStr * + _Vals: int const & + + __init__(TVec<(TStr,int)> self, TSIn SIn) -> TStrV + + Parameters: + SIn: TSIn & + + """ + _snap.TStrV_swiginit(self,_snap.new_TStrV(*args)) + def Load(self, *args): + """ + Load(TStrV self, TSIn SIn) + + Parameters: + SIn: TSIn & + + """ + return _snap.TStrV_Load(self, *args) + + def Save(self, *args): + """ + Save(TStrV self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TStrV_Save(self, *args) + + def LoadXml(self, *args): + """ + LoadXml(TStrV self, PXmlTok const & XmlTok, TStr Nm="") + + Parameters: + XmlTok: PXmlTok const & + Nm: TStr const & + + LoadXml(TStrV self, PXmlTok const & XmlTok) + + Parameters: + XmlTok: PXmlTok const & + + """ + return _snap.TStrV_LoadXml(self, *args) + + def SaveXml(self, *args): + """ + SaveXml(TStrV self, TSOut SOut, TStr Nm) + + Parameters: + SOut: TSOut & + Nm: TStr const & + + """ + return _snap.TStrV_SaveXml(self, *args) + + def __add__(self, *args): + """ + __add__(TStrV self, TStr Val) -> TStrV + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV___add__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TStrV self, TStrV Vec) -> bool + + Parameters: + Vec: TVec< TStr,int > const & + + """ + return _snap.TStrV___eq__(self, *args) + + def __lt__(self, *args): + """ + __lt__(TStrV self, TStrV Vec) -> bool + + Parameters: + Vec: TVec< TStr,int > const & + + """ + return _snap.TStrV___lt__(self, *args) + + def GetMemUsed(self): + """ + GetMemUsed(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_GetMemUsed(self) + + def GetMemSize(self): + """ + GetMemSize(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_GetMemSize(self) + + def GetPrimHashCd(self): + """ + GetPrimHashCd(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_GetPrimHashCd(self) + + def GetSecHashCd(self): + """ + GetSecHashCd(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_GetSecHashCd(self) + + def Gen(self, *args): + """ + Gen(TStrV self, int const & _Vals) + + Parameters: + _Vals: int const & + + Gen(TStrV self, int const & _MxVals, int const & _Vals) + + Parameters: + _MxVals: int const & + _Vals: int const & + + """ + return _snap.TStrV_Gen(self, *args) + + def GenExt(self, *args): + """ + GenExt(TStrV self, TStr _ValT, int const & _Vals) + + Parameters: + _ValT: TStr * + _Vals: int const & + + """ + return _snap.TStrV_GenExt(self, *args) + + def IsExt(self): + """ + IsExt(TStrV self) -> bool + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_IsExt(self) + + def Reserve(self, *args): + """ + Reserve(TStrV self, int const & _MxVals) + + Parameters: + _MxVals: int const & + + Reserve(TStrV self, int const & _MxVals, int const & _Vals) + + Parameters: + _MxVals: int const & + _Vals: int const & + + """ + return _snap.TStrV_Reserve(self, *args) + + def Clr(self, *args): + """ + Clr(TStrV self, bool const & DoDel=True, int const & NoDelLim=-1) + + Parameters: + DoDel: bool const & + NoDelLim: int const & + + Clr(TStrV self, bool const & DoDel=True) + + Parameters: + DoDel: bool const & + + Clr(TStrV self) + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_Clr(self, *args) + + def Trunc(self, *args): + """ + Trunc(TStrV self, int const & _Vals=-1) + + Parameters: + _Vals: int const & + + Trunc(TStrV self) + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_Trunc(self, *args) + + def Pack(self): + """ + Pack(TStrV self) + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_Pack(self) + + def MoveFrom(self, *args): + """ + MoveFrom(TStrV self, TStrV Vec) + + Parameters: + Vec: TVec< TStr,int > & + + """ + return _snap.TStrV_MoveFrom(self, *args) + + def Empty(self): + """ + Empty(TStrV self) -> bool + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_Empty(self) + + def Len(self): + """ + Len(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_Len(self) + + def Reserved(self): + """ + Reserved(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_Reserved(self) + + def Last(self, *args): + """ + Last(TStrV self) -> TStr + Last(TStrV self) -> TStr + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_Last(self, *args) + + def LastValN(self): + """ + LastValN(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_LastValN(self) + + def LastLast(self, *args): + """ + LastLast(TStrV self) -> TStr + LastLast(TStrV self) -> TStr + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_LastLast(self, *args) + + def BegI(self): + """ + BegI(TStrV self) -> TStr + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_BegI(self) + + def EndI(self): + """ + EndI(TStrV self) -> TStr + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_EndI(self) + + def GetI(self, *args): + """ + GetI(TStrV self, int const & ValN) -> TStr + + Parameters: + ValN: int const & + + """ + return _snap.TStrV_GetI(self, *args) + + def AddV(self, *args): + """ + AddV(TStrV self, TStrV ValV) -> int + + Parameters: + ValV: TVec< TStr,int > const & + + """ + return _snap.TStrV_AddV(self, *args) + + def AddSorted(self, *args): + """ + AddSorted(TStrV self, TStr Val, bool const & Asc=True, int const & _MxVals=-1) -> int + + Parameters: + Val: TStr const & + Asc: bool const & + _MxVals: int const & + + AddSorted(TStrV self, TStr Val, bool const & Asc=True) -> int + + Parameters: + Val: TStr const & + Asc: bool const & + + AddSorted(TStrV self, TStr Val) -> int + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_AddSorted(self, *args) + + def AddBackSorted(self, *args): + """ + AddBackSorted(TStrV self, TStr Val, bool const & Asc) -> int + + Parameters: + Val: TStr const & + Asc: bool const & + + """ + return _snap.TStrV_AddBackSorted(self, *args) + + def AddVMerged(self, *args): + """ + AddVMerged(TStrV self, TStrV ValV) -> int + + Parameters: + ValV: TVec< TStr,int > const & + + """ + return _snap.TStrV_AddVMerged(self, *args) + + def AddUnique(self, *args): + """ + AddUnique(TStrV self, TStr Val) -> int + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_AddUnique(self, *args) + + def GetVal(self, *args): + """ + GetVal(TStrV self, int const & ValN) -> TStr + + Parameters: + ValN: int const & + + GetVal(TStrV self, int const & ValN) -> TStr + + Parameters: + ValN: int const & + + """ + return _snap.TStrV_GetVal(self, *args) + + def GetSubValV(self, *args): + """ + GetSubValV(TStrV self, int const & BValN, int const & EValN, TStrV ValV) + + Parameters: + BValN: int const & + EValN: int const & + ValV: TVec< TStr,int > & + + """ + return _snap.TStrV_GetSubValV(self, *args) + + def Ins(self, *args): + """ + Ins(TStrV self, int const & ValN, TStr Val) + + Parameters: + ValN: int const & + Val: TStr const & + + """ + return _snap.TStrV_Ins(self, *args) + + def Del(self, *args): + """ + Del(TStrV self, int const & ValN) + + Parameters: + ValN: int const & + + Del(TStrV self, int const & MnValN, int const & MxValN) + + Parameters: + MnValN: int const & + MxValN: int const & + + """ + return _snap.TStrV_Del(self, *args) + + def DelLast(self): + """ + DelLast(TStrV self) + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_DelLast(self) + + def DelIfIn(self, *args): + """ + DelIfIn(TStrV self, TStr Val) -> bool + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_DelIfIn(self, *args) + + def DelAll(self, *args): + """ + DelAll(TStrV self, TStr Val) + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_DelAll(self, *args) + + def PutAll(self, *args): + """ + PutAll(TStrV self, TStr Val) + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_PutAll(self, *args) + + def Swap(self, *args): + """ + Swap(TStrV self, TStrV Vec) + + Parameters: + Vec: TVec< TStr,int > & + + Swap(TStrV self, int const & ValN1, int const & ValN2) + + Parameters: + ValN1: int const & + ValN2: int const & + + """ + return _snap.TStrV_Swap(self, *args) + + def SwapI(*args): + """ + SwapI(TStr LVal, TStr RVal) + + Parameters: + LVal: TVec< TStr,int >::TIter + RVal: TVec< TStr,int >::TIter + + """ + return _snap.TStrV_SwapI(*args) + + SwapI = staticmethod(SwapI) + def NextPerm(self): + """ + NextPerm(TStrV self) -> bool + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_NextPerm(self) + + def PrevPerm(self): + """ + PrevPerm(TStrV self) -> bool + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_PrevPerm(self) + + def GetPivotValN(self, *args): + """ + GetPivotValN(TStrV self, int const & LValN, int const & RValN) -> int + + Parameters: + LValN: int const & + RValN: int const & + + """ + return _snap.TStrV_GetPivotValN(self, *args) + + def BSort(self, *args): + """ + BSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TStrV_BSort(self, *args) + + def ISort(self, *args): + """ + ISort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TStrV_ISort(self, *args) + + def Partition(self, *args): + """ + Partition(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TStrV_Partition(self, *args) + + def QSort(self, *args): + """ + QSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) + + Parameters: + MnLValN: int const & + MxRValN: int const & + Asc: bool const & + + """ + return _snap.TStrV_QSort(self, *args) + + def Sort(self, Asc=True): + """ + Sort(TStrV self, bool const & Asc=True) + + Parameters: + Asc: bool const & + + Sort(TStrV self) + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_Sort(self, Asc) + + def IsSorted(self, Asc=True): + """ + IsSorted(TStrV self, bool const & Asc=True) -> bool + + Parameters: + Asc: bool const & + + IsSorted(TStrV self) -> bool + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_IsSorted(self, Asc) + + def Shuffle(self, *args): + """ + Shuffle(TStrV self, TRnd Rnd) + + Parameters: + Rnd: TRnd & + + """ + return _snap.TStrV_Shuffle(self, *args) + + def Reverse(self, *args): + """ + Reverse(TStrV self) + Reverse(TStrV self, int LValN, int RValN) + + Parameters: + LValN: int + RValN: int + + """ + return _snap.TStrV_Reverse(self, *args) + + def Merge(self): + """ + Merge(TStrV self) + + Parameters: + self: TVec< TStr,int > * + + """ + return _snap.TStrV_Merge(self) + + def Intrs(self, *args): + """ + Intrs(TStrV self, TStrV ValV) + + Parameters: + ValV: TVec< TStr,int > const & + + Intrs(TStrV self, TStrV ValV, TStrV DstValV) + + Parameters: + ValV: TVec< TStr,int > const & + DstValV: TVec< TStr,int > & + + """ + return _snap.TStrV_Intrs(self, *args) + + def Union(self, *args): + """ + Union(TStrV self, TStrV ValV) + + Parameters: + ValV: TVec< TStr,int > const & + + Union(TStrV self, TStrV ValV, TStrV DstValV) + + Parameters: + ValV: TVec< TStr,int > const & + DstValV: TVec< TStr,int > & + + """ + return _snap.TStrV_Union(self, *args) + + def Diff(self, *args): + """ + Diff(TStrV self, TStrV ValV) + + Parameters: + ValV: TVec< TStr,int > const & + + Diff(TStrV self, TStrV ValV, TStrV DstValV) + + Parameters: + ValV: TVec< TStr,int > const & + DstValV: TVec< TStr,int > & + + """ + return _snap.TStrV_Diff(self, *args) + + def IntrsLen(self, *args): + """ + IntrsLen(TStrV self, TStrV ValV) -> int + + Parameters: + ValV: TVec< TStr,int > const & + + """ + return _snap.TStrV_IntrsLen(self, *args) + + def UnionLen(self, *args): + """ + UnionLen(TStrV self, TStrV ValV) -> int + + Parameters: + ValV: TVec< TStr,int > const & + + """ + return _snap.TStrV_UnionLen(self, *args) + + def Count(self, *args): + """ + Count(TStrV self, TStr Val) -> int + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_Count(self, *args) + + def SearchBin(self, *args): + """ + SearchBin(TStrV self, TStr Val) -> int + + Parameters: + Val: TStr const & + + SearchBin(TStrV self, TStr Val, int & InsValN) -> int + + Parameters: + Val: TStr const & + InsValN: int & + + """ + return _snap.TStrV_SearchBin(self, *args) + + def SearchForw(self, *args): + """ + SearchForw(TStrV self, TStr Val, int const & BValN=0) -> int + + Parameters: + Val: TStr const & + BValN: int const & + + SearchForw(TStrV self, TStr Val) -> int + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_SearchForw(self, *args) + + def SearchBack(self, *args): + """ + SearchBack(TStrV self, TStr Val) -> int + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_SearchBack(self, *args) + + def SearchVForw(self, *args): + """ + SearchVForw(TStrV self, TStrV ValV, int const & BValN=0) -> int + + Parameters: + ValV: TVec< TStr,int > const & + BValN: int const & + + SearchVForw(TStrV self, TStrV ValV) -> int + + Parameters: + ValV: TVec< TStr,int > const & + + """ + return _snap.TStrV_SearchVForw(self, *args) + + def IsIn(self, *args): + """ + IsIn(TStrV self, TStr Val) -> bool + + Parameters: + Val: TStr const & + + IsIn(TStrV self, TStr Val, int & ValN) -> bool + + Parameters: + Val: TStr const & + ValN: int & + + """ + return _snap.TStrV_IsIn(self, *args) + + def IsInBin(self, *args): + """ + IsInBin(TStrV self, TStr Val) -> bool + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_IsInBin(self, *args) + + def GetDat(self, *args): + """ + GetDat(TStrV self, TStr Val) -> TStr + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_GetDat(self, *args) + + def GetAddDat(self, *args): + """ + GetAddDat(TStrV self, TStr Val) -> TStr + + Parameters: + Val: TStr const & + + """ + return _snap.TStrV_GetAddDat(self, *args) + + def GetMxValN(self): + """ + GetMxValN(TStrV self) -> int + + Parameters: + self: TVec< TStr,int > const * + + """ + return _snap.TStrV_GetMxValN(self) + + def GetV(*args): + """ + GetV(TStr Val1) -> TStrV + + Parameters: + Val1: TStr const & + + GetV(TStr Val1, TStr Val2) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + Val7: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + Val7: TStr const & + Val8: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8, + TStr Val9) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + Val7: TStr const & + Val8: TStr const & + Val9: TStr const & + + """ + return _snap.TStrV_GetV(*args) + + GetV = staticmethod(GetV) +TStrV.Load = new_instancemethod(_snap.TStrV_Load,None,TStrV) +TStrV.Save = new_instancemethod(_snap.TStrV_Save,None,TStrV) +TStrV.LoadXml = new_instancemethod(_snap.TStrV_LoadXml,None,TStrV) +TStrV.SaveXml = new_instancemethod(_snap.TStrV_SaveXml,None,TStrV) +TStrV.__add__ = new_instancemethod(_snap.TStrV___add__,None,TStrV) +TStrV.__eq__ = new_instancemethod(_snap.TStrV___eq__,None,TStrV) +TStrV.__lt__ = new_instancemethod(_snap.TStrV___lt__,None,TStrV) +TStrV.GetMemUsed = new_instancemethod(_snap.TStrV_GetMemUsed,None,TStrV) +TStrV.GetMemSize = new_instancemethod(_snap.TStrV_GetMemSize,None,TStrV) +TStrV.GetPrimHashCd = new_instancemethod(_snap.TStrV_GetPrimHashCd,None,TStrV) +TStrV.GetSecHashCd = new_instancemethod(_snap.TStrV_GetSecHashCd,None,TStrV) +TStrV.Gen = new_instancemethod(_snap.TStrV_Gen,None,TStrV) +TStrV.GenExt = new_instancemethod(_snap.TStrV_GenExt,None,TStrV) +TStrV.IsExt = new_instancemethod(_snap.TStrV_IsExt,None,TStrV) +TStrV.Reserve = new_instancemethod(_snap.TStrV_Reserve,None,TStrV) +TStrV.Clr = new_instancemethod(_snap.TStrV_Clr,None,TStrV) +TStrV.Trunc = new_instancemethod(_snap.TStrV_Trunc,None,TStrV) +TStrV.Pack = new_instancemethod(_snap.TStrV_Pack,None,TStrV) +TStrV.MoveFrom = new_instancemethod(_snap.TStrV_MoveFrom,None,TStrV) +TStrV.Empty = new_instancemethod(_snap.TStrV_Empty,None,TStrV) +TStrV.Len = new_instancemethod(_snap.TStrV_Len,None,TStrV) +TStrV.Reserved = new_instancemethod(_snap.TStrV_Reserved,None,TStrV) +TStrV.Last = new_instancemethod(_snap.TStrV_Last,None,TStrV) +TStrV.LastValN = new_instancemethod(_snap.TStrV_LastValN,None,TStrV) +TStrV.LastLast = new_instancemethod(_snap.TStrV_LastLast,None,TStrV) +TStrV.BegI = new_instancemethod(_snap.TStrV_BegI,None,TStrV) +TStrV.EndI = new_instancemethod(_snap.TStrV_EndI,None,TStrV) +TStrV.GetI = new_instancemethod(_snap.TStrV_GetI,None,TStrV) +TStrV.AddV = new_instancemethod(_snap.TStrV_AddV,None,TStrV) +TStrV.AddSorted = new_instancemethod(_snap.TStrV_AddSorted,None,TStrV) +TStrV.AddBackSorted = new_instancemethod(_snap.TStrV_AddBackSorted,None,TStrV) +TStrV.AddVMerged = new_instancemethod(_snap.TStrV_AddVMerged,None,TStrV) +TStrV.AddUnique = new_instancemethod(_snap.TStrV_AddUnique,None,TStrV) +TStrV.GetVal = new_instancemethod(_snap.TStrV_GetVal,None,TStrV) +TStrV.GetSubValV = new_instancemethod(_snap.TStrV_GetSubValV,None,TStrV) +TStrV.Ins = new_instancemethod(_snap.TStrV_Ins,None,TStrV) +TStrV.Del = new_instancemethod(_snap.TStrV_Del,None,TStrV) +TStrV.DelLast = new_instancemethod(_snap.TStrV_DelLast,None,TStrV) +TStrV.DelIfIn = new_instancemethod(_snap.TStrV_DelIfIn,None,TStrV) +TStrV.DelAll = new_instancemethod(_snap.TStrV_DelAll,None,TStrV) +TStrV.PutAll = new_instancemethod(_snap.TStrV_PutAll,None,TStrV) +TStrV.Swap = new_instancemethod(_snap.TStrV_Swap,None,TStrV) +TStrV.NextPerm = new_instancemethod(_snap.TStrV_NextPerm,None,TStrV) +TStrV.PrevPerm = new_instancemethod(_snap.TStrV_PrevPerm,None,TStrV) +TStrV.GetPivotValN = new_instancemethod(_snap.TStrV_GetPivotValN,None,TStrV) +TStrV.BSort = new_instancemethod(_snap.TStrV_BSort,None,TStrV) +TStrV.ISort = new_instancemethod(_snap.TStrV_ISort,None,TStrV) +TStrV.Partition = new_instancemethod(_snap.TStrV_Partition,None,TStrV) +TStrV.QSort = new_instancemethod(_snap.TStrV_QSort,None,TStrV) +TStrV.Sort = new_instancemethod(_snap.TStrV_Sort,None,TStrV) +TStrV.IsSorted = new_instancemethod(_snap.TStrV_IsSorted,None,TStrV) +TStrV.Shuffle = new_instancemethod(_snap.TStrV_Shuffle,None,TStrV) +TStrV.Reverse = new_instancemethod(_snap.TStrV_Reverse,None,TStrV) +TStrV.Merge = new_instancemethod(_snap.TStrV_Merge,None,TStrV) +TStrV.Intrs = new_instancemethod(_snap.TStrV_Intrs,None,TStrV) +TStrV.Union = new_instancemethod(_snap.TStrV_Union,None,TStrV) +TStrV.Diff = new_instancemethod(_snap.TStrV_Diff,None,TStrV) +TStrV.IntrsLen = new_instancemethod(_snap.TStrV_IntrsLen,None,TStrV) +TStrV.UnionLen = new_instancemethod(_snap.TStrV_UnionLen,None,TStrV) +TStrV.Count = new_instancemethod(_snap.TStrV_Count,None,TStrV) +TStrV.SearchBin = new_instancemethod(_snap.TStrV_SearchBin,None,TStrV) +TStrV.SearchForw = new_instancemethod(_snap.TStrV_SearchForw,None,TStrV) +TStrV.SearchBack = new_instancemethod(_snap.TStrV_SearchBack,None,TStrV) +TStrV.SearchVForw = new_instancemethod(_snap.TStrV_SearchVForw,None,TStrV) +TStrV.IsIn = new_instancemethod(_snap.TStrV_IsIn,None,TStrV) +TStrV.IsInBin = new_instancemethod(_snap.TStrV_IsInBin,None,TStrV) +TStrV.GetDat = new_instancemethod(_snap.TStrV_GetDat,None,TStrV) +TStrV.GetAddDat = new_instancemethod(_snap.TStrV_GetAddDat,None,TStrV) +TStrV.GetMxValN = new_instancemethod(_snap.TStrV_GetMxValN,None,TStrV) +TStrV_swigregister = _snap.TStrV_swigregister +TStrV_swigregister(TStrV) + +def TStrV_SwapI(*args): + """ + TStrV_SwapI(TStr LVal, TStr RVal) + + Parameters: + LVal: TVec< TStr,int >::TIter + RVal: TVec< TStr,int >::TIter + + """ + return _snap.TStrV_SwapI(*args) + +def TStrV_GetV(*args): + """ + GetV(TStr Val1) -> TStrV + + Parameters: + Val1: TStr const & + + GetV(TStr Val1, TStr Val2) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + Val7: TStr const & + + GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + Val7: TStr const & + Val8: TStr const & + + TStrV_GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8, + TStr Val9) -> TStrV + + Parameters: + Val1: TStr const & + Val2: TStr const & + Val3: TStr const & + Val4: TStr const & + Val5: TStr const & + Val6: TStr const & + Val7: TStr const & + Val8: TStr const & + Val9: TStr const & + + """ + return _snap.TStrV_GetV(*args) + +class TNGraphNodeI(object): + """Proxy of C++ TNGraphNodeI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNGraphNodeI self) -> TNGraphNodeI + __init__(TNGraphNodeI self, TNGraph::TNodeI const & NodeI) -> TNGraphNodeI + + Parameters: + NodeI: TNGraph::TNodeI const & + + """ + _snap.TNGraphNodeI_swiginit(self,_snap.new_TNGraphNodeI(*args)) + def Next(self): + """ + Next(TNGraphNodeI self) -> TNGraphNodeI + + Parameters: + self: TNGraphNodeI * + + """ + return _snap.TNGraphNodeI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool + + Parameters: + NodeI: TNGraphNodeI const & + + """ + return _snap.TNGraphNodeI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool + + Parameters: + NodeI: TNGraphNodeI const & + + """ + return _snap.TNGraphNodeI___eq__(self, *args) + + def GetId(self): + """ + GetId(TNGraphNodeI self) -> int + + Parameters: + self: TNGraphNodeI const * + + """ + return _snap.TNGraphNodeI_GetId(self) + + def GetDeg(self): + """ + GetDeg(TNGraphNodeI self) -> int + + Parameters: + self: TNGraphNodeI const * + + """ + return _snap.TNGraphNodeI_GetDeg(self) + + def GetInDeg(self): + """ + GetInDeg(TNGraphNodeI self) -> int + + Parameters: + self: TNGraphNodeI const * + + """ + return _snap.TNGraphNodeI_GetInDeg(self) + + def GetOutDeg(self): + """ + GetOutDeg(TNGraphNodeI self) -> int + + Parameters: + self: TNGraphNodeI const * + + """ + return _snap.TNGraphNodeI_GetOutDeg(self) + + def GetInNId(self, *args): + """ + GetInNId(TNGraphNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TNGraphNodeI_GetInNId(self, *args) + + def GetOutNId(self, *args): + """ + GetOutNId(TNGraphNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TNGraphNodeI_GetOutNId(self, *args) + + def GetNbrNId(self, *args): + """ + GetNbrNId(TNGraphNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TNGraphNodeI_GetNbrNId(self, *args) + + def IsInNId(self, *args): + """ + IsInNId(TNGraphNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNGraphNodeI_IsInNId(self, *args) + + def IsOutNId(self, *args): + """ + IsOutNId(TNGraphNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNGraphNodeI_IsOutNId(self, *args) + + def IsNbrNId(self, *args): + """ + IsNbrNId(TNGraphNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNGraphNodeI_IsNbrNId(self, *args) + + __swig_destroy__ = _snap.delete_TNGraphNodeI +TNGraphNodeI.Next = new_instancemethod(_snap.TNGraphNodeI_Next,None,TNGraphNodeI) +TNGraphNodeI.__lt__ = new_instancemethod(_snap.TNGraphNodeI___lt__,None,TNGraphNodeI) +TNGraphNodeI.__eq__ = new_instancemethod(_snap.TNGraphNodeI___eq__,None,TNGraphNodeI) +TNGraphNodeI.GetId = new_instancemethod(_snap.TNGraphNodeI_GetId,None,TNGraphNodeI) +TNGraphNodeI.GetDeg = new_instancemethod(_snap.TNGraphNodeI_GetDeg,None,TNGraphNodeI) +TNGraphNodeI.GetInDeg = new_instancemethod(_snap.TNGraphNodeI_GetInDeg,None,TNGraphNodeI) +TNGraphNodeI.GetOutDeg = new_instancemethod(_snap.TNGraphNodeI_GetOutDeg,None,TNGraphNodeI) +TNGraphNodeI.GetInNId = new_instancemethod(_snap.TNGraphNodeI_GetInNId,None,TNGraphNodeI) +TNGraphNodeI.GetOutNId = new_instancemethod(_snap.TNGraphNodeI_GetOutNId,None,TNGraphNodeI) +TNGraphNodeI.GetNbrNId = new_instancemethod(_snap.TNGraphNodeI_GetNbrNId,None,TNGraphNodeI) +TNGraphNodeI.IsInNId = new_instancemethod(_snap.TNGraphNodeI_IsInNId,None,TNGraphNodeI) +TNGraphNodeI.IsOutNId = new_instancemethod(_snap.TNGraphNodeI_IsOutNId,None,TNGraphNodeI) +TNGraphNodeI.IsNbrNId = new_instancemethod(_snap.TNGraphNodeI_IsNbrNId,None,TNGraphNodeI) +TNGraphNodeI_swigregister = _snap.TNGraphNodeI_swigregister +TNGraphNodeI_swigregister(TNGraphNodeI) + +class TNGraphEdgeI(object): + """Proxy of C++ TNGraphEdgeI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNGraphEdgeI self) -> TNGraphEdgeI + __init__(TNGraphEdgeI self, TNGraph::TEdgeI const & EdgeI) -> TNGraphEdgeI + + Parameters: + EdgeI: TNGraph::TEdgeI const & + + """ + _snap.TNGraphEdgeI_swiginit(self,_snap.new_TNGraphEdgeI(*args)) + def Next(self): + """ + Next(TNGraphEdgeI self) -> TNGraphEdgeI + + Parameters: + self: TNGraphEdgeI * + + """ + return _snap.TNGraphEdgeI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool + + Parameters: + EdgeI: TNGraphEdgeI const & + + """ + return _snap.TNGraphEdgeI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool + + Parameters: + EdgeI: TNGraphEdgeI const & + + """ + return _snap.TNGraphEdgeI___eq__(self, *args) + + def GetId(self): + """ + GetId(TNGraphEdgeI self) -> int + + Parameters: + self: TNGraphEdgeI const * + + """ + return _snap.TNGraphEdgeI_GetId(self) + + def GetSrcNId(self): + """ + GetSrcNId(TNGraphEdgeI self) -> int + + Parameters: + self: TNGraphEdgeI const * + + """ + return _snap.TNGraphEdgeI_GetSrcNId(self) + + def GetDstNId(self): + """ + GetDstNId(TNGraphEdgeI self) -> int + + Parameters: + self: TNGraphEdgeI const * + + """ + return _snap.TNGraphEdgeI_GetDstNId(self) + + __swig_destroy__ = _snap.delete_TNGraphEdgeI +TNGraphEdgeI.Next = new_instancemethod(_snap.TNGraphEdgeI_Next,None,TNGraphEdgeI) +TNGraphEdgeI.__lt__ = new_instancemethod(_snap.TNGraphEdgeI___lt__,None,TNGraphEdgeI) +TNGraphEdgeI.__eq__ = new_instancemethod(_snap.TNGraphEdgeI___eq__,None,TNGraphEdgeI) +TNGraphEdgeI.GetId = new_instancemethod(_snap.TNGraphEdgeI_GetId,None,TNGraphEdgeI) +TNGraphEdgeI.GetSrcNId = new_instancemethod(_snap.TNGraphEdgeI_GetSrcNId,None,TNGraphEdgeI) +TNGraphEdgeI.GetDstNId = new_instancemethod(_snap.TNGraphEdgeI_GetDstNId,None,TNGraphEdgeI) +TNGraphEdgeI_swigregister = _snap.TNGraphEdgeI_swigregister +TNGraphEdgeI_swigregister(TNGraphEdgeI) + +class TUNGraphNodeI(object): + """Proxy of C++ TUNGraphNodeI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TUNGraphNodeI self) -> TUNGraphNodeI + __init__(TUNGraphNodeI self, TUNGraph::TNodeI const & NodeI) -> TUNGraphNodeI + + Parameters: + NodeI: TUNGraph::TNodeI const & + + """ + _snap.TUNGraphNodeI_swiginit(self,_snap.new_TUNGraphNodeI(*args)) + def Next(self): + """ + Next(TUNGraphNodeI self) -> TUNGraphNodeI + + Parameters: + self: TUNGraphNodeI * + + """ + return _snap.TUNGraphNodeI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool + + Parameters: + NodeI: TUNGraphNodeI const & + + """ + return _snap.TUNGraphNodeI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool + + Parameters: + NodeI: TUNGraphNodeI const & + + """ + return _snap.TUNGraphNodeI___eq__(self, *args) + + def GetId(self): + """ + GetId(TUNGraphNodeI self) -> int + + Parameters: + self: TUNGraphNodeI const * + + """ + return _snap.TUNGraphNodeI_GetId(self) + + def GetDeg(self): + """ + GetDeg(TUNGraphNodeI self) -> int + + Parameters: + self: TUNGraphNodeI const * + + """ + return _snap.TUNGraphNodeI_GetDeg(self) + + def GetInDeg(self): + """ + GetInDeg(TUNGraphNodeI self) -> int + + Parameters: + self: TUNGraphNodeI const * + + """ + return _snap.TUNGraphNodeI_GetInDeg(self) + + def GetOutDeg(self): + """ + GetOutDeg(TUNGraphNodeI self) -> int + + Parameters: + self: TUNGraphNodeI const * + + """ + return _snap.TUNGraphNodeI_GetOutDeg(self) + + def GetInNId(self, *args): + """ + GetInNId(TUNGraphNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TUNGraphNodeI_GetInNId(self, *args) + + def GetOutNId(self, *args): + """ + GetOutNId(TUNGraphNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TUNGraphNodeI_GetOutNId(self, *args) + + def GetNbrNId(self, *args): + """ + GetNbrNId(TUNGraphNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TUNGraphNodeI_GetNbrNId(self, *args) + + def IsInNId(self, *args): + """ + IsInNId(TUNGraphNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TUNGraphNodeI_IsInNId(self, *args) + + def IsOutNId(self, *args): + """ + IsOutNId(TUNGraphNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TUNGraphNodeI_IsOutNId(self, *args) + + def IsNbrNId(self, *args): + """ + IsNbrNId(TUNGraphNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TUNGraphNodeI_IsNbrNId(self, *args) + + __swig_destroy__ = _snap.delete_TUNGraphNodeI +TUNGraphNodeI.Next = new_instancemethod(_snap.TUNGraphNodeI_Next,None,TUNGraphNodeI) +TUNGraphNodeI.__lt__ = new_instancemethod(_snap.TUNGraphNodeI___lt__,None,TUNGraphNodeI) +TUNGraphNodeI.__eq__ = new_instancemethod(_snap.TUNGraphNodeI___eq__,None,TUNGraphNodeI) +TUNGraphNodeI.GetId = new_instancemethod(_snap.TUNGraphNodeI_GetId,None,TUNGraphNodeI) +TUNGraphNodeI.GetDeg = new_instancemethod(_snap.TUNGraphNodeI_GetDeg,None,TUNGraphNodeI) +TUNGraphNodeI.GetInDeg = new_instancemethod(_snap.TUNGraphNodeI_GetInDeg,None,TUNGraphNodeI) +TUNGraphNodeI.GetOutDeg = new_instancemethod(_snap.TUNGraphNodeI_GetOutDeg,None,TUNGraphNodeI) +TUNGraphNodeI.GetInNId = new_instancemethod(_snap.TUNGraphNodeI_GetInNId,None,TUNGraphNodeI) +TUNGraphNodeI.GetOutNId = new_instancemethod(_snap.TUNGraphNodeI_GetOutNId,None,TUNGraphNodeI) +TUNGraphNodeI.GetNbrNId = new_instancemethod(_snap.TUNGraphNodeI_GetNbrNId,None,TUNGraphNodeI) +TUNGraphNodeI.IsInNId = new_instancemethod(_snap.TUNGraphNodeI_IsInNId,None,TUNGraphNodeI) +TUNGraphNodeI.IsOutNId = new_instancemethod(_snap.TUNGraphNodeI_IsOutNId,None,TUNGraphNodeI) +TUNGraphNodeI.IsNbrNId = new_instancemethod(_snap.TUNGraphNodeI_IsNbrNId,None,TUNGraphNodeI) +TUNGraphNodeI_swigregister = _snap.TUNGraphNodeI_swigregister +TUNGraphNodeI_swigregister(TUNGraphNodeI) + +class TUNGraphEdgeI(object): + """Proxy of C++ TUNGraphEdgeI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TUNGraphEdgeI self) -> TUNGraphEdgeI + __init__(TUNGraphEdgeI self, TUNGraph::TEdgeI const & EdgeI) -> TUNGraphEdgeI + + Parameters: + EdgeI: TUNGraph::TEdgeI const & + + """ + _snap.TUNGraphEdgeI_swiginit(self,_snap.new_TUNGraphEdgeI(*args)) + def Next(self): + """ + Next(TUNGraphEdgeI self) -> TUNGraphEdgeI + + Parameters: + self: TUNGraphEdgeI * + + """ + return _snap.TUNGraphEdgeI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool + + Parameters: + EdgeI: TUNGraphEdgeI const & + + """ + return _snap.TUNGraphEdgeI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool + + Parameters: + EdgeI: TUNGraphEdgeI const & + + """ + return _snap.TUNGraphEdgeI___eq__(self, *args) + + def GetId(self): + """ + GetId(TUNGraphEdgeI self) -> int + + Parameters: + self: TUNGraphEdgeI const * + + """ + return _snap.TUNGraphEdgeI_GetId(self) + + def GetSrcNId(self): + """ + GetSrcNId(TUNGraphEdgeI self) -> int + + Parameters: + self: TUNGraphEdgeI const * + + """ + return _snap.TUNGraphEdgeI_GetSrcNId(self) + + def GetDstNId(self): + """ + GetDstNId(TUNGraphEdgeI self) -> int + + Parameters: + self: TUNGraphEdgeI const * + + """ + return _snap.TUNGraphEdgeI_GetDstNId(self) + + __swig_destroy__ = _snap.delete_TUNGraphEdgeI +TUNGraphEdgeI.Next = new_instancemethod(_snap.TUNGraphEdgeI_Next,None,TUNGraphEdgeI) +TUNGraphEdgeI.__lt__ = new_instancemethod(_snap.TUNGraphEdgeI___lt__,None,TUNGraphEdgeI) +TUNGraphEdgeI.__eq__ = new_instancemethod(_snap.TUNGraphEdgeI___eq__,None,TUNGraphEdgeI) +TUNGraphEdgeI.GetId = new_instancemethod(_snap.TUNGraphEdgeI_GetId,None,TUNGraphEdgeI) +TUNGraphEdgeI.GetSrcNId = new_instancemethod(_snap.TUNGraphEdgeI_GetSrcNId,None,TUNGraphEdgeI) +TUNGraphEdgeI.GetDstNId = new_instancemethod(_snap.TUNGraphEdgeI_GetDstNId,None,TUNGraphEdgeI) +TUNGraphEdgeI_swigregister = _snap.TUNGraphEdgeI_swigregister +TUNGraphEdgeI_swigregister(TUNGraphEdgeI) + +class TNEANetNodeI(object): + """Proxy of C++ TNEANetNodeI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNEANetNodeI self) -> TNEANetNodeI + __init__(TNEANetNodeI self, TNEANet::TNodeI const & NodeI) -> TNEANetNodeI + + Parameters: + NodeI: TNEANet::TNodeI const & + + """ + _snap.TNEANetNodeI_swiginit(self,_snap.new_TNEANetNodeI(*args)) + def Next(self): + """ + Next(TNEANetNodeI self) -> TNEANetNodeI + + Parameters: + self: TNEANetNodeI * + + """ + return _snap.TNEANetNodeI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool + + Parameters: + NodeI: TNEANetNodeI const & + + """ + return _snap.TNEANetNodeI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool + + Parameters: + NodeI: TNEANetNodeI const & + + """ + return _snap.TNEANetNodeI___eq__(self, *args) + + def GetId(self): + """ + GetId(TNEANetNodeI self) -> int + + Parameters: + self: TNEANetNodeI const * + + """ + return _snap.TNEANetNodeI_GetId(self) + + def GetDeg(self): + """ + GetDeg(TNEANetNodeI self) -> int + + Parameters: + self: TNEANetNodeI const * + + """ + return _snap.TNEANetNodeI_GetDeg(self) + + def GetInDeg(self): + """ + GetInDeg(TNEANetNodeI self) -> int + + Parameters: + self: TNEANetNodeI const * + + """ + return _snap.TNEANetNodeI_GetInDeg(self) + + def GetOutDeg(self): + """ + GetOutDeg(TNEANetNodeI self) -> int + + Parameters: + self: TNEANetNodeI const * + + """ + return _snap.TNEANetNodeI_GetOutDeg(self) + + def GetInNId(self, *args): + """ + GetInNId(TNEANetNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TNEANetNodeI_GetInNId(self, *args) + + def GetOutNId(self, *args): + """ + GetOutNId(TNEANetNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TNEANetNodeI_GetOutNId(self, *args) + + def GetNbrNId(self, *args): + """ + GetNbrNId(TNEANetNodeI self, int const & NodeN) -> int + + Parameters: + NodeN: int const & + + """ + return _snap.TNEANetNodeI_GetNbrNId(self, *args) + + def IsInNId(self, *args): + """ + IsInNId(TNEANetNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNEANetNodeI_IsInNId(self, *args) + + def IsOutNId(self, *args): + """ + IsOutNId(TNEANetNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNEANetNodeI_IsOutNId(self, *args) + + def IsNbrNId(self, *args): + """ + IsNbrNId(TNEANetNodeI self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNEANetNodeI_IsNbrNId(self, *args) + + __swig_destroy__ = _snap.delete_TNEANetNodeI +TNEANetNodeI.Next = new_instancemethod(_snap.TNEANetNodeI_Next,None,TNEANetNodeI) +TNEANetNodeI.__lt__ = new_instancemethod(_snap.TNEANetNodeI___lt__,None,TNEANetNodeI) +TNEANetNodeI.__eq__ = new_instancemethod(_snap.TNEANetNodeI___eq__,None,TNEANetNodeI) +TNEANetNodeI.GetId = new_instancemethod(_snap.TNEANetNodeI_GetId,None,TNEANetNodeI) +TNEANetNodeI.GetDeg = new_instancemethod(_snap.TNEANetNodeI_GetDeg,None,TNEANetNodeI) +TNEANetNodeI.GetInDeg = new_instancemethod(_snap.TNEANetNodeI_GetInDeg,None,TNEANetNodeI) +TNEANetNodeI.GetOutDeg = new_instancemethod(_snap.TNEANetNodeI_GetOutDeg,None,TNEANetNodeI) +TNEANetNodeI.GetInNId = new_instancemethod(_snap.TNEANetNodeI_GetInNId,None,TNEANetNodeI) +TNEANetNodeI.GetOutNId = new_instancemethod(_snap.TNEANetNodeI_GetOutNId,None,TNEANetNodeI) +TNEANetNodeI.GetNbrNId = new_instancemethod(_snap.TNEANetNodeI_GetNbrNId,None,TNEANetNodeI) +TNEANetNodeI.IsInNId = new_instancemethod(_snap.TNEANetNodeI_IsInNId,None,TNEANetNodeI) +TNEANetNodeI.IsOutNId = new_instancemethod(_snap.TNEANetNodeI_IsOutNId,None,TNEANetNodeI) +TNEANetNodeI.IsNbrNId = new_instancemethod(_snap.TNEANetNodeI_IsNbrNId,None,TNEANetNodeI) +TNEANetNodeI_swigregister = _snap.TNEANetNodeI_swigregister +TNEANetNodeI_swigregister(TNEANetNodeI) + +class TNEANetEdgeI(object): + """Proxy of C++ TNEANetEdgeI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNEANetEdgeI self) -> TNEANetEdgeI + __init__(TNEANetEdgeI self, TNEANet::TEdgeI const & EdgeI) -> TNEANetEdgeI + + Parameters: + EdgeI: TNEANet::TEdgeI const & + + """ + _snap.TNEANetEdgeI_swiginit(self,_snap.new_TNEANetEdgeI(*args)) + def Next(self): + """ + Next(TNEANetEdgeI self) -> TNEANetEdgeI + + Parameters: + self: TNEANetEdgeI * + + """ + return _snap.TNEANetEdgeI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool + + Parameters: + EdgeI: TNEANetEdgeI const & + + """ + return _snap.TNEANetEdgeI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool + + Parameters: + EdgeI: TNEANetEdgeI const & + + """ + return _snap.TNEANetEdgeI___eq__(self, *args) + + def GetId(self): + """ + GetId(TNEANetEdgeI self) -> int + + Parameters: + self: TNEANetEdgeI const * + + """ + return _snap.TNEANetEdgeI_GetId(self) + + def GetSrcNId(self): + """ + GetSrcNId(TNEANetEdgeI self) -> int + + Parameters: + self: TNEANetEdgeI const * + + """ + return _snap.TNEANetEdgeI_GetSrcNId(self) + + def GetDstNId(self): + """ + GetDstNId(TNEANetEdgeI self) -> int + + Parameters: + self: TNEANetEdgeI const * + + """ + return _snap.TNEANetEdgeI_GetDstNId(self) + + __swig_destroy__ = _snap.delete_TNEANetEdgeI +TNEANetEdgeI.Next = new_instancemethod(_snap.TNEANetEdgeI_Next,None,TNEANetEdgeI) +TNEANetEdgeI.__lt__ = new_instancemethod(_snap.TNEANetEdgeI___lt__,None,TNEANetEdgeI) +TNEANetEdgeI.__eq__ = new_instancemethod(_snap.TNEANetEdgeI___eq__,None,TNEANetEdgeI) +TNEANetEdgeI.GetId = new_instancemethod(_snap.TNEANetEdgeI_GetId,None,TNEANetEdgeI) +TNEANetEdgeI.GetSrcNId = new_instancemethod(_snap.TNEANetEdgeI_GetSrcNId,None,TNEANetEdgeI) +TNEANetEdgeI.GetDstNId = new_instancemethod(_snap.TNEANetEdgeI_GetDstNId,None,TNEANetEdgeI) +TNEANetEdgeI_swigregister = _snap.TNEANetEdgeI_swigregister +TNEANetEdgeI_swigregister(TNEANetEdgeI) + +class TNEANetAIntI(object): + """Proxy of C++ TNEANetAIntI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNEANetAIntI self) -> TNEANetAIntI + __init__(TNEANetAIntI self, TIntVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAIntI + + Parameters: + HIter: TIntVecIter const & + attribute: TStr + isEdgeIter: bool + GraphPt: TNEANet const * + + __init__(TNEANetAIntI self, TNEANet::TAIntI const & I) -> TNEANetAIntI + + Parameters: + I: TNEANet::TAIntI const & + + """ + _snap.TNEANetAIntI_swiginit(self,_snap.new_TNEANetAIntI(*args)) + def Next(self): + """ + Next(TNEANetAIntI self) -> TNEANetAIntI + + Parameters: + self: TNEANetAIntI * + + """ + return _snap.TNEANetAIntI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TNEANetAIntI self, TNEANetAIntI I) -> bool + + Parameters: + I: TNEANetAIntI const & + + """ + return _snap.TNEANetAIntI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TNEANetAIntI self, TNEANetAIntI I) -> bool + + Parameters: + I: TNEANetAIntI const & + + """ + return _snap.TNEANetAIntI___eq__(self, *args) + + def GetDat(self): + """ + GetDat(TNEANetAIntI self) -> int + + Parameters: + self: TNEANetAIntI const * + + """ + return _snap.TNEANetAIntI_GetDat(self) + + def IsDeleted(self): + """ + IsDeleted(TNEANetAIntI self) -> bool + + Parameters: + self: TNEANetAIntI const * + + """ + return _snap.TNEANetAIntI_IsDeleted(self) + + __swig_destroy__ = _snap.delete_TNEANetAIntI +TNEANetAIntI.Next = new_instancemethod(_snap.TNEANetAIntI_Next,None,TNEANetAIntI) +TNEANetAIntI.__lt__ = new_instancemethod(_snap.TNEANetAIntI___lt__,None,TNEANetAIntI) +TNEANetAIntI.__eq__ = new_instancemethod(_snap.TNEANetAIntI___eq__,None,TNEANetAIntI) +TNEANetAIntI.GetDat = new_instancemethod(_snap.TNEANetAIntI_GetDat,None,TNEANetAIntI) +TNEANetAIntI.IsDeleted = new_instancemethod(_snap.TNEANetAIntI_IsDeleted,None,TNEANetAIntI) +TNEANetAIntI_swigregister = _snap.TNEANetAIntI_swigregister +TNEANetAIntI_swigregister(TNEANetAIntI) + +class TNEANetAStrI(object): + """Proxy of C++ TNEANetAStrI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNEANetAStrI self) -> TNEANetAStrI + __init__(TNEANetAStrI self, TStrVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAStrI + + Parameters: + HIter: TStrVecIter const & + attribute: TStr + isEdgeIter: bool + GraphPt: TNEANet const * + + __init__(TNEANetAStrI self, TNEANet::TAStrI const & I) -> TNEANetAStrI + + Parameters: + I: TNEANet::TAStrI const & + + """ + _snap.TNEANetAStrI_swiginit(self,_snap.new_TNEANetAStrI(*args)) + def Next(self): + """ + Next(TNEANetAStrI self) -> TNEANetAStrI + + Parameters: + self: TNEANetAStrI * + + """ + return _snap.TNEANetAStrI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TNEANetAStrI self, TNEANetAStrI I) -> bool + + Parameters: + I: TNEANetAStrI const & + + """ + return _snap.TNEANetAStrI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TNEANetAStrI self, TNEANetAStrI I) -> bool + + Parameters: + I: TNEANetAStrI const & + + """ + return _snap.TNEANetAStrI___eq__(self, *args) + + def GetDat(self): + """ + GetDat(TNEANetAStrI self) -> char * + + Parameters: + self: TNEANetAStrI const * + + """ + return _snap.TNEANetAStrI_GetDat(self) + + def IsDeleted(self): + """ + IsDeleted(TNEANetAStrI self) -> bool + + Parameters: + self: TNEANetAStrI const * + + """ + return _snap.TNEANetAStrI_IsDeleted(self) + + __swig_destroy__ = _snap.delete_TNEANetAStrI +TNEANetAStrI.Next = new_instancemethod(_snap.TNEANetAStrI_Next,None,TNEANetAStrI) +TNEANetAStrI.__lt__ = new_instancemethod(_snap.TNEANetAStrI___lt__,None,TNEANetAStrI) +TNEANetAStrI.__eq__ = new_instancemethod(_snap.TNEANetAStrI___eq__,None,TNEANetAStrI) +TNEANetAStrI.GetDat = new_instancemethod(_snap.TNEANetAStrI_GetDat,None,TNEANetAStrI) +TNEANetAStrI.IsDeleted = new_instancemethod(_snap.TNEANetAStrI_IsDeleted,None,TNEANetAStrI) +TNEANetAStrI_swigregister = _snap.TNEANetAStrI_swigregister +TNEANetAStrI_swigregister(TNEANetAStrI) + +class TNEANetAFltI(object): + """Proxy of C++ TNEANetAFltI class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNEANetAFltI self) -> TNEANetAFltI + __init__(TNEANetAFltI self, TFltVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt) -> TNEANetAFltI + + Parameters: + HIter: TFltVecIter const & + attribute: TStr + isEdgeIter: bool + GraphPt: TNEANet const * + + __init__(TNEANetAFltI self, TNEANet::TAFltI const & I) -> TNEANetAFltI + + Parameters: + I: TNEANet::TAFltI const & + + """ + _snap.TNEANetAFltI_swiginit(self,_snap.new_TNEANetAFltI(*args)) + def Next(self): + """ + Next(TNEANetAFltI self) -> TNEANetAFltI + + Parameters: + self: TNEANetAFltI * + + """ + return _snap.TNEANetAFltI_Next(self) + + def __lt__(self, *args): + """ + __lt__(TNEANetAFltI self, TNEANetAFltI I) -> bool + + Parameters: + I: TNEANetAFltI const & + + """ + return _snap.TNEANetAFltI___lt__(self, *args) + + def __eq__(self, *args): + """ + __eq__(TNEANetAFltI self, TNEANetAFltI I) -> bool + + Parameters: + I: TNEANetAFltI const & + + """ + return _snap.TNEANetAFltI___eq__(self, *args) + + def GetDat(self): + """ + GetDat(TNEANetAFltI self) -> double + + Parameters: + self: TNEANetAFltI const * + + """ + return _snap.TNEANetAFltI_GetDat(self) + + def IsDeleted(self): + """ + IsDeleted(TNEANetAFltI self) -> bool + + Parameters: + self: TNEANetAFltI const * + + """ + return _snap.TNEANetAFltI_IsDeleted(self) + + __swig_destroy__ = _snap.delete_TNEANetAFltI +TNEANetAFltI.Next = new_instancemethod(_snap.TNEANetAFltI_Next,None,TNEANetAFltI) +TNEANetAFltI.__lt__ = new_instancemethod(_snap.TNEANetAFltI___lt__,None,TNEANetAFltI) +TNEANetAFltI.__eq__ = new_instancemethod(_snap.TNEANetAFltI___eq__,None,TNEANetAFltI) +TNEANetAFltI.GetDat = new_instancemethod(_snap.TNEANetAFltI_GetDat,None,TNEANetAFltI) +TNEANetAFltI.IsDeleted = new_instancemethod(_snap.TNEANetAFltI_IsDeleted,None,TNEANetAFltI) +TNEANetAFltI_swigregister = _snap.TNEANetAFltI_swigregister +TNEANetAFltI_swigregister(TNEANetAFltI) + + +def TPrGraph(*args): + """ + TPrGraph(PUNGraph G) -> TUNGraph + + Parameters: + G: PUNGraph + + """ + return _snap.TPrGraph(*args) + +def accept_array(*args): + """ + accept_array(int [] array) -> int + + Parameters: + array: int [] + + """ + return _snap.accept_array(*args) + +def print_array(*args): + """ + print_array(int * x, int length) + + Parameters: + x: int * + length: int + + """ + return _snap.print_array(*args) + +def PyTFltV(*args): + """ + PyTFltV(double [10] x) -> TFltV + + Parameters: + x: double [10] + + """ + return _snap.PyTFltV(*args) + +def PyToTIntV(*args): + """ + PyToTIntV(int * array) -> TIntV + + Parameters: + array: int * + + """ + return _snap.PyToTIntV(*args) + +def count(*args): + """ + count(char * str, char c) -> int + + Parameters: + str: char * + c: char + + """ + return _snap.count(*args) + +def TIntVToPy(*args): + """ + TIntVToPy(TIntV originalList) + + Parameters: + originalList: TIntV + + """ + return _snap.TIntVToPy(*args) +class TNEANet(object): + """Proxy of C++ TNEANet class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args): + """ + __init__(TNEANet self) -> TNEANet + __init__(TNEANet self, int const & Nodes, int const & Edges) -> TNEANet + + Parameters: + Nodes: int const & + Edges: int const & + + __init__(TNEANet self, TNEANet Graph) -> TNEANet + + Parameters: + Graph: TNEANet const & + + __init__(TNEANet self, TSIn SIn) -> TNEANet + + Parameters: + SIn: TSIn & + + """ + _snap.TNEANet_swiginit(self,_snap.new_TNEANet(*args)) + def Save(self, *args): + """ + Save(TNEANet self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.TNEANet_Save(self, *args) + + def New(*args): + """ + New() -> PNEANet + New(int const & Nodes, int const & Edges) -> PNEANet + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNEANet_New(*args) + + New = staticmethod(New) + def Load(*args): + """ + Load(TSIn SIn) -> PNEANet + + Parameters: + SIn: TSIn & + + """ + return _snap.TNEANet_Load(*args) + + Load = staticmethod(Load) + def HasFlag(self, *args): + """ + HasFlag(TNEANet self, TGraphFlag const & Flag) -> bool + + Parameters: + Flag: TGraphFlag const & + + """ + return _snap.TNEANet_HasFlag(self, *args) + + def GetNodes(self): + """ + GetNodes(TNEANet self) -> int + + Parameters: + self: TNEANet const * + + """ + return _snap.TNEANet_GetNodes(self) + + def AddNode(self, *args): + """ + AddNode(TNEANet self, int NId=-1) -> int + + Parameters: + NId: int + + AddNode(TNEANet self) -> int + AddNode(TNEANet self, TNEANet::TNodeI const & NodeId) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + + """ + return _snap.TNEANet_AddNode(self, *args) + + def DelNode(self, *args): + """ + DelNode(TNEANet self, int const & NId) + + Parameters: + NId: int const & + + DelNode(TNEANet self, TNEANet::TNode const & NodeI) + + Parameters: + NodeI: TNEANet::TNode const & + + """ + return _snap.TNEANet_DelNode(self, *args) + + def IsNode(self, *args): + """ + IsNode(TNEANet self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.TNEANet_IsNode(self, *args) + + def GetNI(self, *args): + """ + GetNI(TNEANet self, int const & NId) -> TNEANet::TNodeI + + Parameters: + NId: int const & + + """ + return _snap.TNEANet_GetNI(self, *args) + + def GetNAIntI(self, *args): + """ + GetNAIntI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + NId: int const & + + """ + return _snap.TNEANet_GetNAIntI(self, *args) + + def GetNAStrI(self, *args): + """ + GetNAStrI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + NId: int const & + + """ + return _snap.TNEANet_GetNAStrI(self, *args) + + def GetNAFltI(self, *args): + """ + GetNAFltI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + NId: int const & + + """ + return _snap.TNEANet_GetNAFltI(self, *args) + + def AttrNameNI(self, *args): + """ + AttrNameNI(TNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + AttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_AttrNameNI(self, *args) + + def AttrValueNI(self, *args): + """ + AttrValueNI(TNEANet self, TInt NId, TStrV Values) + + Parameters: + NId: TInt const & + Values: TStrV & + + AttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.TNEANet_AttrValueNI(self, *args) + + def IntAttrNameNI(self, *args): + """ + IntAttrNameNI(TNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + IntAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_IntAttrNameNI(self, *args) + + def IntAttrValueNI(self, *args): + """ + IntAttrValueNI(TNEANet self, TInt NId, TIntV Values) + + Parameters: + NId: TInt const & + Values: TIntV & + + IntAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TIntV & + + """ + return _snap.TNEANet_IntAttrValueNI(self, *args) + + def StrAttrNameNI(self, *args): + """ + StrAttrNameNI(TNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + StrAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_StrAttrNameNI(self, *args) + + def StrAttrValueNI(self, *args): + """ + StrAttrValueNI(TNEANet self, TInt NId, TStrV Values) + + Parameters: + NId: TInt const & + Values: TStrV & + + StrAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.TNEANet_StrAttrValueNI(self, *args) + + def FltAttrNameNI(self, *args): + """ + FltAttrNameNI(TNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + FltAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_FltAttrNameNI(self, *args) + + def FltAttrValueNI(self, *args): + """ + FltAttrValueNI(TNEANet self, TInt NId, TFltV & Values) + + Parameters: + NId: TInt const & + Values: TFltV & + + FltAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TFltV & + + """ + return _snap.TNEANet_FltAttrValueNI(self, *args) + + def AttrNameEI(self, *args): + """ + AttrNameEI(TNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + AttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_AttrNameEI(self, *args) + + def AttrValueEI(self, *args): + """ + AttrValueEI(TNEANet self, TInt EId, TStrV Values) + + Parameters: + EId: TInt const & + Values: TStrV & + + AttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.TNEANet_AttrValueEI(self, *args) + + def IntAttrNameEI(self, *args): + """ + IntAttrNameEI(TNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + IntAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_IntAttrNameEI(self, *args) + + def IntAttrValueEI(self, *args): + """ + IntAttrValueEI(TNEANet self, TInt EId, TIntV Values) + + Parameters: + EId: TInt const & + Values: TIntV & + + IntAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TIntV & + + """ + return _snap.TNEANet_IntAttrValueEI(self, *args) + + def StrAttrNameEI(self, *args): + """ + StrAttrNameEI(TNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + StrAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_StrAttrNameEI(self, *args) + + def StrAttrValueEI(self, *args): + """ + StrAttrValueEI(TNEANet self, TInt EId, TStrV Values) + + Parameters: + EId: TInt const & + Values: TStrV & + + StrAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.TNEANet_StrAttrValueEI(self, *args) + + def FltAttrNameEI(self, *args): + """ + FltAttrNameEI(TNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + FltAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.TNEANet_FltAttrNameEI(self, *args) + + def FltAttrValueEI(self, *args): + """ + FltAttrValueEI(TNEANet self, TInt EId, TFltV & Values) + + Parameters: + EId: TInt const & + Values: TFltV & + + FltAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TFltV & + + """ + return _snap.TNEANet_FltAttrValueEI(self, *args) + + def GetEAIntI(self, *args): + """ + GetEAIntI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + EId: int const & + + """ + return _snap.TNEANet_GetEAIntI(self, *args) + + def GetEAStrI(self, *args): + """ + GetEAStrI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + EId: int const & + + """ + return _snap.TNEANet_GetEAStrI(self, *args) + + def GetEAFltI(self, *args): + """ + GetEAFltI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + EId: int const & + + """ + return _snap.TNEANet_GetEAFltI(self, *args) + + def GetMxNId(self): + """ + GetMxNId(TNEANet self) -> int + + Parameters: + self: TNEANet const * + + """ + return _snap.TNEANet_GetMxNId(self) + + def GetEdges(self): + """ + GetEdges(TNEANet self) -> int + + Parameters: + self: TNEANet const * + + """ + return _snap.TNEANet_GetEdges(self) + + def AddEdge(self, *args): + """ + AddEdge(TNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int + + AddEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + AddEdge(TNEANet self, TNEANet::TEdgeI const & EdgeI) -> int + + Parameters: + EdgeI: TNEANet::TEdgeI const & + + """ + return _snap.TNEANet_AddEdge(self, *args) + + def DelEdge(self, *args): + """ + DelEdge(TNEANet self, int const & EId) + + Parameters: + EId: int const & + + DelEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + DelEdge(TNEANet self, int const & SrcNId, int const & DstNId) + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNEANet_DelEdge(self, *args) + + def IsEdge(self, *args): + """ + IsEdge(TNEANet self, int const & EId) -> bool + + Parameters: + EId: int const & + + IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + IsEdge(TNEANet self, int const & SrcNId, int const & DstNId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + + IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int & + IsDir: bool const & + + IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int & + + """ + return _snap.TNEANet_IsEdge(self, *args) + + def GetEId(self, *args): + """ + GetEId(TNEANet self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNEANet_GetEId(self, *args) + + def GetEI(self, *args): + """ + GetEI(TNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.TNEANet_GetEI(self, *args) + + def GetRndNId(self, *args): + """ + GetRndNId(TNEANet self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndNId(TNEANet self) -> int + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_GetRndNId(self, *args) + + def GetRndNI(self, *args): + """ + GetRndNI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI + + Parameters: + Rnd: TRnd & + + GetRndNI(TNEANet self) -> TNEANet::TNodeI + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_GetRndNI(self, *args) + + def GetRndEId(self, *args): + """ + GetRndEId(TNEANet self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndEId(TNEANet self) -> int + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_GetRndEId(self, *args) + + def GetRndEI(self, *args): + """ + GetRndEI(TNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI + + Parameters: + Rnd: TRnd & + + GetRndEI(TNEANet self) -> TNEANet::TEdgeI + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_GetRndEI(self, *args) + + def GetNIdV(self, *args): + """ + GetNIdV(TNEANet self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.TNEANet_GetNIdV(self, *args) + + def GetEIdV(self, *args): + """ + GetEIdV(TNEANet self, TIntV EIdV) + + Parameters: + EIdV: TIntV & + + """ + return _snap.TNEANet_GetEIdV(self, *args) + + def Empty(self): + """ + Empty(TNEANet self) -> bool + + Parameters: + self: TNEANet const * + + """ + return _snap.TNEANet_Empty(self) + + def Clr(self): + """ + Clr(TNEANet self) + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_Clr(self) + + def Reserve(self, *args): + """ + Reserve(TNEANet self, int const & Nodes, int const & Edges) + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNEANet_Reserve(self, *args) + + def Defrag(self, OnlyNodeLinks=False): + """ + Defrag(TNEANet self, bool const & OnlyNodeLinks=False) + + Parameters: + OnlyNodeLinks: bool const & + + Defrag(TNEANet self) + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_Defrag(self, OnlyNodeLinks) + + def IsOk(self, ThrowExcept=True): + """ + IsOk(TNEANet self, bool const & ThrowExcept=True) -> bool + + Parameters: + ThrowExcept: bool const & + + IsOk(TNEANet self) -> bool + + Parameters: + self: TNEANet const * + + """ + return _snap.TNEANet_IsOk(self, ThrowExcept) + + def Dump(self, *args): + """ + Dump(TNEANet self, FILE * OutF=stdout) + + Parameters: + OutF: FILE * + + Dump(TNEANet self) + + Parameters: + self: TNEANet const * + + """ + return _snap.TNEANet_Dump(self, *args) + + def AddIntAttrDatN(self, *args): + """ + AddIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + value: TInt const & + attr: TStr const & + + AddIntAttrDatN(TNEANet self, int const & NId, TInt value, TStr attr) -> int + + Parameters: + NId: int const & + value: TInt const & + attr: TStr const & + + """ + return _snap.TNEANet_AddIntAttrDatN(self, *args) + + def AddStrAttrDatN(self, *args): + """ + AddStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + value: TStr const & + attr: TStr const & + + AddStrAttrDatN(TNEANet self, int const & NId, TStr value, TStr attr) -> int + + Parameters: + NId: int const & + value: TStr const & + attr: TStr const & + + """ + return _snap.TNEANet_AddStrAttrDatN(self, *args) + + def AddFltAttrDatN(self, *args): + """ + AddFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + value: TFlt const & + attr: TStr const & + + AddFltAttrDatN(TNEANet self, int const & NId, TFlt value, TStr attr) -> int + + Parameters: + NId: int const & + value: TFlt const & + attr: TStr const & + + """ + return _snap.TNEANet_AddFltAttrDatN(self, *args) + + def AddIntAttrDatE(self, *args): + """ + AddIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + value: TInt const & + attr: TStr const & + + AddIntAttrDatE(TNEANet self, int const & EId, TInt value, TStr attr) -> int + + Parameters: + EId: int const & + value: TInt const & + attr: TStr const & + + """ + return _snap.TNEANet_AddIntAttrDatE(self, *args) + + def AddStrAttrDatE(self, *args): + """ + AddStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + value: TStr const & + attr: TStr const & + + AddStrAttrDatE(TNEANet self, int const & EId, TStr value, TStr attr) -> int + + Parameters: + EId: int const & + value: TStr const & + attr: TStr const & + + """ + return _snap.TNEANet_AddStrAttrDatE(self, *args) + + def AddFltAttrDatE(self, *args): + """ + AddFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + value: TFlt const & + attr: TStr const & + + AddFltAttrDatE(TNEANet self, int const & EId, TFlt value, TStr attr) -> int + + Parameters: + EId: int const & + value: TFlt const & + attr: TStr const & + + """ + return _snap.TNEANet_AddFltAttrDatE(self, *args) + + def GetIntAttrDatN(self, *args): + """ + GetIntAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + GetIntAttrDatN(TNEANet self, int const & NId, TStr attr) -> TInt + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_GetIntAttrDatN(self, *args) + + def GetStrAttrDatN(self, *args): + """ + GetStrAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + GetStrAttrDatN(TNEANet self, int const & NId, TStr attr) -> TStr + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_GetStrAttrDatN(self, *args) + + def GetFltAttrDatN(self, *args): + """ + GetFltAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + GetFltAttrDatN(TNEANet self, int const & NId, TStr attr) -> TFlt + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_GetFltAttrDatN(self, *args) + + def GetIntAttrDatE(self, *args): + """ + GetIntAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + GetIntAttrDatE(TNEANet self, int const & EId, TStr attr) -> TInt + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_GetIntAttrDatE(self, *args) + + def GetStrAttrDatE(self, *args): + """ + GetStrAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + GetStrAttrDatE(TNEANet self, int const & EId, TStr attr) -> TStr + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_GetStrAttrDatE(self, *args) + + def GetFltAttrDatE(self, *args): + """ + GetFltAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + GetFltAttrDatE(TNEANet self, int const & EId, TStr attr) -> TFlt + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_GetFltAttrDatE(self, *args) + + def DelAttrDatN(self, *args): + """ + DelAttrDatN(TNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + DelAttrDatN(TNEANet self, int const & NId, TStr attr) -> int + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_DelAttrDatN(self, *args) + + def DelAttrDatE(self, *args): + """ + DelAttrDatE(TNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + DelAttrDatE(TNEANet self, int const & EId, TStr attr) -> int + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.TNEANet_DelAttrDatE(self, *args) + + def AddIntAttrN(self, *args): + """ + AddIntAttrN(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TInt + + AddIntAttrN(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_AddIntAttrN(self, *args) + + def AddStrAttrN(self, *args): + """ + AddStrAttrN(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int + + Parameters: + attr: TStr const & + defaultValue: TStr + + AddStrAttrN(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_AddStrAttrN(self, *args) + + def AddFltAttrN(self, *args): + """ + AddFltAttrN(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TFlt + + AddFltAttrN(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_AddFltAttrN(self, *args) + + def AddIntAttrE(self, *args): + """ + AddIntAttrE(TNEANet self, TStr attr, TInt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TInt + + AddIntAttrE(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_AddIntAttrE(self, *args) + + def AddStrAttrE(self, *args): + """ + AddStrAttrE(TNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int + + Parameters: + attr: TStr const & + defaultValue: TStr + + AddStrAttrE(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_AddStrAttrE(self, *args) + + def AddFltAttrE(self, *args): + """ + AddFltAttrE(TNEANet self, TStr attr, TFlt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TFlt + + AddFltAttrE(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_AddFltAttrE(self, *args) + + def DelAttrN(self, *args): + """ + DelAttrN(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_DelAttrN(self, *args) + + def DelAttrE(self, *args): + """ + DelAttrE(TNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_DelAttrE(self, *args) + + def NodeAttrIsDeleted(self, *args): + """ + NodeAttrIsDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_NodeAttrIsDeleted(self, *args) + + def NodeAttrIsIntDeleted(self, *args): + """ + NodeAttrIsIntDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_NodeAttrIsIntDeleted(self, *args) + + def NodeAttrIsStrDeleted(self, *args): + """ + NodeAttrIsStrDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_NodeAttrIsStrDeleted(self, *args) + + def NodeAttrIsFltDeleted(self, *args): + """ + NodeAttrIsFltDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_NodeAttrIsFltDeleted(self, *args) + + def EdgeAttrIsDeleted(self, *args): + """ + EdgeAttrIsDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_EdgeAttrIsDeleted(self, *args) + + def EdgeAttrIsIntDeleted(self, *args): + """ + EdgeAttrIsIntDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_EdgeAttrIsIntDeleted(self, *args) + + def EdgeAttrIsStrDeleted(self, *args): + """ + EdgeAttrIsStrDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_EdgeAttrIsStrDeleted(self, *args) + + def EdgeAttrIsFltDeleted(self, *args): + """ + EdgeAttrIsFltDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_EdgeAttrIsFltDeleted(self, *args) + + def GetNodeAttrValue(self, *args): + """ + GetNodeAttrValue(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_GetNodeAttrValue(self, *args) + + def GetEdgeAttrValue(self, *args): + """ + GetEdgeAttrValue(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.TNEANet_GetEdgeAttrValue(self, *args) + + def BegNI(self, *args): + """ + BegNI(TNEANet self) -> TNEANet::TNodeI + BegNI(TNEANet self) -> TNEANetNodeI + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_BegNI(self, *args) + + def EndNI(self, *args): + """ + EndNI(TNEANet self) -> TNEANet::TNodeI + EndNI(TNEANet self) -> TNEANetNodeI + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_EndNI(self, *args) + + def BegEI(self, *args): + """ + BegEI(TNEANet self) -> TNEANet::TEdgeI + BegEI(TNEANet self) -> TNEANetEdgeI + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_BegEI(self, *args) + + def EndEI(self, *args): + """ + EndEI(TNEANet self) -> TNEANet::TEdgeI + EndEI(TNEANet self) -> TNEANetEdgeI + + Parameters: + self: TNEANet * + + """ + return _snap.TNEANet_EndEI(self, *args) + + def BegNAIntI(self, *args): + """ + BegNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + BegNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_BegNAIntI(self, *args) + + def EndNAIntI(self, *args): + """ + EndNAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + EndNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_EndNAIntI(self, *args) + + def BegNAStrI(self, *args): + """ + BegNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + BegNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_BegNAStrI(self, *args) + + def EndNAStrI(self, *args): + """ + EndNAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + EndNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_EndNAStrI(self, *args) + + def BegNAFltI(self, *args): + """ + BegNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + BegNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_BegNAFltI(self, *args) + + def EndNAFltI(self, *args): + """ + EndNAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + EndNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_EndNAFltI(self, *args) + + def BegEAIntI(self, *args): + """ + BegEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + BegEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_BegEAIntI(self, *args) + + def EndEAIntI(self, *args): + """ + EndEAIntI(TNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + EndEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_EndEAIntI(self, *args) + + def BegEAStrI(self, *args): + """ + BegEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + BegEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_BegEAStrI(self, *args) + + def EndEAStrI(self, *args): + """ + EndEAStrI(TNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + EndEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_EndEAStrI(self, *args) + + def BegEAFltI(self, *args): + """ + BegEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + BegEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_BegEAFltI(self, *args) + + def EndEAFltI(self, *args): + """ + EndEAFltI(TNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + EndEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.TNEANet_EndEAFltI(self, *args) + + __swig_destroy__ = _snap.delete_TNEANet +TNEANet.Save = new_instancemethod(_snap.TNEANet_Save,None,TNEANet) +TNEANet.HasFlag = new_instancemethod(_snap.TNEANet_HasFlag,None,TNEANet) +TNEANet.GetNodes = new_instancemethod(_snap.TNEANet_GetNodes,None,TNEANet) +TNEANet.AddNode = new_instancemethod(_snap.TNEANet_AddNode,None,TNEANet) +TNEANet.DelNode = new_instancemethod(_snap.TNEANet_DelNode,None,TNEANet) +TNEANet.IsNode = new_instancemethod(_snap.TNEANet_IsNode,None,TNEANet) +TNEANet.GetNI = new_instancemethod(_snap.TNEANet_GetNI,None,TNEANet) +TNEANet.GetNAIntI = new_instancemethod(_snap.TNEANet_GetNAIntI,None,TNEANet) +TNEANet.GetNAStrI = new_instancemethod(_snap.TNEANet_GetNAStrI,None,TNEANet) +TNEANet.GetNAFltI = new_instancemethod(_snap.TNEANet_GetNAFltI,None,TNEANet) +TNEANet.AttrNameNI = new_instancemethod(_snap.TNEANet_AttrNameNI,None,TNEANet) +TNEANet.AttrValueNI = new_instancemethod(_snap.TNEANet_AttrValueNI,None,TNEANet) +TNEANet.IntAttrNameNI = new_instancemethod(_snap.TNEANet_IntAttrNameNI,None,TNEANet) +TNEANet.IntAttrValueNI = new_instancemethod(_snap.TNEANet_IntAttrValueNI,None,TNEANet) +TNEANet.StrAttrNameNI = new_instancemethod(_snap.TNEANet_StrAttrNameNI,None,TNEANet) +TNEANet.StrAttrValueNI = new_instancemethod(_snap.TNEANet_StrAttrValueNI,None,TNEANet) +TNEANet.FltAttrNameNI = new_instancemethod(_snap.TNEANet_FltAttrNameNI,None,TNEANet) +TNEANet.FltAttrValueNI = new_instancemethod(_snap.TNEANet_FltAttrValueNI,None,TNEANet) +TNEANet.AttrNameEI = new_instancemethod(_snap.TNEANet_AttrNameEI,None,TNEANet) +TNEANet.AttrValueEI = new_instancemethod(_snap.TNEANet_AttrValueEI,None,TNEANet) +TNEANet.IntAttrNameEI = new_instancemethod(_snap.TNEANet_IntAttrNameEI,None,TNEANet) +TNEANet.IntAttrValueEI = new_instancemethod(_snap.TNEANet_IntAttrValueEI,None,TNEANet) +TNEANet.StrAttrNameEI = new_instancemethod(_snap.TNEANet_StrAttrNameEI,None,TNEANet) +TNEANet.StrAttrValueEI = new_instancemethod(_snap.TNEANet_StrAttrValueEI,None,TNEANet) +TNEANet.FltAttrNameEI = new_instancemethod(_snap.TNEANet_FltAttrNameEI,None,TNEANet) +TNEANet.FltAttrValueEI = new_instancemethod(_snap.TNEANet_FltAttrValueEI,None,TNEANet) +TNEANet.GetEAIntI = new_instancemethod(_snap.TNEANet_GetEAIntI,None,TNEANet) +TNEANet.GetEAStrI = new_instancemethod(_snap.TNEANet_GetEAStrI,None,TNEANet) +TNEANet.GetEAFltI = new_instancemethod(_snap.TNEANet_GetEAFltI,None,TNEANet) +TNEANet.GetMxNId = new_instancemethod(_snap.TNEANet_GetMxNId,None,TNEANet) +TNEANet.GetEdges = new_instancemethod(_snap.TNEANet_GetEdges,None,TNEANet) +TNEANet.AddEdge = new_instancemethod(_snap.TNEANet_AddEdge,None,TNEANet) +TNEANet.DelEdge = new_instancemethod(_snap.TNEANet_DelEdge,None,TNEANet) +TNEANet.IsEdge = new_instancemethod(_snap.TNEANet_IsEdge,None,TNEANet) +TNEANet.GetEId = new_instancemethod(_snap.TNEANet_GetEId,None,TNEANet) +TNEANet.GetEI = new_instancemethod(_snap.TNEANet_GetEI,None,TNEANet) +TNEANet.GetRndNId = new_instancemethod(_snap.TNEANet_GetRndNId,None,TNEANet) +TNEANet.GetRndNI = new_instancemethod(_snap.TNEANet_GetRndNI,None,TNEANet) +TNEANet.GetRndEId = new_instancemethod(_snap.TNEANet_GetRndEId,None,TNEANet) +TNEANet.GetRndEI = new_instancemethod(_snap.TNEANet_GetRndEI,None,TNEANet) +TNEANet.GetNIdV = new_instancemethod(_snap.TNEANet_GetNIdV,None,TNEANet) +TNEANet.GetEIdV = new_instancemethod(_snap.TNEANet_GetEIdV,None,TNEANet) +TNEANet.Empty = new_instancemethod(_snap.TNEANet_Empty,None,TNEANet) +TNEANet.Clr = new_instancemethod(_snap.TNEANet_Clr,None,TNEANet) +TNEANet.Reserve = new_instancemethod(_snap.TNEANet_Reserve,None,TNEANet) +TNEANet.Defrag = new_instancemethod(_snap.TNEANet_Defrag,None,TNEANet) +TNEANet.IsOk = new_instancemethod(_snap.TNEANet_IsOk,None,TNEANet) +TNEANet.Dump = new_instancemethod(_snap.TNEANet_Dump,None,TNEANet) +TNEANet.AddIntAttrDatN = new_instancemethod(_snap.TNEANet_AddIntAttrDatN,None,TNEANet) +TNEANet.AddStrAttrDatN = new_instancemethod(_snap.TNEANet_AddStrAttrDatN,None,TNEANet) +TNEANet.AddFltAttrDatN = new_instancemethod(_snap.TNEANet_AddFltAttrDatN,None,TNEANet) +TNEANet.AddIntAttrDatE = new_instancemethod(_snap.TNEANet_AddIntAttrDatE,None,TNEANet) +TNEANet.AddStrAttrDatE = new_instancemethod(_snap.TNEANet_AddStrAttrDatE,None,TNEANet) +TNEANet.AddFltAttrDatE = new_instancemethod(_snap.TNEANet_AddFltAttrDatE,None,TNEANet) +TNEANet.GetIntAttrDatN = new_instancemethod(_snap.TNEANet_GetIntAttrDatN,None,TNEANet) +TNEANet.GetStrAttrDatN = new_instancemethod(_snap.TNEANet_GetStrAttrDatN,None,TNEANet) +TNEANet.GetFltAttrDatN = new_instancemethod(_snap.TNEANet_GetFltAttrDatN,None,TNEANet) +TNEANet.GetIntAttrDatE = new_instancemethod(_snap.TNEANet_GetIntAttrDatE,None,TNEANet) +TNEANet.GetStrAttrDatE = new_instancemethod(_snap.TNEANet_GetStrAttrDatE,None,TNEANet) +TNEANet.GetFltAttrDatE = new_instancemethod(_snap.TNEANet_GetFltAttrDatE,None,TNEANet) +TNEANet.DelAttrDatN = new_instancemethod(_snap.TNEANet_DelAttrDatN,None,TNEANet) +TNEANet.DelAttrDatE = new_instancemethod(_snap.TNEANet_DelAttrDatE,None,TNEANet) +TNEANet.AddIntAttrN = new_instancemethod(_snap.TNEANet_AddIntAttrN,None,TNEANet) +TNEANet.AddStrAttrN = new_instancemethod(_snap.TNEANet_AddStrAttrN,None,TNEANet) +TNEANet.AddFltAttrN = new_instancemethod(_snap.TNEANet_AddFltAttrN,None,TNEANet) +TNEANet.AddIntAttrE = new_instancemethod(_snap.TNEANet_AddIntAttrE,None,TNEANet) +TNEANet.AddStrAttrE = new_instancemethod(_snap.TNEANet_AddStrAttrE,None,TNEANet) +TNEANet.AddFltAttrE = new_instancemethod(_snap.TNEANet_AddFltAttrE,None,TNEANet) +TNEANet.DelAttrN = new_instancemethod(_snap.TNEANet_DelAttrN,None,TNEANet) +TNEANet.DelAttrE = new_instancemethod(_snap.TNEANet_DelAttrE,None,TNEANet) +TNEANet.NodeAttrIsDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsDeleted,None,TNEANet) +TNEANet.NodeAttrIsIntDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsIntDeleted,None,TNEANet) +TNEANet.NodeAttrIsStrDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsStrDeleted,None,TNEANet) +TNEANet.NodeAttrIsFltDeleted = new_instancemethod(_snap.TNEANet_NodeAttrIsFltDeleted,None,TNEANet) +TNEANet.EdgeAttrIsDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsDeleted,None,TNEANet) +TNEANet.EdgeAttrIsIntDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsIntDeleted,None,TNEANet) +TNEANet.EdgeAttrIsStrDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsStrDeleted,None,TNEANet) +TNEANet.EdgeAttrIsFltDeleted = new_instancemethod(_snap.TNEANet_EdgeAttrIsFltDeleted,None,TNEANet) +TNEANet.GetNodeAttrValue = new_instancemethod(_snap.TNEANet_GetNodeAttrValue,None,TNEANet) +TNEANet.GetEdgeAttrValue = new_instancemethod(_snap.TNEANet_GetEdgeAttrValue,None,TNEANet) +TNEANet.BegNI = new_instancemethod(_snap.TNEANet_BegNI,None,TNEANet) +TNEANet.EndNI = new_instancemethod(_snap.TNEANet_EndNI,None,TNEANet) +TNEANet.BegEI = new_instancemethod(_snap.TNEANet_BegEI,None,TNEANet) +TNEANet.EndEI = new_instancemethod(_snap.TNEANet_EndEI,None,TNEANet) +TNEANet.BegNAIntI = new_instancemethod(_snap.TNEANet_BegNAIntI,None,TNEANet) +TNEANet.EndNAIntI = new_instancemethod(_snap.TNEANet_EndNAIntI,None,TNEANet) +TNEANet.BegNAStrI = new_instancemethod(_snap.TNEANet_BegNAStrI,None,TNEANet) +TNEANet.EndNAStrI = new_instancemethod(_snap.TNEANet_EndNAStrI,None,TNEANet) +TNEANet.BegNAFltI = new_instancemethod(_snap.TNEANet_BegNAFltI,None,TNEANet) +TNEANet.EndNAFltI = new_instancemethod(_snap.TNEANet_EndNAFltI,None,TNEANet) +TNEANet.BegEAIntI = new_instancemethod(_snap.TNEANet_BegEAIntI,None,TNEANet) +TNEANet.EndEAIntI = new_instancemethod(_snap.TNEANet_EndEAIntI,None,TNEANet) +TNEANet.BegEAStrI = new_instancemethod(_snap.TNEANet_BegEAStrI,None,TNEANet) +TNEANet.EndEAStrI = new_instancemethod(_snap.TNEANet_EndEAStrI,None,TNEANet) +TNEANet.BegEAFltI = new_instancemethod(_snap.TNEANet_BegEAFltI,None,TNEANet) +TNEANet.EndEAFltI = new_instancemethod(_snap.TNEANet_EndEAFltI,None,TNEANet) +TNEANet_swigregister = _snap.TNEANet_swigregister +TNEANet_swigregister(TNEANet) + +def TNEANet_New(*args): + """ + New() -> PNEANet + TNEANet_New(int const & Nodes, int const & Edges) -> PNEANet + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.TNEANet_New(*args) + +def TNEANet_Load(*args): + """ + TNEANet_Load(TSIn SIn) -> PNEANet + + Parameters: + SIn: TSIn & + + """ + return _snap.TNEANet_Load(*args) + + +def PercentDegree(*args): + """ + PercentDegree(PNEANet Graph, int const Threshold=0) -> double + + Parameters: + Graph: TPt< TNEANet > const & + Threshold: int const + + PercentDegree(PNEANet Graph) -> double + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.PercentDegree(*args) + +def PercentMxWcc(*args): + """ + PercentMxWcc(PNEANet Graph) -> double + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.PercentMxWcc(*args) + +def PercentMxScc(*args): + """ + PercentMxScc(PNEANet Graph) -> double + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.PercentMxScc(*args) + +def LoadEdgeList(*args): + """ + LoadEdgeList(TStr InFNm, int const & SrcColId=0, int const & DstColId=1) -> PNEANet + + Parameters: + InFNm: TStr const & + SrcColId: int const & + DstColId: int const & + + LoadEdgeList(TStr InFNm, int const & SrcColId=0) -> PNEANet + + Parameters: + InFNm: TStr const & + SrcColId: int const & + + LoadEdgeList(TStr InFNm) -> PNEANet + + Parameters: + InFNm: TStr const & + + LoadEdgeList(TStr InFNm, int const & SrcColId, int const & DstColId, char const & Separator) -> PNEANet + + Parameters: + InFNm: TStr const & + SrcColId: int const & + DstColId: int const & + Separator: char const & + + """ + return _snap.LoadEdgeList(*args) + +def PrintGraphStatTable(*args): + """ + PrintGraphStatTable(PNEANet G, TStr OutFNm, TStr Desc="") + + Parameters: + G: TPt< TNEANet > const & + OutFNm: TStr + Desc: TStr + + PrintGraphStatTable(PNEANet G, TStr OutFNm) + + Parameters: + G: TPt< TNEANet > const & + OutFNm: TStr + + """ + return _snap.PrintGraphStatTable(*args) + +def GenRndGnm(*args): + """ + GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True, TRnd Rnd=Rnd) -> PNEANet + + Parameters: + Nodes: int const & + Edges: int const & + IsDir: bool const & + Rnd: TRnd & + + GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True) -> PNEANet + + Parameters: + Nodes: int const & + Edges: int const & + IsDir: bool const & + + GenRndGnm(int const & Nodes, int const & Edges) -> PNEANet + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.GenRndGnm(*args) + +def NodesGTEDegree(*args): + """ + NodesGTEDegree(PNEANet Graph, int const Threshold=0) -> int + + Parameters: + Graph: TPt< TNEANet > const & + Threshold: int const + + NodesGTEDegree(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.NodesGTEDegree(*args) + +def MxDegree(*args): + """ + MxDegree(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.MxDegree(*args) + +def MxSccSz(*args): + """ + MxSccSz(PNEANet Graph) -> PNEANet + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.MxSccSz(*args) + +def MxWccSz(*args): + """ + MxWccSz(PNEANet Graph) -> double + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.MxWccSz(*args) +class PNEANet(object): + """Proxy of C++ TPt<(TNEANet)> class""" + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") + __repr__ = _swig_repr + def New(): + """New() -> PNEANet""" + return _snap.PNEANet_New() + + New = staticmethod(New) + __swig_destroy__ = _snap.delete_PNEANet + def Save(self, *args): + """ + Save(PNEANet self, TSOut SOut) + + Parameters: + SOut: TSOut & + + """ + return _snap.PNEANet_Save(self, *args) + + def __deref__(self): + """ + __deref__(PNEANet self) -> TNEANet + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet___deref__(self) + + def __ref__(self): + """ + __ref__(PNEANet self) -> TNEANet + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet___ref__(self) + + def __call__(self): + """ + __call__(PNEANet self) -> TNEANet + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet___call__(self) + + def Empty(self): + """ + Empty(PNEANet self) -> bool + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet_Empty(self) + + def Clr(self): + """ + Clr(PNEANet self) + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_Clr(self) + + def GetRefs(self): + """ + GetRefs(PNEANet self) -> int + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet_GetRefs(self) + + def Load(self, *args): + """ + Load(PNEANet self, TSIn SIn) -> PNEANet + + Parameters: + SIn: TSIn & + + """ + return _snap.PNEANet_Load(self, *args) + + def HasFlag(self, *args): + """ + HasFlag(PNEANet self, TGraphFlag const & Flag) -> bool + + Parameters: + Flag: TGraphFlag const & + + """ + return _snap.PNEANet_HasFlag(self, *args) + + def GetNodes(self): + """ + GetNodes(PNEANet self) -> int + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet_GetNodes(self) + + def AddNode(self, *args): + """ + AddNode(PNEANet self, int NId=-1) -> int + + Parameters: + NId: int + + AddNode(PNEANet self) -> int + AddNode(PNEANet self, TNEANet::TNodeI const & NodeId) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + + """ + return _snap.PNEANet_AddNode(self, *args) + + def DelNode(self, *args): + """ + DelNode(PNEANet self, int const & NId) + + Parameters: + NId: int const & + + DelNode(PNEANet self, TNEANet::TNode const & NodeI) + + Parameters: + NodeI: TNEANet::TNode const & + + """ + return _snap.PNEANet_DelNode(self, *args) + + def IsNode(self, *args): + """ + IsNode(PNEANet self, int const & NId) -> bool + + Parameters: + NId: int const & + + """ + return _snap.PNEANet_IsNode(self, *args) + + def BegNI(self, *args): + """ + BegNI(PNEANet self) -> TNEANet::TNodeI + BegNI(PNEANet self) -> TNEANetNodeI + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_BegNI(self, *args) + + def EndNI(self, *args): + """ + EndNI(PNEANet self) -> TNEANet::TNodeI + EndNI(PNEANet self) -> TNEANetNodeI + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_EndNI(self, *args) + + def GetNI(self, *args): + """ + GetNI(PNEANet self, int const & NId) -> TNEANet::TNodeI + + Parameters: + NId: int const & + + """ + return _snap.PNEANet_GetNI(self, *args) + + def BegNAIntI(self, *args): + """ + BegNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + BegNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_BegNAIntI(self, *args) + + def EndNAIntI(self, *args): + """ + EndNAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + EndNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_EndNAIntI(self, *args) + + def GetNAIntI(self, *args): + """ + GetNAIntI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + NId: int const & + + """ + return _snap.PNEANet_GetNAIntI(self, *args) + + def BegNAStrI(self, *args): + """ + BegNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + BegNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_BegNAStrI(self, *args) + + def EndNAStrI(self, *args): + """ + EndNAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + EndNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_EndNAStrI(self, *args) + + def GetNAStrI(self, *args): + """ + GetNAStrI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + NId: int const & + + """ + return _snap.PNEANet_GetNAStrI(self, *args) + + def BegNAFltI(self, *args): + """ + BegNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + BegNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_BegNAFltI(self, *args) + + def EndNAFltI(self, *args): + """ + EndNAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + EndNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_EndNAFltI(self, *args) + + def GetNAFltI(self, *args): + """ + GetNAFltI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + NId: int const & + + """ + return _snap.PNEANet_GetNAFltI(self, *args) + + def AttrNameNI(self, *args): + """ + AttrNameNI(PNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + AttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_AttrNameNI(self, *args) + + def AttrValueNI(self, *args): + """ + AttrValueNI(PNEANet self, TInt NId, TStrV Values) + + Parameters: + NId: TInt const & + Values: TStrV & + + AttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.PNEANet_AttrValueNI(self, *args) + + def IntAttrNameNI(self, *args): + """ + IntAttrNameNI(PNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + IntAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_IntAttrNameNI(self, *args) + + def IntAttrValueNI(self, *args): + """ + IntAttrValueNI(PNEANet self, TInt NId, TIntV Values) + + Parameters: + NId: TInt const & + Values: TIntV & + + IntAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TIntV & + + """ + return _snap.PNEANet_IntAttrValueNI(self, *args) + + def StrAttrNameNI(self, *args): + """ + StrAttrNameNI(PNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + StrAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_StrAttrNameNI(self, *args) + + def StrAttrValueNI(self, *args): + """ + StrAttrValueNI(PNEANet self, TInt NId, TStrV Values) + + Parameters: + NId: TInt const & + Values: TStrV & + + StrAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.PNEANet_StrAttrValueNI(self, *args) + + def FltAttrNameNI(self, *args): + """ + FltAttrNameNI(PNEANet self, TInt NId, TStrV Names) + + Parameters: + NId: TInt const & + Names: TStrV & + + FltAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_FltAttrNameNI(self, *args) + + def FltAttrValueNI(self, *args): + """ + FltAttrValueNI(PNEANet self, TInt NId, TFltV & Values) + + Parameters: + NId: TInt const & + Values: TFltV & + + FltAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values) + + Parameters: + NId: TInt const & + NodeHI: TStrIntPrH::TIter + Values: TFltV & + + """ + return _snap.PNEANet_FltAttrValueNI(self, *args) + + def AttrNameEI(self, *args): + """ + AttrNameEI(PNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + AttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_AttrNameEI(self, *args) + + def AttrValueEI(self, *args): + """ + AttrValueEI(PNEANet self, TInt EId, TStrV Values) + + Parameters: + EId: TInt const & + Values: TStrV & + + AttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.PNEANet_AttrValueEI(self, *args) + + def IntAttrNameEI(self, *args): + """ + IntAttrNameEI(PNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + IntAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_IntAttrNameEI(self, *args) + + def IntAttrValueEI(self, *args): + """ + IntAttrValueEI(PNEANet self, TInt EId, TIntV Values) + + Parameters: + EId: TInt const & + Values: TIntV & + + IntAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TIntV & + + """ + return _snap.PNEANet_IntAttrValueEI(self, *args) + + def StrAttrNameEI(self, *args): + """ + StrAttrNameEI(PNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + StrAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_StrAttrNameEI(self, *args) + + def StrAttrValueEI(self, *args): + """ + StrAttrValueEI(PNEANet self, TInt EId, TStrV Values) + + Parameters: + EId: TInt const & + Values: TStrV & + + StrAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TStrV & + + """ + return _snap.PNEANet_StrAttrValueEI(self, *args) + + def FltAttrNameEI(self, *args): + """ + FltAttrNameEI(PNEANet self, TInt EId, TStrV Names) + + Parameters: + EId: TInt const & + Names: TStrV & + + FltAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Names: TStrV & + + """ + return _snap.PNEANet_FltAttrNameEI(self, *args) + + def FltAttrValueEI(self, *args): + """ + FltAttrValueEI(PNEANet self, TInt EId, TFltV & Values) + + Parameters: + EId: TInt const & + Values: TFltV & + + FltAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values) + + Parameters: + EId: TInt const & + EdgeHI: TStrIntPrH::TIter + Values: TFltV & + + """ + return _snap.PNEANet_FltAttrValueEI(self, *args) + + def BegEAIntI(self, *args): + """ + BegEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + BegEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_BegEAIntI(self, *args) + + def EndEAIntI(self, *args): + """ + EndEAIntI(PNEANet self, TStr attr) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + + EndEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_EndEAIntI(self, *args) + + def GetEAIntI(self, *args): + """ + GetEAIntI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI + + Parameters: + attr: TStr const & + EId: int const & + + """ + return _snap.PNEANet_GetEAIntI(self, *args) + + def BegEAStrI(self, *args): + """ + BegEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + BegEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_BegEAStrI(self, *args) + + def EndEAStrI(self, *args): + """ + EndEAStrI(PNEANet self, TStr attr) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + + EndEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_EndEAStrI(self, *args) + + def GetEAStrI(self, *args): + """ + GetEAStrI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI + + Parameters: + attr: TStr const & + EId: int const & + + """ + return _snap.PNEANet_GetEAStrI(self, *args) + + def BegEAFltI(self, *args): + """ + BegEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + BegEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_BegEAFltI(self, *args) + + def EndEAFltI(self, *args): + """ + EndEAFltI(PNEANet self, TStr attr) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + + EndEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_EndEAFltI(self, *args) + + def GetEAFltI(self, *args): + """ + GetEAFltI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI + + Parameters: + attr: TStr const & + EId: int const & + + """ + return _snap.PNEANet_GetEAFltI(self, *args) + + def GetMxNId(self): + """ + GetMxNId(PNEANet self) -> int + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet_GetMxNId(self) + + def GetEdges(self): + """ + GetEdges(PNEANet self) -> int + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet_GetEdges(self) + + def AddEdge(self, *args): + """ + AddEdge(PNEANet self, int const & SrcNId, int const & DstNId, int EId=-1) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int + + AddEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + AddEdge(PNEANet self, TNEANet::TEdgeI const & EdgeI) -> int + + Parameters: + EdgeI: TNEANet::TEdgeI const & + + """ + return _snap.PNEANet_AddEdge(self, *args) + + def DelEdge(self, *args): + """ + DelEdge(PNEANet self, int const & EId) + + Parameters: + EId: int const & + + DelEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + DelEdge(PNEANet self, int const & SrcNId, int const & DstNId) + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.PNEANet_DelEdge(self, *args) + + def IsEdge(self, *args): + """ + IsEdge(PNEANet self, int const & EId) -> bool + + Parameters: + EId: int const & + + IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + IsEdge(PNEANet self, int const & SrcNId, int const & DstNId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + + IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int & + IsDir: bool const & + + IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool + + Parameters: + SrcNId: int const & + DstNId: int const & + EId: int & + + """ + return _snap.PNEANet_IsEdge(self, *args) + + def GetEId(self, *args): + """ + GetEId(PNEANet self, int const & SrcNId, int const & DstNId) -> int + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.PNEANet_GetEId(self, *args) + + def BegEI(self, *args): + """ + BegEI(PNEANet self) -> TNEANet::TEdgeI + BegEI(PNEANet self) -> TNEANetEdgeI + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_BegEI(self, *args) + + def EndEI(self, *args): + """ + EndEI(PNEANet self) -> TNEANet::TEdgeI + EndEI(PNEANet self) -> TNEANetEdgeI + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_EndEI(self, *args) + + def GetEI(self, *args): + """ + GetEI(PNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI + + Parameters: + SrcNId: int const & + DstNId: int const & + + """ + return _snap.PNEANet_GetEI(self, *args) + + def GetRndNId(self, *args): + """ + GetRndNId(PNEANet self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndNId(PNEANet self) -> int + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_GetRndNId(self, *args) + + def GetRndNI(self, *args): + """ + GetRndNI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TNodeI + + Parameters: + Rnd: TRnd & + + GetRndNI(PNEANet self) -> TNEANet::TNodeI + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_GetRndNI(self, *args) + + def GetRndEId(self, *args): + """ + GetRndEId(PNEANet self, TRnd Rnd=Rnd) -> int + + Parameters: + Rnd: TRnd & + + GetRndEId(PNEANet self) -> int + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_GetRndEId(self, *args) + + def GetRndEI(self, *args): + """ + GetRndEI(PNEANet self, TRnd Rnd=Rnd) -> TNEANet::TEdgeI + + Parameters: + Rnd: TRnd & + + GetRndEI(PNEANet self) -> TNEANet::TEdgeI + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_GetRndEI(self, *args) + + def GetNIdV(self, *args): + """ + GetNIdV(PNEANet self, TIntV NIdV) + + Parameters: + NIdV: TIntV & + + """ + return _snap.PNEANet_GetNIdV(self, *args) + + def GetEIdV(self, *args): + """ + GetEIdV(PNEANet self, TIntV EIdV) + + Parameters: + EIdV: TIntV & + + """ + return _snap.PNEANet_GetEIdV(self, *args) + + def Reserve(self, *args): + """ + Reserve(PNEANet self, int const & Nodes, int const & Edges) + + Parameters: + Nodes: int const & + Edges: int const & + + """ + return _snap.PNEANet_Reserve(self, *args) + + def Defrag(self, OnlyNodeLinks=False): + """ + Defrag(PNEANet self, bool const & OnlyNodeLinks=False) + + Parameters: + OnlyNodeLinks: bool const & + + Defrag(PNEANet self) + + Parameters: + self: TPt< TNEANet > * + + """ + return _snap.PNEANet_Defrag(self, OnlyNodeLinks) + + def IsOk(self, ThrowExcept=True): + """ + IsOk(PNEANet self, bool const & ThrowExcept=True) -> bool + + Parameters: + ThrowExcept: bool const & + + IsOk(PNEANet self) -> bool + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet_IsOk(self, ThrowExcept) + + def Dump(self, *args): + """ + Dump(PNEANet self, FILE * OutF=stdout) + + Parameters: + OutF: FILE * + + Dump(PNEANet self) + + Parameters: + self: TPt< TNEANet > const * + + """ + return _snap.PNEANet_Dump(self, *args) + + def AddIntAttrDatN(self, *args): + """ + AddIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + value: TInt const & + attr: TStr const & + + AddIntAttrDatN(PNEANet self, int const & NId, TInt value, TStr attr) -> int + + Parameters: + NId: int const & + value: TInt const & + attr: TStr const & + + """ + return _snap.PNEANet_AddIntAttrDatN(self, *args) + + def AddStrAttrDatN(self, *args): + """ + AddStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + value: TStr const & + attr: TStr const & + + AddStrAttrDatN(PNEANet self, int const & NId, TStr value, TStr attr) -> int + + Parameters: + NId: int const & + value: TStr const & + attr: TStr const & + + """ + return _snap.PNEANet_AddStrAttrDatN(self, *args) + + def AddFltAttrDatN(self, *args): + """ + AddFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + value: TFlt const & + attr: TStr const & + + AddFltAttrDatN(PNEANet self, int const & NId, TFlt value, TStr attr) -> int + + Parameters: + NId: int const & + value: TFlt const & + attr: TStr const & + + """ + return _snap.PNEANet_AddFltAttrDatN(self, *args) + + def AddIntAttrDatE(self, *args): + """ + AddIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + value: TInt const & + attr: TStr const & + + AddIntAttrDatE(PNEANet self, int const & EId, TInt value, TStr attr) -> int + + Parameters: + EId: int const & + value: TInt const & + attr: TStr const & + + """ + return _snap.PNEANet_AddIntAttrDatE(self, *args) + + def AddStrAttrDatE(self, *args): + """ + AddStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + value: TStr const & + attr: TStr const & + + AddStrAttrDatE(PNEANet self, int const & EId, TStr value, TStr attr) -> int + + Parameters: + EId: int const & + value: TStr const & + attr: TStr const & + + """ + return _snap.PNEANet_AddStrAttrDatE(self, *args) + + def AddFltAttrDatE(self, *args): + """ + AddFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + value: TFlt const & + attr: TStr const & + + AddFltAttrDatE(PNEANet self, int const & EId, TFlt value, TStr attr) -> int + + Parameters: + EId: int const & + value: TFlt const & + attr: TStr const & + + """ + return _snap.PNEANet_AddFltAttrDatE(self, *args) + + def GetIntAttrDatN(self, *args): + """ + GetIntAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TInt + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + GetIntAttrDatN(PNEANet self, int const & NId, TStr attr) -> TInt + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_GetIntAttrDatN(self, *args) + + def GetStrAttrDatN(self, *args): + """ + GetStrAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TStr + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + GetStrAttrDatN(PNEANet self, int const & NId, TStr attr) -> TStr + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_GetStrAttrDatN(self, *args) + + def GetFltAttrDatN(self, *args): + """ + GetFltAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + GetFltAttrDatN(PNEANet self, int const & NId, TStr attr) -> TFlt + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_GetFltAttrDatN(self, *args) + + def GetIntAttrDatE(self, *args): + """ + GetIntAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + GetIntAttrDatE(PNEANet self, int const & EId, TStr attr) -> TInt + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_GetIntAttrDatE(self, *args) + + def GetStrAttrDatE(self, *args): + """ + GetStrAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + GetStrAttrDatE(PNEANet self, int const & EId, TStr attr) -> TStr + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_GetStrAttrDatE(self, *args) + + def GetFltAttrDatE(self, *args): + """ + GetFltAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + GetFltAttrDatE(PNEANet self, int const & EId, TStr attr) -> TFlt + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_GetFltAttrDatE(self, *args) + + def DelAttrDatN(self, *args): + """ + DelAttrDatN(PNEANet self, TNEANet::TNodeI const & NodeId, TStr attr) -> int + + Parameters: + NodeId: TNEANet::TNodeI const & + attr: TStr const & + + DelAttrDatN(PNEANet self, int const & NId, TStr attr) -> int + + Parameters: + NId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_DelAttrDatN(self, *args) + + def DelAttrDatE(self, *args): + """ + DelAttrDatE(PNEANet self, TNEANet::TEdgeI const & EdgeId, TStr attr) -> int + + Parameters: + EdgeId: TNEANet::TEdgeI const & + attr: TStr const & + + DelAttrDatE(PNEANet self, int const & EId, TStr attr) -> int + + Parameters: + EId: int const & + attr: TStr const & + + """ + return _snap.PNEANet_DelAttrDatE(self, *args) + + def AddIntAttrN(self, *args): + """ + AddIntAttrN(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TInt + + AddIntAttrN(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_AddIntAttrN(self, *args) + + def AddStrAttrN(self, *args): + """ + AddStrAttrN(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int + + Parameters: + attr: TStr const & + defaultValue: TStr + + AddStrAttrN(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_AddStrAttrN(self, *args) + + def AddFltAttrN(self, *args): + """ + AddFltAttrN(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TFlt + + AddFltAttrN(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_AddFltAttrN(self, *args) + + def AddIntAttrE(self, *args): + """ + AddIntAttrE(PNEANet self, TStr attr, TInt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TInt + + AddIntAttrE(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_AddIntAttrE(self, *args) + + def AddStrAttrE(self, *args): + """ + AddStrAttrE(PNEANet self, TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int + + Parameters: + attr: TStr const & + defaultValue: TStr + + AddStrAttrE(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_AddStrAttrE(self, *args) + + def AddFltAttrE(self, *args): + """ + AddFltAttrE(PNEANet self, TStr attr, TFlt defaultValue=Mn) -> int + + Parameters: + attr: TStr const & + defaultValue: TFlt + + AddFltAttrE(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_AddFltAttrE(self, *args) + + def DelAttrN(self, *args): + """ + DelAttrN(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_DelAttrN(self, *args) + + def DelAttrE(self, *args): + """ + DelAttrE(PNEANet self, TStr attr) -> int + + Parameters: + attr: TStr const & + + """ + return _snap.PNEANet_DelAttrE(self, *args) + + def NodeAttrIsDeleted(self, *args): + """ + NodeAttrIsDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_NodeAttrIsDeleted(self, *args) + + def NodeAttrIsIntDeleted(self, *args): + """ + NodeAttrIsIntDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_NodeAttrIsIntDeleted(self, *args) + + def NodeAttrIsStrDeleted(self, *args): + """ + NodeAttrIsStrDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_NodeAttrIsStrDeleted(self, *args) + + def NodeAttrIsFltDeleted(self, *args): + """ + NodeAttrIsFltDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_NodeAttrIsFltDeleted(self, *args) + + def EdgeAttrIsDeleted(self, *args): + """ + EdgeAttrIsDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_EdgeAttrIsDeleted(self, *args) + + def EdgeAttrIsIntDeleted(self, *args): + """ + EdgeAttrIsIntDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_EdgeAttrIsIntDeleted(self, *args) + + def EdgeAttrIsStrDeleted(self, *args): + """ + EdgeAttrIsStrDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_EdgeAttrIsStrDeleted(self, *args) + + def EdgeAttrIsFltDeleted(self, *args): + """ + EdgeAttrIsFltDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_EdgeAttrIsFltDeleted(self, *args) + + def GetNodeAttrValue(self, *args): + """ + GetNodeAttrValue(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr + + Parameters: + NId: int const & + NodeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_GetNodeAttrValue(self, *args) + + def GetEdgeAttrValue(self, *args): + """ + GetEdgeAttrValue(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr + + Parameters: + EId: int const & + EdgeHI: TStrIntPrH::TIter const & + + """ + return _snap.PNEANet_GetEdgeAttrValue(self, *args) + +PNEANet.Save = new_instancemethod(_snap.PNEANet_Save,None,PNEANet) +PNEANet.__deref__ = new_instancemethod(_snap.PNEANet___deref__,None,PNEANet) +PNEANet.__ref__ = new_instancemethod(_snap.PNEANet___ref__,None,PNEANet) +PNEANet.__call__ = new_instancemethod(_snap.PNEANet___call__,None,PNEANet) +PNEANet.Empty = new_instancemethod(_snap.PNEANet_Empty,None,PNEANet) +PNEANet.Clr = new_instancemethod(_snap.PNEANet_Clr,None,PNEANet) +PNEANet.GetRefs = new_instancemethod(_snap.PNEANet_GetRefs,None,PNEANet) +PNEANet.Load = new_instancemethod(_snap.PNEANet_Load,None,PNEANet) +PNEANet.HasFlag = new_instancemethod(_snap.PNEANet_HasFlag,None,PNEANet) +PNEANet.GetNodes = new_instancemethod(_snap.PNEANet_GetNodes,None,PNEANet) +PNEANet.AddNode = new_instancemethod(_snap.PNEANet_AddNode,None,PNEANet) +PNEANet.DelNode = new_instancemethod(_snap.PNEANet_DelNode,None,PNEANet) +PNEANet.IsNode = new_instancemethod(_snap.PNEANet_IsNode,None,PNEANet) +PNEANet.BegNI = new_instancemethod(_snap.PNEANet_BegNI,None,PNEANet) +PNEANet.EndNI = new_instancemethod(_snap.PNEANet_EndNI,None,PNEANet) +PNEANet.GetNI = new_instancemethod(_snap.PNEANet_GetNI,None,PNEANet) +PNEANet.BegNAIntI = new_instancemethod(_snap.PNEANet_BegNAIntI,None,PNEANet) +PNEANet.EndNAIntI = new_instancemethod(_snap.PNEANet_EndNAIntI,None,PNEANet) +PNEANet.GetNAIntI = new_instancemethod(_snap.PNEANet_GetNAIntI,None,PNEANet) +PNEANet.BegNAStrI = new_instancemethod(_snap.PNEANet_BegNAStrI,None,PNEANet) +PNEANet.EndNAStrI = new_instancemethod(_snap.PNEANet_EndNAStrI,None,PNEANet) +PNEANet.GetNAStrI = new_instancemethod(_snap.PNEANet_GetNAStrI,None,PNEANet) +PNEANet.BegNAFltI = new_instancemethod(_snap.PNEANet_BegNAFltI,None,PNEANet) +PNEANet.EndNAFltI = new_instancemethod(_snap.PNEANet_EndNAFltI,None,PNEANet) +PNEANet.GetNAFltI = new_instancemethod(_snap.PNEANet_GetNAFltI,None,PNEANet) +PNEANet.AttrNameNI = new_instancemethod(_snap.PNEANet_AttrNameNI,None,PNEANet) +PNEANet.AttrValueNI = new_instancemethod(_snap.PNEANet_AttrValueNI,None,PNEANet) +PNEANet.IntAttrNameNI = new_instancemethod(_snap.PNEANet_IntAttrNameNI,None,PNEANet) +PNEANet.IntAttrValueNI = new_instancemethod(_snap.PNEANet_IntAttrValueNI,None,PNEANet) +PNEANet.StrAttrNameNI = new_instancemethod(_snap.PNEANet_StrAttrNameNI,None,PNEANet) +PNEANet.StrAttrValueNI = new_instancemethod(_snap.PNEANet_StrAttrValueNI,None,PNEANet) +PNEANet.FltAttrNameNI = new_instancemethod(_snap.PNEANet_FltAttrNameNI,None,PNEANet) +PNEANet.FltAttrValueNI = new_instancemethod(_snap.PNEANet_FltAttrValueNI,None,PNEANet) +PNEANet.AttrNameEI = new_instancemethod(_snap.PNEANet_AttrNameEI,None,PNEANet) +PNEANet.AttrValueEI = new_instancemethod(_snap.PNEANet_AttrValueEI,None,PNEANet) +PNEANet.IntAttrNameEI = new_instancemethod(_snap.PNEANet_IntAttrNameEI,None,PNEANet) +PNEANet.IntAttrValueEI = new_instancemethod(_snap.PNEANet_IntAttrValueEI,None,PNEANet) +PNEANet.StrAttrNameEI = new_instancemethod(_snap.PNEANet_StrAttrNameEI,None,PNEANet) +PNEANet.StrAttrValueEI = new_instancemethod(_snap.PNEANet_StrAttrValueEI,None,PNEANet) +PNEANet.FltAttrNameEI = new_instancemethod(_snap.PNEANet_FltAttrNameEI,None,PNEANet) +PNEANet.FltAttrValueEI = new_instancemethod(_snap.PNEANet_FltAttrValueEI,None,PNEANet) +PNEANet.BegEAIntI = new_instancemethod(_snap.PNEANet_BegEAIntI,None,PNEANet) +PNEANet.EndEAIntI = new_instancemethod(_snap.PNEANet_EndEAIntI,None,PNEANet) +PNEANet.GetEAIntI = new_instancemethod(_snap.PNEANet_GetEAIntI,None,PNEANet) +PNEANet.BegEAStrI = new_instancemethod(_snap.PNEANet_BegEAStrI,None,PNEANet) +PNEANet.EndEAStrI = new_instancemethod(_snap.PNEANet_EndEAStrI,None,PNEANet) +PNEANet.GetEAStrI = new_instancemethod(_snap.PNEANet_GetEAStrI,None,PNEANet) +PNEANet.BegEAFltI = new_instancemethod(_snap.PNEANet_BegEAFltI,None,PNEANet) +PNEANet.EndEAFltI = new_instancemethod(_snap.PNEANet_EndEAFltI,None,PNEANet) +PNEANet.GetEAFltI = new_instancemethod(_snap.PNEANet_GetEAFltI,None,PNEANet) +PNEANet.GetMxNId = new_instancemethod(_snap.PNEANet_GetMxNId,None,PNEANet) +PNEANet.GetEdges = new_instancemethod(_snap.PNEANet_GetEdges,None,PNEANet) +PNEANet.AddEdge = new_instancemethod(_snap.PNEANet_AddEdge,None,PNEANet) +PNEANet.DelEdge = new_instancemethod(_snap.PNEANet_DelEdge,None,PNEANet) +PNEANet.IsEdge = new_instancemethod(_snap.PNEANet_IsEdge,None,PNEANet) +PNEANet.GetEId = new_instancemethod(_snap.PNEANet_GetEId,None,PNEANet) +PNEANet.BegEI = new_instancemethod(_snap.PNEANet_BegEI,None,PNEANet) +PNEANet.EndEI = new_instancemethod(_snap.PNEANet_EndEI,None,PNEANet) +PNEANet.GetEI = new_instancemethod(_snap.PNEANet_GetEI,None,PNEANet) +PNEANet.GetRndNId = new_instancemethod(_snap.PNEANet_GetRndNId,None,PNEANet) +PNEANet.GetRndNI = new_instancemethod(_snap.PNEANet_GetRndNI,None,PNEANet) +PNEANet.GetRndEId = new_instancemethod(_snap.PNEANet_GetRndEId,None,PNEANet) +PNEANet.GetRndEI = new_instancemethod(_snap.PNEANet_GetRndEI,None,PNEANet) +PNEANet.GetNIdV = new_instancemethod(_snap.PNEANet_GetNIdV,None,PNEANet) +PNEANet.GetEIdV = new_instancemethod(_snap.PNEANet_GetEIdV,None,PNEANet) +PNEANet.Reserve = new_instancemethod(_snap.PNEANet_Reserve,None,PNEANet) +PNEANet.Defrag = new_instancemethod(_snap.PNEANet_Defrag,None,PNEANet) +PNEANet.IsOk = new_instancemethod(_snap.PNEANet_IsOk,None,PNEANet) +PNEANet.Dump = new_instancemethod(_snap.PNEANet_Dump,None,PNEANet) +PNEANet.AddIntAttrDatN = new_instancemethod(_snap.PNEANet_AddIntAttrDatN,None,PNEANet) +PNEANet.AddStrAttrDatN = new_instancemethod(_snap.PNEANet_AddStrAttrDatN,None,PNEANet) +PNEANet.AddFltAttrDatN = new_instancemethod(_snap.PNEANet_AddFltAttrDatN,None,PNEANet) +PNEANet.AddIntAttrDatE = new_instancemethod(_snap.PNEANet_AddIntAttrDatE,None,PNEANet) +PNEANet.AddStrAttrDatE = new_instancemethod(_snap.PNEANet_AddStrAttrDatE,None,PNEANet) +PNEANet.AddFltAttrDatE = new_instancemethod(_snap.PNEANet_AddFltAttrDatE,None,PNEANet) +PNEANet.GetIntAttrDatN = new_instancemethod(_snap.PNEANet_GetIntAttrDatN,None,PNEANet) +PNEANet.GetStrAttrDatN = new_instancemethod(_snap.PNEANet_GetStrAttrDatN,None,PNEANet) +PNEANet.GetFltAttrDatN = new_instancemethod(_snap.PNEANet_GetFltAttrDatN,None,PNEANet) +PNEANet.GetIntAttrDatE = new_instancemethod(_snap.PNEANet_GetIntAttrDatE,None,PNEANet) +PNEANet.GetStrAttrDatE = new_instancemethod(_snap.PNEANet_GetStrAttrDatE,None,PNEANet) +PNEANet.GetFltAttrDatE = new_instancemethod(_snap.PNEANet_GetFltAttrDatE,None,PNEANet) +PNEANet.DelAttrDatN = new_instancemethod(_snap.PNEANet_DelAttrDatN,None,PNEANet) +PNEANet.DelAttrDatE = new_instancemethod(_snap.PNEANet_DelAttrDatE,None,PNEANet) +PNEANet.AddIntAttrN = new_instancemethod(_snap.PNEANet_AddIntAttrN,None,PNEANet) +PNEANet.AddStrAttrN = new_instancemethod(_snap.PNEANet_AddStrAttrN,None,PNEANet) +PNEANet.AddFltAttrN = new_instancemethod(_snap.PNEANet_AddFltAttrN,None,PNEANet) +PNEANet.AddIntAttrE = new_instancemethod(_snap.PNEANet_AddIntAttrE,None,PNEANet) +PNEANet.AddStrAttrE = new_instancemethod(_snap.PNEANet_AddStrAttrE,None,PNEANet) +PNEANet.AddFltAttrE = new_instancemethod(_snap.PNEANet_AddFltAttrE,None,PNEANet) +PNEANet.DelAttrN = new_instancemethod(_snap.PNEANet_DelAttrN,None,PNEANet) +PNEANet.DelAttrE = new_instancemethod(_snap.PNEANet_DelAttrE,None,PNEANet) +PNEANet.NodeAttrIsDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsDeleted,None,PNEANet) +PNEANet.NodeAttrIsIntDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsIntDeleted,None,PNEANet) +PNEANet.NodeAttrIsStrDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsStrDeleted,None,PNEANet) +PNEANet.NodeAttrIsFltDeleted = new_instancemethod(_snap.PNEANet_NodeAttrIsFltDeleted,None,PNEANet) +PNEANet.EdgeAttrIsDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsDeleted,None,PNEANet) +PNEANet.EdgeAttrIsIntDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsIntDeleted,None,PNEANet) +PNEANet.EdgeAttrIsStrDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsStrDeleted,None,PNEANet) +PNEANet.EdgeAttrIsFltDeleted = new_instancemethod(_snap.PNEANet_EdgeAttrIsFltDeleted,None,PNEANet) +PNEANet.GetNodeAttrValue = new_instancemethod(_snap.PNEANet_GetNodeAttrValue,None,PNEANet) +PNEANet.GetEdgeAttrValue = new_instancemethod(_snap.PNEANet_GetEdgeAttrValue,None,PNEANet) +PNEANet_swigregister = _snap.PNEANet_swigregister +PNEANet_swigregister(PNEANet) + +def PNEANet_New(): + """PNEANet_New() -> PNEANet""" + return _snap.PNEANet_New() + + +def GetNodeWcc(*args): + """ + GetNodeWcc(PNEANet Graph, int const & NId, TIntV CnCom) + + Parameters: + Graph: TPt< TNEANet > const & + NId: int const & + CnCom: TIntV & + + """ + return _snap.GetNodeWcc(*args) + +def IsConnected(*args): + """ + IsConnected(PNEANet Graph) -> bool + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.IsConnected(*args) + +def IsWeaklyConn(*args): + """ + IsWeaklyConn(PNEANet Graph) -> bool + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.IsWeaklyConn(*args) + +def GetWccSzCnt(*args): + """ + GetWccSzCnt(PNEANet Graph, TIntPrV & WccSzCnt) + + Parameters: + Graph: TPt< TNEANet > const & + WccSzCnt: TIntPrV & + + """ + return _snap.GetWccSzCnt(*args) + +def GetWccs(*args): + """ + GetWccs(PNEANet Graph, TCnComV & CnComV) + + Parameters: + Graph: TPt< TNEANet > const & + CnComV: TCnComV & + + """ + return _snap.GetWccs(*args) + +def GetSccSzCnt(*args): + """ + GetSccSzCnt(PNEANet Graph, TIntPrV & SccSzCnt) + + Parameters: + Graph: TPt< TNEANet > const & + SccSzCnt: TIntPrV & + + """ + return _snap.GetSccSzCnt(*args) + +def GetSccs(*args): + """ + GetSccs(PNEANet Graph, TCnComV & CnComV) + + Parameters: + Graph: TPt< TNEANet > const & + CnComV: TCnComV & + + """ + return _snap.GetSccs(*args) + +def GetMxWccSz(*args): + """ + GetMxWccSz(PNEANet Graph) -> double + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetMxWccSz(*args) + +def GetMxWcc(*args): + """ + GetMxWcc(PNEANet Graph) -> PNEANet + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetMxWcc(*args) + +def GetMxScc(*args): + """ + GetMxScc(PNEANet Graph) -> PNEANet + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetMxScc(*args) + +def GetMxBiCon(*args): + """ + GetMxBiCon(PUNGraph const & Graph, bool const & RenumberNodes=False) -> PUNGraph + + Parameters: + Graph: PUNGraph const & + RenumberNodes: bool const & + + GetMxBiCon(PUNGraph const & Graph) -> PUNGraph + + Parameters: + Graph: PUNGraph const & + + GetMxBiCon(PNEANet Graph) -> PNEANet + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetMxBiCon(*args) + +def CntInDegNodes(*args): + """ + CntInDegNodes(PNEANet Graph, int const & NodeInDeg) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NodeInDeg: int const & + + """ + return _snap.CntInDegNodes(*args) + +def CntOutDegNodes(*args): + """ + CntOutDegNodes(PNEANet Graph, int const & NodeOutDeg) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NodeOutDeg: int const & + + """ + return _snap.CntOutDegNodes(*args) + +def CntDegNodes(*args): + """ + CntDegNodes(PNEANet Graph, int const & NodeDeg) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NodeDeg: int const & + + """ + return _snap.CntDegNodes(*args) + +def CntNonZNodes(*args): + """ + CntNonZNodes(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.CntNonZNodes(*args) + +def CntEdgesToSet(*args): + """ + CntEdgesToSet(PNEANet Graph, int const & NId, TIntSet const & NodeSet) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NId: int const & + NodeSet: TIntSet const & + + """ + return _snap.CntEdgesToSet(*args) + +def GetMxDegNId(*args): + """ + GetMxDegNId(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetMxDegNId(*args) + +def GetMxInDegNId(*args): + """ + GetMxInDegNId(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetMxInDegNId(*args) + +def GetMxOutDegNId(*args): + """ + GetMxOutDegNId(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetMxOutDegNId(*args) + +def GetInDegCnt(*args): + """ + GetInDegCnt(PNEANet Graph, TIntPrV & DegToCntV) + + Parameters: + Graph: TPt< TNEANet > const & + DegToCntV: TIntPrV & + + GetInDegCnt(PNEANet Graph, TFltPrV & DegToCntV) + + Parameters: + Graph: TPt< TNEANet > const & + DegToCntV: TFltPrV & + + """ + return _snap.GetInDegCnt(*args) + +def GetOutDegCnt(*args): + """ + GetOutDegCnt(PNEANet Graph, TIntPrV & DegToCntV) + + Parameters: + Graph: TPt< TNEANet > const & + DegToCntV: TIntPrV & + + GetOutDegCnt(PNEANet Graph, TFltPrV & DegToCntV) + + Parameters: + Graph: TPt< TNEANet > const & + DegToCntV: TFltPrV & + + """ + return _snap.GetOutDegCnt(*args) + +def GetDegCnt(*args): + """ + GetDegCnt(PNEANet Graph, TIntPrV & DegToCntV) + + Parameters: + Graph: TPt< TNEANet > const & + DegToCntV: TIntPrV & + + GetDegCnt(PNEANet Graph, TFltPrV & DegToCntV) + + Parameters: + Graph: TPt< TNEANet > const & + DegToCntV: TFltPrV & + + """ + return _snap.GetDegCnt(*args) + +def GetDegSeqV(*args): + """ + GetDegSeqV(PNEANet Graph, TIntV DegV) + + Parameters: + Graph: TPt< TNEANet > const & + DegV: TIntV & + + GetDegSeqV(PNEANet Graph, TIntV InDegV, TIntV OutDegV) + + Parameters: + Graph: TPt< TNEANet > const & + InDegV: TIntV & + OutDegV: TIntV & + + """ + return _snap.GetDegSeqV(*args) + +def GetNodeInDegV(*args): + """ + GetNodeInDegV(PNEANet Graph, TIntPrV & NIdInDegV) + + Parameters: + Graph: TPt< TNEANet > const & + NIdInDegV: TIntPrV & + + """ + return _snap.GetNodeInDegV(*args) + +def GetNodeOutDegV(*args): + """ + GetNodeOutDegV(PNEANet Graph, TIntPrV & NIdOutDegV) + + Parameters: + Graph: TPt< TNEANet > const & + NIdOutDegV: TIntPrV & + + """ + return _snap.GetNodeOutDegV(*args) + +def CntUniqUndirEdges(*args): + """ + CntUniqUndirEdges(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.CntUniqUndirEdges(*args) + +def CntUniqDirEdges(*args): + """ + CntUniqDirEdges(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.CntUniqDirEdges(*args) + +def CntUniqBiDirEdges(*args): + """ + CntUniqBiDirEdges(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.CntUniqBiDirEdges(*args) + +def CntSelfEdges(*args): + """ + CntSelfEdges(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.CntSelfEdges(*args) + +def GetBfsTree(*args): + """ + GetBfsTree(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn) -> PNGraph + + Parameters: + Graph: TPt< TNEANet > const & + StartNId: int const & + FollowOut: bool const & + FollowIn: bool const & + + """ + return _snap.GetBfsTree(*args) + +def GetSubTreeSz(*args): + """ + GetSubTreeSz(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn, + int & TreeSz, int & TreeDepth) -> int + + Parameters: + Graph: TPt< TNEANet > const & + StartNId: int const & + FollowOut: bool const & + FollowIn: bool const & + TreeSz: int & + TreeDepth: int & + + """ + return _snap.GetSubTreeSz(*args) + +def GetNodesAtHop(*args): + """ + GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV, bool const & IsDir=False) -> int + + Parameters: + Graph: TPt< TNEANet > const & + StartNId: int const & + Hop: int const & + NIdV: TIntV & + IsDir: bool const & + + GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV) -> int + + Parameters: + Graph: TPt< TNEANet > const & + StartNId: int const & + Hop: int const & + NIdV: TIntV & + + """ + return _snap.GetNodesAtHop(*args) + +def GetNodesAtHops(*args): + """ + GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV, bool const & IsDir=False) -> int + + Parameters: + Graph: TPt< TNEANet > const & + StartNId: int const & + HopCntV: TIntPrV & + IsDir: bool const & + + GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV) -> int + + Parameters: + Graph: TPt< TNEANet > const & + StartNId: int const & + HopCntV: TIntPrV & + + """ + return _snap.GetNodesAtHops(*args) + +def GetShortPath(*args): + """ + GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId, bool const & IsDir=False) -> int + + Parameters: + Graph: TPt< TNEANet > const & + SrcNId: int const & + DstNId: int const & + IsDir: bool const & + + GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId) -> int + + Parameters: + Graph: TPt< TNEANet > const & + SrcNId: int const & + DstNId: int const & + + GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False, int const & MaxDist=Mx) -> int + + Parameters: + Graph: TPt< TNEANet > const & + SrcNId: int const & + NIdToDistH: TIntH & + IsDir: bool const & + MaxDist: int const & + + GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False) -> int + + Parameters: + Graph: TPt< TNEANet > const & + SrcNId: int const & + NIdToDistH: TIntH & + IsDir: bool const & + + GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH) -> int + + Parameters: + Graph: TPt< TNEANet > const & + SrcNId: int const & + NIdToDistH: TIntH & + + """ + return _snap.GetShortPath(*args) + +def GetBfsFullDiam(*args): + """ + GetBfsFullDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NTestNodes: int const & + IsDir: bool const & + + GetBfsFullDiam(PNEANet Graph, int const & NTestNodes) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NTestNodes: int const & + + """ + return _snap.GetBfsFullDiam(*args) + +def GetBfsEffDiam(*args): + """ + GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NTestNodes: int const & + IsDir: bool const & + + GetBfsEffDiam(PNEANet Graph, int const & NTestNodes) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NTestNodes: int const & + + GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NTestNodes: int const & + IsDir: bool const & + EffDiam: double & + FullDiam: int & + + GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam, + double & AvgSPL) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NTestNodes: int const & + IsDir: bool const & + EffDiam: double & + FullDiam: int & + AvgSPL: double & + + GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, TIntV SubGraphNIdV, bool const & IsDir, double & EffDiam, + int & FullDiam) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NTestNodes: int const & + SubGraphNIdV: TIntV const & + IsDir: bool const & + EffDiam: double & + FullDiam: int & + + """ + return _snap.GetBfsEffDiam(*args) + +def DrawGViz(*args): + """ + DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False, + TIntStrH const & NIdColorH=TIntStrH()) + + Parameters: + Graph: TPt< TNEANet > const & + Layout: TGVizLayout const & + PltFNm: TStr const & + Desc: TStr const & + NodeLabels: bool const & + NIdColorH: TIntStrH const & + + DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False) + + Parameters: + Graph: TPt< TNEANet > const & + Layout: TGVizLayout const & + PltFNm: TStr const & + Desc: TStr const & + NodeLabels: bool const & + + DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr()) + + Parameters: + Graph: TPt< TNEANet > const & + Layout: TGVizLayout const & + PltFNm: TStr const & + Desc: TStr const & + + DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm) + + Parameters: + Graph: TPt< TNEANet > const & + Layout: TGVizLayout const & + PltFNm: TStr const & + + DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc, TIntStrH const & NodeLabelH) + + Parameters: + Graph: TPt< TNEANet > const & + Layout: TGVizLayout const & + PltFNm: TStr const & + Desc: TStr const & + NodeLabelH: TIntStrH const & + + """ + return _snap.DrawGViz(*args) + +def GetClustCf(*args): + """ + GetClustCf(PNEANet Graph, int SampleNodes=-1) -> double + + Parameters: + Graph: TPt< TNEANet > const & + SampleNodes: int + + GetClustCf(PNEANet Graph) -> double + + Parameters: + Graph: TPt< TNEANet > const & + + GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int SampleNodes=-1) -> double + + Parameters: + Graph: TPt< TNEANet > const & + DegToCCfV: TFltPrV & + SampleNodes: int + + GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV) -> double + + Parameters: + Graph: TPt< TNEANet > const & + DegToCCfV: TFltPrV & + + GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes=-1) -> double + + Parameters: + Graph: TPt< TNEANet > const & + DegToCCfV: TFltPrV & + ClosedTriads: int64 & + OpenTriads: int64 & + SampleNodes: int + + GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads) -> double + + Parameters: + Graph: TPt< TNEANet > const & + DegToCCfV: TFltPrV & + ClosedTriads: int64 & + OpenTriads: int64 & + + """ + return _snap.GetClustCf(*args) + +def GetNodeClustCf(*args): + """ + GetNodeClustCf(PNEANet Graph, int const & NId) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NId: int const & + + GetNodeClustCf(PNEANet Graph, TIntFltH & NIdCCfH) + + Parameters: + Graph: TPt< TNEANet > const & + NIdCCfH: TIntFltH & + + """ + return _snap.GetNodeClustCf(*args) + +def GetTriads(*args): + """ + GetTriads(PNEANet Graph, int SampleNodes=-1) -> int64 + + Parameters: + Graph: TPt< TNEANet > const & + SampleNodes: int + + GetTriads(PNEANet Graph) -> int64 + + Parameters: + Graph: TPt< TNEANet > const & + + GetTriads(PNEANet Graph, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes) -> int64 + + Parameters: + Graph: TPt< TNEANet > const & + ClosedTriads: int64 & + OpenTriads: int64 & + SampleNodes: int + + GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV, int SampleNodes=-1) + + Parameters: + Graph: TPt< TNEANet > const & + NIdCOTriadV: TIntTrV & + SampleNodes: int + + GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV) + + Parameters: + Graph: TPt< TNEANet > const & + NIdCOTriadV: TIntTrV & + + """ + return _snap.GetTriads(*args) + +def GetTriadEdges(*args): + """ + GetTriadEdges(PNEANet Graph, int SampleEdges=-1) -> int + + Parameters: + Graph: TPt< TNEANet > const & + SampleEdges: int + + GetTriadEdges(PNEANet Graph) -> int + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetTriadEdges(*args) + +def GetTriadParticip(*args): + """ + GetTriadParticip(PNEANet Graph, TIntPrV & TriadCntV) + + Parameters: + Graph: TPt< TNEANet > const & + TriadCntV: TIntPrV & + + """ + return _snap.GetTriadParticip(*args) + +def GetCmnNbrs(*args): + """ + GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NId1: int const & + NId2: int const & + + GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2, TIntV NbrV) -> int + + Parameters: + Graph: TPt< TNEANet > const & + NId1: int const & + NId2: int const & + NbrV: TIntV & + + """ + return _snap.GetCmnNbrs(*args) + +def GetModularity(*args): + """ + GetModularity(PNEANet G, TIntV NIdV, int GEdges=-1) -> double + + Parameters: + G: TPt< TNEANet > const & + NIdV: TIntV const & + GEdges: int + + GetModularity(PNEANet G, TIntV NIdV) -> double + + Parameters: + G: TPt< TNEANet > const & + NIdV: TIntV const & + + GetModularity(PNEANet G, TCnComV const & CmtyV, int GEdges=-1) -> double + + Parameters: + G: TPt< TNEANet > const & + CmtyV: TCnComV const & + GEdges: int + + GetModularity(PNEANet G, TCnComV const & CmtyV) -> double + + Parameters: + G: TPt< TNEANet > const & + CmtyV: TCnComV const & + + """ + return _snap.GetModularity(*args) + +def GetEdgesInOut(*args): + """ + GetEdgesInOut(PNEANet Graph, TIntV NIdV, int & EdgesIn, int & EdgesOut) + + Parameters: + Graph: TPt< TNEANet > const & + NIdV: TIntV const & + EdgesIn: int & + EdgesOut: int & + + """ + return _snap.GetEdgesInOut(*args) + +def GetAnf(*args): + """ + GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, + int const & NApprox=32) + + Parameters: + Graph: TPt< TNEANet > const & + SrcNId: int const & + DistNbrsV: TIntFltKdV & + MxDist: int const & + IsDir: bool const & + NApprox: int const & + + GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir) + + Parameters: + Graph: TPt< TNEANet > const & + SrcNId: int const & + DistNbrsV: TIntFltKdV & + MxDist: int const & + IsDir: bool const & + + GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, int const & NApprox=32) + + Parameters: + Graph: TPt< TNEANet > const & + DistNbrsV: TIntFltKdV & + MxDist: int const & + IsDir: bool const & + NApprox: int const & + + GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir) + + Parameters: + Graph: TPt< TNEANet > const & + DistNbrsV: TIntFltKdV & + MxDist: int const & + IsDir: bool const & + + """ + return _snap.GetAnf(*args) + +def GetAnfEffDiam(*args): + """ + GetAnfEffDiam(PNEANet Graph, bool const & IsDir, double const & Percentile, int const & NApprox) -> double + + Parameters: + Graph: TPt< TNEANet > const & + IsDir: bool const & + Percentile: double const & + NApprox: int const & + + GetAnfEffDiam(PNEANet Graph, int const NRuns=1, int NApprox=-1) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NRuns: int const + NApprox: int + + GetAnfEffDiam(PNEANet Graph, int const NRuns=1) -> double + + Parameters: + Graph: TPt< TNEANet > const & + NRuns: int const + + GetAnfEffDiam(PNEANet Graph) -> double + + Parameters: + Graph: TPt< TNEANet > const & + + """ + return _snap.GetAnfEffDiam(*args) + + diff --git a/snap-python/source/setup/snap_wrap.cxx b/snap-python/source/setup/snap_wrap.cxx new file mode 100644 index 0000000000000000000000000000000000000000..330f1907b2edd2d6189aece20dc939f53fcf3722 --- /dev/null +++ b/snap-python/source/setup/snap_wrap.cxx @@ -0,0 +1,124569 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.9 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#define SWIGPYTHON +#define SWIG_PYTHON_NO_BUILD_NONE +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + + + +/* Python.h has to appear first */ +#include + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCompare(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + register size_t l = 0; + register size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + register size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + register int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + register size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + register const unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + register unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register char d = *(c++); + register unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = ((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Warning: This function will allocate a new string in Python 3, + * so please call SWIG_Python_str_DelForPy3(x) to free the space. + */ +SWIGINTERN char* +SWIG_Python_str_AsChar(PyObject *str) +{ +#if PY_VERSION_HEX >= 0x03000000 + char *cstr; + char *newstr; + Py_ssize_t len; + str = PyUnicode_AsUTF8String(str); + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char *) malloc(len+1); + memcpy(newstr, cstr, len+1); + Py_XDECREF(str); + return newstr; +#else + return PyString_AsString(str); +#endif +} + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#else +# define SWIG_Python_str_DelForPy3(x) +#endif + + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +/* Add PyOS_snprintf for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) +# define PyOS_snprintf _snprintf +# else +# define PyOS_snprintf snprintf +# endif +#endif + +/* A crude PyString_FromFormat implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 + +#ifndef SWIG_PYBUFFER_SIZE +# define SWIG_PYBUFFER_SIZE 1024 +#endif + +static PyObject * +PyString_FromFormat(const char *fmt, ...) { + va_list ap; + char buf[SWIG_PYBUFFER_SIZE * 2]; + int res; + va_start(ap, fmt); + res = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); +} +#endif + +/* Add PyObject_Del for old Pythons */ +#if PY_VERSION_HEX < 0x01060000 +# define PyObject_Del(op) PyMem_DEL((op)) +#endif +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +/* A crude PyExc_StopIteration exception for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +# ifndef PyExc_StopIteration +# define PyExc_StopIteration PyExc_RuntimeError +# endif +# ifndef PyObject_GenericGetAttr +# define PyObject_GenericGetAttr 0 +# endif +#endif + +/* Py_NotImplemented is defined in 2.1 and up. */ +#if PY_VERSION_HEX < 0x02010000 +# ifndef Py_NotImplemented +# define Py_NotImplemented PyExc_RuntimeError +# endif +#endif + +/* A crude PyString_AsStringAndSize implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02010000 +# ifndef PyString_AsStringAndSize +# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} +# endif +#endif + +/* PySequence_Size for old Pythons */ +#if PY_VERSION_HEX < 0x02000000 +# ifndef PySequence_Size +# define PySequence_Size PySequence_Length +# endif +#endif + +/* PyBool_FromLong for old Pythons */ +#if PY_VERSION_HEX < 0x02030000 +static +PyObject *PyBool_FromLong(long ok) +{ + PyObject *result = ok ? Py_True : Py_False; + Py_INCREF(result); + return result; +} +#endif + +/* Py_ssize_t for old Pythons */ +/* This code is as recommended by: */ +/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ +#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +typedef int Py_ssize_t; +# define PY_SSIZE_T_MAX INT_MAX +# define PY_SSIZE_T_MIN INT_MIN +typedef inquiry lenfunc; +typedef intargfunc ssizeargfunc; +typedef intintargfunc ssizessizeargfunc; +typedef intobjargproc ssizeobjargproc; +typedef intintobjargproc ssizessizeobjargproc; +typedef getreadbufferproc readbufferproc; +typedef getwritebufferproc writebufferproc; +typedef getsegcountproc segcountproc; +typedef getcharbufferproc charbufferproc; +static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) +{ + long result = 0; + PyObject *i = PyNumber_Int(x); + if (i) { + result = PyInt_AsLong(i); + Py_DECREF(i); + } + return result; +} +#endif + +#if PY_VERSION_HEX < 0x02050000 +#define PyInt_FromSize_t(x) PyInt_FromLong((long)x) +#endif + +#if PY_VERSION_HEX < 0x02040000 +#define Py_VISIT(op) \ + do { \ + if (op) { \ + int vret = visit((op), arg); \ + if (vret) \ + return vret; \ + } \ + } while (0) +#endif + +#if PY_VERSION_HEX < 0x02030000 +typedef struct { + PyTypeObject type; + PyNumberMethods as_number; + PyMappingMethods as_mapping; + PySequenceMethods as_sequence; + PyBufferProcs as_buffer; + PyObject *name, *slots; +} PyHeapTypeObject; +#endif + +#if PY_VERSION_HEX < 0x02030000 +typedef destructor freefunc; +#endif + +#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ + (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ + (PY_MAJOR_VERSION > 3)) +# define SWIGPY_USE_CAPSULE +# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) +#endif + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); + if (value) { + char *tmp; + PyObject *old_str = PyObject_Str(value); + PyErr_Clear(); + Py_XINCREF(type); + + PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ +# define SWIG_PYTHON_USE_GIL +# endif +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + + +/* ----------------------------------------------------------------------------- + * Wrapper of PyInstanceMethod_New() used in Python 3 + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ +#if PY_VERSION_HEX >= 0x03000000 +SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) +{ + return PyInstanceMethod_New(func); +} +#else +SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) +{ + return NULL; +} +#endif + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { +#if PY_VERSION_HEX < 0x02030000 + PyDict_SetItemString(d, (char *)name, obj); +#else + PyDict_SetItemString(d, name, obj); +#endif + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { +#if PY_VERSION_HEX < 0x02030000 + PyDict_SetItemString(d, (char *)name, obj); +#else + PyDict_SetItemString(d, name, obj); +#endif + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { +#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +#else + PyObject* o2; + PyObject* o3; + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyTuple_Check(result)) { + o2 = result; + result = PyTuple_New(1); + PyTuple_SET_ITEM(result, 0, o2); + } + o3 = PyTuple_New(1); + PyTuple_SET_ITEM(o3, 0, obj); + o2 = result; + result = PySequence_Concat(o2, o3); + Py_DECREF(o2); + Py_DECREF(o3); + } + return result; +#endif +} + +/* Unpack the argument tuple */ + +SWIGINTERN int +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + register int i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + register Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + register int i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#if PY_VERSION_HEX >= 0x02020000 +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); +#else +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); +#endif + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* How to access Py_None */ +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# ifndef SWIG_PYTHON_NO_BUILD_NONE +# ifndef SWIG_PYTHON_BUILD_NONE +# define SWIG_PYTHON_BUILD_NONE +# endif +# endif +#endif + +#ifdef SWIG_PYTHON_BUILD_NONE +# ifdef Py_None +# undef Py_None +# define Py_None SWIG_Py_None() +# endif +SWIGRUNTIMEINLINE PyObject * +_SWIG_Py_None(void) +{ + PyObject *none = Py_BuildValue((char*)""); + Py_DECREF(none); + return none; +} +SWIGRUNTIME PyObject * +SWIG_Py_None(void) +{ + static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); + return none; +} +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + return data ? data->implicitconv : 0; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { +#if (PY_VERSION_HEX < 0x02020000) + data->newraw = 0; +#else + data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); +#endif + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); +#ifdef METH_O + data->delargs = !(flags & (METH_O)); +#else + data->delargs = 0; +#endif + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { + PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +#ifdef METH_NOARGS +SwigPyObject_repr(SwigPyObject *v) +#else +SwigPyObject_repr(SwigPyObject *v, PyObject *args) +#endif +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (v->next) { +# ifdef METH_NOARGS + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); +# else + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); +# endif +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } + return repr; +} + +SWIGRUNTIME int +SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +{ + char *str; +#ifdef METH_NOARGS + PyObject *repr = SwigPyObject_repr(v); +#else + PyObject *repr = SwigPyObject_repr(v, NULL); +#endif + if (repr) { + str = SWIG_Python_str_AsChar(repr); + fputs(str, fp); + SWIG_Python_str_DelForPy3(str); + Py_DECREF(repr); + return 0; + } else { + return 1; + } +} + +SWIGRUNTIME PyObject * +SwigPyObject_str(SwigPyObject *v) +{ + char result[SWIG_BUFFER_SIZE]; + return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? + SWIG_Python_str_FromChar(result) : 0; +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res; + if( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { +#ifdef SWIGPYTHON_BUILTIN + PyTypeObject *target_tp = SwigPyObject_type(); + if (PyType_IsSubtype(op->ob_type, target_tp)) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); +#else + return (Py_TYPE(op) == SwigPyObject_type()) + || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; +#ifndef METH_O + PyObject *tmp = 0; + if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; + next = tmp; +#endif + if (!SwigPyObject_Check(next)) { + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +#ifdef METH_NOARGS +SwigPyObject_next(PyObject* v) +#else +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +SwigPyObject_disown(PyObject *v) +#else +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +SwigPyObject_acquire(PyObject *v) +#else +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; +#if (PY_VERSION_HEX < 0x02020000) + if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) +#elif (PY_VERSION_HEX < 0x02050000) + if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) +#else + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) +#endif + { + return NULL; + } + else + { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { +#ifdef METH_NOARGS + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v); + } else { + SwigPyObject_disown(v); + } +#else + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v,args); + } else { + SwigPyObject_disown(v,args); + } +#endif + } + return obj; + } +} + +#ifdef METH_O +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, + {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"}, + {0, 0, 0, 0} +}; +#else +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, + {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, + {0, 0, 0, 0} +}; +#endif + +#if PY_VERSION_HEX < 0x02020000 +SWIGINTERN PyObject * +SwigPyObject_getattr(SwigPyObject *sobj,char *name) +{ + return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); +} +#endif + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ +#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ + 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { + /* PyObject header changed in Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + (char *)"SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + (printfunc)SwigPyObject_print, /* tp_print */ +#if PY_VERSION_HEX < 0x02020000 + (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ +#else + (getattrfunc)0, /* tp_getattr */ +#endif + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyObject_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#if PY_VERSION_HEX >= 0x02060000 + 0, /* tp_version */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; +#if PY_VERSION_HEX < 0x02020000 + swigpyobject_type.ob_type = &PyType_Type; +#else + if (PyType_Ready(&swigpyobject_type) < 0) + return NULL; +#endif + } + return &swigpyobject_type; +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME int +SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +{ + char result[SWIG_BUFFER_SIZE]; + fputs("pack, v->size, 0, sizeof(result))) { + fputs("at ", fp); + fputs(result, fp); + } + fputs(v->ty->name,fp); + fputs(">", fp); + return 0; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) + || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { + /* PyObject header changed in Python 3 */ +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + (char *)"SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + (printfunc)SwigPyPacked_print, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#if PY_VERSION_HEX >= 0x02060000 + 0, /* tp_version */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; +#if PY_VERSION_HEX < 0x02020000 + swigpypacked_type.ob_type = &PyType_Type; +#else + if (PyType_Ready(&swigpypacked_type) < 0) + return NULL; +#endif + } + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIMEINLINE PyObject * +_SWIG_This(void) +{ + return SWIG_Python_str_FromChar("this"); +} + +static PyObject *swig_this = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (swig_this == NULL) + swig_this = _SWIG_This(); + return swig_this; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None) { + if (ptr) + *ptr = 0; + return SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + res = SWIG_OK; + } else { + if (flags & SWIG_POINTER_IMPLICIT_CONV) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) + return SWIG_ERROR; + if (ty) { + swig_cast_info *tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + } else { + *ptr = vptr; + } + return SWIG_OK; + } +} + +/* Convert a packed value value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ +#if (PY_VERSION_HEX >= 0x02020000) + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); + if (inst) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +#else +#if (PY_VERSION_HEX >= 0x02010000) + PyObject *inst = 0; + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } + return (PyObject *) inst; +#else + PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); + if (inst == NULL) { + return NULL; + } + inst->in_class = (PyClassObject *)data->newargs; + Py_INCREF(inst->in_class); + inst->in_dict = PyDict_New(); + if (inst->in_dict == NULL) { + Py_DECREF(inst); + return NULL; + } +#ifdef Py_TPFLAGS_HAVE_WEAKREFS + inst->in_weakreflist = NULL; +#endif +#ifdef Py_TPFLAGS_GC + PyObject_GC_Init(inst); +#endif + PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); + return (PyObject *) inst; +#endif +#endif +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, (char*)"__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { + PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else +# ifdef SWIGPY_USE_CAPSULE + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); +# else + type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); +# endif + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +#if PY_MAJOR_VERSION < 2 +/* PyModule_AddObject function was introduced in Python 2.0. The following function + is copied out of Python/modsupport.c in python version 2.3.4 */ +SWIGINTERN int +PyModule_AddObject(PyObject *m, char *name, PyObject *o) +{ + PyObject *dict; + if (!PyModule_Check(m)) { + PyErr_SetString(PyExc_TypeError, + "PyModule_AddObject() needs module as first arg"); + return SWIG_ERROR; + } + if (!o) { + PyErr_SetString(PyExc_TypeError, + "PyModule_AddObject() needs non-NULL value"); + return SWIG_ERROR; + } + + dict = PyModule_GetDict(m); + if (dict == NULL) { + /* Internal error -- modules must have a dict! */ + PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", + PyModule_GetName(m)); + return SWIG_ERROR; + } + if (PyDict_SetItemString(dict, name, o)) + return SWIG_ERROR; + Py_DECREF(o); + return SWIG_OK; +} +#endif + +SWIGRUNTIME void +#ifdef SWIGPY_USE_CAPSULE +SWIG_Python_DestroyModule(PyObject *obj) +#else +SWIG_Python_DestroyModule(void *vptr) +#endif +{ +#ifdef SWIGPY_USE_CAPSULE + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); +#else + swig_module_info *swig_module = (swig_module_info *) vptr; +#endif + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + swig_this = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif +#ifdef SWIGPY_USE_CAPSULE + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +#else + PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +#endif +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { +#ifdef SWIGPY_USE_CAPSULE + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); +#else + descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); +#endif + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { +#ifdef SWIGPY_USE_CAPSULE + obj = PyCapsule_New((void*) descriptor, NULL, NULL); +#else + obj = PyCObject_FromVoidPtr(descriptor, NULL); +#endif + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + char *tmp; + PyObject *old_str = PyObject_Str(value); + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); + } else { + PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +#if SWIG_POINTER_EXCEPTION + if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } +#endif + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) < 0) + goto done; + } + + res = -1; + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_FILE swig_types[0] +#define SWIGTYPE_p_PGStatVec swig_types[1] +#define SWIGTYPE_p_PGraph swig_types[2] +#define SWIGTYPE_p_PNet swig_types[3] +#define SWIGTYPE_p_PVecT_TAscFlt_t swig_types[4] +#define SWIGTYPE_p_PVecT_TFlt_t swig_types[5] +#define SWIGTYPE_p_PVecT_TStr_t swig_types[6] +#define SWIGTYPE_p_TArtPointVisitor swig_types[7] +#define SWIGTYPE_p_TAscFlt swig_types[8] +#define SWIGTYPE_p_TBPGraph swig_types[9] +#define SWIGTYPE_p_TBPGraph__TEdgeI swig_types[10] +#define SWIGTYPE_p_TBPGraph__TNode swig_types[11] +#define SWIGTYPE_p_TBPGraph__TNodeI swig_types[12] +#define SWIGTYPE_p_TBiConVisitor swig_types[13] +#define SWIGTYPE_p_TBigStrPool swig_types[14] +#define SWIGTYPE_p_TBool swig_types[15] +#define SWIGTYPE_p_TCRef swig_types[16] +#define SWIGTYPE_p_TCh swig_types[17] +#define SWIGTYPE_p_TChA swig_types[18] +#define SWIGTYPE_p_TChAIn swig_types[19] +#define SWIGTYPE_p_TChRet swig_types[20] +#define SWIGTYPE_p_TCnCom swig_types[21] +#define SWIGTYPE_p_TConv_Pt64Ints32 swig_types[22] +#define SWIGTYPE_p_TCs swig_types[23] +#define SWIGTYPE_p_TDbStr swig_types[24] +#define SWIGTYPE_p_TFAccess swig_types[25] +#define SWIGTYPE_p_TFIn swig_types[26] +#define SWIGTYPE_p_TFInOut swig_types[27] +#define SWIGTYPE_p_TFOut swig_types[28] +#define SWIGTYPE_p_TFfGGen swig_types[29] +#define SWIGTYPE_p_TFile swig_types[30] +#define SWIGTYPE_p_TFlt swig_types[31] +#define SWIGTYPE_p_TFltRect swig_types[32] +#define SWIGTYPE_p_TFltV__TIter swig_types[33] +#define SWIGTYPE_p_TForestFire swig_types[34] +#define SWIGTYPE_p_TGUtil swig_types[35] +#define SWIGTYPE_p_TGVizLayout_ swig_types[36] +#define SWIGTYPE_p_TGraphFlag swig_types[37] +#define SWIGTYPE_p_THKeyDat swig_types[38] +#define SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t swig_types[39] +#define SWIGTYPE_p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t swig_types[40] +#define SWIGTYPE_p_THashKeyDatT_TInt_TInt_t swig_types[41] +#define SWIGTYPE_p_THashT_TCh_TCh_TDefaultHashFuncT_TCh_t_t swig_types[42] +#define SWIGTYPE_p_THashT_TDbStr_TInt_TDefaultHashFuncT_TDbStr_t_t swig_types[43] +#define SWIGTYPE_p_THashT_TDbStr_TStr_TDefaultHashFuncT_TDbStr_t_t swig_types[44] +#define SWIGTYPE_p_THashT_TFlt_TFlt_TDefaultHashFuncT_TFlt_t_t swig_types[45] +#define SWIGTYPE_p_THashT_TInt_TBool_TDefaultHashFuncT_TInt_t_t swig_types[46] +#define SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t swig_types[47] +#define SWIGTYPE_p_THashT_TInt_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t_TDefaultHashFuncT_TInt_t_t swig_types[48] +#define SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t swig_types[49] +#define SWIGTYPE_p_THashT_TInt_TPairT_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t swig_types[50] +#define SWIGTYPE_p_THashT_TInt_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TInt_t_t swig_types[51] +#define SWIGTYPE_p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t swig_types[52] +#define SWIGTYPE_p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t swig_types[53] +#define SWIGTYPE_p_THashT_TInt_TTripleT_TFlt_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t swig_types[54] +#define SWIGTYPE_p_THashT_TInt_TUInt64_TDefaultHashFuncT_TInt_t_t swig_types[55] +#define SWIGTYPE_p_THashT_TInt_TVecT_TFlt_int_t_TDefaultHashFuncT_TInt_t_t swig_types[56] +#define SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t swig_types[57] +#define SWIGTYPE_p_THashT_TInt_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TInt_t_t swig_types[58] +#define SWIGTYPE_p_THashT_TInt_TVecT_TStr_int_t_TDefaultHashFuncT_TInt_t_t swig_types[59] +#define SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t swig_types[60] +#define SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TInt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t swig_types[61] +#define SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TStr_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t swig_types[62] +#define SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TVecT_TInt_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t swig_types[63] +#define SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t swig_types[64] +#define SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t swig_types[65] +#define SWIGTYPE_p_THashT_TPairT_TInt_TStr_t_TInt_TDefaultHashFuncT_TPairT_TInt_TStr_t_t_t swig_types[66] +#define SWIGTYPE_p_THashT_TPairT_TStr_TInt_t_TInt_TDefaultHashFuncT_TPairT_TStr_TInt_t_t_t swig_types[67] +#define SWIGTYPE_p_THashT_TPairT_TStr_TStr_t_TBool_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t swig_types[68] +#define SWIGTYPE_p_THashT_TPairT_TStr_TStr_t_TFlt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t swig_types[69] +#define SWIGTYPE_p_THashT_TPairT_TStr_TStr_t_TInt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t swig_types[70] +#define SWIGTYPE_p_THashT_TPairT_TStr_TStr_t_TStr_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t swig_types[71] +#define SWIGTYPE_p_THashT_TPairT_TStr_TStr_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t swig_types[72] +#define SWIGTYPE_p_THashT_TStr_TBool_TDefaultHashFuncT_TStr_t_t swig_types[73] +#define SWIGTYPE_p_THashT_TStr_TFlt_TDefaultHashFuncT_TStr_t_t swig_types[74] +#define SWIGTYPE_p_THashT_TStr_TInt_TDefaultHashFuncT_TStr_t_t swig_types[75] +#define SWIGTYPE_p_THashT_TStr_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TStr_t_t swig_types[76] +#define SWIGTYPE_p_THashT_TStr_TPairT_TInt_TInt_t_TDefaultHashFuncT_TStr_t_t swig_types[77] +#define SWIGTYPE_p_THashT_TStr_TPairT_TStr_TStr_t_TDefaultHashFuncT_TStr_t_t swig_types[78] +#define SWIGTYPE_p_THashT_TStr_TStr_TDefaultHashFuncT_TStr_t_t swig_types[79] +#define SWIGTYPE_p_THashT_TStr_TUInt64_TDefaultHashFuncT_TStr_t_t swig_types[80] +#define SWIGTYPE_p_THashT_TStr_TVecT_TFlt_int_t_TDefaultHashFuncT_TStr_t_t swig_types[81] +#define SWIGTYPE_p_THashT_TStr_TVecT_TInt_int_t_TDefaultHashFuncT_TStr_t_t swig_types[82] +#define SWIGTYPE_p_THashT_TStr_TVecT_TKeyDatT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t swig_types[83] +#define SWIGTYPE_p_THashT_TStr_TVecT_TKeyDatT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t swig_types[84] +#define SWIGTYPE_p_THashT_TStr_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t swig_types[85] +#define SWIGTYPE_p_THashT_TStr_TVecT_TPairT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t swig_types[86] +#define SWIGTYPE_p_THashT_TStr_TVecT_TPairT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t swig_types[87] +#define SWIGTYPE_p_THashT_TStr_TVecT_TStr_int_t_TDefaultHashFuncT_TStr_t_t swig_types[88] +#define SWIGTYPE_p_THashT_TStr_TVecT_TUInt64_int_t_TDefaultHashFuncT_TStr_t_t swig_types[89] +#define SWIGTYPE_p_THashT_TTripleT_TCh_TCh_TCh_t_TInt_TDefaultHashFuncT_TTripleT_TCh_TCh_TCh_t_t_t swig_types[90] +#define SWIGTYPE_p_THashT_TTripleT_TInt_TInt_TInt_t_TFlt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t swig_types[91] +#define SWIGTYPE_p_THashT_TTripleT_TInt_TInt_TInt_t_TInt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t swig_types[92] +#define SWIGTYPE_p_THashT_TTripleT_TStr_TStr_TStr_t_TInt_TDefaultHashFuncT_TTripleT_TStr_TStr_TStr_t_t_t swig_types[93] +#define SWIGTYPE_p_THashT_TUInt64_TInt_TDefaultHashFuncT_TUInt64_t_t swig_types[94] +#define SWIGTYPE_p_THashT_TUInt64_TVecT_TStr_int_t_TDefaultHashFuncT_TUInt64_t_t swig_types[95] +#define SWIGTYPE_p_THashT_TUInt_TUInt_TDefaultHashFuncT_TUInt_t_t swig_types[96] +#define SWIGTYPE_p_THashT_TVecT_TInt_int_t_TInt_TDefaultHashFuncT_TVecT_TInt_int_t_t_t swig_types[97] +#define SWIGTYPE_p_THashT_TVecT_TStr_int_t_TInt_TDefaultHashFuncT_TVecT_TStr_int_t_t_t swig_types[98] +#define SWIGTYPE_p_THashT_TVecT_TStr_int_t_TStr_TDefaultHashFuncT_TVecT_TStr_int_t_t_t swig_types[99] +#define SWIGTYPE_p_THashT_TVecT_TStr_int_t_TVecT_TInt_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t swig_types[100] +#define SWIGTYPE_p_THashT_TVecT_TStr_int_t_TVecT_TStr_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t swig_types[101] +#define SWIGTYPE_p_TILx swig_types[102] +#define SWIGTYPE_p_TInt swig_types[103] +#define SWIGTYPE_p_TIntSet swig_types[104] +#define SWIGTYPE_p_TIntV__TIter swig_types[105] +#define SWIGTYPE_p_TIter swig_types[106] +#define SWIGTYPE_p_TKeyDatT_TAscFlt_TInt_t swig_types[107] +#define SWIGTYPE_p_TKeyDatT_TFlt_TBool_t swig_types[108] +#define SWIGTYPE_p_TKeyDatT_TFlt_TFlt_t swig_types[109] +#define SWIGTYPE_p_TKeyDatT_TFlt_TInt_t swig_types[110] +#define SWIGTYPE_p_TKeyDatT_TFlt_TPairT_TInt_TBool_t_t swig_types[111] +#define SWIGTYPE_p_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t swig_types[112] +#define SWIGTYPE_p_TKeyDatT_TFlt_TStr_t swig_types[113] +#define SWIGTYPE_p_TKeyDatT_TFlt_TUInt64_t swig_types[114] +#define SWIGTYPE_p_TKeyDatT_TFlt_TUInt_t swig_types[115] +#define SWIGTYPE_p_TKeyDatT_TInt_TFlt_t swig_types[116] +#define SWIGTYPE_p_TKeyDatT_TInt_TInt_t swig_types[117] +#define SWIGTYPE_p_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t swig_types[118] +#define SWIGTYPE_p_TKeyDatT_TInt_TSFlt_t swig_types[119] +#define SWIGTYPE_p_TKeyDatT_TInt_TStr_t swig_types[120] +#define SWIGTYPE_p_TKeyDatT_TInt_TUInt64_t swig_types[121] +#define SWIGTYPE_p_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t swig_types[122] +#define SWIGTYPE_p_TKeyDatT_TStr_TAscFlt_t swig_types[123] +#define SWIGTYPE_p_TKeyDatT_TStr_TBool_t swig_types[124] +#define SWIGTYPE_p_TKeyDatT_TStr_TFlt_t swig_types[125] +#define SWIGTYPE_p_TKeyDatT_TStr_TInt_t swig_types[126] +#define SWIGTYPE_p_TKeyDatT_TStr_TStr_t swig_types[127] +#define SWIGTYPE_p_TKeyDatT_TUInt64_TFlt_t swig_types[128] +#define SWIGTYPE_p_TKeyDatT_TUInt64_TInt_t swig_types[129] +#define SWIGTYPE_p_TKeyDatT_TUInt64_TStr_t swig_types[130] +#define SWIGTYPE_p_TKeyDatT_TUInt_TInt_t swig_types[131] +#define SWIGTYPE_p_TKeyDatT_TUInt_TUInt_t swig_types[132] +#define SWIGTYPE_p_TLFlt swig_types[133] +#define SWIGTYPE_p_TLnRet swig_types[134] +#define SWIGTYPE_p_TLoc swig_types[135] +#define SWIGTYPE_p_TLogOp swig_types[136] +#define SWIGTYPE_p_TLstT_TFlt_t swig_types[137] +#define SWIGTYPE_p_TLstT_TInt_t swig_types[138] +#define SWIGTYPE_p_TLstT_TKeyDatT_TAscFlt_TInt_t_t swig_types[139] +#define SWIGTYPE_p_TLstT_TKeyDatT_TFlt_TInt_t_t swig_types[140] +#define SWIGTYPE_p_TLstT_TKeyDatT_TInt_TInt_t_t swig_types[141] +#define SWIGTYPE_p_TLstT_TStr_t swig_types[142] +#define SWIGTYPE_p_TMIn swig_types[143] +#define SWIGTYPE_p_TMOut swig_types[144] +#define SWIGTYPE_p_TMem swig_types[145] +#define SWIGTYPE_p_TMemIn swig_types[146] +#define SWIGTYPE_p_TMemOut swig_types[147] +#define SWIGTYPE_p_TNEANet swig_types[148] +#define SWIGTYPE_p_TNEANetAFltI swig_types[149] +#define SWIGTYPE_p_TNEANetAIntI swig_types[150] +#define SWIGTYPE_p_TNEANetAStrI swig_types[151] +#define SWIGTYPE_p_TNEANetEdgeI swig_types[152] +#define SWIGTYPE_p_TNEANetNodeI swig_types[153] +#define SWIGTYPE_p_TNEANet__TAFltI swig_types[154] +#define SWIGTYPE_p_TNEANet__TAIntI swig_types[155] +#define SWIGTYPE_p_TNEANet__TAStrI swig_types[156] +#define SWIGTYPE_p_TNEANet__TEdgeI swig_types[157] +#define SWIGTYPE_p_TNEANet__TNode swig_types[158] +#define SWIGTYPE_p_TNEANet__TNodeI swig_types[159] +#define SWIGTYPE_p_TNEGraph swig_types[160] +#define SWIGTYPE_p_TNEGraph__TEdgeI swig_types[161] +#define SWIGTYPE_p_TNEGraph__TNode swig_types[162] +#define SWIGTYPE_p_TNEGraph__TNodeI swig_types[163] +#define SWIGTYPE_p_TNGraph swig_types[164] +#define SWIGTYPE_p_TNGraphEdgeI swig_types[165] +#define SWIGTYPE_p_TNGraphMtx swig_types[166] +#define SWIGTYPE_p_TNGraphNodeI swig_types[167] +#define SWIGTYPE_p_TNGraph__TEdgeI swig_types[168] +#define SWIGTYPE_p_TNGraph__TNode swig_types[169] +#define SWIGTYPE_p_TNGraph__TNodeI swig_types[170] +#define SWIGTYPE_p_TNet swig_types[171] +#define SWIGTYPE_p_TNodeEDatNetT_TInt_TFlt_t swig_types[172] +#define SWIGTYPE_p_TNodeEDatNetT_TInt_TInt_t swig_types[173] +#define SWIGTYPE_p_TNodeEDatNetT_TStr_TInt_t swig_types[174] +#define SWIGTYPE_p_TNodeEdgeNetT_TFlt_TFlt_t swig_types[175] +#define SWIGTYPE_p_TNodeEdgeNetT_TInt_TInt_t swig_types[176] +#define SWIGTYPE_p_TNodeNetT_TFlt_t swig_types[177] +#define SWIGTYPE_p_TNodeNetT_TInt_t swig_types[178] +#define SWIGTYPE_p_TNodeNetT_TStr_t swig_types[179] +#define SWIGTYPE_p_TNodeTy swig_types[180] +#define SWIGTYPE_p_TOLx swig_types[181] +#define SWIGTYPE_p_TObj swig_types[182] +#define SWIGTYPE_p_TPairHashImpl1 swig_types[183] +#define SWIGTYPE_p_TPairHashImpl2 swig_types[184] +#define SWIGTYPE_p_TPairT_TAscFlt_TAscFlt_t swig_types[185] +#define SWIGTYPE_p_TPairT_TAscFlt_TInt_t swig_types[186] +#define SWIGTYPE_p_TPairT_TAscFlt_TStr_t swig_types[187] +#define SWIGTYPE_p_TPairT_TBool_TCh_t swig_types[188] +#define SWIGTYPE_p_TPairT_TBool_TFlt_t swig_types[189] +#define SWIGTYPE_p_TPairT_TFlt_TFlt_t swig_types[190] +#define SWIGTYPE_p_TPairT_TFlt_TInt_t swig_types[191] +#define SWIGTYPE_p_TPairT_TFlt_TPairT_TStr_TStr_t_t swig_types[192] +#define SWIGTYPE_p_TPairT_TFlt_TStr_t swig_types[193] +#define SWIGTYPE_p_TPairT_TFlt_TUInt64_t swig_types[194] +#define SWIGTYPE_p_TPairT_TInt_TBool_t swig_types[195] +#define SWIGTYPE_p_TPairT_TInt_TCh_t swig_types[196] +#define SWIGTYPE_p_TPairT_TInt_TFlt_t swig_types[197] +#define SWIGTYPE_p_TPairT_TInt_TInt_t swig_types[198] +#define SWIGTYPE_p_TPairT_TInt_TPairT_TInt_TInt_t_t swig_types[199] +#define SWIGTYPE_p_TPairT_TInt_TPairT_TStr_TStr_t_t swig_types[200] +#define SWIGTYPE_p_TPairT_TInt_TStr_t swig_types[201] +#define SWIGTYPE_p_TPairT_TInt_TUInt64_t swig_types[202] +#define SWIGTYPE_p_TPairT_TInt_TVecT_TInt_int_t_t swig_types[203] +#define SWIGTYPE_p_TPairT_TInt_TVecT_TStr_int_t_t swig_types[204] +#define SWIGTYPE_p_TPairT_TPairT_TInt_TInt_t_TInt_t swig_types[205] +#define SWIGTYPE_p_TPairT_TStr_TFlt_t swig_types[206] +#define SWIGTYPE_p_TPairT_TStr_TInt_t swig_types[207] +#define SWIGTYPE_p_TPairT_TStr_TStr_t swig_types[208] +#define SWIGTYPE_p_TPairT_TStr_TVecT_TStr_int_t_t swig_types[209] +#define SWIGTYPE_p_TPairT_TUCh_TInt_t swig_types[210] +#define SWIGTYPE_p_TPairT_TUCh_TStr_t swig_types[211] +#define SWIGTYPE_p_TPairT_TUCh_TUInt64_t swig_types[212] +#define SWIGTYPE_p_TPairT_TUInt64_TFlt_t swig_types[213] +#define SWIGTYPE_p_TPairT_TUInt64_TInt_t swig_types[214] +#define SWIGTYPE_p_TPairT_TUInt64_TStr_t swig_types[215] +#define SWIGTYPE_p_TPairT_TUInt64_TUInt64_t swig_types[216] +#define SWIGTYPE_p_TPairT_TUInt_TInt_t swig_types[217] +#define SWIGTYPE_p_TPairT_TUInt_TUInt_t swig_types[218] +#define SWIGTYPE_p_TPairT_TVecT_TStr_int_t_TInt_t swig_types[219] +#define SWIGTYPE_p_TPtT_PVecT_TAscFlt_t_t swig_types[220] +#define SWIGTYPE_p_TPtT_PVecT_TFlt_t_t swig_types[221] +#define SWIGTYPE_p_TPtT_PVecT_TStr_t_t swig_types[222] +#define SWIGTYPE_p_TPtT_TBPGraph_t swig_types[223] +#define SWIGTYPE_p_TPtT_TBigStrPool_t swig_types[224] +#define SWIGTYPE_p_TPtT_TExcept_t swig_types[225] +#define SWIGTYPE_p_TPtT_TFRnd_t swig_types[226] +#define SWIGTYPE_p_TPtT_TMem_t swig_types[227] +#define SWIGTYPE_p_TPtT_TNEANet_t swig_types[228] +#define SWIGTYPE_p_TPtT_TNEGraph_t swig_types[229] +#define SWIGTYPE_p_TPtT_TNGraph_t swig_types[230] +#define SWIGTYPE_p_TPtT_TNodeEDatNetT_TInt_TFlt_t_t swig_types[231] +#define SWIGTYPE_p_TPtT_TNodeEDatNetT_TInt_TInt_t_t swig_types[232] +#define SWIGTYPE_p_TPtT_TNodeEDatNetT_TStr_TInt_t_t swig_types[233] +#define SWIGTYPE_p_TPtT_TNodeEdgeNetT_TFlt_TFlt_t_t swig_types[234] +#define SWIGTYPE_p_TPtT_TNodeEdgeNetT_TInt_TInt_t_t swig_types[235] +#define SWIGTYPE_p_TPtT_TNodeNetT_TFlt_t_t swig_types[236] +#define SWIGTYPE_p_TPtT_TNodeNetT_TInt_t_t swig_types[237] +#define SWIGTYPE_p_TPtT_TNodeNetT_TStr_t_t swig_types[238] +#define SWIGTYPE_p_TPtT_TSInOut_t swig_types[239] +#define SWIGTYPE_p_TPtT_TSIn_t swig_types[240] +#define SWIGTYPE_p_TPtT_TSOut_t swig_types[241] +#define SWIGTYPE_p_TPtT_TStrPool64_t swig_types[242] +#define SWIGTYPE_p_TPtT_TStrPool_t swig_types[243] +#define SWIGTYPE_p_TPtT_TUNGraph_t swig_types[244] +#define SWIGTYPE_p_TPtT_TVecPoolT_TInt_int_t_t swig_types[245] +#define SWIGTYPE_p_TPtT_TXmlDoc_t swig_types[246] +#define SWIGTYPE_p_TPtT_TXmlTok_t swig_types[247] +#define SWIGTYPE_p_TQQueueT_TFlt_t swig_types[248] +#define SWIGTYPE_p_TQQueueT_TInt_t swig_types[249] +#define SWIGTYPE_p_TQQueueT_TPairT_TInt_TInt_t_t swig_types[250] +#define SWIGTYPE_p_TQQueueT_TPairT_TInt_TStr_t_t swig_types[251] +#define SWIGTYPE_p_TQQueueT_TStr_t swig_types[252] +#define SWIGTYPE_p_TQQueueT_TVecT_TAscFlt_int_t_t swig_types[253] +#define SWIGTYPE_p_TQQueueT_TVecT_TFlt_int_t_t swig_types[254] +#define SWIGTYPE_p_TQuadT_TFlt_TFlt_TFlt_TFlt_t swig_types[255] +#define SWIGTYPE_p_TQuadT_TFlt_TInt_TInt_TInt_t swig_types[256] +#define SWIGTYPE_p_TQuadT_TInt_TInt_TFlt_TFlt_t swig_types[257] +#define SWIGTYPE_p_TQuadT_TInt_TInt_TInt_TInt_t swig_types[258] +#define SWIGTYPE_p_TQuadT_TInt_TStr_TInt_TInt_t swig_types[259] +#define SWIGTYPE_p_TQuadT_TStr_TStr_TInt_TInt_t swig_types[260] +#define SWIGTYPE_p_TQuadT_TStr_TStr_TStr_TStr_t swig_types[261] +#define SWIGTYPE_p_TRStr swig_types[262] +#define SWIGTYPE_p_TRelOp swig_types[263] +#define SWIGTYPE_p_TRnd swig_types[264] +#define SWIGTYPE_p_TSBase swig_types[265] +#define SWIGTYPE_p_TSFlt swig_types[266] +#define SWIGTYPE_p_TSIn swig_types[267] +#define SWIGTYPE_p_TSInOut swig_types[268] +#define SWIGTYPE_p_TSInt swig_types[269] +#define SWIGTYPE_p_TSOut swig_types[270] +#define SWIGTYPE_p_TSOutMnp swig_types[271] +#define SWIGTYPE_p_TSStackT_TInt_t swig_types[272] +#define SWIGTYPE_p_TSStackT_TPairT_TBool_TCh_t_t swig_types[273] +#define SWIGTYPE_p_TSStackT_TPairT_TInt_TInt_t_t swig_types[274] +#define SWIGTYPE_p_TSStr swig_types[275] +#define SWIGTYPE_p_TSecTm swig_types[276] +#define SWIGTYPE_p_TSizeTy swig_types[277] +#define SWIGTYPE_p_TStdIn swig_types[278] +#define SWIGTYPE_p_TStdOut swig_types[279] +#define SWIGTYPE_p_TStopReason swig_types[280] +#define SWIGTYPE_p_TStr swig_types[281] +#define SWIGTYPE_p_TStrHashF_DJB swig_types[282] +#define SWIGTYPE_p_TStrHashF_Md5 swig_types[283] +#define SWIGTYPE_p_TStrHashF_OldGLib swig_types[284] +#define SWIGTYPE_p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t swig_types[285] +#define SWIGTYPE_p_TStrHashT_TVecT_TInt_int_t_TStrPool_TDefaultHashFuncT_TStr_t_t swig_types[286] +#define SWIGTYPE_p_TStrIn swig_types[287] +#define SWIGTYPE_p_TStrIntPrH__TIter swig_types[288] +#define SWIGTYPE_p_TStrPool swig_types[289] +#define SWIGTYPE_p_TStrPool64 swig_types[290] +#define SWIGTYPE_p_TStrUtil swig_types[291] +#define SWIGTYPE_p_TStrV__TIter swig_types[292] +#define SWIGTYPE_p_TTreeT_TFlt_t swig_types[293] +#define SWIGTYPE_p_TTreeT_TInt_t swig_types[294] +#define SWIGTYPE_p_TTreeT_TPairT_TStr_TInt_t_t swig_types[295] +#define SWIGTYPE_p_TTreeT_TStr_t swig_types[296] +#define SWIGTYPE_p_TTreeT_TTripleT_TStr_TInt_TVecT_TStr_int_t_t_t swig_types[297] +#define SWIGTYPE_p_TTripleT_TChA_TChA_TChA_t swig_types[298] +#define SWIGTYPE_p_TTripleT_TCh_TCh_TCh_t swig_types[299] +#define SWIGTYPE_p_TTripleT_TCh_TInt_TInt_t swig_types[300] +#define SWIGTYPE_p_TTripleT_TFlt_TFlt_TFlt_t swig_types[301] +#define SWIGTYPE_p_TTripleT_TFlt_TFlt_TInt_t swig_types[302] +#define SWIGTYPE_p_TTripleT_TFlt_TFlt_TStr_t swig_types[303] +#define SWIGTYPE_p_TTripleT_TFlt_TInt_TInt_t swig_types[304] +#define SWIGTYPE_p_TTripleT_TInt_TFlt_TFlt_t swig_types[305] +#define SWIGTYPE_p_TTripleT_TInt_TFlt_TInt_t swig_types[306] +#define SWIGTYPE_p_TTripleT_TInt_TInt_TFlt_t swig_types[307] +#define SWIGTYPE_p_TTripleT_TInt_TInt_TInt_t swig_types[308] +#define SWIGTYPE_p_TTripleT_TInt_TInt_TStr_t swig_types[309] +#define SWIGTYPE_p_TTripleT_TInt_TInt_TVecT_TInt_int_t_t swig_types[310] +#define SWIGTYPE_p_TTripleT_TInt_TStr_TInt_t swig_types[311] +#define SWIGTYPE_p_TTripleT_TInt_TVecT_TInt_int_t_TInt_t swig_types[312] +#define SWIGTYPE_p_TTripleT_TStr_TFlt_TFlt_t swig_types[313] +#define SWIGTYPE_p_TTripleT_TStr_TInt_TInt_t swig_types[314] +#define SWIGTYPE_p_TTripleT_TStr_TInt_TVecT_TStr_int_t_t swig_types[315] +#define SWIGTYPE_p_TTripleT_TStr_TStr_TInt_t swig_types[316] +#define SWIGTYPE_p_TTripleT_TStr_TStr_TStr_t swig_types[317] +#define SWIGTYPE_p_TTripleT_TUCh_TInt_TInt_t swig_types[318] +#define SWIGTYPE_p_TTripleT_TUInt64_TUInt64_TUInt64_t swig_types[319] +#define SWIGTYPE_p_TUCh swig_types[320] +#define SWIGTYPE_p_TUInt swig_types[321] +#define SWIGTYPE_p_TUInt64 swig_types[322] +#define SWIGTYPE_p_TUNGraph swig_types[323] +#define SWIGTYPE_p_TUNGraphEdgeI swig_types[324] +#define SWIGTYPE_p_TUNGraphMtx swig_types[325] +#define SWIGTYPE_p_TUNGraphNodeI swig_types[326] +#define SWIGTYPE_p_TUNGraph__TEdgeI swig_types[327] +#define SWIGTYPE_p_TUNGraph__TNode swig_types[328] +#define SWIGTYPE_p_TUNGraph__TNodeI swig_types[329] +#define SWIGTYPE_p_TUndirFFire swig_types[330] +#define SWIGTYPE_p_TVVVecT_TFlt_t swig_types[331] +#define SWIGTYPE_p_TVVVecT_TInt_t swig_types[332] +#define SWIGTYPE_p_TVVecT_TBool_t swig_types[333] +#define SWIGTYPE_p_TVVecT_TCh_t swig_types[334] +#define SWIGTYPE_p_TVVecT_TFlt_t swig_types[335] +#define SWIGTYPE_p_TVVecT_TInt_t swig_types[336] +#define SWIGTYPE_p_TVVecT_TPairT_TInt_TInt_t_t swig_types[337] +#define SWIGTYPE_p_TVVecT_TSFlt_t swig_types[338] +#define SWIGTYPE_p_TVVecT_TStr_t swig_types[339] +#define SWIGTYPE_p_TVal swig_types[340] +#define SWIGTYPE_p_TVecPoolT_TInt_int_t swig_types[341] +#define SWIGTYPE_p_TVecT_TAscFlt_int_t swig_types[342] +#define SWIGTYPE_p_TVecT_TBool_int_t swig_types[343] +#define SWIGTYPE_p_TVecT_TChA_int_t swig_types[344] +#define SWIGTYPE_p_TVecT_TCh_int_t swig_types[345] +#define SWIGTYPE_p_TVecT_TCnCom_int_t swig_types[346] +#define SWIGTYPE_p_TVecT_TFlt_int_t swig_types[347] +#define SWIGTYPE_p_TVecT_TInt_int_t swig_types[348] +#define SWIGTYPE_p_TVecT_TKeyDatT_TAscFlt_TInt_t_int_t swig_types[349] +#define SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TBool_t_int_t swig_types[350] +#define SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t swig_types[351] +#define SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TInt_t_int_t swig_types[352] +#define SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t_int_t swig_types[353] +#define SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TStr_t_int_t swig_types[354] +#define SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TUInt64_t_int_t swig_types[355] +#define SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t swig_types[356] +#define SWIGTYPE_p_TVecT_TKeyDatT_TInt_TInt_t_int_t swig_types[357] +#define SWIGTYPE_p_TVecT_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t_int_t swig_types[358] +#define SWIGTYPE_p_TVecT_TKeyDatT_TInt_TStr_t_int_t swig_types[359] +#define SWIGTYPE_p_TVecT_TKeyDatT_TInt_TUInt64_t_int_t swig_types[360] +#define SWIGTYPE_p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t swig_types[361] +#define SWIGTYPE_p_TVecT_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t_int_t swig_types[362] +#define SWIGTYPE_p_TVecT_TKeyDatT_TStr_TAscFlt_t_int_t swig_types[363] +#define SWIGTYPE_p_TVecT_TKeyDatT_TStr_TFlt_t_int_t swig_types[364] +#define SWIGTYPE_p_TVecT_TKeyDatT_TStr_TInt_t_int_t swig_types[365] +#define SWIGTYPE_p_TVecT_TKeyDatT_TStr_TStr_t_int_t swig_types[366] +#define SWIGTYPE_p_TVecT_TKeyDatT_TUInt64_TFlt_t_int_t swig_types[367] +#define SWIGTYPE_p_TVecT_TKeyDatT_TUInt64_TInt_t_int_t swig_types[368] +#define SWIGTYPE_p_TVecT_TKeyDatT_TUInt64_TStr_t_int_t swig_types[369] +#define SWIGTYPE_p_TVecT_TKeyDatT_TUInt_TInt_t_int_t swig_types[370] +#define SWIGTYPE_p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t swig_types[371] +#define SWIGTYPE_p_TVecT_TPairT_TAscFlt_TInt_t_int_t swig_types[372] +#define SWIGTYPE_p_TVecT_TPairT_TAscFlt_TStr_t_int_t swig_types[373] +#define SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t swig_types[374] +#define SWIGTYPE_p_TVecT_TPairT_TFlt_TInt_t_int_t swig_types[375] +#define SWIGTYPE_p_TVecT_TPairT_TFlt_TPairT_TStr_TStr_t_t_int_t swig_types[376] +#define SWIGTYPE_p_TVecT_TPairT_TFlt_TStr_t_int_t swig_types[377] +#define SWIGTYPE_p_TVecT_TPairT_TFlt_TUInt64_t_int_t swig_types[378] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TFlt_t_int_t swig_types[379] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t swig_types[380] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TPairT_TInt_TInt_t_t_int_t swig_types[381] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TPairT_TStr_TStr_t_t_int_t swig_types[382] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TStr_t_int_t swig_types[383] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TUInt64_t_int_t swig_types[384] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t swig_types[385] +#define SWIGTYPE_p_TVecT_TPairT_TInt_TVecT_TStr_int_t_t_int_t swig_types[386] +#define SWIGTYPE_p_TVecT_TPairT_TStr_TFlt_t_int_t swig_types[387] +#define SWIGTYPE_p_TVecT_TPairT_TStr_TInt_t_int_t swig_types[388] +#define SWIGTYPE_p_TVecT_TPairT_TStr_TStr_t_int_t swig_types[389] +#define SWIGTYPE_p_TVecT_TPairT_TStr_TVecT_TStr_int_t_t_int_t swig_types[390] +#define SWIGTYPE_p_TVecT_TPairT_TUCh_TInt_t_int_t swig_types[391] +#define SWIGTYPE_p_TVecT_TPairT_TUCh_TUInt64_t_int_t swig_types[392] +#define SWIGTYPE_p_TVecT_TPairT_TUInt64_TFlt_t_int_t swig_types[393] +#define SWIGTYPE_p_TVecT_TPairT_TUInt64_TInt_t_int_t swig_types[394] +#define SWIGTYPE_p_TVecT_TPairT_TUInt64_TStr_t_int_t swig_types[395] +#define SWIGTYPE_p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t swig_types[396] +#define SWIGTYPE_p_TVecT_TPairT_TVecT_TStr_int_t_TInt_t_int_t swig_types[397] +#define SWIGTYPE_p_TVecT_TPtT_TNGraph_t_int_t swig_types[398] +#define SWIGTYPE_p_TVecT_TQQueueT_TInt_t_int_t swig_types[399] +#define SWIGTYPE_p_TVecT_TQuadT_TFlt_TInt_TInt_TInt_t_int_t swig_types[400] +#define SWIGTYPE_p_TVecT_TQuadT_TInt_TInt_TInt_TInt_t_int_t swig_types[401] +#define SWIGTYPE_p_TVecT_TQuadT_TInt_TStr_TInt_TInt_t_int_t swig_types[402] +#define SWIGTYPE_p_TVecT_TQuadT_TStr_TStr_TStr_TStr_t_int_t swig_types[403] +#define SWIGTYPE_p_TVecT_TSFlt_int_t swig_types[404] +#define SWIGTYPE_p_TVecT_TStr_int_t swig_types[405] +#define SWIGTYPE_p_TVecT_TTripleT_TFlt_TFlt_TFlt_t_int_t swig_types[406] +#define SWIGTYPE_p_TVecT_TTripleT_TFlt_TFlt_TStr_t_int_t swig_types[407] +#define SWIGTYPE_p_TVecT_TTripleT_TFlt_TInt_TInt_t_int_t swig_types[408] +#define SWIGTYPE_p_TVecT_TTripleT_TInt_TFlt_TInt_t_int_t swig_types[409] +#define SWIGTYPE_p_TVecT_TTripleT_TInt_TInt_TFlt_t_int_t swig_types[410] +#define SWIGTYPE_p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t swig_types[411] +#define SWIGTYPE_p_TVecT_TTripleT_TInt_TInt_TStr_t_int_t swig_types[412] +#define SWIGTYPE_p_TVecT_TTripleT_TInt_TInt_TVecT_TInt_int_t_t_int_t swig_types[413] +#define SWIGTYPE_p_TVecT_TTripleT_TInt_TStr_TInt_t_int_t swig_types[414] +#define SWIGTYPE_p_TVecT_TTripleT_TInt_TVecT_TInt_int_t_TInt_t_int_t swig_types[415] +#define SWIGTYPE_p_TVecT_TTripleT_TStr_TFlt_TFlt_t_int_t swig_types[416] +#define SWIGTYPE_p_TVecT_TTripleT_TStr_TStr_TInt_t_int_t swig_types[417] +#define SWIGTYPE_p_TVecT_TTripleT_TStr_TStr_TStr_t_int_t swig_types[418] +#define SWIGTYPE_p_TVecT_TUCh_int_t swig_types[419] +#define SWIGTYPE_p_TVecT_TUInt64_int_t swig_types[420] +#define SWIGTYPE_p_TVecT_TUInt_int_t swig_types[421] +#define SWIGTYPE_p_TVecT_TVal_TSizeTy_t swig_types[422] +#define SWIGTYPE_p_TVecT_TVecT_TFlt_int_t_int_t swig_types[423] +#define SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t swig_types[424] +#define SWIGTYPE_p_TVecT_char_p_int_t swig_types[425] +#define SWIGTYPE_p_TVoid swig_types[426] +#define SWIGTYPE_p_TXmlLx swig_types[427] +#define SWIGTYPE_p_bool swig_types[428] +#define SWIGTYPE_p_char swig_types[429] +#define SWIGTYPE_p_double swig_types[430] +#define SWIGTYPE_p_f_r_TSOut__r_TFInOut swig_types[431] +#define SWIGTYPE_p_f_r_TSOut__r_TFOut swig_types[432] +#define SWIGTYPE_p_f_r_TSOut__r_TMOut swig_types[433] +#define SWIGTYPE_p_f_r_TSOut__r_TMemOut swig_types[434] +#define SWIGTYPE_p_f_r_TSOut__r_TSInOut swig_types[435] +#define SWIGTYPE_p_f_r_TSOut__r_TSOut swig_types[436] +#define SWIGTYPE_p_f_r_TSOut__r_TStdOut swig_types[437] +#define SWIGTYPE_p_float swig_types[438] +#define SWIGTYPE_p_int swig_types[439] +#define SWIGTYPE_p_long_double swig_types[440] +#define SWIGTYPE_p_long_long swig_types[441] +#define SWIGTYPE_p_p_char swig_types[442] +#define SWIGTYPE_p_ptrdiff_t swig_types[443] +#define SWIGTYPE_p_short swig_types[444] +#define SWIGTYPE_p_size_t swig_types[445] +#define SWIGTYPE_p_unsigned_char swig_types[446] +#define SWIGTYPE_p_unsigned_int swig_types[447] +#define SWIGTYPE_p_unsigned_long swig_types[448] +#define SWIGTYPE_p_unsigned_long_long swig_types[449] +#define SWIGTYPE_p_unsigned_short swig_types[450] +#define SWIGTYPE_p_void swig_types[451] +static swig_type_info *swig_types[453]; +static swig_module_info swig_module = {swig_types, 452, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#if (PY_VERSION_HEX <= 0x02000000) +# if !defined(SWIG_PYTHON_CLASSIC) +# error "This python version requires swig to be run with the '-classic' option" +# endif +#endif +#if (PY_VERSION_HEX <= 0x02020000) +# error "This python version requires swig to be run with the '-nomodern' option" +#endif +#if (PY_VERSION_HEX <= 0x02020000) +# error "This python version requires swig to be run with the '-nomodernargs' option" +#endif +#ifndef METH_O +# error "This python version requires swig to be run with the '-nofastunpack' option" +#endif +#ifdef SWIG_TypeQuery +# undef SWIG_TypeQuery +#endif +#define SWIG_TypeQuery SWIG_Python_TypeQuery + +/*----------------------------------------------- + @(target):= _snap.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__snap + +#else +# define SWIG_init init_snap + +#endif +#define SWIG_name "_snap" + +#define SWIGVERSION 0x020009 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + Py_XINCREF(_obj); + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + Py_XINCREF(_obj); + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + return *this; + } + + ~SwigPtr_PyObject() + { + Py_XDECREF(_obj); + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + + +#include "Snap.h" + +/* #include "Engine.h" */ +#include "snapswig.h" + +#include "printgraph.h" +#include "snap_types.h" +#include "goodgraph.cpp" + + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; + } else if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + + #define SWIG_From_double PyFloat_FromDouble + + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor(void) +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +SWIGINTERN int +SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) +{ +#if PY_VERSION_HEX>=0x03000000 + if (PyUnicode_Check(obj)) +#else + if (PyString_Check(obj)) +#endif + { + char *cstr; Py_ssize_t len; +#if PY_VERSION_HEX>=0x03000000 + if (!alloc && cptr) { + /* We can't allow converting without allocation, since the internal + representation of string in Python 3 is UCS-2/UCS-4 but we require + a UTF-8 representation. + TODO(bhy) More detailed explanation */ + return SWIG_RuntimeError; + } + obj = PyUnicode_AsUTF8String(obj); + PyBytes_AsStringAndSize(obj, &cstr, &len); + if(alloc) *alloc = SWIG_NEWOBJ; +#else + PyString_AsStringAndSize(obj, &cstr, &len); +#endif + if (cptr) { + if (alloc) { + /* + In python the user should not be able to modify the inner + string representation. To warranty that, if you define + SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string + buffer is always returned. + + The default behavior is just to return the pointer value, + so, be careful. + */ +#if defined(SWIG_PYTHON_SAFE_CSTRINGS) + if (*alloc != SWIG_OLDOBJ) +#else + if (*alloc == SWIG_NEWOBJ) +#endif + { + *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1))); + *alloc = SWIG_NEWOBJ; + } + else { + *cptr = cstr; + *alloc = SWIG_OLDOBJ; + } + } else { + #if PY_VERSION_HEX>=0x03000000 + assert(0); /* Should never reach here in Python 3 */ + #endif + *cptr = SWIG_Python_str_AsChar(obj); + } + } + if (psize) *psize = len + 1; +#if PY_VERSION_HEX>=0x03000000 + Py_XDECREF(obj); +#endif + return SWIG_OK; + } else { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + if (pchar_descriptor) { + void* vptr = 0; + if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { + if (cptr) *cptr = (char *) vptr; + if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; + if (alloc) *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + } + } + return SWIG_TypeError; +} + + + + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + if (carray) { + if (size > INT_MAX) { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + return pchar_descriptor ? + SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromStringAndSize(carray, static_cast< int >(size)); +#else + return PyString_FromStringAndSize(carray, static_cast< int >(size)); +#endif + } + } else { + return SWIG_Py_Void(); + } +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtr(const char *cptr) +{ + return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + long v = PyInt_AsLong(obj); + if (v >= 0) { + if (val) *val = v; + return SWIG_OK; + } else { + return SWIG_OverflowError; + } + } else +#endif + if (PyLong_Check(obj)) { + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { + if (val) *val = (unsigned long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > UINT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< unsigned int >(v); + } + } + return res; +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val) +{ + int res = SWIG_TypeError; + if (PyLong_Check(obj)) { + unsigned long long v = PyLong_AsUnsignedLongLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } else { + unsigned long v; + res = SWIG_AsVal_unsigned_SS_long (obj,&v); + if (SWIG_IsOK(res)) { + if (val) *val = v; + return res; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + const double mant_max = 1LL << DBL_MANT_DIG; + double d; + res = SWIG_AsVal_double (obj,&d); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) { + if (val) *val = (unsigned long long)(d); + return SWIG_AddCast(res); + } + res = SWIG_TypeError; + } +#endif + return res; +} + + + #define SWIG_From_long PyLong_FromLong + + +SWIGINTERNINLINE PyObject* +SWIG_From_long_SS_long (long long value) +{ + return ((value < LONG_MIN) || (value > LONG_MAX)) ? + PyLong_FromLongLong(value) : PyLong_FromLong(static_cast< long >(value)); +} + + +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long_SS_long (unsigned long long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLongLong(value) : PyLong_FromLong(static_cast< long >(value)); +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_unsigned_SS_int (unsigned int value) +{ + return PyInt_FromSize_t((size_t) value); +} + + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + +SWIGINTERN int +SWIG_AsCharArray(PyObject * obj, char *val, size_t size) +{ + char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ; + int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc); + if (SWIG_IsOK(res)) { + if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize; + if (csize <= size) { + if (val) { + if (csize) memcpy(val, cptr, csize*sizeof(char)); + if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char)); + } + if (alloc == SWIG_NEWOBJ) { + delete[] cptr; + res = SWIG_DelNewMask(res); + } + return res; + } + if (alloc == SWIG_NEWOBJ) delete[] cptr; + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_char (PyObject * obj, char *val) +{ + int res = SWIG_AsCharArray(obj, val, 1); + if (!SWIG_IsOK(res)) { + long v; + res = SWIG_AddCast(SWIG_AsVal_long (obj, &v)); + if (SWIG_IsOK(res)) { + if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) { + if (val) *val = static_cast< char >(v); + } else { + res = SWIG_OverflowError; + } + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_char (char c) +{ + return SWIG_FromCharPtrAndSize(&c,1); +} + + +SWIGINTERNINLINE int +SWIG_AsVal_size_t (PyObject * obj, size_t *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); + return res; +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > UCHAR_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< unsigned char >(v); + } + } + return res; +} + + +SWIGINTERN int +SWIG_AsVal_short (PyObject * obj, short *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < SHRT_MIN || v > SHRT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< short >(v); + } + } + return res; +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > USHRT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< unsigned short >(v); + } + } + return res; +} + + +SWIGINTERN int +SWIG_AsVal_long_SS_long (PyObject *obj, long long *val) +{ + int res = SWIG_TypeError; + if (PyLong_Check(obj)) { + long long v = PyLong_AsLongLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } else { + long v; + res = SWIG_AsVal_long (obj,&v); + if (SWIG_IsOK(res)) { + if (val) *val = v; + return res; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + const double mant_max = 1LL << DBL_MANT_DIG; + const double mant_min = -mant_max; + double d; + res = SWIG_AsVal_double (obj,&d); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) { + if (val) *val = (long long)(d); + return SWIG_AddCast(res); + } + res = SWIG_TypeError; + } +#endif + return res; +} + + +SWIGINTERN int +SWIG_AsVal_float (PyObject * obj, float *val) +{ + double v; + int res = SWIG_AsVal_double (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < -FLT_MAX || v > FLT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< float >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long (unsigned long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLong(value) : PyLong_FromLong(static_cast< long >(value)); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_size_t (size_t value) +{ + return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_unsigned_SS_char (unsigned char value) +{ + return SWIG_From_unsigned_SS_long (value); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_short (short value) +{ + return SWIG_From_long (value); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_float (float value) +{ + return SWIG_From_double (value); +} + +SWIGINTERN int TVec_Sl_TInt_Sc_int_Sg__Add__SWIG_3(TVec< TInt,int > *self,int Val){ + return self->Add(TInt(Val)); + } +SWIGINTERN int TVec_Sl_TInt_Sc_int_Sg__AddMerged__SWIG_1(TVec< TInt,int > *self,int Val){ + return self->AddMerged(TInt(Val)); + } +SWIGINTERN int THash_Sl_TInt_Sc_TVec_Sl_TInt_Sc_int_Sg__Sg__AddKey__SWIG_1(THash< TInt,TVec< TInt,int > > *self,int Val){ + return self->AddKey(TInt(Val)); + } +SWIGINTERN int THash_Sl_TInt_Sc_TVec_Sl_TInt_Sc_int_Sg__Sg__IsKey__SWIG_2(THash< TInt,TVec< TInt,int > > *self,int Val){ + return self->IsKey(TInt(Val)); + } +SWIGINTERN TVec< TInt,int > &THash_Sl_TInt_Sc_TVec_Sl_TInt_Sc_int_Sg__Sg__GetDat__SWIG_2(THash< TInt,TVec< TInt,int > > *self,int Val){ + return self->GetDat(TInt(Val)); + } +SWIGINTERN int THash_Sl_TInt_Sc_TInt_Sg__AddKey__SWIG_1(THash< TInt,TInt > *self,int Val){ + return self->AddKey(TInt(Val)); + } +SWIGINTERN int THash_Sl_TInt_Sc_TInt_Sg__IsKey__SWIG_2(THash< TInt,TInt > *self,int Val){ + return self->IsKey(TInt(Val)); + } +SWIGINTERN TInt &THash_Sl_TInt_Sc_TInt_Sg__GetDat__SWIG_2(THash< TInt,TInt > *self,int Val){ + return self->GetDat(TInt(Val)); + } +SWIGINTERN TInt &THash_Sl_TInt_Sc_TInt_Sg__AddDat__SWIG_2(THash< TInt,TInt > *self,int Key,int Val){ + return self->AddDat(TInt(Key),TInt(Val)); + } +SWIGINTERN TNEANetNodeI TNEANet_BegNI__SWIG_1(TNEANet *self){ + return TNEANetNodeI(self->BegNI()); + } +SWIGINTERN TNEANetNodeI TNEANet_EndNI__SWIG_1(TNEANet *self){ + return TNEANetNodeI(self->EndNI()); + } +SWIGINTERN TNEANetEdgeI TNEANet_BegEI__SWIG_1(TNEANet *self){ + return TNEANetEdgeI(self->BegEI()); + } +SWIGINTERN TNEANetEdgeI TNEANet_EndEI__SWIG_1(TNEANet *self){ + return TNEANetEdgeI(self->EndEI()); + } +SWIGINTERN TNEANetAIntI TNEANet_BegNAIntI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAIntI(self->BegNAIntI(attr)); + } +SWIGINTERN TNEANetAIntI TNEANet_EndNAIntI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAIntI(self->EndNAIntI(attr)); + } +SWIGINTERN TNEANetAStrI TNEANet_BegNAStrI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAStrI(self->BegNAStrI(attr)); + } +SWIGINTERN TNEANetAStrI TNEANet_EndNAStrI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAStrI(self->EndNAStrI(attr)); + } +SWIGINTERN TNEANetAFltI TNEANet_BegNAFltI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAFltI(self->BegNAFltI(attr)); + } +SWIGINTERN TNEANetAFltI TNEANet_EndNAFltI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAFltI(self->EndNAFltI(attr)); + } +SWIGINTERN TNEANetAIntI TNEANet_BegEAIntI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAIntI(self->BegEAIntI(attr)); + } +SWIGINTERN TNEANetAIntI TNEANet_EndEAIntI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAIntI(self->EndEAIntI(attr)); + } +SWIGINTERN TNEANetAStrI TNEANet_BegEAStrI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAStrI(self->BegEAStrI(attr)); + } +SWIGINTERN TNEANetAStrI TNEANet_EndEAStrI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAStrI(self->EndEAStrI(attr)); + } +SWIGINTERN TNEANetAFltI TNEANet_BegEAFltI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAFltI(self->BegEAFltI(attr)); + } +SWIGINTERN TNEANetAFltI TNEANet_EndEAFltI__SWIG_1(TNEANet *self,TStr const &attr){ + return TNEANetAFltI(self->EndEAFltI(attr)); + } +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_CalcEffDiam__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalcEffDiam" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)TSnap::TSnapDetail::CalcEffDiam((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiam__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + result = (double)TSnap::TSnapDetail::CalcEffDiam((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiam__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalcEffDiam" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)TSnap::TSnapDetail::CalcEffDiam((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiam__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiam" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + result = (double)TSnap::TSnapDetail::CalcEffDiam((TVec< TPair< TFlt,TFlt >,int > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiam(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"CalcEffDiam",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_CalcEffDiam__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_CalcEffDiam__SWIG_3(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_CalcEffDiam__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 2) { + return _wrap_CalcEffDiam__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CalcEffDiam'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::TSnapDetail::CalcEffDiam(TIntFltKdV const &,double const &)\n" + " TSnap::TSnapDetail::CalcEffDiam(TIntFltKdV const &)\n" + " TSnap::TSnapDetail::CalcEffDiam(TFltPrV const &,double const &)\n" + " TSnap::TSnapDetail::CalcEffDiam(TFltPrV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiamPdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalcEffDiamPdf" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)TSnap::TSnapDetail::CalcEffDiamPdf((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiamPdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + result = (double)TSnap::TSnapDetail::CalcEffDiamPdf((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiamPdf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalcEffDiamPdf" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)TSnap::TSnapDetail::CalcEffDiamPdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiamPdf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcEffDiamPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + result = (double)TSnap::TSnapDetail::CalcEffDiamPdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcEffDiamPdf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"CalcEffDiamPdf",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_CalcEffDiamPdf__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_CalcEffDiamPdf__SWIG_3(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_CalcEffDiamPdf__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 2) { + return _wrap_CalcEffDiamPdf__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CalcEffDiamPdf'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::TSnapDetail::CalcEffDiamPdf(TIntFltKdV const &,double const &)\n" + " TSnap::TSnapDetail::CalcEffDiamPdf(TIntFltKdV const &)\n" + " TSnap::TSnapDetail::CalcEffDiamPdf(TFltPrV const &,double const &)\n" + " TSnap::TSnapDetail::CalcEffDiamPdf(TFltPrV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CalcAvgDiamPdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcAvgDiamPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcAvgDiamPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + result = (double)TSnap::TSnapDetail::CalcAvgDiamPdf((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcAvgDiamPdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcAvgDiamPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcAvgDiamPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + result = (double)TSnap::TSnapDetail::CalcAvgDiamPdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CalcAvgDiamPdf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"CalcAvgDiamPdf",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_CalcAvgDiamPdf__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_CalcAvgDiamPdf__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CalcAvgDiamPdf'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::TSnapDetail::CalcAvgDiamPdf(TIntFltKdV const &)\n" + " TSnap::TSnapDetail::CalcAvgDiamPdf(TFltPrV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_WrNotify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"WrNotify",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WrNotify" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WrNotify" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + WrNotify((char const *)arg1,(char const *)arg2); + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SaveToErrLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SaveToErrLog" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + SaveToErrLog((char const *)arg1); + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_InfoNotify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InfoNotify" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + InfoNotify((char const *)arg1); + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_WarnNotify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WarnNotify" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + WarnNotify((char const *)arg1); + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ErrNotify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrNotify" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + ErrNotify((char const *)arg1); + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_StatNotify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatNotify" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + StatNotify((char const *)arg1); + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ExeStop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + int *arg5 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + int temp5 ; + int val5 ; + int ecode5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args,"ExeStop",5,5,swig_obj)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExeStop" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExeStop" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExeStop" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExeStop" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ExeStop" "', argument " "5"" of type '" "int""'"); + } + temp5 = static_cast< int >(val5); + arg5 = &temp5; + ExeStop((char const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(int const &)*arg5); + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCRef *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TCRef",0,0,0)) SWIG_fail; + result = (TCRef *)new TCRef(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCRef, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TCRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCRef *arg1 = (TCRef *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCRef, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TCRef" "', argument " "1"" of type '" "TCRef *""'"); + } + arg1 = reinterpret_cast< TCRef * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCRef_MkRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCRef *arg1 = (TCRef *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCRef, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCRef_MkRef" "', argument " "1"" of type '" "TCRef *""'"); + } + arg1 = reinterpret_cast< TCRef * >(argp1); + (arg1)->MkRef(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCRef_UnRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCRef *arg1 = (TCRef *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCRef, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCRef_UnRef" "', argument " "1"" of type '" "TCRef *""'"); + } + arg1 = reinterpret_cast< TCRef * >(argp1); + (arg1)->UnRef(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCRef_NoRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCRef *arg1 = (TCRef *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCRef, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCRef_NoRef" "', argument " "1"" of type '" "TCRef const *""'"); + } + arg1 = reinterpret_cast< TCRef * >(argp1); + result = (bool)((TCRef const *)arg1)->NoRef(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCRef_GetRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCRef *arg1 = (TCRef *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCRef, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCRef_GetRefs" "', argument " "1"" of type '" "TCRef const *""'"); + } + arg1 = reinterpret_cast< TCRef * >(argp1); + result = (int)((TCRef const *)arg1)->GetRefs(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TCRef_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TCRef, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TCRef_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TSStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TSStr *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TSStr *)new TSStr(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TSStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TSStr" "', argument " "1"" of type '" "TSStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TSStr" "', argument " "1"" of type '" "TSStr const &""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + result = (TSStr *)new TSStr((TSStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + TSStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TSStr" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (TSStr *)new TSStr((char const *)arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSStr, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TSStr",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TSStr__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TSStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TSStr__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TSStr__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TSStr'.\n" + " Possible C/C++ prototypes are:\n" + " TSStr::TSStr()\n" + " TSStr::TSStr(TSStr const &)\n" + " TSStr::TSStr(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TSStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSStr *arg1 = (TSStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSStr, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSStr" "', argument " "1"" of type '" "TSStr *""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSStr_CStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSStr *arg1 = (TSStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSStr_CStr" "', argument " "1"" of type '" "TSStr *""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + result = (char *)(arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSStr_CStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSStr *arg1 = (TSStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSStr_CStr" "', argument " "1"" of type '" "TSStr const *""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + result = (char *)((TSStr const *)arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSStr_CStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSStr_CStr",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TSStr_CStr__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_TSStr_CStr__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSStr_CStr'.\n" + " Possible C/C++ prototypes are:\n" + " TSStr::CStr()\n" + " TSStr::CStr() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSStr_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSStr *arg1 = (TSStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSStr_Empty" "', argument " "1"" of type '" "TSStr const *""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + result = (bool)((TSStr const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSStr_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSStr *arg1 = (TSStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSStr_Len" "', argument " "1"" of type '" "TSStr const *""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + result = (int)((TSStr const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TSStr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSStr, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TSStr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TConv_Pt64Ints32__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TConv_Pt64Ints32 *)new TConv_Pt64Ints32(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TConv_Pt64Ints32, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TConv_Pt64Ints32__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int res1 ; + TConv_Pt64Ints32 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TConv_Pt64Ints32" "', argument " "1"" of type '" "void *""'"); + } + result = (TConv_Pt64Ints32 *)new TConv_Pt64Ints32(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TConv_Pt64Ints32, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TConv_Pt64Ints32__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint *arg2 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + TConv_Pt64Ints32 *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TConv_Pt64Ints32" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TConv_Pt64Ints32" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (TConv_Pt64Ints32 *)new TConv_Pt64Ints32((uint const &)*arg1,(uint const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TConv_Pt64Ints32, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TConv_Pt64Ints32(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TConv_Pt64Ints32",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TConv_Pt64Ints32__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TConv_Pt64Ints32__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TConv_Pt64Ints32__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TConv_Pt64Ints32'.\n" + " Possible C/C++ prototypes are:\n" + " TConv_Pt64Ints32::TConv_Pt64Ints32()\n" + " TConv_Pt64Ints32::TConv_Pt64Ints32(void *)\n" + " TConv_Pt64Ints32::TConv_Pt64Ints32(uint const &,uint const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_PutPt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + void *arg2 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TConv_Pt64Ints32_PutPt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_PutPt" "', argument " "1"" of type '" "TConv_Pt64Ints32 *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TConv_Pt64Ints32_PutPt" "', argument " "2"" of type '" "void *""'"); + } + (arg1)->PutPt(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_GetPt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + void *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_GetPt" "', argument " "1"" of type '" "TConv_Pt64Ints32 const *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + result = (void *)((TConv_Pt64Ints32 const *)arg1)->GetPt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_PutUInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint64 temp2 ; + unsigned long long val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TConv_Pt64Ints32_PutUInt64",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_PutUInt64" "', argument " "1"" of type '" "TConv_Pt64Ints32 *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TConv_Pt64Ints32_PutUInt64" "', argument " "2"" of type '" "uint64""'"); + } + temp2 = static_cast< uint64 >(val2); + arg2 = &temp2; + (arg1)->PutUInt64((uint64 const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_GetUInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint64 result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_GetUInt64" "', argument " "1"" of type '" "TConv_Pt64Ints32 const *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + result = (uint64)((TConv_Pt64Ints32 const *)arg1)->GetUInt64(); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_PutMsUInt32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TConv_Pt64Ints32_PutMsUInt32",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_PutMsUInt32" "', argument " "1"" of type '" "TConv_Pt64Ints32 *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TConv_Pt64Ints32_PutMsUInt32" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + (arg1)->PutMsUInt32((uint const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_GetMsUInt32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_GetMsUInt32" "', argument " "1"" of type '" "TConv_Pt64Ints32 const *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + result = (uint)((TConv_Pt64Ints32 const *)arg1)->GetMsUInt32(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_PutLsUInt32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TConv_Pt64Ints32_PutLsUInt32",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_PutLsUInt32" "', argument " "1"" of type '" "TConv_Pt64Ints32 *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TConv_Pt64Ints32_PutLsUInt32" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + (arg1)->PutLsUInt32((uint const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TConv_Pt64Ints32_GetLsUInt32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TConv_Pt64Ints32_GetLsUInt32" "', argument " "1"" of type '" "TConv_Pt64Ints32 const *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + result = (uint)((TConv_Pt64Ints32 const *)arg1)->GetLsUInt32(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TConv_Pt64Ints32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TConv_Pt64Ints32 *arg1 = (TConv_Pt64Ints32 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TConv_Pt64Ints32, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TConv_Pt64Ints32" "', argument " "1"" of type '" "TConv_Pt64Ints32 *""'"); + } + arg1 = reinterpret_cast< TConv_Pt64Ints32 * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TConv_Pt64Ints32_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TConv_Pt64Ints32, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TConv_Pt64Ints32_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TPairHashImpl1_GetHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TPairHashImpl1_GetHashCd",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TPairHashImpl1_GetHashCd" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TPairHashImpl1_GetHashCd" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)TPairHashImpl1::GetHashCd(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TPairHashImpl1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPairHashImpl1 *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TPairHashImpl1",0,0,0)) SWIG_fail; + result = (TPairHashImpl1 *)new TPairHashImpl1(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TPairHashImpl1, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TPairHashImpl1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPairHashImpl1 *arg1 = (TPairHashImpl1 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPairHashImpl1, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TPairHashImpl1" "', argument " "1"" of type '" "TPairHashImpl1 *""'"); + } + arg1 = reinterpret_cast< TPairHashImpl1 * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TPairHashImpl1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TPairHashImpl1, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TPairHashImpl1_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TPairHashImpl2_GetHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TPairHashImpl2_GetHashCd",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TPairHashImpl2_GetHashCd" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TPairHashImpl2_GetHashCd" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)TPairHashImpl2::GetHashCd(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TPairHashImpl2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPairHashImpl2 *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TPairHashImpl2",0,0,0)) SWIG_fail; + result = (TPairHashImpl2 *)new TPairHashImpl2(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TPairHashImpl2, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TPairHashImpl2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPairHashImpl2 *arg1 = (TPairHashImpl2 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPairHashImpl2, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TPairHashImpl2" "', argument " "1"" of type '" "TPairHashImpl2 *""'"); + } + arg1 = reinterpret_cast< TPairHashImpl2 * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TPairHashImpl2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TPairHashImpl2, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TPairHashImpl2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GetDegreeCentr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"GetDegreeCentr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDegreeCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegreeCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetDegreeCentr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TSnap::GetDegreeCentr((TPt< TUNGraph > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetFarnessCentr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"GetFarnessCentr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetFarnessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetFarnessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetFarnessCentr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TSnap::GetFarnessCentr((TPt< TUNGraph > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetClosenessCentr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"GetClosenessCentr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetClosenessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClosenessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetClosenessCentr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TSnap::GetClosenessCentr((TPt< TUNGraph > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + TSnap::GetBetweennessCentr((TPt< TUNGraph > const &)*arg1,*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + TSnap::GetBetweennessCentr((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntPrFltH *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntPrFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntPrFltH &""'"); + } + arg2 = reinterpret_cast< TIntPrFltH * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + TSnap::GetBetweennessCentr((TPt< TUNGraph > const &)*arg1,*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntPrFltH *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntPrFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntPrFltH &""'"); + } + arg2 = reinterpret_cast< TIntPrFltH * >(argp2); + TSnap::GetBetweennessCentr((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + TIntPrFltH *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "TIntPrFltH &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "TIntPrFltH &""'"); + } + arg3 = reinterpret_cast< TIntPrFltH * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetBetweennessCentr" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + TSnap::GetBetweennessCentr((TPt< TUNGraph > const &)*arg1,*arg2,*arg3,(double const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + TIntPrFltH *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "TIntPrFltH &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "TIntPrFltH &""'"); + } + arg3 = reinterpret_cast< TIntPrFltH * >(argp3); + TSnap::GetBetweennessCentr((TPt< TUNGraph > const &)*arg1,*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntV *arg2 = 0 ; + TIntFltH *arg3 = 0 ; + bool *arg4 = 0 ; + TIntPrFltH *arg5 = 0 ; + bool *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool temp6 ; + bool val6 ; + int ecode6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "TIntFltH &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "3"" of type '" "TIntFltH &""'"); + } + arg3 = reinterpret_cast< TIntFltH * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetBetweennessCentr" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetBetweennessCentr" "', argument " "5"" of type '" "TIntPrFltH &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBetweennessCentr" "', argument " "5"" of type '" "TIntPrFltH &""'"); + } + arg5 = reinterpret_cast< TIntPrFltH * >(argp5); + ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetBetweennessCentr" "', argument " "6"" of type '" "bool""'"); + } + temp6 = static_cast< bool >(val6); + arg6 = &temp6; + TSnap::GetBetweennessCentr((TPt< TUNGraph > const &)*arg1,(TVec< TInt,int > const &)*arg2,*arg3,(bool const &)*arg4,*arg5,(bool const &)*arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBetweennessCentr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetBetweennessCentr",0,6,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetBetweennessCentr__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_GetBetweennessCentr__SWIG_3(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_3; + return _wrap_GetBetweennessCentr__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 3) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_GetBetweennessCentr__SWIG_5(self, argc, argv); + } +check_4: + + if (argc == 3) { + return _wrap_GetBetweennessCentr__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetBetweennessCentr__SWIG_4(self, argc, argv); + } + if (argc == 6) { + return _wrap_GetBetweennessCentr__SWIG_6(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetBetweennessCentr'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetBetweennessCentr(PUNGraph const &,TIntFltH &,double const &)\n" + " TSnap::GetBetweennessCentr(PUNGraph const &,TIntFltH &)\n" + " TSnap::GetBetweennessCentr(PUNGraph const &,TIntPrFltH &,double const &)\n" + " TSnap::GetBetweennessCentr(PUNGraph const &,TIntPrFltH &)\n" + " TSnap::GetBetweennessCentr(PUNGraph const &,TIntFltH &,TIntPrFltH &,double const &)\n" + " TSnap::GetBetweennessCentr(PUNGraph const &,TIntFltH &,TIntPrFltH &)\n" + " TSnap::GetBetweennessCentr(PUNGraph const &,TIntV const &,TIntFltH &,bool const &,TIntPrFltH &,bool const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetEigenVectorCentr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + double *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEigenVectorCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigenVectorCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetEigenVectorCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigenVectorCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetEigenVectorCentr" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetEigenVectorCentr" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + TSnap::GetEigenVectorCentr((TPt< TUNGraph > const &)*arg1,*arg2,(double const &)*arg3,(int const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetEigenVectorCentr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEigenVectorCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigenVectorCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetEigenVectorCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigenVectorCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetEigenVectorCentr" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + TSnap::GetEigenVectorCentr((TPt< TUNGraph > const &)*arg1,*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetEigenVectorCentr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEigenVectorCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigenVectorCentr" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetEigenVectorCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigenVectorCentr" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + TSnap::GetEigenVectorCentr((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetEigenVectorCentr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetEigenVectorCentr",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GetEigenVectorCentr__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_GetEigenVectorCentr__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetEigenVectorCentr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetEigenVectorCentr'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetEigenVectorCentr(PUNGraph const &,TIntFltH &,double const &,int const &)\n" + " TSnap::GetEigenVectorCentr(PUNGraph const &,TIntFltH &,double const &)\n" + " TSnap::GetEigenVectorCentr(PUNGraph const &,TIntFltH &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CommunityGirvanNewman(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TCnComV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"CommunityGirvanNewman",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommunityGirvanNewman" "', argument " "1"" of type '" "PUNGraph &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CommunityGirvanNewman" "', argument " "1"" of type '" "PUNGraph &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CommunityGirvanNewman" "', argument " "2"" of type '" "TCnComV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CommunityGirvanNewman" "', argument " "2"" of type '" "TCnComV &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + result = (double)TSnap::CommunityGirvanNewman(*arg1,*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CommunityCNM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TCnComV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"CommunityCNM",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommunityCNM" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CommunityCNM" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CommunityCNM" "', argument " "2"" of type '" "TCnComV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CommunityCNM" "', argument " "2"" of type '" "TCnComV &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + result = (double)TSnap::CommunityCNM((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CmtyGirvanNewmanStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntV *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"CmtyGirvanNewmanStep",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmtyGirvanNewmanStep" "', argument " "1"" of type '" "PUNGraph &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmtyGirvanNewmanStep" "', argument " "1"" of type '" "PUNGraph &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmtyGirvanNewmanStep" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmtyGirvanNewmanStep" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmtyGirvanNewmanStep" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmtyGirvanNewmanStep" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + TSnap::TSnapDetail::CmtyGirvanNewmanStep(*arg1,*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBiConSzCnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetBiConSzCnt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBiConSzCnt" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBiConSzCnt" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBiConSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBiConSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::GetBiConSzCnt((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBiCon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TCnComV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetBiCon",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBiCon" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBiCon" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBiCon" "', argument " "2"" of type '" "TCnComV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBiCon" "', argument " "2"" of type '" "TCnComV &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + TSnap::GetBiCon((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetArtPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetArtPoints",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetArtPoints" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetArtPoints" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetArtPoints" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetArtPoints" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + TSnap::GetArtPoints((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetEdgeBridges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetEdgeBridges",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEdgeBridges" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEdgeBridges" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetEdgeBridges" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEdgeBridges" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::GetEdgeBridges((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Get1CnComSzCnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"Get1CnComSzCnt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Get1CnComSzCnt" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Get1CnComSzCnt" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Get1CnComSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Get1CnComSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::Get1CnComSzCnt((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Get1CnCom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TCnComV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"Get1CnCom",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Get1CnCom" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Get1CnCom" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Get1CnCom" "', argument " "2"" of type '" "TCnComV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Get1CnCom" "', argument " "2"" of type '" "TCnComV &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + TSnap::Get1CnCom((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxBiCon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxBiCon" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxBiCon" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetMxBiCon" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = TSnap::GetMxBiCon((TPt< TUNGraph > const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxBiCon__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxBiCon" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxBiCon" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + result = TSnap::GetMxBiCon((TPt< TUNGraph > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_NIdV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + TIntV *arg2 = (TIntV *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TCnCom_NIdV_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_NIdV_set" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCnCom_NIdV_set" "', argument " "2"" of type '" "TIntV *""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + if (arg1) (arg1)->NIdV = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_NIdV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TIntV *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_NIdV_get" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + result = (TIntV *)& ((arg1)->NIdV); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCnCom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TCnCom *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TCnCom *)new TCnCom(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCnCom, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCnCom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TCnCom *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TCnCom" "', argument " "1"" of type '" "TIntV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TCnCom" "', argument " "1"" of type '" "TIntV const &""'"); + } + arg1 = reinterpret_cast< TIntV * >(argp1); + result = (TCnCom *)new TCnCom((TIntV const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCnCom, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCnCom__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnCom *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TCnCom *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TCnCom, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TCnCom" "', argument " "1"" of type '" "TCnCom const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TCnCom" "', argument " "1"" of type '" "TCnCom const &""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + result = (TCnCom *)new TCnCom((TCnCom const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCnCom, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCnCom__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TCnCom *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TCnCom" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TCnCom" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TCnCom *)new TCnCom(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCnCom, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCnCom(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TCnCom",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TCnCom__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TCnCom__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TCnCom, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TCnCom__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TCnCom__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TCnCom'.\n" + " Possible C/C++ prototypes are:\n" + " TCnCom::TCnCom()\n" + " TCnCom::TCnCom(TIntV const &)\n" + " TCnCom::TCnCom(TCnCom const &)\n" + " TCnCom::TCnCom(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TCnCom_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Save" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCnCom_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TCnCom const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + TCnCom *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TCnCom___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom___eq__" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TCnCom, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCnCom___eq__" "', argument " "2"" of type '" "TCnCom const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom___eq__" "', argument " "2"" of type '" "TCnCom const &""'"); + } + arg2 = reinterpret_cast< TCnCom * >(argp2); + result = (bool)((TCnCom const *)arg1)->operator ==((TCnCom const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + TCnCom *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TCnCom___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom___lt__" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TCnCom, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCnCom___lt__" "', argument " "2"" of type '" "TCnCom const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom___lt__" "', argument " "2"" of type '" "TCnCom const &""'"); + } + arg2 = reinterpret_cast< TCnCom * >(argp2); + result = (bool)((TCnCom const *)arg1)->operator <((TCnCom const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Len" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + result = (int)((TCnCom const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Empty" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + result = (bool)((TCnCom const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Clr" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TCnCom_Add",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Add" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TCnCom_Add" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Add((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TIntV *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom___call__" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + result = (TIntV *) &((TCnCom const *)arg1)->operator ()(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TIntV *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom___call__" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + result = (TIntV *) &(arg1)->operator ()(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom___call__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TCnCom___call__",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TCnCom___call____SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TCnCom___call____SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TCnCom___call__'.\n" + " Possible C/C++ prototypes are:\n" + " TCnCom::operator ()() const\n" + " TCnCom::operator ()()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Sort__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Sort" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TCnCom_Sort" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Sort((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Sort__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Sort" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + (arg1)->Sort(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Sort(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TCnCom_Sort",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TCnCom_Sort__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TCnCom_Sort__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TCnCom_Sort'.\n" + " Possible C/C++ prototypes are:\n" + " TCnCom::Sort(bool const &)\n" + " TCnCom::Sort()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_IsNIdIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TCnCom_IsNIdIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_IsNIdIn" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TCnCom_IsNIdIn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TCnCom const *)arg1)->IsNIdIn((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_GetRndNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TInt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_GetRndNId" "', argument " "1"" of type '" "TCnCom const *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + result = (TInt *) &((TCnCom const *)arg1)->GetRndNId(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Dump__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnComV *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Dump" "', argument " "1"" of type '" "TCnComV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_Dump" "', argument " "1"" of type '" "TCnComV const &""'"); + } + arg1 = reinterpret_cast< TCnComV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCnCom_Dump" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_Dump" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + TCnCom::Dump((TVec< TCnCom > const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Dump__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnComV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_Dump" "', argument " "1"" of type '" "TCnComV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_Dump" "', argument " "1"" of type '" "TCnComV const &""'"); + } + arg1 = reinterpret_cast< TCnComV * >(argp1); + TCnCom::Dump((TVec< TCnCom > const &)*arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_Dump(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TCnCom_Dump",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TCnCom_Dump__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TCnCom_Dump__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TCnCom_Dump'.\n" + " Possible C/C++ prototypes are:\n" + " TCnCom::Dump(TCnComV const &,TStr const &)\n" + " TCnCom::Dump(TCnComV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_SaveTxt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnComV *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_SaveTxt" "', argument " "1"" of type '" "TCnComV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_SaveTxt" "', argument " "1"" of type '" "TCnComV const &""'"); + } + arg1 = reinterpret_cast< TCnComV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCnCom_SaveTxt" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_SaveTxt" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TCnCom_SaveTxt" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_SaveTxt" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + TCnCom::SaveTxt((TVec< TCnCom > const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_SaveTxt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCnComV *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCnCom_SaveTxt" "', argument " "1"" of type '" "TCnComV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_SaveTxt" "', argument " "1"" of type '" "TCnComV const &""'"); + } + arg1 = reinterpret_cast< TCnComV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCnCom_SaveTxt" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCnCom_SaveTxt" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + TCnCom::SaveTxt((TVec< TCnCom > const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCnCom_SaveTxt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TCnCom_SaveTxt",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TCnCom_SaveTxt__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TCnCom_SaveTxt__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TCnCom_SaveTxt'.\n" + " Possible C/C++ prototypes are:\n" + " TCnCom::SaveTxt(TCnComV const &,TStr const &,TStr const &)\n" + " TCnCom::SaveTxt(TCnComV const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TCnCom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCnCom *arg1 = (TCnCom *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCnCom, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TCnCom" "', argument " "1"" of type '" "TCnCom *""'"); + } + arg1 = reinterpret_cast< TCnCom * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TCnCom_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TCnCom, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TCnCom_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_VnLowH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + THash< TInt,TIntPr > *arg2 = (THash< TInt,TIntPr > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_VnLowH_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_VnLowH_set" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TArtPointVisitor_VnLowH_set" "', argument " "2"" of type '" "THash< TInt,TIntPr > *""'"); + } + arg2 = reinterpret_cast< THash< TInt,TIntPr > * >(argp2); + if (arg1) (arg1)->VnLowH = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_VnLowH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THash< TInt,TIntPr > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_VnLowH_get" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + result = (THash< TInt,TIntPr > *)& ((arg1)->VnLowH); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_ParentH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + THash< TInt,TInt > *arg2 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_ParentH_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_ParentH_set" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TArtPointVisitor_ParentH_set" "', argument " "2"" of type '" "THash< TInt,TInt > *""'"); + } + arg2 = reinterpret_cast< THash< TInt,TInt > * >(argp2); + if (arg1) (arg1)->ParentH = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_ParentH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THash< TInt,TInt > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_ParentH_get" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + result = (THash< TInt,TInt > *)& ((arg1)->ParentH); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_ArtSet_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + TIntSet arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_ArtSet_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_ArtSet_set" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TIntSet, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TArtPointVisitor_ArtSet_set" "', argument " "2"" of type '" "TIntSet""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TArtPointVisitor_ArtSet_set" "', argument " "2"" of type '" "TIntSet""'"); + } else { + TIntSet * temp = reinterpret_cast< TIntSet * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->ArtSet = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_ArtSet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TIntSet result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_ArtSet_get" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + result = ((arg1)->ArtSet); + resultobj = SWIG_NewPointerObj((new TIntSet(static_cast< const TIntSet& >(result))), SWIGTYPE_p_TIntSet, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_Time_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + TInt *arg2 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_Time_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_Time_set" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TArtPointVisitor_Time_set" "', argument " "2"" of type '" "TInt *""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + if (arg1) (arg1)->Time = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_Time_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TInt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_Time_get" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + result = (TInt *)& ((arg1)->Time); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TArtPointVisitor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TArtPointVisitor *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TArtPointVisitor *)new TArtPointVisitor(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TArtPointVisitor, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TArtPointVisitor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TArtPointVisitor *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TArtPointVisitor" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TArtPointVisitor *)new TArtPointVisitor((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TArtPointVisitor, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TArtPointVisitor(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TArtPointVisitor",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TArtPointVisitor__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TArtPointVisitor__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TArtPointVisitor'.\n" + " Possible C/C++ prototypes are:\n" + " TArtPointVisitor::TArtPointVisitor()\n" + " TArtPointVisitor::TArtPointVisitor(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_DiscoverNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_DiscoverNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_DiscoverNode" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TArtPointVisitor_DiscoverNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->DiscoverNode(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_FinishNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_FinishNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_FinishNode" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TArtPointVisitor_FinishNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->FinishNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_ExamineEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_ExamineEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_ExamineEdge" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TArtPointVisitor_ExamineEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TArtPointVisitor_ExamineEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->ExamineEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_TreeEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_TreeEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_TreeEdge" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TArtPointVisitor_TreeEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TArtPointVisitor_TreeEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->TreeEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_BackEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_BackEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_BackEdge" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TArtPointVisitor_BackEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TArtPointVisitor_BackEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->BackEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TArtPointVisitor_FwdEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TArtPointVisitor_FwdEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TArtPointVisitor_FwdEdge" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TArtPointVisitor_FwdEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TArtPointVisitor_FwdEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->FwdEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TArtPointVisitor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TArtPointVisitor *arg1 = (TArtPointVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TArtPointVisitor, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TArtPointVisitor" "', argument " "1"" of type '" "TArtPointVisitor *""'"); + } + arg1 = reinterpret_cast< TArtPointVisitor * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TArtPointVisitor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TArtPointVisitor, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TArtPointVisitor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TBiConVisitor_VnLowH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + THash< TInt,TIntPr > *arg2 = (THash< TInt,TIntPr > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_VnLowH_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_VnLowH_set" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBiConVisitor_VnLowH_set" "', argument " "2"" of type '" "THash< TInt,TIntPr > *""'"); + } + arg2 = reinterpret_cast< THash< TInt,TIntPr > * >(argp2); + if (arg1) (arg1)->VnLowH = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_VnLowH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THash< TInt,TIntPr > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_VnLowH_get" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + result = (THash< TInt,TIntPr > *)& ((arg1)->VnLowH); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_ParentH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + THash< TInt,TInt > *arg2 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_ParentH_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_ParentH_set" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBiConVisitor_ParentH_set" "', argument " "2"" of type '" "THash< TInt,TInt > *""'"); + } + arg2 = reinterpret_cast< THash< TInt,TInt > * >(argp2); + if (arg1) (arg1)->ParentH = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_ParentH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THash< TInt,TInt > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_ParentH_get" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + result = (THash< TInt,TInt > *)& ((arg1)->ParentH); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_Stack_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + TSStack< TIntPr > *arg2 = (TSStack< TIntPr > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_Stack_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_Stack_set" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TSStackT_TPairT_TInt_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBiConVisitor_Stack_set" "', argument " "2"" of type '" "TSStack< TIntPr > *""'"); + } + arg2 = reinterpret_cast< TSStack< TIntPr > * >(argp2); + if (arg1) (arg1)->Stack = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_Stack_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TSStack< TIntPr > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_Stack_get" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + result = (TSStack< TIntPr > *)& ((arg1)->Stack); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSStackT_TPairT_TInt_TInt_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_CnComV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + TCnComV *arg2 = (TCnComV *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_CnComV_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_CnComV_set" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBiConVisitor_CnComV_set" "', argument " "2"" of type '" "TCnComV *""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + if (arg1) (arg1)->CnComV = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_CnComV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TCnComV *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_CnComV_get" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + result = (TCnComV *)& ((arg1)->CnComV); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_NSet_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + TIntSet arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_NSet_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_NSet_set" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TIntSet, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBiConVisitor_NSet_set" "', argument " "2"" of type '" "TIntSet""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBiConVisitor_NSet_set" "', argument " "2"" of type '" "TIntSet""'"); + } else { + TIntSet * temp = reinterpret_cast< TIntSet * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->NSet = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_NSet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TIntSet result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_NSet_get" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + result = ((arg1)->NSet); + resultobj = SWIG_NewPointerObj((new TIntSet(static_cast< const TIntSet& >(result))), SWIGTYPE_p_TIntSet, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_Time_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + TInt *arg2 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_Time_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_Time_set" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBiConVisitor_Time_set" "', argument " "2"" of type '" "TInt *""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + if (arg1) (arg1)->Time = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_Time_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TInt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_Time_get" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + result = (TInt *)& ((arg1)->Time); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBiConVisitor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TBiConVisitor *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TBiConVisitor *)new TBiConVisitor(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBiConVisitor, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBiConVisitor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TBiConVisitor *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TBiConVisitor" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TBiConVisitor *)new TBiConVisitor((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBiConVisitor, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBiConVisitor(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TBiConVisitor",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TBiConVisitor__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TBiConVisitor__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TBiConVisitor'.\n" + " Possible C/C++ prototypes are:\n" + " TBiConVisitor::TBiConVisitor()\n" + " TBiConVisitor::TBiConVisitor(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_DiscoverNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_DiscoverNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_DiscoverNode" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBiConVisitor_DiscoverNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->DiscoverNode(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_FinishNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_FinishNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_FinishNode" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBiConVisitor_FinishNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->FinishNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_ExamineEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_ExamineEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_ExamineEdge" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBiConVisitor_ExamineEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBiConVisitor_ExamineEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->ExamineEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_TreeEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_TreeEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_TreeEdge" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBiConVisitor_TreeEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBiConVisitor_TreeEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->TreeEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_BackEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_BackEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_BackEdge" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBiConVisitor_BackEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBiConVisitor_BackEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->BackEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBiConVisitor_FwdEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBiConVisitor_FwdEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBiConVisitor_FwdEdge" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBiConVisitor_FwdEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBiConVisitor_FwdEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->FwdEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TBiConVisitor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBiConVisitor *arg1 = (TBiConVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBiConVisitor, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TBiConVisitor" "', argument " "1"" of type '" "TBiConVisitor *""'"); + } + arg1 = reinterpret_cast< TBiConVisitor * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TBiConVisitor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TBiConVisitor, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TBiConVisitor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TForestFire__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TForestFire *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TForestFire *)new TForestFire(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TForestFire, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TForestFire__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + int *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + int temp5 ; + int val5 ; + int ecode5 = 0 ; + TForestFire *result = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TForestFire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TForestFire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TForestFire" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TForestFire" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TForestFire" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TForestFire" "', argument " "5"" of type '" "int""'"); + } + temp5 = static_cast< int >(val5); + arg5 = &temp5; + result = (TForestFire *)new TForestFire((PNGraph const &)*arg1,(double const &)*arg2,(double const &)*arg3,(double const &)*arg4,(int const &)*arg5); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TForestFire, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TForestFire__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + TForestFire *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TForestFire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TForestFire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TForestFire" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TForestFire" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TForestFire" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + result = (TForestFire *)new TForestFire((PNGraph const &)*arg1,(double const &)*arg2,(double const &)*arg3,(double const &)*arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TForestFire, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TForestFire__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + TForestFire *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TForestFire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TForestFire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TForestFire" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TForestFire" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = (TForestFire *)new TForestFire((PNGraph const &)*arg1,(double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TForestFire, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TForestFire(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TForestFire",0,5,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TForestFire__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_new_TForestFire__SWIG_3(self, argc, argv); + } + if (argc == 4) { + return _wrap_new_TForestFire__SWIG_2(self, argc, argv); + } + if (argc == 5) { + return _wrap_new_TForestFire__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TForestFire'.\n" + " Possible C/C++ prototypes are:\n" + " TForestFire::TForestFire()\n" + " TForestFire::TForestFire(PNGraph const &,double const &,double const &,double const &,int const &)\n" + " TForestFire::TForestFire(PNGraph const &,double const &,double const &,double const &)\n" + " TForestFire::TForestFire(PNGraph const &,double const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_SetGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + PNGraph *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TForestFire_SetGraph",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_SetGraph" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TForestFire_SetGraph" "', argument " "2"" of type '" "PNGraph const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TForestFire_SetGraph" "', argument " "2"" of type '" "PNGraph const &""'"); + } + arg2 = reinterpret_cast< PNGraph * >(argp2); + (arg1)->SetGraph((PNGraph const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GetGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_GetGraph" "', argument " "1"" of type '" "TForestFire const *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + result = ((TForestFire const *)arg1)->GetGraph(); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_SetBurnProb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TForestFire_SetBurnProb",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_SetBurnProb" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TForestFire_SetBurnProb" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TForestFire_SetBurnProb" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + (arg1)->SetBurnProb((double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_SetProbDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TForestFire_SetProbDecay",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_SetProbDecay" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TForestFire_SetProbDecay" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + (arg1)->SetProbDecay((double const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_Infect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_Infect" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TForestFire_Infect" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Infect((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_Infect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_Infect" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TForestFire_Infect" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TForestFire_Infect" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + (arg1)->Infect((TIntV const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_Infect(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TForestFire_Infect",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TForestFire_Infect__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TForestFire_Infect__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TForestFire_Infect'.\n" + " Possible C/C++ prototypes are:\n" + " TForestFire::Infect(int const &)\n" + " TForestFire::Infect(TIntV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_InfectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_InfectAll" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + (arg1)->InfectAll(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_InfectRnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TForestFire_InfectRnd",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_InfectRnd" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TForestFire_InfectRnd" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->InfectRnd((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_BurnExpFire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_BurnExpFire" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + (arg1)->BurnExpFire(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_BurnGeoFire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_BurnGeoFire" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + (arg1)->BurnGeoFire(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GetFireTm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_GetFireTm" "', argument " "1"" of type '" "TForestFire const *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + result = (int)((TForestFire const *)arg1)->GetFireTm(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GetBurned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_GetBurned" "', argument " "1"" of type '" "TForestFire const *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + result = (int)((TForestFire const *)arg1)->GetBurned(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GetBurnedNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TForestFire_GetBurnedNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_GetBurnedNId" "', argument " "1"" of type '" "TForestFire const *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TForestFire_GetBurnedNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TForestFire const *)arg1)->GetBurnedNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GetBurnedNIdV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TIntV *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_GetBurnedNIdV" "', argument " "1"" of type '" "TForestFire const *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + result = (TIntV *) &((TForestFire const *)arg1)->GetBurnedNIdV(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GetBurnedNIdV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_GetBurnedNIdV" "', argument " "1"" of type '" "TForestFire const *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TForestFire_GetBurnedNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TForestFire_GetBurnedNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TForestFire const *)arg1)->GetBurnedNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GetBurnedNIdV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TForestFire_GetBurnedNIdV",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TForestFire_GetBurnedNIdV__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TForestFire_GetBurnedNIdV__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TForestFire_GetBurnedNIdV'.\n" + " Possible C/C++ prototypes are:\n" + " TForestFire::GetBurnedNIdV() const\n" + " TForestFire::GetBurnedNIdV(TIntV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_PlotFire__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_PlotFire" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TForestFire_PlotFire" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TForestFire_PlotFire" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TForestFire_PlotFire" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TForestFire_PlotFire" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TForestFire_PlotFire" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->PlotFire((TStr const &)*arg2,(TStr const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_PlotFire__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TForestFire_PlotFire" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TForestFire_PlotFire" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TForestFire_PlotFire" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TForestFire_PlotFire" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TForestFire_PlotFire" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->PlotFire((TStr const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_PlotFire(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TForestFire_PlotFire",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TForestFire_PlotFire__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TForestFire_PlotFire__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TForestFire_PlotFire'.\n" + " Possible C/C++ prototypes are:\n" + " TForestFire::PlotFire(TStr const &,TStr const &,bool const &)\n" + " TForestFire::PlotFire(TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TForestFire_GenGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!SWIG_Python_UnpackTuple(args,"TForestFire_GenGraph",3,3,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TForestFire_GenGraph" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TForestFire_GenGraph" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TForestFire_GenGraph" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = TForestFire::GenGraph((int const &)*arg1,(double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TForestFire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TForestFire *arg1 = (TForestFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TForestFire, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TForestFire" "', argument " "1"" of type '" "TForestFire *""'"); + } + arg1 = reinterpret_cast< TForestFire * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TForestFire_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TForestFire, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TForestFire_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN int Swig_var_TFfGGen_TimeLimitSec_set(PyObject *_val) { + { + int val; + int res = SWIG_AsVal_int(_val, &val); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""TFfGGen::TimeLimitSec""' of type '""int""'"); + } + TFfGGen::TimeLimitSec = static_cast< int >(val); + } + return 0; +fail: + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFfGGen_TimeLimitSec_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TFfGGen::TimeLimitSec)); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_TimeLimitSec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) { + return Swig_var_TFfGGen_TimeLimitSec_get(); +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_TimeLimitSec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + int res; + + res = Swig_var_TFfGGen_TimeLimitSec_set(args); + return !res ? SWIG_Py_Void() : NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFfGGen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + bool *arg1 = 0 ; + int *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + double *arg6 = 0 ; + double *arg7 = 0 ; + bool temp1 ; + bool val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + double temp5 ; + double val5 ; + int ecode5 = 0 ; + double temp6 ; + double val6 ; + int ecode6 = 0 ; + double temp7 ; + double val7 ; + int ecode7 = 0 ; + PyObject *swig_obj[7] ; + TFfGGen *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TFfGGen",7,7,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TFfGGen" "', argument " "1"" of type '" "bool""'"); + } + temp1 = static_cast< bool >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TFfGGen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TFfGGen" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TFfGGen" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TFfGGen" "', argument " "5"" of type '" "double""'"); + } + temp5 = static_cast< double >(val5); + arg5 = &temp5; + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TFfGGen" "', argument " "6"" of type '" "double""'"); + } + temp6 = static_cast< double >(val6); + arg6 = &temp6; + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TFfGGen" "', argument " "7"" of type '" "double""'"); + } + temp7 = static_cast< double >(val7); + arg7 = &temp7; + result = (TFfGGen *)new TFfGGen((bool const &)*arg1,(int const &)*arg2,(double const &)*arg3,(double const &)*arg4,(double const &)*arg5,(double const &)*arg6,(double const &)*arg7); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFfGGen, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GetGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_GetGraph" "', argument " "1"" of type '" "TFfGGen const *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + result = ((TFfGGen const *)arg1)->GetGraph(); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_SetGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + PNGraph *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFfGGen_SetGraph",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_SetGraph" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFfGGen_SetGraph" "', argument " "2"" of type '" "PNGraph const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFfGGen_SetGraph" "', argument " "2"" of type '" "PNGraph const &""'"); + } + arg2 = reinterpret_cast< PNGraph * >(argp2); + (arg1)->SetGraph((PNGraph const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_Clr" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GetParamStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_GetParamStr" "', argument " "1"" of type '" "TFfGGen const *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + result = ((TFfGGen const *)arg1)->GetParamStr(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_AddNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_AddNodes" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFfGGen_AddNodes" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFfGGen_AddNodes" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (TFfGGen::TStopReason)(arg1)->AddNodes((int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_AddNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_AddNodes" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFfGGen_AddNodes" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TFfGGen::TStopReason)(arg1)->AddNodes((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_AddNodes(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFfGGen_AddNodes",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TFfGGen_AddNodes__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TFfGGen_AddNodes__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFfGGen_AddNodes'.\n" + " Possible C/C++ prototypes are:\n" + " TFfGGen::AddNodes(int const &,bool const &)\n" + " TFfGGen::AddNodes(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GenGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_GenGraph" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFfGGen_GenGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFfGGen_GenGraph" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (TFfGGen::TStopReason)(arg1)->GenGraph((int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GenGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_GenGraph" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFfGGen_GenGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TFfGGen::TStopReason)(arg1)->GenGraph((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GenGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + int *arg2 = 0 ; + PGStatVec *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_GenGraph" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFfGGen_GenGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_PGStatVec, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFfGGen_GenGraph" "', argument " "3"" of type '" "PGStatVec &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFfGGen_GenGraph" "', argument " "3"" of type '" "PGStatVec &""'"); + } + arg3 = reinterpret_cast< PGStatVec * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TFfGGen_GenGraph" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (TFfGGen::TStopReason)(arg1)->GenGraph((int const &)*arg2,*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GenGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + int *arg2 = 0 ; + PGStatVec *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_GenGraph" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFfGGen_GenGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_PGStatVec, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFfGGen_GenGraph" "', argument " "3"" of type '" "PGStatVec &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFfGGen_GenGraph" "', argument " "3"" of type '" "PGStatVec &""'"); + } + arg3 = reinterpret_cast< PGStatVec * >(argp3); + result = (TFfGGen::TStopReason)(arg1)->GenGraph((int const &)*arg2,*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GenGraph(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFfGGen_GenGraph",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TFfGGen_GenGraph__SWIG_1(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_PGStatVec, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TFfGGen_GenGraph__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 3) { + return _wrap_TFfGGen_GenGraph__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TFfGGen_GenGraph__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFfGGen_GenGraph'.\n" + " Possible C/C++ prototypes are:\n" + " TFfGGen::GenGraph(int const &,bool const &)\n" + " TFfGGen::GenGraph(int const &)\n" + " TFfGGen::GenGraph(int const &,PGStatVec &,bool const &)\n" + " TFfGGen::GenGraph(int const &,PGStatVec &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_PlotFireSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TFfGGen_PlotFireSize",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFfGGen_PlotFireSize" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFfGGen_PlotFireSize" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFfGGen_PlotFireSize" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFfGGen_PlotFireSize" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFfGGen_PlotFireSize" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->PlotFireSize((TStr const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFfGGen_GenFFGraphs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + TStr *arg3 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TFfGGen_GenFFGraphs",3,3,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFfGGen_GenFFGraphs" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFfGGen_GenFFGraphs" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFfGGen_GenFFGraphs" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFfGGen_GenFFGraphs" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + TFfGGen::GenFFGraphs((double const &)*arg1,(double const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TFfGGen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFfGGen *arg1 = (TFfGGen *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFfGGen, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TFfGGen" "', argument " "1"" of type '" "TFfGGen *""'"); + } + arg1 = reinterpret_cast< TFfGGen * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TFfGGen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TFfGGen, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TFfGGen_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TUndirFFire__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + TUndirFFire *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TUndirFFire" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (TUndirFFire *)new TUndirFFire((double const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUndirFFire, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUndirFFire__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TUndirFFire *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TUndirFFire *)new TUndirFFire(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUndirFFire, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUndirFFire(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUndirFFire",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TUndirFFire__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TUndirFFire__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUndirFFire'.\n" + " Possible C/C++ prototypes are:\n" + " TUndirFFire::TUndirFFire(double const &)\n" + " TUndirFFire::TUndirFFire()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_SetGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + PUNGraph *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUndirFFire_SetGraph",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUndirFFire_SetGraph" "', argument " "1"" of type '" "TUndirFFire *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUndirFFire_SetGraph" "', argument " "2"" of type '" "PUNGraph const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUndirFFire_SetGraph" "', argument " "2"" of type '" "PUNGraph const &""'"); + } + arg2 = reinterpret_cast< PUNGraph * >(argp2); + (arg1)->SetGraph((PUNGraph const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_GetGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUndirFFire_GetGraph" "', argument " "1"" of type '" "TUndirFFire const *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + result = ((TUndirFFire const *)arg1)->GetGraph(); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_GetNBurned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUndirFFire_GetNBurned" "', argument " "1"" of type '" "TUndirFFire const *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + result = (int)((TUndirFFire const *)arg1)->GetNBurned(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_GetBurnedNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TUndirFFire_GetBurnedNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUndirFFire_GetBurnedNId" "', argument " "1"" of type '" "TUndirFFire const *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUndirFFire_GetBurnedNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TUndirFFire const *)arg1)->GetBurnedNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_BurnGeoFire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TUndirFFire_BurnGeoFire",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUndirFFire_BurnGeoFire" "', argument " "1"" of type '" "TUndirFFire *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUndirFFire_BurnGeoFire" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->BurnGeoFire((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_AddNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUndirFFire_AddNodes" "', argument " "1"" of type '" "TUndirFFire *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUndirFFire_AddNodes" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUndirFFire_AddNodes" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (TFfGGen::TStopReason)(arg1)->AddNodes((int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_AddNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TFfGGen::TStopReason result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUndirFFire_AddNodes" "', argument " "1"" of type '" "TUndirFFire *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUndirFFire_AddNodes" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TFfGGen::TStopReason)(arg1)->AddNodes((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUndirFFire_AddNodes(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUndirFFire_AddNodes",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TUndirFFire_AddNodes__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TUndirFFire_AddNodes__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUndirFFire_AddNodes'.\n" + " Possible C/C++ prototypes are:\n" + " TUndirFFire::AddNodes(int const &,bool const &)\n" + " TUndirFFire::AddNodes(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TUndirFFire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUndirFFire *arg1 = (TUndirFFire *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUndirFFire, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUndirFFire" "', argument " "1"" of type '" "TUndirFFire *""'"); + } + arg1 = reinterpret_cast< TUndirFFire * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUndirFFire_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUndirFFire, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUndirFFire_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TCs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TCs *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TCs *)new TCs(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCs, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCs *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TCs *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TCs, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TCs" "', argument " "1"" of type '" "TCs const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TCs" "', argument " "1"" of type '" "TCs const &""'"); + } + arg1 = reinterpret_cast< TCs * >(argp1); + result = (TCs *)new TCs((TCs const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCs, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TCs *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TCs" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TCs *)new TCs((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCs, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCs(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TCs",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TCs__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TCs, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TCs__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TCs__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TCs'.\n" + " Possible C/C++ prototypes are:\n" + " TCs::TCs()\n" + " TCs::TCs(TCs const &)\n" + " TCs::TCs(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TCs___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCs *arg1 = (TCs *) 0 ; + TCs *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TCs___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCs, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCs___eq__" "', argument " "1"" of type '" "TCs const *""'"); + } + arg1 = reinterpret_cast< TCs * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TCs, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCs___eq__" "', argument " "2"" of type '" "TCs const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCs___eq__" "', argument " "2"" of type '" "TCs const &""'"); + } + arg2 = reinterpret_cast< TCs * >(argp2); + result = (bool)((TCs const *)arg1)->operator ==((TCs const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCs___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCs *arg1 = (TCs *) 0 ; + TCs *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TCs *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCs, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCs___iadd__" "', argument " "1"" of type '" "TCs *""'"); + } + arg1 = reinterpret_cast< TCs * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TCs, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCs___iadd__" "', argument " "2"" of type '" "TCs const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCs___iadd__" "', argument " "2"" of type '" "TCs const &""'"); + } + arg2 = reinterpret_cast< TCs * >(argp2); + result = (TCs *) &(arg1)->operator +=((TCs const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCs, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCs___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCs *arg1 = (TCs *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + TCs *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCs, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCs___iadd__" "', argument " "1"" of type '" "TCs *""'"); + } + arg1 = reinterpret_cast< TCs * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TCs___iadd__" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (TCs *) &(arg1)->operator +=((char const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCs, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCs___iadd____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TCs *arg1 = (TCs *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TCs *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCs, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCs___iadd__" "', argument " "1"" of type '" "TCs *""'"); + } + arg1 = reinterpret_cast< TCs * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TCs___iadd__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TCs *) &(arg1)->operator +=((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCs, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCs___iadd__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TCs___iadd__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TCs, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TCs___iadd____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_2; + return _wrap_TCs___iadd____SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TCs___iadd____SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TCs___iadd__'.\n" + " Possible C/C++ prototypes are:\n" + " TCs::operator +=(TCs const &)\n" + " TCs::operator +=(char const &)\n" + " TCs::operator +=(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TCs_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCs *arg1 = (TCs *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCs, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCs_Get" "', argument " "1"" of type '" "TCs const *""'"); + } + arg1 = reinterpret_cast< TCs * >(argp1); + result = (int)((TCs const *)arg1)->Get(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCs_GetCsFromBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int *arg2 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TCs result; + + if (!SWIG_Python_UnpackTuple(args,"TCs_GetCsFromBf",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCs_GetCsFromBf" "', argument " "1"" of type '" "char *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TCs_GetCsFromBf" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TCs::GetCsFromBf(arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TCs(static_cast< const TCs& >(result))), SWIGTYPE_p_TCs, SWIG_POINTER_OWN | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TCs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCs *arg1 = (TCs *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCs, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TCs" "', argument " "1"" of type '" "TCs *""'"); + } + arg1 = reinterpret_cast< TCs * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TCs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TCs, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TCs_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TSOutMnp___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOutMnp *arg1 = (TSOutMnp *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TSOut *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TSOutMnp___call__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOutMnp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOutMnp___call__" "', argument " "1"" of type '" "TSOutMnp const *""'"); + } + arg1 = reinterpret_cast< TSOutMnp * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOutMnp___call__" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOutMnp___call__" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + result = (TSOut *) &((TSOutMnp const *)arg1)->operator ()(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TSOutMnp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOutMnp *arg1 = (TSOutMnp *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOutMnp, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSOutMnp" "', argument " "1"" of type '" "TSOutMnp *""'"); + } + arg1 = reinterpret_cast< TSOutMnp * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TSOutMnp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSOutMnp, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_TSBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TSBase *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TSBase" "', argument " "1"" of type '" "TSStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TSBase" "', argument " "1"" of type '" "TSStr const &""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + result = (TSBase *)new TSBase((TSStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSBase, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TSBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSBase *arg1 = (TSBase *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSBase, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSBase" "', argument " "1"" of type '" "TSBase *""'"); + } + arg1 = reinterpret_cast< TSBase * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSBase_GetSNm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSBase *arg1 = (TSBase *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSBase, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSBase_GetSNm" "', argument " "1"" of type '" "TSBase const *""'"); + } + arg1 = reinterpret_cast< TSBase * >(argp1); + result = ((TSBase const *)arg1)->GetSNm(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TSBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSBase, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TSBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_delete_TSIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSIn" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Eof" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (bool)(arg1)->Eof(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Len" "', argument " "1"" of type '" "TSIn const *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (int)((TSIn const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_GetCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_GetCh" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (char)(arg1)->GetCh(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_PeekCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_PeekCh" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (char)(arg1)->PeekCh(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_GetBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *arg2 = (void *) 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TSIn_GetBf",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_GetBf" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_GetBf" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSIn_GetBf" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + result = (int)(arg1)->GetBf((void const *)arg2,(TSize const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_GetNextLnBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TSIn_GetNextLnBf",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_GetNextLnBf" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_GetNextLnBf" "', argument " "2"" of type '" "TChA &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_GetNextLnBf" "', argument " "2"" of type '" "TChA &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (bool)(arg1)->GetNextLnBf(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Reset" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + (arg1)->Reset(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_IsFastMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_IsFastMode" "', argument " "1"" of type '" "TSIn const *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (bool)((TSIn const *)arg1)->IsFastMode(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_SetFastMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSIn_SetFastMode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_SetFastMode" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSIn_SetFastMode" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->SetFastMode((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_LoadCs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_LoadCs" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + (arg1)->LoadCs(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_LoadBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + void *arg2 = (void *) 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TSIn_LoadBf",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_LoadBf" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_LoadBf" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSIn_LoadBf" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + (arg1)->LoadBf((void const *)arg2,(TSize const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_LoadNewBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + void *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TSIn_LoadNewBf",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_LoadNewBf" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSIn_LoadNewBf" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (void *)(arg1)->LoadNewBf((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bool, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "bool &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "bool &""'"); + } + arg2 = reinterpret_cast< bool * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + uchar *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_char, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "uchar &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "uchar &""'"); + } + arg2 = reinterpret_cast< uchar * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_char, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "char &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "char &""'"); + } + arg2 = reinterpret_cast< char * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + short *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "short &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "short &""'"); + } + arg2 = reinterpret_cast< short * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + ushort *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_short, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "ushort &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "ushort &""'"); + } + arg2 = reinterpret_cast< ushort * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "uint &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "uint &""'"); + } + arg2 = reinterpret_cast< uint * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "int64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "int64 &""'"); + } + arg2 = reinterpret_cast< int64 * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "uint64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "uint64 &""'"); + } + arg2 = reinterpret_cast< uint64 * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "double &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + sdouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "sdouble &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "sdouble &""'"); + } + arg2 = reinterpret_cast< sdouble * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + ldouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "ldouble &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "ldouble &""'"); + } + arg2 = reinterpret_cast< ldouble * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_12(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + char **arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_char, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "char *&""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "char *&""'"); + } + arg2 = reinterpret_cast< char ** >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSIn_Load" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TSIn_Load" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + (arg1)->Load(*arg2,(int const &)*arg3,(int const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load__SWIG_13(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + char **arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_Load" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_char, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_Load" "', argument " "2"" of type '" "char *&""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_Load" "', argument " "2"" of type '" "char *&""'"); + } + arg2 = reinterpret_cast< char ** >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_Load(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSIn_Load",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TSIn_Load__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TSIn_Load__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_char, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TSIn_Load__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TSIn_Load__SWIG_3(self, argc, argv); + } +check_4: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_TSIn_Load__SWIG_4(self, argc, argv); + } +check_5: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_6; + return _wrap_TSIn_Load__SWIG_5(self, argc, argv); + } +check_6: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_7; + return _wrap_TSIn_Load__SWIG_6(self, argc, argv); + } +check_7: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_8; + return _wrap_TSIn_Load__SWIG_7(self, argc, argv); + } +check_8: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long_long, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_9; + return _wrap_TSIn_Load__SWIG_8(self, argc, argv); + } +check_9: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_10; + return _wrap_TSIn_Load__SWIG_9(self, argc, argv); + } +check_10: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_11; + return _wrap_TSIn_Load__SWIG_10(self, argc, argv); + } +check_11: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_double, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_12; + return _wrap_TSIn_Load__SWIG_11(self, argc, argv); + } +check_12: + + if (argc == 2) { + return _wrap_TSIn_Load__SWIG_13(self, argc, argv); + } + if (argc == 4) { + return _wrap_TSIn_Load__SWIG_12(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSIn_Load'.\n" + " Possible C/C++ prototypes are:\n" + " TSIn::Load(bool &)\n" + " TSIn::Load(uchar &)\n" + " TSIn::Load(char &)\n" + " TSIn::Load(short &)\n" + " TSIn::Load(ushort &)\n" + " TSIn::Load(int &)\n" + " TSIn::Load(uint &)\n" + " TSIn::Load(int64 &)\n" + " TSIn::Load(uint64 &)\n" + " TSIn::Load(double &)\n" + " TSIn::Load(sdouble &)\n" + " TSIn::Load(ldouble &)\n" + " TSIn::Load(char *&,int const &,int const &)\n" + " TSIn::Load(char *&)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bool, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "bool &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "bool &""'"); + } + arg2 = reinterpret_cast< bool * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + uchar *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_char, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "uchar &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "uchar &""'"); + } + arg2 = reinterpret_cast< uchar * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_char, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "char &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "char &""'"); + } + arg2 = reinterpret_cast< char * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + short *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_short, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "short &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "short &""'"); + } + arg2 = reinterpret_cast< short * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + ushort *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_short, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "ushort &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "ushort &""'"); + } + arg2 = reinterpret_cast< ushort * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "uint &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "uint &""'"); + } + arg2 = reinterpret_cast< uint * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "int64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "int64 &""'"); + } + arg2 = reinterpret_cast< int64 * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "uint64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "uint64 &""'"); + } + arg2 = reinterpret_cast< uint64 * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + float *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_float, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "float &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "float &""'"); + } + arg2 = reinterpret_cast< float * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "double &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift____SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + long double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn___rshift__" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "long double &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn___rshift__" "', argument " "2"" of type '" "long double &""'"); + } + arg2 = reinterpret_cast< long double * >(argp2); + result = (TSIn *) &(arg1)->operator >>(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSIn, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn___rshift__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSIn___rshift__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TSIn___rshift____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TSIn___rshift____SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_char, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TSIn___rshift____SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TSIn___rshift____SWIG_3(self, argc, argv); + } +check_4: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_TSIn___rshift____SWIG_4(self, argc, argv); + } +check_5: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_6; + return _wrap_TSIn___rshift____SWIG_5(self, argc, argv); + } +check_6: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_7; + return _wrap_TSIn___rshift____SWIG_6(self, argc, argv); + } +check_7: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_8; + return _wrap_TSIn___rshift____SWIG_7(self, argc, argv); + } +check_8: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long_long, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_9; + return _wrap_TSIn___rshift____SWIG_8(self, argc, argv); + } +check_9: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_10; + return _wrap_TSIn___rshift____SWIG_9(self, argc, argv); + } +check_10: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_11; + return _wrap_TSIn___rshift____SWIG_10(self, argc, argv); + } +check_11: + + if (argc == 2) { + return _wrap_TSIn___rshift____SWIG_11(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TSIn_GetNextLn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_GetNextLn" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_GetNextLn" "', argument " "2"" of type '" "TStr &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_GetNextLn" "', argument " "2"" of type '" "TStr &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)(arg1)->GetNextLn(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_GetNextLn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = (TSIn *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSIn_GetNextLn" "', argument " "1"" of type '" "TSIn *""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSIn_GetNextLn" "', argument " "2"" of type '" "TChA &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSIn_GetNextLn" "', argument " "2"" of type '" "TChA &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (bool)(arg1)->GetNextLn(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSIn_GetNextLn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSIn_GetNextLn",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TSIn_GetNextLn__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TSIn_GetNextLn__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSIn_GetNextLn'.\n" + " Possible C/C++ prototypes are:\n" + " TSIn::GetNextLn(TStr &)\n" + " TSIn::GetNextLn(TChA &)\n"); + return 0; +} + + +SWIGINTERN int Swig_var_TSIn_StdIn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TSIn_StdIn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TSIn_StdIn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TSIn::StdIn), SWIGTYPE_p_TPtT_TSIn_t, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *TSIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSIn, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_TSOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSOut" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_EnableLnTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSOut_EnableLnTrunc",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_EnableLnTrunc" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_EnableLnTrunc" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->EnableLnTrunc((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_DisableLnTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_DisableLnTrunc" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + (arg1)->DisableLnTrunc(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutCh" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutCh((char const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *arg2 = (void *) 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TSOut_PutBf",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutBf" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutBf" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_PutBf" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + result = (int)(arg1)->PutBf((void const *)arg2,(TSize const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Flush" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + (arg1)->Flush(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_GetFileId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TFileId result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_GetFileId" "', argument " "1"" of type '" "TSOut const *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + result = (TFileId)((TSOut const *)arg1)->GetFileId(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TMem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TSOut_PutMem",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutMem" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutMem" "', argument " "2"" of type '" "TMem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_PutMem" "', argument " "2"" of type '" "TMem const &""'"); + } + arg2 = reinterpret_cast< TMem * >(argp2); + result = (int)(arg1)->PutMem((TMem const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutCh" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_PutCh" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->PutCh((char const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutCh",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TSOut_PutCh__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TSOut_PutCh__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutCh'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutCh(char const &)\n" + " TSOut::PutCh(char const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TSOut_PutBool",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutBool" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutBool" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutBool((bool const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutInt" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutInt" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutInt((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutInt" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutInt" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TSOut_PutInt" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (int)(arg1)->PutInt((int const &)*arg2,(char const *)arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutInt",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TSOut_PutInt__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TSOut_PutInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutInt'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutInt(int const &)\n" + " TSOut::PutInt(int const &,char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutUInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutUInt" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutUInt" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutUInt((uint const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutUInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uint *arg2 = 0 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutUInt" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutUInt" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TSOut_PutUInt" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (int)(arg1)->PutUInt((uint const &)*arg2,(char const *)arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutUInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutUInt",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TSOut_PutUInt__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TSOut_PutUInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutUInt'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutUInt(uint const &)\n" + " TSOut::PutUInt(uint const &,char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutFlt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutFlt" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutFlt" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutFlt((double const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutFlt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + double *arg2 = 0 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutFlt" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutFlt" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TSOut_PutFlt" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (int)(arg1)->PutFlt((double const &)*arg2,(char const *)arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutFlt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutFlt",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TSOut_PutFlt__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TSOut_PutFlt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutFlt'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutFlt(double const &)\n" + " TSOut::PutFlt(double const &,char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStr" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)(arg1)->PutStr((char const *)arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStr" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (int)(arg1)->PutStr((TChA const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TStr *arg2 = 0 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStr" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TSOut_PutStr" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (int)(arg1)->PutStr((TStr const &)*arg2,(char const *)arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TStr *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStr" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_PutStr" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->PutStr((TStr const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStr" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_PutStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->PutStr((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutStr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TSOut_PutStr__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TSOut_PutStr__SWIG_4(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TSOut_PutStr__SWIG_0(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TSOut_PutStr__SWIG_2(self, argc, argv); + } +check_4: + + if (argc == 3) { + return _wrap_TSOut_PutStr__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutStr'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutStr(char const *)\n" + " TSOut::PutStr(TChA const &)\n" + " TSOut::PutStr(TStr const &,char const *)\n" + " TSOut::PutStr(TStr const &,bool const &)\n" + " TSOut::PutStr(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStrLn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TStr *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStrLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStrLn" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_PutStrLn" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_PutStrLn" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->PutStrLn((TStr const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStrLn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStrLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStrLn" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_PutStrLn" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->PutStrLn((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStrLn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutStrLn",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TSOut_PutStrLn__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TSOut_PutStrLn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutStrLn'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutStrLn(TStr const &,bool const &)\n" + " TSOut::PutStrLn(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStrFmt__varargs__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *varargs) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = (char *) 0 ; + void *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if(!PyArg_UnpackTuple(args,(char *)"TSOut_PutStrFmt",2,2,&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStrFmt" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStrFmt" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)(arg1)->PutStrFmt((char const *)arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStrFmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj; + PyObject *varargs; + PyObject *newargs; + + newargs = PyTuple_GetSlice(args,0,2); + varargs = PyTuple_GetSlice(args,2,PyTuple_Size(args)+1); + resultobj = _wrap_TSOut_PutStrFmt__varargs__(NULL,newargs,varargs); + Py_XDECREF(newargs); + Py_XDECREF(varargs); + return resultobj; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStrFmtLn__varargs__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *varargs) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = (char *) 0 ; + void *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if(!PyArg_UnpackTuple(args,(char *)"TSOut_PutStrFmtLn",2,2,&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutStrFmtLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_PutStrFmtLn" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)(arg1)->PutStrFmtLn((char const *)arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutStrFmtLn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj; + PyObject *varargs; + PyObject *newargs; + + newargs = PyTuple_GetSlice(args,0,2); + varargs = PyTuple_GetSlice(args,2,PyTuple_Size(args)+1); + resultobj = _wrap_TSOut_PutStrFmtLn__varargs__(NULL,newargs,varargs); + Py_XDECREF(newargs); + Py_XDECREF(varargs); + return resultobj; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutIndent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutIndent" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutIndent" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutIndent((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutIndent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutIndent" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + result = (int)(arg1)->PutIndent(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutIndent(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutIndent",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TSOut_PutIndent__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TSOut_PutIndent__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutIndent'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutIndent(int const &)\n" + " TSOut::PutIndent()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutLn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutLn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutLn((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutLn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + result = (int)(arg1)->PutLn(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutLn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutLn",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TSOut_PutLn__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TSOut_PutLn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutLn'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutLn(int const &)\n" + " TSOut::PutLn()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutDosLn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutDosLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutDosLn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutDosLn((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutDosLn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutDosLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + result = (int)(arg1)->PutDosLn(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutDosLn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutDosLn",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TSOut_PutDosLn__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TSOut_PutDosLn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutDosLn'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutDosLn(int const &)\n" + " TSOut::PutDosLn()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutSep__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutSep" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutSep" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutSep((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutSep__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutSep" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + result = (int)(arg1)->PutSep(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutSep(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutSep",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TSOut_PutSep__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TSOut_PutSep__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutSep'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutSep(int const &)\n" + " TSOut::PutSep()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutSepLn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutSepLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_PutSepLn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->PutSepLn((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutSepLn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_PutSepLn" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + result = (int)(arg1)->PutSepLn(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_PutSepLn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_PutSepLn",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TSOut_PutSepLn__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TSOut_PutSepLn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_PutSepLn'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::PutSepLn(int const &)\n" + " TSOut::PutSepLn()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut_SaveCs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_SaveCs" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + (arg1)->SaveCs(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_SaveBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *arg2 = (void *) 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TSOut_SaveBf",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_SaveBf" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_SaveBf" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_SaveBf" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + (arg1)->SaveBf((void const *)arg2,(TSize const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Save((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + (arg1)->Save((char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uchar *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar temp2 ; + unsigned char val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "uchar""'"); + } + temp2 = static_cast< uchar >(val2); + arg2 = &temp2; + (arg1)->Save((uchar const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + short *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + short temp2 ; + short val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "short""'"); + } + temp2 = static_cast< short >(val2); + arg2 = &temp2; + (arg1)->Save((short const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + ushort *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ushort temp2 ; + unsigned short val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "ushort""'"); + } + temp2 = static_cast< ushort >(val2); + arg2 = &temp2; + (arg1)->Save((ushort const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Save((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + (arg1)->Save((uint const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 temp2 ; + long long val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "int64""'"); + } + temp2 = static_cast< int64 >(val2); + arg2 = &temp2; + (arg1)->Save((int64 const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint64 temp2 ; + unsigned long long val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "uint64""'"); + } + temp2 = static_cast< uint64 >(val2); + arg2 = &temp2; + (arg1)->Save((uint64 const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + (arg1)->Save((double const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + sdouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + sdouble temp2 ; + float val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_float(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "sdouble""'"); + } + temp2 = static_cast< sdouble >(val2); + arg2 = &temp2; + (arg1)->Save((sdouble const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + ldouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "ldouble const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_Save" "', argument " "2"" of type '" "ldouble const &""'"); + } + arg2 = reinterpret_cast< ldouble * >(argp2); + (arg1)->Save((ldouble const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_12(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = (char *) 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_Save" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + (arg1)->Save((char const *)arg2,(TSize const &)*arg3); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_13(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + (arg1)->Save((char const *)arg2); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_14(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TSIn *arg2 = 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_Save" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_Save" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + (arg1)->Save(*arg2,(TSize const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_15(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_Save" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_16(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + PSIn *arg2 = 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "PSIn const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_Save" "', argument " "2"" of type '" "PSIn const &""'"); + } + arg2 = reinterpret_cast< PSIn * >(argp2); + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_Save" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + (arg1)->Save((PSIn const &)*arg2,(TSize const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_17(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + PSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "PSIn const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut_Save" "', argument " "2"" of type '" "PSIn const &""'"); + } + arg2 = reinterpret_cast< PSIn * >(argp2); + (arg1)->Save((PSIn const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save__SWIG_18(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + void *arg2 = (void *) 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut_Save" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut_Save" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TSOut_Save" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + (arg1)->Save((void const *)arg2,(TSize const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut_Save(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut_Save",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_long_double, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TSOut_Save__SWIG_11(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TSOut_Save__SWIG_15(self, argc, argv); + } +check_2: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TPtT_TSIn_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TSOut_Save__SWIG_17(self, argc, argv); + } +check_3: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_4; + return _wrap_TSOut_Save__SWIG_2(self, argc, argv); + } +check_4: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_5; + return _wrap_TSOut_Save__SWIG_4(self, argc, argv); + } +check_5: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_short(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_6; + return _wrap_TSOut_Save__SWIG_3(self, argc, argv); + } +check_6: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_7; + return _wrap_TSOut_Save__SWIG_6(self, argc, argv); + } +check_7: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_8; + return _wrap_TSOut_Save__SWIG_5(self, argc, argv); + } +check_8: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_9; + return _wrap_TSOut_Save__SWIG_8(self, argc, argv); + } +check_9: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_10; + return _wrap_TSOut_Save__SWIG_7(self, argc, argv); + } +check_10: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_11; + return _wrap_TSOut_Save__SWIG_10(self, argc, argv); + } +check_11: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_12; + return _wrap_TSOut_Save__SWIG_9(self, argc, argv); + } +check_12: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_13; + return _wrap_TSOut_Save__SWIG_1(self, argc, argv); + } +check_13: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_14; + return _wrap_TSOut_Save__SWIG_13(self, argc, argv); + } +check_14: + + if (argc == 2) { + return _wrap_TSOut_Save__SWIG_0(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TPtT_TSIn_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_16; + return _wrap_TSOut_Save__SWIG_16(self, argc, argv); + } +check_16: + + if (argc == 3) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_17; + return _wrap_TSOut_Save__SWIG_14(self, argc, argv); + } +check_17: + + if (argc == 3) { + int _v = 0; + { + void *ptr = 0; + int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_18; + return _wrap_TSOut_Save__SWIG_18(self, argc, argv); + } +check_18: + + if (argc == 3) { + return _wrap_TSOut_Save__SWIG_12(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TSOut_Save'.\n" + " Possible C/C++ prototypes are:\n" + " TSOut::Save(bool const &)\n" + " TSOut::Save(char const &)\n" + " TSOut::Save(uchar const &)\n" + " TSOut::Save(short const &)\n" + " TSOut::Save(ushort const &)\n" + " TSOut::Save(int const &)\n" + " TSOut::Save(uint const &)\n" + " TSOut::Save(int64 const &)\n" + " TSOut::Save(uint64 const &)\n" + " TSOut::Save(double const &)\n" + " TSOut::Save(sdouble const &)\n" + " TSOut::Save(ldouble const &)\n" + " TSOut::Save(char const *,TSize const &)\n" + " TSOut::Save(char const *)\n" + " TSOut::Save(TSIn &,TSize const &)\n" + " TSOut::Save(TSIn &)\n" + " TSOut::Save(PSIn const &,TSize const &)\n" + " TSOut::Save(PSIn const &)\n" + " TSOut::Save(void const *,TSize const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((bool const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uchar *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uchar temp2 ; + unsigned char val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "uchar""'"); + } + temp2 = static_cast< uchar >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((uchar const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((char const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + short *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + short temp2 ; + short val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "short""'"); + } + temp2 = static_cast< short >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((short const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + ushort *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ushort temp2 ; + unsigned short val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "ushort""'"); + } + temp2 = static_cast< ushort >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((ushort const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((uint const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 temp2 ; + long long val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "int64""'"); + } + temp2 = static_cast< int64 >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((int64 const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint64 temp2 ; + unsigned long long val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "uint64""'"); + } + temp2 = static_cast< uint64 >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((uint64 const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + float *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + float temp2 ; + float val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_float(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "float""'"); + } + temp2 = static_cast< float >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((float const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TSOut *) &(arg1)->operator <<((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + long double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "long double const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "long double const &""'"); + } + arg2 = reinterpret_cast< long double * >(argp2); + result = (TSOut *) &(arg1)->operator <<((long double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_12(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TSOutMnp *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOutMnp, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "TSOutMnp const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "TSOutMnp const &""'"); + } + arg2 = reinterpret_cast< TSOutMnp * >(argp2); + result = (TSOut *) &(arg1)->operator <<((TSOutMnp const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_13(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TSOut &(*arg2)(TSOut &) = (TSOut &(*)(TSOut &)) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + { + int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_TSOut__r_TSOut); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "TSOut &(*)(TSOut &)""'"); + } + } + result = (TSOut *) &(arg1)->operator <<(arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_14(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + result = (TSOut *) &(arg1)->operator <<(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift____SWIG_15(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSOut *arg1 = (TSOut *) 0 ; + PSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TSOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSOut___lshift__" "', argument " "1"" of type '" "TSOut *""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TSIn_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "PSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSOut___lshift__" "', argument " "2"" of type '" "PSIn &""'"); + } + arg2 = reinterpret_cast< PSIn * >(argp2); + result = (TSOut *) &(arg1)->operator <<(*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSOut, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSOut___lshift__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSOut___lshift__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_long_double, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TSOut___lshift____SWIG_11(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TSOutMnp, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TSOut___lshift____SWIG_12(self, argc, argv); + } +check_2: + + if (argc == 2) { + int _v = 0; + { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_TSOut__r_TSOut); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TSOut___lshift____SWIG_13(self, argc, argv); + } +check_3: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TSOut___lshift____SWIG_14(self, argc, argv); + } +check_4: + + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TPtT_TSIn_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_TSOut___lshift____SWIG_15(self, argc, argv); + } +check_5: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_6; + return _wrap_TSOut___lshift____SWIG_1(self, argc, argv); + } +check_6: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_7; + return _wrap_TSOut___lshift____SWIG_4(self, argc, argv); + } +check_7: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_short(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_8; + return _wrap_TSOut___lshift____SWIG_3(self, argc, argv); + } +check_8: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_9; + return _wrap_TSOut___lshift____SWIG_6(self, argc, argv); + } +check_9: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_10; + return _wrap_TSOut___lshift____SWIG_5(self, argc, argv); + } +check_10: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_11; + return _wrap_TSOut___lshift____SWIG_8(self, argc, argv); + } +check_11: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_12; + return _wrap_TSOut___lshift____SWIG_7(self, argc, argv); + } +check_12: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_13; + return _wrap_TSOut___lshift____SWIG_9(self, argc, argv); + } +check_13: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_14; + return _wrap_TSOut___lshift____SWIG_10(self, argc, argv); + } +check_14: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_15; + return _wrap_TSOut___lshift____SWIG_2(self, argc, argv); + } +check_15: + + if (argc == 2) { + return _wrap_TSOut___lshift____SWIG_0(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN int Swig_var_TSOut_StdOut_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TSOut_StdOut is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TSOut_StdOut_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TSOut::StdOut), SWIGTYPE_p_TPtT_TSOut_t, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *TSOut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSOut, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_TSInOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInOut *arg1 = (TSInOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInOut, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSInOut" "', argument " "1"" of type '" "TSInOut *""'"); + } + arg1 = reinterpret_cast< TSInOut * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInOut_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInOut *arg1 = (TSInOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSInOut_SetPos",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInOut_SetPos" "', argument " "1"" of type '" "TSInOut *""'"); + } + arg1 = reinterpret_cast< TSInOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSInOut_SetPos" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->SetPos((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInOut_MovePos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInOut *arg1 = (TSInOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSInOut_MovePos",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInOut_MovePos" "', argument " "1"" of type '" "TSInOut *""'"); + } + arg1 = reinterpret_cast< TSInOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSInOut_MovePos" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->MovePos((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInOut_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInOut *arg1 = (TSInOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInOut_GetPos" "', argument " "1"" of type '" "TSInOut const *""'"); + } + arg1 = reinterpret_cast< TSInOut * >(argp1); + result = (int)((TSInOut const *)arg1)->GetPos(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInOut_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInOut *arg1 = (TSInOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInOut_GetSize" "', argument " "1"" of type '" "TSInOut const *""'"); + } + arg1 = reinterpret_cast< TSInOut * >(argp1); + result = (int)((TSInOut const *)arg1)->GetSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInOut_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInOut *arg1 = (TSInOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInOut_Clr" "', argument " "1"" of type '" "TSInOut *""'"); + } + arg1 = reinterpret_cast< TSInOut * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TSInOut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSInOut, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_TStdIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStdIn *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TStdIn",0,0,0)) SWIG_fail; + result = (TStdIn *)new TStdIn(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStdIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStdIn_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TSIn > > result; + + if (!SWIG_Python_UnpackTuple(args,"TStdIn_New",0,0,0)) SWIG_fail; + result = TStdIn::New(); + resultobj = SWIG_NewPointerObj((new TPt< TSIn >(static_cast< const TPt< TSIn >& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStdIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStdIn *arg1 = (TStdIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStdIn, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStdIn" "', argument " "1"" of type '" "TStdIn *""'"); + } + arg1 = reinterpret_cast< TStdIn * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStdIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStdIn, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStdIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TStdOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStdOut *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TStdOut",0,0,0)) SWIG_fail; + result = (TStdOut *)new TStdOut(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStdOut, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStdOut_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TSOut > > result; + + if (!SWIG_Python_UnpackTuple(args,"TStdOut_New",0,0,0)) SWIG_fail; + result = TStdOut::New(); + resultobj = SWIG_NewPointerObj((new TPt< TSOut >(static_cast< const TPt< TSOut >& >(result))), SWIGTYPE_p_TPtT_TSOut_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStdOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStdOut *arg1 = (TStdOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStdOut, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStdOut" "', argument " "1"" of type '" "TStdOut *""'"); + } + arg1 = reinterpret_cast< TStdOut * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStdOut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStdOut, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStdOut_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TFIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TFIn *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFIn" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFIn" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TFIn *)new TFIn((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TFIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFIn" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFIn" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bool, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TFIn" "', argument " "2"" of type '" "bool &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFIn" "', argument " "2"" of type '" "bool &""'"); + } + arg2 = reinterpret_cast< bool * >(argp2); + result = (TFIn *)new TFIn((TStr const &)*arg1,*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TFIn",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_new_TFIn__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TFIn__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TFIn'.\n" + " Possible C/C++ prototypes are:\n" + " TFIn::TFIn(TStr const &)\n" + " TFIn::TFIn(TStr const &,bool &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFIn_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TFIn::New((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFIn_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bool, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFIn_New" "', argument " "2"" of type '" "bool &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFIn_New" "', argument " "2"" of type '" "bool &""'"); + } + arg2 = reinterpret_cast< bool * >(argp2); + result = TFIn::New((TStr const &)*arg1,*arg2); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFIn_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFIn_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TFIn_New__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TFIn_New__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFIn_New'.\n" + " Possible C/C++ prototypes are:\n" + " TFIn::New(TStr const &)\n" + " TFIn::New(TStr const &,bool &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TFIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFIn *arg1 = (TFIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFIn, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TFIn" "', argument " "1"" of type '" "TFIn *""'"); + } + arg1 = reinterpret_cast< TFIn * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TFIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TFIn, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TFIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TFOut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + TFOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFOut" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFOut" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TFOut" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (TFOut *)new TFOut((TStr const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFOut, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFOut__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TFOut *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFOut" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFOut" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TFOut *)new TFOut((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFOut, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFOut__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFOut *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFOut" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFOut" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TFOut" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bool, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TFOut" "', argument " "3"" of type '" "bool &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFOut" "', argument " "3"" of type '" "bool &""'"); + } + arg3 = reinterpret_cast< bool * >(argp3); + result = (TFOut *)new TFOut((TStr const &)*arg1,(bool const &)*arg2,*arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFOut, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFOut(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TFOut",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_new_TFOut__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TFOut__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_new_TFOut__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TFOut'.\n" + " Possible C/C++ prototypes are:\n" + " TFOut::TFOut(TStr const &,bool const &)\n" + " TFOut::TFOut(TStr const &)\n" + " TFOut::TFOut(TStr const &,bool const &,bool &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFOut_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TSOut > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFOut_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFOut_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFOut_New" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = TFOut::New((TStr const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj((new PSOut(static_cast< const PSOut& >(result))), SWIGTYPE_p_TPtT_TSOut_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFOut_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TSOut > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFOut_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFOut_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TFOut::New((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSOut(static_cast< const PSOut& >(result))), SWIGTYPE_p_TPtT_TSOut_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFOut_New__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + SwigValueWrapper< TPt< TSOut > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFOut_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFOut_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFOut_New" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bool, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFOut_New" "', argument " "3"" of type '" "bool &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFOut_New" "', argument " "3"" of type '" "bool &""'"); + } + arg3 = reinterpret_cast< bool * >(argp3); + result = TFOut::New((TStr const &)*arg1,(bool const &)*arg2,*arg3); + resultobj = SWIG_NewPointerObj((new PSOut(static_cast< const PSOut& >(result))), SWIGTYPE_p_TPtT_TSOut_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFOut_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFOut_New",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TFOut_New__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TFOut_New__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TFOut_New__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFOut_New'.\n" + " Possible C/C++ prototypes are:\n" + " TFOut::New(TStr const &,bool const &)\n" + " TFOut::New(TStr const &)\n" + " TFOut::New(TStr const &,bool const &,bool &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TFOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFOut *arg1 = (TFOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFOut, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TFOut" "', argument " "1"" of type '" "TFOut *""'"); + } + arg1 = reinterpret_cast< TFOut * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TFOut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TFOut, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TFOut_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TMIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + int res1 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + TMIn *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMIn" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TMIn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TMIn" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (TMIn *)new TMIn((void const *)arg1,(int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int *arg2 = 0 ; + int res1 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TMIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMIn" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TMIn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TMIn *)new TMIn((void const *)arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMIn__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TMIn *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMIn" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMIn" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TMIn *)new TMIn(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMIn__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + TMIn *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMIn" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (TMIn *)new TMIn((char const *)arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMIn, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMIn__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TMIn *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMIn" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMIn" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TMIn *)new TMIn((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMIn__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TMIn *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMIn" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMIn" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (TMIn *)new TMIn((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TMIn",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_new_TMIn__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TMIn__SWIG_4(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TMIn__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TMIn__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TMIn__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_new_TMIn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TMIn'.\n" + " Possible C/C++ prototypes are:\n" + " TMIn::TMIn(void const *,int const &,bool const &)\n" + " TMIn::TMIn(void const *,int const &)\n" + " TMIn::TMIn(TSIn &)\n" + " TMIn::TMIn(char const *)\n" + " TMIn::TMIn(TStr const &)\n" + " TMIn::TMIn(TChA const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMIn_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + int res1 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMIn_New" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMIn_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TMIn_New" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = TMIn::New((void const *)arg1,(int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMIn_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int *arg2 = 0 ; + int res1 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMIn_New" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMIn_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TMIn::New((void const *)arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMIn_New__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMIn_New" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = TMIn::New((char const *)arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMIn_New__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TMIn::New((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMIn_New__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMIn_New" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMIn_New" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TMIn::New((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMIn_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMIn_New",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TMIn_New__SWIG_3(self, argc, argv); + } +check_1: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TMIn_New__SWIG_4(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_TMIn_New__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TMIn_New__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TMIn_New__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMIn_New'.\n" + " Possible C/C++ prototypes are:\n" + " TMIn::New(void const *,int const &,bool const &)\n" + " TMIn::New(void const *,int const &)\n" + " TMIn::New(char const *)\n" + " TMIn::New(TStr const &)\n" + " TMIn::New(TChA const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TMIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMIn *arg1 = (TMIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMIn, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TMIn" "', argument " "1"" of type '" "TMIn *""'"); + } + arg1 = reinterpret_cast< TMIn * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMIn_GetBfAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMIn *arg1 = (TMIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMIn, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMIn_GetBfAddr" "', argument " "1"" of type '" "TMIn *""'"); + } + arg1 = reinterpret_cast< TMIn * >(argp1); + result = (char *)(arg1)->GetBfAddr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TMIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TMIn, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TMIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TMOut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TMOut *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TMOut" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TMOut *)new TMOut((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMOut, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMOut__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TMOut *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TMOut *)new TMOut(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMOut, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + SwigValueWrapper< TPt< TSOut > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TMOut_New" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = TMOut::New((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSOut(static_cast< const PSOut& >(result))), SWIGTYPE_p_TPtT_TSOut_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TSOut > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TMOut::New(); + resultobj = SWIG_NewPointerObj((new PSOut(static_cast< const PSOut& >(result))), SWIGTYPE_p_TPtT_TSOut_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMOut_New",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TMOut_New__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TMOut_New__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMOut_New'.\n" + " Possible C/C++ prototypes are:\n" + " TMOut::New(int const &)\n" + " TMOut::New()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_TMOut__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int *arg2 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TMOut *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMOut" "', argument " "1"" of type '" "char *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TMOut" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TMOut *)new TMOut(arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMOut, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMOut(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TMOut",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TMOut__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TMOut__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TMOut__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TMOut'.\n" + " Possible C/C++ prototypes are:\n" + " TMOut::TMOut(int const &)\n" + " TMOut::TMOut()\n" + " TMOut::TMOut(char *,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TMOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TMOut" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_AppendBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *arg2 = (void *) 0 ; + TSize *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + TSize temp3 ; + size_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TMOut_AppendBf",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_AppendBf" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMOut_AppendBf" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TMOut_AppendBf" "', argument " "3"" of type '" "TSize""'"); + } + temp3 = static_cast< TSize >(val3); + arg3 = &temp3; + (arg1)->AppendBf((void const *)arg2,(TSize const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_Len" "', argument " "1"" of type '" "TMOut const *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + result = (int)((TMOut const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_Clr" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char result; + + if (!SWIG_Python_UnpackTuple(args,"TMOut_GetCh",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetCh" "', argument " "1"" of type '" "TMOut const *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMOut_GetCh" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (char)((TMOut const *)arg1)->GetCh((int const &)*arg2); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetAsStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetAsStr" "', argument " "1"" of type '" "TMOut const *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + result = ((TMOut const *)arg1)->GetAsStr(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_CutBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TMOut_CutBf",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_CutBf" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMOut_CutBf" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->CutBf((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetSIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetSIn" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMOut_GetSIn" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TMOut_GetSIn" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (arg1)->GetSIn((bool const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetSIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetSIn" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMOut_GetSIn" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (arg1)->GetSIn((bool const &)*arg2); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetSIn__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetSIn" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + result = (arg1)->GetSIn(); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetSIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMOut_GetSIn",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TMOut_GetSIn__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TMOut_GetSIn__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TMOut_GetSIn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMOut_GetSIn'.\n" + " Possible C/C++ prototypes are:\n" + " TMOut::GetSIn(bool const &,int const &)\n" + " TMOut::GetSIn(bool const &)\n" + " TMOut::GetSIn()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetBfAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetBfAddr" "', argument " "1"" of type '" "TMOut const *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + result = (char *)((TMOut const *)arg1)->GetBfAddr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_IsCrLfLn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_IsCrLfLn" "', argument " "1"" of type '" "TMOut const *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + result = (bool)((TMOut const *)arg1)->IsCrLfLn(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetCrLfLn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetCrLfLn" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + result = (arg1)->GetCrLfLn(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_IsEolnLn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_IsEolnLn" "', argument " "1"" of type '" "TMOut const *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + result = (bool)((TMOut const *)arg1)->IsEolnLn(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_GetEolnLn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + bool *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TMOut_GetEolnLn",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_GetEolnLn" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMOut_GetEolnLn" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TMOut_GetEolnLn" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (arg1)->GetEolnLn((bool const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMOut_MkEolnLn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMOut *arg1 = (TMOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMOut_MkEolnLn" "', argument " "1"" of type '" "TMOut *""'"); + } + arg1 = reinterpret_cast< TMOut * >(argp1); + (arg1)->MkEolnLn(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TMOut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TMOut, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TMOut_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TChRet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + TChRet *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChRet" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChRet" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TChRet" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (TChRet *)new TChRet((PSIn const &)*arg1,(char const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChRet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChRet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TChRet *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChRet" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChRet" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + result = (TChRet *)new TChRet((PSIn const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChRet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChRet(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TChRet",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_new_TChRet__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TChRet__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TChRet'.\n" + " Possible C/C++ prototypes are:\n" + " TChRet::TChRet(PSIn const &,char const &)\n" + " TChRet::TChRet(PSIn const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChRet_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChRet *arg1 = (TChRet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChRet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChRet_Eof" "', argument " "1"" of type '" "TChRet const *""'"); + } + arg1 = reinterpret_cast< TChRet * >(argp1); + result = (bool)((TChRet const *)arg1)->Eof(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChRet_GetCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChRet *arg1 = (TChRet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChRet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChRet_GetCh" "', argument " "1"" of type '" "TChRet *""'"); + } + arg1 = reinterpret_cast< TChRet * >(argp1); + result = (char)(arg1)->GetCh(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChRet___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChRet *arg1 = (TChRet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChRet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChRet___call__" "', argument " "1"" of type '" "TChRet *""'"); + } + arg1 = reinterpret_cast< TChRet * >(argp1); + result = (char)(arg1)->operator ()(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TChRet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChRet *arg1 = (TChRet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChRet, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TChRet" "', argument " "1"" of type '" "TChRet *""'"); + } + arg1 = reinterpret_cast< TChRet * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TChRet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TChRet, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TChRet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TLnRet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TLnRet *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TLnRet" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TLnRet" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + result = (TLnRet *)new TLnRet((PSIn const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TLnRet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLnRet_NextLn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLnRet *arg1 = (TLnRet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TLnRet_NextLn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLnRet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLnRet_NextLn" "', argument " "1"" of type '" "TLnRet *""'"); + } + arg1 = reinterpret_cast< TLnRet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLnRet_NextLn" "', argument " "2"" of type '" "TStr &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLnRet_NextLn" "', argument " "2"" of type '" "TStr &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)(arg1)->NextLn(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TLnRet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLnRet *arg1 = (TLnRet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLnRet, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TLnRet" "', argument " "1"" of type '" "TLnRet *""'"); + } + arg1 = reinterpret_cast< TLnRet * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TLnRet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TLnRet, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TLnRet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN int Swig_var_TFile_TxtFExt_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFile_TxtFExt is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFile_TxtFExt_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TFile::TxtFExt), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFile_HtmlFExt_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFile_HtmlFExt is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFile_HtmlFExt_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TFile::HtmlFExt), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFile_HtmFExt_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFile_HtmFExt is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFile_HtmFExt_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TFile::HtmFExt), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFile_GifFExt_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFile_GifFExt is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFile_GifFExt_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TFile::GifFExt), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFile_JarFExt_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFile_JarFExt is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFile_JarFExt_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TFile::JarFExt), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_TFile_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFile_Exists" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_Exists" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)TFile::Exists((TStr const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFile_Del__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFile_Del" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_Del" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFile_Del" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + TFile::Del((TStr const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFile_Del__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFile_Del" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_Del" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + TFile::Del((TStr const &)*arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFile_Del(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFile_Del",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TFile_Del__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TFile_Del__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFile_Del'.\n" + " Possible C/C++ prototypes are:\n" + " TFile::Del(TStr const &,bool const &)\n" + " TFile::Del(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFile_DelWc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFile_DelWc" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_DelWc" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFile_DelWc" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + TFile::DelWc((TStr const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFile_DelWc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFile_DelWc" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_DelWc" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + TFile::DelWc((TStr const &)*arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFile_DelWc(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFile_DelWc",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TFile_DelWc__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TFile_DelWc__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFile_DelWc'.\n" + " Possible C/C++ prototypes are:\n" + " TFile::DelWc(TStr const &,bool const &)\n" + " TFile::DelWc(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFile_Rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFile_Rename",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFile_Rename" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_Rename" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFile_Rename" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_Rename" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + TFile::Rename((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFile_GetUniqueFNm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFile_GetUniqueFNm" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFile_GetUniqueFNm" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TFile::GetUniqueFNm((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFile *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TFile",0,0,0)) SWIG_fail; + result = (TFile *)new TFile(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFile, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFile *arg1 = (TFile *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFile, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TFile" "', argument " "1"" of type '" "TFile *""'"); + } + arg1 = reinterpret_cast< TFile * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TFile, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TUNGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TUNGraph *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TUNGraph *)new TUNGraph(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TUNGraph *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TUNGraph" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TUNGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TUNGraph *)new TUNGraph((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUNGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TUNGraph, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUNGraph" "', argument " "1"" of type '" "TUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUNGraph" "', argument " "1"" of type '" "TUNGraph const &""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (TUNGraph *)new TUNGraph((TUNGraph const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUNGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUNGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUNGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TUNGraph *)new TUNGraph(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraph(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUNGraph",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TUNGraph__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TUNGraph, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TUNGraph__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TUNGraph__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TUNGraph__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUNGraph'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::TUNGraph()\n" + " TUNGraph::TUNGraph(int const &,int const &)\n" + " TUNGraph::TUNGraph(TUNGraph const &)\n" + " TUNGraph::TUNGraph(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Save" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TUNGraph const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TUNGraph::New(); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUNGraph_New" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TUNGraph::New((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TUNGraph_New__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUNGraph_New__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_New'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::New()\n" + " TUNGraph::New(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TUNGraph::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TGraphFlag *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_HasFlag",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_HasFlag" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TGraphFlag, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + arg2 = reinterpret_cast< TGraphFlag * >(argp2); + result = (bool)((TUNGraph const *)arg1)->HasFlag((TGraphFlag const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetNodes" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (int)((TUNGraph const *)arg1)->GetNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_AddNode" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->AddNode(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_AddNode" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (int)(arg1)->AddNode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TUNGraph::TNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_AddNode" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUNGraph__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_AddNode" "', argument " "2"" of type '" "TUNGraph::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_AddNode" "', argument " "2"" of type '" "TUNGraph::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TUNGraph::TNodeI * >(argp2); + result = (int)(arg1)->AddNode((TUNGraph::TNodeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddNode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_AddNode" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUNGraph_AddNode" "', argument " "3"" of type '" "TIntV const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_AddNode" "', argument " "3"" of type '" "TIntV const &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + result = (int)(arg1)->AddNode((int const &)*arg2,(TIntV const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddNode__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + TVecPool< TInt > *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_AddNode" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecPoolT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUNGraph_AddNode" "', argument " "3"" of type '" "TVecPool< TInt > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_AddNode" "', argument " "3"" of type '" "TVecPool< TInt > const &""'"); + } + arg3 = reinterpret_cast< TVecPool< TInt > * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TUNGraph_AddNode" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)(arg1)->AddNode((int const &)*arg2,(TVecPool< TInt > const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_AddNode",0,4,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUNGraph_AddNode__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TUNGraph__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TUNGraph_AddNode__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TUNGraph_AddNode__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TUNGraph_AddNode__SWIG_3(self, argc, argv); + } + if (argc == 4) { + return _wrap_TUNGraph_AddNode__SWIG_4(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_AddNode'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::AddNode(int)\n" + " TUNGraph::AddNode()\n" + " TUNGraph::AddNode(TUNGraph::TNodeI const &)\n" + " TUNGraph::AddNode(int const &,TIntV const &)\n" + " TUNGraph::AddNode(int const &,TVecPool< TInt > const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_DelNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_DelNode" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_DelNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_DelNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TUNGraph::TNode *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_DelNode" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUNGraph__TNode, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_DelNode" "', argument " "2"" of type '" "TUNGraph::TNode const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_DelNode" "', argument " "2"" of type '" "TUNGraph::TNode const &""'"); + } + arg2 = reinterpret_cast< TUNGraph::TNode * >(argp2); + (arg1)->DelNode((TUNGraph::TNode const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_DelNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_DelNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TUNGraph__TNode, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TUNGraph_DelNode__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TUNGraph_DelNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_DelNode'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::DelNode(int const &)\n" + " TUNGraph::DelNode(TUNGraph::TNode const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_IsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_IsNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_IsNode" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_IsNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TUNGraph const *)arg1)->IsNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_BegNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUNGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_BegNI" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = ((TUNGraph const *)arg1)->BegNI(); + resultobj = SWIG_NewPointerObj((new TUNGraph::TNodeI(static_cast< const TUNGraph::TNodeI& >(result))), SWIGTYPE_p_TUNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_EndNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUNGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_EndNI" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = ((TUNGraph const *)arg1)->EndNI(); + resultobj = SWIG_NewPointerObj((new TUNGraph::TNodeI(static_cast< const TUNGraph::TNodeI& >(result))), SWIGTYPE_p_TUNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TUNGraph::TNodeI result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_GetNI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetNI" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_GetNI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TUNGraph const *)arg1)->GetNI((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TUNGraph::TNodeI(static_cast< const TUNGraph::TNodeI& >(result))), SWIGTYPE_p_TUNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetMxNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetMxNId" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (int)((TUNGraph const *)arg1)->GetMxNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetEdges" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (int)((TUNGraph const *)arg1)->GetEdges(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_AddEdge" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraph_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TUNGraph::TEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_AddEdge" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUNGraph__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_AddEdge" "', argument " "2"" of type '" "TUNGraph::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_AddEdge" "', argument " "2"" of type '" "TUNGraph::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TUNGraph::TEdgeI * >(argp2); + result = (int)(arg1)->AddEdge((TUNGraph::TEdgeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_AddEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_AddEdge",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TUNGraph_AddEdge__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TUNGraph_AddEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_AddEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::AddEdge(int const &,int const &)\n" + " TUNGraph::AddEdge(TUNGraph::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_DelEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_DelEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_DelEdge" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraph_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_IsEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_IsEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_IsEdge" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (bool)((TUNGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_BegEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUNGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_BegEI" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = ((TUNGraph const *)arg1)->BegEI(); + resultobj = SWIG_NewPointerObj((new TUNGraph::TEdgeI(static_cast< const TUNGraph::TEdgeI& >(result))), SWIGTYPE_p_TUNGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_EndEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUNGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_EndEI" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = ((TUNGraph const *)arg1)->EndEI(); + resultobj = SWIG_NewPointerObj((new TUNGraph::TEdgeI(static_cast< const TUNGraph::TEdgeI& >(result))), SWIGTYPE_p_TUNGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TUNGraph::TEdgeI result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_GetEI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetEI" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_GetEI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraph_GetEI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TUNGraph const *)arg1)->GetEI((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TUNGraph::TEdgeI(static_cast< const TUNGraph::TEdgeI& >(result))), SWIGTYPE_p_TUNGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetRndNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetRndNId" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetRndNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetRndNId" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (int)(arg1)->GetRndNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetRndNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_GetRndNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUNGraph_GetRndNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUNGraph_GetRndNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_GetRndNId'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::GetRndNId(TRnd &)\n" + " TUNGraph::GetRndNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetRndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TUNGraph::TNodeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetRndNI" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (arg1)->GetRndNI(*arg2); + resultobj = SWIG_NewPointerObj((new TUNGraph::TNodeI(static_cast< const TUNGraph::TNodeI& >(result))), SWIGTYPE_p_TUNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetRndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUNGraph::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetRndNI" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (arg1)->GetRndNI(); + resultobj = SWIG_NewPointerObj((new TUNGraph::TNodeI(static_cast< const TUNGraph::TNodeI& >(result))), SWIGTYPE_p_TUNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetRndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_GetRndNI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUNGraph_GetRndNI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUNGraph_GetRndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_GetRndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::GetRndNI(TRnd &)\n" + " TUNGraph::GetRndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_GetNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_GetNIdV" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TUNGraph const *)arg1)->GetNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Empty" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (bool)((TUNGraph const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Clr" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_Reserve",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Reserve" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraph_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_ReserveNIdDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_ReserveNIdDeg",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_ReserveNIdDeg" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_ReserveNIdDeg" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraph_ReserveNIdDeg" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->ReserveNIdDeg((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Defrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Defrag" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_Defrag" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Defrag((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Defrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Defrag" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + (arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Defrag(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_Defrag",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUNGraph_Defrag__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUNGraph_Defrag__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_Defrag'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::Defrag(bool const &)\n" + " TUNGraph::Defrag()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_IsOk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_IsOk" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraph_IsOk" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TUNGraph const *)arg1)->IsOk((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_IsOk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_IsOk" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + result = (bool)((TUNGraph const *)arg1)->IsOk(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_IsOk(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_IsOk",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUNGraph_IsOk__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUNGraph_IsOk__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_IsOk'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::IsOk(bool const &) const\n" + " TUNGraph::IsOk() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Dump__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + FILE *arg2 = (FILE *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Dump" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraph_Dump" "', argument " "2"" of type '" "FILE *""'"); + } + arg2 = reinterpret_cast< FILE * >(argp2); + ((TUNGraph const *)arg1)->Dump(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Dump__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraph_Dump" "', argument " "1"" of type '" "TUNGraph const *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + ((TUNGraph const *)arg1)->Dump(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_Dump(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraph_Dump",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUNGraph_Dump__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUNGraph_Dump__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraph_Dump'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraph::Dump(FILE *) const\n" + " TUNGraph::Dump() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraph_GetSmallGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TUNGraph > > result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraph_GetSmallGraph",0,0,0)) SWIG_fail; + result = TUNGraph::GetSmallGraph(); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TUNGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraph *arg1 = (TUNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraph, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUNGraph" "', argument " "1"" of type '" "TUNGraph *""'"); + } + arg1 = reinterpret_cast< TUNGraph * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUNGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUNGraph, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUNGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNGraph *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNGraph *)new TNGraph(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TNGraph *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TNGraph" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TNGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TNGraph *)new TNGraph((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNGraph, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNGraph" "', argument " "1"" of type '" "TNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNGraph" "', argument " "1"" of type '" "TNGraph const &""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (TNGraph *)new TNGraph((TNGraph const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TNGraph *)new TNGraph(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraph(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNGraph",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNGraph__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TNGraph, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TNGraph__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TNGraph__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TNGraph__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNGraph'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::TNGraph()\n" + " TNGraph::TNGraph(int const &,int const &)\n" + " TNGraph::TNGraph(TNGraph const &)\n" + " TNGraph::TNGraph(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Save" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TNGraph const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TNGraph::New(); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TNGraph_New" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TNGraph::New((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TNGraph_New__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNGraph_New__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_New'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::New()\n" + " TNGraph::New(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TNGraph::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TGraphFlag *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_HasFlag",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_HasFlag" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TGraphFlag, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + arg2 = reinterpret_cast< TGraphFlag * >(argp2); + result = (bool)((TNGraph const *)arg1)->HasFlag((TGraphFlag const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetNodes" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (int)((TNGraph const *)arg1)->GetNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_AddNode" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->AddNode(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_AddNode" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (int)(arg1)->AddNode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TNGraph::TNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_AddNode" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNGraph__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_AddNode" "', argument " "2"" of type '" "TNGraph::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_AddNode" "', argument " "2"" of type '" "TNGraph::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNGraph::TNodeI * >(argp2); + result = (int)(arg1)->AddNode((TNGraph::TNodeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddNode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + TIntV *arg3 = 0 ; + TIntV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_AddNode" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNGraph_AddNode" "', argument " "3"" of type '" "TIntV const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_AddNode" "', argument " "3"" of type '" "TIntV const &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNGraph_AddNode" "', argument " "4"" of type '" "TIntV const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_AddNode" "', argument " "4"" of type '" "TIntV const &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + result = (int)(arg1)->AddNode((int const &)*arg2,(TIntV const &)*arg3,(TIntV const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddNode__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + TVecPool< TInt > *arg3 = 0 ; + int *arg4 = 0 ; + int *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int temp5 ; + int val5 ; + int ecode5 = 0 ; + int result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_AddNode" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecPoolT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNGraph_AddNode" "', argument " "3"" of type '" "TVecPool< TInt > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_AddNode" "', argument " "3"" of type '" "TVecPool< TInt > const &""'"); + } + arg3 = reinterpret_cast< TVecPool< TInt > * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNGraph_AddNode" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TNGraph_AddNode" "', argument " "5"" of type '" "int""'"); + } + temp5 = static_cast< int >(val5); + arg5 = &temp5; + result = (int)(arg1)->AddNode((int const &)*arg2,(TVecPool< TInt > const &)*arg3,(int const &)*arg4,(int const &)*arg5); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_AddNode",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNGraph_AddNode__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNGraph__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TNGraph_AddNode__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TNGraph_AddNode__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNGraph_AddNode__SWIG_3(self, argc, argv); + } + if (argc == 5) { + return _wrap_TNGraph_AddNode__SWIG_4(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_AddNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::AddNode(int)\n" + " TNGraph::AddNode()\n" + " TNGraph::AddNode(TNGraph::TNodeI const &)\n" + " TNGraph::AddNode(int const &,TIntV const &,TIntV const &)\n" + " TNGraph::AddNode(int const &,TVecPool< TInt > const &,int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_DelNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_DelNode" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_DelNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_DelNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TNGraph::TNode *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_DelNode" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNGraph__TNode, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_DelNode" "', argument " "2"" of type '" "TNGraph::TNode const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_DelNode" "', argument " "2"" of type '" "TNGraph::TNode const &""'"); + } + arg2 = reinterpret_cast< TNGraph::TNode * >(argp2); + (arg1)->DelNode((TNGraph::TNode const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_DelNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_DelNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNGraph__TNode, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNGraph_DelNode__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TNGraph_DelNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_DelNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::DelNode(int const &)\n" + " TNGraph::DelNode(TNGraph::TNode const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_IsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_IsNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_IsNode" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_IsNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNGraph const *)arg1)->IsNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_BegNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_BegNI" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = ((TNGraph const *)arg1)->BegNI(); + resultobj = SWIG_NewPointerObj((new TNGraph::TNodeI(static_cast< const TNGraph::TNodeI& >(result))), SWIGTYPE_p_TNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_EndNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_EndNI" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = ((TNGraph const *)arg1)->EndNI(); + resultobj = SWIG_NewPointerObj((new TNGraph::TNodeI(static_cast< const TNGraph::TNodeI& >(result))), SWIGTYPE_p_TNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TNGraph::TNodeI result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_GetNI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetNI" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_GetNI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TNGraph const *)arg1)->GetNI((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNGraph::TNodeI(static_cast< const TNGraph::TNodeI& >(result))), SWIGTYPE_p_TNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetMxNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetMxNId" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (int)((TNGraph const *)arg1)->GetMxNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetEdges" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (int)((TNGraph const *)arg1)->GetEdges(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_AddEdge" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TNGraph::TEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_AddEdge" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNGraph__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_AddEdge" "', argument " "2"" of type '" "TNGraph::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_AddEdge" "', argument " "2"" of type '" "TNGraph::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNGraph::TEdgeI * >(argp2); + result = (int)(arg1)->AddEdge((TNGraph::TEdgeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_AddEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_AddEdge",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNGraph_AddEdge__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNGraph_AddEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_AddEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::AddEdge(int const &,int const &)\n" + " TNGraph::AddEdge(TNGraph::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_DelEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_DelEdge" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNGraph_DelEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_DelEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_DelEdge" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_DelEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_DelEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNGraph_DelEdge__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNGraph_DelEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_DelEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::DelEdge(int const &,int const &,bool const &)\n" + " TNGraph::DelEdge(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_IsEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_IsEdge" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNGraph_IsEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (bool)((TNGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_IsEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_IsEdge" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (bool)((TNGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_IsEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_IsEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNGraph_IsEdge__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNGraph_IsEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_IsEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::IsEdge(int const &,int const &,bool const &) const\n" + " TNGraph::IsEdge(int const &,int const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_BegEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_BegEI" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = ((TNGraph const *)arg1)->BegEI(); + resultobj = SWIG_NewPointerObj((new TNGraph::TEdgeI(static_cast< const TNGraph::TEdgeI& >(result))), SWIGTYPE_p_TNGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_EndEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_EndEI" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = ((TNGraph const *)arg1)->EndEI(); + resultobj = SWIG_NewPointerObj((new TNGraph::TEdgeI(static_cast< const TNGraph::TEdgeI& >(result))), SWIGTYPE_p_TNGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNGraph::TEdgeI result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_GetEI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetEI" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_GetEI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_GetEI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNGraph const *)arg1)->GetEI((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNGraph::TEdgeI(static_cast< const TNGraph::TEdgeI& >(result))), SWIGTYPE_p_TNGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetRndNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetRndNId" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetRndNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetRndNId" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (int)(arg1)->GetRndNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetRndNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_GetRndNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNGraph_GetRndNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNGraph_GetRndNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_GetRndNId'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::GetRndNId(TRnd &)\n" + " TNGraph::GetRndNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetRndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNGraph::TNodeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetRndNI" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (arg1)->GetRndNI(*arg2); + resultobj = SWIG_NewPointerObj((new TNGraph::TNodeI(static_cast< const TNGraph::TNodeI& >(result))), SWIGTYPE_p_TNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetRndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNGraph::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetRndNI" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (arg1)->GetRndNI(); + resultobj = SWIG_NewPointerObj((new TNGraph::TNodeI(static_cast< const TNGraph::TNodeI& >(result))), SWIGTYPE_p_TNGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetRndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_GetRndNI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNGraph_GetRndNI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNGraph_GetRndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_GetRndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::GetRndNI(TRnd &)\n" + " TNGraph::GetRndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_GetNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_GetNIdV" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TNGraph const *)arg1)->GetNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Empty" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (bool)((TNGraph const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Clr" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_Reserve",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Reserve" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_ReserveNIdInDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_ReserveNIdInDeg",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_ReserveNIdInDeg" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_ReserveNIdInDeg" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_ReserveNIdInDeg" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->ReserveNIdInDeg((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_ReserveNIdOutDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_ReserveNIdOutDeg",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_ReserveNIdOutDeg" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_ReserveNIdOutDeg" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraph_ReserveNIdOutDeg" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->ReserveNIdOutDeg((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Defrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Defrag" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_Defrag" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Defrag((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Defrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Defrag" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + (arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Defrag(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_Defrag",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNGraph_Defrag__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNGraph_Defrag__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_Defrag'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::Defrag(bool const &)\n" + " TNGraph::Defrag()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_IsOk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_IsOk" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraph_IsOk" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TNGraph const *)arg1)->IsOk((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_IsOk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_IsOk" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + result = (bool)((TNGraph const *)arg1)->IsOk(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_IsOk(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_IsOk",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNGraph_IsOk__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNGraph_IsOk__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_IsOk'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::IsOk(bool const &) const\n" + " TNGraph::IsOk() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Dump__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + FILE *arg2 = (FILE *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Dump" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraph_Dump" "', argument " "2"" of type '" "FILE *""'"); + } + arg2 = reinterpret_cast< FILE * >(argp2); + ((TNGraph const *)arg1)->Dump(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Dump__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraph_Dump" "', argument " "1"" of type '" "TNGraph const *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + ((TNGraph const *)arg1)->Dump(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_Dump(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraph_Dump",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNGraph_Dump__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNGraph_Dump__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraph_Dump'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraph::Dump(FILE *) const\n" + " TNGraph::Dump() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraph_GetSmallGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraph_GetSmallGraph",0,0,0)) SWIG_fail; + result = TNGraph::GetSmallGraph(); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraph *arg1 = (TNGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraph, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNGraph" "', argument " "1"" of type '" "TNGraph *""'"); + } + arg1 = reinterpret_cast< TNGraph * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNGraph, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNEGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNEGraph *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNEGraph *)new TNEGraph(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TNEGraph *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TNEGraph" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TNEGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TNEGraph *)new TNEGraph((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNEGraph, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEGraph" "', argument " "1"" of type '" "TNEGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEGraph" "', argument " "1"" of type '" "TNEGraph const &""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (TNEGraph *)new TNEGraph((TNEGraph const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TNEGraph *)new TNEGraph(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEGraph(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNEGraph",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNEGraph__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TNEGraph, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TNEGraph__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TNEGraph__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TNEGraph__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNEGraph'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::TNEGraph()\n" + " TNEGraph::TNEGraph(int const &,int const &)\n" + " TNEGraph::TNEGraph(TNEGraph const &)\n" + " TNEGraph::TNEGraph(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Save" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TNEGraph const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TNEGraph > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TNEGraph::New(); + resultobj = SWIG_NewPointerObj((new PNEGraph(static_cast< const PNEGraph& >(result))), SWIGTYPE_p_TPtT_TNEGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TNEGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TNEGraph_New" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TNEGraph::New((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PNEGraph(static_cast< const PNEGraph& >(result))), SWIGTYPE_p_TPtT_TNEGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TNEGraph_New__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_New__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_New'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::New()\n" + " TNEGraph::New(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TNEGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TNEGraph::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PNEGraph(static_cast< const PNEGraph& >(result))), SWIGTYPE_p_TPtT_TNEGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TGraphFlag *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_HasFlag",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_HasFlag" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TGraphFlag, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + arg2 = reinterpret_cast< TGraphFlag * >(argp2); + result = (bool)((TNEGraph const *)arg1)->HasFlag((TGraphFlag const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetNodes" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (int)((TNEGraph const *)arg1)->GetNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_AddNode" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->AddNode(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_AddNode" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (int)(arg1)->AddNode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TNEGraph::TNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_AddNode" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEGraph__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_AddNode" "', argument " "2"" of type '" "TNEGraph::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_AddNode" "', argument " "2"" of type '" "TNEGraph::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEGraph::TNodeI * >(argp2); + result = (int)(arg1)->AddNode((TNEGraph::TNodeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_AddNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_AddNode__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEGraph__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TNEGraph_AddNode__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TNEGraph_AddNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_AddNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::AddNode(int)\n" + " TNEGraph::AddNode()\n" + " TNEGraph::AddNode(TNEGraph::TNodeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_DelNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_DelNode" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_DelNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_DelNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TNEGraph::TNode *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_DelNode" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEGraph__TNode, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_DelNode" "', argument " "2"" of type '" "TNEGraph::TNode const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_DelNode" "', argument " "2"" of type '" "TNEGraph::TNode const &""'"); + } + arg2 = reinterpret_cast< TNEGraph::TNode * >(argp2); + (arg1)->DelNode((TNEGraph::TNode const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_DelNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_DelNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEGraph__TNode, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEGraph_DelNode__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TNEGraph_DelNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_DelNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::DelNode(int const &)\n" + " TNEGraph::DelNode(TNEGraph::TNode const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_IsNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsNode" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_IsNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNEGraph const *)arg1)->IsNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_BegNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_BegNI" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = ((TNEGraph const *)arg1)->BegNI(); + resultobj = SWIG_NewPointerObj((new TNEGraph::TNodeI(static_cast< const TNEGraph::TNodeI& >(result))), SWIGTYPE_p_TNEGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_EndNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_EndNI" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = ((TNEGraph const *)arg1)->EndNI(); + resultobj = SWIG_NewPointerObj((new TNEGraph::TNodeI(static_cast< const TNEGraph::TNodeI& >(result))), SWIGTYPE_p_TNEGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TNEGraph::TNodeI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_GetNI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetNI" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_GetNI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TNEGraph const *)arg1)->GetNI((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEGraph::TNodeI(static_cast< const TNEGraph::TNodeI& >(result))), SWIGTYPE_p_TNEGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetMxNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetMxNId" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (int)((TNEGraph const *)arg1)->GetMxNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetEdges" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (int)((TNEGraph const *)arg1)->GetEdges(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_AddEdge" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNEGraph_AddEdge" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + result = (int)(arg1)->AddEdge((int const &)*arg2,(int const &)*arg3,arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_AddEdge" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TNEGraph::TEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_AddEdge" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEGraph__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_AddEdge" "', argument " "2"" of type '" "TNEGraph::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_AddEdge" "', argument " "2"" of type '" "TNEGraph::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEGraph::TEdgeI * >(argp2); + result = (int)(arg1)->AddEdge((TNEGraph::TEdgeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_AddEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_AddEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEGraph_AddEdge__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEGraph_AddEdge__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEGraph_AddEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_AddEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::AddEdge(int const &,int const &,int)\n" + " TNEGraph::AddEdge(int const &,int const &)\n" + " TNEGraph::AddEdge(TNEGraph::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_DelEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_DelEdge" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelEdge((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_DelEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_DelEdge" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNEGraph_DelEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_DelEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_DelEdge" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_DelEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_DelEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEGraph_DelEdge__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEGraph_DelEdge__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEGraph_DelEdge__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_DelEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::DelEdge(int const &)\n" + " TNEGraph::DelEdge(int const &,int const &,bool const &)\n" + " TNEGraph::DelEdge(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsEdge" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNEGraph const *)arg1)->IsEdge((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsEdge" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNEGraph_IsEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (bool)((TNEGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsEdge" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (bool)((TNEGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsEdge__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + bool *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsEdge" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEGraph_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TNEGraph_IsEdge" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + result = (bool)((TNEGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,*arg4,(bool const &)*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsEdge__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsEdge" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEGraph_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + result = (bool)((TNEGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_IsEdge",0,5,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEGraph_IsEdge__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEGraph_IsEdge__SWIG_2(self, argc, argv); + } + if (argc == 4) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TNEGraph_IsEdge__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 4) { + return _wrap_TNEGraph_IsEdge__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TNEGraph_IsEdge__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_IsEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::IsEdge(int const &) const\n" + " TNEGraph::IsEdge(int const &,int const &,bool const &) const\n" + " TNEGraph::IsEdge(int const &,int const &) const\n" + " TNEGraph::IsEdge(int const &,int const &,int &,bool const &) const\n" + " TNEGraph::IsEdge(int const &,int const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetEId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_GetEId",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetEId" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_GetEId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_GetEId" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TNEGraph const *)arg1)->GetEId((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_BegEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_BegEI" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = ((TNEGraph const *)arg1)->BegEI(); + resultobj = SWIG_NewPointerObj((new TNEGraph::TEdgeI(static_cast< const TNEGraph::TEdgeI& >(result))), SWIGTYPE_p_TNEGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_EndEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_EndEI" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = ((TNEGraph const *)arg1)->EndEI(); + resultobj = SWIG_NewPointerObj((new TNEGraph::TEdgeI(static_cast< const TNEGraph::TEdgeI& >(result))), SWIGTYPE_p_TNEGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TNEGraph::TEdgeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetEI" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_GetEI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TNEGraph const *)arg1)->GetEI((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEGraph::TEdgeI(static_cast< const TNEGraph::TEdgeI& >(result))), SWIGTYPE_p_TNEGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + TNEGraph::TEdgeI result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetEI" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_GetEI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_GetEI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEGraph const *)arg1)->GetEI((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEGraph::TEdgeI(static_cast< const TNEGraph::TEdgeI& >(result))), SWIGTYPE_p_TNEGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_GetEI",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEGraph_GetEI__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEGraph_GetEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_GetEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::GetEI(int const &) const\n" + " TNEGraph::GetEI(int const &,int const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndNId" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndNId" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (int)(arg1)->GetRndNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_GetRndNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_GetRndNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_GetRndNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_GetRndNId'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::GetRndNId(TRnd &)\n" + " TNEGraph::GetRndNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEGraph::TNodeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndNI" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (arg1)->GetRndNI(*arg2); + resultobj = SWIG_NewPointerObj((new TNEGraph::TNodeI(static_cast< const TNEGraph::TNodeI& >(result))), SWIGTYPE_p_TNEGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEGraph::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndNI" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (arg1)->GetRndNI(); + resultobj = SWIG_NewPointerObj((new TNEGraph::TNodeI(static_cast< const TNEGraph::TNodeI& >(result))), SWIGTYPE_p_TNEGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_GetRndNI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_GetRndNI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_GetRndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_GetRndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::GetRndNI(TRnd &)\n" + " TNEGraph::GetRndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndEId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndEId" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_GetRndEId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_GetRndEId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndEId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndEId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndEId" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (int)(arg1)->GetRndEId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndEId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_GetRndEId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_GetRndEId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_GetRndEId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_GetRndEId'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::GetRndEId(TRnd &)\n" + " TNEGraph::GetRndEId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEGraph::TEdgeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndEI" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_GetRndEI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_GetRndEI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (arg1)->GetRndEI(*arg2); + resultobj = SWIG_NewPointerObj((new TNEGraph::TEdgeI(static_cast< const TNEGraph::TEdgeI& >(result))), SWIGTYPE_p_TNEGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEGraph::TEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetRndEI" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (arg1)->GetRndEI(); + resultobj = SWIG_NewPointerObj((new TNEGraph::TEdgeI(static_cast< const TNEGraph::TEdgeI& >(result))), SWIGTYPE_p_TNEGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetRndEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_GetRndEI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_GetRndEI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_GetRndEI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_GetRndEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::GetRndEI(TRnd &)\n" + " TNEGraph::GetRndEI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_GetNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetNIdV" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TNEGraph const *)arg1)->GetNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_GetEIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_GetEIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_GetEIdV" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_GetEIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEGraph_GetEIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TNEGraph const *)arg1)->GetEIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Empty" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (bool)((TNEGraph const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Clr" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEGraph_Reserve",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Reserve" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEGraph_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Defrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Defrag" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_Defrag" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Defrag((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Defrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Defrag" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + (arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Defrag(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_Defrag",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_Defrag__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_Defrag__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_Defrag'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::Defrag(bool const &)\n" + " TNEGraph::Defrag()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsOk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsOk" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEGraph_IsOk" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TNEGraph const *)arg1)->IsOk((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsOk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_IsOk" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + result = (bool)((TNEGraph const *)arg1)->IsOk(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_IsOk(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_IsOk",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_IsOk__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_IsOk__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_IsOk'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::IsOk(bool const &) const\n" + " TNEGraph::IsOk() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Dump__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + FILE *arg2 = (FILE *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Dump" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEGraph_Dump" "', argument " "2"" of type '" "FILE *""'"); + } + arg2 = reinterpret_cast< FILE * >(argp2); + ((TNEGraph const *)arg1)->Dump(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Dump__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEGraph_Dump" "', argument " "1"" of type '" "TNEGraph const *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + ((TNEGraph const *)arg1)->Dump(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEGraph_Dump(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEGraph_Dump",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEGraph_Dump__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEGraph_Dump__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEGraph_Dump'.\n" + " Possible C/C++ prototypes are:\n" + " TNEGraph::Dump(FILE *) const\n" + " TNEGraph::Dump() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TNEGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEGraph *arg1 = (TNEGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEGraph, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNEGraph" "', argument " "1"" of type '" "TNEGraph *""'"); + } + arg1 = reinterpret_cast< TNEGraph * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNEGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNEGraph, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNEGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TBPGraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TBPGraph *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TBPGraph *)new TBPGraph(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBPGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBPGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TBPGraph *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TBPGraph" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TBPGraph" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TBPGraph *)new TBPGraph((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBPGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBPGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TBPGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TBPGraph, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TBPGraph" "', argument " "1"" of type '" "TBPGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TBPGraph" "', argument " "1"" of type '" "TBPGraph const &""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (TBPGraph *)new TBPGraph((TBPGraph const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBPGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBPGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TBPGraph *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TBPGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TBPGraph" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TBPGraph *)new TBPGraph(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBPGraph, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBPGraph(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TBPGraph",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TBPGraph__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TBPGraph, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TBPGraph__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TBPGraph__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TBPGraph__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TBPGraph'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::TBPGraph()\n" + " TBPGraph::TBPGraph(int const &,int const &)\n" + " TBPGraph::TBPGraph(TBPGraph const &)\n" + " TBPGraph::TBPGraph(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Save" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TBPGraph const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TBPGraph > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TBPGraph::New(); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TBPGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TBPGraph_New" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TBPGraph::New((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TBPGraph_New__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_New__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_New'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::New()\n" + " TBPGraph::New(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TBPGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TBPGraph::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetNodes" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)((TBPGraph const *)arg1)->GetNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetLNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetLNodes" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)((TBPGraph const *)arg1)->GetLNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRNodes" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)((TBPGraph const *)arg1)->GetRNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int arg2 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_AddNode" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBPGraph_AddNode" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddNode(arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_AddNode" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_AddNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->AddNode(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_AddNode" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)(arg1)->AddNode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddNode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TBPGraph::TNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_AddNode" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TBPGraph__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_AddNode" "', argument " "2"" of type '" "TBPGraph::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_AddNode" "', argument " "2"" of type '" "TBPGraph::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TBPGraph::TNodeI * >(argp2); + result = (int)(arg1)->AddNode((TBPGraph::TNodeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_AddNode",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_AddNode__SWIG_2(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TBPGraph__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TBPGraph_AddNode__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TBPGraph_AddNode__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TBPGraph_AddNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_AddNode'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::AddNode(int,bool const &)\n" + " TBPGraph::AddNode(int)\n" + " TBPGraph::AddNode()\n" + " TBPGraph::AddNode(TBPGraph::TNodeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_DelNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_DelNode" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_DelNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_DelNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TBPGraph::TNode *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_DelNode" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TBPGraph__TNode, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_DelNode" "', argument " "2"" of type '" "TBPGraph::TNode const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_DelNode" "', argument " "2"" of type '" "TBPGraph::TNode const &""'"); + } + arg2 = reinterpret_cast< TBPGraph::TNode * >(argp2); + (arg1)->DelNode((TBPGraph::TNode const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_DelNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_DelNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TBPGraph__TNode, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TBPGraph_DelNode__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TBPGraph_DelNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_DelNode'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::DelNode(int const &)\n" + " TBPGraph::DelNode(TBPGraph::TNode const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_IsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_IsNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_IsNode" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_IsNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TBPGraph const *)arg1)->IsNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_IsLNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_IsLNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_IsLNode" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_IsLNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TBPGraph const *)arg1)->IsLNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_IsRNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_IsRNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_IsRNode" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_IsRNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TBPGraph const *)arg1)->IsRNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetMxNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetMxNId" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)((TBPGraph const *)arg1)->GetMxNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_BegNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_BegNI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->BegNI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_EndNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_EndNI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->EndNI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TBPGraph::TNodeI result; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_GetNI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetNI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_GetNI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TBPGraph const *)arg1)->GetNI((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_BegLNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_BegLNI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->BegLNI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_EndLNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_EndLNI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->EndLNI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_BegRNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_BegRNI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->BegRNI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_EndRNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TNodeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_EndRNI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->EndRNI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetEdges" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)((TBPGraph const *)arg1)->GetEdges(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_AddEdge" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBPGraph_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TBPGraph::TEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_AddEdge" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TBPGraph__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_AddEdge" "', argument " "2"" of type '" "TBPGraph::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_AddEdge" "', argument " "2"" of type '" "TBPGraph::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TBPGraph::TEdgeI * >(argp2); + result = (int)(arg1)->AddEdge((TBPGraph::TEdgeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_AddEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_AddEdge",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TBPGraph_AddEdge__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TBPGraph_AddEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_AddEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::AddEdge(int const &,int const &)\n" + " TBPGraph::AddEdge(TBPGraph::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_DelEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_DelEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_DelEdge" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBPGraph_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_IsEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_IsEdge",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_IsEdge" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBPGraph_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (bool)((TBPGraph const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_BegEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_BegEI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->BegEI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TEdgeI(static_cast< const TBPGraph::TEdgeI& >(result))), SWIGTYPE_p_TBPGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_EndEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TBPGraph::TEdgeI result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_EndEI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = ((TBPGraph const *)arg1)->EndEI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TEdgeI(static_cast< const TBPGraph::TEdgeI& >(result))), SWIGTYPE_p_TBPGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TBPGraph::TEdgeI result; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_GetEI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetEI" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_GetEI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBPGraph_GetEI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TBPGraph const *)arg1)->GetEI((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TBPGraph::TEdgeI(static_cast< const TBPGraph::TEdgeI& >(result))), SWIGTYPE_p_TBPGraph__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndNId" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndNId" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)(arg1)->GetRndNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_GetRndNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_GetRndNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_GetRndNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_GetRndNId'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::GetRndNId(TRnd &)\n" + " TBPGraph::GetRndNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndLNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndLNId" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_GetRndLNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_GetRndLNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndLNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndLNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndLNId" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)(arg1)->GetRndLNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndLNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_GetRndLNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_GetRndLNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_GetRndLNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_GetRndLNId'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::GetRndLNId(TRnd &)\n" + " TBPGraph::GetRndLNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndRNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndRNId" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_GetRndRNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_GetRndRNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndRNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndRNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndRNId" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (int)(arg1)->GetRndRNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndRNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_GetRndRNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_GetRndRNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_GetRndRNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_GetRndRNId'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::GetRndRNId(TRnd &)\n" + " TBPGraph::GetRndRNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TBPGraph::TNodeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndNI" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (arg1)->GetRndNI(*arg2); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TBPGraph::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRndNI" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (arg1)->GetRndNI(); + resultobj = SWIG_NewPointerObj((new TBPGraph::TNodeI(static_cast< const TBPGraph::TNodeI& >(result))), SWIGTYPE_p_TBPGraph__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_GetRndNI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_GetRndNI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_GetRndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_GetRndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::GetRndNI(TRnd &)\n" + " TBPGraph::GetRndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_GetNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetNIdV" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TBPGraph const *)arg1)->GetNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetLNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_GetLNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetLNIdV" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_GetLNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_GetLNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TBPGraph const *)arg1)->GetLNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetRNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_GetRNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_GetRNIdV" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_GetRNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBPGraph_GetRNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TBPGraph const *)arg1)->GetRNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Empty" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (bool)((TBPGraph const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Clr" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_Reserve",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Reserve" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBPGraph_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Defrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Defrag" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_Defrag" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Defrag((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Defrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Defrag" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + (arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Defrag(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_Defrag",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_Defrag__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_Defrag__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_Defrag'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::Defrag(bool const &)\n" + " TBPGraph::Defrag()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_IsOk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_IsOk" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBPGraph_IsOk" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TBPGraph const *)arg1)->IsOk((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_IsOk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_IsOk" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + result = (bool)((TBPGraph const *)arg1)->IsOk(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_IsOk(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_IsOk",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_IsOk__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_IsOk__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_IsOk'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::IsOk(bool const &) const\n" + " TBPGraph::IsOk() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Dump__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + FILE *arg2 = (FILE *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Dump" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBPGraph_Dump" "', argument " "2"" of type '" "FILE *""'"); + } + arg2 = reinterpret_cast< FILE * >(argp2); + ((TBPGraph const *)arg1)->Dump(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Dump__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBPGraph_Dump" "', argument " "1"" of type '" "TBPGraph const *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + ((TBPGraph const *)arg1)->Dump(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_Dump(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBPGraph_Dump",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBPGraph_Dump__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBPGraph_Dump__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBPGraph_Dump'.\n" + " Possible C/C++ prototypes are:\n" + " TBPGraph::Dump(FILE *) const\n" + " TBPGraph::Dump() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBPGraph_GetSmallGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TBPGraph > > result; + + if (!SWIG_Python_UnpackTuple(args,"TBPGraph_GetSmallGraph",0,0,0)) SWIG_fail; + result = TBPGraph::GetSmallGraph(); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TBPGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBPGraph *arg1 = (TBPGraph *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBPGraph, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TBPGraph" "', argument " "1"" of type '" "TBPGraph *""'"); + } + arg1 = reinterpret_cast< TBPGraph * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TBPGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TBPGraph, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TBPGraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNGraphMtx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNGraphMtx *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNGraphMtx" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNGraphMtx" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + result = (TNGraphMtx *)new TNGraphMtx((PNGraph const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphMtx, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraphMtx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNGraphMtx *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNGraphMtx, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNGraphMtx" "', argument " "1"" of type '" "TNGraphMtx const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNGraphMtx" "', argument " "1"" of type '" "TNGraphMtx const &""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + result = (TNGraphMtx *)new TNGraphMtx((TNGraphMtx const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphMtx, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraphMtx(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNGraphMtx",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_new_TNGraphMtx__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_new_TNGraphMtx__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNGraphMtx'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraphMtx::TNGraphMtx(PNGraph const &)\n" + " TNGraphMtx::TNGraphMtx(TNGraphMtx const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PGetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = (TNGraphMtx *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphMtx_PGetRows" "', argument " "1"" of type '" "TNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + result = (int)((TNGraphMtx const *)arg1)->PGetRows(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PGetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = (TNGraphMtx *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphMtx_PGetCols" "', argument " "1"" of type '" "TNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + result = (int)((TNGraphMtx const *)arg1)->PGetCols(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PMultiply__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = (TNGraphMtx *) 0 ; + TFltVV *arg2 = 0 ; + int arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphMtx_PMultiply" "', argument " "1"" of type '" "TNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVVecT_TFlt_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltVV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltVV const &""'"); + } + arg2 = reinterpret_cast< TFltVV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraphMtx_PMultiply" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNGraphMtx_PMultiply" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiply" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + ((TNGraphMtx const *)arg1)->PMultiply((TFltVV const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PMultiply__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = (TNGraphMtx *) 0 ; + TFltV *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphMtx_PMultiply" "', argument " "1"" of type '" "TNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltV const &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNGraphMtx_PMultiply" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiply" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + ((TNGraphMtx const *)arg1)->PMultiply((TFltV const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PMultiply(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraphMtx_PMultiply",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNGraphMtx_PMultiply__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNGraphMtx_PMultiply__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraphMtx_PMultiply'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraphMtx::PMultiply(TFltVV const &,int,TFltV &) const\n" + " TNGraphMtx::PMultiply(TFltV const &,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PMultiplyT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = (TNGraphMtx *) 0 ; + TFltVV *arg2 = 0 ; + int arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphMtx_PMultiplyT" "', argument " "1"" of type '" "TNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVVecT_TFlt_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltVV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltVV const &""'"); + } + arg2 = reinterpret_cast< TFltVV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNGraphMtx_PMultiplyT" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNGraphMtx_PMultiplyT" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiplyT" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + ((TNGraphMtx const *)arg1)->PMultiplyT((TFltVV const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PMultiplyT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = (TNGraphMtx *) 0 ; + TFltV *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphMtx_PMultiplyT" "', argument " "1"" of type '" "TNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltV const &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNGraphMtx_PMultiplyT" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphMtx_PMultiplyT" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + ((TNGraphMtx const *)arg1)->PMultiplyT((TFltV const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphMtx_PMultiplyT(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNGraphMtx_PMultiplyT",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNGraphMtx_PMultiplyT__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNGraphMtx_PMultiplyT__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNGraphMtx_PMultiplyT'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraphMtx::PMultiplyT(TFltVV const &,int,TFltV &) const\n" + " TNGraphMtx::PMultiplyT(TFltV const &,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TNGraphMtx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphMtx *arg1 = (TNGraphMtx *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphMtx, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNGraphMtx" "', argument " "1"" of type '" "TNGraphMtx *""'"); + } + arg1 = reinterpret_cast< TNGraphMtx * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNGraphMtx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNGraphMtx, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNGraphMtx_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TUNGraphMtx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUNGraphMtx *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUNGraphMtx" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUNGraphMtx" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + result = (TUNGraphMtx *)new TUNGraphMtx((PUNGraph const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphMtx, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraphMtx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUNGraphMtx *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TUNGraphMtx, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUNGraphMtx" "', argument " "1"" of type '" "TUNGraphMtx const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUNGraphMtx" "', argument " "1"" of type '" "TUNGraphMtx const &""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + result = (TUNGraphMtx *)new TUNGraphMtx((TUNGraphMtx const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphMtx, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraphMtx(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUNGraphMtx",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TUNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_new_TUNGraphMtx__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_new_TUNGraphMtx__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUNGraphMtx'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraphMtx::TUNGraphMtx(PUNGraph const &)\n" + " TUNGraphMtx::TUNGraphMtx(TUNGraphMtx const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PGetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = (TUNGraphMtx *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphMtx_PGetRows" "', argument " "1"" of type '" "TUNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + result = (int)((TUNGraphMtx const *)arg1)->PGetRows(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PGetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = (TUNGraphMtx *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphMtx_PGetCols" "', argument " "1"" of type '" "TUNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + result = (int)((TUNGraphMtx const *)arg1)->PGetCols(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PMultiply__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = (TUNGraphMtx *) 0 ; + TFltVV *arg2 = 0 ; + int arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphMtx_PMultiply" "', argument " "1"" of type '" "TUNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVVecT_TFlt_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltVV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltVV const &""'"); + } + arg2 = reinterpret_cast< TFltVV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraphMtx_PMultiply" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TUNGraphMtx_PMultiply" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiply" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + ((TUNGraphMtx const *)arg1)->PMultiply((TFltVV const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PMultiply__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = (TUNGraphMtx *) 0 ; + TFltV *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphMtx_PMultiply" "', argument " "1"" of type '" "TUNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiply" "', argument " "2"" of type '" "TFltV const &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUNGraphMtx_PMultiply" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiply" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + ((TUNGraphMtx const *)arg1)->PMultiply((TFltV const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PMultiply(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraphMtx_PMultiply",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TUNGraphMtx_PMultiply__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TUNGraphMtx_PMultiply__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraphMtx_PMultiply'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraphMtx::PMultiply(TFltVV const &,int,TFltV &) const\n" + " TUNGraphMtx::PMultiply(TFltV const &,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PMultiplyT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = (TUNGraphMtx *) 0 ; + TFltVV *arg2 = 0 ; + int arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "1"" of type '" "TUNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVVecT_TFlt_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltVV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltVV const &""'"); + } + arg2 = reinterpret_cast< TFltVV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + ((TUNGraphMtx const *)arg1)->PMultiplyT((TFltVV const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PMultiplyT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = (TUNGraphMtx *) 0 ; + TFltV *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphMtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "1"" of type '" "TUNGraphMtx const *""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "2"" of type '" "TFltV const &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphMtx_PMultiplyT" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + ((TUNGraphMtx const *)arg1)->PMultiplyT((TFltV const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphMtx_PMultiplyT(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUNGraphMtx_PMultiplyT",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TUNGraphMtx_PMultiplyT__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TUNGraphMtx_PMultiplyT__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUNGraphMtx_PMultiplyT'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraphMtx::PMultiplyT(TFltVV const &,int,TFltV &) const\n" + " TUNGraphMtx::PMultiplyT(TFltV const &,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TUNGraphMtx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphMtx *arg1 = (TUNGraphMtx *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphMtx, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUNGraphMtx" "', argument " "1"" of type '" "TUNGraphMtx *""'"); + } + arg1 = reinterpret_cast< TUNGraphMtx * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUNGraphMtx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUNGraphMtx, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUNGraphMtx_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GetSngVals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + int *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"GetSngVals",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSngVals" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVals" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetSngVals" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetSngVals" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVals" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + TSnap::GetSngVals((TPt< TNGraph > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSngVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + TFltV *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSngVec" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVec" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSngVec" "', argument " "2"" of type '" "TFltV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVec" "', argument " "2"" of type '" "TFltV &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetSngVec" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVec" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + TSnap::GetSngVec((TPt< TNGraph > const &)*arg1,*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSngVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + int *arg2 = 0 ; + TFltV *arg3 = 0 ; + TVec< TFltV > *arg4 = 0 ; + TVec< TFltV > *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSngVec" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVec" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetSngVec" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetSngVec" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVec" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TVecT_TFlt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetSngVec" "', argument " "4"" of type '" "TVec< TFltV > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVec" "', argument " "4"" of type '" "TVec< TFltV > &""'"); + } + arg4 = reinterpret_cast< TVec< TFltV > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TVecT_TFlt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSngVec" "', argument " "5"" of type '" "TVec< TFltV > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSngVec" "', argument " "5"" of type '" "TVec< TFltV > &""'"); + } + arg5 = reinterpret_cast< TVec< TFltV > * >(argp5); + TSnap::GetSngVec((TPt< TNGraph > const &)*arg1,(int const &)*arg2,*arg3,*arg4,*arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSngVec(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetSngVec",0,5,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_GetSngVec__SWIG_0(self, argc, argv); + } + if (argc == 5) { + return _wrap_GetSngVec__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetSngVec'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetSngVec(PNGraph const &,TFltV &,TFltV &)\n" + " TSnap::GetSngVec(PNGraph const &,int const &,TFltV &,TVec< TFltV > &,TVec< TFltV > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetEigVals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"GetEigVals",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEigVals" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigVals" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetEigVals" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetEigVals" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigVals" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + TSnap::GetEigVals((TPt< TUNGraph > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetEigVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TFltV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEigVec" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigVec" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetEigVec" "', argument " "2"" of type '" "TFltV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigVec" "', argument " "2"" of type '" "TFltV &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + TSnap::GetEigVec((TPt< TUNGraph > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetEigVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int *arg2 = 0 ; + TFltV *arg3 = 0 ; + TVec< TFltV > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEigVec" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigVec" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetEigVec" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetEigVec" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigVec" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TVecT_TFlt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetEigVec" "', argument " "4"" of type '" "TVec< TFltV > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEigVec" "', argument " "4"" of type '" "TVec< TFltV > &""'"); + } + arg4 = reinterpret_cast< TVec< TFltV > * >(argp4); + TSnap::GetEigVec((TPt< TUNGraph > const &)*arg1,(int const &)*arg2,*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetEigVec(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetEigVec",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GetEigVec__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetEigVec__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetEigVec'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetEigVec(PUNGraph const &,TFltV &)\n" + " TSnap::GetEigVec(PUNGraph const &,int const &,TFltV &,TVec< TFltV > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetInvParticipRat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int arg2 ; + int arg3 ; + TFltPrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"GetInvParticipRat",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetInvParticipRat" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInvParticipRat" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetInvParticipRat" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetInvParticipRat" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetInvParticipRat" "', argument " "4"" of type '" "TFltPrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInvParticipRat" "', argument " "4"" of type '" "TFltPrV &""'"); + } + arg4 = reinterpret_cast< TFltPrV * >(argp4); + TSnap::GetInvParticipRat((TPt< TUNGraph > const &)*arg1,arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetInvParticipRatEig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TFlt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetInvParticipRatEig" "', argument " "1"" of type '" "TFltV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInvParticipRatEig" "', argument " "1"" of type '" "TFltV const &""'"); + } + arg1 = reinterpret_cast< TFltV * >(argp1); + result = (double)TSnap::TSnapDetail::GetInvParticipRatEig((TVec< TFlt,int > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LoadDyNet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadDyNet" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoadDyNet" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TSnap::LoadDyNet((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LoadDyNetGraphV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TVec< TPt< TNGraph > > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadDyNetGraphV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoadDyNetGraphV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TSnap::LoadDyNetGraphV((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TVec< PNGraph >(static_cast< const TVec< PNGraph >& >(result))), SWIGTYPE_p_TVecT_TPtT_TNGraph_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GVizDoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr arg2 ; + TGVizLayout *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 ; + TGVizLayout temp3 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"GVizDoLayout",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GVizDoLayout" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GVizDoLayout" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GVizDoLayout" "', argument " "2"" of type '" "TStr""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GVizDoLayout" "', argument " "2"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ecode3 = SWIG_AsVal_int (swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GVizDoLayout" "', argument " "3"" of type '" "TGVizLayout const &""'"); + } else { + temp3 = static_cast< TGVizLayout >(val3); + arg3 = &temp3; + } + TSnap::TSnapDetail::GVizDoLayout((TStr const &)*arg1,arg2,(enum TGVizLayout_ const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GVizGetLayoutStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TGVizLayout *arg1 = 0 ; + int val1 ; + int ecode1 ; + TGVizLayout temp1 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int (swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GVizGetLayoutStr" "', argument " "1"" of type '" "TGVizLayout const &""'"); + } else { + temp1 = static_cast< TGVizLayout >(val1); + arg1 = &temp1; + } + result = TSnap::TSnapDetail::GVizGetLayoutStr((enum TGVizLayout_ const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBigStrPool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSize arg1 ; + uint arg2 ; + size_t val1 ; + int ecode1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + TBigStrPool *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TSize""'"); + } + arg1 = static_cast< TSize >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TBigStrPool" "', argument " "2"" of type '" "uint""'"); + } + arg2 = static_cast< uint >(val2); + result = (TBigStrPool *)new TBigStrPool(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBigStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBigStrPool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSize arg1 ; + size_t val1 ; + int ecode1 = 0 ; + TBigStrPool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TSize""'"); + } + arg1 = static_cast< TSize >(val1); + result = (TBigStrPool *)new TBigStrPool(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBigStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBigStrPool__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TBigStrPool *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TBigStrPool *)new TBigStrPool(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBigStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBigStrPool__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + TBigStrPool *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TBigStrPool" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (TBigStrPool *)new TBigStrPool(*arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBigStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBigStrPool__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TBigStrPool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TBigStrPool *)new TBigStrPool(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBigStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBigStrPool__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TBigStrPool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TBigStrPool, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TBigStrPool const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TBigStrPool" "', argument " "1"" of type '" "TBigStrPool const &""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + result = (TBigStrPool *)new TBigStrPool((TBigStrPool const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBigStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBigStrPool(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TBigStrPool",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TBigStrPool__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TBigStrPool__SWIG_4(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TBigStrPool, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TBigStrPool__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TBigStrPool__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_5; + return _wrap_new_TBigStrPool__SWIG_3(self, argc, argv); + } +check_5: + + if (argc == 2) { + return _wrap_new_TBigStrPool__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TBigStrPool'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::TBigStrPool(TSize,uint)\n" + " TBigStrPool::TBigStrPool(TSize)\n" + " TBigStrPool::TBigStrPool()\n" + " TBigStrPool::TBigStrPool(TSIn &,bool)\n" + " TBigStrPool::TBigStrPool(TSIn &)\n" + " TBigStrPool::TBigStrPool(TBigStrPool const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TBigStrPool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TBigStrPool" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSize arg1 ; + uint arg2 ; + size_t val1 ; + int ecode1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TBigStrPool > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TBigStrPool_New" "', argument " "1"" of type '" "TSize""'"); + } + arg1 = static_cast< TSize >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_New" "', argument " "2"" of type '" "uint""'"); + } + arg2 = static_cast< uint >(val2); + result = TBigStrPool::New(arg1,arg2); + resultobj = SWIG_NewPointerObj((new PBigStrPool(static_cast< const PBigStrPool& >(result))), SWIGTYPE_p_TPtT_TBigStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSize arg1 ; + size_t val1 ; + int ecode1 = 0 ; + SwigValueWrapper< TPt< TBigStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TBigStrPool_New" "', argument " "1"" of type '" "TSize""'"); + } + arg1 = static_cast< TSize >(val1); + result = TBigStrPool::New(arg1); + resultobj = SWIG_NewPointerObj((new PBigStrPool(static_cast< const PBigStrPool& >(result))), SWIGTYPE_p_TPtT_TBigStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_New__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TBigStrPool > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TBigStrPool::New(); + resultobj = SWIG_NewPointerObj((new PBigStrPool(static_cast< const PBigStrPool& >(result))), SWIGTYPE_p_TPtT_TBigStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_New__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TBigStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_New" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBigStrPool_New" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TBigStrPool::New(*arg1); + resultobj = SWIG_NewPointerObj((new PBigStrPool(static_cast< const PBigStrPool& >(result))), SWIGTYPE_p_TPtT_TBigStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_New__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TBigStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBigStrPool_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TBigStrPool::New((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PBigStrPool(static_cast< const PBigStrPool& >(result))), SWIGTYPE_p_TPtT_TBigStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBigStrPool_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TBigStrPool_New__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TBigStrPool_New__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TBigStrPool_New__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_TBigStrPool_New__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBigStrPool_New__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBigStrPool_New'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::New(TSize,uint)\n" + " TBigStrPool::New(TSize)\n" + " TBigStrPool::New()\n" + " TBigStrPool::New(TSIn &)\n" + " TBigStrPool::New(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TBigStrPool > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBigStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_Load" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = TBigStrPool::Load(*arg1,arg2); + resultobj = SWIG_NewPointerObj((new PBigStrPool(static_cast< const PBigStrPool& >(result))), SWIGTYPE_p_TPtT_TBigStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TBigStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBigStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TBigStrPool::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PBigStrPool(static_cast< const PBigStrPool& >(result))), SWIGTYPE_p_TPtT_TBigStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Load(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBigStrPool_Load",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBigStrPool_Load__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBigStrPool_Load__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBigStrPool_Load'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::Load(TSIn &,bool)\n" + " TBigStrPool::Load(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Save" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBigStrPool_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBigStrPool_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TBigStrPool const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Save" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBigStrPool_Save" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBigStrPool_Save" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + (arg1)->Save((TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Save(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBigStrPool_Save",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TSOut, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TBigStrPool_Save__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TBigStrPool_Save__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBigStrPool_Save'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::Save(TSOut &) const\n" + " TBigStrPool::Save(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetStrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetStrs" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + result = (int)((TBigStrPool const *)arg1)->GetStrs(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TSize result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Len" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + result = ((TBigStrPool const *)arg1)->Len(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TSize result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Size" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + result = ((TBigStrPool const *)arg1)->Size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Empty" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + result = (bool)((TBigStrPool const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool___call__" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + result = (char *)((TBigStrPool const *)arg1)->operator ()(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_AddStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + char *arg2 = (char *) 0 ; + uint arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + unsigned int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_AddStr" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBigStrPool_AddStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TBigStrPool_AddStr" "', argument " "3"" of type '" "uint""'"); + } + arg3 = static_cast< uint >(val3); + result = (int)(arg1)->AddStr((char const *)arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_AddStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_AddStr" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBigStrPool_AddStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)(arg1)->AddStr((char const *)arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_AddStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_AddStr" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBigStrPool_AddStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBigStrPool_AddStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddStr((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_AddStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBigStrPool_AddStr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TBigStrPool_AddStr__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TBigStrPool_AddStr__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TBigStrPool_AddStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBigStrPool_AddStr'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::AddStr(char const *,uint)\n" + " TBigStrPool::AddStr(char const *)\n" + " TBigStrPool::AddStr(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetCStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TBigStrPool_GetCStr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetCStr" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_GetCStr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (char *)((TBigStrPool const *)arg1)->GetCStr((int const &)*arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetStrFromOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + TSize *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TSize temp2 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TBigStrPool_GetStrFromOffset",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetStrFromOffset" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_GetStrFromOffset" "', argument " "2"" of type '" "TSize""'"); + } + temp2 = static_cast< TSize >(val2); + arg2 = &temp2; + result = ((TBigStrPool const *)arg1)->GetStrFromOffset((TSize const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetCStrFromOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + TSize *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TSize temp2 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TBigStrPool_GetCStrFromOffset",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetCStrFromOffset" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_GetCStrFromOffset" "', argument " "2"" of type '" "TSize""'"); + } + temp2 = static_cast< TSize >(val2); + arg2 = &temp2; + result = (char *)((TBigStrPool const *)arg1)->GetCStrFromOffset((TSize const &)*arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Clr" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_Clr" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->Clr(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Clr" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBigStrPool_Clr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBigStrPool_Clr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBigStrPool_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBigStrPool_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::Clr(bool)\n" + " TBigStrPool::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_Cmp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + int *arg2 = 0 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TBigStrPool_Cmp",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_Cmp" "', argument " "1"" of type '" "TBigStrPool const *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_Cmp" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TBigStrPool_Cmp" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (int)((TBigStrPool const *)arg1)->Cmp((int const &)*arg2,(char const *)arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetPrimHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetPrimHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TBigStrPool::GetPrimHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetSecHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetSecHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TBigStrPool::GetSecHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetPrimHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetPrimHashCd" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_GetPrimHashCd" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->GetPrimHashCd((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetPrimHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBigStrPool_GetPrimHashCd",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBigStrPool_GetPrimHashCd__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBigStrPool_GetPrimHashCd__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBigStrPool_GetPrimHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::GetPrimHashCd(char const *)\n" + " TBigStrPool::GetPrimHashCd(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetSecHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TBigStrPool *arg1 = (TBigStrPool *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBigStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBigStrPool_GetSecHashCd" "', argument " "1"" of type '" "TBigStrPool *""'"); + } + arg1 = reinterpret_cast< TBigStrPool * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBigStrPool_GetSecHashCd" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->GetSecHashCd((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBigStrPool_GetSecHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBigStrPool_GetSecHashCd",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBigStrPool_GetSecHashCd__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBigStrPool_GetSecHashCd__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBigStrPool_GetSecHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TBigStrPool::GetSecHashCd(char const *)\n" + " TBigStrPool::GetSecHashCd(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *TBigStrPool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TBigStrPool, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TBigStrPool_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TStrHashF_OldGLib_GetPrimHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_OldGLib_GetPrimHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrHashF_OldGLib::GetPrimHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_OldGLib_GetSecHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_OldGLib_GetSecHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrHashF_OldGLib::GetSecHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_OldGLib_GetPrimHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_OldGLib_GetPrimHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrHashF_OldGLib_GetPrimHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)TStrHashF_OldGLib::GetPrimHashCd((TStr const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_OldGLib_GetPrimHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrHashF_OldGLib_GetPrimHashCd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrHashF_OldGLib_GetPrimHashCd__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStrHashF_OldGLib_GetPrimHashCd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrHashF_OldGLib_GetPrimHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrHashF_OldGLib::GetPrimHashCd(char const *)\n" + " TStrHashF_OldGLib::GetPrimHashCd(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_OldGLib_GetSecHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_OldGLib_GetSecHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrHashF_OldGLib_GetSecHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)TStrHashF_OldGLib::GetSecHashCd((TStr const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_OldGLib_GetSecHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrHashF_OldGLib_GetSecHashCd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrHashF_OldGLib_GetSecHashCd__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStrHashF_OldGLib_GetSecHashCd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrHashF_OldGLib_GetSecHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrHashF_OldGLib::GetSecHashCd(char const *)\n" + " TStrHashF_OldGLib::GetSecHashCd(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_TStrHashF_OldGLib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHashF_OldGLib *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TStrHashF_OldGLib",0,0,0)) SWIG_fail; + result = (TStrHashF_OldGLib *)new TStrHashF_OldGLib(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrHashF_OldGLib, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrHashF_OldGLib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHashF_OldGLib *arg1 = (TStrHashF_OldGLib *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrHashF_OldGLib, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrHashF_OldGLib" "', argument " "1"" of type '" "TStrHashF_OldGLib *""'"); + } + arg1 = reinterpret_cast< TStrHashF_OldGLib * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStrHashF_OldGLib_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStrHashF_OldGLib, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrHashF_OldGLib_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TStrHashF_Md5_GetPrimHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_Md5_GetPrimHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrHashF_Md5::GetPrimHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_Md5_GetSecHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_Md5_GetSecHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrHashF_Md5::GetSecHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_Md5_GetPrimHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_Md5_GetPrimHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrHashF_Md5_GetPrimHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)TStrHashF_Md5::GetPrimHashCd((TStr const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_Md5_GetPrimHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrHashF_Md5_GetPrimHashCd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrHashF_Md5_GetPrimHashCd__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStrHashF_Md5_GetPrimHashCd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrHashF_Md5_GetPrimHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrHashF_Md5::GetPrimHashCd(char const *)\n" + " TStrHashF_Md5::GetPrimHashCd(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_Md5_GetSecHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_Md5_GetSecHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrHashF_Md5_GetSecHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)TStrHashF_Md5::GetSecHashCd((TStr const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_Md5_GetSecHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrHashF_Md5_GetSecHashCd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrHashF_Md5_GetSecHashCd__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStrHashF_Md5_GetSecHashCd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrHashF_Md5_GetSecHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrHashF_Md5::GetSecHashCd(char const *)\n" + " TStrHashF_Md5::GetSecHashCd(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_TStrHashF_Md5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHashF_Md5 *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TStrHashF_Md5",0,0,0)) SWIG_fail; + result = (TStrHashF_Md5 *)new TStrHashF_Md5(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrHashF_Md5, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrHashF_Md5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHashF_Md5 *arg1 = (TStrHashF_Md5 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrHashF_Md5, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrHashF_Md5" "', argument " "1"" of type '" "TStrHashF_Md5 *""'"); + } + arg1 = reinterpret_cast< TStrHashF_Md5 * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStrHashF_Md5_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStrHashF_Md5, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrHashF_Md5_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TStrHashF_DJB_GetPrimHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_DJB_GetPrimHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrHashF_DJB::GetPrimHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_DJB_GetSecHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_DJB_GetSecHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrHashF_DJB::GetSecHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_DJB_GetPrimHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_DJB_GetPrimHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrHashF_DJB_GetPrimHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)TStrHashF_DJB::GetPrimHashCd((TStr const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_DJB_GetPrimHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrHashF_DJB_GetPrimHashCd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrHashF_DJB_GetPrimHashCd__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStrHashF_DJB_GetPrimHashCd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrHashF_DJB_GetPrimHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrHashF_DJB::GetPrimHashCd(char const *)\n" + " TStrHashF_DJB::GetPrimHashCd(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_DJB_GetSecHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrHashF_DJB_GetSecHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrHashF_DJB_GetSecHashCd" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)TStrHashF_DJB::GetSecHashCd((TStr const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrHashF_DJB_GetSecHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrHashF_DJB_GetSecHashCd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrHashF_DJB_GetSecHashCd__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStrHashF_DJB_GetSecHashCd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrHashF_DJB_GetSecHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrHashF_DJB::GetSecHashCd(char const *)\n" + " TStrHashF_DJB::GetSecHashCd(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_TStrHashF_DJB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHashF_DJB *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TStrHashF_DJB",0,0,0)) SWIG_fail; + result = (TStrHashF_DJB *)new TStrHashF_DJB(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrHashF_DJB, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrHashF_DJB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHashF_DJB *arg1 = (TStrHashF_DJB *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrHashF_DJB, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrHashF_DJB" "', argument " "1"" of type '" "TStrHashF_DJB *""'"); + } + arg1 = reinterpret_cast< TStrHashF_DJB * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStrHashF_DJB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStrHashF_DJB, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrHashF_DJB_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GenRndBipart__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TRnd *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + SwigValueWrapper< TPt< TBPGraph > > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndBipart" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndBipart" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndBipart" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenRndBipart" "', argument " "4"" of type '" "TRnd &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRndBipart" "', argument " "4"" of type '" "TRnd &""'"); + } + arg4 = reinterpret_cast< TRnd * >(argp4); + result = TSnap::GenRndBipart((int const &)*arg1,(int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndBipart__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TBPGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndBipart" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndBipart" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndBipart" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = TSnap::GenRndBipart((int const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndBipart(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenRndBipart",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_GenRndBipart__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_GenRndBipart__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenRndBipart'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenRndBipart(int const &,int const &,int const &,TRnd &)\n" + " TSnap::GenRndBipart(int const &,int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenRndDegK__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TRnd *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndDegK" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndDegK" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndDegK" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenRndDegK" "', argument " "4"" of type '" "TRnd &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRndDegK" "', argument " "4"" of type '" "TRnd &""'"); + } + arg4 = reinterpret_cast< TRnd * >(argp4); + result = TSnap::GenRndDegK((int const &)*arg1,(int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndDegK__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndDegK" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndDegK" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndDegK" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = TSnap::GenRndDegK((int const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndDegK__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndDegK" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndDegK" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TSnap::GenRndDegK((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndDegK(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenRndDegK",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GenRndDegK__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_GenRndDegK__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_GenRndDegK__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenRndDegK'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenRndDegK(int const &,int const &,int const &,TRnd &)\n" + " TSnap::GenRndDegK(int const &,int const &,int const &)\n" + " TSnap::GenRndDegK(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenRndPowerLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + double *arg2 = 0 ; + bool *arg3 = 0 ; + TRnd *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndPowerLaw" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndPowerLaw" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndPowerLaw" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenRndPowerLaw" "', argument " "4"" of type '" "TRnd &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRndPowerLaw" "', argument " "4"" of type '" "TRnd &""'"); + } + arg4 = reinterpret_cast< TRnd * >(argp4); + result = TSnap::GenRndPowerLaw((int const &)*arg1,(double const &)*arg2,(bool const &)*arg3,*arg4); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndPowerLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + double *arg2 = 0 ; + bool *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndPowerLaw" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndPowerLaw" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndPowerLaw" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = TSnap::GenRndPowerLaw((int const &)*arg1,(double const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndPowerLaw__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + double *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndPowerLaw" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndPowerLaw" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = TSnap::GenRndPowerLaw((int const &)*arg1,(double const &)*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndPowerLaw(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenRndPowerLaw",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GenRndPowerLaw__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_GenRndPowerLaw__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_GenRndPowerLaw__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenRndPowerLaw'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenRndPowerLaw(int const &,double const &,bool const &,TRnd &)\n" + " TSnap::GenRndPowerLaw(int const &,double const &,bool const &)\n" + " TSnap::GenRndPowerLaw(int const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenDegSeq__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntV *arg1 = 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDegSeq" "', argument " "1"" of type '" "TIntV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenDegSeq" "', argument " "1"" of type '" "TIntV const &""'"); + } + arg1 = reinterpret_cast< TIntV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenDegSeq" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenDegSeq" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = TSnap::GenDegSeq((TVec< TInt,int > const &)*arg1,*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenDegSeq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenDegSeq" "', argument " "1"" of type '" "TIntV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenDegSeq" "', argument " "1"" of type '" "TIntV const &""'"); + } + arg1 = reinterpret_cast< TIntV * >(argp1); + result = TSnap::GenDegSeq((TVec< TInt,int > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenDegSeq(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenDegSeq",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_GenDegSeq__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_GenDegSeq__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenDegSeq'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenDegSeq(TIntV const &,TRnd &)\n" + " TSnap::GenDegSeq(TIntV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenPrefAttach__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + TRnd *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenPrefAttach" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenPrefAttach" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenPrefAttach" "', argument " "3"" of type '" "TRnd &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenPrefAttach" "', argument " "3"" of type '" "TRnd &""'"); + } + arg3 = reinterpret_cast< TRnd * >(argp3); + result = TSnap::GenPrefAttach((int const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenPrefAttach__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenPrefAttach" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenPrefAttach" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TSnap::GenPrefAttach((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenPrefAttach(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenPrefAttach",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GenPrefAttach__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_GenPrefAttach__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenPrefAttach'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenPrefAttach(int const &,int const &,TRnd &)\n" + " TSnap::GenPrefAttach(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenGeoPrefAttach__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + double *arg3 = 0 ; + TRnd *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenGeoPrefAttach" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenGeoPrefAttach" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenGeoPrefAttach" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenGeoPrefAttach" "', argument " "4"" of type '" "TRnd &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenGeoPrefAttach" "', argument " "4"" of type '" "TRnd &""'"); + } + arg4 = reinterpret_cast< TRnd * >(argp4); + result = TSnap::GenGeoPrefAttach((int const &)*arg1,(int const &)*arg2,(double const &)*arg3,*arg4); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenGeoPrefAttach__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + double *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenGeoPrefAttach" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenGeoPrefAttach" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenGeoPrefAttach" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = TSnap::GenGeoPrefAttach((int const &)*arg1,(int const &)*arg2,(double const &)*arg3); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenGeoPrefAttach(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenGeoPrefAttach",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_GenGeoPrefAttach__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_GenGeoPrefAttach__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenGeoPrefAttach'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenGeoPrefAttach(int const &,int const &,double const &,TRnd &)\n" + " TSnap::GenGeoPrefAttach(int const &,int const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenSmallWorld__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + double *arg3 = 0 ; + TRnd *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenSmallWorld" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenSmallWorld" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenSmallWorld" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenSmallWorld" "', argument " "4"" of type '" "TRnd &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenSmallWorld" "', argument " "4"" of type '" "TRnd &""'"); + } + arg4 = reinterpret_cast< TRnd * >(argp4); + result = TSnap::GenSmallWorld((int const &)*arg1,(int const &)*arg2,(double const &)*arg3,*arg4); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenSmallWorld__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + double *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenSmallWorld" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenSmallWorld" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenSmallWorld" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = TSnap::GenSmallWorld((int const &)*arg1,(int const &)*arg2,(double const &)*arg3); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenSmallWorld(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenSmallWorld",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_GenSmallWorld__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_GenSmallWorld__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenSmallWorld'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenSmallWorld(int const &,int const &,double const &,TRnd &)\n" + " TSnap::GenSmallWorld(int const &,int const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenConfModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntV *arg1 = 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenConfModel" "', argument " "1"" of type '" "TIntV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenConfModel" "', argument " "1"" of type '" "TIntV const &""'"); + } + arg1 = reinterpret_cast< TIntV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GenConfModel" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenConfModel" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = TSnap::GenConfModel((TVec< TInt,int > const &)*arg1,*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenConfModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenConfModel" "', argument " "1"" of type '" "TIntV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenConfModel" "', argument " "1"" of type '" "TIntV const &""'"); + } + arg1 = reinterpret_cast< TIntV * >(argp1); + result = TSnap::GenConfModel((TVec< TInt,int > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenForestFire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!SWIG_Python_UnpackTuple(args,"GenForestFire",3,3,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenForestFire" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenForestFire" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenForestFire" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = TSnap::GenForestFire((int const &)*arg1,(double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenCopyModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + double *arg2 = 0 ; + TRnd *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenCopyModel" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenCopyModel" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenCopyModel" "', argument " "3"" of type '" "TRnd &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenCopyModel" "', argument " "3"" of type '" "TRnd &""'"); + } + arg3 = reinterpret_cast< TRnd * >(argp3); + result = TSnap::GenCopyModel((int const &)*arg1,(double const &)*arg2,*arg3); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenCopyModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + double *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenCopyModel" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenCopyModel" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = TSnap::GenCopyModel((int const &)*arg1,(double const &)*arg2); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenCopyModel(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenCopyModel",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GenCopyModel__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_GenCopyModel__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenCopyModel'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenCopyModel(int const &,double const &,TRnd &)\n" + " TSnap::GenCopyModel(int const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenRMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + TRnd *arg6 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + double temp5 ; + double val5 ; + int ecode5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRMat" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRMat" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRMat" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GenRMat" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GenRMat" "', argument " "5"" of type '" "double""'"); + } + temp5 = static_cast< double >(val5); + arg5 = &temp5; + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GenRMat" "', argument " "6"" of type '" "TRnd &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRMat" "', argument " "6"" of type '" "TRnd &""'"); + } + arg6 = reinterpret_cast< TRnd * >(argp6); + result = TSnap::GenRMat((int const &)*arg1,(int const &)*arg2,(double const &)*arg3,(double const &)*arg4,(double const &)*arg5,*arg6); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + double temp5 ; + double val5 ; + int ecode5 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRMat" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRMat" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRMat" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GenRMat" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GenRMat" "', argument " "5"" of type '" "double""'"); + } + temp5 = static_cast< double >(val5); + arg5 = &temp5; + result = TSnap::GenRMat((int const &)*arg1,(int const &)*arg2,(double const &)*arg3,(double const &)*arg4,(double const &)*arg5); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRMat(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenRMat",0,6,argv))) SWIG_fail; + --argc; + if (argc == 5) { + return _wrap_GenRMat__SWIG_1(self, argc, argv); + } + if (argc == 6) { + return _wrap_GenRMat__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenRMat'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenRMat(int const &,int const &,double const &,double const &,double const &,TRnd &)\n" + " TSnap::GenRMat(int const &,int const &,double const &,double const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenRMatEpinions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!SWIG_Python_UnpackTuple(args,"GenRMatEpinions",0,0,0)) SWIG_fail; + result = TSnap::GenRMatEpinions(); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int *arg2 = 0 ; + TRnd *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRewire" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenRewire" "', argument " "3"" of type '" "TRnd &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "3"" of type '" "TRnd &""'"); + } + arg3 = reinterpret_cast< TRnd * >(argp3); + result = TSnap::GenRewire((TPt< TUNGraph > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRewire" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TSnap::GenRewire((TPt< TUNGraph > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + result = TSnap::GenRewire((TPt< TUNGraph > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + int *arg2 = 0 ; + TRnd *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRewire" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenRewire" "', argument " "3"" of type '" "TRnd &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "3"" of type '" "TRnd &""'"); + } + arg3 = reinterpret_cast< TRnd * >(argp3); + result = TSnap::GenRewire((TPt< TNGraph > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRewire" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TSnap::GenRewire((TPt< TNGraph > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + result = TSnap::GenRewire((TPt< TNGraph > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PBPGraph *arg1 = 0 ; + int *arg2 = 0 ; + TRnd *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + SwigValueWrapper< TPt< TBPGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TBPGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PBPGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PBPGraph const &""'"); + } + arg1 = reinterpret_cast< PBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRewire" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GenRewire" "', argument " "3"" of type '" "TRnd &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "3"" of type '" "TRnd &""'"); + } + arg3 = reinterpret_cast< TRnd * >(argp3); + result = TSnap::GenRewire((TPt< TBPGraph > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PBPGraph *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TBPGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TBPGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PBPGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PBPGraph const &""'"); + } + arg1 = reinterpret_cast< PBPGraph * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRewire" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TSnap::GenRewire((TPt< TBPGraph > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PBPGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TBPGraph > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TBPGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenRewire" "', argument " "1"" of type '" "PBPGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRewire" "', argument " "1"" of type '" "PBPGraph const &""'"); + } + arg1 = reinterpret_cast< PBPGraph * >(argp1); + result = TSnap::GenRewire((TPt< TBPGraph > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PBPGraph(static_cast< const PBPGraph& >(result))), SWIGTYPE_p_TPtT_TBPGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRewire(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenRewire",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TUNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GenRewire__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_GenRewire__SWIG_5(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_GenRewire__SWIG_8(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TUNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_GenRewire__SWIG_1(self, argc, argv); + } +check_4: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TBPGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_GenRewire__SWIG_7(self, argc, argv); + } +check_5: + + if (argc == 2) { + return _wrap_GenRewire__SWIG_4(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TBPGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_7; + return _wrap_GenRewire__SWIG_6(self, argc, argv); + } +check_7: + + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TUNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_8; + return _wrap_GenRewire__SWIG_0(self, argc, argv); + } +check_8: + + if (argc == 3) { + return _wrap_GenRewire__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenRewire'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenRewire(PUNGraph const &,int const &,TRnd &)\n" + " TSnap::GenRewire(PUNGraph const &,int const &)\n" + " TSnap::GenRewire(PUNGraph const &)\n" + " TSnap::GenRewire(PNGraph const &,int const &,TRnd &)\n" + " TSnap::GenRewire(PNGraph const &,int const &)\n" + " TSnap::GenRewire(PNGraph const &)\n" + " TSnap::GenRewire(PBPGraph const &,int const &,TRnd &)\n" + " TSnap::GenRewire(PBPGraph const &,int const &)\n" + " TSnap::GenRewire(PBPGraph const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenConfModel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GenConfModel" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenConfModel" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + result = TSnap::GenConfModel((TPt< TUNGraph > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenConfModel(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenConfModel",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GenConfModel__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_GenConfModel__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_GenConfModel__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenConfModel'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenConfModel(TIntV const &,TRnd &)\n" + " TSnap::GenConfModel(TIntV const &)\n" + " TSnap::GenConfModel(PUNGraph const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetSubGraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntV *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSubGraph" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetSubGraph" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = TSnap::GetSubGraph((TPt< TUNGraph > const &)*arg1,(TVec< TInt,int > const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSubGraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PUNGraph *arg1 = 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + SwigValueWrapper< TPt< TUNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSubGraph" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "1"" of type '" "PUNGraph const &""'"); + } + arg1 = reinterpret_cast< PUNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + result = TSnap::GetSubGraph((TPt< TUNGraph > const &)*arg1,(TVec< TInt,int > const &)*arg2); + resultobj = SWIG_NewPointerObj((new PUNGraph(static_cast< const PUNGraph& >(result))), SWIGTYPE_p_TPtT_TUNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSubGraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + TIntV *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSubGraph" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetSubGraph" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = TSnap::GetSubGraph((TPt< TNGraph > const &)*arg1,(TVec< TInt,int > const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSubGraph__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PNGraph *arg1 = 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + SwigValueWrapper< TPt< TNGraph > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSubGraph" "', argument " "1"" of type '" "PNGraph const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "1"" of type '" "PNGraph const &""'"); + } + arg1 = reinterpret_cast< PNGraph * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubGraph" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + result = TSnap::GetSubGraph((TPt< TNGraph > const &)*arg1,(TVec< TInt,int > const &)*arg2); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSubGraph(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetSubGraph",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TUNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetSubGraph__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_GetSubGraph__SWIG_4(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_GetSubGraph__SWIG_3(self, argc, argv); + } +check_3: + + if (argc == 3) { + return _wrap_GetSubGraph__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetSubGraph'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetSubGraph(PUNGraph const &,TIntV const &,bool const &)\n" + " TSnap::GetSubGraph(PUNGraph const &,TIntV const &)\n" + " TSnap::GetSubGraph(PNGraph const &,TIntV const &,bool const &)\n" + " TSnap::GetSubGraph(PNGraph const &,TIntV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntPrV *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + arg1 = reinterpret_cast< TIntPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetCdf" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TGUtil::GetCdf((TVec< TPair< TInt,TInt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetCdf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + TGUtil::GetCdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCdf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + TIntFltKdV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetCdf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + arg2 = reinterpret_cast< TIntFltKdV * >(argp2); + TGUtil::GetCdf((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCdf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TVec< TPair< TInt,TInt >,int > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + arg1 = reinterpret_cast< TIntPrV * >(argp1); + result = TGUtil::GetCdf((TVec< TPair< TInt,TInt >,int > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TIntPrV(static_cast< const TIntPrV& >(result))), SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCdf__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TVec< TPair< TFlt,TFlt >,int > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + result = TGUtil::GetCdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TFltPrV(static_cast< const TFltPrV& >(result))), SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCdf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TGUtil_GetCdf",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TGUtil_GetCdf__SWIG_3(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TGUtil_GetCdf__SWIG_4(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TGUtil_GetCdf__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TGUtil_GetCdf__SWIG_0(self, argc, argv); + } +check_4: + + if (argc == 2) { + return _wrap_TGUtil_GetCdf__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TGUtil_GetCdf'.\n" + " Possible C/C++ prototypes are:\n" + " TGUtil::GetCdf(TIntPrV const &,TIntPrV &)\n" + " TGUtil::GetCdf(TFltPrV const &,TFltPrV &)\n" + " TGUtil::GetCdf(TIntFltKdV const &,TIntFltKdV &)\n" + " TGUtil::GetCdf(TIntPrV const &)\n" + " TGUtil::GetCdf(TFltPrV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCCdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntPrV *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + arg1 = reinterpret_cast< TIntPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetCCdf" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TGUtil::GetCCdf((TVec< TPair< TInt,TInt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCCdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetCCdf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + TGUtil::GetCCdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCCdf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + TIntFltKdV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetCCdf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + arg2 = reinterpret_cast< TIntFltKdV * >(argp2); + TGUtil::GetCCdf((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCCdf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TVec< TPair< TInt,TInt >,int > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + arg1 = reinterpret_cast< TIntPrV * >(argp1); + result = TGUtil::GetCCdf((TVec< TPair< TInt,TInt >,int > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TIntPrV(static_cast< const TIntPrV& >(result))), SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCCdf__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TVec< TPair< TFlt,TFlt >,int > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetCCdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + result = TGUtil::GetCCdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TFltPrV(static_cast< const TFltPrV& >(result))), SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetCCdf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TGUtil_GetCCdf",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TGUtil_GetCCdf__SWIG_3(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TGUtil_GetCCdf__SWIG_4(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TGUtil_GetCCdf__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TGUtil_GetCCdf__SWIG_0(self, argc, argv); + } +check_4: + + if (argc == 2) { + return _wrap_TGUtil_GetCCdf__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TGUtil_GetCCdf'.\n" + " Possible C/C++ prototypes are:\n" + " TGUtil::GetCCdf(TIntPrV const &,TIntPrV &)\n" + " TGUtil::GetCCdf(TFltPrV const &,TFltPrV &)\n" + " TGUtil::GetCCdf(TIntFltKdV const &,TIntFltKdV &)\n" + " TGUtil::GetCCdf(TIntPrV const &)\n" + " TGUtil::GetCCdf(TFltPrV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetPdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntPrV *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetPdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetPdf" "', argument " "1"" of type '" "TIntPrV const &""'"); + } + arg1 = reinterpret_cast< TIntPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetPdf" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetPdf" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TGUtil::GetPdf((TVec< TPair< TInt,TInt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetPdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetPdf" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetPdf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetPdf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + TGUtil::GetPdf((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetPdf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + TIntFltKdV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_GetPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetPdf" "', argument " "1"" of type '" "TIntFltKdV const &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_GetPdf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_GetPdf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + arg2 = reinterpret_cast< TIntFltKdV * >(argp2); + TGUtil::GetPdf((TVec< TKeyDat< TInt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_GetPdf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TGUtil_GetPdf",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TGUtil_GetPdf__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TGUtil_GetPdf__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TGUtil_GetPdf__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TGUtil_GetPdf'.\n" + " Possible C/C++ prototypes are:\n" + " TGUtil::GetPdf(TIntPrV const &,TIntPrV &)\n" + " TGUtil::GetPdf(TFltPrV const &,TFltPrV &)\n" + " TGUtil::GetPdf(TIntFltKdV const &,TIntFltKdV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_Normalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_Normalize" "', argument " "1"" of type '" "TFltPrV &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_Normalize" "', argument " "1"" of type '" "TFltPrV &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + TGUtil::Normalize(*arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_Normalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntFltKdV *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_Normalize" "', argument " "1"" of type '" "TIntFltKdV &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_Normalize" "', argument " "1"" of type '" "TIntFltKdV &""'"); + } + arg1 = reinterpret_cast< TIntFltKdV * >(argp1); + TGUtil::Normalize(*arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_Normalize(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TGUtil_Normalize",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TGUtil_Normalize__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TGUtil_Normalize__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TGUtil_Normalize'.\n" + " Possible C/C++ prototypes are:\n" + " TGUtil::Normalize(TFltPrV &)\n" + " TGUtil::Normalize(TIntFltKdV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TGUtil_MakeExpBins" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TGUtil_MakeExpBins" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + TGUtil::MakeExpBins((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,*arg2,(double const &)*arg3,(double const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TGUtil_MakeExpBins" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + TGUtil::MakeExpBins((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltPrV *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltPrV const &""'"); + } + arg1 = reinterpret_cast< TFltPrV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + TGUtil::MakeExpBins((TVec< TPair< TFlt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltKdV *arg1 = 0 ; + TFltKdV *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltKdV const &""'"); + } + arg1 = reinterpret_cast< TFltKdV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltKdV &""'"); + } + arg2 = reinterpret_cast< TFltKdV * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TGUtil_MakeExpBins" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TGUtil_MakeExpBins" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + TGUtil::MakeExpBins((TVec< TKeyDat< TFlt,TFlt >,int > const &)*arg1,*arg2,(double const &)*arg3,(double const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltKdV *arg1 = 0 ; + TFltKdV *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltKdV const &""'"); + } + arg1 = reinterpret_cast< TFltKdV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltKdV &""'"); + } + arg2 = reinterpret_cast< TFltKdV * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TGUtil_MakeExpBins" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + TGUtil::MakeExpBins((TVec< TKeyDat< TFlt,TFlt >,int > const &)*arg1,*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltKdV *arg1 = 0 ; + TFltKdV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltKdV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltKdV const &""'"); + } + arg1 = reinterpret_cast< TFltKdV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltKdV &""'"); + } + arg2 = reinterpret_cast< TFltKdV * >(argp2); + TGUtil::MakeExpBins((TVec< TKeyDat< TFlt,TFlt >,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltV *arg1 = 0 ; + TFltV *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TFlt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltV const &""'"); + } + arg1 = reinterpret_cast< TFltV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltV &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TGUtil_MakeExpBins" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + TGUtil::MakeExpBins((TVec< TFlt,int > const &)*arg1,*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltV *arg1 = 0 ; + TFltV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TFlt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TFltV const &""'"); + } + arg1 = reinterpret_cast< TFltV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TFltV &""'"); + } + arg2 = reinterpret_cast< TFltV * >(argp2); + TGUtil::MakeExpBins((TVec< TFlt,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntV *arg1 = 0 ; + TIntV *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TIntV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TIntV const &""'"); + } + arg1 = reinterpret_cast< TIntV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TGUtil_MakeExpBins" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + TGUtil::MakeExpBins((TVec< TInt,int > const &)*arg1,*arg2,(double const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntV *arg1 = 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TIntV const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "1"" of type '" "TIntV const &""'"); + } + arg1 = reinterpret_cast< TIntV * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TGUtil_MakeExpBins" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + TGUtil::MakeExpBins((TVec< TInt,int > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TGUtil_MakeExpBins(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TGUtil_MakeExpBins",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TGUtil_MakeExpBins__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TGUtil_MakeExpBins__SWIG_5(self, argc, argv); + } +check_2: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TFlt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TFlt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TGUtil_MakeExpBins__SWIG_7(self, argc, argv); + } +check_3: + + if (argc == 2) { + return _wrap_TGUtil_MakeExpBins__SWIG_9(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TFlt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TFlt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_TGUtil_MakeExpBins__SWIG_6(self, argc, argv); + } +check_5: + + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_6; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_6; + return _wrap_TGUtil_MakeExpBins__SWIG_4(self, argc, argv); + } +check_6: + + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_7; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_7; + return _wrap_TGUtil_MakeExpBins__SWIG_8(self, argc, argv); + } +check_7: + + if (argc == 3) { + return _wrap_TGUtil_MakeExpBins__SWIG_1(self, argc, argv); + } + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_9; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_9; + return _wrap_TGUtil_MakeExpBins__SWIG_0(self, argc, argv); + } +check_9: + + if (argc == 4) { + return _wrap_TGUtil_MakeExpBins__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TGUtil_MakeExpBins'.\n" + " Possible C/C++ prototypes are:\n" + " TGUtil::MakeExpBins(TFltPrV const &,TFltPrV &,double const &,double const &)\n" + " TGUtil::MakeExpBins(TFltPrV const &,TFltPrV &,double const &)\n" + " TGUtil::MakeExpBins(TFltPrV const &,TFltPrV &)\n" + " TGUtil::MakeExpBins(TFltKdV const &,TFltKdV &,double const &,double const &)\n" + " TGUtil::MakeExpBins(TFltKdV const &,TFltKdV &,double const &)\n" + " TGUtil::MakeExpBins(TFltKdV const &,TFltKdV &)\n" + " TGUtil::MakeExpBins(TFltV const &,TFltV &,double const &)\n" + " TGUtil::MakeExpBins(TFltV const &,TFltV &)\n" + " TGUtil::MakeExpBins(TIntV const &,TIntV &,double const &)\n" + " TGUtil::MakeExpBins(TIntV const &,TIntV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_TGUtil(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TGUtil *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TGUtil",0,0,0)) SWIG_fail; + result = (TGUtil *)new TGUtil(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TGUtil, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TGUtil(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TGUtil *arg1 = (TGUtil *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TGUtil, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TGUtil" "', argument " "1"" of type '" "TGUtil *""'"); + } + arg1 = reinterpret_cast< TGUtil * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TGUtil_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TGUtil, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TGUtil_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TStrUtil_GetXmlTagVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TXmlLx *arg1 = 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TChA *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetXmlTagVal",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TXmlLx, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetXmlTagVal" "', argument " "1"" of type '" "TXmlLx &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagVal" "', argument " "1"" of type '" "TXmlLx &""'"); + } + arg1 = reinterpret_cast< TXmlLx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetXmlTagVal" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagVal" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (TChA *) &TStrUtil::GetXmlTagVal(*arg1,(TChA const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetXmlTagNmVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TXmlLx *arg1 = 0 ; + TChA *arg2 = 0 ; + TChA *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetXmlTagNmVal",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TXmlLx, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetXmlTagNmVal" "', argument " "1"" of type '" "TXmlLx &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagNmVal" "', argument " "1"" of type '" "TXmlLx &""'"); + } + arg1 = reinterpret_cast< TXmlLx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetXmlTagNmVal" "', argument " "2"" of type '" "TChA &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagNmVal" "', argument " "2"" of type '" "TChA &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrUtil_GetXmlTagNmVal" "', argument " "3"" of type '" "TChA &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagNmVal" "', argument " "3"" of type '" "TChA &""'"); + } + arg3 = reinterpret_cast< TChA * >(argp3); + TStrUtil::GetXmlTagNmVal(*arg1,*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetXmlTagNmVal2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TXmlLx *arg1 = 0 ; + TChA *arg2 = 0 ; + TChA *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetXmlTagNmVal2",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TXmlLx, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetXmlTagNmVal2" "', argument " "1"" of type '" "TXmlLx &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagNmVal2" "', argument " "1"" of type '" "TXmlLx &""'"); + } + arg1 = reinterpret_cast< TXmlLx * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetXmlTagNmVal2" "', argument " "2"" of type '" "TChA &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagNmVal2" "', argument " "2"" of type '" "TChA &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrUtil_GetXmlTagNmVal2" "', argument " "3"" of type '" "TChA &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetXmlTagNmVal2" "', argument " "3"" of type '" "TChA &""'"); + } + arg3 = reinterpret_cast< TChA * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStrUtil_GetXmlTagNmVal2" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (bool)TStrUtil::GetXmlTagNmVal2(*arg1,*arg2,*arg3,(bool const &)*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetDomNm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetDomNm" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetDomNm" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TStrUtil::GetDomNm((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetDomNm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetDomNm2" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetDomNm2" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TStrUtil::GetDomNm2((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetWebsiteNm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetWebsiteNm" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetWebsiteNm" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TStrUtil::GetWebsiteNm((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetNormalizedUrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TChA *arg2 = 0 ; + TChA *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetNormalizedUrl",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetNormalizedUrl" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetNormalizedUrl" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetNormalizedUrl" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetNormalizedUrl" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrUtil_GetNormalizedUrl" "', argument " "3"" of type '" "TChA &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetNormalizedUrl" "', argument " "3"" of type '" "TChA &""'"); + } + arg3 = reinterpret_cast< TChA * >(argp3); + result = (bool)TStrUtil::GetNormalizedUrl((TChA const &)*arg1,(TChA const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_StripEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TChA *arg2 = 0 ; + TChA *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_StripEnd",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_StripEnd" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_StripEnd" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_StripEnd" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_StripEnd" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrUtil_StripEnd" "', argument " "3"" of type '" "TChA &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_StripEnd" "', argument " "3"" of type '" "TChA &""'"); + } + arg3 = reinterpret_cast< TChA * >(argp3); + result = (bool)TStrUtil::StripEnd((TChA const &)*arg1,(TChA const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetShorStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + TChA result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetShorStr" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetShorStr" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrUtil_GetShorStr" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = TStrUtil::GetShorStr((TChA const &)*arg1,arg2); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetShorStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TChA result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetShorStr" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetShorStr" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TStrUtil::GetShorStr((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetShorStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrUtil_GetShorStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrUtil_GetShorStr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrUtil_GetShorStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrUtil_GetShorStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStrUtil::GetShorStr(TChA const &,int const)\n" + " TStrUtil::GetShorStr(TChA const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetCleanStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetCleanStr" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetCleanStr" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TStrUtil::GetCleanStr((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetCleanWrdStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetCleanWrdStr" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetCleanWrdStr" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TStrUtil::GetCleanWrdStr((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_CountWords__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_CountWords" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrUtil::CountWords((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_CountWords__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_CountWords" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_CountWords" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (int)TStrUtil::CountWords((TChA const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_CountWords__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TStrHash< TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_CountWords" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_CountWords" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_CountWords" "', argument " "2"" of type '" "TStrHash< TInt > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_CountWords" "', argument " "2"" of type '" "TStrHash< TInt > const &""'"); + } + arg2 = reinterpret_cast< TStrHash< TInt > * >(argp2); + result = (int)TStrUtil::CountWords((TChA const &)*arg1,(TStrHash< TInt > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_CountWords(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrUtil_CountWords",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrUtil_CountWords__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStrUtil_CountWords__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrUtil_CountWords__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrUtil_CountWords'.\n" + " Possible C/C++ prototypes are:\n" + " TStrUtil::CountWords(char const *)\n" + " TStrUtil::CountWords(TChA const &)\n" + " TStrUtil::CountWords(TChA const &,TStrHash< TInt > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitWords__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TVec< char * > *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_SplitWords" "', argument " "1"" of type '" "TChA &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitWords" "', argument " "1"" of type '" "TChA &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_char_p_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_SplitWords" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitWords" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + arg2 = reinterpret_cast< TVec< char * > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrUtil_SplitWords" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)TStrUtil::SplitWords(*arg1,*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitWords__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TVec< char * > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_SplitWords" "', argument " "1"" of type '" "TChA &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitWords" "', argument " "1"" of type '" "TChA &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_char_p_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_SplitWords" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitWords" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + arg2 = reinterpret_cast< TVec< char * > * >(argp2); + result = (int)TStrUtil::SplitWords(*arg1,*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitWords(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrUtil_SplitWords",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrUtil_SplitWords__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrUtil_SplitWords__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrUtil_SplitWords'.\n" + " Possible C/C++ prototypes are:\n" + " TStrUtil::SplitWords(TChA &,TVec< char * > &,bool const &)\n" + " TStrUtil::SplitWords(TChA &,TVec< char * > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitOnCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TVec< char * > *arg2 = 0 ; + char *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_SplitOnCh" "', argument " "1"" of type '" "TChA &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitOnCh" "', argument " "1"" of type '" "TChA &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_char_p_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_SplitOnCh" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitOnCh" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + arg2 = reinterpret_cast< TVec< char * > * >(argp2); + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrUtil_SplitOnCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStrUtil_SplitOnCh" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)TStrUtil::SplitOnCh(*arg1,*arg2,(char const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitOnCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TVec< char * > *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_SplitOnCh" "', argument " "1"" of type '" "TChA &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitOnCh" "', argument " "1"" of type '" "TChA &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_char_p_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_SplitOnCh" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitOnCh" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + arg2 = reinterpret_cast< TVec< char * > * >(argp2); + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrUtil_SplitOnCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + result = (int)TStrUtil::SplitOnCh(*arg1,*arg2,(char const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitOnCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrUtil_SplitOnCh",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TStrUtil_SplitOnCh__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStrUtil_SplitOnCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrUtil_SplitOnCh'.\n" + " Possible C/C++ prototypes are:\n" + " TStrUtil::SplitOnCh(TChA &,TVec< char * > &,char const &,bool const &)\n" + " TStrUtil::SplitOnCh(TChA &,TVec< char * > &,char const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitLines__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TVec< char * > *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_SplitLines" "', argument " "1"" of type '" "TChA &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitLines" "', argument " "1"" of type '" "TChA &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_char_p_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_SplitLines" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitLines" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + arg2 = reinterpret_cast< TVec< char * > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrUtil_SplitLines" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)TStrUtil::SplitLines(*arg1,*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitLines__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TVec< char * > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_SplitLines" "', argument " "1"" of type '" "TChA &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitLines" "', argument " "1"" of type '" "TChA &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_char_p_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_SplitLines" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitLines" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + arg2 = reinterpret_cast< TVec< char * > * >(argp2); + result = (int)TStrUtil::SplitLines(*arg1,*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitLines(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrUtil_SplitLines",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrUtil_SplitLines__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrUtil_SplitLines__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrUtil_SplitLines'.\n" + " Possible C/C++ prototypes are:\n" + " TStrUtil::SplitLines(TChA &,TVec< char * > &,bool const &)\n" + " TStrUtil::SplitLines(TChA &,TVec< char * > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_SplitSentences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TVec< char * > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_SplitSentences",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_SplitSentences" "', argument " "1"" of type '" "TChA &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitSentences" "', argument " "1"" of type '" "TChA &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_char_p_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_SplitSentences" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_SplitSentences" "', argument " "2"" of type '" "TVec< char * > &""'"); + } + arg2 = reinterpret_cast< TVec< char * > * >(argp2); + result = (int)TStrUtil::SplitSentences(*arg1,*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_RemoveHtmlTags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_RemoveHtmlTags",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_RemoveHtmlTags" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_RemoveHtmlTags" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_RemoveHtmlTags" "', argument " "2"" of type '" "TChA &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_RemoveHtmlTags" "', argument " "2"" of type '" "TChA &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + TStrUtil::RemoveHtmlTags((TChA const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_IsLatinStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_IsLatinStr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_IsLatinStr" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_IsLatinStr" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrUtil_IsLatinStr" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (bool)TStrUtil::IsLatinStr((TChA const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetWIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHash< TInt > *arg1 = 0 ; + char *arg2 = (char *) 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetWIdV",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetWIdV" "', argument " "1"" of type '" "TStrHash< TInt > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetWIdV" "', argument " "1"" of type '" "TStrHash< TInt > const &""'"); + } + arg1 = reinterpret_cast< TStrHash< TInt > * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetWIdV" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrUtil_GetWIdV" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetWIdV" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + TStrUtil::GetWIdV((TStrHash< TInt > const &)*arg1,(char const *)arg2,*arg3); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetAddWIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrHash< TInt > *arg1 = 0 ; + char *arg2 = (char *) 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetAddWIdV",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetAddWIdV" "', argument " "1"" of type '" "TStrHash< TInt > &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetAddWIdV" "', argument " "1"" of type '" "TStrHash< TInt > &""'"); + } + arg1 = reinterpret_cast< TStrHash< TInt > * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetAddWIdV" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrUtil_GetAddWIdV" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetAddWIdV" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + TStrUtil::GetAddWIdV(*arg1,(char const *)arg2,*arg3); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetTmFromStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + TSecTm *arg2 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetTmFromStr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetTmFromStr" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSecTm, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetTmFromStr" "', argument " "2"" of type '" "TSecTm &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetTmFromStr" "', argument " "2"" of type '" "TSecTm &""'"); + } + arg2 = reinterpret_cast< TSecTm * >(argp2); + result = (bool)TStrUtil::GetTmFromStr((char const *)arg1,*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetStdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr arg1 ; + void *argp1 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetStdName" "', argument " "1"" of type '" "TStr""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetStdName" "', argument " "1"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; + } + } + result = TStrUtil::GetStdName(arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrUtil_GetStdNameV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr arg1 ; + TStrV *arg2 = 0 ; + void *argp1 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrUtil_GetStdNameV",2,2,swig_obj)) SWIG_fail; + { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrUtil_GetStdNameV" "', argument " "1"" of type '" "TStr""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetStdNameV" "', argument " "1"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrUtil_GetStdNameV" "', argument " "2"" of type '" "TStrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrUtil_GetStdNameV" "', argument " "2"" of type '" "TStrV &""'"); + } + arg2 = reinterpret_cast< TStrV * >(argp2); + TStrUtil::GetStdNameV(arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrUtil(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrUtil *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"new_TStrUtil",0,0,0)) SWIG_fail; + result = (TStrUtil *)new TStrUtil(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrUtil, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrUtil(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrUtil *arg1 = (TStrUtil *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrUtil, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrUtil" "', argument " "1"" of type '" "TStrUtil *""'"); + } + arg1 = reinterpret_cast< TStrUtil * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStrUtil_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStrUtil, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrUtil_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN int Swig_var_TRnd_RndSeed_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TRnd_RndSeed is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TRnd_RndSeed_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TRnd::RndSeed)); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_new_TRnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TRnd *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TRnd" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TRnd" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TRnd *)new TRnd((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRnd, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TRnd *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TRnd" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TRnd *)new TRnd((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRnd, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRnd__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TRnd *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TRnd *)new TRnd(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRnd, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRnd__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TRnd *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TRnd" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TRnd" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TRnd *)new TRnd(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRnd, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRnd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TRnd",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TRnd__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TRnd__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TRnd__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TRnd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TRnd'.\n" + " Possible C/C++ prototypes are:\n" + " TRnd::TRnd(int const &,int const &)\n" + " TRnd::TRnd(int const &)\n" + " TRnd::TRnd()\n" + " TRnd::TRnd(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRnd_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_Save" "', argument " "1"" of type '" "TRnd const *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRnd_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TRnd const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_LoadXml" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRnd_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TRnd_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_SaveXml" "', argument " "1"" of type '" "TRnd const *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRnd_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TRnd_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TRnd const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd___eq__" "', argument " "1"" of type '" "TRnd const *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRnd___eq__" "', argument " "2"" of type '" "TRnd const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd___eq__" "', argument " "2"" of type '" "TRnd const &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (bool)((TRnd const *)arg1)->operator ==((TRnd const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (double)(arg1)->GetUniDev(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevInt" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetUniDevInt" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)(arg1)->GetUniDevInt((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevInt" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (int)(arg1)->GetUniDevInt(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevInt" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetUniDevInt" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TRnd_GetUniDevInt" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->GetUniDevInt((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TRnd_GetUniDevInt",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TRnd_GetUniDevInt__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TRnd_GetUniDevInt__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TRnd_GetUniDevInt__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TRnd_GetUniDevInt'.\n" + " Possible C/C++ prototypes are:\n" + " TRnd::GetUniDevInt(int const &)\n" + " TRnd::GetUniDevInt()\n" + " TRnd::GetUniDevInt(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevUInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + uint result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevUInt" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetUniDevUInt" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (uint)(arg1)->GetUniDevUInt((uint const &)*arg2); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevUInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevUInt" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (uint)(arg1)->GetUniDevUInt(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevUInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TRnd_GetUniDevUInt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TRnd_GetUniDevUInt__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TRnd_GetUniDevUInt__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TRnd_GetUniDevUInt'.\n" + " Possible C/C++ prototypes are:\n" + " TRnd::GetUniDevUInt(uint const &)\n" + " TRnd::GetUniDevUInt()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 temp2 ; + long long val2 ; + int ecode2 = 0 ; + int64 result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevInt64" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetUniDevInt64" "', argument " "2"" of type '" "int64""'"); + } + temp2 = static_cast< int64 >(val2); + arg2 = &temp2; + result = (int64)(arg1)->GetUniDevInt64((int64 const &)*arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevInt64" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (int64)(arg1)->GetUniDevInt64(); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TRnd_GetUniDevInt64",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TRnd_GetUniDevInt64__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TRnd_GetUniDevInt64__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TRnd_GetUniDevInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TRnd::GetUniDevInt64(int64 const &)\n" + " TRnd::GetUniDevInt64()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevUInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint64 temp2 ; + unsigned long long val2 ; + int ecode2 = 0 ; + uint64 result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevUInt64" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetUniDevUInt64" "', argument " "2"" of type '" "uint64""'"); + } + temp2 = static_cast< uint64 >(val2); + arg2 = &temp2; + result = (uint64)(arg1)->GetUniDevUInt64((uint64 const &)*arg2); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevUInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint64 result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetUniDevUInt64" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (uint64)(arg1)->GetUniDevUInt64(); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevUInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TRnd_GetUniDevUInt64",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TRnd_GetUniDevUInt64__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TRnd_GetUniDevUInt64__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TRnd_GetUniDevUInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TRnd::GetUniDevUInt64(uint64 const &)\n" + " TRnd::GetUniDevUInt64()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetNrmDev__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetNrmDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (double)(arg1)->GetNrmDev(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetNrmDev__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + double temp5 ; + double val5 ; + int ecode5 = 0 ; + double result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetNrmDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetNrmDev" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TRnd_GetNrmDev" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TRnd_GetNrmDev" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TRnd_GetNrmDev" "', argument " "5"" of type '" "double""'"); + } + temp5 = static_cast< double >(val5); + arg5 = &temp5; + result = (double)(arg1)->GetNrmDev((double const &)*arg2,(double const &)*arg3,(double const &)*arg4,(double const &)*arg5); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetNrmDev(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TRnd_GetNrmDev",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TRnd_GetNrmDev__SWIG_0(self, argc, argv); + } + if (argc == 5) { + return _wrap_TRnd_GetNrmDev__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TRnd_GetNrmDev'.\n" + " Possible C/C++ prototypes are:\n" + " TRnd::GetNrmDev()\n" + " TRnd::GetNrmDev(double const &,double const &,double const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetExpDev__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetExpDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (double)(arg1)->GetExpDev(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetExpDev__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetExpDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetExpDev" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)(arg1)->GetExpDev((double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetExpDev(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TRnd_GetExpDev",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TRnd_GetExpDev__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TRnd_GetExpDev__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TRnd_GetExpDev'.\n" + " Possible C/C++ prototypes are:\n" + " TRnd::GetExpDev()\n" + " TRnd::GetExpDev(double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetGammaDev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetGammaDev",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetGammaDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetGammaDev" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)(arg1)->GetGammaDev((int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetPoissonDev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetPoissonDev",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetPoissonDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetPoissonDev" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)(arg1)->GetPoissonDev((double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetBinomialDev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetBinomialDev",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetBinomialDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetBinomialDev" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TRnd_GetBinomialDev" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (double)(arg1)->GetBinomialDev((double const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetGeoDev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetGeoDev",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetGeoDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetGeoDev" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (int)(arg1)->GetGeoDev((double const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetPowerDev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetPowerDev",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetPowerDev" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetPowerDev" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)(arg1)->GetPowerDev((double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetRayleigh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetRayleigh",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetRayleigh" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetRayleigh" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)(arg1)->GetRayleigh((double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetWeibull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetWeibull",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetWeibull" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetWeibull" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TRnd_GetWeibull" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = (double)(arg1)->GetWeibull((double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_PutSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_PutSeed",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_PutSeed" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_PutSeed" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->PutSeed((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_GetSeed" "', argument " "1"" of type '" "TRnd const *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (int)((TRnd const *)arg1)->GetSeed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_Randomize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_Randomize" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + (arg1)->Randomize(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_Move",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_Move" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_Move" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Move((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_Check" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + result = (bool)(arg1)->Check(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetUniDevStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetUniDevStep",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TRnd_GetUniDevStep" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetUniDevStep" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TRnd::GetUniDevStep((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetNrmDevStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetNrmDevStep",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TRnd_GetNrmDevStep" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetNrmDevStep" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TRnd::GetNrmDevStep((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_GetExpDevStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_GetExpDevStep",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TRnd_GetExpDevStep" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRnd_GetExpDevStep" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TRnd::GetExpDevStep((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_LoadTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TILx *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TRnd result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TILx, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_LoadTxt" "', argument " "1"" of type '" "TILx &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd_LoadTxt" "', argument " "1"" of type '" "TILx &""'"); + } + arg1 = reinterpret_cast< TILx * >(argp1); + result = TRnd::LoadTxt(*arg1); + resultobj = SWIG_NewPointerObj((new TRnd(static_cast< const TRnd& >(result))), SWIGTYPE_p_TRnd, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRnd_SaveTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + TOLx *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TRnd_SaveTxt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRnd_SaveTxt" "', argument " "1"" of type '" "TRnd const *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TOLx, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRnd_SaveTxt" "', argument " "2"" of type '" "TOLx &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRnd_SaveTxt" "', argument " "2"" of type '" "TOLx &""'"); + } + arg2 = reinterpret_cast< TOLx * >(argp2); + ((TRnd const *)arg1)->SaveTxt(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TRnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRnd *arg1 = (TRnd *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRnd, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TRnd" "', argument " "1"" of type '" "TRnd *""'"); + } + arg1 = reinterpret_cast< TRnd * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TRnd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TRnd, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TRnd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TMem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TMem" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TMem *)new TMem((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TMem *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TMem *)new TMem(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + SwigValueWrapper< TPt< TMem > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TMem_New" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = TMem::New((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new PMem(static_cast< const PMem& >(result))), SWIGTYPE_p_TPtT_TMem_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TMem > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TMem::New(); + resultobj = SWIG_NewPointerObj((new PMem(static_cast< const PMem& >(result))), SWIGTYPE_p_TPtT_TMem_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMem__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int *arg2 = 0 ; + int res1 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMem" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TMem" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TMem *)new TMem((void const *)arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_New__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int *arg2 = 0 ; + int res1 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TMem > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_New" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TMem::New((void const *)arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PMem(static_cast< const PMem& >(result))), SWIGTYPE_p_TPtT_TMem_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMem__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMem" "', argument " "1"" of type '" "TMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMem" "', argument " "1"" of type '" "TMem const &""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (TMem *)new TMem((TMem const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_New__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TMem > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_New" "', argument " "1"" of type '" "TMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_New" "', argument " "1"" of type '" "TMem const &""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = TMem::New((TMem const &)*arg1); + resultobj = SWIG_NewPointerObj((new PMem(static_cast< const PMem& >(result))), SWIGTYPE_p_TPtT_TMem_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_New__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TMem > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TMem_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_New" "', argument " "1"" of type '" "PMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_New" "', argument " "1"" of type '" "PMem const &""'"); + } + arg1 = reinterpret_cast< PMem * >(argp1); + result = TMem::New((TPt< TMem > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PMem(static_cast< const PMem& >(result))), SWIGTYPE_p_TPtT_TMem_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMem" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMem" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TMem *)new TMem((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_New__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TMem > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TMem::New((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PMem(static_cast< const PMem& >(result))), SWIGTYPE_p_TPtT_TMem_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMem_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TMem_New__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TMem_New__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TMem_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TMem_New__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TMem_New__SWIG_5(self, argc, argv); + } +check_4: + + if (argc == 1) { + return _wrap_TMem_New__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TMem_New__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMem_New'.\n" + " Possible C/C++ prototypes are:\n" + " TMem::New(int const &)\n" + " TMem::New()\n" + " TMem::New(void const *,int const &)\n" + " TMem::New(TMem const &)\n" + " TMem::New(PMem const &)\n" + " TMem::New(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TMem" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMem" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMem" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TMem *)new TMem(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMem(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TMem",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TMem__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TMem__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TMem__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_new_TMem__SWIG_5(self, argc, argv); + } +check_4: + + if (argc == 1) { + return _wrap_new_TMem__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TMem__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TMem'.\n" + " Possible C/C++ prototypes are:\n" + " TMem::TMem(int const &)\n" + " TMem::TMem()\n" + " TMem::TMem(void const *,int const &)\n" + " TMem::TMem(TMem const &)\n" + " TMem::TMem(TStr const &)\n" + " TMem::TMem(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMem_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Save" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TMem const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_SaveXml" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TMem_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TMem const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem___call__" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (char *)((TMem const *)arg1)->operator ()(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem___iadd__" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem___iadd__" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (TMem *) &(arg1)->operator +=((char const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + TMem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem___iadd__" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem___iadd__" "', argument " "2"" of type '" "TMem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem___iadd__" "', argument " "2"" of type '" "TMem const &""'"); + } + arg2 = reinterpret_cast< TMem * >(argp2); + result = (TMem *) &(arg1)->operator +=((TMem const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem___iadd____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem___iadd__" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem___iadd__" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem___iadd__" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (TMem *) &(arg1)->operator +=((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem___iadd____SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + PSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TMem *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem___iadd__" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem___iadd__" "', argument " "2"" of type '" "PSIn const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem___iadd__" "', argument " "2"" of type '" "PSIn const &""'"); + } + arg2 = reinterpret_cast< PSIn * >(argp2); + result = (TMem *) &(arg1)->operator +=((PSIn const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMem, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem___iadd__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMem___iadd__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TMem___iadd____SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TMem___iadd____SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TPtT_TSIn_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TMem___iadd____SWIG_3(self, argc, argv); + } +check_3: + + if (argc == 2) { + return _wrap_TMem___iadd____SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMem___iadd__'.\n" + " Possible C/C++ prototypes are:\n" + " TMem::operator +=(char const &)\n" + " TMem::operator +=(TMem const &)\n" + " TMem::operator +=(TStr const &)\n" + " TMem::operator +=(PSIn const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMem_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_GetMemUsed" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (int)((TMem const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Gen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_Gen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Gen" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Gen((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_GenZeros(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_GenZeros",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_GenZeros" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_GenZeros" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->GenZeros((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Reserve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Reserve" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TMem_Reserve" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Reserve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Reserve" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Reserve((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Reserve(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMem_Reserve",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TMem_Reserve__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TMem_Reserve__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMem_Reserve'.\n" + " Possible C/C++ prototypes are:\n" + " TMem::Reserve(int const &,bool const &)\n" + " TMem::Reserve(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMem_Del(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_Del",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Del" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TMem_Del" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Del((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Clr" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Clr((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Clr" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMem_Clr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TMem_Clr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TMem_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMem_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " TMem::Clr(bool const &)\n" + " TMem::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMem_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Len" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (int)((TMem const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Empty" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (bool)((TMem const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Trunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_Trunc",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Trunc" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_Trunc" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Trunc((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_Push",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Push" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_Push" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + (arg1)->Push((char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_Pop" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (char)(arg1)->Pop(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_DoFitStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TMem_DoFitStr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_DoFitStr" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem_DoFitStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_DoFitStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TMem const *)arg1)->DoFitStr((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_AddBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *arg2 = (void *) 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_AddBf",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_AddBf" "', argument " "1"" of type '" "TMem *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem_AddBf" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TMem_AddBf" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->AddBf((void const *)arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_GetBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_GetBf" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (char *)((TMem const *)arg1)->GetBf(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_GetAsStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + TStr result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_GetAsStr" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TMem_GetAsStr" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = ((TMem const *)arg1)->GetAsStr((char const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_GetAsStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_GetAsStr" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = ((TMem const *)arg1)->GetAsStr(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_GetAsStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMem_GetAsStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TMem_GetAsStr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TMem_GetAsStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMem_GetAsStr'.\n" + " Possible C/C++ prototypes are:\n" + " TMem::GetAsStr(char const &) const\n" + " TMem::GetAsStr() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMem_GetSIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TSIn > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_GetSIn" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = ((TMem const *)arg1)->GetSIn(); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_LoadMem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + TMem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_LoadMem" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_LoadMem" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TMem, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem_LoadMem" "', argument " "2"" of type '" "TMem &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_LoadMem" "', argument " "2"" of type '" "TMem &""'"); + } + arg2 = reinterpret_cast< TMem * >(argp2); + TMem::LoadMem((TPt< TSIn > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_LoadMem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + PMem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_LoadMem" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_LoadMem" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TMem_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem_LoadMem" "', argument " "2"" of type '" "PMem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_LoadMem" "', argument " "2"" of type '" "PMem const &""'"); + } + arg2 = reinterpret_cast< PMem * >(argp2); + TMem::LoadMem((TPt< TSIn > const &)*arg1,(TPt< TMem > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMem_LoadMem(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMem_LoadMem",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TMem_LoadMem__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TMem_LoadMem__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMem_LoadMem'.\n" + " Possible C/C++ prototypes are:\n" + " TMem::LoadMem(PSIn const &,TMem &)\n" + " TMem::LoadMem(PSIn const &,PMem const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMem_SaveMem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMem *arg1 = (TMem *) 0 ; + PSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TMem_SaveMem",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMem_SaveMem" "', argument " "1"" of type '" "TMem const *""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TSOut_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TMem_SaveMem" "', argument " "2"" of type '" "PSOut const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMem_SaveMem" "', argument " "2"" of type '" "PSOut const &""'"); + } + arg2 = reinterpret_cast< PSOut * >(argp2); + ((TMem const *)arg1)->SaveMem((PSOut const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TMem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TMem, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TMem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TMemIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TMemIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMemIn" "', argument " "1"" of type '" "TMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMemIn" "', argument " "1"" of type '" "TMem const &""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TMemIn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TMemIn *)new TMemIn((TMem const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMemIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMemIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TMemIn *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMemIn" "', argument " "1"" of type '" "TMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMemIn" "', argument " "1"" of type '" "TMem const &""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (TMemIn *)new TMemIn((TMem const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMemIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TMemIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TMemIn",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_new_TMemIn__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TMemIn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TMemIn'.\n" + " Possible C/C++ prototypes are:\n" + " TMemIn::TMemIn(TMem const &,int const &)\n" + " TMemIn::TMemIn(TMem const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TMemIn_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMemIn_New" "', argument " "1"" of type '" "TMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMemIn_New" "', argument " "1"" of type '" "TMem const &""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = TMemIn::New((TMem const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMemIn_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TSIn > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TMem_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMemIn_New" "', argument " "1"" of type '" "PMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMemIn_New" "', argument " "1"" of type '" "PMem const &""'"); + } + arg1 = reinterpret_cast< PMem * >(argp1); + result = TMemIn::New((TPt< TMem > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMemIn_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TMemIn_New",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TMemIn_New__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TMemIn_New__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TMemIn_New'.\n" + " Possible C/C++ prototypes are:\n" + " TMemIn::New(TMem const &)\n" + " TMemIn::New(PMem const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TMemIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMemIn *arg1 = (TMemIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMemIn, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TMemIn" "', argument " "1"" of type '" "TMemIn *""'"); + } + arg1 = reinterpret_cast< TMemIn * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TMemIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TMemIn, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TMemIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TMemOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TMemOut *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TMem_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TMemOut" "', argument " "1"" of type '" "PMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TMemOut" "', argument " "1"" of type '" "PMem const &""'"); + } + arg1 = reinterpret_cast< PMem * >(argp1); + result = (TMemOut *)new TMemOut((PMem const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TMemOut, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TMemOut_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TSOut > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TMem_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TMemOut_New" "', argument " "1"" of type '" "PMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TMemOut_New" "', argument " "1"" of type '" "PMem const &""'"); + } + arg1 = reinterpret_cast< PMem * >(argp1); + result = TMemOut::New((TPt< TMem > const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSOut(static_cast< const PSOut& >(result))), SWIGTYPE_p_TPtT_TSOut_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TMemOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TMemOut *arg1 = (TMemOut *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TMemOut, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TMemOut" "', argument " "1"" of type '" "TMemOut *""'"); + } + arg1 = reinterpret_cast< TMemOut * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TMemOut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TMemOut, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TMemOut_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TChA" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TChA *)new TChA((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TChA *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TChA *)new TChA(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChA" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (TChA *)new TChA((char const *)arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int *arg2 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChA" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TChA" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TChA *)new TChA((char const *)arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChA" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChA" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (TChA *)new TChA((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChA" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChA" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TChA *)new TChA((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChA" "', argument " "1"" of type '" "TMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChA" "', argument " "1"" of type '" "TMem const &""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (TChA *)new TChA((TMem const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TChA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TChA" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChA" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChA" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TChA *)new TChA(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChA(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TChA",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TChA__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TChA__SWIG_4(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TChA__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_new_TChA__SWIG_6(self, argc, argv); + } +check_4: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_new_TChA__SWIG_7(self, argc, argv); + } +check_5: + + if (argc == 1) { + int _v = 0; + { + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_6; + return _wrap_new_TChA__SWIG_0(self, argc, argv); + } +check_6: + + if (argc == 1) { + return _wrap_new_TChA__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TChA__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TChA'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::TChA(int const &)\n" + " TChA::TChA()\n" + " TChA::TChA(char const *)\n" + " TChA::TChA(char const *,int const &)\n" + " TChA::TChA(TChA const &)\n" + " TChA::TChA(TStr const &)\n" + " TChA::TChA(TMem const &)\n" + " TChA::TChA(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Load" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TSOut *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Save" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_Save" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ((TChA const *)arg1)->Save(*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Save" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TChA const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Save(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_Save",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TChA_Save__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TChA_Save__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_Save'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::Save(TSOut &,bool const &) const\n" + " TChA::Save(TSOut &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SaveXml" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TChA_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TChA const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___eq__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___eq__" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA___eq__" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (bool)((TChA const *)arg1)->operator ==((TChA const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___eq__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___eq__" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TChA const *)arg1)->operator ==((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___eq____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___eq__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA___eq__" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (bool)((TChA const *)arg1)->operator ==((char const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___eq__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA___eq__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TChA___eq____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_2; + return _wrap_TChA___eq____SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TChA___eq____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TChA___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___ne__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___ne__" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA___ne__" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (bool)((TChA const *)arg1)->operator !=((TChA const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___ne__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___ne__" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TChA const *)arg1)->operator !=((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___ne____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___ne__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA___ne__" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (bool)((TChA const *)arg1)->operator !=((char const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___ne__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA___ne__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TChA___ne____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_2; + return _wrap_TChA___ne____SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TChA___ne____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TChA___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TChA___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___lt__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___lt__" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA___lt__" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (bool)((TChA const *)arg1)->operator <((TChA const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TMem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___iadd__" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___iadd__" "', argument " "2"" of type '" "TMem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA___iadd__" "', argument " "2"" of type '" "TMem const &""'"); + } + arg2 = reinterpret_cast< TMem * >(argp2); + result = (TChA *) &(arg1)->operator +=((TMem const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___iadd__" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___iadd__" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA___iadd__" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (TChA *) &(arg1)->operator +=((TChA const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___iadd____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___iadd__" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___iadd__" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA___iadd__" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (TChA *) &(arg1)->operator +=((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___iadd____SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___iadd__" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA___iadd__" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (TChA *) &(arg1)->operator +=((char const *)arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___iadd____SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + TChA *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___iadd__" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA___iadd__" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (TChA *) &(arg1)->operator +=((char const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___iadd__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA___iadd__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TChA___iadd____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TChA___iadd____SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TChA___iadd____SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_4; + return _wrap_TChA___iadd____SWIG_4(self, argc, argv); + } +check_4: + + if (argc == 2) { + return _wrap_TChA___iadd____SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA___iadd__'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::operator +=(TMem const &)\n" + " TChA::operator +=(TChA const &)\n" + " TChA::operator +=(TStr const &)\n" + " TChA::operator +=(char const *)\n" + " TChA::operator +=(char const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_GetMemUsed" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (int)((TChA const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___call__" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (char *)(arg1)->operator ()(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA___call__" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (char *)((TChA const *)arg1)->operator ()(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA___call__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA___call__",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TChA___call____SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_TChA___call____SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA___call__'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::operator ()()\n" + " TChA::operator ()() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_CStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_CStr" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (char *)(arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_CStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_CStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (char *)((TChA const *)arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_CStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_CStr",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TChA_CStr__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_TChA_CStr__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_CStr'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::CStr()\n" + " TChA::CStr() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Clr" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Len" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (int)((TChA const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Empty" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (bool)((TChA const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Ins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + int *arg2 = 0 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_Ins",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Ins" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_Ins" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TChA_Ins" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + (arg1)->Ins((int const &)*arg2,(char const *)arg3); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Del(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_Del",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Del" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Del((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_DelLastCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_DelLastCh" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + (arg1)->DelLastCh(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_Push",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Push" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_Push" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + (arg1)->Push((char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Pop" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (char)(arg1)->Pop(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Trunc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Trunc" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + (arg1)->Trunc(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Trunc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Trunc" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_Trunc" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Trunc((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Trunc(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_Trunc",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TChA_Trunc__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TChA_Trunc__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_Trunc'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::Trunc()\n" + " TChA::Trunc(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_Reverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Reverse" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + (arg1)->Reverse(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_AddCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_AddCh" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_AddCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_AddCh" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->AddCh((char const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_AddCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_AddCh" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_AddCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + (arg1)->AddCh((char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_AddCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_AddCh",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TChA_AddCh__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TChA_AddCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_AddCh'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::AddCh(char const &,int const &)\n" + " TChA::AddCh(char const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_AddChTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_AddChTo",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_AddChTo" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_AddChTo" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_AddChTo" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->AddChTo((char const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_AddBf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_AddBf",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_AddBf" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_AddBf" "', argument " "2"" of type '" "char *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_AddBf" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->AddBf(arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_PutCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + int *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_PutCh",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_PutCh" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_PutCh" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_PutCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + (arg1)->PutCh((int const &)*arg2,(char const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_GetCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char result; + + if (!SWIG_Python_UnpackTuple(args,"TChA_GetCh",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_GetCh" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_GetCh" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (char)((TChA const *)arg1)->GetCh((int const &)*arg2); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_LastCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_LastCh" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (char)((TChA const *)arg1)->LastCh(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_LastLastCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_LastLastCh" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (char)((TChA const *)arg1)->LastLastCh(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_GetSubStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TChA result; + + if (!SWIG_Python_UnpackTuple(args,"TChA_GetSubStr",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_GetSubStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_GetSubStr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_GetSubStr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TChA const *)arg1)->GetSubStr((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TChA(static_cast< const TChA& >(result))), SWIGTYPE_p_TChA, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_CountCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_CountCh" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_CountCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_CountCh" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TChA const *)arg1)->CountCh((char const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_CountCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_CountCh" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_CountCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (int)((TChA const *)arg1)->CountCh((char const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_CountCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_CountCh",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TChA_CountCh__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TChA_CountCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_CountCh'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::CountCh(char const &,int const &) const\n" + " TChA::CountCh(char const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchCh" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_SearchCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_SearchCh" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TChA const *)arg1)->SearchCh((char const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchCh" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_SearchCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (int)((TChA const *)arg1)->SearchCh((char const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_SearchCh",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TChA_SearchCh__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TChA_SearchCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_SearchCh'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::SearchCh(char const &,int const &) const\n" + " TChA::SearchCh(char const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchChBack__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchChBack" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_SearchChBack" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_SearchChBack" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (int)((TChA const *)arg1)->SearchChBack((char const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchChBack__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchChBack" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_SearchChBack" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (int)((TChA const *)arg1)->SearchChBack((char const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchChBack(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_SearchChBack",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TChA_SearchChBack__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TChA_SearchChBack__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_SearchChBack'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::SearchChBack(char const &,int) const\n" + " TChA::SearchChBack(char const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_SearchStr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TChA const *)arg1)->SearchStr((TChA const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (int)((TChA const *)arg1)->SearchStr((TChA const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_SearchStr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TChA const *)arg1)->SearchStr((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchStr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)((TChA const *)arg1)->SearchStr((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchStr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_SearchStr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TChA const *)arg1)->SearchStr((char const *)arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchStr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SearchStr" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SearchStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)((TChA const *)arg1)->SearchStr((char const *)arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SearchStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_SearchStr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TChA_SearchStr__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TChA_SearchStr__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TChA_SearchStr__SWIG_5(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TChA_SearchStr__SWIG_0(self, argc, argv); + } +check_4: + + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_TChA_SearchStr__SWIG_2(self, argc, argv); + } +check_5: + + if (argc == 3) { + return _wrap_TChA_SearchStr__SWIG_4(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_SearchStr'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::SearchStr(TChA const &,int const &) const\n" + " TChA::SearchStr(TChA const &) const\n" + " TChA::SearchStr(TStr const &,int const &) const\n" + " TChA::SearchStr(TStr const &) const\n" + " TChA::SearchStr(char const *,int const &) const\n" + " TChA::SearchStr(char const *) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsStrIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TChA_IsStrIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsStrIn" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsStrIn" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_IsStrIn" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TChA const *)arg1)->IsStrIn((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsPrefix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsPrefix" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsPrefix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_IsPrefix" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (bool)((TChA const *)arg1)->IsPrefix((char const *)arg2,(int const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsPrefix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsPrefix" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsPrefix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TChA const *)arg1)->IsPrefix((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsPrefix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsPrefix" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsPrefix" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_IsPrefix" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TChA const *)arg1)->IsPrefix((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsPrefix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsPrefix" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsPrefix" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_IsPrefix" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (bool)((TChA const *)arg1)->IsPrefix((TChA const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsPrefix(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_IsPrefix",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TChA_IsPrefix__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TChA_IsPrefix__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TChA_IsPrefix__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TChA_IsPrefix__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_IsPrefix'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::IsPrefix(char const *,int const &) const\n" + " TChA::IsPrefix(char const *) const\n" + " TChA::IsPrefix(TStr const &) const\n" + " TChA::IsPrefix(TChA const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsSuffix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsSuffix" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsSuffix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TChA const *)arg1)->IsSuffix((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsSuffix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsSuffix" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsSuffix" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_IsSuffix" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TChA const *)arg1)->IsSuffix((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsSuffix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsSuffix" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_IsSuffix" "', argument " "2"" of type '" "TChA const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_IsSuffix" "', argument " "2"" of type '" "TChA const &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + result = (bool)((TChA const *)arg1)->IsSuffix((TChA const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsSuffix(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_IsSuffix",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TChA_IsSuffix__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TChA_IsSuffix__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TChA_IsSuffix__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_IsSuffix'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::IsSuffix(char const *) const\n" + " TChA::IsSuffix(TStr const &) const\n" + " TChA::IsSuffix(TChA const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_IsChIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TChA_IsChIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_IsChIn" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_IsChIn" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (bool)((TChA const *)arg1)->IsChIn((char const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_ChangeCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_ChangeCh",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_ChangeCh" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_ChangeCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_ChangeCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + (arg1)->ChangeCh((char const &)*arg2,(char const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_ToUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_ToUc" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (TChA *) &(arg1)->ToUc(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_ToLc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_ToLc" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (TChA *) &(arg1)->ToLc(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_ToTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TChA *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_ToTrunc" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (TChA *) &(arg1)->ToTrunc(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChA, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_CompressWs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_CompressWs" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + (arg1)->CompressWs(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Swap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Swap" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TChA_Swap" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TChA_Swap" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Swap((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_Swap" "', argument " "1"" of type '" "TChA *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_Swap" "', argument " "2"" of type '" "TChA &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_Swap" "', argument " "2"" of type '" "TChA &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + (arg1)->Swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_Swap(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TChA_Swap",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TChA_Swap__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TChA_Swap__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TChA_Swap'.\n" + " Possible C/C++ prototypes are:\n" + " TChA::Swap(int const &,int const &)\n" + " TChA::Swap(TChA &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChA_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_GetPrimHashCd" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (int)((TChA const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_GetSecHashCd" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (int)((TChA const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_LoadTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + TChA *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_LoadTxt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_LoadTxt" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_LoadTxt" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TChA, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_LoadTxt" "', argument " "2"" of type '" "TChA &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_LoadTxt" "', argument " "2"" of type '" "TChA &""'"); + } + arg2 = reinterpret_cast< TChA * >(argp2); + TChA::LoadTxt((TPt< TSIn > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TChA_SaveTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = (TChA *) 0 ; + PSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TChA_SaveTxt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChA, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChA_SaveTxt" "', argument " "1"" of type '" "TChA const *""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TSOut_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TChA_SaveTxt" "', argument " "2"" of type '" "PSOut const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChA_SaveTxt" "', argument " "2"" of type '" "PSOut const &""'"); + } + arg2 = reinterpret_cast< PSOut * >(argp2); + ((TChA const *)arg1)->SaveTxt((PSOut const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TChA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TChA, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TChA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TChAIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TChAIn *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChAIn" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChAIn" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TChAIn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TChAIn *)new TChAIn((TChA const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChAIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChAIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TChAIn *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TChAIn" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TChAIn" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (TChAIn *)new TChAIn((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TChAIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TChAIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TChAIn",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_new_TChAIn__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TChAIn__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TChAIn'.\n" + " Possible C/C++ prototypes are:\n" + " TChAIn::TChAIn(TChA const &,int const &)\n" + " TChAIn::TChAIn(TChA const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TChAIn_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TSIn > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TChAIn_New" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TChAIn_New" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = TChAIn::New((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TChAIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TChAIn *arg1 = (TChAIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TChAIn, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TChAIn" "', argument " "1"" of type '" "TChAIn *""'"); + } + arg1 = reinterpret_cast< TChAIn * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TChAIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TChAIn, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TChAIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TRStr_Bf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TRStr_Bf_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_Bf_set" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRStr_Bf_set" "', argument " "2"" of type '" "char *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + if (arg1->Bf) delete[] arg1->Bf; + if (arg2) { + size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1; + arg1->Bf = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size))); + } else { + arg1->Bf = 0; + } + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_Bf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_Bf_get" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (char *) ((arg1)->Bf); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_Refs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TRStr_Refs_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_Refs_set" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRStr_Refs_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->Refs = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_Refs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_Refs_get" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (int) ((arg1)->Refs); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TRStr *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TRStr *)new TRStr(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TRStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TRStr" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TRStr *)new TRStr((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + TRStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TRStr" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (TRStr *)new TRStr((char const *)arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int *arg2 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TRStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TRStr" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TRStr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TRStr *)new TRStr((char const *)arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + TRStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TRStr" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TRStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (TRStr *)new TRStr((char const *)arg1,(char const *)arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + TRStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TRStr" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (TRStr *)new TRStr((char const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char *arg2 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + TRStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TRStr" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TRStr" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (TRStr *)new TRStr((char const &)*arg1,(char const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TRStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TRStr" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + TRStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TRStr" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TRStr" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TRStr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (TRStr *)new TRStr(*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TRStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TRStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TRStr__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_2; + return _wrap_new_TRStr__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[0], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_3; + return _wrap_new_TRStr__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TRStr__SWIG_2(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_5; + return _wrap_new_TRStr__SWIG_7(self, argc, argv); + } +check_5: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[0], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_6; + { + { + int res = SWIG_AsVal_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_6; + return _wrap_new_TRStr__SWIG_6(self, argc, argv); + } +check_6: + + if (argc == 2) { + int _v = 0; + { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_7; + return _wrap_new_TRStr__SWIG_3(self, argc, argv); + } +check_7: + + if (argc == 2) { + return _wrap_new_TRStr__SWIG_4(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TRStr'.\n" + " Possible C/C++ prototypes are:\n" + " TRStr::TRStr()\n" + " TRStr::TRStr(int const &)\n" + " TRStr::TRStr(char const *)\n" + " TRStr::TRStr(char const *,int const &)\n" + " TRStr::TRStr(char const *,char const *)\n" + " TRStr::TRStr(char const &)\n" + " TRStr::TRStr(char const &,char const &)\n" + " TRStr::TRStr(TSIn &,bool const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRStr_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + TSOut *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TRStr_Save",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_Save" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TRStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TRStr_Save" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ((TRStr const *)arg1)->Save(*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_GetMemUsed" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (int)((TRStr const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_MkRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_MkRef" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + (arg1)->MkRef(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_UnRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_UnRef" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + (arg1)->UnRef(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_CStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_CStr" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (char *)((TRStr const *)arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_CStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_CStr" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (char *)(arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_CStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TRStr_CStr",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TRStr_CStr__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TRStr_CStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TRStr_CStr'.\n" + " Possible C/C++ prototypes are:\n" + " TRStr::CStr() const\n" + " TRStr::CStr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TRStr_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_Empty" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (bool)((TRStr const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_Len" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (int)((TRStr const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_PutCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + int *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TRStr_PutCh",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_PutCh" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRStr_PutCh" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TRStr_PutCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + (arg1)->PutCh((int const &)*arg2,(char const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_GetCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char result; + + if (!SWIG_Python_UnpackTuple(args,"TRStr_GetCh",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_GetCh" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TRStr_GetCh" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (char)((TRStr const *)arg1)->GetCh((int const &)*arg2); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_IsUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_IsUc" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (bool)((TRStr const *)arg1)->IsUc(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_ToUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_ToUc" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + (arg1)->ToUc(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_IsLc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_IsLc" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (bool)((TRStr const *)arg1)->IsLc(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_ToLc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_ToLc" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + (arg1)->ToLc(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_ToCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_ToCap" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + (arg1)->ToCap(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_ConvUsFromYuAscii(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_ConvUsFromYuAscii" "', argument " "1"" of type '" "TRStr *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + (arg1)->ConvUsFromYuAscii(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_CmpI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TRStr_CmpI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_CmpI" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TRStr_CmpI" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)TRStr::CmpI((char const *)arg1,(char const *)arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_GetPrimHashCd" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (int)((TRStr const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *arg1 = (TRStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TRStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TRStr_GetSecHashCd" "', argument " "1"" of type '" "TRStr const *""'"); + } + arg1 = reinterpret_cast< TRStr * >(argp1); + result = (int)((TRStr const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TRStr_GetNullRStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TRStr *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TRStr_GetNullRStr",0,0,0)) SWIG_fail; + result = (TRStr *)TRStr::GetNullRStr(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TRStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TRStr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TRStr, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TRStr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TStr *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TStr *)new TStr(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *)new TStr((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TChA *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TChA, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "TChA const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStr" "', argument " "1"" of type '" "TChA const &""'"); + } + arg1 = reinterpret_cast< TChA * >(argp1); + result = (TStr *)new TStr((TChA const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "TSStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStr" "', argument " "1"" of type '" "TSStr const &""'"); + } + arg1 = reinterpret_cast< TSStr * >(argp1); + result = (TStr *)new TStr((TSStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (TStr *)new TStr((char const *)arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TStr" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (TStr *)new TStr((char const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TMem *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TMem, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "TMem const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStr" "', argument " "1"" of type '" "TMem const &""'"); + } + arg1 = reinterpret_cast< TMem * >(argp1); + result = (TStr *)new TStr((TMem const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStr" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + result = (TStr *)new TStr((PSIn const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStr" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TStr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (TStr *)new TStr(*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStr" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStr" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TStr *)new TStr(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TStr__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TStr__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TChA, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TStr__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TSStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_new_TStr__SWIG_3(self, argc, argv); + } +check_4: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TMem, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_new_TStr__SWIG_6(self, argc, argv); + } +check_5: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TSIn_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_6; + return _wrap_new_TStr__SWIG_7(self, argc, argv); + } +check_6: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_7; + return _wrap_new_TStr__SWIG_9(self, argc, argv); + } +check_7: + + if (argc == 1) { + int _v = 0; + { + { + int res = SWIG_AsVal_char(argv[0], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_8; + return _wrap_new_TStr__SWIG_5(self, argc, argv); + } +check_8: + + if (argc == 1) { + return _wrap_new_TStr__SWIG_4(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TStr__SWIG_8(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::TStr()\n" + " TStr::TStr(TStr const &)\n" + " TStr::TStr(TChA const &)\n" + " TStr::TStr(TSStr const &)\n" + " TStr::TStr(char const *)\n" + " TStr::TStr(char const &)\n" + " TStr::TStr(TMem const &)\n" + " TStr::TStr(PSIn const &)\n" + " TStr::TStr(TSIn &,bool const &)\n" + " TStr::TStr(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TSIn *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Load" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_Load" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + (arg1)->Load(*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Load" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Load(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_Load",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_Load__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_Load__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_Load'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::Load(TSIn &,bool const &)\n" + " TStr::Load(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TSOut *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Save" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_Save" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ((TStr const *)arg1)->Save(*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Save" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TStr const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Save(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_Save",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_Save__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_Save__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_Save'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::Save(TSOut &,bool const &) const\n" + " TStr::Save(TSOut &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_LoadXml" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SaveXml" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TStr const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___iadd__" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr___iadd__" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr___iadd__" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (TStr *) &(arg1)->operator +=((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___iadd__" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr___iadd__" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (TStr *) &(arg1)->operator +=((char const *)arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___iadd__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr___iadd__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStr___iadd____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TStr___iadd____SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr___iadd__'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::operator +=(TStr const &)\n" + " TStr::operator +=(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___eq__" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr___eq__" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr___eq__" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TStr const *)arg1)->operator ==((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___eq__" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr___eq__" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TStr const *)arg1)->operator ==((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___eq__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr___eq__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStr___eq____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TStr___eq____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TStr___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStr___ne__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___ne__" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr___ne__" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TStr const *)arg1)->operator !=((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStr___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___lt__" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr___lt__" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr___lt__" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TStr const *)arg1)->operator <((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetMemUsed" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)((TStr const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___call__" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (char *)(arg1)->operator ()(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___call__" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (char *)((TStr const *)arg1)->operator ()(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_CStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_CStr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (char *)(arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_CStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_CStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (char *)((TStr const *)arg1)->CStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_CStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_CStr",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_CStr__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_TStr_CStr__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_CStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::CStr()\n" + " TStr::CStr() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_PutCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_PutCh",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_PutCh" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_PutCh" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_PutCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + (arg1)->PutCh((int const &)*arg2,(char const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_GetCh",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetCh" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (char)((TStr const *)arg1)->GetCh((int const &)*arg2); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_LastCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_LastCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (char)((TStr const *)arg1)->LastCh(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Clr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Len" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)((TStr const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Empty" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsUc" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsUc(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ToUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ToUc" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *) &(arg1)->ToUc(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetUc" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetUc(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_CmpI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_CmpI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_CmpI" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_CmpI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_CmpI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)((TStr const *)arg1)->CmpI((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_EqI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_EqI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_EqI" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_EqI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_EqI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TStr const *)arg1)->EqI((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsLc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsLc" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsLc(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ToLc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ToLc" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *) &(arg1)->ToLc(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetLc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetLc" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetLc(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ToCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ToCap" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *) &(arg1)->ToCap(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetCap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetCap" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetCap(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ToTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ToTrunc" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *) &(arg1)->ToTrunc(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetTrunc" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetTrunc(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ConvUsFromYuAscii(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ConvUsFromYuAscii" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *) &(arg1)->ConvUsFromYuAscii(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUsFromYuAscii(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetUsFromYuAscii" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetUsFromYuAscii(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ToHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ToHex" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *) &(arg1)->ToHex(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetHex" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetHex(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_FromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_FromHex" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStr *) &(arg1)->FromHex(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFromHex" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetFromHex(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetSubStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetSubStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetSubStr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_GetSubStr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TStr const *)arg1)->GetSubStr((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetSubStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TStr result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetSubStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetSubStr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->GetSubStr((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetSubStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetSubStr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_GetSubStr__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_GetSubStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetSubStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetSubStr(int const &,int const &) const\n" + " TStr::GetSubStr(int const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_InsStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_InsStr",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_InsStr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_InsStr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_InsStr" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_InsStr" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->InsStr((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_DelChAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_DelChAll",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_DelChAll" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_DelChAll" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + (arg1)->DelChAll((char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_DelSubStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_DelSubStr",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_DelSubStr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_DelSubStr" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_DelSubStr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->DelSubStr((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_DelStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_DelStr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_DelStr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_DelStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_DelStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)(arg1)->DelStr((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_LeftOf",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_LeftOf" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_LeftOf" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->LeftOf((char const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_LeftOfLast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_LeftOfLast",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_LeftOfLast" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_LeftOfLast" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->LeftOfLast((char const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_RightOf",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_RightOf" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_RightOf" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->RightOf((char const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_RightOfLast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_RightOfLast",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_RightOfLast" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_RightOfLast" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->RightOfLast((char const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + char *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_SplitOnCh",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnCh" "', argument " "2"" of type '" "TStr &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnCh" "', argument " "2"" of type '" "TStr &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_SplitOnCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStr_SplitOnCh" "', argument " "4"" of type '" "TStr &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnCh" "', argument " "4"" of type '" "TStr &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + ((TStr const *)arg1)->SplitOnCh(*arg2,(char const &)*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnLastCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + char *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_SplitOnLastCh",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnLastCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnLastCh" "', argument " "2"" of type '" "TStr &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnLastCh" "', argument " "2"" of type '" "TStr &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_SplitOnLastCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStr_SplitOnLastCh" "', argument " "4"" of type '" "TStr &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnLastCh" "', argument " "4"" of type '" "TStr &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + ((TStr const *)arg1)->SplitOnLastCh(*arg2,(char const &)*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnAllCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + TStrV *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnAllCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_SplitOnAllCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_SplitOnAllCh" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnAllCh" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_SplitOnAllCh" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + ((TStr const *)arg1)->SplitOnAllCh((char const &)*arg2,*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnAllCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnAllCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_SplitOnAllCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_SplitOnAllCh" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnAllCh" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TStr const *)arg1)->SplitOnAllCh((char const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnAllCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_SplitOnAllCh",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TStr_SplitOnAllCh__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStr_SplitOnAllCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_SplitOnAllCh'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::SplitOnAllCh(char const &,TStrV &,bool const &) const\n" + " TStr::SplitOnAllCh(char const &,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnAllAnyCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStrV *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnAllAnyCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnAllAnyCh" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnAllAnyCh" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_SplitOnAllAnyCh" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnAllAnyCh" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_SplitOnAllAnyCh" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + ((TStr const *)arg1)->SplitOnAllAnyCh((TStr const &)*arg2,*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnAllAnyCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnAllAnyCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnAllAnyCh" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnAllAnyCh" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_SplitOnAllAnyCh" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnAllAnyCh" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TStr const *)arg1)->SplitOnAllAnyCh((TStr const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnAllAnyCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_SplitOnAllAnyCh",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TStr_SplitOnAllAnyCh__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStr_SplitOnAllAnyCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_SplitOnAllAnyCh'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::SplitOnAllAnyCh(TStr const &,TStrV &,bool const &) const\n" + " TStr::SplitOnAllAnyCh(TStr const &,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnWs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_SplitOnWs",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnWs" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnWs" "', argument " "2"" of type '" "TStrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnWs" "', argument " "2"" of type '" "TStrV &""'"); + } + arg2 = reinterpret_cast< TStrV * >(argp2); + ((TStr const *)arg1)->SplitOnWs(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnNonAlNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_SplitOnNonAlNum",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnNonAlNum" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnNonAlNum" "', argument " "2"" of type '" "TStrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnNonAlNum" "', argument " "2"" of type '" "TStrV &""'"); + } + arg2 = reinterpret_cast< TStrV * >(argp2); + ((TStr const *)arg1)->SplitOnNonAlNum(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_SplitOnStr" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnStr" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TStr const *)arg1)->SplitOnStr((TStr const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SplitOnStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SplitOnStr" "', argument " "2"" of type '" "TStr &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnStr" "', argument " "2"" of type '" "TStr &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_SplitOnStr" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnStr" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStr_SplitOnStr" "', argument " "4"" of type '" "TStr &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SplitOnStr" "', argument " "4"" of type '" "TStr &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + ((TStr const *)arg1)->SplitOnStr(*arg2,(TStr const &)*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SplitOnStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_SplitOnStr",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TStr_SplitOnStr__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStr_SplitOnStr__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_SplitOnStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::SplitOnStr(TStr const &,TStrV &) const\n" + " TStr::SplitOnStr(TStr &,TStr const &,TStr &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_Mid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Mid" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_Mid" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_Mid" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TStr const *)arg1)->Mid((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Mid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TStr result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Mid" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_Mid" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->Mid((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Mid(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_Mid",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_Mid__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_Mid__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_Mid'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::Mid(int const &,int const &) const\n" + " TStr::Mid(int const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_Left",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Left" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_Left" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->Left((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_Right",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Right" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_Right" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TStr const *)arg1)->Right((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Slice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_Slice",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Slice" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_Slice" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_Slice" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = ((TStr const *)arg1)->Slice(arg2,arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___call____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr___call__" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr___call__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr___call__" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TStr const *)arg1)->operator ()((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr___call__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr___call__",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr___call____SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_TStr___call____SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr___call____SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr___call__'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::operator ()()\n" + " TStr::operator ()() const\n" + " TStr::operator ()(int const &,int const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_CountCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_CountCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_CountCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_CountCh" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TStr const *)arg1)->CountCh((char const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_CountCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_CountCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_CountCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (int)((TStr const *)arg1)->CountCh((char const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_CountCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_CountCh",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_CountCh__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_CountCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_CountCh'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::CountCh(char const &,int const &) const\n" + " TStr::CountCh(char const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SearchCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_SearchCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_SearchCh" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TStr const *)arg1)->SearchCh((char const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SearchCh" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_SearchCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (int)((TStr const *)arg1)->SearchCh((char const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_SearchCh",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_SearchCh__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_SearchCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_SearchCh'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::SearchCh(char const &,int const &) const\n" + " TStr::SearchCh(char const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchChBack__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SearchChBack" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_SearchChBack" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_SearchChBack" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (int)((TStr const *)arg1)->SearchChBack((char const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchChBack__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SearchChBack" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_SearchChBack" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (int)((TStr const *)arg1)->SearchChBack((char const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchChBack(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_SearchChBack",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_SearchChBack__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_SearchChBack__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_SearchChBack'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::SearchChBack(char const &,int) const\n" + " TStr::SearchChBack(char const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SearchStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_SearchStr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TStr const *)arg1)->SearchStr((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SearchStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SearchStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)((TStr const *)arg1)->SearchStr((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SearchStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_SearchStr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_SearchStr__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_SearchStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_SearchStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::SearchStr(TStr const &,int const &) const\n" + " TStr::SearchStr(TStr const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsChIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_IsChIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsChIn" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsChIn" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (bool)((TStr const *)arg1)->IsChIn((char const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsStrIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_IsStrIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsStrIn" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsStrIn" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsStrIn" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TStr const *)arg1)->IsStrIn((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsPrefix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsPrefix" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsPrefix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TStr const *)arg1)->IsPrefix((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsPrefix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsPrefix" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsPrefix" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsPrefix" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TStr const *)arg1)->IsPrefix((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsPrefix(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsPrefix",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStr_IsPrefix__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TStr_IsPrefix__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsPrefix'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsPrefix(char const *) const\n" + " TStr::IsPrefix(TStr const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsSuffix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsSuffix" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsSuffix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (bool)((TStr const *)arg1)->IsSuffix((char const *)arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsSuffix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsSuffix" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsSuffix" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsSuffix" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TStr const *)arg1)->IsSuffix((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsSuffix(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsSuffix",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStr_IsSuffix__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TStr_IsSuffix__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsSuffix'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsSuffix(char const *) const\n" + " TStr::IsSuffix(TStr const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ChangeCh" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_ChangeCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_ChangeCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_ChangeCh" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)(arg1)->ChangeCh((char const &)*arg2,(char const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ChangeCh" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_ChangeCh" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_ChangeCh" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + result = (int)(arg1)->ChangeCh((char const &)*arg2,(char const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_ChangeCh",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TStr_ChangeCh__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStr_ChangeCh__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_ChangeCh'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::ChangeCh(char const &,char const &,int const &)\n" + " TStr::ChangeCh(char const &,char const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeChAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_ChangeChAll",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ChangeChAll" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_ChangeChAll" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_ChangeChAll" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + result = (int)(arg1)->ChangeChAll((char const &)*arg2,(char const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ChangeStr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_ChangeStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_ChangeStr" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStr" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_ChangeStr" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)(arg1)->ChangeStr((TStr const &)*arg2,(TStr const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ChangeStr" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_ChangeStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_ChangeStr" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStr" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(arg1)->ChangeStr((TStr const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_ChangeStr",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TStr_ChangeStr__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStr_ChangeStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_ChangeStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::ChangeStr(TStr const &,TStr const &,int const &)\n" + " TStr::ChangeStr(TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeStrAll__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ChangeStrAll" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_ChangeStrAll" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStrAll" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_ChangeStrAll" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStrAll" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_ChangeStrAll" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)(arg1)->ChangeStrAll((TStr const &)*arg2,(TStr const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeStrAll__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_ChangeStrAll" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_ChangeStrAll" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStrAll" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_ChangeStrAll" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_ChangeStrAll" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(arg1)->ChangeStrAll((TStr const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_ChangeStrAll(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_ChangeStrAll",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TStr_ChangeStrAll__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStr_ChangeStrAll__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_ChangeStrAll'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::ChangeStrAll(TStr const &,TStr const &,bool const &)\n" + " TStr::ChangeStrAll(TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_Reverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Reverse" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->Reverse(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetPrimHashCd" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)((TStr const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetSecHashCd" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)((TStr const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_IsBool",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsBool" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bool, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsBool" "', argument " "2"" of type '" "bool &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsBool" "', argument " "2"" of type '" "bool &""'"); + } + arg2 = reinterpret_cast< bool * >(argp2); + result = (bool)((TStr const *)arg1)->IsBool(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + int *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsInt" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsInt" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsInt" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsInt" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsInt" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + result = (bool)((TStr const *)arg1)->IsInt((bool const &)*arg2,(int const &)*arg3,(int const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsInt" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsInt" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + result = (bool)((TStr const *)arg1)->IsInt(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsInt(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsInt",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsInt__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsInt__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStr_IsInt__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsInt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsInt(bool const &,int const &,int const &,int &) const\n" + " TStr::IsInt(int &) const\n" + " TStr::IsInt() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)((TStr const *)arg1)->GetInt(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetInt" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TStr const *)arg1)->GetInt((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetInt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetInt__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetInt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetInt() const\n" + " TStr::GetInt(int const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + uint *arg3 = 0 ; + uint *arg4 = 0 ; + uint *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + uint temp3 ; + unsigned int val3 ; + int ecode3 = 0 ; + uint temp4 ; + unsigned int val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsUInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsUInt" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsUInt" "', argument " "3"" of type '" "uint""'"); + } + temp3 = static_cast< uint >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsUInt" "', argument " "4"" of type '" "uint""'"); + } + temp4 = static_cast< uint >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_unsigned_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsUInt" "', argument " "5"" of type '" "uint &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsUInt" "', argument " "5"" of type '" "uint &""'"); + } + arg5 = reinterpret_cast< uint * >(argp5); + result = (bool)((TStr const *)arg1)->IsUInt((bool const &)*arg2,(uint const &)*arg3,(uint const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsUInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsUInt" "', argument " "2"" of type '" "uint &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsUInt" "', argument " "2"" of type '" "uint &""'"); + } + arg2 = reinterpret_cast< uint * >(argp2); + result = (bool)((TStr const *)arg1)->IsUInt(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsUInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsUInt(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsUInt",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsUInt__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsUInt__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStr_IsUInt__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsUInt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsUInt(bool const &,uint const &,uint const &,uint &) const\n" + " TStr::IsUInt(uint &) const\n" + " TStr::IsUInt() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetUInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (uint)((TStr const *)arg1)->GetUInt(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + uint result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetUInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetUInt" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (uint)((TStr const *)arg1)->GetUInt((uint const &)*arg2); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetUInt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetUInt__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetUInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetUInt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetUInt() const\n" + " TStr::GetUInt(uint const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + int64 *arg3 = 0 ; + int64 *arg4 = 0 ; + int64 *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int64 temp3 ; + long long val3 ; + int ecode3 = 0 ; + int64 temp4 ; + long long val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsInt64" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_long_SS_long(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsInt64" "', argument " "3"" of type '" "int64""'"); + } + temp3 = static_cast< int64 >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_long_SS_long(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsInt64" "', argument " "4"" of type '" "int64""'"); + } + temp4 = static_cast< int64 >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsInt64" "', argument " "5"" of type '" "int64 &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsInt64" "', argument " "5"" of type '" "int64 &""'"); + } + arg5 = reinterpret_cast< int64 * >(argp5); + result = (bool)((TStr const *)arg1)->IsInt64((bool const &)*arg2,(int64 const &)*arg3,(int64 const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsInt64" "', argument " "2"" of type '" "int64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsInt64" "', argument " "2"" of type '" "int64 &""'"); + } + arg2 = reinterpret_cast< int64 * >(argp2); + result = (bool)((TStr const *)arg1)->IsInt64(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt64__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsInt64(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsInt64",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsInt64__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsInt64__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStr_IsInt64__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsInt64(bool const &,int64 const &,int64 const &,int64 &) const\n" + " TStr::IsInt64(int64 &) const\n" + " TStr::IsInt64() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int64)((TStr const *)arg1)->GetInt64(); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 temp2 ; + long long val2 ; + int ecode2 = 0 ; + int64 result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetInt64" "', argument " "2"" of type '" "int64""'"); + } + temp2 = static_cast< int64 >(val2); + arg2 = &temp2; + result = (int64)((TStr const *)arg1)->GetInt64((int64 const &)*arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetInt64",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetInt64__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetInt64__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetInt64() const\n" + " TStr::GetInt64(int64 const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + uint64 *arg3 = 0 ; + uint64 *arg4 = 0 ; + uint64 *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + uint64 temp3 ; + unsigned long long val3 ; + int ecode3 = 0 ; + uint64 temp4 ; + unsigned long long val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsUInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsUInt64" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsUInt64" "', argument " "3"" of type '" "uint64""'"); + } + temp3 = static_cast< uint64 >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsUInt64" "', argument " "4"" of type '" "uint64""'"); + } + temp4 = static_cast< uint64 >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_unsigned_long_long, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsUInt64" "', argument " "5"" of type '" "uint64 &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsUInt64" "', argument " "5"" of type '" "uint64 &""'"); + } + arg5 = reinterpret_cast< uint64 * >(argp5); + result = (bool)((TStr const *)arg1)->IsUInt64((bool const &)*arg2,(uint64 const &)*arg3,(uint64 const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsUInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsUInt64" "', argument " "2"" of type '" "uint64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsUInt64" "', argument " "2"" of type '" "uint64 &""'"); + } + arg2 = reinterpret_cast< uint64 * >(argp2); + result = (bool)((TStr const *)arg1)->IsUInt64(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt64__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsUInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsUInt64(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsUInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsUInt64",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsUInt64__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsUInt64__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStr_IsUInt64__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsUInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsUInt64(bool const &,uint64 const &,uint64 const &,uint64 &) const\n" + " TStr::IsUInt64(uint64 &) const\n" + " TStr::IsUInt64() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint64 result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetUInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (uint64)((TStr const *)arg1)->GetUInt64(); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + uint64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint64 temp2 ; + unsigned long long val2 ; + int ecode2 = 0 ; + uint64 result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetUInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetUInt64" "', argument " "2"" of type '" "uint64""'"); + } + temp2 = static_cast< uint64 >(val2); + arg2 = &temp2; + result = (uint64)((TStr const *)arg1)->GetUInt64((uint64 const &)*arg2); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetUInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetUInt64",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetUInt64__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetUInt64__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetUInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetUInt64() const\n" + " TStr::GetUInt64(uint64 const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + int *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsHexInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsHexInt" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsHexInt" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsHexInt" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsHexInt" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsHexInt" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + result = (bool)((TStr const *)arg1)->IsHexInt((bool const &)*arg2,(int const &)*arg3,(int const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsHexInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsHexInt" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsHexInt" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + result = (bool)((TStr const *)arg1)->IsHexInt(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsHexInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsHexInt(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsHexInt",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsHexInt__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsHexInt__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStr_IsHexInt__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsHexInt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsHexInt(bool const &,int const &,int const &,int &) const\n" + " TStr::IsHexInt(int &) const\n" + " TStr::IsHexInt() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetHexInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetHexInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int)((TStr const *)arg1)->GetHexInt(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetHexInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetHexInt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetHexInt" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TStr const *)arg1)->GetHexInt((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetHexInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetHexInt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetHexInt__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetHexInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetHexInt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetHexInt() const\n" + " TStr::GetHexInt(int const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + int64 *arg3 = 0 ; + int64 *arg4 = 0 ; + int64 *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int64 temp3 ; + long long val3 ; + int ecode3 = 0 ; + int64 temp4 ; + long long val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsHexInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsHexInt64" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_long_SS_long(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsHexInt64" "', argument " "3"" of type '" "int64""'"); + } + temp3 = static_cast< int64 >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_long_SS_long(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsHexInt64" "', argument " "4"" of type '" "int64""'"); + } + temp4 = static_cast< int64 >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsHexInt64" "', argument " "5"" of type '" "int64 &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsHexInt64" "', argument " "5"" of type '" "int64 &""'"); + } + arg5 = reinterpret_cast< int64 * >(argp5); + result = (bool)((TStr const *)arg1)->IsHexInt64((bool const &)*arg2,(int64 const &)*arg3,(int64 const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsHexInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsHexInt64" "', argument " "2"" of type '" "int64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsHexInt64" "', argument " "2"" of type '" "int64 &""'"); + } + arg2 = reinterpret_cast< int64 * >(argp2); + result = (bool)((TStr const *)arg1)->IsHexInt64(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt64__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsHexInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsHexInt64(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsHexInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsHexInt64",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsHexInt64__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsHexInt64__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStr_IsHexInt64__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsHexInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsHexInt64(bool const &,int64 const &,int64 const &,int64 &) const\n" + " TStr::IsHexInt64(int64 &) const\n" + " TStr::IsHexInt64() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetHexInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetHexInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (int64)((TStr const *)arg1)->GetHexInt64(); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetHexInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 temp2 ; + long long val2 ; + int ecode2 = 0 ; + int64 result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetHexInt64" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetHexInt64" "', argument " "2"" of type '" "int64""'"); + } + temp2 = static_cast< int64 >(val2); + arg2 = &temp2; + result = (int64)((TStr const *)arg1)->GetHexInt64((int64 const &)*arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetHexInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetHexInt64",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetHexInt64__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetHexInt64__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetHexInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetHexInt64() const\n" + " TStr::GetHexInt64(int64 const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsFlt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + char *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + char temp6 ; + char val6 ; + int ecode6 = 0 ; + bool result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsFlt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsFlt" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsFlt" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsFlt" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsFlt" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsFlt" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); + ecode6 = SWIG_AsVal_char(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TStr_IsFlt" "', argument " "6"" of type '" "char""'"); + } + temp6 = static_cast< char >(val6); + arg6 = &temp6; + result = (bool)((TStr const *)arg1)->IsFlt((bool const &)*arg2,(double const &)*arg3,(double const &)*arg4,*arg5,(char const &)*arg6); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsFlt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsFlt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsFlt" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsFlt" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsFlt" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsFlt" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsFlt" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); + result = (bool)((TStr const *)arg1)->IsFlt((bool const &)*arg2,(double const &)*arg3,(double const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsFlt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsFlt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsFlt" "', argument " "2"" of type '" "double &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsFlt" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + result = (bool)((TStr const *)arg1)->IsFlt(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsFlt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsFlt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsFlt(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsFlt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsFlt",0,6,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsFlt__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsFlt__SWIG_2(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStr_IsFlt__SWIG_1(self, argc, argv); + } + if (argc == 6) { + return _wrap_TStr_IsFlt__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsFlt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsFlt(bool const &,double const &,double const &,double &,char const &) const\n" + " TStr::IsFlt(bool const &,double const &,double const &,double &) const\n" + " TStr::IsFlt(double &) const\n" + " TStr::IsFlt() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFlt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFlt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (double)((TStr const *)arg1)->GetFlt(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFlt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFlt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetFlt" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)((TStr const *)arg1)->GetFlt((double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFlt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetFlt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetFlt__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetFlt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetFlt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetFlt() const\n" + " TStr::GetFlt(double const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWord__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWord" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsWord" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsWord" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (bool)((TStr const *)arg1)->IsWord((bool const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWord__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWord" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsWord" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TStr const *)arg1)->IsWord((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWord__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWord" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsWord(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWord(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsWord",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_IsWord__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_IsWord__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_IsWord__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsWord'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsWord(bool const &,bool const &) const\n" + " TStr::IsWord(bool const &) const\n" + " TStr::IsWord() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWs" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)((TStr const *)arg1)->IsWs(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + int *arg4 = 0 ; + TStrV *arg5 = 0 ; + char *arg6 = 0 ; + char *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + char temp6 ; + char val6 ; + int ecode6 = 0 ; + char temp7 ; + char val7 ; + int ecode7 = 0 ; + bool result; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsWcMatch" "', argument " "5"" of type '" "TStrV &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "5"" of type '" "TStrV &""'"); + } + arg5 = reinterpret_cast< TStrV * >(argp5); + ecode6 = SWIG_AsVal_char(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TStr_IsWcMatch" "', argument " "6"" of type '" "char""'"); + } + temp6 = static_cast< char >(val6); + arg6 = &temp6; + ecode7 = SWIG_AsVal_char(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "TStr_IsWcMatch" "', argument " "7"" of type '" "char""'"); + } + temp7 = static_cast< char >(val7); + arg7 = &temp7; + result = (bool)((TStr const *)arg1)->IsWcMatch((int const &)*arg2,(TStr const &)*arg3,(int const &)*arg4,*arg5,(char const &)*arg6,(char const &)*arg7); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + int *arg4 = 0 ; + TStrV *arg5 = 0 ; + char *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + char temp6 ; + char val6 ; + int ecode6 = 0 ; + bool result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsWcMatch" "', argument " "5"" of type '" "TStrV &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "5"" of type '" "TStrV &""'"); + } + arg5 = reinterpret_cast< TStrV * >(argp5); + ecode6 = SWIG_AsVal_char(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TStr_IsWcMatch" "', argument " "6"" of type '" "char""'"); + } + temp6 = static_cast< char >(val6); + arg6 = &temp6; + result = (bool)((TStr const *)arg1)->IsWcMatch((int const &)*arg2,(TStr const &)*arg3,(int const &)*arg4,*arg5,(char const &)*arg6); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + int *arg4 = 0 ; + TStrV *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStr_IsWcMatch" "', argument " "5"" of type '" "TStrV &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "5"" of type '" "TStrV &""'"); + } + arg5 = reinterpret_cast< TStrV * >(argp5); + result = (bool)((TStr const *)arg1)->IsWcMatch((int const &)*arg2,(TStr const &)*arg3,(int const &)*arg4,*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStrV *arg3 = 0 ; + char *arg4 = 0 ; + char *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + char temp4 ; + char val4 ; + int ecode4 = 0 ; + char temp5 ; + char val5 ; + int ecode5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "char""'"); + } + temp4 = static_cast< char >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_char(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TStr_IsWcMatch" "', argument " "5"" of type '" "char""'"); + } + temp5 = static_cast< char >(val5); + arg5 = &temp5; + result = (bool)((TStr const *)arg1)->IsWcMatch((TStr const &)*arg2,*arg3,(char const &)*arg4,(char const &)*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStrV *arg3 = 0 ; + char *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + char temp4 ; + char val4 ; + int ecode4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "char""'"); + } + temp4 = static_cast< char >(val4); + arg4 = &temp4; + result = (bool)((TStr const *)arg1)->IsWcMatch((TStr const &)*arg2,*arg3,(char const &)*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + result = (bool)((TStr const *)arg1)->IsWcMatch((TStr const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + char *arg3 = 0 ; + char *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + char temp4 ; + char val4 ; + int ecode4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "char""'"); + } + temp4 = static_cast< char >(val4); + arg4 = &temp4; + result = (bool)((TStr const *)arg1)->IsWcMatch((TStr const &)*arg2,(char const &)*arg3,(char const &)*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_IsWcMatch" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "TStr &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "4"" of type '" "TStr &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (bool)((TStr const *)arg1)->IsWcMatch((TStr const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TStr const *)arg1)->IsWcMatch((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsWcMatch(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[8]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_IsWcMatch",0,7,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_IsWcMatch__SWIG_8(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_IsWcMatch__SWIG_5(self, argc, argv); + } + if (argc == 4) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_TVecT_TStr_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + { + { + int res = SWIG_AsVal_char(argv[3], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_3; + return _wrap_TStr_IsWcMatch__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 4) { + int _v = 0; + { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_4; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_TStr_IsWcMatch__SWIG_7(self, argc, argv); + } +check_4: + + if (argc == 4) { + return _wrap_TStr_IsWcMatch__SWIG_6(self, argc, argv); + } + if (argc == 5) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_6; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_TVecT_TStr_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_6; + { + { + int res = SWIG_AsVal_char(argv[3], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_6; + { + { + int res = SWIG_AsVal_char(argv[4], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_6; + return _wrap_TStr_IsWcMatch__SWIG_3(self, argc, argv); + } +check_6: + + if (argc == 5) { + return _wrap_TStr_IsWcMatch__SWIG_2(self, argc, argv); + } + if (argc == 6) { + return _wrap_TStr_IsWcMatch__SWIG_1(self, argc, argv); + } + if (argc == 7) { + return _wrap_TStr_IsWcMatch__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_IsWcMatch'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::IsWcMatch(int const &,TStr const &,int const &,TStrV &,char const &,char const &) const\n" + " TStr::IsWcMatch(int const &,TStr const &,int const &,TStrV &,char const &) const\n" + " TStr::IsWcMatch(int const &,TStr const &,int const &,TStrV &) const\n" + " TStr::IsWcMatch(TStr const &,TStrV &,char const &,char const &) const\n" + " TStr::IsWcMatch(TStr const &,TStrV &,char const &) const\n" + " TStr::IsWcMatch(TStr const &,TStrV &) const\n" + " TStr::IsWcMatch(TStr const &,char const &,char const &) const\n" + " TStr::IsWcMatch(TStr const &,int const &,TStr &) const\n" + " TStr::IsWcMatch(TStr const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetWcMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_GetWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStr_GetWcMatch" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TStr const *)arg1)->GetWcMatch((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetWcMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TStr result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetWcMatch" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_GetWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetWcMatch" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TStr const *)arg1)->GetWcMatch((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetWcMatch(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetWcMatch",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStr_GetWcMatch__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStr_GetWcMatch__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetWcMatch'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetWcMatch(TStr const &,int const &) const\n" + " TStr::GetWcMatch(TStr const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFPath" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetFPath(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFBase" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetFBase(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFMid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFMid" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetFMid(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFExt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = ((TStr const *)arg1)->GetFExt(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrFPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetNrFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNrFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::GetNrFPath((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrFMid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetNrFMid" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNrFMid" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::GetNrFMid((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrFExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetNrFExt" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNrFExt" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::GetNrFExt((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrNumFExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStr_GetNrNumFExt" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = TStr::GetNrNumFExt((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrFNm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetNrFNm" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNrFNm" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::GetNrFNm((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrAbsFPath__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TStr result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetNrAbsFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNrAbsFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_GetNrAbsFPath" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNrAbsFPath" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TStr::GetNrAbsFPath((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrAbsFPath__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetNrAbsFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNrAbsFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::GetNrAbsFPath((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNrAbsFPath(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetNrAbsFPath",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetNrAbsFPath__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetNrAbsFPath__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetNrAbsFPath'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetNrAbsFPath(TStr const &,TStr const &)\n" + " TStr::GetNrAbsFPath(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_IsAbsFPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_IsAbsFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_IsAbsFPath" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)TStr::IsAbsFPath((TStr const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_PutFExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_PutFExt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_PutFExt" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFExt" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_PutFExt" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFExt" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TStr::PutFExt((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_PutFExtIfEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_PutFExtIfEmpty",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_PutFExtIfEmpty" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFExtIfEmpty" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_PutFExtIfEmpty" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFExtIfEmpty" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TStr::PutFExtIfEmpty((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_PutFBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_PutFBase",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_PutFBase" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFBase" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_PutFBase" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFBase" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TStr::PutFBase((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_PutFBaseIfEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_PutFBaseIfEmpty",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_PutFBaseIfEmpty" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFBaseIfEmpty" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_PutFBaseIfEmpty" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_PutFBaseIfEmpty" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TStr::PutFBaseIfEmpty((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_AddToFMid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_AddToFMid",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_AddToFMid" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_AddToFMid" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_AddToFMid" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_AddToFMid" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TStr::AddToFMid((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNumFNm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_GetNumFNm",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetNumFNm" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetNumFNm" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetNumFNm" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TStr::GetNumFNm((TStr const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFNmStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + TStr result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFNmStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetFNmStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetFNmStr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = TStr::GetFNmStr((TStr const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFNmStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetFNmStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_GetFNmStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::GetFNmStr((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetFNmStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_GetFNmStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStr_GetFNmStr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStr_GetFNmStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_GetFNmStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::GetFNmStr(TStr const &,bool const &)\n" + " TStr::GetFNmStr(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_LoadTxt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TSIn_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_LoadTxt" "', argument " "1"" of type '" "PSIn const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_LoadTxt" "', argument " "1"" of type '" "PSIn const &""'"); + } + arg1 = reinterpret_cast< PSIn * >(argp1); + result = TStr::LoadTxt((TPt< TSIn > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_LoadTxt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_LoadTxt" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_LoadTxt" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::LoadTxt((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_LoadTxt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_LoadTxt",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TSIn_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStr_LoadTxt__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TStr_LoadTxt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_LoadTxt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::LoadTxt(PSIn const &)\n" + " TStr::LoadTxt(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_SaveTxt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + PSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SaveTxt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TSOut_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SaveTxt" "', argument " "2"" of type '" "PSOut const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SaveTxt" "', argument " "2"" of type '" "PSOut const &""'"); + } + arg2 = reinterpret_cast< PSOut * >(argp2); + ((TStr const *)arg1)->SaveTxt((PSOut const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SaveTxt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_SaveTxt" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStr_SaveTxt" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_SaveTxt" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ((TStr const *)arg1)->SaveTxt((TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_SaveTxt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStr_SaveTxt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TPtT_TSOut_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStr_SaveTxt__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TStr_SaveTxt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStr_SaveTxt'.\n" + " Possible C/C++ prototypes are:\n" + " TStr::SaveTxt(PSOut const &) const\n" + " TStr::SaveTxt(TStr const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetChStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStr_GetChStr" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (TStr *) &TStr::GetChStr((char const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetDChStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char *arg2 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TStr_GetDChStr",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStr_GetDChStr" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStr_GetDChStr" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (TStr *) &TStr::GetDChStr((char const &)*arg1,(char const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Fmt__varargs__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *varargs) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + void *arg2 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject * obj0 = 0 ; + TStr result; + + if(!PyArg_UnpackTuple(args,(char *)"TStr_Fmt",1,1,&obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_Fmt" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = TStr::Fmt((char const *)arg1,arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_Fmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj; + PyObject *varargs; + PyObject *newargs; + + newargs = PyTuple_GetSlice(args,0,1); + varargs = PyTuple_GetSlice(args,1,PyTuple_Size(args)+1); + resultobj = _wrap_TStr_Fmt__varargs__(NULL,newargs,varargs); + Py_XDECREF(newargs); + Py_XDECREF(varargs); + return resultobj; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetSpaceStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStr_GetSpaceStr" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = TStr::GetSpaceStr((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetCStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_GetCStr" "', argument " "1"" of type '" "TStr const *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (char *)((TStr const *)arg1)->GetCStr(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_MkClone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStr_MkClone" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStr_MkClone" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStr::MkClone((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStr_GetNullStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TStr_GetNullStr",0,0,0)) SWIG_fail; + result = TStr::GetNullStr(); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStr, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TStrIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStrIn *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrIn" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrIn" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TStrIn *)new TStrIn((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrIn, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrIn_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TPt< TSIn > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrIn_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStrIn::New((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PSIn(static_cast< const PSIn& >(result))), SWIGTYPE_p_TPtT_TSIn_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrIn *arg1 = (TStrIn *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrIn, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrIn" "', argument " "1"" of type '" "TStrIn *""'"); + } + arg1 = reinterpret_cast< TStrIn * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStrIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStrIn, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TDbStr_Str1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + TStr *arg2 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TDbStr_Str1_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_Str1_set" "', argument " "1"" of type '" "TDbStr *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TDbStr_Str1_set" "', argument " "2"" of type '" "TStr *""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + if (arg1) (arg1)->Str1 = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_Str1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_Str1_get" "', argument " "1"" of type '" "TDbStr *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + result = (TStr *)& ((arg1)->Str1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_Str2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + TStr *arg2 = (TStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TDbStr_Str2_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_Str2_set" "', argument " "1"" of type '" "TDbStr *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TDbStr_Str2_set" "', argument " "2"" of type '" "TStr *""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + if (arg1) (arg1)->Str2 = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_Str2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_Str2_get" "', argument " "1"" of type '" "TDbStr *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + result = (TStr *)& ((arg1)->Str2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TDbStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TDbStr *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TDbStr *)new TDbStr(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TDbStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TDbStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TDbStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TDbStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TDbStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TDbStr" "', argument " "1"" of type '" "TDbStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TDbStr" "', argument " "1"" of type '" "TDbStr const &""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + result = (TDbStr *)new TDbStr((TDbStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TDbStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TDbStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TDbStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TDbStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TDbStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (TDbStr *)new TDbStr((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TDbStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TDbStr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TDbStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TDbStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TDbStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TDbStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TDbStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (TDbStr *)new TDbStr((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TDbStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TDbStr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TDbStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TDbStr" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TDbStr" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TDbStr *)new TDbStr(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TDbStr, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TDbStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TDbStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TDbStr__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TDbStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TDbStr__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TDbStr__SWIG_2(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TDbStr__SWIG_4(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TDbStr__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TDbStr'.\n" + " Possible C/C++ prototypes are:\n" + " TDbStr::TDbStr()\n" + " TDbStr::TDbStr(TDbStr const &)\n" + " TDbStr::TDbStr(TStr const &)\n" + " TDbStr::TDbStr(TStr const &,TStr const &)\n" + " TDbStr::TDbStr(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TDbStr_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_Save" "', argument " "1"" of type '" "TDbStr const *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TDbStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TDbStr_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TDbStr const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + TDbStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TDbStr___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr___eq__" "', argument " "1"" of type '" "TDbStr const *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TDbStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TDbStr___eq__" "', argument " "2"" of type '" "TDbStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TDbStr___eq__" "', argument " "2"" of type '" "TDbStr const &""'"); + } + arg2 = reinterpret_cast< TDbStr * >(argp2); + result = (bool)((TDbStr const *)arg1)->operator ==((TDbStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + TDbStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TDbStr___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr___lt__" "', argument " "1"" of type '" "TDbStr const *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TDbStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TDbStr___lt__" "', argument " "2"" of type '" "TDbStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TDbStr___lt__" "', argument " "2"" of type '" "TDbStr const &""'"); + } + arg2 = reinterpret_cast< TDbStr * >(argp2); + result = (bool)((TDbStr const *)arg1)->operator <((TDbStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_GetPrimHashCd" "', argument " "1"" of type '" "TDbStr const *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + result = (int)((TDbStr const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_GetSecHashCd" "', argument " "1"" of type '" "TDbStr const *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + result = (int)((TDbStr const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_Empty" "', argument " "1"" of type '" "TDbStr const *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + result = (bool)((TDbStr const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TDbStr_Filled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TDbStr_Filled" "', argument " "1"" of type '" "TDbStr const *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + result = (bool)((TDbStr const *)arg1)->Filled(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TDbStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TDbStr *arg1 = (TDbStr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TDbStr, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TDbStr" "', argument " "1"" of type '" "TDbStr *""'"); + } + arg1 = reinterpret_cast< TDbStr * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TDbStr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TDbStr, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TDbStr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TStrPool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint *arg2 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + TStrPool *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TStrPool" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TStrPool" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (TStrPool *)new TStrPool((uint const &)*arg1,(uint const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + TStrPool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TStrPool" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = (TStrPool *)new TStrPool((uint const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TStrPool *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TStrPool *)new TStrPool(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + TStrPool *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TStrPool" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (TStrPool *)new TStrPool(*arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStrPool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrPool" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TStrPool *)new TStrPool(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStrPool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStrPool, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrPool" "', argument " "1"" of type '" "TStrPool const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrPool" "', argument " "1"" of type '" "TStrPool const &""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + result = (TStrPool *)new TStrPool((TStrPool const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TStrPool",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TStrPool__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TStrPool__SWIG_4(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStrPool, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TStrPool__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TStrPool__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_5; + return _wrap_new_TStrPool__SWIG_3(self, argc, argv); + } +check_5: + + if (argc == 2) { + return _wrap_new_TStrPool__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TStrPool'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::TStrPool(uint const &,uint const &)\n" + " TStrPool::TStrPool(uint const &)\n" + " TStrPool::TStrPool()\n" + " TStrPool::TStrPool(TSIn &,bool)\n" + " TStrPool::TStrPool(TSIn &)\n" + " TStrPool::TStrPool(TStrPool const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrPool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrPool" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint *arg2 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TStrPool > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStrPool_New" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool_New" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = TStrPool::New((unsigned int const &)*arg1,(unsigned int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PStrPool(static_cast< const PStrPool& >(result))), SWIGTYPE_p_TPtT_TStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + SwigValueWrapper< TPt< TStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStrPool_New" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = TStrPool::New((unsigned int const &)*arg1); + resultobj = SWIG_NewPointerObj((new PStrPool(static_cast< const PStrPool& >(result))), SWIGTYPE_p_TPtT_TStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_New__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TStrPool > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TStrPool::New(); + resultobj = SWIG_NewPointerObj((new PStrPool(static_cast< const PStrPool& >(result))), SWIGTYPE_p_TPtT_TStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_New__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_New" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool_New" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TStrPool::New(*arg1); + resultobj = SWIG_NewPointerObj((new PStrPool(static_cast< const PStrPool& >(result))), SWIGTYPE_p_TPtT_TStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_New__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_New" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool_New" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TStrPool::New((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new PStrPool(static_cast< const PStrPool& >(result))), SWIGTYPE_p_TPtT_TStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TStrPool_New__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TStrPool_New__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TStrPool_New__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_TStrPool_New__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool_New__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool_New'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::New(uint const &,uint const &)\n" + " TStrPool::New(uint const &)\n" + " TStrPool::New()\n" + " TStrPool::New(TSIn &)\n" + " TStrPool::New(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TStrPool > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool_Load" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = TStrPool::Load(*arg1,arg2); + resultobj = SWIG_NewPointerObj((new PStrPool(static_cast< const PStrPool& >(result))), SWIGTYPE_p_TPtT_TStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TStrPool > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TStrPool::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PStrPool(static_cast< const PStrPool& >(result))), SWIGTYPE_p_TPtT_TStrPool_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Load(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool_Load",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrPool_Load__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool_Load__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool_Load'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::Load(TSIn &,bool)\n" + " TStrPool::Load(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Save" "', argument " "1"" of type '" "TStrPool const *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrPool_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TStrPool const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Save" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrPool_Save" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool_Save" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + (arg1)->Save((TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Save(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool_Save",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TSOut, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrPool_Save__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TStrPool_Save__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool_Save'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::Save(TSOut &) const\n" + " TStrPool::Save(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Len" "', argument " "1"" of type '" "TStrPool const *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + result = (uint)((TStrPool const *)arg1)->Len(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Size" "', argument " "1"" of type '" "TStrPool const *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + result = (uint)((TStrPool const *)arg1)->Size(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Empty" "', argument " "1"" of type '" "TStrPool const *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + result = (bool)((TStrPool const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool___call__" "', argument " "1"" of type '" "TStrPool const *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + result = (char *)((TStrPool const *)arg1)->operator ()(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_AddStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + char *arg2 = (char *) 0 ; + uint *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + uint temp3 ; + unsigned int val3 ; + int ecode3 = 0 ; + uint result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_AddStr" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrPool_AddStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrPool_AddStr" "', argument " "3"" of type '" "uint""'"); + } + temp3 = static_cast< uint >(val3); + arg3 = &temp3; + result = (uint)(arg1)->AddStr((char const *)arg2,(uint const &)*arg3); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_AddStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + uint result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_AddStr" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrPool_AddStr" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (uint)(arg1)->AddStr((char const *)arg2); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_AddStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + uint result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_AddStr" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrPool_AddStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool_AddStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (uint)(arg1)->AddStr((TStr const &)*arg2); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_AddStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool_AddStr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TStrPool_AddStr__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TStrPool_AddStr__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrPool_AddStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool_AddStr'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::AddStr(char const *,uint const &)\n" + " TStrPool::AddStr(char const *)\n" + " TStrPool::AddStr(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_GetCStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TStrPool_GetCStr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_GetCStr" "', argument " "1"" of type '" "TStrPool const *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool_GetCStr" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (char *)((TStrPool const *)arg1)->GetCStr((uint const &)*arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Clr" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool_Clr" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->Clr(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Clr" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool_Clr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrPool_Clr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::Clr(bool)\n" + " TStrPool::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_Cmp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + uint *arg2 = 0 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrPool_Cmp",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_Cmp" "', argument " "1"" of type '" "TStrPool const *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool_Cmp" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrPool_Cmp" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (int)((TStrPool const *)arg1)->Cmp((uint const &)*arg2,(char const *)arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_GetPrimHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_GetPrimHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrPool::GetPrimHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_GetSecHashCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_GetSecHashCd" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + result = (int)TStrPool::GetSecHashCd((char const *)arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_GetPrimHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_GetPrimHashCd" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool_GetPrimHashCd" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (int)(arg1)->GetPrimHashCd((uint const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_GetPrimHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool_GetPrimHashCd",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrPool_GetPrimHashCd__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool_GetPrimHashCd__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool_GetPrimHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::GetPrimHashCd(char const *)\n" + " TStrPool::GetPrimHashCd(uint const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_GetSecHashCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool *arg1 = (TStrPool *) 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool_GetSecHashCd" "', argument " "1"" of type '" "TStrPool *""'"); + } + arg1 = reinterpret_cast< TStrPool * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool_GetSecHashCd" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (int)(arg1)->GetSecHashCd((uint const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool_GetSecHashCd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool_GetSecHashCd",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrPool_GetSecHashCd__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool_GetSecHashCd__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool_GetSecHashCd'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool::GetSecHashCd(char const *)\n" + " TStrPool::GetSecHashCd(uint const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *TStrPool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStrPool, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrPool_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TStrPool64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ::TSize arg1 ; + ::TSize arg2 ; + size_t val1 ; + int ecode1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + TStrPool64 *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TStrPool64" "', argument " "1"" of type '" "::TSize""'"); + } + arg1 = static_cast< ::TSize >(val1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TStrPool64" "', argument " "2"" of type '" "::TSize""'"); + } + arg2 = static_cast< ::TSize >(val2); + result = (TStrPool64 *)new TStrPool64(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ::TSize arg1 ; + size_t val1 ; + int ecode1 = 0 ; + TStrPool64 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TStrPool64" "', argument " "1"" of type '" "::TSize""'"); + } + arg1 = static_cast< ::TSize >(val1); + result = (TStrPool64 *)new TStrPool64(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool64__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TStrPool64 *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TStrPool64 *)new TStrPool64(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool64__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStrPool64 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStrPool64, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrPool64" "', argument " "1"" of type '" "TStrPool64 const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrPool64" "', argument " "1"" of type '" "TStrPool64 const &""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + result = (TStrPool64 *)new TStrPool64((TStrPool64 const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool64__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + TStrPool64 *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrPool64" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrPool64" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TStrPool64" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (TStrPool64 *)new TStrPool64(*arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool64__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStrPool64 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrPool64" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrPool64" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TStrPool64 *)new TStrPool64(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStrPool64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrPool64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TStrPool64",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TStrPool64__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TStrPool64, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TStrPool64__SWIG_3(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TStrPool64__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TStrPool64__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_5; + return _wrap_new_TStrPool64__SWIG_4(self, argc, argv); + } +check_5: + + if (argc == 2) { + return _wrap_new_TStrPool64__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TStrPool64'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool64::TStrPool64(::TSize,::TSize)\n" + " TStrPool64::TStrPool64(::TSize)\n" + " TStrPool64::TStrPool64()\n" + " TStrPool64::TStrPool64(TStrPool64 const &)\n" + " TStrPool64::TStrPool64(TSIn &,bool)\n" + " TStrPool64::TStrPool64(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrPool64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrPool64" "', argument " "1"" of type '" "TStrPool64 *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrPool64_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Save" "', argument " "1"" of type '" "TStrPool64 const *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrPool64_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool64_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TStrPool64 const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ::TSize arg1 ; + ::TSize arg2 ; + size_t val1 ; + int ecode1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TStrPool64 > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStrPool64_New" "', argument " "1"" of type '" "::TSize""'"); + } + arg1 = static_cast< ::TSize >(val1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool64_New" "', argument " "2"" of type '" "::TSize""'"); + } + arg2 = static_cast< ::TSize >(val2); + result = TStrPool64::New(arg1,arg2); + resultobj = SWIG_NewPointerObj((new PStrPool64(static_cast< const PStrPool64& >(result))), SWIGTYPE_p_TPtT_TStrPool64_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ::TSize arg1 ; + size_t val1 ; + int ecode1 = 0 ; + SwigValueWrapper< TPt< TStrPool64 > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TStrPool64_New" "', argument " "1"" of type '" "::TSize""'"); + } + arg1 = static_cast< ::TSize >(val1); + result = TStrPool64::New(arg1); + resultobj = SWIG_NewPointerObj((new PStrPool64(static_cast< const PStrPool64& >(result))), SWIGTYPE_p_TPtT_TStrPool64_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_New__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TStrPool64 > > result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TStrPool64::New(); + resultobj = SWIG_NewPointerObj((new PStrPool64(static_cast< const PStrPool64& >(result))), SWIGTYPE_p_TPtT_TStrPool64_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool64_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TStrPool64_New__SWIG_2(self, argc, argv); + } + if (argc == 1) { + return _wrap_TStrPool64_New__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool64_New__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool64_New'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool64::New(::TSize,::TSize)\n" + " TStrPool64::New(::TSize)\n" + " TStrPool64::New()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + SwigValueWrapper< TPt< TStrPool64 > > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool64_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool64_Load" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = TStrPool64::Load(*arg1,arg2); + resultobj = SWIG_NewPointerObj((new PStrPool64(static_cast< const PStrPool64& >(result))), SWIGTYPE_p_TPtT_TStrPool64_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + SwigValueWrapper< TPt< TStrPool64 > > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool64_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TStrPool64::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PStrPool64(static_cast< const PStrPool64& >(result))), SWIGTYPE_p_TPtT_TStrPool64_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Load(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool64_Load",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrPool64_Load__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool64_Load__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool64_Load'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool64::Load(TSIn &,bool)\n" + " TStrPool64::Load(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint64 result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_GetMemUsed" "', argument " "1"" of type '" "TStrPool64 const *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + result = (uint64)((TStrPool64 const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Empty" "', argument " "1"" of type '" "TStrPool64 const *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + result = (bool)((TStrPool64 const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint64 result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Len" "', argument " "1"" of type '" "TStrPool64 const *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + result = (uint64)((TStrPool64 const *)arg1)->Len(); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Reserved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint64 result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Reserved" "', argument " "1"" of type '" "TStrPool64 const *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + result = (uint64)((TStrPool64 const *)arg1)->Reserved(); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Clr" "', argument " "1"" of type '" "TStrPool64 *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool64_Clr" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->Clr(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Clr" "', argument " "1"" of type '" "TStrPool64 *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrPool64_Clr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrPool64_Clr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrPool64_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrPool64_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " TStrPool64::Clr(bool)\n" + " TStrPool64::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_Cmp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + uint64 arg2 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrPool64_Cmp",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_Cmp" "', argument " "1"" of type '" "TStrPool64 const *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrPool64_Cmp" "', argument " "2"" of type '" "uint64""'"); + } + arg2 = static_cast< uint64 >(val2); + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrPool64_Cmp" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (int)((TStrPool64 const *)arg1)->Cmp(arg2,(char const *)arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrPool64_AddStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStrPool64 *arg1 = (TStrPool64 *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + uint64 result; + + if (!SWIG_Python_UnpackTuple(args,"TStrPool64_AddStr",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStrPool64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrPool64_AddStr" "', argument " "1"" of type '" "TStrPool64 *""'"); + } + arg1 = reinterpret_cast< TStrPool64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrPool64_AddStr" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrPool64_AddStr" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (uint64)(arg1)->AddStr((TStr const &)*arg2); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TStrPool64_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TStrPool64, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrPool64_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TVoid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TVoid *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TVoid *)new TVoid(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVoid, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TVoid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVoid *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TVoid" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TVoid" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TVoid *)new TVoid(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVoid, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TVoid(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TVoid",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TVoid__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TVoid__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TVoid'.\n" + " Possible C/C++ prototypes are:\n" + " TVoid::TVoid()\n" + " TVoid::TVoid(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TVoid_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVoid *arg1 = (TVoid *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TVoid_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVoid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVoid_Save" "', argument " "1"" of type '" "TVoid const *""'"); + } + arg1 = reinterpret_cast< TVoid * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVoid_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVoid_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TVoid const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TVoid_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVoid *arg1 = (TVoid *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TVoid_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVoid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVoid_LoadXml" "', argument " "1"" of type '" "TVoid *""'"); + } + arg1 = reinterpret_cast< TVoid * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVoid_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVoid_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TVoid_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVoid_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TVoid_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVoid *arg1 = (TVoid *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TVoid_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVoid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVoid_SaveXml" "', argument " "1"" of type '" "TVoid const *""'"); + } + arg1 = reinterpret_cast< TVoid * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVoid_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVoid_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TVoid_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVoid_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TVoid const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TVoid___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVoid *arg1 = (TVoid *) 0 ; + TVoid *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TVoid___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVoid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVoid___eq__" "', argument " "1"" of type '" "TVoid const *""'"); + } + arg1 = reinterpret_cast< TVoid * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVoid, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVoid___eq__" "', argument " "2"" of type '" "TVoid const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVoid___eq__" "', argument " "2"" of type '" "TVoid const &""'"); + } + arg2 = reinterpret_cast< TVoid * >(argp2); + result = (bool)((TVoid const *)arg1)->operator ==((TVoid const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TVoid___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVoid *arg1 = (TVoid *) 0 ; + TVoid *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TVoid___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVoid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVoid___lt__" "', argument " "1"" of type '" "TVoid const *""'"); + } + arg1 = reinterpret_cast< TVoid * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVoid, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVoid___lt__" "', argument " "2"" of type '" "TVoid const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVoid___lt__" "', argument " "2"" of type '" "TVoid const &""'"); + } + arg2 = reinterpret_cast< TVoid * >(argp2); + result = (bool)((TVoid const *)arg1)->operator <((TVoid const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TVoid_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVoid *arg1 = (TVoid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVoid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVoid_GetMemUsed" "', argument " "1"" of type '" "TVoid const *""'"); + } + arg1 = reinterpret_cast< TVoid * >(argp1); + result = (int)((TVoid const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TVoid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVoid *arg1 = (TVoid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVoid, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TVoid" "', argument " "1"" of type '" "TVoid *""'"); + } + arg1 = reinterpret_cast< TVoid * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TVoid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TVoid, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TVoid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TBool_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBool_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_Val_set" "', argument " "1"" of type '" "TBool *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBool_Val_set" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_Val_get" "', argument " "1"" of type '" "TBool *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + result = (bool) ((arg1)->Val); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TBool_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_bool(static_cast< bool >(TBool::Mn)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_bool(static_cast< bool >(TBool::Mx)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_Vals_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_Vals is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_Vals_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TBool::Vals)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_Rnd_set(PyObject *_val) { + { + void *argp = 0; + int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_TRnd, 0 | 0); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""TBool::Rnd""' of type '""TRnd""'"); + } + if (!argp) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""TBool::Rnd""' of type '""TRnd""'"); + } else { + TRnd * temp; + temp = reinterpret_cast< TRnd * >(argp); + TBool::Rnd = *temp; + if (SWIG_IsNewObj(res)) delete temp; + } + } + return 0; +fail: + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_Rnd_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TBool::Rnd), SWIGTYPE_p_TRnd, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_TBool_Rnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) { + return Swig_var_TBool_Rnd_get(); +} + + +SWIGINTERN PyObject *_wrap_TBool_Rnd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + int res; + + res = Swig_var_TBool_Rnd_set(args); + return !res ? SWIG_Py_Void() : NULL; +} + + +SWIGINTERN int Swig_var_TBool_FalseStr_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_FalseStr is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_FalseStr_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TBool::FalseStr), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_TrueStr_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_TrueStr is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_TrueStr_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TBool::TrueStr), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_NStr_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_NStr is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_NStr_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TBool::NStr), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_YStr_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_YStr is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_YStr_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TBool::YStr), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_NoStr_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_NoStr is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_NoStr_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TBool::NoStr), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TBool_YesStr_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TBool_YesStr is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TBool_YesStr_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TBool::YesStr), SWIGTYPE_p_TStr, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_new_TBool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TBool *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TBool *)new TBool(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + bool *arg1 = 0 ; + bool temp1 ; + bool val1 ; + int ecode1 = 0 ; + TBool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TBool" "', argument " "1"" of type '" "bool""'"); + } + temp1 = static_cast< bool >(val1); + arg1 = &temp1; + result = (TBool *)new TBool((bool const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool___nonzero__" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + result = (bool)((TBool const *)arg1)->operator bool(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBool__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TBool *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TBool" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TBool" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TBool *)new TBool(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TBool, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TBool(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TBool",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TBool__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TBool__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TBool__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TBool'.\n" + " Possible C/C++ prototypes are:\n" + " TBool::TBool()\n" + " TBool::TBool(bool const &)\n" + " TBool::TBool(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TBool_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBool_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_Load" "', argument " "1"" of type '" "TBool *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBool_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TBool_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_Save" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBool_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TBool const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBool_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_LoadXml" "', argument " "1"" of type '" "TBool *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBool_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TBool_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TBool_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_SaveXml" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBool_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TBool_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TBool const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + TBool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TBool___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool___eq__" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TBool, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBool___eq__" "', argument " "2"" of type '" "TBool const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool___eq__" "', argument " "2"" of type '" "TBool const &""'"); + } + arg2 = reinterpret_cast< TBool * >(argp2); + result = (bool)((TBool const *)arg1)->operator ==((TBool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + TBool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TBool___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool___lt__" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TBool, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TBool___lt__" "', argument " "2"" of type '" "TBool const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool___lt__" "', argument " "2"" of type '" "TBool const &""'"); + } + arg2 = reinterpret_cast< TBool * >(argp2); + result = (bool)((TBool const *)arg1)->operator <((TBool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool___call__" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + result = (bool)((TBool const *)arg1)->operator ()(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_GetMemUsed" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + result = (int)((TBool const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_GetPrimHashCd" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + result = (int)((TBool const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_GetSecHashCd" "', argument " "1"" of type '" "TBool const *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + result = (int)((TBool const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetRnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TBool_GetRnd",0,0,0)) SWIG_fail; + result = (bool)TBool::GetRnd(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetYNStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + bool *arg1 = 0 ; + bool temp1 ; + bool val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TBool_GetYNStr" "', argument " "1"" of type '" "bool""'"); + } + temp1 = static_cast< bool >(val1); + arg1 = &temp1; + result = TBool::GetYNStr((bool const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetYesNoStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + bool *arg1 = 0 ; + bool temp1 ; + bool val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TBool_GetYesNoStr" "', argument " "1"" of type '" "bool""'"); + } + temp1 = static_cast< bool >(val1); + arg1 = &temp1; + result = TBool::GetYesNoStr((bool const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_Get01Str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + bool *arg1 = 0 ; + bool temp1 ; + bool val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TBool_Get01Str" "', argument " "1"" of type '" "bool""'"); + } + temp1 = static_cast< bool >(val1); + arg1 = &temp1; + result = TBool::Get01Str((bool const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_IsValStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_IsValStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_IsValStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)TBool::IsValStr((TStr const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetValFromStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_GetValFromStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_GetValFromStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)TBool::GetValFromStr((TStr const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetValFromStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TBool_GetValFromStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TBool_GetValFromStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TBool_GetValFromStr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)TBool::GetValFromStr((TStr const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TBool_GetValFromStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TBool_GetValFromStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TBool_GetValFromStr__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TBool_GetValFromStr__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TBool_GetValFromStr'.\n" + " Possible C/C++ prototypes are:\n" + " TBool::GetValFromStr(TStr const &)\n" + " TBool::GetValFromStr(TStr const &,bool const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TBool *arg1 = (TBool *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TBool, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TBool" "', argument " "1"" of type '" "TBool *""'"); + } + arg1 = reinterpret_cast< TBool * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TBool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TBool, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TBool_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TCh_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + char arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TCh_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_Val_set" "', argument " "1"" of type '" "TCh *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TCh_Val_set" "', argument " "2"" of type '" "char""'"); + } + arg2 = static_cast< char >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_Val_get" "', argument " "1"" of type '" "TCh *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + result = (char) ((arg1)->Val); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TCh_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::Mn)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::Mx)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_Vals_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_Vals is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_Vals_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TCh::Vals)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_NullCh_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_NullCh is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_NullCh_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::NullCh)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_TabCh_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_TabCh is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_TabCh_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::TabCh)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_LfCh_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_LfCh is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_LfCh_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::LfCh)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_CrCh_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_CrCh is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_CrCh_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::CrCh)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_EofCh_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_EofCh is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_EofCh_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::EofCh)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TCh_HashCh_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TCh_HashCh is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TCh_HashCh_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_char(static_cast< char >(TCh::HashCh)); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_new_TCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TCh *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TCh *)new TCh(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + TCh *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TCh" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (TCh *)new TCh((char const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TCh *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TCh" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TCh" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TCh *)new TCh(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TCh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TCh",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TCh__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TCh__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TCh__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TCh'.\n" + " Possible C/C++ prototypes are:\n" + " TCh::TCh()\n" + " TCh::TCh(char const &)\n" + " TCh::TCh(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TCh_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TCh_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_Save" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCh_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCh_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TCh const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TCh_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_LoadXml" "', argument " "1"" of type '" "TCh *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCh_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCh_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TCh_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCh_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TCh_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_SaveXml" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCh_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCh_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TCh_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCh_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TCh const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + TCh *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TCh___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh___eq__" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TCh, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCh___eq__" "', argument " "2"" of type '" "TCh const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCh___eq__" "', argument " "2"" of type '" "TCh const &""'"); + } + arg2 = reinterpret_cast< TCh * >(argp2); + result = (bool)((TCh const *)arg1)->operator ==((TCh const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + TCh *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TCh___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh___lt__" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TCh, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TCh___lt__" "', argument " "2"" of type '" "TCh const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TCh___lt__" "', argument " "2"" of type '" "TCh const &""'"); + } + arg2 = reinterpret_cast< TCh * >(argp2); + result = (bool)((TCh const *)arg1)->operator <((TCh const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh___call__" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + result = (char)((TCh const *)arg1)->operator ()(); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_GetMemUsed" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + result = (int)((TCh const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_GetPrimHashCd" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + result = (int)((TCh const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TCh_GetSecHashCd" "', argument " "1"" of type '" "TCh const *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + result = (int)((TCh const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_IsWs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_IsWs" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (bool)TCh::IsWs((char const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_IsAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_IsAlpha" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (bool)TCh::IsAlpha((char const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_IsNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_IsNum" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (bool)TCh::IsNum((char const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_IsAlNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_IsAlNum" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (bool)TCh::IsAlNum((char const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_GetNum" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (int)TCh::GetNum((char const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_IsHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_IsHex" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (bool)TCh::IsHex((char const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_GetHex" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (int)TCh::GetHex((char const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetHexCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_GetHexCh" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (char)TCh::GetHexCh((int const &)*arg1); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_IsUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_IsUc" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (char)TCh::IsUc((char const &)*arg1); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetUc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_GetUc" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (char)TCh::GetUc((char const &)*arg1); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TCh_GetUsFromYuAscii(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = 0 ; + char temp1 ; + char val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + char result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TCh_GetUsFromYuAscii" "', argument " "1"" of type '" "char""'"); + } + temp1 = static_cast< char >(val1); + arg1 = &temp1; + result = (char)TCh::GetUsFromYuAscii((char const &)*arg1); + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TCh *arg1 = (TCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TCh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TCh" "', argument " "1"" of type '" "TCh *""'"); + } + arg1 = reinterpret_cast< TCh * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TCh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TCh, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TCh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TUCh_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + uchar arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUCh_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_Val_set" "', argument " "1"" of type '" "TUCh *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUCh_Val_set" "', argument " "2"" of type '" "uchar""'"); + } + arg2 = static_cast< uchar >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uchar result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_Val_get" "', argument " "1"" of type '" "TUCh *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + result = (uchar) ((arg1)->Val); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TUCh_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TUCh_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUCh_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(TUCh::Mn)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TUCh_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TUCh_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUCh_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(TUCh::Mx)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TUCh_Vals_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TUCh_Vals is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUCh_Vals_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TUCh::Vals)); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_new_TUCh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TUCh *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TUCh *)new TUCh(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUCh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUCh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uchar *arg1 = 0 ; + uchar temp1 ; + unsigned char val1 ; + int ecode1 = 0 ; + TUCh *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_char(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TUCh" "', argument " "1"" of type '" "uchar""'"); + } + temp1 = static_cast< uchar >(val1); + arg1 = &temp1; + result = (TUCh *)new TUCh((uchar const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUCh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUCh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUCh *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUCh" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUCh" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TUCh *)new TUCh(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUCh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUCh(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUCh",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TUCh__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TUCh__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TUCh__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUCh'.\n" + " Possible C/C++ prototypes are:\n" + " TUCh::TUCh()\n" + " TUCh::TUCh(uchar const &)\n" + " TUCh::TUCh(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUCh_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUCh_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_Save" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUCh_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUCh_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TUCh const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUCh_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_LoadXml" "', argument " "1"" of type '" "TUCh *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUCh_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUCh_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUCh_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUCh_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUCh_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_SaveXml" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUCh_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUCh_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUCh_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUCh_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TUCh const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + TUCh *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUCh___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh___eq__" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUCh, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUCh___eq__" "', argument " "2"" of type '" "TUCh const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUCh___eq__" "', argument " "2"" of type '" "TUCh const &""'"); + } + arg2 = reinterpret_cast< TUCh * >(argp2); + result = (bool)((TUCh const *)arg1)->operator ==((TUCh const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + TUCh *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUCh___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh___lt__" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUCh, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUCh___lt__" "', argument " "2"" of type '" "TUCh const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUCh___lt__" "', argument " "2"" of type '" "TUCh const &""'"); + } + arg2 = reinterpret_cast< TUCh * >(argp2); + result = (bool)((TUCh const *)arg1)->operator <((TUCh const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uchar result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh___call__" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + result = (uchar)((TUCh const *)arg1)->operator ()(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_GetMemUsed" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + result = (int)((TUCh const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_GetPrimHashCd" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + result = (int)((TUCh const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUCh_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUCh_GetSecHashCd" "', argument " "1"" of type '" "TUCh const *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + result = (int)((TUCh const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TUCh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUCh *arg1 = (TUCh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUCh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUCh" "', argument " "1"" of type '" "TUCh *""'"); + } + arg1 = reinterpret_cast< TUCh * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUCh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUCh, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUCh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TSInt_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInt *arg1 = (TSInt *) 0 ; + int16 arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSInt_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInt_Val_set" "', argument " "1"" of type '" "TSInt *""'"); + } + arg1 = reinterpret_cast< TSInt * >(argp1); + ecode2 = SWIG_AsVal_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSInt_Val_set" "', argument " "2"" of type '" "int16""'"); + } + arg2 = static_cast< int16 >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInt_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInt *arg1 = (TSInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int16 result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInt_Val_get" "', argument " "1"" of type '" "TSInt *""'"); + } + arg1 = reinterpret_cast< TSInt * >(argp1); + result = (int16) ((arg1)->Val); + resultobj = SWIG_From_short(static_cast< short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TSInt *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TSInt *)new TSInt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int16 *arg1 = 0 ; + int16 temp1 ; + short val1 ; + int ecode1 = 0 ; + TSInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_short(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TSInt" "', argument " "1"" of type '" "int16""'"); + } + temp1 = static_cast< int16 >(val1); + arg1 = &temp1; + result = (TSInt *)new TSInt((int16 const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TSInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TSInt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TSInt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TSInt *)new TSInt(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TSInt",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TSInt__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TSInt__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TSInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TSInt'.\n" + " Possible C/C++ prototypes are:\n" + " TSInt::TSInt()\n" + " TSInt::TSInt(int16 const &)\n" + " TSInt::TSInt(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSInt_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInt *arg1 = (TSInt *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSInt_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInt_Load" "', argument " "1"" of type '" "TSInt *""'"); + } + arg1 = reinterpret_cast< TSInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSInt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSInt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInt_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInt *arg1 = (TSInt *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSInt_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInt_Save" "', argument " "1"" of type '" "TSInt const *""'"); + } + arg1 = reinterpret_cast< TSInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSInt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSInt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TSInt const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInt_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInt *arg1 = (TSInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInt_GetPrimHashCd" "', argument " "1"" of type '" "TSInt const *""'"); + } + arg1 = reinterpret_cast< TSInt * >(argp1); + result = (int)((TSInt const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSInt_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInt *arg1 = (TSInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSInt_GetSecHashCd" "', argument " "1"" of type '" "TSInt const *""'"); + } + arg1 = reinterpret_cast< TSInt * >(argp1); + result = (int)((TSInt const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TSInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSInt *arg1 = (TSInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSInt" "', argument " "1"" of type '" "TSInt *""'"); + } + arg1 = reinterpret_cast< TSInt * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TSInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSInt, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TSInt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TInt_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_Val_set" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_Val_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_Val_get" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + result = (int) ((arg1)->Val); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TInt_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TInt_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TInt_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TInt::Mn)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TInt_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TInt_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TInt_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TInt::Mx)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TInt_Kilo_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TInt_Kilo is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TInt_Kilo_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TInt::Kilo)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TInt_Mega_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TInt_Mega is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TInt_Mega_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TInt::Mega)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TInt_Giga_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TInt_Giga is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TInt_Giga_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(TInt::Giga)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TInt_Rnd_set(PyObject *_val) { + { + void *argp = 0; + int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_TRnd, 0 | 0); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""TInt::Rnd""' of type '""TRnd""'"); + } + if (!argp) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""TInt::Rnd""' of type '""TRnd""'"); + } else { + TRnd * temp; + temp = reinterpret_cast< TRnd * >(argp); + TInt::Rnd = *temp; + if (SWIG_IsNewObj(res)) delete temp; + } + } + return 0; +fail: + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TInt_Rnd_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TInt::Rnd), SWIGTYPE_p_TRnd, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_TInt_Rnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) { + return Swig_var_TInt_Rnd_get(); +} + + +SWIGINTERN PyObject *_wrap_TInt_Rnd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + int res; + + res = Swig_var_TInt_Rnd_set(args); + return !res ? SWIG_Py_Void() : NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TInt *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TInt *)new TInt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TInt" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TInt *)new TInt((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TInt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TInt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TInt *)new TInt(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TInt",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TInt__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TInt__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TInt'.\n" + " Possible C/C++ prototypes are:\n" + " TInt::TInt()\n" + " TInt::TInt(int const &)\n" + " TInt::TInt(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TInt_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_Load" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_Save" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TInt const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_LoadXml" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TInt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_SaveXml" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TInt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TInt const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___eq__" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt___eq__" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt___eq__" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)((TInt const *)arg1)->operator ==((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___eq__" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt___eq__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TInt const *)arg1)->operator ==((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___eq__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TInt___eq__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TInt___eq____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TInt___eq____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TInt___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TInt___ne__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___ne__" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt___ne__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TInt const *)arg1)->operator !=((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___lt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___lt__" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt___lt__" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt___lt__" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)((TInt const *)arg1)->operator <((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___lt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___lt__" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt___lt__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TInt const *)arg1)->operator <((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___lt__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TInt___lt__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TInt___lt____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TInt___lt____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TInt___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___call__" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + result = (int)((TInt const *)arg1)->operator ()(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TInt___iadd__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___iadd__" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt___iadd__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TInt *) &(arg1)->operator +=((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TInt___isub__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt___isub__" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt___isub__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TInt *) &(arg1)->operator -=((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_GetMemUsed" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + result = (int)((TInt const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_GetPrimHashCd" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + result = (int)((TInt const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_GetSecHashCd" "', argument " "1"" of type '" "TInt const *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + result = (int)((TInt const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_Abs" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (int)TInt::Abs((int const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_Sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_Sign" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (int)TInt::Sign((int const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_Swap",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_Swap" "', argument " "1"" of type '" "int &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_Swap" "', argument " "1"" of type '" "int &""'"); + } + arg1 = reinterpret_cast< int * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_Swap" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_Swap" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + TInt::Swap(*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetRnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetRnd" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (int)TInt::GetRnd((int const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetRnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + int result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (int)TInt::GetRnd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetRnd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TInt_GetRnd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TInt_GetRnd__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TInt_GetRnd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TInt_GetRnd'.\n" + " Possible C/C++ prototypes are:\n" + " TInt::GetRnd(int const &)\n" + " TInt::GetRnd()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TInt_IsOdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_IsOdd" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (bool)TInt::IsOdd((int const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_IsEven(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_IsEven" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (bool)TInt::IsEven((int const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetMn" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_GetMn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)TInt::GetMn((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetMx" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_GetMx" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)TInt::GetMx((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetMn" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_GetMn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TInt_GetMn" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)TInt::GetMn((int const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMn__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetMn" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_GetMn" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TInt_GetMn" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TInt_GetMn" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)TInt::GetMn((int const &)*arg1,(int const &)*arg2,(int const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TInt_GetMn",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TInt_GetMn__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TInt_GetMn__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TInt_GetMn__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TInt_GetMn'.\n" + " Possible C/C++ prototypes are:\n" + " TInt::GetMn(int const &,int const &)\n" + " TInt::GetMn(int const &,int const &,int const &)\n" + " TInt::GetMn(int const &,int const &,int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetMx" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_GetMx" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TInt_GetMx" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)TInt::GetMx((int const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMx__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetMx" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_GetMx" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TInt_GetMx" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TInt_GetMx" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)TInt::GetMx((int const &)*arg1,(int const &)*arg2,(int const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMx(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TInt_GetMx",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TInt_GetMx__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TInt_GetMx__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TInt_GetMx__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TInt_GetMx'.\n" + " Possible C/C++ prototypes are:\n" + " TInt::GetMx(int const &,int const &)\n" + " TInt::GetMx(int const &,int const &,int const &)\n" + " TInt::GetMx(int const &,int const &,int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetInRng(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TInt_GetInRng",3,3,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetInRng" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_GetInRng" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TInt_GetInRng" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)TInt::GetInRng((int const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetHexStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TStr result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetHexStr" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = TInt::GetHexStr((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetHexStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_GetHexStr" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_GetHexStr" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + result = TInt::GetHexStr((TInt const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetHexStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TInt_GetHexStr",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TInt_GetHexStr__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TInt_GetHexStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TInt_GetHexStr'.\n" + " Possible C/C++ prototypes are:\n" + " TInt::GetHexStr(int const &)\n" + " TInt::GetHexStr(TInt const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetKiloStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetKiloStr" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = TInt::GetKiloStr((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_GetMegaStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TInt_GetMegaStr" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = TInt::GetMegaStr((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_SaveFrugalInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + char *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_SaveFrugalInt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_SaveFrugalInt" "', argument " "1"" of type '" "char *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TInt_SaveFrugalInt" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (char *)TInt::SaveFrugalInt(arg1,arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_LoadFrugalInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int *arg2 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + char *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_LoadFrugalInt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_LoadFrugalInt" "', argument " "1"" of type '" "char *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_LoadFrugalInt" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_LoadFrugalInt" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + result = (char *)TInt::LoadFrugalInt(arg1,*arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_TestFrugalInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + + if (!SWIG_Python_UnpackTuple(args,"TInt_TestFrugalInt",0,0,0)) SWIG_fail; + TInt::TestFrugalInt(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_SaveFrugalIntV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSOut *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TInt_SaveFrugalIntV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_SaveFrugalIntV" "', argument " "1"" of type '" "TSOut &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_SaveFrugalIntV" "', argument " "1"" of type '" "TSOut &""'"); + } + arg1 = reinterpret_cast< TSOut * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_SaveFrugalIntV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_SaveFrugalIntV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + TInt::SaveFrugalIntV(*arg1,(TVec< TInt,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_LoadFrugalIntV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_LoadFrugalIntV" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_LoadFrugalIntV" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_LoadFrugalIntV" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_LoadFrugalIntV" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TInt_LoadFrugalIntV" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + TInt::LoadFrugalIntV(*arg1,*arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_LoadFrugalIntV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TInt_LoadFrugalIntV" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_LoadFrugalIntV" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TInt_LoadFrugalIntV" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TInt_LoadFrugalIntV" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + TInt::LoadFrugalIntV(*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TInt_LoadFrugalIntV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TInt_LoadFrugalIntV",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TInt_LoadFrugalIntV__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TInt_LoadFrugalIntV__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TInt_LoadFrugalIntV'.\n" + " Possible C/C++ prototypes are:\n" + " TInt::LoadFrugalIntV(TSIn &,TVec< TInt,int > &,bool)\n" + " TInt::LoadFrugalIntV(TSIn &,TVec< TInt,int > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TInt" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TInt, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TInt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TUInt_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + uint arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_Val_set" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUInt_Val_set" "', argument " "2"" of type '" "uint""'"); + } + arg2 = static_cast< uint >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_Val_get" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + result = (uint) ((arg1)->Val); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TUInt_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TUInt_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUInt_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(TUInt::Mn)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TUInt_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TUInt_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUInt_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(TUInt::Mx)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TUInt_Rnd_set(PyObject *_val) { + { + void *argp = 0; + int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_TRnd, 0 | 0); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""TUInt::Rnd""' of type '""TRnd""'"); + } + if (!argp) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""TUInt::Rnd""' of type '""TRnd""'"); + } else { + TRnd * temp; + temp = reinterpret_cast< TRnd * >(argp); + TUInt::Rnd = *temp; + if (SWIG_IsNewObj(res)) delete temp; + } + } + return 0; +fail: + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUInt_Rnd_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TUInt::Rnd), SWIGTYPE_p_TRnd, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_TUInt_Rnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) { + return Swig_var_TUInt_Rnd_get(); +} + + +SWIGINTERN PyObject *_wrap_TUInt_Rnd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + int res; + + res = Swig_var_TUInt_Rnd_set(args); + return !res ? SWIG_Py_Void() : NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TUInt *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TUInt *)new TUInt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + TUInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TUInt" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = (TUInt *)new TUInt((uint const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUInt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUInt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TUInt *)new TUInt(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUInt",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TUInt__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TUInt__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TUInt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUInt'.\n" + " Possible C/C++ prototypes are:\n" + " TUInt::TUInt()\n" + " TUInt::TUInt(uint const &)\n" + " TUInt::TUInt(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUInt_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_Load" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_Save" "', argument " "1"" of type '" "TUInt const *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TUInt const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_LoadXml" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUInt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_SaveXml" "', argument " "1"" of type '" "TUInt const *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUInt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TUInt const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___call__" "', argument " "1"" of type '" "TUInt const *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + result = (uint)((TUInt const *)arg1)->operator ()(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___call__" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + result = (uint *) &(arg1)->operator ()(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___call__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUInt___call__",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUInt___call____SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_TUInt___call____SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUInt___call__'.\n" + " Possible C/C++ prototypes are:\n" + " TUInt::operator ()() const\n" + " TUInt::operator ()()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUInt___invert__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUInt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___invert__" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + result = (TUInt *) &(arg1)->operator ~(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___iand__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + TUInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TUInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt___iand__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___iand__" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt___iand__" "', argument " "2"" of type '" "TUInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt___iand__" "', argument " "2"" of type '" "TUInt const &""'"); + } + arg2 = reinterpret_cast< TUInt * >(argp2); + result = (TUInt *) &(arg1)->operator &=((TUInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___ior__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + TUInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TUInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt___ior__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___ior__" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt___ior__" "', argument " "2"" of type '" "TUInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt___ior__" "', argument " "2"" of type '" "TUInt const &""'"); + } + arg2 = reinterpret_cast< TUInt * >(argp2); + result = (TUInt *) &(arg1)->operator |=((TUInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___ixor__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + TUInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TUInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt___ixor__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___ixor__" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt___ixor__" "', argument " "2"" of type '" "TUInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt___ixor__" "', argument " "2"" of type '" "TUInt const &""'"); + } + arg2 = reinterpret_cast< TUInt * >(argp2); + result = (TUInt *) &(arg1)->operator ^=((TUInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___irshift__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TUInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt___irshift__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___irshift__" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUInt___irshift__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TUInt *) &(arg1)->operator >>=((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt___ilshift__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TUInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt___ilshift__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt___ilshift__" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUInt___ilshift__" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TUInt *) &(arg1)->operator <<=((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_GetMemUsed" "', argument " "1"" of type '" "TUInt const *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + result = (int)((TUInt const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_GetPrimHashCd" "', argument " "1"" of type '" "TUInt const *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + result = (int)((TUInt const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_GetSecHashCd" "', argument " "1"" of type '" "TUInt const *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + result = (int)((TUInt const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetRnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + uint result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUInt_GetRnd" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = (uint)TUInt::GetRnd((unsigned int const &)*arg1); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetRnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + uint result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (uint)TUInt::GetRnd(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetRnd(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUInt_GetRnd",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TUInt_GetRnd__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TUInt_GetRnd__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUInt_GetRnd'.\n" + " Possible C/C++ prototypes are:\n" + " TUInt::GetRnd(uint const &)\n" + " TUInt::GetRnd()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetKiloStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUInt_GetKiloStr" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = TUInt::GetKiloStr((unsigned int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetMegaStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUInt_GetMegaStr" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = TUInt::GetMegaStr((unsigned int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_JavaUIntToCppUInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUInt_JavaUIntToCppUInt" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = (uint)TUInt::JavaUIntToCppUInt((unsigned int const &)*arg1); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + uint *arg2 = 0 ; + char *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + char temp3 ; + char val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt_IsIpStr" "', argument " "2"" of type '" "uint &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpStr" "', argument " "2"" of type '" "uint &""'"); + } + arg2 = reinterpret_cast< uint * >(argp2); + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TUInt_IsIpStr" "', argument " "3"" of type '" "char""'"); + } + temp3 = static_cast< char >(val3); + arg3 = &temp3; + result = (bool)TUInt::IsIpStr((TStr const &)*arg1,*arg2,(char const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + uint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt_IsIpStr" "', argument " "2"" of type '" "uint &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpStr" "', argument " "2"" of type '" "uint &""'"); + } + arg2 = reinterpret_cast< uint * >(argp2); + result = (bool)TUInt::IsIpStr((TStr const &)*arg1,*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpStr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUInt_IsIpStr" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (bool)TUInt::IsIpStr((TStr const &)*arg1,(char const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpStr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)TUInt::IsIpStr((TStr const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUInt_IsIpStr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUInt_IsIpStr__SWIG_3(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TUInt_IsIpStr__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TUInt_IsIpStr__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TUInt_IsIpStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUInt_IsIpStr'.\n" + " Possible C/C++ prototypes are:\n" + " TUInt::IsIpStr(TStr const &,uint &,char const &)\n" + " TUInt::IsIpStr(TStr const &,uint &)\n" + " TUInt::IsIpStr(TStr const &,char const &)\n" + " TUInt::IsIpStr(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetUIntFromIpStr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + uint result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_GetUIntFromIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_GetUIntFromIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUInt_GetUIntFromIpStr" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (uint)TUInt::GetUIntFromIpStr((TStr const &)*arg1,(char const &)*arg2); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetUIntFromIpStr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + uint result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_GetUIntFromIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_GetUIntFromIpStr" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (uint)TUInt::GetUIntFromIpStr((TStr const &)*arg1); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetUIntFromIpStr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUInt_GetUIntFromIpStr",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUInt_GetUIntFromIpStr__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUInt_GetUIntFromIpStr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUInt_GetUIntFromIpStr'.\n" + " Possible C/C++ prototypes are:\n" + " TUInt::GetUIntFromIpStr(TStr const &,char const &)\n" + " TUInt::GetUIntFromIpStr(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUInt_GetStrFromIpUInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUInt_GetStrFromIpUInt" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + result = TUInt::GetStrFromIpUInt((unsigned int const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpv6Str__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + char *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2 ; + char val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_IsIpv6Str" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpv6Str" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUInt_IsIpv6Str" "', argument " "2"" of type '" "char""'"); + } + temp2 = static_cast< char >(val2); + arg2 = &temp2; + result = (bool)TUInt::IsIpv6Str((TStr const &)*arg1,(char const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpv6Str__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt_IsIpv6Str" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt_IsIpv6Str" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = (bool)TUInt::IsIpv6Str((TStr const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt_IsIpv6Str(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TUInt_IsIpv6Str",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TUInt_IsIpv6Str__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TUInt_IsIpv6Str__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TUInt_IsIpv6Str'.\n" + " Possible C/C++ prototypes are:\n" + " TUInt::IsIpv6Str(TStr const &,char const &)\n" + " TUInt::IsIpv6Str(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TUInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt *arg1 = (TUInt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUInt" "', argument " "1"" of type '" "TUInt *""'"); + } + arg1 = reinterpret_cast< TUInt * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUInt, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUInt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TUInt64_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + uint64 arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt64_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_Val_set" "', argument " "1"" of type '" "TUInt64 *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUInt64_Val_set" "', argument " "2"" of type '" "uint64""'"); + } + arg2 = static_cast< uint64 >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint64 result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_Val_get" "', argument " "1"" of type '" "TUInt64 *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = (uint64) ((arg1)->Val); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TUInt64_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TUInt64_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUInt64_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TUInt64::Mn), SWIGTYPE_p_TUInt64, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TUInt64_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TUInt64_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TUInt64_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TUInt64::Mx), SWIGTYPE_p_TUInt64, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt64__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TUInt64 *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TUInt64 *)new TUInt64(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt64__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUInt64 *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUInt64 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TUInt64, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUInt64" "', argument " "1"" of type '" "TUInt64 const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUInt64" "', argument " "1"" of type '" "TUInt64 const &""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = (TUInt64 *)new TUInt64((TUInt64 const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt64__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint64 *arg1 = 0 ; + uint64 temp1 ; + unsigned long long val1 ; + int ecode1 = 0 ; + TUInt64 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TUInt64" "', argument " "1"" of type '" "uint64""'"); + } + temp1 = static_cast< uint64 >(val1); + arg1 = &temp1; + result = (TUInt64 *)new TUInt64((uint64 const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt64__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + uint *arg1 = 0 ; + uint *arg2 = 0 ; + uint temp1 ; + unsigned int val1 ; + int ecode1 = 0 ; + uint temp2 ; + unsigned int val2 ; + int ecode2 = 0 ; + TUInt64 *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TUInt64" "', argument " "1"" of type '" "uint""'"); + } + temp1 = static_cast< uint >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TUInt64" "', argument " "2"" of type '" "uint""'"); + } + temp2 = static_cast< uint >(val2); + arg2 = &temp2; + result = (TUInt64 *)new TUInt64((uint const &)*arg1,(uint const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt64__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + void *arg1 = (void *) 0 ; + int res1 ; + TUInt64 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUInt64" "', argument " "1"" of type '" "void *""'"); + } + result = (TUInt64 *)new TUInt64(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt64__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUInt64 *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUInt64" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUInt64" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TUInt64 *)new TUInt64(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUInt64(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUInt64",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TUInt64__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TUInt64, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TUInt64__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TUInt64__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + int _v = 0; + { + void *ptr = 0; + int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_new_TUInt64__SWIG_4(self, argc, argv); + } +check_4: + + if (argc == 1) { + return _wrap_new_TUInt64__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TUInt64__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUInt64'.\n" + " Possible C/C++ prototypes are:\n" + " TUInt64::TUInt64()\n" + " TUInt64::TUInt64(TUInt64 const &)\n" + " TUInt64::TUInt64(uint64 const &)\n" + " TUInt64::TUInt64(uint const &,uint const &)\n" + " TUInt64::TUInt64(void *)\n" + " TUInt64::TUInt64(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt64_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_Load" "', argument " "1"" of type '" "TUInt64 *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt64_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt64_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_Save" "', argument " "1"" of type '" "TUInt64 const *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt64_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TUInt64 const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt64_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_LoadXml" "', argument " "1"" of type '" "TUInt64 *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt64_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUInt64_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt64_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_SaveXml" "', argument " "1"" of type '" "TUInt64 const *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt64_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TUInt64_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TUInt64 const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + TUInt64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TUInt64 *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt64___iadd__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64___iadd__" "', argument " "1"" of type '" "TUInt64 *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUInt64, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt64___iadd__" "', argument " "2"" of type '" "TUInt64 const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64___iadd__" "', argument " "2"" of type '" "TUInt64 const &""'"); + } + arg2 = reinterpret_cast< TUInt64 * >(argp2); + result = (TUInt64 *) &(arg1)->operator +=((TUInt64 const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + TUInt64 *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TUInt64 *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TUInt64___isub__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64___isub__" "', argument " "1"" of type '" "TUInt64 *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUInt64, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUInt64___isub__" "', argument " "2"" of type '" "TUInt64 const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64___isub__" "', argument " "2"" of type '" "TUInt64 const &""'"); + } + arg2 = reinterpret_cast< TUInt64 * >(argp2); + result = (TUInt64 *) &(arg1)->operator -=((TUInt64 const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUInt64, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_GetMemUsed" "', argument " "1"" of type '" "TUInt64 const *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = (int)((TUInt64 const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_GetPrimHashCd" "', argument " "1"" of type '" "TUInt64 const *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = (int)((TUInt64 const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_GetSecHashCd" "', argument " "1"" of type '" "TUInt64 const *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = (int)((TUInt64 const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetMsVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_GetMsVal" "', argument " "1"" of type '" "TUInt64 const *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = (uint)((TUInt64 const *)arg1)->GetMsVal(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetLsVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_GetLsVal" "', argument " "1"" of type '" "TUInt64 const *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = (uint)((TUInt64 const *)arg1)->GetLsVal(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetHexStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TUInt64, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUInt64_GetHexStr" "', argument " "1"" of type '" "TUInt64 const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUInt64_GetHexStr" "', argument " "1"" of type '" "TUInt64 const &""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + result = TUInt64::GetHexStr((TUInt64 const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetKiloStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + uint64 *arg1 = 0 ; + uint64 temp1 ; + unsigned long long val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUInt64_GetKiloStr" "', argument " "1"" of type '" "uint64""'"); + } + temp1 = static_cast< uint64 >(val1); + arg1 = &temp1; + result = TUInt64::GetKiloStr((unsigned long long const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUInt64_GetMegaStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + uint64 *arg1 = 0 ; + uint64 temp1 ; + unsigned long long val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TUInt64_GetMegaStr" "', argument " "1"" of type '" "uint64""'"); + } + temp1 = static_cast< uint64 >(val1); + arg1 = &temp1; + result = TUInt64::GetMegaStr((unsigned long long const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TUInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUInt64 *arg1 = (TUInt64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUInt64, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUInt64" "', argument " "1"" of type '" "TUInt64 *""'"); + } + arg1 = reinterpret_cast< TUInt64 * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUInt64_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUInt64, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUInt64_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TFlt_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_Val_set" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_Val_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_Val_get" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + result = (double) ((arg1)->Val); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TFlt_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFlt_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFlt_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_double(static_cast< double >(TFlt::Mn)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFlt_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFlt_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFlt_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_double(static_cast< double >(TFlt::Mx)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFlt_NInf_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFlt_NInf is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFlt_NInf_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_double(static_cast< double >(TFlt::NInf)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFlt_PInf_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFlt_PInf is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFlt_PInf_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_double(static_cast< double >(TFlt::PInf)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFlt_Eps_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFlt_Eps is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFlt_Eps_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_double(static_cast< double >(TFlt::Eps)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFlt_EpsHalf_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TFlt_EpsHalf is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFlt_EpsHalf_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_double(static_cast< double >(TFlt::EpsHalf)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TFlt_Rnd_set(PyObject *_val) { + { + void *argp = 0; + int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_TRnd, 0 | 0); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""TFlt::Rnd""' of type '""TRnd""'"); + } + if (!argp) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""TFlt::Rnd""' of type '""TRnd""'"); + } else { + TRnd * temp; + temp = reinterpret_cast< TRnd * >(argp); + TFlt::Rnd = *temp; + if (SWIG_IsNewObj(res)) delete temp; + } + } + return 0; +fail: + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TFlt_Rnd_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TFlt::Rnd), SWIGTYPE_p_TRnd, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Rnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) { + return Swig_var_TFlt_Rnd_get(); +} + + +SWIGINTERN PyObject *_wrap_TFlt_Rnd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + int res; + + res = Swig_var_TFlt_Rnd_set(args); + return !res ? SWIG_Py_Void() : NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFlt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TFlt *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TFlt *)new TFlt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFlt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + TFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TFlt" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (TFlt *)new TFlt((double const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFlt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TFlt *)new TFlt(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_Save" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TFlt const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFlt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + TFlt *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TFlt" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (TFlt *)new TFlt(*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFlt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TFlt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TFlt__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TFlt__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TFlt__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TFlt__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TFlt'.\n" + " Possible C/C++ prototypes are:\n" + " TFlt::TFlt()\n" + " TFlt::TFlt(double const &)\n" + " TFlt::TFlt(TSIn &)\n" + " TFlt::TFlt(TSIn &,bool const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_Load" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFlt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + TSOut *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_Save" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFlt_Save" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ((TFlt const *)arg1)->Save(*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Save(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFlt_Save",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TFlt_Save__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TFlt_Save__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFlt_Save'.\n" + " Possible C/C++ prototypes are:\n" + " TFlt::Save(TSOut &) const\n" + " TFlt::Save(TSOut &,bool const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFlt_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_LoadXml" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFlt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFlt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_SaveXml" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFlt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFlt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TFlt const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + TFlt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___eq__" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TFlt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFlt___eq__" "', argument " "2"" of type '" "TFlt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFlt___eq__" "', argument " "2"" of type '" "TFlt const &""'"); + } + arg2 = reinterpret_cast< TFlt * >(argp2); + result = (bool)((TFlt const *)arg1)->operator ==((TFlt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___eq__" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt___eq__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (bool)((TFlt const *)arg1)->operator ==((double const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___eq__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFlt___eq__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TFlt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TFlt___eq____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TFlt___eq____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TFlt___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TFlt___ne__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___ne__" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt___ne__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (bool)((TFlt const *)arg1)->operator !=((double const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___call__" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + result = (double)((TFlt const *)arg1)->operator ()(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt___iadd__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___iadd__" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt___iadd__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TFlt *) &(arg1)->operator +=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt___isub__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___isub__" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt___isub__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TFlt *) &(arg1)->operator -=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt___imul__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___imul__" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt___imul__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TFlt *) &(arg1)->operator *=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TFlt___idiv__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt___idiv__" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt___idiv__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TFlt *) &(arg1)->operator /=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_GetMemUsed" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + result = (int)((TFlt const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_GetPrimHashCd" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + result = (int)((TFlt const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_GetSecHashCd" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + result = (int)((TFlt const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_Abs" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (double)TFlt::Abs((double const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_Sign" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (int)TFlt::Sign((double const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Round(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_Round" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (int)TFlt::Round((double const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetRnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_GetRnd",0,0,0)) SWIG_fail; + result = (double)TFlt::GetRnd(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_Eq6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_Eq6",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_Eq6" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_Eq6" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (bool)TFlt::Eq6((double const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetMn" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetMn" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)TFlt::GetMn((double const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetMn" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetMn" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFlt_GetMn" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = (double)TFlt::GetMn((double const &)*arg1,(double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMn__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + double result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetMn" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetMn" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFlt_GetMn" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TFlt_GetMn" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + result = (double)TFlt::GetMn((double const &)*arg1,(double const &)*arg2,(double const &)*arg3,(double const &)*arg4); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFlt_GetMn",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TFlt_GetMn__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TFlt_GetMn__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TFlt_GetMn__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFlt_GetMn'.\n" + " Possible C/C++ prototypes are:\n" + " TFlt::GetMn(double const &,double const &)\n" + " TFlt::GetMn(double const &,double const &,double const &)\n" + " TFlt::GetMn(double const &,double const &,double const &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetMx" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetMx" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (double)TFlt::GetMx((double const &)*arg1,(double const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double arg3 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + double result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetMx" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetMx" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFlt_GetMx" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + result = (double)TFlt::GetMx((double const &)*arg1,(double const &)*arg2,arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMx__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double arg3 ; + double *arg4 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + double result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetMx" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetMx" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFlt_GetMx" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TFlt_GetMx" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + result = (double)TFlt::GetMx((double const &)*arg1,(double const &)*arg2,arg3,(double const &)*arg4); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMx(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFlt_GetMx",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TFlt_GetMx__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TFlt_GetMx__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TFlt_GetMx__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFlt_GetMx'.\n" + " Possible C/C++ prototypes are:\n" + " TFlt::GetMx(double const &,double const &)\n" + " TFlt::GetMx(double const &,double const &,double const)\n" + " TFlt::GetMx(double const &,double const &,double const,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetInRng(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + double result; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_GetInRng",3,3,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetInRng" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetInRng" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFlt_GetInRng" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = (double)TFlt::GetInRng((double const &)*arg1,(double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_IsNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_IsNum" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (bool)TFlt::IsNum((double const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_IsNan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_IsNan" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (bool)TFlt::IsNan((double const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_IsNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_IsNum" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + result = (bool)((TFlt const *)arg1)->IsNum(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_IsNum(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFlt_IsNum",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TFlt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TFlt_IsNum__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TFlt_IsNum__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFlt_IsNum'.\n" + " Possible C/C++ prototypes are:\n" + " TFlt::IsNum(double const &)\n" + " TFlt::IsNum() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFlt_IsNan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFlt_IsNan" "', argument " "1"" of type '" "TFlt const *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + result = (bool)((TFlt const *)arg1)->IsNan(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_IsNan(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TFlt_IsNan",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TFlt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TFlt_IsNan__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_TFlt_IsNan__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TFlt_IsNan'.\n" + " Possible C/C++ prototypes are:\n" + " TFlt::IsNan(double const &)\n" + " TFlt::IsNan() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetPrcStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TFlt_GetPrcStr",2,2,swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetPrcStr" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFlt_GetPrcStr" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = TFlt::GetPrcStr((double const &)*arg1,(double const &)*arg2); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetKiloStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetKiloStr" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = TFlt::GetKiloStr((double const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetMegaStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetMegaStr" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = TFlt::GetMegaStr((double const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFlt_GetGigaStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + TStr result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TFlt_GetGigaStr" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = TFlt::GetGigaStr((double const &)*arg1); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFlt *arg1 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TFlt" "', argument " "1"" of type '" "TFlt *""'"); + } + arg1 = reinterpret_cast< TFlt * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TFlt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TFlt, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TFlt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TAscFlt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TAscFlt *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TAscFlt *)new TAscFlt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TAscFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TAscFlt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + TAscFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TAscFlt" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + result = (TAscFlt *)new TAscFlt((double const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TAscFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TAscFlt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TAscFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TAscFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TAscFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TAscFlt *)new TAscFlt(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TAscFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TAscFlt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TAscFlt",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TAscFlt__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TAscFlt__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TAscFlt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TAscFlt'.\n" + " Possible C/C++ prototypes are:\n" + " TAscFlt::TAscFlt()\n" + " TAscFlt::TAscFlt(double const &)\n" + " TAscFlt::TAscFlt(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TAscFlt_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TAscFlt *arg1 = (TAscFlt *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TAscFlt_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TAscFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TAscFlt_Save" "', argument " "1"" of type '" "TAscFlt const *""'"); + } + arg1 = reinterpret_cast< TAscFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TAscFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TAscFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TAscFlt const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TAscFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TAscFlt *arg1 = (TAscFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TAscFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TAscFlt" "', argument " "1"" of type '" "TAscFlt *""'"); + } + arg1 = reinterpret_cast< TAscFlt * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TAscFlt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TAscFlt, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TAscFlt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TSFlt_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + sdouble arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + float val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_Val_set" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + ecode2 = SWIG_AsVal_float(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSFlt_Val_set" "', argument " "2"" of type '" "sdouble""'"); + } + arg2 = static_cast< sdouble >(val2); + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + sdouble result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_Val_get" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + result = (sdouble) ((arg1)->Val); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TSFlt_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TSFlt_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TSFlt_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_float(static_cast< float >(TSFlt::Mn)); + return pyobj; +} + + +SWIGINTERN int Swig_var_TSFlt_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TSFlt_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TSFlt_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_float(static_cast< float >(TSFlt::Mx)); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_new_TSFlt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TSFlt *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TSFlt *)new TSFlt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSFlt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + sdouble *arg1 = 0 ; + sdouble temp1 ; + float val1 ; + int ecode1 = 0 ; + TSFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TSFlt" "', argument " "1"" of type '" "sdouble""'"); + } + temp1 = static_cast< sdouble >(val1); + arg1 = &temp1; + result = (TSFlt *)new TSFlt((sdouble const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSFlt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TSFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TSFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TSFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TSFlt *)new TSFlt(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TSFlt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TSFlt",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TSFlt__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TSFlt__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TSFlt__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TSFlt'.\n" + " Possible C/C++ prototypes are:\n" + " TSFlt::TSFlt()\n" + " TSFlt::TSFlt(sdouble const &)\n" + " TSFlt::TSFlt(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TSFlt_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_Save" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TSFlt const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_LoadXml" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSFlt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSFlt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TSFlt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSFlt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_SaveXml" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSFlt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSFlt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TSFlt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSFlt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TSFlt const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + TSFlt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___eq__" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSFlt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSFlt___eq__" "', argument " "2"" of type '" "TSFlt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSFlt___eq__" "', argument " "2"" of type '" "TSFlt const &""'"); + } + arg2 = reinterpret_cast< TSFlt * >(argp2); + result = (bool)((TSFlt const *)arg1)->operator ==((TSFlt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___eq__" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSFlt___eq__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (bool)((TSFlt const *)arg1)->operator ==((double const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___eq__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TSFlt___eq__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TSFlt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TSFlt___eq____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TSFlt___eq____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt___ne__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___ne__" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSFlt___ne__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (bool)((TSFlt const *)arg1)->operator !=((double const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + TSFlt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___lt__" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSFlt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TSFlt___lt__" "', argument " "2"" of type '" "TSFlt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TSFlt___lt__" "', argument " "2"" of type '" "TSFlt const &""'"); + } + arg2 = reinterpret_cast< TSFlt * >(argp2); + result = (bool)((TSFlt const *)arg1)->operator <((TSFlt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + sdouble result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___call__" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + result = (sdouble)((TSFlt const *)arg1)->operator ()(); + resultobj = SWIG_From_float(static_cast< float >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TSFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt___iadd__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___iadd__" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSFlt___iadd__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TSFlt *) &(arg1)->operator +=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TSFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt___isub__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___isub__" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSFlt___isub__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TSFlt *) &(arg1)->operator -=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TSFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt___imul__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___imul__" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSFlt___imul__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TSFlt *) &(arg1)->operator *=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + double *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TSFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TSFlt___idiv__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt___idiv__" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TSFlt___idiv__" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + result = (TSFlt *) &(arg1)->operator /=((double const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TSFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_GetMemUsed" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + result = (int)((TSFlt const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_GetPrimHashCd" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + result = (int)((TSFlt const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TSFlt_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TSFlt_GetSecHashCd" "', argument " "1"" of type '" "TSFlt const *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + result = (int)((TSFlt const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TSFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSFlt *arg1 = (TSFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TSFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TSFlt" "', argument " "1"" of type '" "TSFlt *""'"); + } + arg1 = reinterpret_cast< TSFlt * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TSFlt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TSFlt, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TSFlt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TLFlt_Val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + ldouble arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt_Val_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_Val_set" "', argument " "1"" of type '" "TLFlt *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt_Val_set" "', argument " "2"" of type '" "ldouble""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt_Val_set" "', argument " "2"" of type '" "ldouble""'"); + } else { + ldouble * temp = reinterpret_cast< ldouble * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (arg1) (arg1)->Val = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt_Val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ldouble result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_Val_get" "', argument " "1"" of type '" "TLFlt *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + result = (ldouble) ((arg1)->Val); + resultobj = SWIG_NewPointerObj((new ldouble(static_cast< const ldouble& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_TLFlt_Mn_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TLFlt_Mn is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TLFlt_Mn_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TLFlt::Mn), SWIGTYPE_p_long_double, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_TLFlt_Mx_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable TLFlt_Mx is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_TLFlt_Mx_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&TLFlt::Mx), SWIGTYPE_p_long_double, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_new_TLFlt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TLFlt *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TLFlt *)new TLFlt(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TLFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TLFlt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ldouble *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TLFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TLFlt" "', argument " "1"" of type '" "ldouble const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TLFlt" "', argument " "1"" of type '" "ldouble const &""'"); + } + arg1 = reinterpret_cast< ldouble * >(argp1); + result = (TLFlt *)new TLFlt((ldouble const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TLFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TLFlt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TLFlt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TLFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TLFlt" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TLFlt *)new TLFlt(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TLFlt, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TLFlt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TLFlt",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TLFlt__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_long_double, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TLFlt__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TLFlt__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TLFlt'.\n" + " Possible C/C++ prototypes are:\n" + " TLFlt::TLFlt()\n" + " TLFlt::TLFlt(ldouble const &)\n" + " TLFlt::TLFlt(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TLFlt_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_Save" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TLFlt const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_LoadXml" "', argument " "1"" of type '" "TLFlt *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TLFlt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_SaveXml" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TLFlt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TLFlt const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + TLFlt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt___eq__" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TLFlt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt___eq__" "', argument " "2"" of type '" "TLFlt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt___eq__" "', argument " "2"" of type '" "TLFlt const &""'"); + } + arg2 = reinterpret_cast< TLFlt * >(argp2); + result = (bool)((TLFlt const *)arg1)->operator ==((TLFlt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + ldouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt___eq__" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt___eq__" "', argument " "2"" of type '" "ldouble const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt___eq__" "', argument " "2"" of type '" "ldouble const &""'"); + } + arg2 = reinterpret_cast< ldouble * >(argp2); + result = (bool)((TLFlt const *)arg1)->operator ==((ldouble const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___eq__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TLFlt___eq__",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TLFlt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TLFlt___eq____SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TLFlt___eq____SWIG_1(self, argc, argv); + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + ldouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt___ne__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt___ne__" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt___ne__" "', argument " "2"" of type '" "ldouble const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt___ne__" "', argument " "2"" of type '" "ldouble const &""'"); + } + arg2 = reinterpret_cast< ldouble * >(argp2); + result = (bool)((TLFlt const *)arg1)->operator !=((ldouble const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + TLFlt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt___lt__" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TLFlt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt___lt__" "', argument " "2"" of type '" "TLFlt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt___lt__" "', argument " "2"" of type '" "TLFlt const &""'"); + } + arg2 = reinterpret_cast< TLFlt * >(argp2); + result = (bool)((TLFlt const *)arg1)->operator <((TLFlt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ldouble result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt___call__" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + result = (ldouble)((TLFlt const *)arg1)->operator ()(); + resultobj = SWIG_NewPointerObj((new ldouble(static_cast< const ldouble& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + ldouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TLFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt___iadd__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt___iadd__" "', argument " "1"" of type '" "TLFlt *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt___iadd__" "', argument " "2"" of type '" "ldouble const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt___iadd__" "', argument " "2"" of type '" "ldouble const &""'"); + } + arg2 = reinterpret_cast< ldouble * >(argp2); + result = (TLFlt *) &(arg1)->operator +=((ldouble const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TLFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + ldouble *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TLFlt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TLFlt___isub__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt___isub__" "', argument " "1"" of type '" "TLFlt *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_double, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TLFlt___isub__" "', argument " "2"" of type '" "ldouble const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TLFlt___isub__" "', argument " "2"" of type '" "ldouble const &""'"); + } + arg2 = reinterpret_cast< ldouble * >(argp2); + result = (TLFlt *) &(arg1)->operator -=((ldouble const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TLFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_GetMemUsed" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + result = (int)((TLFlt const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_GetPrimHashCd" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + result = (int)((TLFlt const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TLFlt_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TLFlt_GetSecHashCd" "', argument " "1"" of type '" "TLFlt const *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + result = (int)((TLFlt const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TLFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TLFlt *arg1 = (TLFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TLFlt, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TLFlt" "', argument " "1"" of type '" "TLFlt *""'"); + } + arg1 = reinterpret_cast< TLFlt * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TLFlt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TLFlt, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TLFlt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TFltRect_MnX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + TFlt *arg2 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_MnX_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MnX_set" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_MnX_set" "', argument " "2"" of type '" "TFlt *""'"); + } + arg2 = reinterpret_cast< TFlt * >(argp2); + if (arg1) (arg1)->MnX = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_MnX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TFlt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MnX_get" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (TFlt *)& ((arg1)->MnX); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_MnY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + TFlt *arg2 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_MnY_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MnY_set" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_MnY_set" "', argument " "2"" of type '" "TFlt *""'"); + } + arg2 = reinterpret_cast< TFlt * >(argp2); + if (arg1) (arg1)->MnY = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_MnY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TFlt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MnY_get" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (TFlt *)& ((arg1)->MnY); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_MxX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + TFlt *arg2 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_MxX_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MxX_set" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_MxX_set" "', argument " "2"" of type '" "TFlt *""'"); + } + arg2 = reinterpret_cast< TFlt * >(argp2); + if (arg1) (arg1)->MxX = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_MxX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TFlt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MxX_get" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (TFlt *)& ((arg1)->MxX); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_MxY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + TFlt *arg2 = (TFlt *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_MxY_set",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MxY_set" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TFlt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_MxY_set" "', argument " "2"" of type '" "TFlt *""'"); + } + arg2 = reinterpret_cast< TFlt * >(argp2); + if (arg1) (arg1)->MxY = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_MxY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TFlt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_MxY_get" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (TFlt *)& ((arg1)->MxY); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFlt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFltRect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TFltRect *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TFltRect *)new TFltRect(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFltRect, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFltRect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltRect *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TFltRect *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TFltRect, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFltRect" "', argument " "1"" of type '" "TFltRect const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFltRect" "', argument " "1"" of type '" "TFltRect const &""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (TFltRect *)new TFltRect((TFltRect const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFltRect, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFltRect__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double *arg1 = 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double temp1 ; + double val1 ; + int ecode1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + double temp4 ; + double val4 ; + int ecode4 = 0 ; + TFltRect *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TFltRect" "', argument " "1"" of type '" "double""'"); + } + temp1 = static_cast< double >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TFltRect" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TFltRect" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TFltRect" "', argument " "4"" of type '" "double""'"); + } + temp4 = static_cast< double >(val4); + arg4 = &temp4; + result = (TFltRect *)new TFltRect((double const &)*arg1,(double const &)*arg2,(double const &)*arg3,(double const &)*arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFltRect, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFltRect__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TFltRect *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TFltRect" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TFltRect" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TFltRect *)new TFltRect(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TFltRect, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TFltRect(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TFltRect",0,4,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TFltRect__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TFltRect, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TFltRect__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TFltRect__SWIG_3(self, argc, argv); + } + if (argc == 4) { + return _wrap_new_TFltRect__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TFltRect'.\n" + " Possible C/C++ prototypes are:\n" + " TFltRect::TFltRect()\n" + " TFltRect::TFltRect(TFltRect const &)\n" + " TFltRect::TFltRect(double const &,double const &,double const &,double const &)\n" + " TFltRect::TFltRect(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_Save" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFltRect_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TFltRect const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_LoadXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_LoadXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_LoadXml" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFltRect_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFltRect_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFltRect_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_SaveXml" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFltRect_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TFltRect_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFltRect_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TFltRect const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetMnX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetMnX" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetMnX(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetMnY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetMnY" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetMnY(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetMxX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetMxX" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetMxX(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetMxY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetMxY" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetMxY(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetXLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetXLen" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetXLen(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetYLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetYLen" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetYLen(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetXCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetXCenter" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetXCenter(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_GetYCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_GetYCenter" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + result = (double)((TFltRect const *)arg1)->GetYCenter(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_IsXYIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double temp2 ; + double val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_IsXYIn",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_IsXYIn" "', argument " "1"" of type '" "TFltRect const *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TFltRect_IsXYIn" "', argument " "2"" of type '" "double""'"); + } + temp2 = static_cast< double >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TFltRect_IsXYIn" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = (bool)((TFltRect const *)arg1)->IsXYIn((double const &)*arg2,(double const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TFltRect_Intersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = 0 ; + TFltRect *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TFltRect_Intersection",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TFltRect, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TFltRect_Intersection" "', argument " "1"" of type '" "TFltRect const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFltRect_Intersection" "', argument " "1"" of type '" "TFltRect const &""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TFltRect, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TFltRect_Intersection" "', argument " "2"" of type '" "TFltRect const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TFltRect_Intersection" "', argument " "2"" of type '" "TFltRect const &""'"); + } + arg2 = reinterpret_cast< TFltRect * >(argp2); + result = (bool)TFltRect::Intersection((TFltRect const &)*arg1,(TFltRect const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TFltRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TFltRect *arg1 = (TFltRect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TFltRect, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TFltRect" "', argument " "1"" of type '" "TFltRect *""'"); + } + arg1 = reinterpret_cast< TFltRect * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TFltRect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TFltRect, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TFltRect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TIntV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TVec< TInt,int > *)new TVec< TInt,int >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (TVec< TInt,int > *)new TVec< TInt,int >((TVec< TInt,int > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntV" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TVec< TInt,int > *)new TVec< TInt,int >((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntV" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TIntV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TInt,int > *)new TVec< TInt,int >((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntV__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = (TInt *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntV" "', argument " "1"" of type '" "TInt *""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TIntV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TInt,int > *)new TVec< TInt,int >(arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TIntV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TIntV" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntV__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntV" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntV" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TVec< TInt,int > *)new TVec< TInt,int >(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TIntV",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TIntV__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TIntV__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TIntV__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TIntV__SWIG_2(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_new_TIntV__SWIG_4(self, argc, argv); + } +check_5: + + if (argc == 2) { + return _wrap_new_TIntV__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TIntV'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::TVec()\n" + " TVec< TInt,int >::TVec(TVec< TInt,int > const &)\n" + " TVec< TInt,int >::TVec(int const &)\n" + " TVec< TInt,int >::TVec(int const &,int const &)\n" + " TVec< TInt,int >::TVec(TInt *,int const &)\n" + " TVec< TInt,int >::TVec(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Load" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Save" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TVec< TInt,int > const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_LoadXml__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_LoadXml" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_LoadXml__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + PXmlTok *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_LoadXml" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + (arg1)->LoadXml((PXmlTok const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_LoadXml(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_LoadXml",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_LoadXml__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_LoadXml__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_LoadXml'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::LoadXml(PXmlTok const &,TStr const &)\n" + " TVec< TInt,int >::LoadXml(PXmlTok const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SaveXml" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TVec< TInt,int > const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TInt,int > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV___add__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV___add__" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV___add__" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV___add__" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TVec< TInt,int > *) &(arg1)->operator +((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV___eq__" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV___eq__" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV___eq__" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (bool)((TVec< TInt,int > const *)arg1)->operator ==((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV___lt__" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV___lt__" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV___lt__" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (bool)((TVec< TInt,int > const *)arg1)->operator <((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetMemUsed" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetMemSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetMemSize" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->GetMemSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetPrimHashCd" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetSecHashCd" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Gen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Gen" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Gen((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Gen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Gen" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Gen" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Gen((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Gen(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Gen",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_Gen__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Gen__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Gen'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Gen(int const &)\n" + " TVec< TInt,int >::Gen(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GenExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = (TInt *) 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_GenExt",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GenExt" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GenExt" "', argument " "2"" of type '" "TInt *""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_GenExt" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->GenExt(arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_IsExt" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (bool)((TVec< TInt,int > const *)arg1)->IsExt(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Reserve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Reserve" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Reserve((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Reserve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Reserve" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Reserve(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Reserve",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_Reserve__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Reserve__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Reserve'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Reserve(int const &)\n" + " TVec< TInt,int >::Reserve(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Clr" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Clr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Clr((bool const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Clr" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Clr((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Clr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Clr" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Clr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_Clr__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntV_Clr__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Clr(bool const &,int const &)\n" + " TVec< TInt,int >::Clr(bool const &)\n" + " TVec< TInt,int >::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Trunc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Trunc" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Trunc" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Trunc((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Trunc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Trunc" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + (arg1)->Trunc(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Trunc(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Trunc",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_Trunc__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntV_Trunc__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Trunc'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Trunc(int const &)\n" + " TVec< TInt,int >::Trunc()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Pack" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + (arg1)->Pack(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_MoveFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_MoveFrom",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_MoveFrom" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_MoveFrom" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_MoveFrom" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + (arg1)->MoveFrom(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Swap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Swap" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Swap" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Swap" "', argument " "2"" of type '" "TVec< TInt,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + (arg1)->Swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Empty" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (bool)((TVec< TInt,int > const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Len" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Reserved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Reserved" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->Reserved(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Last__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Last" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (TInt *) &((TVec< TInt,int > const *)arg1)->Last(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Last__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Last" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (TInt *) &(arg1)->Last(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Last(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Last",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_Last__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TIntV_Last__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Last'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Last() const\n" + " TVec< TInt,int >::Last()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_LastValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_LastValN" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->LastValN(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_LastLast__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_LastLast" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (TInt *) &((TVec< TInt,int > const *)arg1)->LastLast(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_LastLast__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_LastLast" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (TInt *) &(arg1)->LastLast(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_LastLast(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_LastLast",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_LastLast__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TIntV_LastLast__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_LastLast'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::LastLast() const\n" + " TVec< TInt,int >::LastLast()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_BegI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TVec< TInt,int >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_BegI" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (TVec< TInt,int >::TIter)((TVec< TInt,int > const *)arg1)->BegI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_EndI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TVec< TInt,int >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_EndI" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (TVec< TInt,int >::TIter)((TVec< TInt,int > const *)arg1)->EndI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TInt,int >::TIter result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_GetI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetI" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_GetI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TInt,int >::TIter)((TVec< TInt,int > const *)arg1)->GetI((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Add" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)(arg1)->Add(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Add" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Add" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Add" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)(arg1)->Add((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Add__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Add" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Add" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Add" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Add" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->Add((TInt const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_AddV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddV" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)(arg1)->AddV((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddSorted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + bool *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddSorted" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_AddSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntV_AddSorted" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)(arg1)->AddSorted((TInt const &)*arg2,(bool const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddSorted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddSorted" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_AddSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddSorted((TInt const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddSorted__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddSorted" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)(arg1)->AddSorted((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddSorted(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_AddSorted",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_AddSorted__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_AddSorted__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TIntV_AddSorted__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_AddSorted'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::AddSorted(TInt const &,bool const &,int const &)\n" + " TVec< TInt,int >::AddSorted(TInt const &,bool const &)\n" + " TVec< TInt,int >::AddSorted(TInt const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddBackSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_AddBackSorted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddBackSorted" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddBackSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddBackSorted" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_AddBackSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddBackSorted((TInt const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddMerged__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddMerged" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddMerged" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddMerged" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)(arg1)->AddMerged((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddVMerged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_AddVMerged",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddVMerged" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddVMerged" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddVMerged" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)(arg1)->AddVMerged((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_AddUnique",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddUnique" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_AddUnique" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_AddUnique" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)(arg1)->AddUnique((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetVal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetVal" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_GetVal" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TInt *) &((TVec< TInt,int > const *)arg1)->GetVal((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetVal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetVal" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_GetVal" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TInt *) &(arg1)->GetVal((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetVal(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_GetVal",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_GetVal__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntV_GetVal__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_GetVal'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::GetVal(int const &) const\n" + " TVec< TInt,int >::GetVal(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetSubValV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_GetSubValV",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetSubValV" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_GetSubValV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_GetSubValV" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntV_GetSubValV" "', argument " "4"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetSubValV" "', argument " "4"" of type '" "TVec< TInt,int > &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + ((TVec< TInt,int > const *)arg1)->GetSubValV((int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Ins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + TInt *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_Ins",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Ins" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Ins" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_Ins" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Ins" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + (arg1)->Ins((int const &)*arg2,(TInt const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Del__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Del" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Del((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Del__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Del" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Del" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Del((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Del(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Del",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_Del__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Del__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Del'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Del(int const &)\n" + " TVec< TInt,int >::Del(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_DelLast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_DelLast" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + (arg1)->DelLast(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_DelIfIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_DelIfIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_DelIfIn" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_DelIfIn" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_DelIfIn" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)(arg1)->DelIfIn((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_DelAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_DelAll",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_DelAll" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_DelAll" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_DelAll" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + (arg1)->DelAll((TInt const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_PutAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_PutAll",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_PutAll" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_PutAll" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_PutAll" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + (arg1)->PutAll((TInt const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Swap" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Swap" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Swap" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Swap((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Swap(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Swap",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_Swap__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Swap__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Swap'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Swap(TVec< TInt,int > &)\n" + " TVec< TInt,int >::Swap(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SwapI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int >::TIter arg1 = (TVec< TInt,int >::TIter) 0 ; + TVec< TInt,int >::TIter arg2 = (TVec< TInt,int >::TIter) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_SwapI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SwapI" "', argument " "1"" of type '" "TVec< TInt,int >::TIter""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int >::TIter >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TInt, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SwapI" "', argument " "2"" of type '" "TVec< TInt,int >::TIter""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int >::TIter >(argp2); + TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR SwapI(arg1,arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_NextPerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_NextPerm" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (bool)(arg1)->NextPerm(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_PrevPerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_PrevPerm" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (bool)(arg1)->PrevPerm(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetPivotValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_GetPivotValN",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetPivotValN" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_GetPivotValN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_GetPivotValN" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TInt,int > const *)arg1)->GetPivotValN((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_BSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_BSort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_BSort" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_BSort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_BSort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntV_BSort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->BSort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_ISort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_ISort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_ISort" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_ISort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_ISort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntV_ISort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->ISort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Partition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_Partition",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Partition" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Partition" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Partition" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntV_Partition" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)(arg1)->Partition((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_QSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_QSort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_QSort" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_QSort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_QSort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntV_QSort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->QSort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Sort__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Sort" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Sort" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Sort((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Sort__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Sort" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + (arg1)->Sort(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Sort(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Sort",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_Sort__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntV_Sort__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Sort'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Sort(bool const &)\n" + " TVec< TInt,int >::Sort()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsSorted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_IsSorted" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_IsSorted" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TVec< TInt,int > const *)arg1)->IsSorted((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsSorted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_IsSorted" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (bool)((TVec< TInt,int > const *)arg1)->IsSorted(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsSorted(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_IsSorted",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_IsSorted__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntV_IsSorted__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_IsSorted'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::IsSorted(bool const &) const\n" + " TVec< TInt,int >::IsSorted() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Shuffle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_Shuffle",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Shuffle" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Shuffle" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Shuffle" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + (arg1)->Shuffle(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Reverse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Reverse" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + (arg1)->Reverse(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Reverse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Reverse" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Reverse" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_Reverse" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + (arg1)->Reverse(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Reverse(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Reverse",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_Reverse__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Reverse__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Reverse'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Reverse()\n" + " TVec< TInt,int >::Reverse(int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Merge" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + (arg1)->Merge(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Intrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Intrs" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Intrs" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Intrs" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + (arg1)->Intrs((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Union__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Union" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Union" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Union" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + (arg1)->Union((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Diff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Diff" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Diff" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Diff" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + (arg1)->Diff((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Intrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Intrs" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Intrs" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Intrs" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_Intrs" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Intrs" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + ((TVec< TInt,int > const *)arg1)->Intrs((TVec< TInt,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Intrs(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Intrs",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_Intrs__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Intrs__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Intrs'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Intrs(TVec< TInt,int > const &)\n" + " TVec< TInt,int >::Intrs(TVec< TInt,int > const &,TVec< TInt,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Union__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Union" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Union" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Union" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_Union" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Union" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + ((TVec< TInt,int > const *)arg1)->Union((TVec< TInt,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Union(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Union",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_Union__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Union__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Union'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Union(TVec< TInt,int > const &)\n" + " TVec< TInt,int >::Union(TVec< TInt,int > const &,TVec< TInt,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Diff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Diff" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Diff" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Diff" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_Diff" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Diff" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + ((TVec< TInt,int > const *)arg1)->Diff((TVec< TInt,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Diff(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Diff",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_Diff__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Diff__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Diff'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Diff(TVec< TInt,int > const &)\n" + " TVec< TInt,int >::Diff(TVec< TInt,int > const &,TVec< TInt,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IntrsLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_IntrsLen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_IntrsLen" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_IntrsLen" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_IntrsLen" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)((TVec< TInt,int > const *)arg1)->IntrsLen((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_UnionLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_UnionLen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_UnionLen" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_UnionLen" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_UnionLen" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)((TVec< TInt,int > const *)arg1)->UnionLen((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_Count",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Count" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_Count" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_Count" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)((TVec< TInt,int > const *)arg1)->Count((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchBin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SearchBin" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SearchBin" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchBin" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)((TVec< TInt,int > const *)arg1)->SearchBin((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchBin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SearchBin" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SearchBin" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchBin" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_SearchBin" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchBin" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (int)((TVec< TInt,int > const *)arg1)->SearchBin((TInt const &)*arg2,*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchBin(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_SearchBin",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_SearchBin__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_SearchBin__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_SearchBin'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::SearchBin(TInt const &) const\n" + " TVec< TInt,int >::SearchBin(TInt const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchForw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SearchForw" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SearchForw" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchForw" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_SearchForw" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TInt,int > const *)arg1)->SearchForw((TInt const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchForw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SearchForw" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SearchForw" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchForw" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)((TVec< TInt,int > const *)arg1)->SearchForw((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchForw(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_SearchForw",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_SearchForw__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_SearchForw__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_SearchForw'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::SearchForw(TInt const &,int const &) const\n" + " TVec< TInt,int >::SearchForw(TInt const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_SearchBack",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SearchBack" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SearchBack" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchBack" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)((TVec< TInt,int > const *)arg1)->SearchBack((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchVForw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SearchVForw" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SearchVForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchVForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntV_SearchVForw" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TInt,int > const *)arg1)->SearchVForw((TVec< TInt,int > const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchVForw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_SearchVForw" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_SearchVForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_SearchVForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)((TVec< TInt,int > const *)arg1)->SearchVForw((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_SearchVForw(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_SearchVForw",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_SearchVForw__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_SearchVForw__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_SearchVForw'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::SearchVForw(TVec< TInt,int > const &,int const &) const\n" + " TVec< TInt,int >::SearchVForw(TVec< TInt,int > const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_IsIn" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_IsIn" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_IsIn" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)((TVec< TInt,int > const *)arg1)->IsIn((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_IsIn" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_IsIn" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_IsIn" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_IsIn" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_IsIn" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (bool)((TVec< TInt,int > const *)arg1)->IsIn((TInt const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_IsIn",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntV_IsIn__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_IsIn__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_IsIn'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::IsIn(TInt const &) const\n" + " TVec< TInt,int >::IsIn(TInt const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_IsInBin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_IsInBin",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_IsInBin" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_IsInBin" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_IsInBin" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)((TVec< TInt,int > const *)arg1)->IsInBin((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_GetDat",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetDat" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TInt *) &((TVec< TInt,int > const *)arg1)->GetDat((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetAddDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntV_GetAddDat",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetAddDat" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetAddDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetAddDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TInt *) &(arg1)->GetAddDat((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetMxValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetMxValN" "', argument " "1"" of type '" "TVec< TInt,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = (int)((TVec< TInt,int > const *)arg1)->GetMxValN(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2,(TInt const &)*arg3); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + TInt *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + arg4 = reinterpret_cast< TInt * >(argp4); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2,(TInt const &)*arg3,(TInt const &)*arg4); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + TInt *arg4 = 0 ; + TInt *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + arg4 = reinterpret_cast< TInt * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + arg5 = reinterpret_cast< TInt * >(argp5); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2,(TInt const &)*arg3,(TInt const &)*arg4,(TInt const &)*arg5); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + TInt *arg4 = 0 ; + TInt *arg5 = 0 ; + TInt *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + arg4 = reinterpret_cast< TInt * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + arg5 = reinterpret_cast< TInt * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + arg6 = reinterpret_cast< TInt * >(argp6); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2,(TInt const &)*arg3,(TInt const &)*arg4,(TInt const &)*arg5,(TInt const &)*arg6); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + TInt *arg4 = 0 ; + TInt *arg5 = 0 ; + TInt *arg6 = 0 ; + TInt *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + arg4 = reinterpret_cast< TInt * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + arg5 = reinterpret_cast< TInt * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + arg6 = reinterpret_cast< TInt * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TIntV_GetV" "', argument " "7"" of type '" "TInt const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "7"" of type '" "TInt const &""'"); + } + arg7 = reinterpret_cast< TInt * >(argp7); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2,(TInt const &)*arg3,(TInt const &)*arg4,(TInt const &)*arg5,(TInt const &)*arg6,(TInt const &)*arg7); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + TInt *arg4 = 0 ; + TInt *arg5 = 0 ; + TInt *arg6 = 0 ; + TInt *arg7 = 0 ; + TInt *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + arg4 = reinterpret_cast< TInt * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + arg5 = reinterpret_cast< TInt * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + arg6 = reinterpret_cast< TInt * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TIntV_GetV" "', argument " "7"" of type '" "TInt const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "7"" of type '" "TInt const &""'"); + } + arg7 = reinterpret_cast< TInt * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TIntV_GetV" "', argument " "8"" of type '" "TInt const &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "8"" of type '" "TInt const &""'"); + } + arg8 = reinterpret_cast< TInt * >(argp8); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2,(TInt const &)*arg3,(TInt const &)*arg4,(TInt const &)*arg5,(TInt const &)*arg6,(TInt const &)*arg7,(TInt const &)*arg8); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TInt *arg1 = 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + TInt *arg4 = 0 ; + TInt *arg5 = 0 ; + TInt *arg6 = 0 ; + TInt *arg7 = 0 ; + TInt *arg8 = 0 ; + TInt *arg9 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + void *argp9 = 0 ; + int res9 = 0 ; + TVec< TInt,int > result; + + if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "1"" of type '" "TInt const &""'"); + } + arg1 = reinterpret_cast< TInt * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "4"" of type '" "TInt const &""'"); + } + arg4 = reinterpret_cast< TInt * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "5"" of type '" "TInt const &""'"); + } + arg5 = reinterpret_cast< TInt * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "6"" of type '" "TInt const &""'"); + } + arg6 = reinterpret_cast< TInt * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TIntV_GetV" "', argument " "7"" of type '" "TInt const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "7"" of type '" "TInt const &""'"); + } + arg7 = reinterpret_cast< TInt * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TIntV_GetV" "', argument " "8"" of type '" "TInt const &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "8"" of type '" "TInt const &""'"); + } + arg8 = reinterpret_cast< TInt * >(argp8); + res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res9)) { + SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "TIntV_GetV" "', argument " "9"" of type '" "TInt const &""'"); + } + if (!argp9) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntV_GetV" "', argument " "9"" of type '" "TInt const &""'"); + } + arg9 = reinterpret_cast< TInt * >(argp9); + result = TVec< TInt,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TInt const &)*arg1,(TInt const &)*arg2,(TInt const &)*arg3,(TInt const &)*arg4,(TInt const &)*arg5,(TInt const &)*arg6,(TInt const &)*arg7,(TInt const &)*arg8,(TInt const &)*arg9); + resultobj = SWIG_NewPointerObj((new TVec< TInt,int >(static_cast< const TVec< TInt,int >& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_GetV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[10]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_GetV",0,9,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_GetV__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntV_GetV__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_GetV__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_TIntV_GetV__SWIG_3(self, argc, argv); + } + if (argc == 5) { + return _wrap_TIntV_GetV__SWIG_4(self, argc, argv); + } + if (argc == 6) { + return _wrap_TIntV_GetV__SWIG_5(self, argc, argv); + } + if (argc == 7) { + return _wrap_TIntV_GetV__SWIG_6(self, argc, argv); + } + if (argc == 8) { + return _wrap_TIntV_GetV__SWIG_7(self, argc, argv); + } + if (argc == 9) { + return _wrap_TIntV_GetV__SWIG_8(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_GetV'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::GetV(TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &,TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &,TInt const &,TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &,TInt const &,TInt const &,TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &)\n" + " TVec< TInt,int >::GetV(TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &,TInt const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Add__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_Add" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_Add" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)TVec_Sl_TInt_Sc_int_Sg__Add__SWIG_3(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_Add(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_Add",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntV_Add__SWIG_0(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TIntV_Add__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TIntV_Add__SWIG_3(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntV_Add__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_Add'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::Add()\n" + " TVec< TInt,int >::Add(TInt const &)\n" + " TVec< TInt,int >::Add(TInt const &,int const &)\n" + " TVec< TInt,int >::Add(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddMerged__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntV_AddMerged" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntV_AddMerged" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)TVec_Sl_TInt_Sc_int_Sg__AddMerged__SWIG_1(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntV_AddMerged(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntV_AddMerged",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TIntV_AddMerged__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TIntV_AddMerged__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntV_AddMerged'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TInt,int >::AddMerged(TInt const &)\n" + " TVec< TInt,int >::AddMerged(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *TIntV_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TVecT_TInt_int_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TIntV_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TIntIntVV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TVec< TVec< TInt,int >,int > *)new TVec< TVec< TInt,int >,int >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TVec< TInt,int >,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntIntVV" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntIntVV" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (TVec< TVec< TInt,int >,int > *)new TVec< TVec< TInt,int >,int >((TVec< TVec< TInt,int >,int > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TVec< TVec< TInt,int >,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntIntVV" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TVec< TVec< TInt,int >,int > *)new TVec< TVec< TInt,int >,int >((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TVec< TInt,int >,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntIntVV" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TIntIntVV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TVec< TInt,int >,int > *)new TVec< TVec< TInt,int >,int >((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVV__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = (TVec< TInt,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TVec< TInt,int >,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntIntVV" "', argument " "1"" of type '" "TVec< TInt,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TIntIntVV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TVec< TInt,int >,int > *)new TVec< TVec< TInt,int >,int >(arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TIntIntVV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TIntIntVV" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVV__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TVec< TInt,int >,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntIntVV" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntIntVV" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TVec< TVec< TInt,int >,int > *)new TVec< TVec< TInt,int >,int >(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TIntIntVV",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TIntIntVV__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TIntIntVV__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TIntIntVV__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TIntIntVV__SWIG_2(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_new_TIntIntVV__SWIG_4(self, argc, argv); + } +check_5: + + if (argc == 2) { + return _wrap_new_TIntIntVV__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TIntIntVV'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::TVec()\n" + " TVec< TVec< TInt,int >,int >::TVec(TVec< TVec< TInt,int >,int > const &)\n" + " TVec< TVec< TInt,int >,int >::TVec(int const &)\n" + " TVec< TVec< TInt,int >,int >::TVec(int const &,int const &)\n" + " TVec< TVec< TInt,int >,int >::TVec(TVec< TInt,int > *,int const &)\n" + " TVec< TVec< TInt,int >,int >::TVec(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Load" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Save" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TVec< TVec< TInt,int >,int > const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_LoadXml__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_LoadXml" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_LoadXml__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + PXmlTok *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_LoadXml" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + (arg1)->LoadXml((PXmlTok const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_LoadXml(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_LoadXml",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_LoadXml__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_LoadXml__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_LoadXml'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::LoadXml(PXmlTok const &,TStr const &)\n" + " TVec< TVec< TInt,int >,int >::LoadXml(PXmlTok const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SaveXml" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TVec< TVec< TInt,int >,int > const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TVec< TInt,int >,int > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV___add__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV___add__" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV___add__" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV___add__" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (TVec< TVec< TInt,int >,int > *) &(arg1)->operator +((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV___eq__" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV___eq__" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV___eq__" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->operator ==((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV___lt__" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV___lt__" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV___lt__" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->operator <((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetMemUsed" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetMemSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetMemSize" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->GetMemSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetPrimHashCd" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetSecHashCd" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Gen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Gen" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Gen((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Gen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Gen" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_Gen" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Gen((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Gen(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Gen",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_Gen__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Gen__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Gen'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Gen(int const &)\n" + " TVec< TVec< TInt,int >,int >::Gen(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GenExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = (TVec< TInt,int > *) 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_GenExt",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GenExt" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GenExt" "', argument " "2"" of type '" "TVec< TInt,int > *""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_GenExt" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->GenExt(arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_IsExt" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->IsExt(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Reserve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Reserve" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Reserve((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Reserve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Reserve" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Reserve(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Reserve",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_Reserve__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Reserve__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Reserve'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Reserve(int const &)\n" + " TVec< TVec< TInt,int >,int >::Reserve(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Clr" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_Clr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Clr((bool const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Clr" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Clr((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Clr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Clr" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Clr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_Clr__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVV_Clr__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Clr(bool const &,int const &)\n" + " TVec< TVec< TInt,int >,int >::Clr(bool const &)\n" + " TVec< TVec< TInt,int >,int >::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Trunc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Trunc" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Trunc" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Trunc((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Trunc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Trunc" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + (arg1)->Trunc(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Trunc(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Trunc",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_Trunc__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVV_Trunc__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Trunc'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Trunc(int const &)\n" + " TVec< TVec< TInt,int >,int >::Trunc()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Pack" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + (arg1)->Pack(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_MoveFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_MoveFrom",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_MoveFrom" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_MoveFrom" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_MoveFrom" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + (arg1)->MoveFrom(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Swap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Swap" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Swap" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Swap" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + (arg1)->Swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Empty" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Len" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Reserved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Reserved" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->Reserved(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Last__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Last" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (TVec< TInt,int > *) &((TVec< TVec< TInt,int >,int > const *)arg1)->Last(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Last__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Last" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (TVec< TInt,int > *) &(arg1)->Last(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Last(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Last",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_Last__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TIntIntVV_Last__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Last'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Last() const\n" + " TVec< TVec< TInt,int >,int >::Last()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_LastValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_LastValN" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->LastValN(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_LastLast__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_LastLast" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (TVec< TInt,int > *) &((TVec< TVec< TInt,int >,int > const *)arg1)->LastLast(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_LastLast__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_LastLast" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (TVec< TInt,int > *) &(arg1)->LastLast(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_LastLast(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_LastLast",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_LastLast__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TIntIntVV_LastLast__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_LastLast'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::LastLast() const\n" + " TVec< TVec< TInt,int >,int >::LastLast()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_BegI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TVec< TVec< TInt,int >,int >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_BegI" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (TVec< TVec< TInt,int >,int >::TIter)((TVec< TVec< TInt,int >,int > const *)arg1)->BegI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_EndI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TVec< TVec< TInt,int >,int >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_EndI" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (TVec< TVec< TInt,int >,int >::TIter)((TVec< TVec< TInt,int >,int > const *)arg1)->EndI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TVec< TInt,int >,int >::TIter result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_GetI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetI" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_GetI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TVec< TInt,int >,int >::TIter)((TVec< TVec< TInt,int >,int > const *)arg1)->GetI((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_AddV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_AddV" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_AddV" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_AddV" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + result = (int)(arg1)->AddV((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddSorted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + bool *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_AddSorted" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_AddSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_AddSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_AddSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntIntVV_AddSorted" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)(arg1)->AddSorted((TVec< TInt,int > const &)*arg2,(bool const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddSorted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_AddSorted" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_AddSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_AddSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_AddSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddSorted((TVec< TInt,int > const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddSorted__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_AddSorted" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_AddSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_AddSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)(arg1)->AddSorted((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddSorted(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_AddSorted",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_AddSorted__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_AddSorted__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TIntIntVV_AddSorted__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_AddSorted'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::AddSorted(TVec< TInt,int > const &,bool const &,int const &)\n" + " TVec< TVec< TInt,int >,int >::AddSorted(TVec< TInt,int > const &,bool const &)\n" + " TVec< TVec< TInt,int >,int >::AddSorted(TVec< TInt,int > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddBackSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_AddBackSorted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_AddBackSorted" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_AddBackSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_AddBackSorted" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_AddBackSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddBackSorted((TVec< TInt,int > const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddVMerged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_AddVMerged",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_AddVMerged" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_AddVMerged" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_AddVMerged" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + result = (int)(arg1)->AddVMerged((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_AddUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_AddUnique",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_AddUnique" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_AddUnique" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_AddUnique" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)(arg1)->AddUnique((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetVal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetVal" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_GetVal" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TInt,int > *) &((TVec< TVec< TInt,int >,int > const *)arg1)->GetVal((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetVal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetVal" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_GetVal" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TInt,int > *) &(arg1)->GetVal((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetVal(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_GetVal",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_GetVal__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVV_GetVal__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_GetVal'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::GetVal(int const &) const\n" + " TVec< TVec< TInt,int >,int >::GetVal(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetSubValV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TVec< TVec< TInt,int >,int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_GetSubValV",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetSubValV" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_GetSubValV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_GetSubValV" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVV_GetSubValV" "', argument " "4"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetSubValV" "', argument " "4"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + arg4 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp4); + ((TVec< TVec< TInt,int >,int > const *)arg1)->GetSubValV((int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Ins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_Ins",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Ins" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Ins" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_Ins" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Ins" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + (arg1)->Ins((int const &)*arg2,(TVec< TInt,int > const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Del__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Del" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Del((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Del__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Del" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_Del" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Del((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Del(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Del",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_Del__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Del__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Del'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Del(int const &)\n" + " TVec< TVec< TInt,int >,int >::Del(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_DelLast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_DelLast" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + (arg1)->DelLast(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_DelIfIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_DelIfIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_DelIfIn" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_DelIfIn" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_DelIfIn" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (bool)(arg1)->DelIfIn((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_DelAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_DelAll",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_DelAll" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_DelAll" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_DelAll" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + (arg1)->DelAll((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_PutAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_PutAll",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_PutAll" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_PutAll" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_PutAll" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + (arg1)->PutAll((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Swap" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Swap" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_Swap" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Swap((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Swap(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Swap",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_Swap__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Swap__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Swap'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Swap(TVec< TVec< TInt,int >,int > &)\n" + " TVec< TVec< TInt,int >,int >::Swap(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SwapI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int >::TIter arg1 = (TVec< TVec< TInt,int >,int >::TIter) 0 ; + TVec< TVec< TInt,int >,int >::TIter arg2 = (TVec< TVec< TInt,int >,int >::TIter) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_SwapI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SwapI" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int >::TIter""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int >::TIter >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SwapI" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int >::TIter""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int >::TIter >(argp2); + TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR SwapI(arg1,arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_NextPerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_NextPerm" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (bool)(arg1)->NextPerm(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_PrevPerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_PrevPerm" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (bool)(arg1)->PrevPerm(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetPivotValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_GetPivotValN",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetPivotValN" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_GetPivotValN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_GetPivotValN" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->GetPivotValN((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_BSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_BSort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_BSort" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_BSort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_BSort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntIntVV_BSort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->BSort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_ISort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_ISort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_ISort" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_ISort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_ISort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntIntVV_ISort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->ISort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Partition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_Partition",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Partition" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Partition" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_Partition" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntIntVV_Partition" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)(arg1)->Partition((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_QSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_QSort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_QSort" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_QSort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_QSort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntIntVV_QSort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->QSort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Sort__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Sort" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Sort" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Sort((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Sort__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Sort" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + (arg1)->Sort(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Sort(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Sort",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_Sort__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVV_Sort__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Sort'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Sort(bool const &)\n" + " TVec< TVec< TInt,int >,int >::Sort()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsSorted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_IsSorted" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_IsSorted" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->IsSorted((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsSorted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_IsSorted" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->IsSorted(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsSorted(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_IsSorted",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_IsSorted__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVV_IsSorted__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_IsSorted'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::IsSorted(bool const &) const\n" + " TVec< TVec< TInt,int >,int >::IsSorted() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Shuffle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_Shuffle",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Shuffle" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Shuffle" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Shuffle" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + (arg1)->Shuffle(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Reverse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Reverse" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + (arg1)->Reverse(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Reverse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Reverse" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVV_Reverse" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_Reverse" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + (arg1)->Reverse(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Reverse(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Reverse",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_Reverse__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Reverse__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Reverse'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Reverse()\n" + " TVec< TVec< TInt,int >,int >::Reverse(int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Merge" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + (arg1)->Merge(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Intrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Intrs" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Intrs" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Intrs" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + (arg1)->Intrs((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Union__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Union" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Union" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Union" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + (arg1)->Union((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Diff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Diff" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Diff" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Diff" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + (arg1)->Diff((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Intrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + TVec< TVec< TInt,int >,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Intrs" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Intrs" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Intrs" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_Intrs" "', argument " "3"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Intrs" "', argument " "3"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp3); + ((TVec< TVec< TInt,int >,int > const *)arg1)->Intrs((TVec< TVec< TInt,int >,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Intrs(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Intrs",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_Intrs__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Intrs__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Intrs'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Intrs(TVec< TVec< TInt,int >,int > const &)\n" + " TVec< TVec< TInt,int >,int >::Intrs(TVec< TVec< TInt,int >,int > const &,TVec< TVec< TInt,int >,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Union__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + TVec< TVec< TInt,int >,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Union" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Union" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Union" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_Union" "', argument " "3"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Union" "', argument " "3"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp3); + ((TVec< TVec< TInt,int >,int > const *)arg1)->Union((TVec< TVec< TInt,int >,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Union(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Union",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_Union__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Union__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Union'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Union(TVec< TVec< TInt,int >,int > const &)\n" + " TVec< TVec< TInt,int >,int >::Union(TVec< TVec< TInt,int >,int > const &,TVec< TVec< TInt,int >,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Diff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + TVec< TVec< TInt,int >,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Diff" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Diff" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Diff" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_Diff" "', argument " "3"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Diff" "', argument " "3"" of type '" "TVec< TVec< TInt,int >,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp3); + ((TVec< TVec< TInt,int >,int > const *)arg1)->Diff((TVec< TVec< TInt,int >,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Diff(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_Diff",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_Diff__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_Diff__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_Diff'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::Diff(TVec< TVec< TInt,int >,int > const &)\n" + " TVec< TVec< TInt,int >,int >::Diff(TVec< TVec< TInt,int >,int > const &,TVec< TVec< TInt,int >,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IntrsLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_IntrsLen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_IntrsLen" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_IntrsLen" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_IntrsLen" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->IntrsLen((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_UnionLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_UnionLen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_UnionLen" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_UnionLen" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_UnionLen" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->UnionLen((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_Count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_Count",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_Count" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_Count" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_Count" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->Count((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchBin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SearchBin" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SearchBin" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchBin" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->SearchBin((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchBin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SearchBin" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SearchBin" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchBin" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_SearchBin" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchBin" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->SearchBin((TVec< TInt,int > const &)*arg2,*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchBin(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_SearchBin",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_SearchBin__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_SearchBin__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_SearchBin'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::SearchBin(TVec< TInt,int > const &) const\n" + " TVec< TVec< TInt,int >,int >::SearchBin(TVec< TInt,int > const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchForw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SearchForw" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SearchForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_SearchForw" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->SearchForw((TVec< TInt,int > const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchForw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SearchForw" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SearchForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchForw" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->SearchForw((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchForw(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_SearchForw",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_SearchForw__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_SearchForw__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_SearchForw'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::SearchForw(TVec< TInt,int > const &,int const &) const\n" + " TVec< TVec< TInt,int >,int >::SearchForw(TVec< TInt,int > const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_SearchBack",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SearchBack" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SearchBack" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchBack" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->SearchBack((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchVForw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SearchVForw" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SearchVForw" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchVForw" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVV_SearchVForw" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->SearchVForw((TVec< TVec< TInt,int >,int > const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchVForw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TVec< TInt,int >,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_SearchVForw" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_SearchVForw" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_SearchVForw" "', argument " "2"" of type '" "TVec< TVec< TInt,int >,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp2); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->SearchVForw((TVec< TVec< TInt,int >,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_SearchVForw(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_SearchVForw",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_SearchVForw__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_SearchVForw__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_SearchVForw'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::SearchVForw(TVec< TVec< TInt,int >,int > const &,int const &) const\n" + " TVec< TVec< TInt,int >,int >::SearchVForw(TVec< TVec< TInt,int >,int > const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_IsIn" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_IsIn" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_IsIn" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->IsIn((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_IsIn" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_IsIn" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_IsIn" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_IsIn" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_IsIn" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->IsIn((TVec< TInt,int > const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_IsIn",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVV_IsIn__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_IsIn__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_IsIn'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::IsIn(TVec< TInt,int > const &) const\n" + " TVec< TVec< TInt,int >,int >::IsIn(TVec< TInt,int > const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_IsInBin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_IsInBin",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_IsInBin" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_IsInBin" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_IsInBin" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (bool)((TVec< TVec< TInt,int >,int > const *)arg1)->IsInBin((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TInt,int > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_GetDat",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetDat" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetDat" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetDat" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (TVec< TInt,int > *) &((TVec< TVec< TInt,int >,int > const *)arg1)->GetDat((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetAddDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TInt,int > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVV_GetAddDat",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetAddDat" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetAddDat" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetAddDat" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = (TVec< TInt,int > *) &(arg1)->GetAddDat((TVec< TInt,int > const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetMxValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TVec< TInt,int >,int > *arg1 = (TVec< TVec< TInt,int >,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetMxValN" "', argument " "1"" of type '" "TVec< TVec< TInt,int >,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TVec< TInt,int >,int > * >(argp1); + result = (int)((TVec< TVec< TInt,int >,int > const *)arg1)->GetMxValN(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2,(TVec< TInt,int > const &)*arg3); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2,(TVec< TInt,int > const &)*arg3,(TVec< TInt,int > const &)*arg4); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + TVec< TInt,int > *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + arg5 = reinterpret_cast< TVec< TInt,int > * >(argp5); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2,(TVec< TInt,int > const &)*arg3,(TVec< TInt,int > const &)*arg4,(TVec< TInt,int > const &)*arg5); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + TVec< TInt,int > *arg5 = 0 ; + TVec< TInt,int > *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + arg5 = reinterpret_cast< TVec< TInt,int > * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + arg6 = reinterpret_cast< TVec< TInt,int > * >(argp6); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2,(TVec< TInt,int > const &)*arg3,(TVec< TInt,int > const &)*arg4,(TVec< TInt,int > const &)*arg5,(TVec< TInt,int > const &)*arg6); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + TVec< TInt,int > *arg5 = 0 ; + TVec< TInt,int > *arg6 = 0 ; + TVec< TInt,int > *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + arg5 = reinterpret_cast< TVec< TInt,int > * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + arg6 = reinterpret_cast< TVec< TInt,int > * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TIntIntVV_GetV" "', argument " "7"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "7"" of type '" "TVec< TInt,int > const &""'"); + } + arg7 = reinterpret_cast< TVec< TInt,int > * >(argp7); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2,(TVec< TInt,int > const &)*arg3,(TVec< TInt,int > const &)*arg4,(TVec< TInt,int > const &)*arg5,(TVec< TInt,int > const &)*arg6,(TVec< TInt,int > const &)*arg7); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + TVec< TInt,int > *arg5 = 0 ; + TVec< TInt,int > *arg6 = 0 ; + TVec< TInt,int > *arg7 = 0 ; + TVec< TInt,int > *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + arg5 = reinterpret_cast< TVec< TInt,int > * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + arg6 = reinterpret_cast< TVec< TInt,int > * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TIntIntVV_GetV" "', argument " "7"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "7"" of type '" "TVec< TInt,int > const &""'"); + } + arg7 = reinterpret_cast< TVec< TInt,int > * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TIntIntVV_GetV" "', argument " "8"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "8"" of type '" "TVec< TInt,int > const &""'"); + } + arg8 = reinterpret_cast< TVec< TInt,int > * >(argp8); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2,(TVec< TInt,int > const &)*arg3,(TVec< TInt,int > const &)*arg4,(TVec< TInt,int > const &)*arg5,(TVec< TInt,int > const &)*arg6,(TVec< TInt,int > const &)*arg7,(TVec< TInt,int > const &)*arg8); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TInt,int > *arg1 = 0 ; + TVec< TInt,int > *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + TVec< TInt,int > *arg5 = 0 ; + TVec< TInt,int > *arg6 = 0 ; + TVec< TInt,int > *arg7 = 0 ; + TVec< TInt,int > *arg8 = 0 ; + TVec< TInt,int > *arg9 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + void *argp9 = 0 ; + int res9 = 0 ; + TVec< TVec< TInt,int >,int > result; + + if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "1"" of type '" "TVec< TInt,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TInt,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "2"" of type '" "TVec< TInt,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TInt,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "3"" of type '" "TVec< TInt,int > const &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "4"" of type '" "TVec< TInt,int > const &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "5"" of type '" "TVec< TInt,int > const &""'"); + } + arg5 = reinterpret_cast< TVec< TInt,int > * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "6"" of type '" "TVec< TInt,int > const &""'"); + } + arg6 = reinterpret_cast< TVec< TInt,int > * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TIntIntVV_GetV" "', argument " "7"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "7"" of type '" "TVec< TInt,int > const &""'"); + } + arg7 = reinterpret_cast< TVec< TInt,int > * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TIntIntVV_GetV" "', argument " "8"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "8"" of type '" "TVec< TInt,int > const &""'"); + } + arg8 = reinterpret_cast< TVec< TInt,int > * >(argp8); + res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res9)) { + SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "TIntIntVV_GetV" "', argument " "9"" of type '" "TVec< TInt,int > const &""'"); + } + if (!argp9) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVV_GetV" "', argument " "9"" of type '" "TVec< TInt,int > const &""'"); + } + arg9 = reinterpret_cast< TVec< TInt,int > * >(argp9); + result = TVec< TVec< TInt,int >,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TVec< TInt,int > const &)*arg1,(TVec< TInt,int > const &)*arg2,(TVec< TInt,int > const &)*arg3,(TVec< TInt,int > const &)*arg4,(TVec< TInt,int > const &)*arg5,(TVec< TInt,int > const &)*arg6,(TVec< TInt,int > const &)*arg7,(TVec< TInt,int > const &)*arg8,(TVec< TInt,int > const &)*arg9); + resultobj = SWIG_NewPointerObj((new TVec< TVec< TInt,int >,int >(static_cast< const TVec< TVec< TInt,int >,int >& >(result))), SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVV_GetV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[10]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVV_GetV",0,9,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVV_GetV__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVV_GetV__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVV_GetV__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_TIntIntVV_GetV__SWIG_3(self, argc, argv); + } + if (argc == 5) { + return _wrap_TIntIntVV_GetV__SWIG_4(self, argc, argv); + } + if (argc == 6) { + return _wrap_TIntIntVV_GetV__SWIG_5(self, argc, argv); + } + if (argc == 7) { + return _wrap_TIntIntVV_GetV__SWIG_6(self, argc, argv); + } + if (argc == 8) { + return _wrap_TIntIntVV_GetV__SWIG_7(self, argc, argv); + } + if (argc == 9) { + return _wrap_TIntIntVV_GetV__SWIG_8(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVV_GetV'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &)\n" + " TVec< TVec< TInt,int >,int >::GetV(TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &,TVec< TInt,int > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *TIntIntVV_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TIntIntVV_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TIntIntVH__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (THash< TInt,TVec< TInt,int > > *)new THash< TInt,TVec< TInt,int > >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVH__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + THash< TInt,TVec< TInt,int > > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntIntVH" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntIntVH" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const &""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (THash< TInt,TVec< TInt,int > > *)new THash< TInt,TVec< TInt,int > >((THash< TInt,TVec< TInt,int > > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVH__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + bool *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + THash< TInt,TVec< TInt,int > > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntIntVH" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TIntIntVH" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (THash< TInt,TVec< TInt,int > > *)new THash< TInt,TVec< TInt,int > >((int const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVH__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + THash< TInt,TVec< TInt,int > > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntIntVH" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (THash< TInt,TVec< TInt,int > > *)new THash< TInt,TVec< TInt,int > >((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVH__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + THash< TInt,TVec< TInt,int > > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntIntVH" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntIntVH" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (THash< TInt,TVec< TInt,int > > *)new THash< TInt,TVec< TInt,int > >(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntIntVH(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TIntIntVH",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TIntIntVH__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TIntIntVH__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TIntIntVH__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TIntIntVH__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TIntIntVH__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TIntIntVH'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::THash()\n" + " THash< TInt,TVec< TInt,int > >::THash(THash< TInt,TVec< TInt,int > > const &)\n" + " THash< TInt,TVec< TInt,int > >::THash(int const &,bool const &)\n" + " THash< TInt,TVec< TInt,int > >::THash(int const &)\n" + " THash< TInt,TVec< TInt,int > >::THash(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Load" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Save" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_LoadXml__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_LoadXml" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVH_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_LoadXml__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + PXmlTok *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_LoadXml" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + (arg1)->LoadXml((PXmlTok const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_LoadXml(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_LoadXml",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVH_LoadXml__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVH_LoadXml__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_LoadXml'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::LoadXml(PXmlTok const &,TStr const &)\n" + " THash< TInt,TVec< TInt,int > >::LoadXml(PXmlTok const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_SaveXml" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVH_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + THash< TInt,TVec< TInt,int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH___eq__" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH___eq__" "', argument " "2"" of type '" "THash< TInt,TVec< TInt,int > > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH___eq__" "', argument " "2"" of type '" "THash< TInt,TVec< TInt,int > > const &""'"); + } + arg2 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp2); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->operator ==((THash< TInt,TVec< TInt,int > > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + THash< TInt,TVec< TInt,int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH___lt__" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH___lt__" "', argument " "2"" of type '" "THash< TInt,TVec< TInt,int > > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH___lt__" "', argument " "2"" of type '" "THash< TInt,TVec< TInt,int > > const &""'"); + } + arg2 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp2); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->operator <((THash< TInt,TVec< TInt,int > > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TInt,int > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH___call__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH___call__" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH___call__" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH___call__" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TVec< TInt,int > *) &(arg1)->operator ()((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ::TSize result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetMemUsed" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_BegI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< THashKeyDatI< TInt,TVec< TInt,int > > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_BegI" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = ((THash< TInt,TVec< TInt,int > > const *)arg1)->BegI(); + resultobj = SWIG_NewPointerObj((new THash< TInt,TVec< TInt,int > >::TIter(static_cast< const THash< TInt,TVec< TInt,int > >::TIter& >(result))), SWIGTYPE_p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_EndI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< THashKeyDatI< TInt,TVec< TInt,int > > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_EndI" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = ((THash< TInt,TVec< TInt,int > > const *)arg1)->EndI(); + resultobj = SWIG_NewPointerObj((new THash< TInt,TVec< TInt,int > >::TIter(static_cast< const THash< TInt,TVec< TInt,int > >::TIter& >(result))), SWIGTYPE_p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + SwigValueWrapper< THashKeyDatI< TInt,TVec< TInt,int > > > result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetI" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetI((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj((new THash< TInt,TVec< TInt,int > >::TIter(static_cast< const THash< TInt,TVec< TInt,int > >::TIter& >(result))), SWIGTYPE_p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Gen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_Gen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Gen" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Gen((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Clr" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVH_Clr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntIntVH_Clr" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->Clr((bool const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Clr" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVH_Clr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Clr((bool const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Clr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Clr" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Clr((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Clr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Clr" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_Clr",0,4,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVH_Clr__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVH_Clr__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVH_Clr__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TIntIntVH_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::Clr(bool const &,int const &,bool const &)\n" + " THash< TInt,TVec< TInt,int > >::Clr(bool const &,int const &)\n" + " THash< TInt,TVec< TInt,int > >::Clr(bool const &)\n" + " THash< TInt,TVec< TInt,int > >::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Empty" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Len" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (int)((THash< TInt,TVec< TInt,int > > const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetPorts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetPorts" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (int)((THash< TInt,TVec< TInt,int > > const *)arg1)->GetPorts(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsAutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_IsAutoSize" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->IsAutoSize(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetMxKeyIds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetMxKeyIds" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (int)((THash< TInt,TVec< TInt,int > > const *)arg1)->GetMxKeyIds(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetReservedKeyIds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetReservedKeyIds" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (int)((THash< TInt,TVec< TInt,int > > const *)arg1)->GetReservedKeyIds(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsKeyIdEqKeyN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_IsKeyIdEqKeyN" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->IsKeyIdEqKeyN(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_AddKey__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_AddKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_AddKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_AddKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)(arg1)->AddKey((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_DelKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_DelKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_DelKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_DelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_DelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + (arg1)->DelKey((TInt const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_DelIfKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_DelIfKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_DelIfKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_DelIfKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_DelIfKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)(arg1)->DelIfKey((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_DelKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_DelKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_DelKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_DelKeyId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelKeyId((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_DelKeyIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_DelKeyIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_DelKeyIdV" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_DelKeyIdV" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_DelKeyIdV" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + (arg1)->DelKeyIdV((TIntV const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_MarkDelKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_MarkDelKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_MarkDelKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_MarkDelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_MarkDelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + (arg1)->MarkDelKey((TInt const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_MarkDelKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_MarkDelKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_MarkDelKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_MarkDelKeyId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->MarkDelKeyId((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_GetKey" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TInt *) &((THash< TInt,TVec< TInt,int > > const *)arg1)->GetKey((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetKeyId" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetKeyId" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)((THash< TInt,TVec< TInt,int > > const *)arg1)->GetKeyId((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetRndKeyId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetRndKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)((THash< TInt,TVec< TInt,int > > const *)arg1)->GetRndKeyId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetRndKeyId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TRnd *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetRndKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVH_GetRndKeyId" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = (int)(arg1)->GetRndKeyId(*arg2,(double const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetRndKeyId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_GetRndKeyId",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntIntVH_GetRndKeyId__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVH_GetRndKeyId__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_GetRndKeyId'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::GetRndKeyId(TRnd &) const\n" + " THash< TInt,TVec< TInt,int > >::GetRndKeyId(TRnd &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsKey__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_IsKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->IsKey((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsKey__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_IsKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVH_IsKey" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_IsKey" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->IsKey((TInt const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_IsKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_IsKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_IsKeyId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->IsKeyId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetDat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetDat" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TVec< TInt,int > *) &((THash< TInt,TVec< TInt,int > > const *)arg1)->GetDat((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetDat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetDat" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TVec< TInt,int > *) &(arg1)->GetDat((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetKeyDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int *arg2 = 0 ; + TInt *arg3 = 0 ; + TVec< TInt,int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetKeyDat",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetKeyDat" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_GetKeyDat" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVH_GetKeyDat" "', argument " "3"" of type '" "TInt &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetKeyDat" "', argument " "3"" of type '" "TInt &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntIntVH_GetKeyDat" "', argument " "4"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetKeyDat" "', argument " "4"" of type '" "TVec< TInt,int > &""'"); + } + arg4 = reinterpret_cast< TVec< TInt,int > * >(argp4); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetKeyDat((int const &)*arg2,*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsKeyGetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TInt *arg2 = 0 ; + TVec< TInt,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_IsKeyGetDat",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_IsKeyGetDat" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_IsKeyGetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_IsKeyGetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntIntVH_IsKeyGetDat" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_IsKeyGetDat" "', argument " "3"" of type '" "TVec< TInt,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TInt,int > * >(argp3); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->IsKeyGetDat((TInt const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_FFirstKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_FFirstKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + result = (int)((THash< TInt,TVec< TInt,int > > const *)arg1)->FFirstKeyId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_FNextKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_FNextKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_FNextKeyId" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_FNextKeyId" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_FNextKeyId" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + result = (bool)((THash< TInt,TVec< TInt,int > > const *)arg1)->FNextKeyId(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetKeyV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TVec< TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetKeyV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetKeyV" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetKeyV" "', argument " "2"" of type '" "TVec< TInt > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetKeyV" "', argument " "2"" of type '" "TVec< TInt > &""'"); + } + arg2 = reinterpret_cast< TVec< TInt > * >(argp2); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetKeyV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetDatV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TVec< TVec< TInt,int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetDatV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetDatV" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TVecT_TInt_int_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetDatV" "', argument " "2"" of type '" "TVec< TVec< TInt,int > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetDatV" "', argument " "2"" of type '" "TVec< TVec< TInt,int > > &""'"); + } + arg2 = reinterpret_cast< TVec< TVec< TInt,int > > * >(argp2); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetDatV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetKeyDatPrV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TVec< TPair< TInt,TVec< TInt,int > > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetKeyDatPrV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetKeyDatPrV" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetKeyDatPrV" "', argument " "2"" of type '" "TVec< TPair< TInt,TVec< TInt,int > > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetKeyDatPrV" "', argument " "2"" of type '" "TVec< TPair< TInt,TVec< TInt,int > > > &""'"); + } + arg2 = reinterpret_cast< TVec< TPair< TInt,TVec< TInt,int > > > * >(argp2); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetKeyDatPrV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetDatKeyPrV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TVec< TPair< TVec< TInt,int >,TInt > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetDatKeyPrV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetDatKeyPrV" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetDatKeyPrV" "', argument " "2"" of type '" "TVec< TPair< TVec< TInt,int >,TInt > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetDatKeyPrV" "', argument " "2"" of type '" "TVec< TPair< TVec< TInt,int >,TInt > > &""'"); + } + arg2 = reinterpret_cast< TVec< TPair< TVec< TInt,int >,TInt > > * >(argp2); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetDatKeyPrV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetKeyDatKdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TVec< TKeyDat< TInt,TVec< TInt,int > > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetKeyDatKdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetKeyDatKdV" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetKeyDatKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TInt,TVec< TInt,int > > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetKeyDatKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TInt,TVec< TInt,int > > > &""'"); + } + arg2 = reinterpret_cast< TVec< TKeyDat< TInt,TVec< TInt,int > > > * >(argp2); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetKeyDatKdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetDatKeyKdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + TVec< TKeyDat< TVec< TInt,int >,TInt > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_GetDatKeyKdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetDatKeyKdV" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_GetDatKeyKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TVec< TInt,int >,TInt > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_GetDatKeyKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TVec< TInt,int >,TInt > > &""'"); + } + arg2 = reinterpret_cast< TVec< TKeyDat< TVec< TInt,int >,TInt > > * >(argp2); + ((THash< TInt,TVec< TInt,int > > const *)arg1)->GetDatKeyKdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + THash< TInt,TVec< TInt,int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_Swap",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Swap" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntIntVH_Swap" "', argument " "2"" of type '" "THash< TInt,TVec< TInt,int > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntIntVH_Swap" "', argument " "2"" of type '" "THash< TInt,TVec< TInt,int > > &""'"); + } + arg2 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp2); + (arg1)->Swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Defrag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Defrag" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + (arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Pack" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + (arg1)->Pack(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + bool *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntIntVH_Sort",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_Sort" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_Sort" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntIntVH_Sort" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + (arg1)->Sort((bool const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_SortByKey__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_SortByKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_SortByKey" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->SortByKey((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_SortByKey__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_SortByKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + (arg1)->SortByKey(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_SortByKey(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_SortByKey",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVH_SortByKey__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVH_SortByKey__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_SortByKey'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::SortByKey(bool const &)\n" + " THash< TInt,TVec< TInt,int > >::SortByKey()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_SortByDat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_SortByDat" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_SortByDat" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->SortByDat((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_SortByDat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_SortByDat" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + (arg1)->SortByDat(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_SortByDat(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_SortByDat",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntIntVH_SortByDat__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntIntVH_SortByDat__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_SortByDat'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::SortByDat(bool const &)\n" + " THash< TInt,TVec< TInt,int > >::SortByDat()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_AddKey__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_AddKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_AddKey" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)THash_Sl_TInt_Sc_TVec_Sl_TInt_Sc_int_Sg__Sg__AddKey__SWIG_1(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_AddKey(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_AddKey",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TIntIntVH_AddKey__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TIntIntVH_AddKey__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_AddKey'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::AddKey(TInt const &)\n" + " THash< TInt,TVec< TInt,int > >::AddKey(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsKey__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_IsKey" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_IsKey" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)THash_Sl_TInt_Sc_TVec_Sl_TInt_Sc_int_Sg__Sg__IsKey__SWIG_2(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_IsKey(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_IsKey",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TIntIntVH_IsKey__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TIntIntVH_IsKey__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntIntVH_IsKey__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_IsKey'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::IsKey(TInt const &) const\n" + " THash< TInt,TVec< TInt,int > >::IsKey(TInt const &,int &) const\n" + " THash< TInt,TVec< TInt,int > >::IsKey(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetDat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + TVec< TInt,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntIntVH_GetDat" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntIntVH_GetDat" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (TVec< TInt,int > *) &THash_Sl_TInt_Sc_TVec_Sl_TInt_Sc_int_Sg__Sg__GetDat__SWIG_2(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntIntVH_GetDat(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntIntVH_GetDat",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TIntIntVH_GetDat__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TIntIntVH_GetDat__SWIG_0(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TIntIntVH_GetDat__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntIntVH_GetDat'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TVec< TInt,int > >::GetDat(TInt const &) const\n" + " THash< TInt,TVec< TInt,int > >::GetDat(TInt const &)\n" + " THash< TInt,TVec< TInt,int > >::GetDat(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TIntIntVH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TVec< TInt,int > > *arg1 = (THash< TInt,TVec< TInt,int > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TIntIntVH" "', argument " "1"" of type '" "THash< TInt,TVec< TInt,int > > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TVec< TInt,int > > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TIntIntVH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TIntIntVH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TIntH__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + THash< TInt,TInt > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (THash< TInt,TInt > *)new THash< TInt,TInt >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntH__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + THash< TInt,TInt > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntH" "', argument " "1"" of type '" "THash< TInt,TInt > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntH" "', argument " "1"" of type '" "THash< TInt,TInt > const &""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (THash< TInt,TInt > *)new THash< TInt,TInt >((THash< TInt,TInt > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntH__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + bool *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + THash< TInt,TInt > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntH" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TIntH" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (THash< TInt,TInt > *)new THash< TInt,TInt >((int const &)*arg1,(bool const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntH__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + THash< TInt,TInt > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TIntH" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (THash< TInt,TInt > *)new THash< TInt,TInt >((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntH__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + THash< TInt,TInt > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntH" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntH" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (THash< TInt,TInt > *)new THash< TInt,TInt >(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntH(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TIntH",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TIntH__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TIntH__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TIntH__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TIntH__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TIntH__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TIntH'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::THash()\n" + " THash< TInt,TInt >::THash(THash< TInt,TInt > const &)\n" + " THash< TInt,TInt >::THash(int const &,bool const &)\n" + " THash< TInt,TInt >::THash(int const &)\n" + " THash< TInt,TInt >::THash(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Load" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Save" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((THash< TInt,TInt > const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_LoadXml__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_LoadXml" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntH_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_LoadXml__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + PXmlTok *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_LoadXml" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + (arg1)->LoadXml((PXmlTok const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_LoadXml(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_LoadXml",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntH_LoadXml__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntH_LoadXml__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_LoadXml'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::LoadXml(PXmlTok const &,TStr const &)\n" + " THash< TInt,TInt >::LoadXml(PXmlTok const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_SaveXml" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntH_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + THash< TInt,TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH___eq__" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH___eq__" "', argument " "2"" of type '" "THash< TInt,TInt > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH___eq__" "', argument " "2"" of type '" "THash< TInt,TInt > const &""'"); + } + arg2 = reinterpret_cast< THash< TInt,TInt > * >(argp2); + result = (bool)((THash< TInt,TInt > const *)arg1)->operator ==((THash< TInt,TInt > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + THash< TInt,TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH___lt__" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH___lt__" "', argument " "2"" of type '" "THash< TInt,TInt > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH___lt__" "', argument " "2"" of type '" "THash< TInt,TInt > const &""'"); + } + arg2 = reinterpret_cast< THash< TInt,TInt > * >(argp2); + result = (bool)((THash< TInt,TInt > const *)arg1)->operator <((THash< TInt,TInt > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH___call__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH___call__" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH___call__" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH___call__" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TInt *) &(arg1)->operator ()((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ::TSize result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetMemUsed" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = ((THash< TInt,TInt > const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_BegI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THash< TInt,TInt >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_BegI" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = ((THash< TInt,TInt > const *)arg1)->BegI(); + resultobj = SWIG_NewPointerObj((new THash< TInt,TInt >::TIter(static_cast< const THash< TInt,TInt >::TIter& >(result))), SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_EndI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THash< TInt,TInt >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_EndI" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = ((THash< TInt,TInt > const *)arg1)->EndI(); + resultobj = SWIG_NewPointerObj((new THash< TInt,TInt >::TIter(static_cast< const THash< TInt,TInt >::TIter& >(result))), SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + THash< TInt,TInt >::TIter result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetI" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = ((THash< TInt,TInt > const *)arg1)->GetI((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj((new THash< TInt,TInt >::TIter(static_cast< const THash< TInt,TInt >::TIter& >(result))), SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Gen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_Gen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Gen" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Gen((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Clr" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntH_Clr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TIntH_Clr" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->Clr((bool const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Clr" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntH_Clr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Clr((bool const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Clr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Clr" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Clr((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Clr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Clr" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_Clr",0,4,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntH_Clr__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntH_Clr__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntH_Clr__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TIntH_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::Clr(bool const &,int const &,bool const &)\n" + " THash< TInt,TInt >::Clr(bool const &,int const &)\n" + " THash< TInt,TInt >::Clr(bool const &)\n" + " THash< TInt,TInt >::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Empty" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (bool)((THash< TInt,TInt > const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Len" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (int)((THash< TInt,TInt > const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetPorts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetPorts" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (int)((THash< TInt,TInt > const *)arg1)->GetPorts(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsAutoSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_IsAutoSize" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (bool)((THash< TInt,TInt > const *)arg1)->IsAutoSize(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetMxKeyIds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetMxKeyIds" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (int)((THash< TInt,TInt > const *)arg1)->GetMxKeyIds(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetReservedKeyIds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetReservedKeyIds" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (int)((THash< TInt,TInt > const *)arg1)->GetReservedKeyIds(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsKeyIdEqKeyN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_IsKeyIdEqKeyN" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (bool)((THash< TInt,TInt > const *)arg1)->IsKeyIdEqKeyN(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddKey__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_AddKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_AddKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_AddKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)(arg1)->AddKey((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddDatId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_AddDatId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_AddDatId" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_AddDatId" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_AddDatId" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TInt *) &(arg1)->AddDatId((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddDat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_AddDat" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_AddDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_AddDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TInt *) &(arg1)->AddDat((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddDat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_AddDat" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_AddDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_AddDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntH_AddDat" "', argument " "3"" of type '" "TInt const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_AddDat" "', argument " "3"" of type '" "TInt const &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + result = (TInt *) &(arg1)->AddDat((TInt const &)*arg2,(TInt const &)*arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_DelKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_DelKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_DelKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_DelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_DelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + (arg1)->DelKey((TInt const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_DelIfKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_DelIfKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_DelIfKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_DelIfKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_DelIfKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)(arg1)->DelIfKey((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_DelKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_DelKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_DelKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_DelKeyId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelKeyId((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_DelKeyIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_DelKeyIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_DelKeyIdV" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_DelKeyIdV" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_DelKeyIdV" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + (arg1)->DelKeyIdV((TIntV const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_MarkDelKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_MarkDelKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_MarkDelKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_MarkDelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_MarkDelKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + (arg1)->MarkDelKey((TInt const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_MarkDelKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_MarkDelKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_MarkDelKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_MarkDelKeyId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->MarkDelKeyId((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TInt *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetKey",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetKey" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_GetKey" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TInt *) &((THash< TInt,TInt > const *)arg1)->GetKey((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetKeyId" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetKeyId" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (int)((THash< TInt,TInt > const *)arg1)->GetKeyId((TInt const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetRndKeyId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetRndKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)((THash< TInt,TInt > const *)arg1)->GetRndKeyId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetRndKeyId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TRnd *arg2 = 0 ; + double *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetRndKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetRndKeyId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntH_GetRndKeyId" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + result = (int)(arg1)->GetRndKeyId(*arg2,(double const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetRndKeyId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_GetRndKeyId",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntH_GetRndKeyId__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntH_GetRndKeyId__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_GetRndKeyId'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::GetRndKeyId(TRnd &) const\n" + " THash< TInt,TInt >::GetRndKeyId(TRnd &,double const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsKey__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_IsKey" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (bool)((THash< TInt,TInt > const *)arg1)->IsKey((TInt const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsKey__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_IsKey" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_IsKey" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntH_IsKey" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_IsKey" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (bool)((THash< TInt,TInt > const *)arg1)->IsKey((TInt const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_IsKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_IsKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_IsKeyId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((THash< TInt,TInt > const *)arg1)->IsKeyId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetDat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetDat" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TInt *) &((THash< TInt,TInt > const *)arg1)->GetDat((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetDat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetDat" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + result = (TInt *) &(arg1)->GetDat((TInt const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetKeyDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int *arg2 = 0 ; + TInt *arg3 = 0 ; + TInt *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetKeyDat",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetKeyDat" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_GetKeyDat" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntH_GetKeyDat" "', argument " "3"" of type '" "TInt &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetKeyDat" "', argument " "3"" of type '" "TInt &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TInt, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TIntH_GetKeyDat" "', argument " "4"" of type '" "TInt &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetKeyDat" "', argument " "4"" of type '" "TInt &""'"); + } + arg4 = reinterpret_cast< TInt * >(argp4); + ((THash< TInt,TInt > const *)arg1)->GetKeyDat((int const &)*arg2,*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsKeyGetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TInt *arg2 = 0 ; + TInt *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_IsKeyGetDat",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_IsKeyGetDat" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_IsKeyGetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_IsKeyGetDat" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TInt, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TIntH_IsKeyGetDat" "', argument " "3"" of type '" "TInt &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_IsKeyGetDat" "', argument " "3"" of type '" "TInt &""'"); + } + arg3 = reinterpret_cast< TInt * >(argp3); + result = (bool)((THash< TInt,TInt > const *)arg1)->IsKeyGetDat((TInt const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_FFirstKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_FFirstKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + result = (int)((THash< TInt,TInt > const *)arg1)->FFirstKeyId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_FNextKeyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_FNextKeyId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_FNextKeyId" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_FNextKeyId" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_FNextKeyId" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + result = (bool)((THash< TInt,TInt > const *)arg1)->FNextKeyId(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetKeyV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TVec< TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetKeyV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetKeyV" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetKeyV" "', argument " "2"" of type '" "TVec< TInt > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetKeyV" "', argument " "2"" of type '" "TVec< TInt > &""'"); + } + arg2 = reinterpret_cast< TVec< TInt > * >(argp2); + ((THash< TInt,TInt > const *)arg1)->GetKeyV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetDatV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TVec< TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetDatV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetDatV" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetDatV" "', argument " "2"" of type '" "TVec< TInt > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetDatV" "', argument " "2"" of type '" "TVec< TInt > &""'"); + } + arg2 = reinterpret_cast< TVec< TInt > * >(argp2); + ((THash< TInt,TInt > const *)arg1)->GetDatV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetKeyDatPrV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TVec< TPair< TInt,TInt > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetKeyDatPrV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetKeyDatPrV" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetKeyDatPrV" "', argument " "2"" of type '" "TVec< TPair< TInt,TInt > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetKeyDatPrV" "', argument " "2"" of type '" "TVec< TPair< TInt,TInt > > &""'"); + } + arg2 = reinterpret_cast< TVec< TPair< TInt,TInt > > * >(argp2); + ((THash< TInt,TInt > const *)arg1)->GetKeyDatPrV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetDatKeyPrV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TVec< TPair< TInt,TInt > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetDatKeyPrV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetDatKeyPrV" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetDatKeyPrV" "', argument " "2"" of type '" "TVec< TPair< TInt,TInt > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetDatKeyPrV" "', argument " "2"" of type '" "TVec< TPair< TInt,TInt > > &""'"); + } + arg2 = reinterpret_cast< TVec< TPair< TInt,TInt > > * >(argp2); + ((THash< TInt,TInt > const *)arg1)->GetDatKeyPrV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetKeyDatKdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TVec< TKeyDat< TInt,TInt > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetKeyDatKdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetKeyDatKdV" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetKeyDatKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TInt,TInt > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetKeyDatKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TInt,TInt > > &""'"); + } + arg2 = reinterpret_cast< TVec< TKeyDat< TInt,TInt > > * >(argp2); + ((THash< TInt,TInt > const *)arg1)->GetKeyDatKdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetDatKeyKdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + TVec< TKeyDat< TInt,TInt > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_GetDatKeyKdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetDatKeyKdV" "', argument " "1"" of type '" "THash< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_GetDatKeyKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TInt,TInt > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_GetDatKeyKdV" "', argument " "2"" of type '" "TVec< TKeyDat< TInt,TInt > > &""'"); + } + arg2 = reinterpret_cast< TVec< TKeyDat< TInt,TInt > > * >(argp2); + ((THash< TInt,TInt > const *)arg1)->GetDatKeyKdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + THash< TInt,TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_Swap",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Swap" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntH_Swap" "', argument " "2"" of type '" "THash< TInt,TInt > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntH_Swap" "', argument " "2"" of type '" "THash< TInt,TInt > &""'"); + } + arg2 = reinterpret_cast< THash< TInt,TInt > * >(argp2); + (arg1)->Swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Defrag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Defrag" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + (arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Pack" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + (arg1)->Pack(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + bool *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TIntH_Sort",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_Sort" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_Sort" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntH_Sort" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + (arg1)->Sort((bool const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_SortByKey__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_SortByKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_SortByKey" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->SortByKey((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_SortByKey__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_SortByKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + (arg1)->SortByKey(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_SortByKey(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_SortByKey",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntH_SortByKey__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntH_SortByKey__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_SortByKey'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::SortByKey(bool const &)\n" + " THash< TInt,TInt >::SortByKey()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_SortByDat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_SortByDat" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_SortByDat" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->SortByDat((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_SortByDat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_SortByDat" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + (arg1)->SortByDat(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_SortByDat(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_SortByDat",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntH_SortByDat__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TIntH_SortByDat__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_SortByDat'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::SortByDat(bool const &)\n" + " THash< TInt,TInt >::SortByDat()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddKey__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_AddKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_AddKey" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)THash_Sl_TInt_Sc_TInt_Sg__AddKey__SWIG_1(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddKey(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_AddKey",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TIntH_AddKey__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TIntH_AddKey__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_AddKey'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::AddKey(TInt const &)\n" + " THash< TInt,TInt >::AddKey(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsKey__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_IsKey" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_IsKey" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)THash_Sl_TInt_Sc_TInt_Sg__IsKey__SWIG_2(arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_IsKey(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_IsKey",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TIntH_IsKey__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TIntH_IsKey__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TIntH_IsKey__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_IsKey'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::IsKey(TInt const &) const\n" + " THash< TInt,TInt >::IsKey(TInt const &,int &) const\n" + " THash< TInt,TInt >::IsKey(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetDat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_GetDat" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_GetDat" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (TInt *) &THash_Sl_TInt_Sc_TInt_Sg__GetDat__SWIG_2(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_GetDat(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_GetDat",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TIntH_GetDat__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TIntH_GetDat__SWIG_0(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TIntH_GetDat__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_GetDat'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::GetDat(TInt const &) const\n" + " THash< TInt,TInt >::GetDat(TInt const &)\n" + " THash< TInt,TInt >::GetDat(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddDat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntH_AddDat" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TIntH_AddDat" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TIntH_AddDat" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (TInt *) &THash_Sl_TInt_Sc_TInt_Sg__AddDat__SWIG_2(arg1,arg2,arg3); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntH_AddDat(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntH_AddDat",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TIntH_AddDat__SWIG_0(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TInt, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TIntH_AddDat__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 3) { + return _wrap_TIntH_AddDat__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntH_AddDat'.\n" + " Possible C/C++ prototypes are:\n" + " THash< TInt,TInt >::AddDat(TInt const &)\n" + " THash< TInt,TInt >::AddDat(TInt const &,TInt const &)\n" + " THash< TInt,TInt >::AddDat(int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TIntH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THash< TInt,TInt > *arg1 = (THash< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TIntH" "', argument " "1"" of type '" "THash< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THash< TInt,TInt > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TIntH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TIntH_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TIntHI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (THashKeyDatI< TInt,TInt > *)new THashKeyDatI< TInt,TInt >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntHI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + THashKeyDatI< TInt,TInt > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntHI" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TIntHI" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const &""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (THashKeyDatI< TInt,TInt > *)new THashKeyDatI< TInt,TInt >((THashKeyDatI< TInt,TInt > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntHI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt >::THKeyDat *arg1 = (THashKeyDatI< TInt,TInt >::THKeyDat *) 0 ; + THashKeyDatI< TInt,TInt >::THKeyDat *arg2 = (THashKeyDatI< TInt,TInt >::THKeyDat *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + THashKeyDatI< TInt,TInt > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TIntHI" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt >::THKeyDat const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt >::THKeyDat * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_THashKeyDatT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TIntHI" "', argument " "2"" of type '" "THashKeyDatI< TInt,TInt >::THKeyDat const *""'"); + } + arg2 = reinterpret_cast< THashKeyDatI< TInt,TInt >::THKeyDat * >(argp2); + result = (THashKeyDatI< TInt,TInt > *)new THashKeyDatI< TInt,TInt >((THashKeyDatI< TInt,TInt >::THKeyDat const *)arg1,(THashKeyDatI< TInt,TInt >::THKeyDat const *)arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TIntHI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TIntHI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TIntHI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TIntHI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TIntHI__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TIntHI'.\n" + " Possible C/C++ prototypes are:\n" + " THashKeyDatI< TInt,TInt >::THashKeyDatI()\n" + " THashKeyDatI< TInt,TInt >::THashKeyDatI(THashKeyDatI< TInt,TInt > const &)\n" + " THashKeyDatI< TInt,TInt >::THashKeyDatI(THashKeyDatI< TInt,TInt >::THKeyDat const *,THashKeyDatI< TInt,TInt >::THKeyDat const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TIntHI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + THashKeyDatI< TInt,TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntHI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI___eq__" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntHI___eq__" "', argument " "2"" of type '" "THashKeyDatI< TInt,TInt > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntHI___eq__" "', argument " "2"" of type '" "THashKeyDatI< TInt,TInt > const &""'"); + } + arg2 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp2); + result = (bool)((THashKeyDatI< TInt,TInt > const *)arg1)->operator ==((THashKeyDatI< TInt,TInt > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + THashKeyDatI< TInt,TInt > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TIntHI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI___lt__" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TIntHI___lt__" "', argument " "2"" of type '" "THashKeyDatI< TInt,TInt > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntHI___lt__" "', argument " "2"" of type '" "THashKeyDatI< TInt,TInt > const &""'"); + } + arg2 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp2); + result = (bool)((THashKeyDatI< TInt,TInt > const *)arg1)->operator <((THashKeyDatI< TInt,TInt > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THashKeyDatI< TInt,TInt >::THKeyDat *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI___ref__" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (THashKeyDatI< TInt,TInt >::THKeyDat *) &((THashKeyDatI< TInt,TInt > const *)arg1)->operator *(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashKeyDatT_TInt_TInt_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THashKeyDatI< TInt,TInt >::THKeyDat *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI___call__" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (THashKeyDatI< TInt,TInt >::THKeyDat *) &((THashKeyDatI< TInt,TInt > const *)arg1)->operator ()(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashKeyDatT_TInt_TInt_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THashKeyDatI< TInt,TInt >::THKeyDat *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI___deref__" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (THashKeyDatI< TInt,TInt >::THKeyDat *)((THashKeyDatI< TInt,TInt > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashKeyDatT_TInt_TInt_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + THashKeyDatI< TInt,TInt > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI_Next" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (THashKeyDatI< TInt,TInt > *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI_IsEmpty" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (bool)((THashKeyDatI< TInt,TInt > const *)arg1)->IsEmpty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI_IsEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI_IsEnd" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (bool)((THashKeyDatI< TInt,TInt > const *)arg1)->IsEnd(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI_GetKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TInt *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI_GetKey" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (TInt *) &((THashKeyDatI< TInt,TInt > const *)arg1)->GetKey(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI_GetDat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI_GetDat" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > const *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (TInt *) &((THashKeyDatI< TInt,TInt > const *)arg1)->GetDat(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI_GetDat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TInt *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntHI_GetDat" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + result = (TInt *) &(arg1)->GetDat(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TInt, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntHI_GetDat(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TIntHI_GetDat",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TIntHI_GetDat__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TIntHI_GetDat__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TIntHI_GetDat'.\n" + " Possible C/C++ prototypes are:\n" + " THashKeyDatI< TInt,TInt >::GetDat() const\n" + " THashKeyDatI< TInt,TInt >::GetDat()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TIntHI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + THashKeyDatI< TInt,TInt > *arg1 = (THashKeyDatI< TInt,TInt > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TIntHI" "', argument " "1"" of type '" "THashKeyDatI< TInt,TInt > *""'"); + } + arg1 = reinterpret_cast< THashKeyDatI< TInt,TInt > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TIntHI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_THashKeyDatIT_TInt_TInt_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TIntHI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TStrV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TVec< TStr,int > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TVec< TStr,int > *)new TVec< TStr,int >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TStr,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrV" "', argument " "1"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrV" "', argument " "1"" of type '" "TVec< TStr,int > const &""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (TVec< TStr,int > *)new TVec< TStr,int >((TVec< TStr,int > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + TVec< TStr,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TStrV" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = (TVec< TStr,int > *)new TVec< TStr,int >((int const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TStr,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TStrV" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TStrV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TStr,int > *)new TVec< TStr,int >((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrV__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = (TStr *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TVec< TStr,int > *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrV" "', argument " "1"" of type '" "TStr *""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TStrV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TStr,int > *)new TVec< TStr,int >(arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TStrV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TStrV" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrV__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TStr,int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TStrV" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TStrV" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TVec< TStr,int > *)new TVec< TStr,int >(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TStrV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TStrV",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TStrV__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TVecT_TStr_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TStrV__SWIG_1(self, argc, argv); + } +check_2: + + if (argc == 1) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TSIn, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_new_TStrV__SWIG_5(self, argc, argv); + } +check_3: + + if (argc == 1) { + return _wrap_new_TStrV__SWIG_2(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TStr, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_5; + return _wrap_new_TStrV__SWIG_4(self, argc, argv); + } +check_5: + + if (argc == 2) { + return _wrap_new_TStrV__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TStrV'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::TVec()\n" + " TVec< TStr,int >::TVec(TVec< TStr,int > const &)\n" + " TVec< TStr,int >::TVec(int const &)\n" + " TVec< TStr,int >::TVec(int const &,int const &)\n" + " TVec< TStr,int >::TVec(TStr *,int const &)\n" + " TVec< TStr,int >::TVec(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Load" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + (arg1)->Load(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Save" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TVec< TStr,int > const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_LoadXml__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + PXmlTok *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_LoadXml" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_LoadXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->LoadXml((PXmlTok const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_LoadXml__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + PXmlTok *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_LoadXml" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TPtT_TXmlTok_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_LoadXml" "', argument " "2"" of type '" "PXmlTok const &""'"); + } + arg2 = reinterpret_cast< PXmlTok * >(argp2); + (arg1)->LoadXml((PXmlTok const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_LoadXml(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_LoadXml",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_LoadXml__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_LoadXml__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_LoadXml'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::LoadXml(PXmlTok const &,TStr const &)\n" + " TVec< TStr,int >::LoadXml(PXmlTok const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SaveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TSOut *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_SaveXml",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SaveXml" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SaveXml" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SaveXml" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + ((TVec< TStr,int > const *)arg1)->SaveXml(*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TStr,int > *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV___add__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV___add__" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV___add__" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV___add__" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (TVec< TStr,int > *) &(arg1)->operator +((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV___eq__" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV___eq__" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV___eq__" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + result = (bool)((TVec< TStr,int > const *)arg1)->operator ==((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV___lt__" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV___lt__" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV___lt__" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + result = (bool)((TVec< TStr,int > const *)arg1)->operator <((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetMemUsed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetMemUsed" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->GetMemUsed(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetMemSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetMemSize" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->GetMemSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetPrimHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetPrimHashCd" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->GetPrimHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetSecHashCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetSecHashCd" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->GetSecHashCd(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Gen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Gen" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Gen((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Gen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Gen" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Gen" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_Gen" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Gen((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Gen(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Gen",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_Gen__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Gen__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Gen'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Gen(int const &)\n" + " TVec< TStr,int >::Gen(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GenExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = (TStr *) 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_GenExt",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GenExt" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GenExt" "', argument " "2"" of type '" "TStr *""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_GenExt" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->GenExt(arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_IsExt" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (bool)((TVec< TStr,int > const *)arg1)->IsExt(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Reserve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Reserve" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Reserve((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Reserve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Reserve" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Reserve(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Reserve",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_Reserve__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Reserve__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Reserve'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Reserve(int const &)\n" + " TVec< TStr,int >::Reserve(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Clr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + bool *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Clr" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_Clr" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Clr((bool const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Clr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Clr" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Clr" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Clr((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Clr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Clr" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Clr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Clr",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_Clr__SWIG_2(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrV_Clr__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Clr__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Clr'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Clr(bool const &,int const &)\n" + " TVec< TStr,int >::Clr(bool const &)\n" + " TVec< TStr,int >::Clr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Trunc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Trunc" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Trunc" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Trunc((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Trunc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Trunc" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + (arg1)->Trunc(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Trunc(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Trunc",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_Trunc__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrV_Trunc__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Trunc'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Trunc(int const &)\n" + " TVec< TStr,int >::Trunc()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Pack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Pack" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + (arg1)->Pack(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_MoveFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_MoveFrom",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_MoveFrom" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_MoveFrom" "', argument " "2"" of type '" "TVec< TStr,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_MoveFrom" "', argument " "2"" of type '" "TVec< TStr,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + (arg1)->MoveFrom(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Swap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Swap" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Swap" "', argument " "2"" of type '" "TVec< TStr,int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Swap" "', argument " "2"" of type '" "TVec< TStr,int > &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + (arg1)->Swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Empty" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (bool)((TVec< TStr,int > const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Len" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->Len(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Reserved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Reserved" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->Reserved(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Last__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Last" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (TStr *) &((TVec< TStr,int > const *)arg1)->Last(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Last__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Last" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (TStr *) &(arg1)->Last(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Last(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Last",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_Last__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TStrV_Last__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Last'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Last() const\n" + " TVec< TStr,int >::Last()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_LastValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_LastValN" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->LastValN(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_LastLast__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_LastLast" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (TStr *) &((TVec< TStr,int > const *)arg1)->LastLast(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_LastLast__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_LastLast" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (TStr *) &(arg1)->LastLast(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_LastLast(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_LastLast",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_LastLast__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TStrV_LastLast__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_LastLast'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::LastLast() const\n" + " TVec< TStr,int >::LastLast()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_BegI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TVec< TStr,int >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_BegI" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (TVec< TStr,int >::TIter)((TVec< TStr,int > const *)arg1)->BegI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_EndI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TVec< TStr,int >::TIter result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_EndI" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (TVec< TStr,int >::TIter)((TVec< TStr,int > const *)arg1)->EndI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TVec< TStr,int >::TIter result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_GetI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetI" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_GetI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TVec< TStr,int >::TIter)((TVec< TStr,int > const *)arg1)->GetI((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_AddV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_AddV" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_AddV" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_AddV" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + result = (int)(arg1)->AddV((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddSorted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + bool *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_AddSorted" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_AddSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_AddSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_AddSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStrV_AddSorted" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (int)(arg1)->AddSorted((TStr const &)*arg2,(bool const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddSorted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_AddSorted" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_AddSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_AddSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_AddSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddSorted((TStr const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddSorted__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_AddSorted" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_AddSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_AddSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddSorted((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddSorted(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_AddSorted",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_AddSorted__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_AddSorted__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStrV_AddSorted__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_AddSorted'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::AddSorted(TStr const &,bool const &,int const &)\n" + " TVec< TStr,int >::AddSorted(TStr const &,bool const &)\n" + " TVec< TStr,int >::AddSorted(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddBackSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_AddBackSorted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_AddBackSorted" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_AddBackSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_AddBackSorted" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_AddBackSorted" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddBackSorted((TStr const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddVMerged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_AddVMerged",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_AddVMerged" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_AddVMerged" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_AddVMerged" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + result = (int)(arg1)->AddVMerged((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_AddUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_AddUnique",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_AddUnique" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_AddUnique" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_AddUnique" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddUnique((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetVal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetVal" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_GetVal" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TStr *) &((TVec< TStr,int > const *)arg1)->GetVal((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetVal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TStr *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetVal" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_GetVal" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TStr *) &(arg1)->GetVal((int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetVal(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_GetVal",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_GetVal__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrV_GetVal__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_GetVal'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::GetVal(int const &) const\n" + " TVec< TStr,int >::GetVal(int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetSubValV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TVec< TStr,int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_GetSubValV",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetSubValV" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_GetSubValV" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_GetSubValV" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStrV_GetSubValV" "', argument " "4"" of type '" "TVec< TStr,int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetSubValV" "', argument " "4"" of type '" "TVec< TStr,int > &""'"); + } + arg4 = reinterpret_cast< TVec< TStr,int > * >(argp4); + ((TVec< TStr,int > const *)arg1)->GetSubValV((int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Ins(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_Ins",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Ins" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Ins" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_Ins" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Ins" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + (arg1)->Ins((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Del__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Del" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->Del((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Del__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Del" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Del" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_Del" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Del((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Del(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Del",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_Del__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Del__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Del'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Del(int const &)\n" + " TVec< TStr,int >::Del(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_DelLast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_DelLast" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + (arg1)->DelLast(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_DelIfIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_DelIfIn",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_DelIfIn" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_DelIfIn" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_DelIfIn" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)(arg1)->DelIfIn((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_DelAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_DelAll",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_DelAll" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_DelAll" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_DelAll" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + (arg1)->DelAll((TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_PutAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_PutAll",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_PutAll" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_PutAll" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_PutAll" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + (arg1)->PutAll((TStr const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Swap" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Swap" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_Swap" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Swap((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Swap(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Swap",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_Swap__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Swap__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Swap'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Swap(TVec< TStr,int > &)\n" + " TVec< TStr,int >::Swap(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SwapI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int >::TIter arg1 = (TVec< TStr,int >::TIter) 0 ; + TVec< TStr,int >::TIter arg2 = (TVec< TStr,int >::TIter) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_SwapI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SwapI" "', argument " "1"" of type '" "TVec< TStr,int >::TIter""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int >::TIter >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_TStr, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SwapI" "', argument " "2"" of type '" "TVec< TStr,int >::TIter""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int >::TIter >(argp2); + TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR SwapI(arg1,arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_NextPerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_NextPerm" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (bool)(arg1)->NextPerm(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_PrevPerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_PrevPerm" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (bool)(arg1)->PrevPerm(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetPivotValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_GetPivotValN",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetPivotValN" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_GetPivotValN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_GetPivotValN" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TStr,int > const *)arg1)->GetPivotValN((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_BSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_BSort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_BSort" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_BSort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_BSort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStrV_BSort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->BSort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_ISort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_ISort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_ISort" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_ISort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_ISort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStrV_ISort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->ISort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Partition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_Partition",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Partition" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Partition" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_Partition" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStrV_Partition" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)(arg1)->Partition((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_QSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_QSort",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_QSort" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_QSort" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_QSort" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TStrV_QSort" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->QSort((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Sort__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Sort" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Sort" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Sort((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Sort__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Sort" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + (arg1)->Sort(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Sort(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Sort",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_Sort__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrV_Sort__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Sort'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Sort(bool const &)\n" + " TVec< TStr,int >::Sort()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsSorted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_IsSorted" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_IsSorted" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TVec< TStr,int > const *)arg1)->IsSorted((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsSorted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_IsSorted" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (bool)((TVec< TStr,int > const *)arg1)->IsSorted(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsSorted(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_IsSorted",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_IsSorted__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrV_IsSorted__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_IsSorted'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::IsSorted(bool const &) const\n" + " TVec< TStr,int >::IsSorted() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Shuffle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_Shuffle",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Shuffle" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Shuffle" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Shuffle" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + (arg1)->Shuffle(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Reverse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Reverse" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + (arg1)->Reverse(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Reverse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Reverse" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TStrV_Reverse" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_Reverse" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + (arg1)->Reverse(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Reverse(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Reverse",0,3,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_Reverse__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Reverse__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Reverse'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Reverse()\n" + " TVec< TStr,int >::Reverse(int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Merge" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + (arg1)->Merge(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Intrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Intrs" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Intrs" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Intrs" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + (arg1)->Intrs((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Union__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Union" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Union" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Union" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + (arg1)->Union((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Diff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Diff" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Diff" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Diff" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + (arg1)->Diff((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Intrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + TVec< TStr,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Intrs" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Intrs" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Intrs" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_Intrs" "', argument " "3"" of type '" "TVec< TStr,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Intrs" "', argument " "3"" of type '" "TVec< TStr,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TStr,int > * >(argp3); + ((TVec< TStr,int > const *)arg1)->Intrs((TVec< TStr,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Intrs(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Intrs",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_Intrs__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Intrs__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Intrs'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Intrs(TVec< TStr,int > const &)\n" + " TVec< TStr,int >::Intrs(TVec< TStr,int > const &,TVec< TStr,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Union__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + TVec< TStr,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Union" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Union" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Union" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_Union" "', argument " "3"" of type '" "TVec< TStr,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Union" "', argument " "3"" of type '" "TVec< TStr,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TStr,int > * >(argp3); + ((TVec< TStr,int > const *)arg1)->Union((TVec< TStr,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Union(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Union",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_Union__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Union__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Union'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Union(TVec< TStr,int > const &)\n" + " TVec< TStr,int >::Union(TVec< TStr,int > const &,TVec< TStr,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Diff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + TVec< TStr,int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Diff" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Diff" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Diff" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_Diff" "', argument " "3"" of type '" "TVec< TStr,int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Diff" "', argument " "3"" of type '" "TVec< TStr,int > &""'"); + } + arg3 = reinterpret_cast< TVec< TStr,int > * >(argp3); + ((TVec< TStr,int > const *)arg1)->Diff((TVec< TStr,int > const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Diff(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_Diff",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_Diff__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_Diff__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_Diff'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::Diff(TVec< TStr,int > const &)\n" + " TVec< TStr,int >::Diff(TVec< TStr,int > const &,TVec< TStr,int > &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IntrsLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_IntrsLen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_IntrsLen" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_IntrsLen" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_IntrsLen" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + result = (int)((TVec< TStr,int > const *)arg1)->IntrsLen((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_UnionLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_UnionLen",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_UnionLen" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_UnionLen" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_UnionLen" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + result = (int)((TVec< TStr,int > const *)arg1)->UnionLen((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_Count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_Count",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_Count" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_Count" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_Count" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)((TVec< TStr,int > const *)arg1)->Count((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchBin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SearchBin" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SearchBin" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchBin" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)((TVec< TStr,int > const *)arg1)->SearchBin((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchBin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SearchBin" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SearchBin" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchBin" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_SearchBin" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchBin" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (int)((TVec< TStr,int > const *)arg1)->SearchBin((TStr const &)*arg2,*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchBin(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_SearchBin",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_SearchBin__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_SearchBin__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_SearchBin'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::SearchBin(TStr const &) const\n" + " TVec< TStr,int >::SearchBin(TStr const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchForw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SearchForw" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SearchForw" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchForw" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_SearchForw" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TStr,int > const *)arg1)->SearchForw((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchForw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SearchForw" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SearchForw" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchForw" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)((TVec< TStr,int > const *)arg1)->SearchForw((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchForw(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_SearchForw",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_SearchForw__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_SearchForw__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_SearchForw'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::SearchForw(TStr const &,int const &) const\n" + " TVec< TStr,int >::SearchForw(TStr const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_SearchBack",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SearchBack" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SearchBack" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchBack" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)((TVec< TStr,int > const *)arg1)->SearchBack((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchVForw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SearchVForw" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SearchVForw" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchVForw" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TStrV_SearchVForw" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TVec< TStr,int > const *)arg1)->SearchVForw((TVec< TStr,int > const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchVForw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TVec< TStr,int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_SearchVForw" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_SearchVForw" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_SearchVForw" "', argument " "2"" of type '" "TVec< TStr,int > const &""'"); + } + arg2 = reinterpret_cast< TVec< TStr,int > * >(argp2); + result = (int)((TVec< TStr,int > const *)arg1)->SearchVForw((TVec< TStr,int > const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_SearchVForw(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_SearchVForw",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_SearchVForw__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_SearchVForw__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_SearchVForw'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::SearchVForw(TVec< TStr,int > const &,int const &) const\n" + " TVec< TStr,int >::SearchVForw(TVec< TStr,int > const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsIn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_IsIn" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_IsIn" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_IsIn" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TVec< TStr,int > const *)arg1)->IsIn((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsIn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_IsIn" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_IsIn" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_IsIn" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_IsIn" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_IsIn" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + result = (bool)((TVec< TStr,int > const *)arg1)->IsIn((TStr const &)*arg2,*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsIn(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_IsIn",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TStrV_IsIn__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_IsIn__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_IsIn'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::IsIn(TStr const &) const\n" + " TVec< TStr,int >::IsIn(TStr const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TStrV_IsInBin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_IsInBin",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_IsInBin" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_IsInBin" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_IsInBin" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (bool)((TVec< TStr,int > const *)arg1)->IsInBin((TStr const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TStr *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_GetDat",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetDat" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetDat" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetDat" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (TStr *) &((TVec< TStr,int > const *)arg1)->GetDat((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetAddDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + TStr *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args,"TStrV_GetAddDat",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetAddDat" "', argument " "1"" of type '" "TVec< TStr,int > *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetAddDat" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetAddDat" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (TStr *) &(arg1)->GetAddDat((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TStr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetMxValN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TVec< TStr,int > *arg1 = (TVec< TStr,int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TVecT_TStr_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetMxValN" "', argument " "1"" of type '" "TVec< TStr,int > const *""'"); + } + arg1 = reinterpret_cast< TVec< TStr,int > * >(argp1); + result = (int)((TVec< TStr,int > const *)arg1)->GetMxValN(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + TStr *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + arg5 = reinterpret_cast< TStr * >(argp5); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(TStr const &)*arg5); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + TStr *arg5 = 0 ; + TStr *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + arg5 = reinterpret_cast< TStr * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + arg6 = reinterpret_cast< TStr * >(argp6); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(TStr const &)*arg5,(TStr const &)*arg6); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + TStr *arg5 = 0 ; + TStr *arg6 = 0 ; + TStr *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + arg5 = reinterpret_cast< TStr * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + arg6 = reinterpret_cast< TStr * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TStrV_GetV" "', argument " "7"" of type '" "TStr const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "7"" of type '" "TStr const &""'"); + } + arg7 = reinterpret_cast< TStr * >(argp7); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(TStr const &)*arg5,(TStr const &)*arg6,(TStr const &)*arg7); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + TStr *arg5 = 0 ; + TStr *arg6 = 0 ; + TStr *arg7 = 0 ; + TStr *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + arg5 = reinterpret_cast< TStr * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + arg6 = reinterpret_cast< TStr * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TStrV_GetV" "', argument " "7"" of type '" "TStr const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "7"" of type '" "TStr const &""'"); + } + arg7 = reinterpret_cast< TStr * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TStrV_GetV" "', argument " "8"" of type '" "TStr const &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "8"" of type '" "TStr const &""'"); + } + arg8 = reinterpret_cast< TStr * >(argp8); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(TStr const &)*arg5,(TStr const &)*arg6,(TStr const &)*arg7,(TStr const &)*arg8); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + TStr *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + TStr *arg5 = 0 ; + TStr *arg6 = 0 ; + TStr *arg7 = 0 ; + TStr *arg8 = 0 ; + TStr *arg9 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + void *argp9 = 0 ; + int res9 = 0 ; + TVec< TStr,int > result; + + if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "5"" of type '" "TStr const &""'"); + } + arg5 = reinterpret_cast< TStr * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "6"" of type '" "TStr const &""'"); + } + arg6 = reinterpret_cast< TStr * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TStrV_GetV" "', argument " "7"" of type '" "TStr const &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "7"" of type '" "TStr const &""'"); + } + arg7 = reinterpret_cast< TStr * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TStrV_GetV" "', argument " "8"" of type '" "TStr const &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "8"" of type '" "TStr const &""'"); + } + arg8 = reinterpret_cast< TStr * >(argp8); + res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res9)) { + SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "TStrV_GetV" "', argument " "9"" of type '" "TStr const &""'"); + } + if (!argp9) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TStrV_GetV" "', argument " "9"" of type '" "TStr const &""'"); + } + arg9 = reinterpret_cast< TStr * >(argp9); + result = TVec< TStr,int >::SWIGTEMPLATEDISAMBIGUATOR GetV((TStr const &)*arg1,(TStr const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(TStr const &)*arg5,(TStr const &)*arg6,(TStr const &)*arg7,(TStr const &)*arg8,(TStr const &)*arg9); + resultobj = SWIG_NewPointerObj((new TVec< TStr,int >(static_cast< const TVec< TStr,int >& >(result))), SWIGTYPE_p_TVecT_TStr_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TStrV_GetV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[10]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TStrV_GetV",0,9,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TStrV_GetV__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TStrV_GetV__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TStrV_GetV__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_TStrV_GetV__SWIG_3(self, argc, argv); + } + if (argc == 5) { + return _wrap_TStrV_GetV__SWIG_4(self, argc, argv); + } + if (argc == 6) { + return _wrap_TStrV_GetV__SWIG_5(self, argc, argv); + } + if (argc == 7) { + return _wrap_TStrV_GetV__SWIG_6(self, argc, argv); + } + if (argc == 8) { + return _wrap_TStrV_GetV__SWIG_7(self, argc, argv); + } + if (argc == 9) { + return _wrap_TStrV_GetV__SWIG_8(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TStrV_GetV'.\n" + " Possible C/C++ prototypes are:\n" + " TVec< TStr,int >::GetV(TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &,TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &,TStr const &,TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &,TStr const &,TStr const &,TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &)\n" + " TVec< TStr,int >::GetV(TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *TStrV_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TVecT_TStr_int_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TStrV_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNGraphNodeI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNGraphNodeI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNGraphNodeI *)new TNGraphNodeI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphNodeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraphNodeI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph::TNodeI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNGraphNodeI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNGraph__TNodeI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNGraphNodeI" "', argument " "1"" of type '" "TNGraph::TNodeI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNGraphNodeI" "', argument " "1"" of type '" "TNGraph::TNodeI const &""'"); + } + arg1 = reinterpret_cast< TNGraph::TNodeI * >(argp1); + result = (TNGraphNodeI *)new TNGraphNodeI((TNGraph::TNodeI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphNodeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraphNodeI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNGraphNodeI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNGraphNodeI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TNGraphNodeI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNGraphNodeI'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraphNodeI::TNGraphNodeI()\n" + " TNGraphNodeI::TNGraphNodeI(TNGraph::TNodeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNGraphNodeI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_Next" "', argument " "1"" of type '" "TNGraphNodeI *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + result = (TNGraphNodeI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + TNGraphNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI___lt__" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNGraphNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphNodeI___lt__" "', argument " "2"" of type '" "TNGraphNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphNodeI___lt__" "', argument " "2"" of type '" "TNGraphNodeI const &""'"); + } + arg2 = reinterpret_cast< TNGraphNodeI * >(argp2); + result = (bool)((TNGraphNodeI const *)arg1)->operator <((TNGraphNodeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + TNGraphNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI___eq__" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNGraphNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphNodeI___eq__" "', argument " "2"" of type '" "TNGraphNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphNodeI___eq__" "', argument " "2"" of type '" "TNGraphNodeI const &""'"); + } + arg2 = reinterpret_cast< TNGraphNodeI * >(argp2); + result = (bool)((TNGraphNodeI const *)arg1)->operator ==((TNGraphNodeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_GetId" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + result = (int)((TNGraphNodeI const *)arg1)->GetId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_GetDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_GetDeg" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + result = (int)((TNGraphNodeI const *)arg1)->GetDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_GetInDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_GetInDeg" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + result = (int)((TNGraphNodeI const *)arg1)->GetInDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_GetOutDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_GetOutDeg" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + result = (int)((TNGraphNodeI const *)arg1)->GetOutDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_GetInNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI_GetInNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_GetInNId" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraphNodeI_GetInNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TNGraphNodeI const *)arg1)->GetInNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_GetOutNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI_GetOutNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_GetOutNId" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraphNodeI_GetOutNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TNGraphNodeI const *)arg1)->GetOutNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_GetNbrNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI_GetNbrNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_GetNbrNId" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraphNodeI_GetNbrNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TNGraphNodeI const *)arg1)->GetNbrNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_IsInNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI_IsInNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_IsInNId" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraphNodeI_IsInNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNGraphNodeI const *)arg1)->IsInNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_IsOutNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI_IsOutNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_IsOutNId" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraphNodeI_IsOutNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNGraphNodeI const *)arg1)->IsOutNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphNodeI_IsNbrNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphNodeI_IsNbrNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphNodeI_IsNbrNId" "', argument " "1"" of type '" "TNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNGraphNodeI_IsNbrNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNGraphNodeI const *)arg1)->IsNbrNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNGraphNodeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphNodeI *arg1 = (TNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphNodeI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNGraphNodeI" "', argument " "1"" of type '" "TNGraphNodeI *""'"); + } + arg1 = reinterpret_cast< TNGraphNodeI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNGraphNodeI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNGraphNodeI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNGraphNodeI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNGraphEdgeI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNGraphEdgeI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNGraphEdgeI *)new TNGraphEdgeI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphEdgeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraphEdgeI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNGraph::TEdgeI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNGraphEdgeI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNGraph__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNGraphEdgeI" "', argument " "1"" of type '" "TNGraph::TEdgeI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNGraphEdgeI" "', argument " "1"" of type '" "TNGraph::TEdgeI const &""'"); + } + arg1 = reinterpret_cast< TNGraph::TEdgeI * >(argp1); + result = (TNGraphEdgeI *)new TNGraphEdgeI((TNGraph::TEdgeI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphEdgeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNGraphEdgeI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNGraphEdgeI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNGraphEdgeI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TNGraphEdgeI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNGraphEdgeI'.\n" + " Possible C/C++ prototypes are:\n" + " TNGraphEdgeI::TNGraphEdgeI()\n" + " TNGraphEdgeI::TNGraphEdgeI(TNGraph::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNGraphEdgeI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphEdgeI *arg1 = (TNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNGraphEdgeI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphEdgeI_Next" "', argument " "1"" of type '" "TNGraphEdgeI *""'"); + } + arg1 = reinterpret_cast< TNGraphEdgeI * >(argp1); + result = (TNGraphEdgeI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNGraphEdgeI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphEdgeI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphEdgeI *arg1 = (TNGraphEdgeI *) 0 ; + TNGraphEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphEdgeI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphEdgeI___lt__" "', argument " "1"" of type '" "TNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphEdgeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNGraphEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphEdgeI___lt__" "', argument " "2"" of type '" "TNGraphEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphEdgeI___lt__" "', argument " "2"" of type '" "TNGraphEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNGraphEdgeI * >(argp2); + result = (bool)((TNGraphEdgeI const *)arg1)->operator <((TNGraphEdgeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphEdgeI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphEdgeI *arg1 = (TNGraphEdgeI *) 0 ; + TNGraphEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNGraphEdgeI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphEdgeI___eq__" "', argument " "1"" of type '" "TNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphEdgeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNGraphEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNGraphEdgeI___eq__" "', argument " "2"" of type '" "TNGraphEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNGraphEdgeI___eq__" "', argument " "2"" of type '" "TNGraphEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNGraphEdgeI * >(argp2); + result = (bool)((TNGraphEdgeI const *)arg1)->operator ==((TNGraphEdgeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphEdgeI_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphEdgeI *arg1 = (TNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphEdgeI_GetId" "', argument " "1"" of type '" "TNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphEdgeI * >(argp1); + result = (int)((TNGraphEdgeI const *)arg1)->GetId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphEdgeI_GetSrcNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphEdgeI *arg1 = (TNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphEdgeI_GetSrcNId" "', argument " "1"" of type '" "TNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphEdgeI * >(argp1); + result = (int)((TNGraphEdgeI const *)arg1)->GetSrcNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNGraphEdgeI_GetDstNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphEdgeI *arg1 = (TNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNGraphEdgeI_GetDstNId" "', argument " "1"" of type '" "TNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNGraphEdgeI * >(argp1); + result = (int)((TNGraphEdgeI const *)arg1)->GetDstNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNGraphEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNGraphEdgeI *arg1 = (TNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNGraphEdgeI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNGraphEdgeI" "', argument " "1"" of type '" "TNGraphEdgeI *""'"); + } + arg1 = reinterpret_cast< TNGraphEdgeI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNGraphEdgeI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNGraphEdgeI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNGraphEdgeI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TUNGraphNodeI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TUNGraphNodeI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TUNGraphNodeI *)new TUNGraphNodeI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphNodeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraphNodeI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph::TNodeI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUNGraphNodeI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TUNGraph__TNodeI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUNGraphNodeI" "', argument " "1"" of type '" "TUNGraph::TNodeI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUNGraphNodeI" "', argument " "1"" of type '" "TUNGraph::TNodeI const &""'"); + } + arg1 = reinterpret_cast< TUNGraph::TNodeI * >(argp1); + result = (TUNGraphNodeI *)new TUNGraphNodeI((TUNGraph::TNodeI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphNodeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraphNodeI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUNGraphNodeI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TUNGraphNodeI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TUNGraphNodeI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUNGraphNodeI'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraphNodeI::TUNGraphNodeI()\n" + " TUNGraphNodeI::TUNGraphNodeI(TUNGraph::TNodeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUNGraphNodeI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_Next" "', argument " "1"" of type '" "TUNGraphNodeI *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + result = (TUNGraphNodeI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + TUNGraphNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI___lt__" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUNGraphNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphNodeI___lt__" "', argument " "2"" of type '" "TUNGraphNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphNodeI___lt__" "', argument " "2"" of type '" "TUNGraphNodeI const &""'"); + } + arg2 = reinterpret_cast< TUNGraphNodeI * >(argp2); + result = (bool)((TUNGraphNodeI const *)arg1)->operator <((TUNGraphNodeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + TUNGraphNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI___eq__" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUNGraphNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphNodeI___eq__" "', argument " "2"" of type '" "TUNGraphNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphNodeI___eq__" "', argument " "2"" of type '" "TUNGraphNodeI const &""'"); + } + arg2 = reinterpret_cast< TUNGraphNodeI * >(argp2); + result = (bool)((TUNGraphNodeI const *)arg1)->operator ==((TUNGraphNodeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_GetId" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + result = (int)((TUNGraphNodeI const *)arg1)->GetId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_GetDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_GetDeg" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + result = (int)((TUNGraphNodeI const *)arg1)->GetDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_GetInDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_GetInDeg" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + result = (int)((TUNGraphNodeI const *)arg1)->GetInDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_GetOutDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_GetOutDeg" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + result = (int)((TUNGraphNodeI const *)arg1)->GetOutDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_GetInNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI_GetInNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_GetInNId" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraphNodeI_GetInNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TUNGraphNodeI const *)arg1)->GetInNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_GetOutNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI_GetOutNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_GetOutNId" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraphNodeI_GetOutNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TUNGraphNodeI const *)arg1)->GetOutNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_GetNbrNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI_GetNbrNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_GetNbrNId" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraphNodeI_GetNbrNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TUNGraphNodeI const *)arg1)->GetNbrNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_IsInNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI_IsInNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_IsInNId" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraphNodeI_IsInNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TUNGraphNodeI const *)arg1)->IsInNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_IsOutNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI_IsOutNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_IsOutNId" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraphNodeI_IsOutNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TUNGraphNodeI const *)arg1)->IsOutNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphNodeI_IsNbrNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphNodeI_IsNbrNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphNodeI_IsNbrNId" "', argument " "1"" of type '" "TUNGraphNodeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TUNGraphNodeI_IsNbrNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TUNGraphNodeI const *)arg1)->IsNbrNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TUNGraphNodeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphNodeI *arg1 = (TUNGraphNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphNodeI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUNGraphNodeI" "', argument " "1"" of type '" "TUNGraphNodeI *""'"); + } + arg1 = reinterpret_cast< TUNGraphNodeI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUNGraphNodeI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUNGraphNodeI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUNGraphNodeI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TUNGraphEdgeI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TUNGraphEdgeI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TUNGraphEdgeI *)new TUNGraphEdgeI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphEdgeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraphEdgeI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TUNGraph::TEdgeI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TUNGraphEdgeI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TUNGraph__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TUNGraphEdgeI" "', argument " "1"" of type '" "TUNGraph::TEdgeI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TUNGraphEdgeI" "', argument " "1"" of type '" "TUNGraph::TEdgeI const &""'"); + } + arg1 = reinterpret_cast< TUNGraph::TEdgeI * >(argp1); + result = (TUNGraphEdgeI *)new TUNGraphEdgeI((TUNGraph::TEdgeI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphEdgeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TUNGraphEdgeI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TUNGraphEdgeI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TUNGraphEdgeI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TUNGraphEdgeI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TUNGraphEdgeI'.\n" + " Possible C/C++ prototypes are:\n" + " TUNGraphEdgeI::TUNGraphEdgeI()\n" + " TUNGraphEdgeI::TUNGraphEdgeI(TUNGraph::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphEdgeI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphEdgeI *arg1 = (TUNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUNGraphEdgeI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphEdgeI_Next" "', argument " "1"" of type '" "TUNGraphEdgeI *""'"); + } + arg1 = reinterpret_cast< TUNGraphEdgeI * >(argp1); + result = (TUNGraphEdgeI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TUNGraphEdgeI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphEdgeI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphEdgeI *arg1 = (TUNGraphEdgeI *) 0 ; + TUNGraphEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphEdgeI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphEdgeI___lt__" "', argument " "1"" of type '" "TUNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphEdgeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUNGraphEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphEdgeI___lt__" "', argument " "2"" of type '" "TUNGraphEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphEdgeI___lt__" "', argument " "2"" of type '" "TUNGraphEdgeI const &""'"); + } + arg2 = reinterpret_cast< TUNGraphEdgeI * >(argp2); + result = (bool)((TUNGraphEdgeI const *)arg1)->operator <((TUNGraphEdgeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphEdgeI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphEdgeI *arg1 = (TUNGraphEdgeI *) 0 ; + TUNGraphEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TUNGraphEdgeI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphEdgeI___eq__" "', argument " "1"" of type '" "TUNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphEdgeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TUNGraphEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TUNGraphEdgeI___eq__" "', argument " "2"" of type '" "TUNGraphEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TUNGraphEdgeI___eq__" "', argument " "2"" of type '" "TUNGraphEdgeI const &""'"); + } + arg2 = reinterpret_cast< TUNGraphEdgeI * >(argp2); + result = (bool)((TUNGraphEdgeI const *)arg1)->operator ==((TUNGraphEdgeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphEdgeI_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphEdgeI *arg1 = (TUNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphEdgeI_GetId" "', argument " "1"" of type '" "TUNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphEdgeI * >(argp1); + result = (int)((TUNGraphEdgeI const *)arg1)->GetId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphEdgeI_GetSrcNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphEdgeI *arg1 = (TUNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphEdgeI_GetSrcNId" "', argument " "1"" of type '" "TUNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphEdgeI * >(argp1); + result = (int)((TUNGraphEdgeI const *)arg1)->GetSrcNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TUNGraphEdgeI_GetDstNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphEdgeI *arg1 = (TUNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TUNGraphEdgeI_GetDstNId" "', argument " "1"" of type '" "TUNGraphEdgeI const *""'"); + } + arg1 = reinterpret_cast< TUNGraphEdgeI * >(argp1); + result = (int)((TUNGraphEdgeI const *)arg1)->GetDstNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TUNGraphEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TUNGraphEdgeI *arg1 = (TUNGraphEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TUNGraphEdgeI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TUNGraphEdgeI" "', argument " "1"" of type '" "TUNGraphEdgeI *""'"); + } + arg1 = reinterpret_cast< TUNGraphEdgeI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TUNGraphEdgeI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TUNGraphEdgeI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TUNGraphEdgeI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNEANetNodeI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNEANetNodeI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNEANetNodeI *)new TNEANetNodeI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetNodeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetNodeI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet::TNodeI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetNodeI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetNodeI" "', argument " "1"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetNodeI" "', argument " "1"" of type '" "TNEANet::TNodeI const &""'"); + } + arg1 = reinterpret_cast< TNEANet::TNodeI * >(argp1); + result = (TNEANetNodeI *)new TNEANetNodeI((TNEANet::TNodeI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetNodeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetNodeI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNEANetNodeI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNEANetNodeI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TNEANetNodeI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNEANetNodeI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANetNodeI::TNEANetNodeI()\n" + " TNEANetNodeI::TNEANetNodeI(TNEANet::TNodeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANetNodeI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_Next" "', argument " "1"" of type '" "TNEANetNodeI *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + result = (TNEANetNodeI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + TNEANetNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI___lt__" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetNodeI___lt__" "', argument " "2"" of type '" "TNEANetNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetNodeI___lt__" "', argument " "2"" of type '" "TNEANetNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANetNodeI * >(argp2); + result = (bool)((TNEANetNodeI const *)arg1)->operator <((TNEANetNodeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + TNEANetNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI___eq__" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetNodeI___eq__" "', argument " "2"" of type '" "TNEANetNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetNodeI___eq__" "', argument " "2"" of type '" "TNEANetNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANetNodeI * >(argp2); + result = (bool)((TNEANetNodeI const *)arg1)->operator ==((TNEANetNodeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_GetId" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + result = (int)((TNEANetNodeI const *)arg1)->GetId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_GetDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_GetDeg" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + result = (int)((TNEANetNodeI const *)arg1)->GetDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_GetInDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_GetInDeg" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + result = (int)((TNEANetNodeI const *)arg1)->GetInDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_GetOutDeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_GetOutDeg" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + result = (int)((TNEANetNodeI const *)arg1)->GetOutDeg(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_GetInNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI_GetInNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_GetInNId" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANetNodeI_GetInNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TNEANetNodeI const *)arg1)->GetInNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_GetOutNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI_GetOutNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_GetOutNId" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANetNodeI_GetOutNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TNEANetNodeI const *)arg1)->GetOutNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_GetNbrNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI_GetNbrNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_GetNbrNId" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANetNodeI_GetNbrNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)((TNEANetNodeI const *)arg1)->GetNbrNId((int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_IsInNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI_IsInNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_IsInNId" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANetNodeI_IsInNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNEANetNodeI const *)arg1)->IsInNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_IsOutNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI_IsOutNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_IsOutNId" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANetNodeI_IsOutNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNEANetNodeI const *)arg1)->IsOutNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetNodeI_IsNbrNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetNodeI_IsNbrNId",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetNodeI_IsNbrNId" "', argument " "1"" of type '" "TNEANetNodeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANetNodeI_IsNbrNId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNEANetNodeI const *)arg1)->IsNbrNId((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNEANetNodeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetNodeI *arg1 = (TNEANetNodeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetNodeI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNEANetNodeI" "', argument " "1"" of type '" "TNEANetNodeI *""'"); + } + arg1 = reinterpret_cast< TNEANetNodeI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNEANetNodeI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNEANetNodeI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNEANetNodeI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNEANetEdgeI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNEANetEdgeI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNEANetEdgeI *)new TNEANetEdgeI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetEdgeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetEdgeI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet::TEdgeI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetEdgeI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetEdgeI" "', argument " "1"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetEdgeI" "', argument " "1"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg1 = reinterpret_cast< TNEANet::TEdgeI * >(argp1); + result = (TNEANetEdgeI *)new TNEANetEdgeI((TNEANet::TEdgeI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetEdgeI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetEdgeI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNEANetEdgeI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNEANetEdgeI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TNEANetEdgeI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNEANetEdgeI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANetEdgeI::TNEANetEdgeI()\n" + " TNEANetEdgeI::TNEANetEdgeI(TNEANet::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANetEdgeI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetEdgeI *arg1 = (TNEANetEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANetEdgeI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetEdgeI_Next" "', argument " "1"" of type '" "TNEANetEdgeI *""'"); + } + arg1 = reinterpret_cast< TNEANetEdgeI * >(argp1); + result = (TNEANetEdgeI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetEdgeI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetEdgeI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetEdgeI *arg1 = (TNEANetEdgeI *) 0 ; + TNEANetEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetEdgeI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetEdgeI___lt__" "', argument " "1"" of type '" "TNEANetEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetEdgeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetEdgeI___lt__" "', argument " "2"" of type '" "TNEANetEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetEdgeI___lt__" "', argument " "2"" of type '" "TNEANetEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANetEdgeI * >(argp2); + result = (bool)((TNEANetEdgeI const *)arg1)->operator <((TNEANetEdgeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetEdgeI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetEdgeI *arg1 = (TNEANetEdgeI *) 0 ; + TNEANetEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetEdgeI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetEdgeI___eq__" "', argument " "1"" of type '" "TNEANetEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetEdgeI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetEdgeI___eq__" "', argument " "2"" of type '" "TNEANetEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetEdgeI___eq__" "', argument " "2"" of type '" "TNEANetEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANetEdgeI * >(argp2); + result = (bool)((TNEANetEdgeI const *)arg1)->operator ==((TNEANetEdgeI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetEdgeI_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetEdgeI *arg1 = (TNEANetEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetEdgeI_GetId" "', argument " "1"" of type '" "TNEANetEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetEdgeI * >(argp1); + result = (int)((TNEANetEdgeI const *)arg1)->GetId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetEdgeI_GetSrcNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetEdgeI *arg1 = (TNEANetEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetEdgeI_GetSrcNId" "', argument " "1"" of type '" "TNEANetEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetEdgeI * >(argp1); + result = (int)((TNEANetEdgeI const *)arg1)->GetSrcNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetEdgeI_GetDstNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetEdgeI *arg1 = (TNEANetEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetEdgeI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetEdgeI_GetDstNId" "', argument " "1"" of type '" "TNEANetEdgeI const *""'"); + } + arg1 = reinterpret_cast< TNEANetEdgeI * >(argp1); + result = (int)((TNEANetEdgeI const *)arg1)->GetDstNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNEANetEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetEdgeI *arg1 = (TNEANetEdgeI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetEdgeI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNEANetEdgeI" "', argument " "1"" of type '" "TNEANetEdgeI *""'"); + } + arg1 = reinterpret_cast< TNEANetEdgeI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNEANetEdgeI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNEANetEdgeI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNEANetEdgeI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNEANetAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNEANetAIntI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNEANetAIntI *)new TNEANetAIntI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TIntVecIter *arg1 = 0 ; + TStr arg2 ; + bool arg3 ; + TNEANet *arg4 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + TNEANetAIntI *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TIntV__TIter, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetAIntI" "', argument " "1"" of type '" "TIntVecIter const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAIntI" "', argument " "1"" of type '" "TIntVecIter const &""'"); + } + arg1 = reinterpret_cast< TIntVecIter * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TNEANetAIntI" "', argument " "2"" of type '" "TStr""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAIntI" "', argument " "2"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TNEANetAIntI" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_TNEANetAIntI" "', argument " "4"" of type '" "TNEANet const *""'"); + } + arg4 = reinterpret_cast< TNEANet * >(argp4); + result = (TNEANetAIntI *)new TNEANetAIntI((TIntVecIter const &)*arg1,arg2,arg3,(TNEANet const *)arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAIntI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet::TAIntI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetAIntI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNEANet__TAIntI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetAIntI" "', argument " "1"" of type '" "TNEANet::TAIntI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAIntI" "', argument " "1"" of type '" "TNEANet::TAIntI const &""'"); + } + arg1 = reinterpret_cast< TNEANet::TAIntI * >(argp1); + result = (TNEANetAIntI *)new TNEANetAIntI((TNEANet::TAIntI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNEANetAIntI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNEANetAIntI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TNEANetAIntI__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_new_TNEANetAIntI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNEANetAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANetAIntI::TNEANetAIntI()\n" + " TNEANetAIntI::TNEANetAIntI(TIntVecIter const &,TStr,bool,TNEANet const *)\n" + " TNEANetAIntI::TNEANetAIntI(TNEANet::TAIntI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAIntI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAIntI *arg1 = (TNEANetAIntI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANetAIntI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAIntI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAIntI_Next" "', argument " "1"" of type '" "TNEANetAIntI *""'"); + } + arg1 = reinterpret_cast< TNEANetAIntI * >(argp1); + result = (TNEANetAIntI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAIntI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAIntI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAIntI *arg1 = (TNEANetAIntI *) 0 ; + TNEANetAIntI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetAIntI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAIntI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAIntI___lt__" "', argument " "1"" of type '" "TNEANetAIntI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAIntI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetAIntI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetAIntI___lt__" "', argument " "2"" of type '" "TNEANetAIntI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetAIntI___lt__" "', argument " "2"" of type '" "TNEANetAIntI const &""'"); + } + arg2 = reinterpret_cast< TNEANetAIntI * >(argp2); + result = (bool)((TNEANetAIntI const *)arg1)->operator <((TNEANetAIntI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAIntI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAIntI *arg1 = (TNEANetAIntI *) 0 ; + TNEANetAIntI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetAIntI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAIntI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAIntI___eq__" "', argument " "1"" of type '" "TNEANetAIntI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAIntI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetAIntI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetAIntI___eq__" "', argument " "2"" of type '" "TNEANetAIntI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetAIntI___eq__" "', argument " "2"" of type '" "TNEANetAIntI const &""'"); + } + arg2 = reinterpret_cast< TNEANetAIntI * >(argp2); + result = (bool)((TNEANetAIntI const *)arg1)->operator ==((TNEANetAIntI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAIntI_GetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAIntI *arg1 = (TNEANetAIntI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAIntI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAIntI_GetDat" "', argument " "1"" of type '" "TNEANetAIntI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAIntI * >(argp1); + result = (int)((TNEANetAIntI const *)arg1)->GetDat(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAIntI_IsDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAIntI *arg1 = (TNEANetAIntI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAIntI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAIntI_IsDeleted" "', argument " "1"" of type '" "TNEANetAIntI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAIntI * >(argp1); + result = (bool)((TNEANetAIntI const *)arg1)->IsDeleted(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNEANetAIntI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAIntI *arg1 = (TNEANetAIntI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNEANetAIntI" "', argument " "1"" of type '" "TNEANetAIntI *""'"); + } + arg1 = reinterpret_cast< TNEANetAIntI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNEANetAIntI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNEANetAIntI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNEANetAIntI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNEANetAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNEANetAStrI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNEANetAStrI *)new TNEANetAStrI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStrVecIter *arg1 = 0 ; + TStr arg2 ; + bool arg3 ; + TNEANet *arg4 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + TNEANetAStrI *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStrV__TIter, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetAStrI" "', argument " "1"" of type '" "TStrVecIter const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAStrI" "', argument " "1"" of type '" "TStrVecIter const &""'"); + } + arg1 = reinterpret_cast< TStrVecIter * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TNEANetAStrI" "', argument " "2"" of type '" "TStr""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAStrI" "', argument " "2"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TNEANetAStrI" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_TNEANetAStrI" "', argument " "4"" of type '" "TNEANet const *""'"); + } + arg4 = reinterpret_cast< TNEANet * >(argp4); + result = (TNEANetAStrI *)new TNEANetAStrI((TStrVecIter const &)*arg1,arg2,arg3,(TNEANet const *)arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAStrI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet::TAStrI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetAStrI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNEANet__TAStrI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetAStrI" "', argument " "1"" of type '" "TNEANet::TAStrI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAStrI" "', argument " "1"" of type '" "TNEANet::TAStrI const &""'"); + } + arg1 = reinterpret_cast< TNEANet::TAStrI * >(argp1); + result = (TNEANetAStrI *)new TNEANetAStrI((TNEANet::TAStrI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNEANetAStrI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNEANetAStrI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TNEANetAStrI__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_new_TNEANetAStrI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNEANetAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANetAStrI::TNEANetAStrI()\n" + " TNEANetAStrI::TNEANetAStrI(TStrVecIter const &,TStr,bool,TNEANet const *)\n" + " TNEANetAStrI::TNEANetAStrI(TNEANet::TAStrI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAStrI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAStrI *arg1 = (TNEANetAStrI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANetAStrI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAStrI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAStrI_Next" "', argument " "1"" of type '" "TNEANetAStrI *""'"); + } + arg1 = reinterpret_cast< TNEANetAStrI * >(argp1); + result = (TNEANetAStrI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAStrI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAStrI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAStrI *arg1 = (TNEANetAStrI *) 0 ; + TNEANetAStrI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetAStrI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAStrI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAStrI___lt__" "', argument " "1"" of type '" "TNEANetAStrI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAStrI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetAStrI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetAStrI___lt__" "', argument " "2"" of type '" "TNEANetAStrI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetAStrI___lt__" "', argument " "2"" of type '" "TNEANetAStrI const &""'"); + } + arg2 = reinterpret_cast< TNEANetAStrI * >(argp2); + result = (bool)((TNEANetAStrI const *)arg1)->operator <((TNEANetAStrI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAStrI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAStrI *arg1 = (TNEANetAStrI *) 0 ; + TNEANetAStrI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetAStrI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAStrI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAStrI___eq__" "', argument " "1"" of type '" "TNEANetAStrI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAStrI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetAStrI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetAStrI___eq__" "', argument " "2"" of type '" "TNEANetAStrI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetAStrI___eq__" "', argument " "2"" of type '" "TNEANetAStrI const &""'"); + } + arg2 = reinterpret_cast< TNEANetAStrI * >(argp2); + result = (bool)((TNEANetAStrI const *)arg1)->operator ==((TNEANetAStrI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAStrI_GetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAStrI *arg1 = (TNEANetAStrI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAStrI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAStrI_GetDat" "', argument " "1"" of type '" "TNEANetAStrI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAStrI * >(argp1); + result = (char *)((TNEANetAStrI const *)arg1)->GetDat(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAStrI_IsDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAStrI *arg1 = (TNEANetAStrI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAStrI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAStrI_IsDeleted" "', argument " "1"" of type '" "TNEANetAStrI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAStrI * >(argp1); + result = (bool)((TNEANetAStrI const *)arg1)->IsDeleted(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNEANetAStrI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAStrI *arg1 = (TNEANetAStrI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNEANetAStrI" "', argument " "1"" of type '" "TNEANetAStrI *""'"); + } + arg1 = reinterpret_cast< TNEANetAStrI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNEANetAStrI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNEANetAStrI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNEANetAStrI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TNEANetAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNEANetAFltI *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNEANetAFltI *)new TNEANetAFltI(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TFltVecIter *arg1 = 0 ; + TStr arg2 ; + bool arg3 ; + TNEANet *arg4 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + TNEANetAFltI *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TFltV__TIter, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetAFltI" "', argument " "1"" of type '" "TFltVecIter const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAFltI" "', argument " "1"" of type '" "TFltVecIter const &""'"); + } + arg1 = reinterpret_cast< TFltVecIter * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TNEANetAFltI" "', argument " "2"" of type '" "TStr""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAFltI" "', argument " "2"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TNEANetAFltI" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_TNEANetAFltI" "', argument " "4"" of type '" "TNEANet const *""'"); + } + arg4 = reinterpret_cast< TNEANet * >(argp4); + result = (TNEANetAFltI *)new TNEANetAFltI((TFltVecIter const &)*arg1,arg2,arg3,(TNEANet const *)arg4); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAFltI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet::TAFltI *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetAFltI *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNEANet__TAFltI, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANetAFltI" "', argument " "1"" of type '" "TNEANet::TAFltI const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANetAFltI" "', argument " "1"" of type '" "TNEANet::TAFltI const &""'"); + } + arg1 = reinterpret_cast< TNEANet::TAFltI * >(argp1); + result = (TNEANetAFltI *)new TNEANetAFltI((TNEANet::TAFltI const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANetAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNEANetAFltI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNEANetAFltI__SWIG_0(self, argc, argv); + } + if (argc == 1) { + return _wrap_new_TNEANetAFltI__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_new_TNEANetAFltI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNEANetAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANetAFltI::TNEANetAFltI()\n" + " TNEANetAFltI::TNEANetAFltI(TFltVecIter const &,TStr,bool,TNEANet const *)\n" + " TNEANetAFltI::TNEANetAFltI(TNEANet::TAFltI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAFltI_Next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAFltI *arg1 = (TNEANetAFltI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANetAFltI *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAFltI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAFltI_Next" "', argument " "1"" of type '" "TNEANetAFltI *""'"); + } + arg1 = reinterpret_cast< TNEANetAFltI * >(argp1); + result = (TNEANetAFltI *) &(arg1)->Next(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANetAFltI, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAFltI___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAFltI *arg1 = (TNEANetAFltI *) 0 ; + TNEANetAFltI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetAFltI___lt__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAFltI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAFltI___lt__" "', argument " "1"" of type '" "TNEANetAFltI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAFltI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetAFltI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetAFltI___lt__" "', argument " "2"" of type '" "TNEANetAFltI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetAFltI___lt__" "', argument " "2"" of type '" "TNEANetAFltI const &""'"); + } + arg2 = reinterpret_cast< TNEANetAFltI * >(argp2); + result = (bool)((TNEANetAFltI const *)arg1)->operator <((TNEANetAFltI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAFltI___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAFltI *arg1 = (TNEANetAFltI *) 0 ; + TNEANetAFltI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANetAFltI___eq__",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAFltI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAFltI___eq__" "', argument " "1"" of type '" "TNEANetAFltI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAFltI * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANetAFltI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANetAFltI___eq__" "', argument " "2"" of type '" "TNEANetAFltI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANetAFltI___eq__" "', argument " "2"" of type '" "TNEANetAFltI const &""'"); + } + arg2 = reinterpret_cast< TNEANetAFltI * >(argp2); + result = (bool)((TNEANetAFltI const *)arg1)->operator ==((TNEANetAFltI const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAFltI_GetDat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAFltI *arg1 = (TNEANetAFltI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAFltI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAFltI_GetDat" "', argument " "1"" of type '" "TNEANetAFltI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAFltI * >(argp1); + result = (double)((TNEANetAFltI const *)arg1)->GetDat(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANetAFltI_IsDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAFltI *arg1 = (TNEANetAFltI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAFltI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANetAFltI_IsDeleted" "', argument " "1"" of type '" "TNEANetAFltI const *""'"); + } + arg1 = reinterpret_cast< TNEANetAFltI * >(argp1); + result = (bool)((TNEANetAFltI const *)arg1)->IsDeleted(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TNEANetAFltI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANetAFltI *arg1 = (TNEANetAFltI *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNEANetAFltI" "', argument " "1"" of type '" "TNEANetAFltI *""'"); + } + arg1 = reinterpret_cast< TNEANetAFltI * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNEANetAFltI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNEANetAFltI, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNEANetAFltI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_TPrGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< TPt< TUNGraph > > arg1 ; + void *argp1 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TUNGraph result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TUNGraph_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TPrGraph" "', argument " "1"" of type '" "PUNGraph""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TPrGraph" "', argument " "1"" of type '" "PUNGraph""'"); + } else { + PUNGraph * temp = reinterpret_cast< PUNGraph * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; + } + } + result = TPrGraph(arg1); + resultobj = SWIG_NewPointerObj((new TUNGraph(static_cast< const TUNGraph& >(result))), SWIGTYPE_p_TUNGraph, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_accept_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "accept_array" "', argument " "1"" of type '" "int []""'"); + } + arg1 = reinterpret_cast< int * >(argp1); + result = (int)accept_array(arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_print_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = (int *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"print_array",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_array" "', argument " "1"" of type '" "int *""'"); + } + arg1 = reinterpret_cast< int * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_array" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + print_array(arg1,arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PyTFltV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 ; + double temp1[10] ; + PyObject *swig_obj[1] ; + SwigValueWrapper< TVec< TFlt,int > > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int i; + if (!PySequence_Check(swig_obj[0])) { + PyErr_SetString(PyExc_ValueError,"Expected a sequence"); + return NULL; + } + if (PySequence_Length(swig_obj[0]) != 10) { + PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected 10 elements"); + return NULL; + } + for (i = 0; i < 10; i++) { + PyObject *o = PySequence_GetItem(swig_obj[0],i); + if (PyNumber_Check(o)) { + temp1[i] = (double) PyFloat_AsDouble(o); + } else { + PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); + return NULL; + } + } + arg1 = temp1; + } + result = PyTFltV(arg1); + resultobj = SWIG_NewPointerObj((new TFltV(static_cast< const TFltV& >(result))), SWIGTYPE_p_TVecT_TFlt_int_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PyToTIntV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = (int *) 0 ; + int arg2 ; + PyObject *swig_obj[1] ; + TIntV result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int i; + PyObject* seq = PySequence_Fast(swig_obj[0], "expected a sequence"); + int length = PySequence_Size(swig_obj[0]); + int *temp = (int *) malloc(length*sizeof(int)); + for (i = 0; i < length; i++) { + temp[i] = (int) PyInt_AsLong(PySequence_Fast_GET_ITEM(seq, i)); + } + Py_DECREF(seq); + arg1 = temp; + arg2 = length; + } + result = PyToTIntV(arg1,arg2); + resultobj = SWIG_NewPointerObj((new TIntV(static_cast< const TIntV& >(result))), SWIGTYPE_p_TVecT_TInt_int_t, SWIG_POINTER_OWN | 0 ); + { + if (arg1) free(arg1); + } + return resultobj; +fail: + { + if (arg1) free(arg1); + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + char arg3 ; + char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"count",2,2,swig_obj)) SWIG_fail; + { + arg1 = PyString_AsString(swig_obj[0]); /* char *str */ + arg2 = PyString_Size(swig_obj[0]); /* int len */ + } + ecode3 = SWIG_AsVal_char(swig_obj[1], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "count" "', argument " "3"" of type '" "char""'"); + } + arg3 = static_cast< char >(val3); + result = (int)count(arg1,arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TIntVToPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TIntV arg1 ; + TIntV *arg2 = (TIntV *) 0 ; + void *argp1 ; + int res1 = 0 ; + TIntV temp2 ; + PyObject *swig_obj[1] ; + + { + arg2 = &temp2; + } + if (!args) SWIG_fail; + swig_obj[0] = args; + { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TIntVToPy" "', argument " "1"" of type '" "TIntV""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TIntVToPy" "', argument " "1"" of type '" "TIntV""'"); + } else { + TIntV * temp = reinterpret_cast< TIntV * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; + } + } + TIntVToPy(arg1,arg2); + resultobj = SWIG_Py_Void(); + { + resultobj = PyList_New(arg2->Len()); + for (int i = 0; i < arg2->Len(); ++i) { + PyList_SetItem(resultobj, i, PyInt_FromLong((*arg2)[i])); + } + delete arg2; // Avoid a leak since you called new + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + TNEANet *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (TNEANet *)new TNEANet(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TNEANet *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TNEANet" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TNEANet" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (TNEANet *)new TNEANet((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TNEANet, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANet" "', argument " "1"" of type '" "TNEANet const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANet" "', argument " "1"" of type '" "TNEANet const &""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (TNEANet *)new TNEANet((TNEANet const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TNEANet" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TNEANet" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = (TNEANet *)new TNEANet(*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANet, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TNEANet(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"new_TNEANet",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_TNEANet__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TNEANet, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_new_TNEANet__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 1) { + return _wrap_new_TNEANet__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_new_TNEANet__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TNEANet'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::TNEANet()\n" + " TNEANet::TNEANet(int const &,int const &)\n" + " TNEANet::TNEANet(TNEANet const &)\n" + " TNEANet::TNEANet(TSIn &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Save" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TNEANet const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_New__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + PNEANet result; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = TNEANet::New(); + resultobj = SWIG_NewPointerObj((new PNEANet(static_cast< const PNEANet& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_New__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PNEANet result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TNEANet_New" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_New" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TNEANet::New((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new PNEANet(static_cast< const PNEANet& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_New(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_New",0,2,argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_TNEANet_New__SWIG_0(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_New__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_New'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::New()\n" + " TNEANet::New(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TSIn *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PNEANet result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_Load" "', argument " "1"" of type '" "TSIn &""'"); + } + arg1 = reinterpret_cast< TSIn * >(argp1); + result = TNEANet::Load(*arg1); + resultobj = SWIG_NewPointerObj((new PNEANet(static_cast< const PNEANet& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TGraphFlag *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_HasFlag",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_HasFlag" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TGraphFlag, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + arg2 = reinterpret_cast< TGraphFlag * >(argp2); + result = (bool)((TNEANet const *)arg1)->HasFlag((TGraphFlag const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetNodes" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (int)((TNEANet const *)arg1)->GetNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddNode" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->AddNode(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddNode" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (int)(arg1)->AddNode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddNode" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddNode" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddNode" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + result = (int)(arg1)->AddNode((TNEANet::TNodeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_AddNode__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_TNEANet_AddNode__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_TNEANet_AddNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddNode(int)\n" + " TNEANet::AddNode()\n" + " TNEANet::AddNode(TNEANet::TNodeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelNode" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_DelNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNode *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelNode" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNode, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_DelNode" "', argument " "2"" of type '" "TNEANet::TNode const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelNode" "', argument " "2"" of type '" "TNEANet::TNode const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNode * >(argp2); + (arg1)->DelNode((TNEANet::TNode const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_DelNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNode, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_DelNode__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_TNEANet_DelNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_DelNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelNode(int const &)\n" + " TNEANet::DelNode(TNEANet::TNode const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_IsNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsNode" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_IsNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNEANet const *)arg1)->IsNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = ((TNEANet const *)arg1)->BegNI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = ((TNEANet const *)arg1)->EndNI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TNEANet::TNodeI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetNI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetNI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = ((TNEANet const *)arg1)->GetNI((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNAIntI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->BegNAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNAIntI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->EndNAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetNAIntI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAIntI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetNAIntI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetNAIntI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetNAIntI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEANet const *)arg1)->GetNAIntI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNAStrI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->BegNAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNAStrI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->EndNAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetNAStrI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAStrI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetNAStrI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetNAStrI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetNAStrI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEANet const *)arg1)->GetNAStrI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNAFltI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->BegNAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNAFltI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->EndNAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetNAFltI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAFltI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetNAFltI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetNAFltI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetNAFltI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEANet const *)arg1)->GetNAFltI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->AttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->AttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_AttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_AttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::AttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->AttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->AttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_AttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_AttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrValueNI(TInt const &,TStrV &) const\n" + " TNEANet::AttrValueNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->IntAttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_IntAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->IntAttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_IntAttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_IntAttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_IntAttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_IntAttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::IntAttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + ((TNEANet const *)arg1)->IntAttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TIntV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_IntAttrValueNI" "', argument " "4"" of type '" "TIntV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueNI" "', argument " "4"" of type '" "TIntV &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + ((TNEANet const *)arg1)->IntAttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_IntAttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_IntAttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_IntAttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_IntAttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrValueNI(TInt const &,TIntV &) const\n" + " TNEANet::IntAttrValueNI(TInt const &,TStrIntPrH::TIter,TIntV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->StrAttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_StrAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->StrAttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_StrAttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_StrAttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_StrAttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_StrAttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->StrAttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_StrAttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->StrAttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_StrAttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_StrAttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_StrAttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_StrAttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrValueNI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrValueNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->FltAttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrNameNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_FltAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->FltAttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_FltAttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_FltAttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_FltAttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_FltAttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::FltAttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + ((TNEANet const *)arg1)->FltAttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrValueNI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_FltAttrValueNI" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueNI" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + ((TNEANet const *)arg1)->FltAttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_FltAttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_FltAttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_FltAttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_FltAttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrValueNI(TInt const &,TFltV &) const\n" + " TNEANet::FltAttrValueNI(TInt const &,TStrIntPrH::TIter,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->AttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->AttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_AttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_AttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::AttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->AttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->AttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_AttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_AttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrValueEI(TInt const &,TStrV &) const\n" + " TNEANet::AttrValueEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->IntAttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_IntAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->IntAttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_IntAttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_IntAttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_IntAttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_IntAttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::IntAttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + ((TNEANet const *)arg1)->IntAttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TIntV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IntAttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_IntAttrValueEI" "', argument " "4"" of type '" "TIntV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IntAttrValueEI" "', argument " "4"" of type '" "TIntV &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + ((TNEANet const *)arg1)->IntAttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IntAttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_IntAttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_IntAttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_IntAttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_IntAttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrValueEI(TInt const &,TIntV &) const\n" + " TNEANet::IntAttrValueEI(TInt const &,TStrIntPrH::TIter,TIntV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->StrAttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_StrAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->StrAttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_StrAttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_StrAttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_StrAttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_StrAttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->StrAttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_StrAttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_StrAttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_StrAttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->StrAttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_StrAttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_StrAttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_StrAttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_StrAttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_StrAttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrValueEI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrValueEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + ((TNEANet const *)arg1)->FltAttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrNameEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_FltAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + ((TNEANet const *)arg1)->FltAttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_FltAttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_FltAttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_FltAttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_FltAttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::FltAttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + ((TNEANet const *)arg1)->FltAttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_FltAttrValueEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_FltAttrValueEI" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_FltAttrValueEI" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + ((TNEANet const *)arg1)->FltAttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_FltAttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_FltAttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_TNEANet_FltAttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_FltAttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_FltAttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrValueEI(TInt const &,TFltV &) const\n" + " TNEANet::FltAttrValueEI(TInt const &,TStrIntPrH::TIter,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEAIntI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->BegEAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEAIntI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->EndEAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEAIntI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAIntI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetEAIntI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEAIntI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetEAIntI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEANet const *)arg1)->GetEAIntI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEAStrI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->BegEAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEAStrI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->EndEAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEAStrI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAStrI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetEAStrI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEAStrI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetEAStrI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEANet const *)arg1)->GetEAStrI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEAFltI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->BegEAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEAFltI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = ((TNEANet const *)arg1)->EndEAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEAFltI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAFltI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetEAFltI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEAFltI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetEAFltI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEANet const *)arg1)->GetEAFltI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetMxNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetMxNId" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (int)((TNEANet const *)arg1)->GetMxNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEdges" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (int)((TNEANet const *)arg1)->GetEdges(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddEdge" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNEANet_AddEdge" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + result = (int)(arg1)->AddEdge((int const &)*arg2,(int const &)*arg3,arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddEdge" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(arg1)->AddEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddEdge" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddEdge" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddEdge" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + result = (int)(arg1)->AddEdge((TNEANet::TEdgeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_AddEdge__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_AddEdge__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_AddEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddEdge(int const &,int const &,int)\n" + " TNEANet::AddEdge(int const &,int const &)\n" + " TNEANet::AddEdge(TNEANet::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelEdge" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (arg1)->DelEdge((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelEdge" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNEANet_DelEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelEdge" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->DelEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_DelEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_DelEdge__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_DelEdge__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_TNEANet_DelEdge__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_DelEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelEdge(int const &)\n" + " TNEANet::DelEdge(int const &,int const &,bool const &)\n" + " TNEANet::DelEdge(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsEdge" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)((TNEANet const *)arg1)->IsEdge((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsEdge" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TNEANet_IsEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (bool)((TNEANet const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsEdge" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (bool)((TNEANet const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsEdge__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + bool *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsEdge" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TNEANet_IsEdge" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + result = (bool)((TNEANet const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,*arg4,(bool const &)*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsEdge__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsEdge" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + result = (bool)((TNEANet const *)arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_IsEdge",0,5,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_IsEdge__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_IsEdge__SWIG_2(self, argc, argv); + } + if (argc == 4) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_TNEANet_IsEdge__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 4) { + return _wrap_TNEANet_IsEdge__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_TNEANet_IsEdge__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_IsEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IsEdge(int const &) const\n" + " TNEANet::IsEdge(int const &,int const &,bool const &) const\n" + " TNEANet::IsEdge(int const &,int const &) const\n" + " TNEANet::IsEdge(int const &,int const &,int &,bool const &) const\n" + " TNEANet::IsEdge(int const &,int const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetEId",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEId" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetEId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetEId" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)((TNEANet const *)arg1)->GetEId((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = ((TNEANet const *)arg1)->BegEI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = ((TNEANet const *)arg1)->EndEI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TEdgeI result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetEI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEI" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetEI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_GetEI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = ((TNEANet const *)arg1)->GetEI((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndNId" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndNId" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (int)(arg1)->GetRndNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetRndNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_GetRndNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_GetRndNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetRndNId'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndNId(TRnd &)\n" + " TNEANet::GetRndNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndNI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (arg1)->GetRndNI(*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndNI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (arg1)->GetRndNI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetRndNI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_GetRndNI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_GetRndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetRndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndNI(TRnd &)\n" + " TNEANet::GetRndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndEId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndEId" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetRndEId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetRndEId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(arg1)->GetRndEId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndEId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndEId" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (int)(arg1)->GetRndEId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndEId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetRndEId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_GetRndEId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_GetRndEId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetRndEId'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndEId(TRnd &)\n" + " TNEANet::GetRndEId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndEI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetRndEI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetRndEI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (arg1)->GetRndEI(*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetRndEI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (arg1)->GetRndEI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetRndEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetRndEI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_GetRndEI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_GetRndEI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetRndEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndEI(TRnd &)\n" + " TNEANet::GetRndEI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetNIdV" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TNEANet const *)arg1)->GetNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetEIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEIdV" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetEIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetEIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ((TNEANet const *)arg1)->GetEIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Empty" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (bool)((TNEANet const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Clr" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_Reserve",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Reserve" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TNEANet_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Defrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Defrag" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_Defrag" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (arg1)->Defrag((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Defrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Defrag" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + (arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Defrag(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_Defrag",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_Defrag__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_Defrag__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_Defrag'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::Defrag(bool const &)\n" + " TNEANet::Defrag()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsOk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsOk" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_IsOk" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)((TNEANet const *)arg1)->IsOk((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsOk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_IsOk" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = (bool)((TNEANet const *)arg1)->IsOk(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_IsOk(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_IsOk",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_IsOk__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_IsOk__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_IsOk'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IsOk(bool const &) const\n" + " TNEANet::IsOk() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Dump__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + FILE *arg2 = (FILE *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Dump" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_Dump" "', argument " "2"" of type '" "FILE *""'"); + } + arg2 = reinterpret_cast< FILE * >(argp2); + ((TNEANet const *)arg1)->Dump(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Dump__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_Dump" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ((TNEANet const *)arg1)->Dump(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_Dump(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_Dump",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_Dump__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_Dump__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_Dump'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::Dump(FILE *) const\n" + " TNEANet::Dump() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddIntAttrDatN((TNEANet::TNodeI const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddIntAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddIntAttrDatN((int const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddIntAttrDatN",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_AddIntAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_TNEANet_AddIntAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddIntAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrDatN(TNEANet::TNodeI const &,TInt const &,TStr const &)\n" + " TNEANet::AddIntAttrDatN(int const &,TInt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddStrAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddStrAttrDatN((int const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddStrAttrDatN",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_AddStrAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_TNEANet_AddStrAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddStrAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrDatN(TNEANet::TNodeI const &,TStr const &,TStr const &)\n" + " TNEANet::AddStrAttrDatN(int const &,TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddFltAttrDatN((TNEANet::TNodeI const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddFltAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddFltAttrDatN((int const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddFltAttrDatN",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_AddFltAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_TNEANet_AddFltAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddFltAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrDatN(TNEANet::TNodeI const &,TFlt const &,TStr const &)\n" + " TNEANet::AddFltAttrDatN(int const &,TFlt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddIntAttrDatE((TNEANet::TEdgeI const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddIntAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddIntAttrDatE((int const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddIntAttrDatE",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_AddIntAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_TNEANet_AddIntAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddIntAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrDatE(TNEANet::TEdgeI const &,TInt const &,TStr const &)\n" + " TNEANet::AddIntAttrDatE(int const &,TInt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddStrAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddStrAttrDatE((int const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddStrAttrDatE",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_AddStrAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_TNEANet_AddStrAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddStrAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrDatE(TNEANet::TEdgeI const &,TStr const &,TStr const &)\n" + " TNEANet::AddStrAttrDatE(int const &,TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddFltAttrDatE((TNEANet::TEdgeI const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_AddFltAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(arg1)->AddFltAttrDatE((int const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddFltAttrDatE",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_AddFltAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_TNEANet_AddFltAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddFltAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrDatE(TNEANet::TEdgeI const &,TFlt const &,TStr const &)\n" + " TNEANet::AddFltAttrDatE(int const &,TFlt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetIntAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetIntAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetIntAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetIntAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetIntAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetIntAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetIntAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetIntAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetIntAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_GetIntAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_GetIntAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetIntAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetIntAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::GetIntAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetStrAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetStrAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetStrAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetStrAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetStrAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetStrAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetStrAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetStrAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetStrAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_GetStrAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_GetStrAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetStrAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetStrAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::GetStrAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetFltAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetFltAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetFltAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetFltAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetFltAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetFltAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetFltAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetFltAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetFltAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_GetFltAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_GetFltAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetFltAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetFltAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::GetFltAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetIntAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetIntAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetIntAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetIntAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetIntAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetIntAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetIntAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetIntAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetIntAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_GetIntAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_GetIntAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetIntAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetIntAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::GetIntAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetStrAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetStrAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetStrAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetStrAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetStrAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetStrAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetStrAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetStrAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetStrAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_GetStrAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_GetStrAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetStrAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetStrAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::GetStrAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetFltAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetFltAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_GetFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetFltAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetFltAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetFltAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetFltAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (arg1)->GetFltAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetFltAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_GetFltAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_GetFltAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_GetFltAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_GetFltAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetFltAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::GetFltAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_DelAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(arg1)->DelAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelAttrDatN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_DelAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(arg1)->DelAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_DelAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_DelAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_DelAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_DelAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::DelAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_DelAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(arg1)->DelAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelAttrDatE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_DelAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(arg1)->DelAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_DelAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_TNEANet_DelAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_TNEANet_DelAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_DelAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::DelAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + TInt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = I; + } + result = (int)(arg1)->AddIntAttrN((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddIntAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddIntAttrN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_AddIntAttrN__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_AddIntAttrN__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddIntAttrN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrN(TStr const &,TInt)\n" + " TNEANet::AddIntAttrN(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + TStr arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TStr S(PyString_AsString(swig_obj[2])); + arg3 = S; + } + result = (int)(arg1)->AddStrAttrN((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddStrAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddStrAttrN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_AddStrAttrN__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_AddStrAttrN__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddStrAttrN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrN(TStr const &,TStr)\n" + " TNEANet::AddStrAttrN(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + TFlt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = F; + } + result = (int)(arg1)->AddFltAttrN((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddFltAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddFltAttrN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_AddFltAttrN__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_AddFltAttrN__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddFltAttrN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrN(TStr const &,TFlt)\n" + " TNEANet::AddFltAttrN(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + TInt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = I; + } + result = (int)(arg1)->AddIntAttrE((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddIntAttrE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddIntAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddIntAttrE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddIntAttrE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_AddIntAttrE__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_AddIntAttrE__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddIntAttrE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrE(TStr const &,TInt)\n" + " TNEANet::AddIntAttrE(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + TStr arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TStr S(PyString_AsString(swig_obj[2])); + arg3 = S; + } + result = (int)(arg1)->AddStrAttrE((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddStrAttrE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddStrAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddStrAttrE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddStrAttrE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_AddStrAttrE__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_AddStrAttrE__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddStrAttrE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrE(TStr const &,TStr)\n" + " TNEANet::AddStrAttrE(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + TFlt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = F; + } + result = (int)(arg1)->AddFltAttrE((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_AddFltAttrE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->AddFltAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_AddFltAttrE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_AddFltAttrE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_AddFltAttrE__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_TNEANet_AddFltAttrE__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_AddFltAttrE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrE(TStr const &,TFlt)\n" + " TNEANet::AddFltAttrE(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_DelAttrN",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelAttrN" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_DelAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->DelAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_DelAttrE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_DelAttrE",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_DelAttrE" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_DelAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_DelAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(arg1)->DelAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_NodeAttrIsDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_NodeAttrIsDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_NodeAttrIsDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_NodeAttrIsDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_NodeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_NodeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->NodeAttrIsDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_NodeAttrIsIntDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_NodeAttrIsIntDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_NodeAttrIsIntDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_NodeAttrIsIntDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_NodeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_NodeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->NodeAttrIsIntDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_NodeAttrIsStrDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_NodeAttrIsStrDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_NodeAttrIsStrDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_NodeAttrIsStrDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_NodeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_NodeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->NodeAttrIsStrDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_NodeAttrIsFltDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_NodeAttrIsFltDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_NodeAttrIsFltDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_NodeAttrIsFltDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_NodeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_NodeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->NodeAttrIsFltDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EdgeAttrIsDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_EdgeAttrIsDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EdgeAttrIsDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_EdgeAttrIsDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_EdgeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EdgeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->EdgeAttrIsDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EdgeAttrIsIntDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_EdgeAttrIsIntDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EdgeAttrIsIntDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_EdgeAttrIsIntDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_EdgeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EdgeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->EdgeAttrIsIntDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EdgeAttrIsStrDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_EdgeAttrIsStrDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EdgeAttrIsStrDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_EdgeAttrIsStrDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_EdgeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EdgeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->EdgeAttrIsStrDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EdgeAttrIsFltDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_EdgeAttrIsFltDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EdgeAttrIsFltDeleted" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_EdgeAttrIsFltDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_EdgeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EdgeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)((TNEANet const *)arg1)->EdgeAttrIsFltDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetNodeAttrValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetNodeAttrValue",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetNodeAttrValue" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetNodeAttrValue" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetNodeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetNodeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = ((TNEANet const *)arg1)->GetNodeAttrValue((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_GetEdgeAttrValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"TNEANet_GetEdgeAttrValue",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_GetEdgeAttrValue" "', argument " "1"" of type '" "TNEANet const *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TNEANet_GetEdgeAttrValue" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TNEANet_GetEdgeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_GetEdgeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = ((TNEANet const *)arg1)->GetEdgeAttrValue((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = TNEANet_BegNI__SWIG_1(arg1); + resultobj = SWIG_NewPointerObj((new TNEANetNodeI(static_cast< const TNEANetNodeI& >(result))), SWIGTYPE_p_TNEANetNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegNI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_BegNI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TNEANet_BegNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNI() const\n" + " TNEANet::BegNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = TNEANet_EndNI__SWIG_1(arg1); + resultobj = SWIG_NewPointerObj((new TNEANetNodeI(static_cast< const TNEANetNodeI& >(result))), SWIGTYPE_p_TNEANetNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndNI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_EndNI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TNEANet_EndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNI() const\n" + " TNEANet::EndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = TNEANet_BegEI__SWIG_1(arg1); + resultobj = SWIG_NewPointerObj((new TNEANetEdgeI(static_cast< const TNEANetEdgeI& >(result))), SWIGTYPE_p_TNEANetEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegEI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_BegEI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TNEANet_BegEI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEI() const\n" + " TNEANet::BegEI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + result = TNEANet_EndEI__SWIG_1(arg1); + resultobj = SWIG_NewPointerObj((new TNEANetEdgeI(static_cast< const TNEANetEdgeI& >(result))), SWIGTYPE_p_TNEANetEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndEI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_TNEANet_EndEI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_TNEANet_EndEI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEI() const\n" + " TNEANet::EndEI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNAIntI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegNAIntI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegNAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_BegNAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_BegNAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegNAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNAIntI(TStr const &) const\n" + " TNEANet::BegNAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNAIntI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndNAIntI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndNAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_EndNAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_EndNAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndNAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNAIntI(TStr const &) const\n" + " TNEANet::EndNAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNAStrI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegNAStrI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegNAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_BegNAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_BegNAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegNAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNAStrI(TStr const &) const\n" + " TNEANet::BegNAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNAStrI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndNAStrI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndNAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_EndNAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_EndNAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndNAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNAStrI(TStr const &) const\n" + " TNEANet::EndNAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegNAFltI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegNAFltI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegNAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegNAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_BegNAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_BegNAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegNAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNAFltI(TStr const &) const\n" + " TNEANet::BegNAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndNAFltI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndNAFltI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndNAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndNAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_EndNAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_EndNAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndNAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNAFltI(TStr const &) const\n" + " TNEANet::EndNAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEAIntI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegEAIntI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegEAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_BegEAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_BegEAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegEAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEAIntI(TStr const &) const\n" + " TNEANet::BegEAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEAIntI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndEAIntI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndEAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_EndEAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_EndEAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndEAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEAIntI(TStr const &) const\n" + " TNEANet::EndEAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEAStrI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegEAStrI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegEAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_BegEAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_BegEAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegEAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEAStrI(TStr const &) const\n" + " TNEANet::BegEAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEAStrI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndEAStrI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndEAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_EndEAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_EndEAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndEAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEAStrI(TStr const &) const\n" + " TNEANet::EndEAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_BegEAFltI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegEAFltI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_BegEAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_BegEAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_BegEAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_BegEAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_BegEAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEAFltI(TStr const &) const\n" + " TNEANet::BegEAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TNEANet_EndEAFltI" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndEAFltI__SWIG_1(arg1,(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TNEANet_EndEAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"TNEANet_EndEAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_TNEANet_EndEAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_TNEANet_EndEAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TNEANet_EndEAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEAFltI(TStr const &) const\n" + " TNEANet::EndEAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TNEANet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TNEANet *arg1 = (TNEANet *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TNEANet, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNEANet" "', argument " "1"" of type '" "TNEANet *""'"); + } + arg1 = reinterpret_cast< TNEANet * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TNEANet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TNEANet, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TNEANet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_PercentDegree__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PercentDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PercentDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PercentDegree" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (double)PercentDegree< PNEANet >((TPt< TNEANet > const &)*arg1,arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PercentDegree__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PercentDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PercentDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (double)PercentDegree< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PercentDegree(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PercentDegree",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PercentDegree__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_PercentDegree__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PercentDegree'.\n" + " Possible C/C++ prototypes are:\n" + " PercentDegree< PNEANet >(TPt< TNEANet > const &,int const)\n" + " PercentDegree< PNEANet >(TPt< TNEANet > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PercentMxWcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PercentMxWcc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PercentMxWcc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (double)PercentMxWcc< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PercentMxScc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PercentMxScc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PercentMxScc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (double)PercentMxScc< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LoadEdgeList__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoadEdgeList" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoadEdgeList" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR LoadEdgeList< PNEANet >((TStr const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LoadEdgeList__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoadEdgeList" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR LoadEdgeList< PNEANet >((TStr const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LoadEdgeList__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR LoadEdgeList< PNEANet >((TStr const &)*arg1); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LoadEdgeList__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TStr *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + char *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + char temp4 ; + char val4 ; + int ecode4 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LoadEdgeList" "', argument " "1"" of type '" "TStr const &""'"); + } + arg1 = reinterpret_cast< TStr * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LoadEdgeList" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoadEdgeList" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_char(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LoadEdgeList" "', argument " "4"" of type '" "char""'"); + } + temp4 = static_cast< char >(val4); + arg4 = &temp4; + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR LoadEdgeList< PNEANet >((TStr const &)*arg1,(int const &)*arg2,(int const &)*arg3,(char const &)*arg4); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LoadEdgeList(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"LoadEdgeList",0,4,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_LoadEdgeList__SWIG_6(self, argc, argv); + } + if (argc == 2) { + return _wrap_LoadEdgeList__SWIG_5(self, argc, argv); + } + if (argc == 3) { + return _wrap_LoadEdgeList__SWIG_4(self, argc, argv); + } + if (argc == 4) { + return _wrap_LoadEdgeList__SWIG_7(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LoadEdgeList'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::LoadEdgeList< PNEANet >(TStr const &,int const &,int const &)\n" + " TSnap::LoadEdgeList< PNEANet >(TStr const &,int const &)\n" + " TSnap::LoadEdgeList< PNEANet >(TStr const &)\n" + " TSnap::LoadEdgeList< PNEANet >(TStr const &,int const &,int const &,char const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PrintGraphStatTable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TStr arg2 ; + TStr arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrintGraphStatTable" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrintGraphStatTable" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrintGraphStatTable" "', argument " "2"" of type '" "TStr""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrintGraphStatTable" "', argument " "2"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrintGraphStatTable" "', argument " "3"" of type '" "TStr""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrintGraphStatTable" "', argument " "3"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + PrintGraphStatTable< PNEANet >((TPt< TNEANet > const &)*arg1,arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PrintGraphStatTable__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TStr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrintGraphStatTable" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrintGraphStatTable" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrintGraphStatTable" "', argument " "2"" of type '" "TStr""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrintGraphStatTable" "', argument " "2"" of type '" "TStr""'"); + } else { + TStr * temp = reinterpret_cast< TStr * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + PrintGraphStatTable< PNEANet >((TPt< TNEANet > const &)*arg1,arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PrintGraphStatTable(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PrintGraphStatTable",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PrintGraphStatTable__SWIG_3(self, argc, argv); + } + if (argc == 3) { + return _wrap_PrintGraphStatTable__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PrintGraphStatTable'.\n" + " Possible C/C++ prototypes are:\n" + " PrintGraphStatTable< PNEANet >(TPt< TNEANet > const &,TStr,TStr)\n" + " PrintGraphStatTable< PNEANet >(TPt< TNEANet > const &,TStr)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GenRndGnm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + TRnd *arg4 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndGnm" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndGnm" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndGnm" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GenRndGnm" "', argument " "4"" of type '" "TRnd &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GenRndGnm" "', argument " "4"" of type '" "TRnd &""'"); + } + arg4 = reinterpret_cast< TRnd * >(argp4); + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GenRndGnm< PNEANet >((int const &)*arg1,(int const &)*arg2,(bool const &)*arg3,*arg4); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndGnm__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndGnm" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndGnm" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GenRndGnm" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GenRndGnm< PNEANet >((int const &)*arg1,(int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndGnm__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GenRndGnm" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GenRndGnm" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GenRndGnm< PNEANet >((int const &)*arg1,(int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GenRndGnm(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GenRndGnm",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GenRndGnm__SWIG_5(self, argc, argv); + } + if (argc == 3) { + return _wrap_GenRndGnm__SWIG_4(self, argc, argv); + } + if (argc == 4) { + return _wrap_GenRndGnm__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GenRndGnm'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GenRndGnm< PNEANet >(int const &,int const &,bool const &,TRnd &)\n" + " TSnap::GenRndGnm< PNEANet >(int const &,int const &,bool const &)\n" + " TSnap::GenRndGnm< PNEANet >(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_NodesGTEDegree__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodesGTEDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodesGTEDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodesGTEDegree" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)NodesGTEDegree< PNEANet >((TPt< TNEANet > const &)*arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NodesGTEDegree__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodesGTEDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodesGTEDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)NodesGTEDegree< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NodesGTEDegree(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"NodesGTEDegree",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_NodesGTEDegree__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_NodesGTEDegree__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'NodesGTEDegree'.\n" + " Possible C/C++ prototypes are:\n" + " NodesGTEDegree< PNEANet >(TPt< TNEANet > const &,int const)\n" + " NodesGTEDegree< PNEANet >(TPt< TNEANet > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MxDegree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MxDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MxDegree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)MxDegree< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MxSccSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TPt< TNEANet > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MxSccSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MxSccSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxScc< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MxWccSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MxWccSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MxWccSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxWccSz< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_New",0,0,0)) SWIG_fail; + result = TPt< TNEANet >::SWIGTEMPLATEDISAMBIGUATOR New(); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_PNEANet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PNEANet" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TSOut *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_Save",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Save" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSOut, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_Save" "', argument " "2"" of type '" "TSOut &""'"); + } + arg2 = reinterpret_cast< TSOut * >(argp2); + ((TPt< TNEANet > const *)arg1)->Save(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANet *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet___deref__" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (TNEANet *)((TPt< TNEANet > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANet, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANet *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet___ref__" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (TNEANet *) &((TPt< TNEANet > const *)arg1)->operator *(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANet, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TNEANet *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet___call__" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (TNEANet *)((TPt< TNEANet > const *)arg1)->operator ()(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TNEANet, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Empty" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (bool)((TPt< TNEANet > const *)arg1)->Empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Clr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Clr" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + (arg1)->Clr(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRefs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRefs" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)((TPt< TNEANet > const *)arg1)->GetRefs(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TSIn *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + PNEANet result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_Load",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Load" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TSIn, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_Load" "', argument " "2"" of type '" "TSIn &""'"); + } + arg2 = reinterpret_cast< TSIn * >(argp2); + result = (*arg1)->Load(*arg2); + resultobj = SWIG_NewPointerObj((new PNEANet(static_cast< const PNEANet& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TGraphFlag *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_HasFlag",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_HasFlag" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TGraphFlag, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_HasFlag" "', argument " "2"" of type '" "TGraphFlag const &""'"); + } + arg2 = reinterpret_cast< TGraphFlag * >(argp2); + result = (bool)(*arg1)->HasFlag((TGraphFlag const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetNodes" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)(*arg1)->GetNodes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddNode" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddNode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(*arg1)->AddNode(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddNode" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)(*arg1)->AddNode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddNode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddNode" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddNode" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddNode" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + result = (int)(*arg1)->AddNode((TNEANet::TNodeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_AddNode__SWIG_1(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_PNEANet_AddNode__SWIG_2(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_PNEANet_AddNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddNode(int)\n" + " TNEANet::AddNode()\n" + " TNEANet::AddNode(TNEANet::TNodeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelNode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelNode" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_DelNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (*arg1)->DelNode((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelNode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNode *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelNode" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNode, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_DelNode" "', argument " "2"" of type '" "TNEANet::TNode const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelNode" "', argument " "2"" of type '" "TNEANet::TNode const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNode * >(argp2); + (*arg1)->DelNode((TNEANet::TNode const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelNode(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_DelNode",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNode, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_DelNode__SWIG_1(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_PNEANet_DelNode__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_DelNode'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelNode(int const &)\n" + " TNEANet::DelNode(TNEANet::TNode const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_IsNode",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsNode" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_IsNode" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)(*arg1)->IsNode((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (*arg1)->BegNI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TNEANet_BegNI__SWIG_1((TNEANet*)(arg1)->operator ->()); + resultobj = SWIG_NewPointerObj((new TNEANetNodeI(static_cast< const TNEANetNodeI& >(result))), SWIGTYPE_p_TNEANetNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegNI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_BegNI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_PNEANet_BegNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNI() const\n" + " TNEANet::BegNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (*arg1)->EndNI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TNEANet_EndNI__SWIG_1((TNEANet*)(arg1)->operator ->()); + resultobj = SWIG_NewPointerObj((new TNEANetNodeI(static_cast< const TNEANetNodeI& >(result))), SWIGTYPE_p_TNEANetNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndNI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_EndNI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_PNEANet_EndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNI() const\n" + " TNEANet::EndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetNI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + TNEANet::TNodeI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetNI",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetNI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (*arg1)->GetNI((int const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNAIntI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->BegNAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNAIntI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegNAIntI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegNAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_BegNAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_BegNAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegNAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNAIntI(TStr const &) const\n" + " TNEANet::BegNAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNAIntI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->EndNAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNAIntI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndNAIntI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndNAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_EndNAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_EndNAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndNAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNAIntI(TStr const &) const\n" + " TNEANet::EndNAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetNAIntI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAIntI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetNAIntI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetNAIntI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetNAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetNAIntI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (*arg1)->GetNAIntI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNAStrI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->BegNAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNAStrI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegNAStrI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegNAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_BegNAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_BegNAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegNAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNAStrI(TStr const &) const\n" + " TNEANet::BegNAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNAStrI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->EndNAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNAStrI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndNAStrI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndNAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_EndNAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_EndNAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndNAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNAStrI(TStr const &) const\n" + " TNEANet::EndNAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetNAStrI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAStrI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetNAStrI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetNAStrI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetNAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetNAStrI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (*arg1)->GetNAStrI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNAFltI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->BegNAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegNAFltI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegNAFltI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegNAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegNAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_BegNAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_BegNAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegNAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegNAFltI(TStr const &) const\n" + " TNEANet::BegNAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNAFltI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->EndNAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndNAFltI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndNAFltI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndNAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndNAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_EndNAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_EndNAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndNAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndNAFltI(TStr const &) const\n" + " TNEANet::EndNAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetNAFltI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAFltI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetNAFltI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetNAFltI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetNAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetNAFltI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (*arg1)->GetNAFltI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->AttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->AttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_AttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_AttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::AttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->AttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->AttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_AttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_AttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrValueNI(TInt const &,TStrV &) const\n" + " TNEANet::AttrValueNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->IntAttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_IntAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->IntAttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_IntAttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_IntAttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_IntAttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_IntAttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::IntAttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + (*arg1)->IntAttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TIntV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_IntAttrValueNI" "', argument " "4"" of type '" "TIntV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueNI" "', argument " "4"" of type '" "TIntV &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + (*arg1)->IntAttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_IntAttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_IntAttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_IntAttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_IntAttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrValueNI(TInt const &,TIntV &) const\n" + " TNEANet::IntAttrValueNI(TInt const &,TStrIntPrH::TIter,TIntV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->StrAttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_StrAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->StrAttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_StrAttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_StrAttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_StrAttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_StrAttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->StrAttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_StrAttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->StrAttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_StrAttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_StrAttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_StrAttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_StrAttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrValueNI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrValueNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrNameNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->FltAttrNameNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrNameNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrNameNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_FltAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameNI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->FltAttrNameNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrNameNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_FltAttrNameNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_FltAttrNameNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_FltAttrNameNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_FltAttrNameNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrNameNI(TInt const &,TStrV &) const\n" + " TNEANet::FltAttrNameNI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrValueNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + (*arg1)->FltAttrValueNI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrValueNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrValueNI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + { + TInt I = PyInt_AsLong(swig_obj[1]); + arg2 = &I; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueNI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_FltAttrValueNI" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueNI" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + (*arg1)->FltAttrValueNI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrValueNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_FltAttrValueNI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_FltAttrValueNI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_FltAttrValueNI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_FltAttrValueNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrValueNI(TInt const &,TFltV &) const\n" + " TNEANet::FltAttrValueNI(TInt const &,TStrIntPrH::TIter,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->AttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->AttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_AttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_AttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::AttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->AttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->AttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_AttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_AttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AttrValueEI(TInt const &,TStrV &) const\n" + " TNEANet::AttrValueEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->IntAttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_IntAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->IntAttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_IntAttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_IntAttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_IntAttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_IntAttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::IntAttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + (*arg1)->IntAttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TIntV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IntAttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_IntAttrValueEI" "', argument " "4"" of type '" "TIntV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IntAttrValueEI" "', argument " "4"" of type '" "TIntV &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + (*arg1)->IntAttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IntAttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_IntAttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_IntAttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_IntAttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_IntAttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IntAttrValueEI(TInt const &,TIntV &) const\n" + " TNEANet::IntAttrValueEI(TInt const &,TStrIntPrH::TIter,TIntV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->StrAttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_StrAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->StrAttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_StrAttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_StrAttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_StrAttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_StrAttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->StrAttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_StrAttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_StrAttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_StrAttrValueEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->StrAttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_StrAttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_StrAttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_StrAttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_StrAttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_StrAttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::StrAttrValueEI(TInt const &,TStrV &) const\n" + " TNEANet::StrAttrValueEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrNameEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrV &""'"); + } + arg3 = reinterpret_cast< TStrV * >(argp3); + (*arg1)->FltAttrNameEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrNameEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TStrV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrNameEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TStr_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_FltAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrNameEI" "', argument " "4"" of type '" "TStrV &""'"); + } + arg4 = reinterpret_cast< TStrV * >(argp4); + (*arg1)->FltAttrNameEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrNameEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_FltAttrNameEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_FltAttrNameEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_FltAttrNameEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_FltAttrNameEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrNameEI(TInt const &,TStrV &) const\n" + " TNEANet::FltAttrNameEI(TInt const &,TStrIntPrH::TIter,TStrV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrValueEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TFltV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TFltV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TFltV &""'"); + } + arg3 = reinterpret_cast< TFltV * >(argp3); + (*arg1)->FltAttrValueEI((TInt const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrValueEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TInt *arg2 = 0 ; + TStrIntPrH::TIter arg3 ; + TFltV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_FltAttrValueEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TInt, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueEI" "', argument " "2"" of type '" "TInt const &""'"); + } + arg2 = reinterpret_cast< TInt * >(argp2); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueEI" "', argument " "3"" of type '" "TStrIntPrH::TIter""'"); + } else { + TStrIntPrH::TIter * temp = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TFlt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_FltAttrValueEI" "', argument " "4"" of type '" "TFltV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_FltAttrValueEI" "', argument " "4"" of type '" "TFltV &""'"); + } + arg4 = reinterpret_cast< TFltV * >(argp4); + (*arg1)->FltAttrValueEI((TInt const &)*arg2,arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_FltAttrValueEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_FltAttrValueEI",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_PNEANet_FltAttrValueEI__SWIG_0(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_FltAttrValueEI__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_FltAttrValueEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::FltAttrValueEI(TInt const &,TFltV &) const\n" + " TNEANet::FltAttrValueEI(TInt const &,TStrIntPrH::TIter,TFltV &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEAIntI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->BegEAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEAIntI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegEAIntI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegEAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_BegEAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_BegEAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegEAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEAIntI(TStr const &) const\n" + " TNEANet::BegEAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAIntI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEAIntI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->EndEAIntI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAIntI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAIntI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEAIntI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndEAIntI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAIntI(static_cast< const TNEANetAIntI& >(result))), SWIGTYPE_p_TNEANetAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAIntI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndEAIntI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_EndEAIntI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_EndEAIntI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndEAIntI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEAIntI(TStr const &) const\n" + " TNEANet::EndEAIntI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEAIntI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAIntI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetEAIntI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEAIntI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetEAIntI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetEAIntI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (*arg1)->GetEAIntI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAIntI(static_cast< const TNEANet::TAIntI& >(result))), SWIGTYPE_p_TNEANet__TAIntI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEAStrI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->BegEAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEAStrI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegEAStrI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegEAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_BegEAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_BegEAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegEAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEAStrI(TStr const &) const\n" + " TNEANet::BegEAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAStrI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEAStrI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->EndEAStrI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAStrI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAStrI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEAStrI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndEAStrI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAStrI(static_cast< const TNEANetAStrI& >(result))), SWIGTYPE_p_TNEANetAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAStrI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndEAStrI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_EndEAStrI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_EndEAStrI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndEAStrI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEAStrI(TStr const &) const\n" + " TNEANet::EndEAStrI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEAStrI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAStrI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetEAStrI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEAStrI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetEAStrI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetEAStrI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (*arg1)->GetEAStrI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAStrI(static_cast< const TNEANet::TAStrI& >(result))), SWIGTYPE_p_TNEANet__TAStrI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEAFltI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->BegEAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEAFltI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_BegEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_BegEAFltI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegEAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_BegEAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_BegEAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegEAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEAFltI(TStr const &) const\n" + " TNEANet::BegEAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAFltI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEAFltI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (*arg1)->EndEAFltI((TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAFltI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANetAFltI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEAFltI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EndEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = TNEANet_EndEAFltI__SWIG_1((TNEANet*)(arg1)->operator ->(),(TStr const &)*arg2); + resultobj = SWIG_NewPointerObj((new TNEANetAFltI(static_cast< const TNEANetAFltI& >(result))), SWIGTYPE_p_TNEANetAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEAFltI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndEAFltI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_EndEAFltI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_EndEAFltI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndEAFltI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEAFltI(TStr const &) const\n" + " TNEANet::EndEAFltI(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEAFltI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TAFltI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetEAFltI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEAFltI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetEAFltI" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetEAFltI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (*arg1)->GetEAFltI((TStr const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TAFltI(static_cast< const TNEANet::TAFltI& >(result))), SWIGTYPE_p_TNEANet__TAFltI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetMxNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetMxNId" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)(*arg1)->GetMxNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEdges" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)(*arg1)->GetEdges(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddEdge" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PNEANet_AddEdge" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + result = (int)(*arg1)->AddEdge((int const &)*arg2,(int const &)*arg3,arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddEdge" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_AddEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(*arg1)->AddEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddEdge" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddEdge" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddEdge" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + result = (int)(*arg1)->AddEdge((TNEANet::TEdgeI const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_AddEdge__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_AddEdge__SWIG_1(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_AddEdge__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddEdge(int const &,int const &,int)\n" + " TNEANet::AddEdge(int const &,int const &)\n" + " TNEANet::AddEdge(TNEANet::TEdgeI const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelEdge" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + (*arg1)->DelEdge((int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelEdge" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PNEANet_DelEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + (*arg1)->DelEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelEdge" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_DelEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_DelEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (*arg1)->DelEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_DelEdge",0,4,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_DelEdge__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_DelEdge__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_PNEANet_DelEdge__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_DelEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelEdge(int const &)\n" + " TNEANet::DelEdge(int const &,int const &,bool const &)\n" + " TNEANet::DelEdge(int const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsEdge" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (bool)(*arg1)->IsEdge((int const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsEdge" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PNEANet_IsEdge" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (bool)(*arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsEdge" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (bool)(*arg1)->IsEdge((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsEdge__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + bool *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + bool result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsEdge" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PNEANet_IsEdge" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + result = (bool)(*arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,*arg4,(bool const &)*arg5); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsEdge__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsEdge" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_IsEdge" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_IsEdge" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_IsEdge" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + result = (bool)(*arg1)->IsEdge((int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsEdge(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_IsEdge",0,5,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_IsEdge__SWIG_0(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_IsEdge__SWIG_2(self, argc, argv); + } + if (argc == 4) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_PNEANet_IsEdge__SWIG_4(self, argc, argv); + } +check_3: + + if (argc == 4) { + return _wrap_PNEANet_IsEdge__SWIG_1(self, argc, argv); + } + if (argc == 5) { + return _wrap_PNEANet_IsEdge__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_IsEdge'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IsEdge(int const &) const\n" + " TNEANet::IsEdge(int const &,int const &,bool const &) const\n" + " TNEANet::IsEdge(int const &,int const &) const\n" + " TNEANet::IsEdge(int const &,int const &,int &,bool const &) const\n" + " TNEANet::IsEdge(int const &,int const &,int &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetEId",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEId" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetEId" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetEId" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)(*arg1)->GetEId((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (*arg1)->BegEI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_BegEI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TNEANet_BegEI__SWIG_1((TNEANet*)(arg1)->operator ->()); + resultobj = SWIG_NewPointerObj((new TNEANetEdgeI(static_cast< const TNEANetEdgeI& >(result))), SWIGTYPE_p_TNEANetEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_BegEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_BegEI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_BegEI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_PNEANet_BegEI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_BegEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::BegEI() const\n" + " TNEANet::BegEI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (*arg1)->EndEI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANetEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EndEI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TNEANet_EndEI__SWIG_1((TNEANet*)(arg1)->operator ->()); + resultobj = SWIG_NewPointerObj((new TNEANetEdgeI(static_cast< const TNEANetEdgeI& >(result))), SWIGTYPE_p_TNEANetEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EndEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_EndEI",0,1,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_EndEI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + return _wrap_PNEANet_EndEI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_EndEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::EndEI() const\n" + " TNEANet::EndEI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + TNEANet::TEdgeI result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetEI",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEI" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetEI" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_GetEI" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (*arg1)->GetEI((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndNId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndNId" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetRndNId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(*arg1)->GetRndNId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndNId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndNId" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)(*arg1)->GetRndNId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndNId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetRndNId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_GetRndNId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_GetRndNId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetRndNId'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndNId(TRnd &)\n" + " TNEANet::GetRndNId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndNI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndNI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetRndNI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (*arg1)->GetRndNI(*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndNI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TNodeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndNI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (*arg1)->GetRndNI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TNodeI(static_cast< const TNEANet::TNodeI& >(result))), SWIGTYPE_p_TNEANet__TNodeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndNI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetRndNI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_GetRndNI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_GetRndNI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetRndNI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndNI(TRnd &)\n" + " TNEANet::GetRndNI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndEId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndEId" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetRndEId" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetRndEId" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (int)(*arg1)->GetRndEId(*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndEId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndEId" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)(*arg1)->GetRndEId(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndEId(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetRndEId",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_GetRndEId__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_GetRndEId__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetRndEId'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndEId(TRnd &)\n" + " TNEANet::GetRndEId()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndEI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TRnd *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndEI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TRnd, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetRndEI" "', argument " "2"" of type '" "TRnd &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetRndEI" "', argument " "2"" of type '" "TRnd &""'"); + } + arg2 = reinterpret_cast< TRnd * >(argp2); + result = (*arg1)->GetRndEI(*arg2); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndEI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TNEANet::TEdgeI result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetRndEI" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (*arg1)->GetRndEI(); + resultobj = SWIG_NewPointerObj((new TNEANet::TEdgeI(static_cast< const TNEANet::TEdgeI& >(result))), SWIGTYPE_p_TNEANet__TEdgeI, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetRndEI(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetRndEI",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_GetRndEI__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_GetRndEI__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetRndEI'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetRndEI(TRnd &)\n" + " TNEANet::GetRndEI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetNIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetNIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetNIdV" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetNIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + (*arg1)->GetNIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEIdV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetEIdV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEIdV" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetEIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetEIdV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + (*arg1)->GetEIdV(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_Reserve",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Reserve" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_Reserve" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PNEANet_Reserve" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + (*arg1)->Reserve((int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Defrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Defrag" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_Defrag" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + (*arg1)->Defrag((bool const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Defrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Defrag" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + (*arg1)->Defrag(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Defrag(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_Defrag",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_Defrag__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_Defrag__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_Defrag'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::Defrag(bool const &)\n" + " TNEANet::Defrag()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsOk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + bool *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsOk" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_IsOk" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + result = (bool)(*arg1)->IsOk((bool const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsOk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_IsOk" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (bool)(*arg1)->IsOk(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_IsOk(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_IsOk",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_IsOk__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_IsOk__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_IsOk'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::IsOk(bool const &) const\n" + " TNEANet::IsOk() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Dump__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + FILE *arg2 = (FILE *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Dump" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_Dump" "', argument " "2"" of type '" "FILE *""'"); + } + arg2 = reinterpret_cast< FILE * >(argp2); + (*arg1)->Dump(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Dump__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_Dump" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + (*arg1)->Dump(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_Dump(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_Dump",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_PNEANet_Dump__SWIG_1(self, argc, argv); + } + if (argc == 2) { + return _wrap_PNEANet_Dump__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_Dump'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::Dump(FILE *) const\n" + " TNEANet::Dump() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddIntAttrDatN((TNEANet::TNodeI const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddIntAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddIntAttrDatN((int const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddIntAttrDatN",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_AddIntAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_PNEANet_AddIntAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddIntAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrDatN(TNEANet::TNodeI const &,TInt const &,TStr const &)\n" + " TNEANet::AddIntAttrDatN(int const &,TInt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddStrAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddStrAttrDatN((int const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddStrAttrDatN",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_AddStrAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_PNEANet_AddStrAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddStrAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrDatN(TNEANet::TNodeI const &,TStr const &,TStr const &)\n" + " TNEANet::AddStrAttrDatN(int const &,TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddFltAttrDatN((TNEANet::TNodeI const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddFltAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrDatN" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddFltAttrDatN((int const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddFltAttrDatN",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_AddFltAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_PNEANet_AddFltAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddFltAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrDatN(TNEANet::TNodeI const &,TFlt const &,TStr const &)\n" + " TNEANet::AddFltAttrDatN(int const &,TFlt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddIntAttrDatE((TNEANet::TEdgeI const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TInt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddIntAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = &I; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddIntAttrDatE((int const &)*arg2,(TInt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddIntAttrDatE",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_AddIntAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_PNEANet_AddIntAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddIntAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrDatE(TNEANet::TEdgeI const &,TInt const &,TStr const &)\n" + " TNEANet::AddIntAttrDatE(int const &,TInt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddStrAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddStrAttrDatE((int const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddStrAttrDatE",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_AddStrAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_PNEANet_AddStrAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddStrAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrDatE(TNEANet::TEdgeI const &,TStr const &,TStr const &)\n" + " TNEANet::AddStrAttrDatE(int const &,TStr const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddFltAttrDatE((TNEANet::TEdgeI const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TFlt *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_AddFltAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = &F; + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrDatE" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + result = (int)(*arg1)->AddFltAttrDatE((int const &)*arg2,(TFlt const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddFltAttrDatE",0,4,argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_AddFltAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 4) { + return _wrap_PNEANet_AddFltAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddFltAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrDatE(TNEANet::TEdgeI const &,TFlt const &,TStr const &)\n" + " TNEANet::AddFltAttrDatE(int const &,TFlt const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetIntAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetIntAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetIntAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetIntAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetIntAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetIntAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetIntAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetIntAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetIntAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetIntAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetIntAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_GetIntAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_GetIntAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetIntAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetIntAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::GetIntAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetStrAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetStrAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetStrAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetStrAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetStrAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetStrAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetStrAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetStrAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetStrAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetStrAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetStrAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_GetStrAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_GetStrAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetStrAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetStrAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::GetStrAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetFltAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetFltAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetFltAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetFltAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetFltAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetFltAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetFltAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetFltAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetFltAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetFltAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetFltAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_GetFltAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_GetFltAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetFltAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetFltAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::GetFltAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetIntAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetIntAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetIntAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetIntAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetIntAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TInt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetIntAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetIntAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetIntAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetIntAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TInt(static_cast< const TInt& >(result))), SWIGTYPE_p_TInt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetIntAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetIntAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_GetIntAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_GetIntAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetIntAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetIntAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::GetIntAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetStrAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetStrAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetStrAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetStrAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetStrAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TStr result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetStrAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetStrAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetStrAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetStrAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetStrAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetStrAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_GetStrAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_GetStrAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetStrAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetStrAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::GetStrAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetFltAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetFltAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_GetFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetFltAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetFltAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetFltAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + TFlt result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetFltAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetFltAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetFltAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (*arg1)->GetFltAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_NewPointerObj((new TFlt(static_cast< const TFlt& >(result))), SWIGTYPE_p_TFlt, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetFltAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_GetFltAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_GetFltAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_GetFltAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_GetFltAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::GetFltAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::GetFltAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrDatN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TNodeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TNodeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_DelAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrDatN" "', argument " "2"" of type '" "TNEANet::TNodeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TNodeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(*arg1)->DelAttrDatN((TNEANet::TNodeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrDatN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelAttrDatN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_DelAttrDatN" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrDatN" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(*arg1)->DelAttrDatN((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrDatN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_DelAttrDatN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TNodeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_DelAttrDatN__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_DelAttrDatN__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_DelAttrDatN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelAttrDatN(TNEANet::TNodeI const &,TStr const &)\n" + " TNEANet::DelAttrDatN(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrDatE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TNEANet::TEdgeI *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TNEANet__TEdgeI, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_DelAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrDatE" "', argument " "2"" of type '" "TNEANet::TEdgeI const &""'"); + } + arg2 = reinterpret_cast< TNEANet::TEdgeI * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(*arg1)->DelAttrDatE((TNEANet::TEdgeI const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrDatE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelAttrDatE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_DelAttrDatE" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrDatE" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + result = (int)(*arg1)->DelAttrDatE((int const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrDatE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_DelAttrDatE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TNEANet__TEdgeI, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_PNEANet_DelAttrDatE__SWIG_0(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_PNEANet_DelAttrDatE__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_DelAttrDatE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::DelAttrDatE(TNEANet::TEdgeI const &,TStr const &)\n" + " TNEANet::DelAttrDatE(int const &,TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + TInt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = I; + } + result = (int)(*arg1)->AddIntAttrN((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->AddIntAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddIntAttrN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_AddIntAttrN__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_AddIntAttrN__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddIntAttrN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrN(TStr const &,TInt)\n" + " TNEANet::AddIntAttrN(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + TStr arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TStr S(PyString_AsString(swig_obj[2])); + arg3 = S; + } + result = (int)(*arg1)->AddStrAttrN((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->AddStrAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddStrAttrN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_AddStrAttrN__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_AddStrAttrN__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddStrAttrN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrN(TStr const &,TStr)\n" + " TNEANet::AddStrAttrN(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrN__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + TFlt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = F; + } + result = (int)(*arg1)->AddFltAttrN((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrN__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->AddFltAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrN(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddFltAttrN",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_AddFltAttrN__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_AddFltAttrN__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddFltAttrN'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrN(TStr const &,TFlt)\n" + " TNEANet::AddFltAttrN(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + TInt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TInt I = PyInt_AsLong(swig_obj[2]); + arg3 = I; + } + result = (int)(*arg1)->AddIntAttrE((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddIntAttrE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddIntAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->AddIntAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddIntAttrE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddIntAttrE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_AddIntAttrE__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_AddIntAttrE__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddIntAttrE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddIntAttrE(TStr const &,TInt)\n" + " TNEANet::AddIntAttrE(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + TStr arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TStr S(PyString_AsString(swig_obj[2])); + arg3 = S; + } + result = (int)(*arg1)->AddStrAttrE((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddStrAttrE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddStrAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->AddStrAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddStrAttrE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddStrAttrE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_AddStrAttrE__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_AddStrAttrE__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddStrAttrE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddStrAttrE(TStr const &,TStr)\n" + " TNEANet::AddStrAttrE(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + TFlt arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + { + TFlt F = PyFloat_AsDouble(swig_obj[2]); + arg3 = F; + } + result = (int)(*arg1)->AddFltAttrE((TStr const &)*arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_AddFltAttrE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_AddFltAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->AddFltAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_AddFltAttrE(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"PNEANet_AddFltAttrE",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_PNEANet_AddFltAttrE__SWIG_1(self, argc, argv); + } + if (argc == 3) { + return _wrap_PNEANet_AddFltAttrE__SWIG_0(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PNEANet_AddFltAttrE'.\n" + " Possible C/C++ prototypes are:\n" + " TNEANet::AddFltAttrE(TStr const &,TFlt)\n" + " TNEANet::AddFltAttrE(TStr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_DelAttrN",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelAttrN" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_DelAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrN" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->DelAttrN((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_DelAttrE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + TStr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_DelAttrE",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_DelAttrE" "', argument " "1"" of type '" "TPt< TNEANet > *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PNEANet_DelAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_DelAttrE" "', argument " "2"" of type '" "TStr const &""'"); + } + arg2 = reinterpret_cast< TStr * >(argp2); + result = (int)(*arg1)->DelAttrE((TStr const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_NodeAttrIsDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_NodeAttrIsDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_NodeAttrIsDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_NodeAttrIsDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_NodeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_NodeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->NodeAttrIsDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_NodeAttrIsIntDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_NodeAttrIsIntDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_NodeAttrIsIntDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_NodeAttrIsIntDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_NodeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_NodeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->NodeAttrIsIntDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_NodeAttrIsStrDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_NodeAttrIsStrDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_NodeAttrIsStrDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_NodeAttrIsStrDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_NodeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_NodeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->NodeAttrIsStrDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_NodeAttrIsFltDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_NodeAttrIsFltDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_NodeAttrIsFltDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_NodeAttrIsFltDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_NodeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_NodeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->NodeAttrIsFltDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EdgeAttrIsDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_EdgeAttrIsDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EdgeAttrIsDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_EdgeAttrIsDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_EdgeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EdgeAttrIsDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->EdgeAttrIsDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EdgeAttrIsIntDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_EdgeAttrIsIntDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EdgeAttrIsIntDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_EdgeAttrIsIntDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_EdgeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EdgeAttrIsIntDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->EdgeAttrIsIntDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EdgeAttrIsStrDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_EdgeAttrIsStrDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EdgeAttrIsStrDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_EdgeAttrIsStrDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_EdgeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EdgeAttrIsStrDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->EdgeAttrIsStrDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_EdgeAttrIsFltDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_EdgeAttrIsFltDeleted",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_EdgeAttrIsFltDeleted" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_EdgeAttrIsFltDeleted" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_EdgeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_EdgeAttrIsFltDeleted" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (bool)(*arg1)->EdgeAttrIsFltDeleted((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetNodeAttrValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetNodeAttrValue",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetNodeAttrValue" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetNodeAttrValue" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetNodeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetNodeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (*arg1)->GetNodeAttrValue((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PNEANet_GetEdgeAttrValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = (TPt< TNEANet > *) 0 ; + int *arg2 = 0 ; + TStrIntPrH::TIter *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + TStr result; + + if (!SWIG_Python_UnpackTuple(args,"PNEANet_GetEdgeAttrValue",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PNEANet_GetEdgeAttrValue" "', argument " "1"" of type '" "TPt< TNEANet > const *""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PNEANet_GetEdgeAttrValue" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStrIntPrH__TIter, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PNEANet_GetEdgeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PNEANet_GetEdgeAttrValue" "', argument " "3"" of type '" "TStrIntPrH::TIter const &""'"); + } + arg3 = reinterpret_cast< TStrIntPrH::TIter * >(argp3); + result = (*arg1)->GetEdgeAttrValue((int const &)*arg2,(TStrIntPrH::TIter const &)*arg3); + resultobj = SWIG_NewPointerObj((new TStr(static_cast< const TStr& >(result))), SWIGTYPE_p_TStr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *PNEANet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_TPtT_TNEANet_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_GetNodeWcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args,"GetNodeWcc",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodeWcc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeWcc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetNodeWcc" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetNodeWcc" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeWcc" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodeWcc< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IsConnected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsConnected" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IsConnected" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (bool)TSnap::SWIGTEMPLATEDISAMBIGUATOR IsConnected< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IsWeaklyConn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsWeaklyConn" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IsWeaklyConn" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (bool)TSnap::SWIGTEMPLATEDISAMBIGUATOR IsWeaklyConn< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetWccSzCnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetWccSzCnt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetWccSzCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetWccSzCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetWccSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetWccSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetWccSzCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetWccs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TCnComV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetWccs",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetWccs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetWccs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetWccs" "', argument " "2"" of type '" "TCnComV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetWccs" "', argument " "2"" of type '" "TCnComV &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetWccs< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSccSzCnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetSccSzCnt",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSccSzCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSccSzCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSccSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSccSzCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetSccSzCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSccs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TCnComV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetSccs",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSccs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSccs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSccs" "', argument " "2"" of type '" "TCnComV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSccs" "', argument " "2"" of type '" "TCnComV &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetSccs< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxWccSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxWccSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxWccSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxWccSz< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxWcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TPt< TNEANet > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxWcc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxWcc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxWcc< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxScc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + TPt< TNEANet > result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxScc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxScc" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxScc< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxBiCon__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + TPt< TNEANet > result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxBiCon" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxBiCon" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxBiCon< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_NewPointerObj((new TPt< TNEANet >(static_cast< const TPt< TNEANet >& >(result))), SWIGTYPE_p_TPtT_TNEANet_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxBiCon(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetMxBiCon",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TPtT_TUNGraph_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetMxBiCon__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 1) { + return _wrap_GetMxBiCon__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_GetMxBiCon__SWIG_1(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetMxBiCon'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetMxBiCon(PUNGraph const &,bool const &)\n" + " TSnap::GetMxBiCon(PUNGraph const &)\n" + " TSnap::GetMxBiCon< PNEANet >(TPt< TNEANet > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CntInDegNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"CntInDegNodes",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntInDegNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntInDegNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CntInDegNodes" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntInDegNodes< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntOutDegNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"CntOutDegNodes",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntOutDegNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntOutDegNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CntOutDegNodes" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntOutDegNodes< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntDegNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"CntDegNodes",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntDegNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntDegNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CntDegNodes" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntDegNodes< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntNonZNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntNonZNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntNonZNodes" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntNonZNodes< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntEdgesToSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntSet *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"CntEdgesToSet",3,3,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntEdgesToSet" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntEdgesToSet" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CntEdgesToSet" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TIntSet, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CntEdgesToSet" "', argument " "3"" of type '" "TIntSet const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntEdgesToSet" "', argument " "3"" of type '" "TIntSet const &""'"); + } + arg3 = reinterpret_cast< TIntSet * >(argp3); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntEdgesToSet< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(TIntSet const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxDegNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxDegNId" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxDegNId" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxDegNId< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxInDegNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxInDegNId" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxInDegNId" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxInDegNId< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetMxOutDegNId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMxOutDegNId" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetMxOutDegNId" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetMxOutDegNId< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetInDegCnt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetInDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetInDegCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInDegCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetInDegCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetInDegCnt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetInDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetInDegCnt" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInDegCnt" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetInDegCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetInDegCnt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetInDegCnt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetInDegCnt__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_GetInDegCnt__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetInDegCnt'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetInDegCnt< PNEANet >(TPt< TNEANet > const &,TIntPrV &)\n" + " TSnap::GetInDegCnt< PNEANet >(TPt< TNEANet > const &,TFltPrV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetOutDegCnt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOutDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOutDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetOutDegCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOutDegCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetOutDegCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetOutDegCnt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOutDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOutDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetOutDegCnt" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOutDegCnt" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetOutDegCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetOutDegCnt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetOutDegCnt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetOutDegCnt__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_GetOutDegCnt__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetOutDegCnt'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetOutDegCnt< PNEANet >(TPt< TNEANet > const &,TIntPrV &)\n" + " TSnap::GetOutDegCnt< PNEANet >(TPt< TNEANet > const &,TFltPrV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetDegCnt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetDegCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegCnt" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetDegCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetDegCnt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegCnt" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetDegCnt" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegCnt" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetDegCnt< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetDegCnt(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetDegCnt",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetDegCnt__SWIG_2(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_GetDegCnt__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetDegCnt'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetDegCnt< PNEANet >(TPt< TNEANet > const &,TIntPrV &)\n" + " TSnap::GetDegCnt< PNEANet >(TPt< TNEANet > const &,TFltPrV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetDegSeqV__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDegSeqV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegSeqV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetDegSeqV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegSeqV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetDegSeqV< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetDegSeqV__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntV *arg2 = 0 ; + TIntV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDegSeqV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegSeqV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetDegSeqV" "', argument " "2"" of type '" "TIntV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegSeqV" "', argument " "2"" of type '" "TIntV &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetDegSeqV" "', argument " "3"" of type '" "TIntV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDegSeqV" "', argument " "3"" of type '" "TIntV &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetDegSeqV< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetDegSeqV(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetDegSeqV",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GetDegSeqV__SWIG_2(self, argc, argv); + } + if (argc == 3) { + return _wrap_GetDegSeqV__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetDegSeqV'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetDegSeqV< PNEANet >(TPt< TNEANet > const &,TIntV &)\n" + " TSnap::GetDegSeqV< PNEANet >(TPt< TNEANet > const &,TIntV &,TIntV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetNodeInDegV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetNodeInDegV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodeInDegV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeInDegV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetNodeInDegV" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeInDegV" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodeInDegV< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodeOutDegV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetNodeOutDegV",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodeOutDegV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeOutDegV" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetNodeOutDegV" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeOutDegV" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodeOutDegV< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntUniqUndirEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntUniqUndirEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntUniqUndirEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntUniqUndirEdges< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntUniqDirEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntUniqDirEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntUniqDirEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntUniqDirEdges< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntUniqBiDirEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntUniqBiDirEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntUniqBiDirEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntUniqBiDirEdges< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CntSelfEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CntSelfEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CntSelfEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR CntSelfEdges< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + SwigValueWrapper< TPt< TNGraph > > result; + + if (!SWIG_Python_UnpackTuple(args,"GetBfsTree",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsTree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsTree" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsTree" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetBfsTree" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetBfsTree" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsTree< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(bool const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_NewPointerObj((new PNGraph(static_cast< const PNGraph& >(result))), SWIGTYPE_p_TPtT_TNGraph_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetSubTreeSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + bool *arg4 = 0 ; + int *arg5 = 0 ; + int *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject *swig_obj[6] ; + int result; + + if (!SWIG_Python_UnpackTuple(args,"GetSubTreeSz",6,6,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSubTreeSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubTreeSz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetSubTreeSz" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetSubTreeSz" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetSubTreeSz" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSubTreeSz" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubTreeSz" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GetSubTreeSz" "', argument " "6"" of type '" "int &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSubTreeSz" "', argument " "6"" of type '" "int &""'"); + } + arg6 = reinterpret_cast< int * >(argp6); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetSubTreeSz< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(bool const &)*arg3,(bool const &)*arg4,*arg5,*arg6); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodesAtHop__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TIntV *arg4 = 0 ; + bool *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + int result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodesAtHop" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHop" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetNodesAtHop" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetNodesAtHop" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetNodesAtHop" "', argument " "4"" of type '" "TIntV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHop" "', argument " "4"" of type '" "TIntV &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNodesAtHop" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodesAtHop< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(int const &)*arg3,*arg4,(bool const &)*arg5); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodesAtHop__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TIntV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodesAtHop" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHop" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetNodesAtHop" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetNodesAtHop" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetNodesAtHop" "', argument " "4"" of type '" "TIntV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHop" "', argument " "4"" of type '" "TIntV &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodesAtHop< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodesAtHop(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetNodesAtHop",0,5,argv))) SWIG_fail; + --argc; + if (argc == 4) { + return _wrap_GetNodesAtHop__SWIG_3(self, argc, argv); + } + if (argc == 5) { + return _wrap_GetNodesAtHop__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetNodesAtHop'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetNodesAtHop< PNEANet >(TPt< TNEANet > const &,int const &,int const &,TIntV &,bool const &)\n" + " TSnap::GetNodesAtHop< PNEANet >(TPt< TNEANet > const &,int const &,int const &,TIntV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetNodesAtHops__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntPrV *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodesAtHops" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHops" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetNodesAtHops" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetNodesAtHops" "', argument " "3"" of type '" "TIntPrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHops" "', argument " "3"" of type '" "TIntPrV &""'"); + } + arg3 = reinterpret_cast< TIntPrV * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNodesAtHops" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodesAtHops< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodesAtHops__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntPrV *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodesAtHops" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHops" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetNodesAtHops" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetNodesAtHops" "', argument " "3"" of type '" "TIntPrV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodesAtHops" "', argument " "3"" of type '" "TIntPrV &""'"); + } + arg3 = reinterpret_cast< TIntPrV * >(argp3); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodesAtHops< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodesAtHops(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetNodesAtHops",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_GetNodesAtHops__SWIG_3(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetNodesAtHops__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetNodesAtHops'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetNodesAtHops< PNEANet >(TPt< TNEANet > const &,int const &,TIntPrV &,bool const &)\n" + " TSnap::GetNodesAtHops< PNEANet >(TPt< TNEANet > const &,int const &,TIntPrV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetShortPath__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetShortPath" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetShortPath" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetShortPath" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetShortPath< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetShortPath__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetShortPath" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetShortPath" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetShortPath< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetShortPath__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntH *arg3 = 0 ; + bool *arg4 = 0 ; + int *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + int temp5 ; + int val5 ; + int ecode5 = 0 ; + int result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetShortPath" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetShortPath" "', argument " "3"" of type '" "TIntH &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "3"" of type '" "TIntH &""'"); + } + arg3 = reinterpret_cast< TIntH * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetShortPath" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetShortPath" "', argument " "5"" of type '" "int""'"); + } + temp5 = static_cast< int >(val5); + arg5 = &temp5; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetShortPath< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3,(bool const &)*arg4,(int const &)*arg5); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetShortPath__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntH *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetShortPath" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetShortPath" "', argument " "3"" of type '" "TIntH &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "3"" of type '" "TIntH &""'"); + } + arg3 = reinterpret_cast< TIntH * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetShortPath" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetShortPath< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3,(bool const &)*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetShortPath__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntH *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetShortPath" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetShortPath" "', argument " "3"" of type '" "TIntH &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShortPath" "', argument " "3"" of type '" "TIntH &""'"); + } + arg3 = reinterpret_cast< TIntH * >(argp3); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetShortPath< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetShortPath(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetShortPath",0,5,argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetShortPath__SWIG_9(self, argc, argv); + } +check_1: + + if (argc == 3) { + return _wrap_GetShortPath__SWIG_6(self, argc, argv); + } + if (argc == 4) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_GetShortPath__SWIG_8(self, argc, argv); + } +check_3: + + if (argc == 4) { + return _wrap_GetShortPath__SWIG_5(self, argc, argv); + } + if (argc == 5) { + return _wrap_GetShortPath__SWIG_7(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetShortPath'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetShortPath< PNEANet >(TPt< TNEANet > const &,int const &,int const &,bool const &)\n" + " TSnap::GetShortPath< PNEANet >(TPt< TNEANet > const &,int const &,int const &)\n" + " TSnap::GetShortPath< PNEANet >(TPt< TNEANet > const &,int const &,TIntH &,bool const &,int const &)\n" + " TSnap::GetShortPath< PNEANet >(TPt< TNEANet > const &,int const &,TIntH &,bool const &)\n" + " TSnap::GetShortPath< PNEANet >(TPt< TNEANet > const &,int const &,TIntH &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetBfsFullDiam__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsFullDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsFullDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsFullDiam" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetBfsFullDiam" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsFullDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsFullDiam__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsFullDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsFullDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsFullDiam" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsFullDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsFullDiam(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetBfsFullDiam",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GetBfsFullDiam__SWIG_3(self, argc, argv); + } + if (argc == 3) { + return _wrap_GetBfsFullDiam__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetBfsFullDiam'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetBfsFullDiam< PNEANet >(TPt< TNEANet > const &,int const &,bool const &)\n" + " TSnap::GetBfsFullDiam< PNEANet >(TPt< TNEANet > const &,int const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetBfsEffDiam__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + double result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsEffDiam" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetBfsEffDiam" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(bool const &)*arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsEffDiam__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsEffDiam" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsEffDiam__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + double *arg4 = 0 ; + int *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsEffDiam" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetBfsEffDiam" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetBfsEffDiam" "', argument " "4"" of type '" "double &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetBfsEffDiam" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(bool const &)*arg3,*arg4,*arg5); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsEffDiam__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + bool *arg3 = 0 ; + double *arg4 = 0 ; + int *arg5 = 0 ; + double *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + bool temp3 ; + bool val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + double result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsEffDiam" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetBfsEffDiam" "', argument " "3"" of type '" "bool""'"); + } + temp3 = static_cast< bool >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetBfsEffDiam" "', argument " "4"" of type '" "double &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetBfsEffDiam" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GetBfsEffDiam" "', argument " "6"" of type '" "double &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "6"" of type '" "double &""'"); + } + arg6 = reinterpret_cast< double * >(argp6); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(bool const &)*arg3,*arg4,*arg5,*arg6); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsEffDiam__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntV *arg3 = 0 ; + bool *arg4 = 0 ; + double *arg5 = 0 ; + int *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + double result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetBfsEffDiam" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetBfsEffDiam" "', argument " "3"" of type '" "TIntV const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "3"" of type '" "TIntV const &""'"); + } + arg3 = reinterpret_cast< TIntV * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetBfsEffDiam" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetBfsEffDiam" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GetBfsEffDiam" "', argument " "6"" of type '" "int &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBfsEffDiam" "', argument " "6"" of type '" "int &""'"); + } + arg6 = reinterpret_cast< int * >(argp6); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetBfsEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(TVec< TInt,int > const &)*arg3,(bool const &)*arg4,*arg5,*arg6); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetBfsEffDiam(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetBfsEffDiam",0,6,argv))) SWIG_fail; + --argc; + if (argc == 2) { + return _wrap_GetBfsEffDiam__SWIG_6(self, argc, argv); + } + if (argc == 3) { + return _wrap_GetBfsEffDiam__SWIG_5(self, argc, argv); + } + if (argc == 5) { + return _wrap_GetBfsEffDiam__SWIG_7(self, argc, argv); + } + if (argc == 6) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_4; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_4; + return _wrap_GetBfsEffDiam__SWIG_9(self, argc, argv); + } +check_4: + + if (argc == 6) { + return _wrap_GetBfsEffDiam__SWIG_8(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetBfsEffDiam'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetBfsEffDiam< PNEANet >(TPt< TNEANet > const &,int const &,bool const &)\n" + " TSnap::GetBfsEffDiam< PNEANet >(TPt< TNEANet > const &,int const &)\n" + " TSnap::GetBfsEffDiam< PNEANet >(TPt< TNEANet > const &,int const &,bool const &,double &,int &)\n" + " TSnap::GetBfsEffDiam< PNEANet >(TPt< TNEANet > const &,int const &,bool const &,double &,int &,double &)\n" + " TSnap::GetBfsEffDiam< PNEANet >(TPt< TNEANet > const &,int const &,TIntV const &,bool const &,double &,int &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DrawGViz__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TGVizLayout *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + bool *arg5 = 0 ; + TIntStrH *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 ; + TGVizLayout temp2 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int (swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawGViz" "', argument " "2"" of type '" "TGVizLayout const &""'"); + } else { + temp2 = static_cast< TGVizLayout >(val2); + arg2 = &temp2; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DrawGViz" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DrawGViz" "', argument " "6"" of type '" "TIntStrH const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "6"" of type '" "TIntStrH const &""'"); + } + arg6 = reinterpret_cast< TIntStrH * >(argp6); + TSnap::SWIGTEMPLATEDISAMBIGUATOR DrawGViz< PNEANet >((TPt< TNEANet > const &)*arg1,(enum TGVizLayout_ const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(bool const &)*arg5,(THash< TInt,TStr,TDefaultHashFunc< TInt > > const &)*arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DrawGViz__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TGVizLayout *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + bool *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 ; + TGVizLayout temp2 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int (swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawGViz" "', argument " "2"" of type '" "TGVizLayout const &""'"); + } else { + temp2 = static_cast< TGVizLayout >(val2); + arg2 = &temp2; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DrawGViz" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + TSnap::SWIGTEMPLATEDISAMBIGUATOR DrawGViz< PNEANet >((TPt< TNEANet > const &)*arg1,(enum TGVizLayout_ const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(bool const &)*arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DrawGViz__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TGVizLayout *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 ; + TGVizLayout temp2 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int (swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawGViz" "', argument " "2"" of type '" "TGVizLayout const &""'"); + } else { + temp2 = static_cast< TGVizLayout >(val2); + arg2 = &temp2; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + TSnap::SWIGTEMPLATEDISAMBIGUATOR DrawGViz< PNEANet >((TPt< TNEANet > const &)*arg1,(enum TGVizLayout_ const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DrawGViz__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TGVizLayout *arg2 = 0 ; + TStr *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 ; + TGVizLayout temp2 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int (swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawGViz" "', argument " "2"" of type '" "TGVizLayout const &""'"); + } else { + temp2 = static_cast< TGVizLayout >(val2); + arg2 = &temp2; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + TSnap::SWIGTEMPLATEDISAMBIGUATOR DrawGViz< PNEANet >((TPt< TNEANet > const &)*arg1,(enum TGVizLayout_ const &)*arg2,(TStr const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DrawGViz__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TGVizLayout *arg2 = 0 ; + TStr *arg3 = 0 ; + TStr *arg4 = 0 ; + TIntStrH *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 ; + TGVizLayout temp2 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int (swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DrawGViz" "', argument " "2"" of type '" "TGVizLayout const &""'"); + } else { + temp2 = static_cast< TGVizLayout >(val2); + arg2 = &temp2; + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "3"" of type '" "TStr const &""'"); + } + arg3 = reinterpret_cast< TStr * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TStr, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "4"" of type '" "TStr const &""'"); + } + arg4 = reinterpret_cast< TStr * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DrawGViz" "', argument " "5"" of type '" "TIntStrH const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawGViz" "', argument " "5"" of type '" "TIntStrH const &""'"); + } + arg5 = reinterpret_cast< TIntStrH * >(argp5); + TSnap::SWIGTEMPLATEDISAMBIGUATOR DrawGViz< PNEANet >((TPt< TNEANet > const &)*arg1,(enum TGVizLayout_ const &)*arg2,(TStr const &)*arg3,(TStr const &)*arg4,(THash< TInt,TStr,TDefaultHashFunc< TInt > > const &)*arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DrawGViz(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"DrawGViz",0,6,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_DrawGViz__SWIG_8(self, argc, argv); + } + if (argc == 4) { + return _wrap_DrawGViz__SWIG_7(self, argc, argv); + } + if (argc == 5) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_DrawGViz__SWIG_9(self, argc, argv); + } +check_3: + + if (argc == 5) { + return _wrap_DrawGViz__SWIG_6(self, argc, argv); + } + if (argc == 6) { + return _wrap_DrawGViz__SWIG_5(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DrawGViz'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::DrawGViz< PNEANet >(TPt< TNEANet > const &,TGVizLayout const &,TStr const &,TStr const &,bool const &,TIntStrH const &)\n" + " TSnap::DrawGViz< PNEANet >(TPt< TNEANet > const &,TGVizLayout const &,TStr const &,TStr const &,bool const &)\n" + " TSnap::DrawGViz< PNEANet >(TPt< TNEANet > const &,TGVizLayout const &,TStr const &,TStr const &)\n" + " TSnap::DrawGViz< PNEANet >(TPt< TNEANet > const &,TGVizLayout const &,TStr const &)\n" + " TSnap::DrawGViz< PNEANet >(TPt< TNEANet > const &,TGVizLayout const &,TStr const &,TStr const &,TIntStrH const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetClustCf__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetClustCf" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetClustCf< PNEANet >((TPt< TNEANet > const &)*arg1,arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetClustCf__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetClustCf< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetClustCf__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + double result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetClustCf" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetClustCf< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetClustCf__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetClustCf< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetClustCf__SWIG_10(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + int64 *arg3 = 0 ; + int64 *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; + double result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetClustCf" "', argument " "3"" of type '" "int64 &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "3"" of type '" "int64 &""'"); + } + arg3 = reinterpret_cast< int64 * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetClustCf" "', argument " "4"" of type '" "int64 &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "4"" of type '" "int64 &""'"); + } + arg4 = reinterpret_cast< int64 * >(argp4); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetClustCf" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetClustCf< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,*arg3,*arg4,arg5); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetClustCf__SWIG_11(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TFltPrV *arg2 = 0 ; + int64 *arg3 = 0 ; + int64 *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "2"" of type '" "TFltPrV &""'"); + } + arg2 = reinterpret_cast< TFltPrV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetClustCf" "', argument " "3"" of type '" "int64 &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "3"" of type '" "int64 &""'"); + } + arg3 = reinterpret_cast< int64 * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetClustCf" "', argument " "4"" of type '" "int64 &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetClustCf" "', argument " "4"" of type '" "int64 &""'"); + } + arg4 = reinterpret_cast< int64 * >(argp4); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetClustCf< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,*arg3,*arg4); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetClustCf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[6]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetClustCf",0,5,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_GetClustCf__SWIG_7(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_GetClustCf__SWIG_9(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_GetClustCf__SWIG_6(self, argc, argv); + } + if (argc == 3) { + return _wrap_GetClustCf__SWIG_8(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetClustCf__SWIG_11(self, argc, argv); + } + if (argc == 5) { + return _wrap_GetClustCf__SWIG_10(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetClustCf'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetClustCf< PNEANet >(TPt< TNEANet > const &,int)\n" + " TSnap::GetClustCf< PNEANet >(TPt< TNEANet > const &)\n" + " TSnap::GetClustCf< PNEANet >(TPt< TNEANet > const &,TFltPrV &,int)\n" + " TSnap::GetClustCf< PNEANet >(TPt< TNEANet > const &,TFltPrV &)\n" + " TSnap::GetClustCf< PNEANet >(TPt< TNEANet > const &,TFltPrV &,int64 &,int64 &,int)\n" + " TSnap::GetClustCf< PNEANet >(TPt< TNEANet > const &,TFltPrV &,int64 &,int64 &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetNodeClustCf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodeClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetNodeClustCf" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodeClustCf< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodeClustCf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntFltH *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNodeClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeClustCf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetNodeClustCf" "', argument " "2"" of type '" "TIntFltH &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetNodeClustCf" "', argument " "2"" of type '" "TIntFltH &""'"); + } + arg2 = reinterpret_cast< TIntFltH * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetNodeClustCf< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetNodeClustCf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetNodeClustCf",0,2,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetNodeClustCf__SWIG_3(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_GetNodeClustCf__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetNodeClustCf'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetNodeClustCf< PNEANet >(TPt< TNEANet > const &,int const &)\n" + " TSnap::GetNodeClustCf< PNEANet >(TPt< TNEANet > const &,TIntFltH &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetTriads__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int64 result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetTriads" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int64)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriads< PNEANet >((TPt< TNEANet > const &)*arg1,arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetTriads__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int64 result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int64)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriads< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetTriads__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int64 *arg2 = 0 ; + int64 *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int64 result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetTriads" "', argument " "2"" of type '" "int64 &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "2"" of type '" "int64 &""'"); + } + arg2 = reinterpret_cast< int64 * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_long_long, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetTriads" "', argument " "3"" of type '" "int64 &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "3"" of type '" "int64 &""'"); + } + arg3 = reinterpret_cast< int64 * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetTriads" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + result = (int64)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriads< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,*arg3,arg4); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetTriads__SWIG_8(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntTrV *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetTriads" "', argument " "2"" of type '" "TIntTrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "2"" of type '" "TIntTrV &""'"); + } + arg2 = reinterpret_cast< TIntTrV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetTriads" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriads< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetTriads__SWIG_9(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntTrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetTriads" "', argument " "2"" of type '" "TIntTrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriads" "', argument " "2"" of type '" "TIntTrV &""'"); + } + arg2 = reinterpret_cast< TIntTrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriads< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetTriads(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetTriads",0,4,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_GetTriads__SWIG_6(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + return _wrap_GetTriads__SWIG_9(self, argc, argv); + } +check_2: + + if (argc == 2) { + return _wrap_GetTriads__SWIG_5(self, argc, argv); + } + if (argc == 3) { + return _wrap_GetTriads__SWIG_8(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetTriads__SWIG_7(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetTriads'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetTriads< PNEANet >(TPt< TNEANet > const &,int)\n" + " TSnap::GetTriads< PNEANet >(TPt< TNEANet > const &)\n" + " TSnap::GetTriads< PNEANet >(TPt< TNEANet > const &,int64 &,int64 &,int)\n" + " TSnap::GetTriads< PNEANet >(TPt< TNEANet > const &,TIntTrV &,int)\n" + " TSnap::GetTriads< PNEANet >(TPt< TNEANet > const &,TIntTrV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetTriadEdges__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriadEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriadEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetTriadEdges" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriadEdges< PNEANet >((TPt< TNEANet > const &)*arg1,arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetTriadEdges__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriadEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriadEdges" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriadEdges< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetTriadEdges(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetTriadEdges",0,2,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_GetTriadEdges__SWIG_3(self, argc, argv); + } + if (argc == 2) { + return _wrap_GetTriadEdges__SWIG_2(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetTriadEdges'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetTriadEdges< PNEANet >(TPt< TNEANet > const &,int)\n" + " TSnap::GetTriadEdges< PNEANet >(TPt< TNEANet > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetTriadParticip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntPrV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args,"GetTriadParticip",2,2,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTriadParticip" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriadParticip" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TPairT_TInt_TInt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetTriadParticip" "', argument " "2"" of type '" "TIntPrV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTriadParticip" "', argument " "2"" of type '" "TIntPrV &""'"); + } + arg2 = reinterpret_cast< TIntPrV * >(argp2); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetTriadParticip< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetCmnNbrs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + int result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCmnNbrs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetCmnNbrs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetCmnNbrs" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetCmnNbrs" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetCmnNbrs< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(int const &)*arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetCmnNbrs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + TIntV *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCmnNbrs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetCmnNbrs" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetCmnNbrs" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetCmnNbrs" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_TVecT_TInt_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetCmnNbrs" "', argument " "4"" of type '" "TIntV &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetCmnNbrs" "', argument " "4"" of type '" "TIntV &""'"); + } + arg4 = reinterpret_cast< TIntV * >(argp4); + result = (int)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetCmnNbrs< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,(int const &)*arg3,*arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetCmnNbrs(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetCmnNbrs",0,4,argv))) SWIG_fail; + --argc; + if (argc == 3) { + return _wrap_GetCmnNbrs__SWIG_2(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetCmnNbrs__SWIG_3(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetCmnNbrs'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetCmnNbrs< PNEANet >(TPt< TNEANet > const &,int const &,int const &)\n" + " TSnap::GetCmnNbrs< PNEANet >(TPt< TNEANet > const &,int const &,int const &,TIntV &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetModularity__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntV *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + double result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetModularity" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetModularity" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetModularity< PNEANet >((TPt< TNEANet > const &)*arg1,(TVec< TInt,int > const &)*arg2,arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetModularity__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetModularity" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetModularity< PNEANet >((TPt< TNEANet > const &)*arg1,(TVec< TInt,int > const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetModularity__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TCnComV *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + double result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetModularity" "', argument " "2"" of type '" "TCnComV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "2"" of type '" "TCnComV const &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetModularity" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetModularity< PNEANet >((TPt< TNEANet > const &)*arg1,(TVec< TCnCom > const &)*arg2,arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetModularity__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TCnComV *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TCnCom_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetModularity" "', argument " "2"" of type '" "TCnComV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetModularity" "', argument " "2"" of type '" "TCnComV const &""'"); + } + arg2 = reinterpret_cast< TCnComV * >(argp2); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetModularity< PNEANet >((TPt< TNEANet > const &)*arg1,(TVec< TCnCom > const &)*arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetModularity(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetModularity",0,3,argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TVecT_TInt_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_1; + return _wrap_GetModularity__SWIG_5(self, argc, argv); + } +check_1: + + if (argc == 2) { + return _wrap_GetModularity__SWIG_7(self, argc, argv); + } + if (argc == 3) { + int _v = 0; + { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TVecT_TCnCom_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_3; + return _wrap_GetModularity__SWIG_6(self, argc, argv); + } +check_3: + + if (argc == 3) { + return _wrap_GetModularity__SWIG_4(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetModularity'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetModularity< PNEANet >(TPt< TNEANet > const &,TIntV const &,int)\n" + " TSnap::GetModularity< PNEANet >(TPt< TNEANet > const &,TIntV const &)\n" + " TSnap::GetModularity< PNEANet >(TPt< TNEANet > const &,TCnComV const &,int)\n" + " TSnap::GetModularity< PNEANet >(TPt< TNEANet > const &,TCnComV const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetEdgesInOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntV *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args,"GetEdgesInOut",4,4,swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetEdgesInOut" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEdgesInOut" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TInt_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetEdgesInOut" "', argument " "2"" of type '" "TIntV const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEdgesInOut" "', argument " "2"" of type '" "TIntV const &""'"); + } + arg2 = reinterpret_cast< TIntV * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetEdgesInOut" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEdgesInOut" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetEdgesInOut" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetEdgesInOut" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetEdgesInOut< PNEANet >((TPt< TNEANet > const &)*arg1,(TVec< TInt,int > const &)*arg2,*arg3,*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnf__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntFltKdV *arg3 = 0 ; + int *arg4 = 0 ; + bool *arg5 = 0 ; + int *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + int temp6 ; + int val6 ; + int ecode6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetAnf" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetAnf" "', argument " "3"" of type '" "TIntFltKdV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "3"" of type '" "TIntFltKdV &""'"); + } + arg3 = reinterpret_cast< TIntFltKdV * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetAnf" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetAnf" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetAnf" "', argument " "6"" of type '" "int""'"); + } + temp6 = static_cast< int >(val6); + arg6 = &temp6; + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnf< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3,(int const &)*arg4,(bool const &)*arg5,(int const &)*arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnf__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int *arg2 = 0 ; + TIntFltKdV *arg3 = 0 ; + int *arg4 = 0 ; + bool *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int temp2 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + bool temp5 ; + bool val5 ; + int ecode5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetAnf" "', argument " "2"" of type '" "int""'"); + } + temp2 = static_cast< int >(val2); + arg2 = &temp2; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetAnf" "', argument " "3"" of type '" "TIntFltKdV &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "3"" of type '" "TIntFltKdV &""'"); + } + arg3 = reinterpret_cast< TIntFltKdV * >(argp3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetAnf" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetAnf" "', argument " "5"" of type '" "bool""'"); + } + temp5 = static_cast< bool >(val5); + arg5 = &temp5; + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnf< PNEANet >((TPt< TNEANet > const &)*arg1,(int const &)*arg2,*arg3,(int const &)*arg4,(bool const &)*arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnf__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntFltKdV *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + int *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + int temp5 ; + int val5 ; + int ecode5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetAnf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + arg2 = reinterpret_cast< TIntFltKdV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetAnf" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetAnf" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetAnf" "', argument " "5"" of type '" "int""'"); + } + temp5 = static_cast< int >(val5); + arg5 = &temp5; + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnf< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,(int const &)*arg3,(bool const &)*arg4,(int const &)*arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnf__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + TIntFltKdV *arg2 = 0 ; + int *arg3 = 0 ; + bool *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int temp3 ; + int val3 ; + int ecode3 = 0 ; + bool temp4 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetAnf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnf" "', argument " "2"" of type '" "TIntFltKdV &""'"); + } + arg2 = reinterpret_cast< TIntFltKdV * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetAnf" "', argument " "3"" of type '" "int""'"); + } + temp3 = static_cast< int >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetAnf" "', argument " "4"" of type '" "bool""'"); + } + temp4 = static_cast< bool >(val4); + arg4 = &temp4; + TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnf< PNEANet >((TPt< TNEANet > const &)*arg1,*arg2,(int const &)*arg3,(bool const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnf(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetAnf",0,6,argv))) SWIG_fail; + --argc; + if (argc == 4) { + return _wrap_GetAnf__SWIG_7(self, argc, argv); + } + if (argc == 5) { + int _v = 0; + { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0); + _v = SWIG_CheckState(res); + } + if (!_v) goto check_2; + { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_2; + { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_2; + { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + } + if (!_v) goto check_2; + return _wrap_GetAnf__SWIG_6(self, argc, argv); + } +check_2: + + if (argc == 5) { + return _wrap_GetAnf__SWIG_5(self, argc, argv); + } + if (argc == 6) { + return _wrap_GetAnf__SWIG_4(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetAnf'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetAnf< PNEANet >(TPt< TNEANet > const &,int const &,TIntFltKdV &,int const &,bool const &,int const &)\n" + " TSnap::GetAnf< PNEANet >(TPt< TNEANet > const &,int const &,TIntFltKdV &,int const &,bool const &)\n" + " TSnap::GetAnf< PNEANet >(TPt< TNEANet > const &,TIntFltKdV &,int const &,bool const &,int const &)\n" + " TSnap::GetAnf< PNEANet >(TPt< TNEANet > const &,TIntFltKdV &,int const &,bool const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GetAnfEffDiam__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + bool *arg2 = 0 ; + double *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool temp2 ; + bool val2 ; + int ecode2 = 0 ; + double temp3 ; + double val3 ; + int ecode3 = 0 ; + int temp4 ; + int val4 ; + int ecode4 = 0 ; + double result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetAnfEffDiam" "', argument " "2"" of type '" "bool""'"); + } + temp2 = static_cast< bool >(val2); + arg2 = &temp2; + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetAnfEffDiam" "', argument " "3"" of type '" "double""'"); + } + temp3 = static_cast< double >(val3); + arg3 = &temp3; + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetAnfEffDiam" "', argument " "4"" of type '" "int""'"); + } + temp4 = static_cast< int >(val4); + arg4 = &temp4; + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnfEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,(bool const &)*arg2,(double const &)*arg3,(int const &)*arg4); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnfEffDiam__SWIG_5(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + double result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetAnfEffDiam" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GetAnfEffDiam" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnfEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,arg2,arg3); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnfEffDiam__SWIG_6(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetAnfEffDiam" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnfEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1,arg2); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnfEffDiam__SWIG_7(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + TPt< TNEANet > *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TPtT_TNEANet_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetAnfEffDiam" "', argument " "1"" of type '" "TPt< TNEANet > const &""'"); + } + arg1 = reinterpret_cast< TPt< TNEANet > * >(argp1); + result = (double)TSnap::SWIGTEMPLATEDISAMBIGUATOR GetAnfEffDiam< PNEANet >((TPt< TNEANet > const &)*arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetAnfEffDiam(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + + if (!(argc = SWIG_Python_UnpackTuple(args,"GetAnfEffDiam",0,4,argv))) SWIG_fail; + --argc; + if (argc == 1) { + return _wrap_GetAnfEffDiam__SWIG_7(self, argc, argv); + } + if (argc == 2) { + return _wrap_GetAnfEffDiam__SWIG_6(self, argc, argv); + } + if (argc == 3) { + return _wrap_GetAnfEffDiam__SWIG_5(self, argc, argv); + } + if (argc == 4) { + return _wrap_GetAnfEffDiam__SWIG_4(self, argc, argv); + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GetAnfEffDiam'.\n" + " Possible C/C++ prototypes are:\n" + " TSnap::GetAnfEffDiam< PNEANet >(TPt< TNEANet > const &,bool const &,double const &,int const &)\n" + " TSnap::GetAnfEffDiam< PNEANet >(TPt< TNEANet > const &,int const,int)\n" + " TSnap::GetAnfEffDiam< PNEANet >(TPt< TNEANet > const &,int const)\n" + " TSnap::GetAnfEffDiam< PNEANet >(TPt< TNEANet > const &)\n"); + return 0; +} + + +static PyMethodDef SwigMethods[] = { + { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, + { (char *)"CalcEffDiam", _wrap_CalcEffDiam, METH_VARARGS, (char *)"\n" + "CalcEffDiam(TIntFltKdV const & DistNbrsCdfV, double const & Percentile=0.9) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsCdfV: TIntFltKdV const &\n" + " Percentile: double const &\n" + "\n" + "CalcEffDiam(TIntFltKdV const & DistNbrsCdfV) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsCdfV: TIntFltKdV const &\n" + "\n" + "CalcEffDiam(TFltPrV const & DistNbrsCdfV, double const & Percentile=0.9) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsCdfV: TFltPrV const &\n" + " Percentile: double const &\n" + "\n" + "CalcEffDiam(TFltPrV const & DistNbrsCdfV) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsCdfV: TFltPrV const &\n" + "\n" + ""}, + { (char *)"CalcEffDiamPdf", _wrap_CalcEffDiamPdf, METH_VARARGS, (char *)"\n" + "CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV, double const & Percentile=0.9) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsPdfV: TIntFltKdV const &\n" + " Percentile: double const &\n" + "\n" + "CalcEffDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsPdfV: TIntFltKdV const &\n" + "\n" + "CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV, double const & Percentile=0.9) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsPdfV: TFltPrV const &\n" + " Percentile: double const &\n" + "\n" + "CalcEffDiamPdf(TFltPrV const & DistNbrsPdfV) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsPdfV: TFltPrV const &\n" + "\n" + ""}, + { (char *)"CalcAvgDiamPdf", _wrap_CalcAvgDiamPdf, METH_VARARGS, (char *)"\n" + "CalcAvgDiamPdf(TIntFltKdV const & DistNbrsPdfV) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsPdfV: TIntFltKdV const &\n" + "\n" + "CalcAvgDiamPdf(TFltPrV const & DistNbrsPdfV) -> double\n" + "\n" + "Parameters:\n" + " DistNbrsPdfV: TFltPrV const &\n" + "\n" + ""}, + { (char *)"WrNotify", _wrap_WrNotify, METH_VARARGS, (char *)"\n" + "WrNotify(char const * CaptionCStr, char const * NotifyCStr)\n" + "\n" + "Parameters:\n" + " CaptionCStr: char const *\n" + " NotifyCStr: char const *\n" + "\n" + ""}, + { (char *)"SaveToErrLog", (PyCFunction)_wrap_SaveToErrLog, METH_O, (char *)"\n" + "SaveToErrLog(char const * MsgCStr)\n" + "\n" + "Parameters:\n" + " MsgCStr: char const *\n" + "\n" + ""}, + { (char *)"InfoNotify", (PyCFunction)_wrap_InfoNotify, METH_O, (char *)"\n" + "InfoNotify(char const * NotifyCStr)\n" + "\n" + "Parameters:\n" + " NotifyCStr: char const *\n" + "\n" + ""}, + { (char *)"WarnNotify", (PyCFunction)_wrap_WarnNotify, METH_O, (char *)"\n" + "WarnNotify(char const * NotifyCStr)\n" + "\n" + "Parameters:\n" + " NotifyCStr: char const *\n" + "\n" + ""}, + { (char *)"ErrNotify", (PyCFunction)_wrap_ErrNotify, METH_O, (char *)"\n" + "ErrNotify(char const * NotifyCStr)\n" + "\n" + "Parameters:\n" + " NotifyCStr: char const *\n" + "\n" + ""}, + { (char *)"StatNotify", (PyCFunction)_wrap_StatNotify, METH_O, (char *)"\n" + "StatNotify(char const * NotifyCStr)\n" + "\n" + "Parameters:\n" + " NotifyCStr: char const *\n" + "\n" + ""}, + { (char *)"ExeStop", _wrap_ExeStop, METH_VARARGS, (char *)"\n" + "ExeStop(char const * MsgStr, char const * ReasonStr, char const * CondStr, char const * FNm, \n" + " int const & LnN)\n" + "\n" + "Parameters:\n" + " MsgStr: char const *\n" + " ReasonStr: char const *\n" + " CondStr: char const *\n" + " FNm: char const *\n" + " LnN: int const &\n" + "\n" + ""}, + { (char *)"new_TCRef", (PyCFunction)_wrap_new_TCRef, METH_NOARGS, (char *)"new_TCRef() -> TCRef"}, + { (char *)"delete_TCRef", (PyCFunction)_wrap_delete_TCRef, METH_O, (char *)"\n" + "delete_TCRef(TCRef self)\n" + "\n" + "Parameters:\n" + " self: TCRef *\n" + "\n" + ""}, + { (char *)"TCRef_MkRef", (PyCFunction)_wrap_TCRef_MkRef, METH_O, (char *)"\n" + "TCRef_MkRef(TCRef self)\n" + "\n" + "Parameters:\n" + " self: TCRef *\n" + "\n" + ""}, + { (char *)"TCRef_UnRef", (PyCFunction)_wrap_TCRef_UnRef, METH_O, (char *)"\n" + "TCRef_UnRef(TCRef self)\n" + "\n" + "Parameters:\n" + " self: TCRef *\n" + "\n" + ""}, + { (char *)"TCRef_NoRef", (PyCFunction)_wrap_TCRef_NoRef, METH_O, (char *)"\n" + "TCRef_NoRef(TCRef self) -> bool\n" + "\n" + "Parameters:\n" + " self: TCRef const *\n" + "\n" + ""}, + { (char *)"TCRef_GetRefs", (PyCFunction)_wrap_TCRef_GetRefs, METH_O, (char *)"\n" + "TCRef_GetRefs(TCRef self) -> int\n" + "\n" + "Parameters:\n" + " self: TCRef const *\n" + "\n" + ""}, + { (char *)"TCRef_swigregister", TCRef_swigregister, METH_VARARGS, NULL}, + { (char *)"TCRef_swiginit", TCRef_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TSStr", _wrap_new_TSStr, METH_VARARGS, (char *)"\n" + "TSStr()\n" + "TSStr(TSStr SStr)\n" + "\n" + "Parameters:\n" + " SStr: TSStr const &\n" + "\n" + "new_TSStr(char const * _Bf) -> TSStr\n" + "\n" + "Parameters:\n" + " _Bf: char const *\n" + "\n" + ""}, + { (char *)"delete_TSStr", (PyCFunction)_wrap_delete_TSStr, METH_O, (char *)"\n" + "delete_TSStr(TSStr self)\n" + "\n" + "Parameters:\n" + " self: TSStr *\n" + "\n" + ""}, + { (char *)"TSStr_CStr", _wrap_TSStr_CStr, METH_VARARGS, (char *)"\n" + "CStr() -> char\n" + "TSStr_CStr(TSStr self) -> char const *\n" + "\n" + "Parameters:\n" + " self: TSStr const *\n" + "\n" + ""}, + { (char *)"TSStr_Empty", (PyCFunction)_wrap_TSStr_Empty, METH_O, (char *)"\n" + "TSStr_Empty(TSStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TSStr const *\n" + "\n" + ""}, + { (char *)"TSStr_Len", (PyCFunction)_wrap_TSStr_Len, METH_O, (char *)"\n" + "TSStr_Len(TSStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TSStr const *\n" + "\n" + ""}, + { (char *)"TSStr_swigregister", TSStr_swigregister, METH_VARARGS, NULL}, + { (char *)"TSStr_swiginit", TSStr_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TConv_Pt64Ints32", _wrap_new_TConv_Pt64Ints32, METH_VARARGS, (char *)"\n" + "TConv_Pt64Ints32()\n" + "TConv_Pt64Ints32(void * Pt)\n" + "\n" + "Parameters:\n" + " Pt: void *\n" + "\n" + "new_TConv_Pt64Ints32(uint const & Ms, uint const & Ls) -> TConv_Pt64Ints32\n" + "\n" + "Parameters:\n" + " Ms: uint const &\n" + " Ls: uint const &\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_PutPt", _wrap_TConv_Pt64Ints32_PutPt, METH_VARARGS, (char *)"\n" + "TConv_Pt64Ints32_PutPt(TConv_Pt64Ints32 self, void * Pt)\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 *\n" + " Pt: void *\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_GetPt", (PyCFunction)_wrap_TConv_Pt64Ints32_GetPt, METH_O, (char *)"\n" + "TConv_Pt64Ints32_GetPt(TConv_Pt64Ints32 self) -> void *\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 const *\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_PutUInt64", _wrap_TConv_Pt64Ints32_PutUInt64, METH_VARARGS, (char *)"\n" + "TConv_Pt64Ints32_PutUInt64(TConv_Pt64Ints32 self, uint64 const & _UInt64)\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 *\n" + " _UInt64: uint64 const &\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_GetUInt64", (PyCFunction)_wrap_TConv_Pt64Ints32_GetUInt64, METH_O, (char *)"\n" + "TConv_Pt64Ints32_GetUInt64(TConv_Pt64Ints32 self) -> uint64\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 const *\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_PutMsUInt32", _wrap_TConv_Pt64Ints32_PutMsUInt32, METH_VARARGS, (char *)"\n" + "TConv_Pt64Ints32_PutMsUInt32(TConv_Pt64Ints32 self, uint const & Ms)\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 *\n" + " Ms: uint const &\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_GetMsUInt32", (PyCFunction)_wrap_TConv_Pt64Ints32_GetMsUInt32, METH_O, (char *)"\n" + "TConv_Pt64Ints32_GetMsUInt32(TConv_Pt64Ints32 self) -> uint\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 const *\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_PutLsUInt32", _wrap_TConv_Pt64Ints32_PutLsUInt32, METH_VARARGS, (char *)"\n" + "TConv_Pt64Ints32_PutLsUInt32(TConv_Pt64Ints32 self, uint const & Ls)\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 *\n" + " Ls: uint const &\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_GetLsUInt32", (PyCFunction)_wrap_TConv_Pt64Ints32_GetLsUInt32, METH_O, (char *)"\n" + "TConv_Pt64Ints32_GetLsUInt32(TConv_Pt64Ints32 self) -> uint\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 const *\n" + "\n" + ""}, + { (char *)"delete_TConv_Pt64Ints32", (PyCFunction)_wrap_delete_TConv_Pt64Ints32, METH_O, (char *)"\n" + "delete_TConv_Pt64Ints32(TConv_Pt64Ints32 self)\n" + "\n" + "Parameters:\n" + " self: TConv_Pt64Ints32 *\n" + "\n" + ""}, + { (char *)"TConv_Pt64Ints32_swigregister", TConv_Pt64Ints32_swigregister, METH_VARARGS, NULL}, + { (char *)"TConv_Pt64Ints32_swiginit", TConv_Pt64Ints32_swiginit, METH_VARARGS, NULL}, + { (char *)"TPairHashImpl1_GetHashCd", _wrap_TPairHashImpl1_GetHashCd, METH_VARARGS, (char *)"\n" + "TPairHashImpl1_GetHashCd(int const hc1, int const hc2) -> int\n" + "\n" + "Parameters:\n" + " hc1: int const\n" + " hc2: int const\n" + "\n" + ""}, + { (char *)"new_TPairHashImpl1", (PyCFunction)_wrap_new_TPairHashImpl1, METH_NOARGS, (char *)"new_TPairHashImpl1() -> TPairHashImpl1"}, + { (char *)"delete_TPairHashImpl1", (PyCFunction)_wrap_delete_TPairHashImpl1, METH_O, (char *)"\n" + "delete_TPairHashImpl1(TPairHashImpl1 self)\n" + "\n" + "Parameters:\n" + " self: TPairHashImpl1 *\n" + "\n" + ""}, + { (char *)"TPairHashImpl1_swigregister", TPairHashImpl1_swigregister, METH_VARARGS, NULL}, + { (char *)"TPairHashImpl1_swiginit", TPairHashImpl1_swiginit, METH_VARARGS, NULL}, + { (char *)"TPairHashImpl2_GetHashCd", _wrap_TPairHashImpl2_GetHashCd, METH_VARARGS, (char *)"\n" + "TPairHashImpl2_GetHashCd(int const hc1, int const hc2) -> int\n" + "\n" + "Parameters:\n" + " hc1: int const\n" + " hc2: int const\n" + "\n" + ""}, + { (char *)"new_TPairHashImpl2", (PyCFunction)_wrap_new_TPairHashImpl2, METH_NOARGS, (char *)"new_TPairHashImpl2() -> TPairHashImpl2"}, + { (char *)"delete_TPairHashImpl2", (PyCFunction)_wrap_delete_TPairHashImpl2, METH_O, (char *)"\n" + "delete_TPairHashImpl2(TPairHashImpl2 self)\n" + "\n" + "Parameters:\n" + " self: TPairHashImpl2 *\n" + "\n" + ""}, + { (char *)"TPairHashImpl2_swigregister", TPairHashImpl2_swigregister, METH_VARARGS, NULL}, + { (char *)"TPairHashImpl2_swiginit", TPairHashImpl2_swiginit, METH_VARARGS, NULL}, + { (char *)"GetDegreeCentr", _wrap_GetDegreeCentr, METH_VARARGS, (char *)"\n" + "GetDegreeCentr(PUNGraph const & Graph, int const & NId) -> double\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"GetFarnessCentr", _wrap_GetFarnessCentr, METH_VARARGS, (char *)"\n" + "GetFarnessCentr(PUNGraph const & Graph, int const & NId) -> double\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"GetClosenessCentr", _wrap_GetClosenessCentr, METH_VARARGS, (char *)"\n" + "GetClosenessCentr(PUNGraph const & Graph, int const & NId) -> double\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"GetBetweennessCentr", _wrap_GetBetweennessCentr, METH_VARARGS, (char *)"\n" + "GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, double const & NodeFrac=1.0)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdBtwH: TIntFltH &\n" + " NodeFrac: double const &\n" + "\n" + "GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdBtwH: TIntFltH &\n" + "\n" + "GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " EdgeBtwH: TIntPrFltH &\n" + " NodeFrac: double const &\n" + "\n" + "GetBetweennessCentr(PUNGraph const & Graph, TIntPrFltH & EdgeBtwH)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " EdgeBtwH: TIntPrFltH &\n" + "\n" + "GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH, double const & NodeFrac=1.0)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdBtwH: TIntFltH &\n" + " EdgeBtwH: TIntPrFltH &\n" + " NodeFrac: double const &\n" + "\n" + "GetBetweennessCentr(PUNGraph const & Graph, TIntFltH & NIdBtwH, TIntPrFltH & EdgeBtwH)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdBtwH: TIntFltH &\n" + " EdgeBtwH: TIntPrFltH &\n" + "\n" + "GetBetweennessCentr(PUNGraph const & Graph, TIntV BtwNIdV, TIntFltH & NodeBtwH, bool const & DoNodeCent, \n" + " TIntPrFltH & EdgeBtwH, bool const & DoEdgeCent)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " BtwNIdV: TIntV const &\n" + " NodeBtwH: TIntFltH &\n" + " DoNodeCent: bool const &\n" + " EdgeBtwH: TIntPrFltH &\n" + " DoEdgeCent: bool const &\n" + "\n" + ""}, + { (char *)"GetEigenVectorCentr", _wrap_GetEigenVectorCentr, METH_VARARGS, (char *)"\n" + "GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4, int const & MaxIter=100)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdEigenH: TIntFltH &\n" + " Eps: double const &\n" + " MaxIter: int const &\n" + "\n" + "GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH, double const & Eps=1e-4)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdEigenH: TIntFltH &\n" + " Eps: double const &\n" + "\n" + "GetEigenVectorCentr(PUNGraph const & Graph, TIntFltH & NIdEigenH)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdEigenH: TIntFltH &\n" + "\n" + ""}, + { (char *)"CommunityGirvanNewman", _wrap_CommunityGirvanNewman, METH_VARARGS, (char *)"\n" + "CommunityGirvanNewman(PUNGraph & Graph, TCnComV & CmtyV) -> double\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph &\n" + " CmtyV: TCnComV &\n" + "\n" + ""}, + { (char *)"CommunityCNM", _wrap_CommunityCNM, METH_VARARGS, (char *)"\n" + "CommunityCNM(PUNGraph const & Graph, TCnComV & CmtyV) -> double\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " CmtyV: TCnComV &\n" + "\n" + ""}, + { (char *)"CmtyGirvanNewmanStep", _wrap_CmtyGirvanNewmanStep, METH_VARARGS, (char *)"\n" + "CmtyGirvanNewmanStep(PUNGraph & Graph, TIntV Cmty1, TIntV Cmty2)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph &\n" + " Cmty1: TIntV &\n" + " Cmty2: TIntV &\n" + "\n" + ""}, + { (char *)"GetBiConSzCnt", _wrap_GetBiConSzCnt, METH_VARARGS, (char *)"\n" + "GetBiConSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " SzCntV: TIntPrV &\n" + "\n" + ""}, + { (char *)"GetBiCon", _wrap_GetBiCon, METH_VARARGS, (char *)"\n" + "GetBiCon(PUNGraph const & Graph, TCnComV & BiCnComV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " BiCnComV: TCnComV &\n" + "\n" + ""}, + { (char *)"GetArtPoints", _wrap_GetArtPoints, METH_VARARGS, (char *)"\n" + "GetArtPoints(PUNGraph const & Graph, TIntV ArtNIdV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " ArtNIdV: TIntV &\n" + "\n" + ""}, + { (char *)"GetEdgeBridges", _wrap_GetEdgeBridges, METH_VARARGS, (char *)"\n" + "GetEdgeBridges(PUNGraph const & Graph, TIntPrV & EdgeV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " EdgeV: TIntPrV &\n" + "\n" + ""}, + { (char *)"Get1CnComSzCnt", _wrap_Get1CnComSzCnt, METH_VARARGS, (char *)"\n" + "Get1CnComSzCnt(PUNGraph const & Graph, TIntPrV & SzCntV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " SzCntV: TIntPrV &\n" + "\n" + ""}, + { (char *)"Get1CnCom", _wrap_Get1CnCom, METH_VARARGS, (char *)"\n" + "Get1CnCom(PUNGraph const & Graph, TCnComV & Cn1ComV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " Cn1ComV: TCnComV &\n" + "\n" + ""}, + { (char *)"TCnCom_NIdV_set", _wrap_TCnCom_NIdV_set, METH_VARARGS, (char *)"\n" + "TCnCom_NIdV_set(TCnCom self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TCnCom *\n" + " NIdV: TIntV *\n" + "\n" + ""}, + { (char *)"TCnCom_NIdV_get", (PyCFunction)_wrap_TCnCom_NIdV_get, METH_O, (char *)"\n" + "TCnCom_NIdV_get(TCnCom self) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TCnCom *\n" + "\n" + ""}, + { (char *)"new_TCnCom", _wrap_new_TCnCom, METH_VARARGS, (char *)"\n" + "TCnCom()\n" + "TCnCom(TIntV NodeIdV)\n" + "\n" + "Parameters:\n" + " NodeIdV: TIntV const &\n" + "\n" + "TCnCom(TCnCom CC)\n" + "\n" + "Parameters:\n" + " CC: TCnCom const &\n" + "\n" + "new_TCnCom(TSIn SIn) -> TCnCom\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TCnCom_Save", _wrap_TCnCom_Save, METH_VARARGS, (char *)"\n" + "TCnCom_Save(TCnCom self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TCnCom const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TCnCom___eq__", _wrap_TCnCom___eq__, METH_VARARGS, (char *)"\n" + "TCnCom___eq__(TCnCom self, TCnCom CC) -> bool\n" + "\n" + "Parameters:\n" + " self: TCnCom const *\n" + " CC: TCnCom const &\n" + "\n" + ""}, + { (char *)"TCnCom___lt__", _wrap_TCnCom___lt__, METH_VARARGS, (char *)"\n" + "TCnCom___lt__(TCnCom self, TCnCom CC) -> bool\n" + "\n" + "Parameters:\n" + " self: TCnCom const *\n" + " CC: TCnCom const &\n" + "\n" + ""}, + { (char *)"TCnCom_Len", (PyCFunction)_wrap_TCnCom_Len, METH_O, (char *)"\n" + "TCnCom_Len(TCnCom self) -> int\n" + "\n" + "Parameters:\n" + " self: TCnCom const *\n" + "\n" + ""}, + { (char *)"TCnCom_Empty", (PyCFunction)_wrap_TCnCom_Empty, METH_O, (char *)"\n" + "TCnCom_Empty(TCnCom self) -> bool\n" + "\n" + "Parameters:\n" + " self: TCnCom const *\n" + "\n" + ""}, + { (char *)"TCnCom_Clr", (PyCFunction)_wrap_TCnCom_Clr, METH_O, (char *)"\n" + "TCnCom_Clr(TCnCom self)\n" + "\n" + "Parameters:\n" + " self: TCnCom *\n" + "\n" + ""}, + { (char *)"TCnCom_Add", _wrap_TCnCom_Add, METH_VARARGS, (char *)"\n" + "TCnCom_Add(TCnCom self, int const & NodeId)\n" + "\n" + "Parameters:\n" + " self: TCnCom *\n" + " NodeId: int const &\n" + "\n" + ""}, + { (char *)"TCnCom___call__", _wrap_TCnCom___call__, METH_VARARGS, (char *)"\n" + "__call__() -> TIntV\n" + "TCnCom___call__(TCnCom self) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TCnCom *\n" + "\n" + ""}, + { (char *)"TCnCom_Sort", _wrap_TCnCom_Sort, METH_VARARGS, (char *)"\n" + "Sort(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TCnCom_Sort(TCnCom self)\n" + "\n" + "Parameters:\n" + " self: TCnCom *\n" + "\n" + ""}, + { (char *)"TCnCom_IsNIdIn", _wrap_TCnCom_IsNIdIn, METH_VARARGS, (char *)"\n" + "TCnCom_IsNIdIn(TCnCom self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TCnCom const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TCnCom_GetRndNId", (PyCFunction)_wrap_TCnCom_GetRndNId, METH_O, (char *)"\n" + "TCnCom_GetRndNId(TCnCom self) -> TInt\n" + "\n" + "Parameters:\n" + " self: TCnCom const *\n" + "\n" + ""}, + { (char *)"TCnCom_Dump", _wrap_TCnCom_Dump, METH_VARARGS, (char *)"\n" + "Dump(TCnComV const & CnComV, TStr Desc=TStr())\n" + "\n" + "Parameters:\n" + " CnComV: TCnComV const &\n" + " Desc: TStr const &\n" + "\n" + "TCnCom_Dump(TCnComV const & CnComV)\n" + "\n" + "Parameters:\n" + " CnComV: TCnComV const &\n" + "\n" + ""}, + { (char *)"TCnCom_SaveTxt", _wrap_TCnCom_SaveTxt, METH_VARARGS, (char *)"\n" + "SaveTxt(TCnComV const & CnComV, TStr FNm, TStr Desc=TStr())\n" + "\n" + "Parameters:\n" + " CnComV: TCnComV const &\n" + " FNm: TStr const &\n" + " Desc: TStr const &\n" + "\n" + "TCnCom_SaveTxt(TCnComV const & CnComV, TStr FNm)\n" + "\n" + "Parameters:\n" + " CnComV: TCnComV const &\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"delete_TCnCom", (PyCFunction)_wrap_delete_TCnCom, METH_O, (char *)"\n" + "delete_TCnCom(TCnCom self)\n" + "\n" + "Parameters:\n" + " self: TCnCom *\n" + "\n" + ""}, + { (char *)"TCnCom_swigregister", TCnCom_swigregister, METH_VARARGS, NULL}, + { (char *)"TCnCom_swiginit", TCnCom_swiginit, METH_VARARGS, NULL}, + { (char *)"TArtPointVisitor_VnLowH_set", _wrap_TArtPointVisitor_VnLowH_set, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_VnLowH_set(TArtPointVisitor self, THash< TInt,TIntPr > * VnLowH)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " VnLowH: THash< TInt,TIntPr > *\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_VnLowH_get", (PyCFunction)_wrap_TArtPointVisitor_VnLowH_get, METH_O, (char *)"\n" + "TArtPointVisitor_VnLowH_get(TArtPointVisitor self) -> THash< TInt,TIntPr > *\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_ParentH_set", _wrap_TArtPointVisitor_ParentH_set, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_ParentH_set(TArtPointVisitor self, TIntH ParentH)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " ParentH: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_ParentH_get", (PyCFunction)_wrap_TArtPointVisitor_ParentH_get, METH_O, (char *)"\n" + "TArtPointVisitor_ParentH_get(TArtPointVisitor self) -> TIntH\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_ArtSet_set", _wrap_TArtPointVisitor_ArtSet_set, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_ArtSet_set(TArtPointVisitor self, TIntSet ArtSet)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " ArtSet: TIntSet\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_ArtSet_get", (PyCFunction)_wrap_TArtPointVisitor_ArtSet_get, METH_O, (char *)"\n" + "TArtPointVisitor_ArtSet_get(TArtPointVisitor self) -> TIntSet\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_Time_set", _wrap_TArtPointVisitor_Time_set, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_Time_set(TArtPointVisitor self, TInt Time)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " Time: TInt *\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_Time_get", (PyCFunction)_wrap_TArtPointVisitor_Time_get, METH_O, (char *)"\n" + "TArtPointVisitor_Time_get(TArtPointVisitor self) -> TInt\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + "\n" + ""}, + { (char *)"new_TArtPointVisitor", _wrap_new_TArtPointVisitor, METH_VARARGS, (char *)"\n" + "TArtPointVisitor()\n" + "new_TArtPointVisitor(int const & Nodes) -> TArtPointVisitor\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_DiscoverNode", _wrap_TArtPointVisitor_DiscoverNode, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_DiscoverNode(TArtPointVisitor self, int NId)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " NId: int\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_FinishNode", _wrap_TArtPointVisitor_FinishNode, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_FinishNode(TArtPointVisitor self, int const & NId)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_ExamineEdge", _wrap_TArtPointVisitor_ExamineEdge, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_ExamineEdge(TArtPointVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_TreeEdge", _wrap_TArtPointVisitor_TreeEdge, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_TreeEdge(TArtPointVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_BackEdge", _wrap_TArtPointVisitor_BackEdge, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_BackEdge(TArtPointVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_FwdEdge", _wrap_TArtPointVisitor_FwdEdge, METH_VARARGS, (char *)"\n" + "TArtPointVisitor_FwdEdge(TArtPointVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"delete_TArtPointVisitor", (PyCFunction)_wrap_delete_TArtPointVisitor, METH_O, (char *)"\n" + "delete_TArtPointVisitor(TArtPointVisitor self)\n" + "\n" + "Parameters:\n" + " self: TArtPointVisitor *\n" + "\n" + ""}, + { (char *)"TArtPointVisitor_swigregister", TArtPointVisitor_swigregister, METH_VARARGS, NULL}, + { (char *)"TArtPointVisitor_swiginit", TArtPointVisitor_swiginit, METH_VARARGS, NULL}, + { (char *)"TBiConVisitor_VnLowH_set", _wrap_TBiConVisitor_VnLowH_set, METH_VARARGS, (char *)"\n" + "TBiConVisitor_VnLowH_set(TBiConVisitor self, THash< TInt,TIntPr > * VnLowH)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " VnLowH: THash< TInt,TIntPr > *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_VnLowH_get", (PyCFunction)_wrap_TBiConVisitor_VnLowH_get, METH_O, (char *)"\n" + "TBiConVisitor_VnLowH_get(TBiConVisitor self) -> THash< TInt,TIntPr > *\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_ParentH_set", _wrap_TBiConVisitor_ParentH_set, METH_VARARGS, (char *)"\n" + "TBiConVisitor_ParentH_set(TBiConVisitor self, TIntH ParentH)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " ParentH: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_ParentH_get", (PyCFunction)_wrap_TBiConVisitor_ParentH_get, METH_O, (char *)"\n" + "TBiConVisitor_ParentH_get(TBiConVisitor self) -> TIntH\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_Stack_set", _wrap_TBiConVisitor_Stack_set, METH_VARARGS, (char *)"\n" + "TBiConVisitor_Stack_set(TBiConVisitor self, TSStack< TIntPr > * Stack)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " Stack: TSStack< TIntPr > *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_Stack_get", (PyCFunction)_wrap_TBiConVisitor_Stack_get, METH_O, (char *)"\n" + "TBiConVisitor_Stack_get(TBiConVisitor self) -> TSStack< TIntPr > *\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_CnComV_set", _wrap_TBiConVisitor_CnComV_set, METH_VARARGS, (char *)"\n" + "TBiConVisitor_CnComV_set(TBiConVisitor self, TCnComV * CnComV)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " CnComV: TCnComV *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_CnComV_get", (PyCFunction)_wrap_TBiConVisitor_CnComV_get, METH_O, (char *)"\n" + "TBiConVisitor_CnComV_get(TBiConVisitor self) -> TCnComV *\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_NSet_set", _wrap_TBiConVisitor_NSet_set, METH_VARARGS, (char *)"\n" + "TBiConVisitor_NSet_set(TBiConVisitor self, TIntSet NSet)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " NSet: TIntSet\n" + "\n" + ""}, + { (char *)"TBiConVisitor_NSet_get", (PyCFunction)_wrap_TBiConVisitor_NSet_get, METH_O, (char *)"\n" + "TBiConVisitor_NSet_get(TBiConVisitor self) -> TIntSet\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_Time_set", _wrap_TBiConVisitor_Time_set, METH_VARARGS, (char *)"\n" + "TBiConVisitor_Time_set(TBiConVisitor self, TInt Time)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " Time: TInt *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_Time_get", (PyCFunction)_wrap_TBiConVisitor_Time_get, METH_O, (char *)"\n" + "TBiConVisitor_Time_get(TBiConVisitor self) -> TInt\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + "\n" + ""}, + { (char *)"new_TBiConVisitor", _wrap_new_TBiConVisitor, METH_VARARGS, (char *)"\n" + "TBiConVisitor()\n" + "new_TBiConVisitor(int const & Nodes) -> TBiConVisitor\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + "\n" + ""}, + { (char *)"TBiConVisitor_DiscoverNode", _wrap_TBiConVisitor_DiscoverNode, METH_VARARGS, (char *)"\n" + "TBiConVisitor_DiscoverNode(TBiConVisitor self, int NId)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " NId: int\n" + "\n" + ""}, + { (char *)"TBiConVisitor_FinishNode", _wrap_TBiConVisitor_FinishNode, METH_VARARGS, (char *)"\n" + "TBiConVisitor_FinishNode(TBiConVisitor self, int const & NId)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TBiConVisitor_ExamineEdge", _wrap_TBiConVisitor_ExamineEdge, METH_VARARGS, (char *)"\n" + "TBiConVisitor_ExamineEdge(TBiConVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"TBiConVisitor_TreeEdge", _wrap_TBiConVisitor_TreeEdge, METH_VARARGS, (char *)"\n" + "TBiConVisitor_TreeEdge(TBiConVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"TBiConVisitor_BackEdge", _wrap_TBiConVisitor_BackEdge, METH_VARARGS, (char *)"\n" + "TBiConVisitor_BackEdge(TBiConVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"TBiConVisitor_FwdEdge", _wrap_TBiConVisitor_FwdEdge, METH_VARARGS, (char *)"\n" + "TBiConVisitor_FwdEdge(TBiConVisitor self, int const & NId1, int const & NId2)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + ""}, + { (char *)"delete_TBiConVisitor", (PyCFunction)_wrap_delete_TBiConVisitor, METH_O, (char *)"\n" + "delete_TBiConVisitor(TBiConVisitor self)\n" + "\n" + "Parameters:\n" + " self: TBiConVisitor *\n" + "\n" + ""}, + { (char *)"TBiConVisitor_swigregister", TBiConVisitor_swigregister, METH_VARARGS, NULL}, + { (char *)"TBiConVisitor_swiginit", TBiConVisitor_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TForestFire", _wrap_new_TForestFire, METH_VARARGS, (char *)"\n" + "TForestFire()\n" + "TForestFire(PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, \n" + " double const & DecayProb=1.0, int const & RndSeed=1)\n" + "\n" + "Parameters:\n" + " GraphPt: PNGraph const &\n" + " ForwBurnProb: double const &\n" + " BackBurnProb: double const &\n" + " DecayProb: double const &\n" + " RndSeed: int const &\n" + "\n" + "TForestFire(PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb, \n" + " double const & DecayProb=1.0)\n" + "\n" + "Parameters:\n" + " GraphPt: PNGraph const &\n" + " ForwBurnProb: double const &\n" + " BackBurnProb: double const &\n" + " DecayProb: double const &\n" + "\n" + "new_TForestFire(PNGraph const & GraphPt, double const & ForwBurnProb, double const & BackBurnProb) -> TForestFire\n" + "\n" + "Parameters:\n" + " GraphPt: PNGraph const &\n" + " ForwBurnProb: double const &\n" + " BackBurnProb: double const &\n" + "\n" + ""}, + { (char *)"TForestFire_SetGraph", _wrap_TForestFire_SetGraph, METH_VARARGS, (char *)"\n" + "TForestFire_SetGraph(TForestFire self, PNGraph const & GraphPt)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + " GraphPt: PNGraph const &\n" + "\n" + ""}, + { (char *)"TForestFire_GetGraph", (PyCFunction)_wrap_TForestFire_GetGraph, METH_O, (char *)"\n" + "TForestFire_GetGraph(TForestFire self) -> PNGraph\n" + "\n" + "Parameters:\n" + " self: TForestFire const *\n" + "\n" + ""}, + { (char *)"TForestFire_SetBurnProb", _wrap_TForestFire_SetBurnProb, METH_VARARGS, (char *)"\n" + "TForestFire_SetBurnProb(TForestFire self, double const & ForwBurnProb, double const & BackBurnProb)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + " ForwBurnProb: double const &\n" + " BackBurnProb: double const &\n" + "\n" + ""}, + { (char *)"TForestFire_SetProbDecay", _wrap_TForestFire_SetProbDecay, METH_VARARGS, (char *)"\n" + "TForestFire_SetProbDecay(TForestFire self, double const & DecayProb)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + " DecayProb: double const &\n" + "\n" + ""}, + { (char *)"TForestFire_Infect", _wrap_TForestFire_Infect, METH_VARARGS, (char *)"\n" + "Infect(int const & NodeId)\n" + "\n" + "Parameters:\n" + " NodeId: int const &\n" + "\n" + "TForestFire_Infect(TForestFire self, TIntV InfectedNIdV)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + " InfectedNIdV: TIntV const &\n" + "\n" + ""}, + { (char *)"TForestFire_InfectAll", (PyCFunction)_wrap_TForestFire_InfectAll, METH_O, (char *)"\n" + "TForestFire_InfectAll(TForestFire self)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + "\n" + ""}, + { (char *)"TForestFire_InfectRnd", _wrap_TForestFire_InfectRnd, METH_VARARGS, (char *)"\n" + "TForestFire_InfectRnd(TForestFire self, int const & NInfect)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + " NInfect: int const &\n" + "\n" + ""}, + { (char *)"TForestFire_BurnExpFire", (PyCFunction)_wrap_TForestFire_BurnExpFire, METH_O, (char *)"\n" + "TForestFire_BurnExpFire(TForestFire self)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + "\n" + ""}, + { (char *)"TForestFire_BurnGeoFire", (PyCFunction)_wrap_TForestFire_BurnGeoFire, METH_O, (char *)"\n" + "TForestFire_BurnGeoFire(TForestFire self)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + "\n" + ""}, + { (char *)"TForestFire_GetFireTm", (PyCFunction)_wrap_TForestFire_GetFireTm, METH_O, (char *)"\n" + "TForestFire_GetFireTm(TForestFire self) -> int\n" + "\n" + "Parameters:\n" + " self: TForestFire const *\n" + "\n" + ""}, + { (char *)"TForestFire_GetBurned", (PyCFunction)_wrap_TForestFire_GetBurned, METH_O, (char *)"\n" + "TForestFire_GetBurned(TForestFire self) -> int\n" + "\n" + "Parameters:\n" + " self: TForestFire const *\n" + "\n" + ""}, + { (char *)"TForestFire_GetBurnedNId", _wrap_TForestFire_GetBurnedNId, METH_VARARGS, (char *)"\n" + "TForestFire_GetBurnedNId(TForestFire self, int const & NIdN) -> int\n" + "\n" + "Parameters:\n" + " self: TForestFire const *\n" + " NIdN: int const &\n" + "\n" + ""}, + { (char *)"TForestFire_GetBurnedNIdV", _wrap_TForestFire_GetBurnedNIdV, METH_VARARGS, (char *)"\n" + "GetBurnedNIdV() -> TIntV\n" + "TForestFire_GetBurnedNIdV(TForestFire self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TForestFire const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TForestFire_PlotFire", _wrap_TForestFire_PlotFire, METH_VARARGS, (char *)"\n" + "PlotFire(TStr FNmPref, TStr Desc, bool const & PlotAllBurned=False)\n" + "\n" + "Parameters:\n" + " FNmPref: TStr const &\n" + " Desc: TStr const &\n" + " PlotAllBurned: bool const &\n" + "\n" + "TForestFire_PlotFire(TForestFire self, TStr FNmPref, TStr Desc)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + " FNmPref: TStr const &\n" + " Desc: TStr const &\n" + "\n" + ""}, + { (char *)"TForestFire_GenGraph", _wrap_TForestFire_GenGraph, METH_VARARGS, (char *)"\n" + "TForestFire_GenGraph(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " FwdProb: double const &\n" + " BckProb: double const &\n" + "\n" + ""}, + { (char *)"delete_TForestFire", (PyCFunction)_wrap_delete_TForestFire, METH_O, (char *)"\n" + "delete_TForestFire(TForestFire self)\n" + "\n" + "Parameters:\n" + " self: TForestFire *\n" + "\n" + ""}, + { (char *)"TForestFire_swigregister", TForestFire_swigregister, METH_VARARGS, NULL}, + { (char *)"TForestFire_swiginit", TForestFire_swiginit, METH_VARARGS, NULL}, + { (char *)"TFfGGen_TimeLimitSec_get", _wrap_TFfGGen_TimeLimitSec_get, METH_VARARGS, NULL}, + { (char *)"TFfGGen_TimeLimitSec_set", _wrap_TFfGGen_TimeLimitSec_set, METH_VARARGS, NULL}, + { (char *)"new_TFfGGen", _wrap_new_TFfGGen, METH_VARARGS, (char *)"\n" + "new_TFfGGen(bool const & BurnExpFireP, int const & StartNNodes, double const & ForwBurnProb, \n" + " double const & BackBurnProb, double const & DecayProb, double const & Take2AmbasPrb, \n" + " double const & OrphanPrb) -> TFfGGen\n" + "\n" + "Parameters:\n" + " BurnExpFireP: bool const &\n" + " StartNNodes: int const &\n" + " ForwBurnProb: double const &\n" + " BackBurnProb: double const &\n" + " DecayProb: double const &\n" + " Take2AmbasPrb: double const &\n" + " OrphanPrb: double const &\n" + "\n" + ""}, + { (char *)"TFfGGen_GetGraph", (PyCFunction)_wrap_TFfGGen_GetGraph, METH_O, (char *)"\n" + "TFfGGen_GetGraph(TFfGGen self) -> PNGraph\n" + "\n" + "Parameters:\n" + " self: TFfGGen const *\n" + "\n" + ""}, + { (char *)"TFfGGen_SetGraph", _wrap_TFfGGen_SetGraph, METH_VARARGS, (char *)"\n" + "TFfGGen_SetGraph(TFfGGen self, PNGraph const & NGraph)\n" + "\n" + "Parameters:\n" + " self: TFfGGen *\n" + " NGraph: PNGraph const &\n" + "\n" + ""}, + { (char *)"TFfGGen_Clr", (PyCFunction)_wrap_TFfGGen_Clr, METH_O, (char *)"\n" + "TFfGGen_Clr(TFfGGen self)\n" + "\n" + "Parameters:\n" + " self: TFfGGen *\n" + "\n" + ""}, + { (char *)"TFfGGen_GetParamStr", (PyCFunction)_wrap_TFfGGen_GetParamStr, METH_O, (char *)"\n" + "TFfGGen_GetParamStr(TFfGGen self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TFfGGen const *\n" + "\n" + ""}, + { (char *)"TFfGGen_AddNodes", _wrap_TFfGGen_AddNodes, METH_VARARGS, (char *)"\n" + "AddNodes(int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " GraphNodes: int const &\n" + " FloodStop: bool const &\n" + "\n" + "TFfGGen_AddNodes(TFfGGen self, int const & GraphNodes) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " self: TFfGGen *\n" + " GraphNodes: int const &\n" + "\n" + ""}, + { (char *)"TFfGGen_GenGraph", _wrap_TFfGGen_GenGraph, METH_VARARGS, (char *)"\n" + "GenGraph(int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " GraphNodes: int const &\n" + " FloodStop: bool const &\n" + "\n" + "GenGraph(int const & GraphNodes) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " GraphNodes: int const &\n" + "\n" + "GenGraph(int const & GraphNodes, PGStatVec & EvolStat, bool const & FloodStop=True) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " GraphNodes: int const &\n" + " EvolStat: PGStatVec &\n" + " FloodStop: bool const &\n" + "\n" + "TFfGGen_GenGraph(TFfGGen self, int const & GraphNodes, PGStatVec & EvolStat) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " self: TFfGGen *\n" + " GraphNodes: int const &\n" + " EvolStat: PGStatVec &\n" + "\n" + ""}, + { (char *)"TFfGGen_PlotFireSize", _wrap_TFfGGen_PlotFireSize, METH_VARARGS, (char *)"\n" + "TFfGGen_PlotFireSize(TFfGGen self, TStr FNmPref, TStr DescStr)\n" + "\n" + "Parameters:\n" + " self: TFfGGen *\n" + " FNmPref: TStr const &\n" + " DescStr: TStr const &\n" + "\n" + ""}, + { (char *)"TFfGGen_GenFFGraphs", _wrap_TFfGGen_GenFFGraphs, METH_VARARGS, (char *)"\n" + "TFfGGen_GenFFGraphs(double const & FProb, double const & BProb, TStr FNm)\n" + "\n" + "Parameters:\n" + " FProb: double const &\n" + " BProb: double const &\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"delete_TFfGGen", (PyCFunction)_wrap_delete_TFfGGen, METH_O, (char *)"\n" + "delete_TFfGGen(TFfGGen self)\n" + "\n" + "Parameters:\n" + " self: TFfGGen *\n" + "\n" + ""}, + { (char *)"TFfGGen_swigregister", TFfGGen_swigregister, METH_VARARGS, NULL}, + { (char *)"TFfGGen_swiginit", TFfGGen_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TUndirFFire", _wrap_new_TUndirFFire, METH_VARARGS, (char *)"\n" + "TUndirFFire(double const & _BurnProb=0.3)\n" + "\n" + "Parameters:\n" + " _BurnProb: double const &\n" + "\n" + "new_TUndirFFire() -> TUndirFFire\n" + ""}, + { (char *)"TUndirFFire_SetGraph", _wrap_TUndirFFire_SetGraph, METH_VARARGS, (char *)"\n" + "TUndirFFire_SetGraph(TUndirFFire self, PUNGraph const & GraphPt)\n" + "\n" + "Parameters:\n" + " self: TUndirFFire *\n" + " GraphPt: PUNGraph const &\n" + "\n" + ""}, + { (char *)"TUndirFFire_GetGraph", (PyCFunction)_wrap_TUndirFFire_GetGraph, METH_O, (char *)"\n" + "TUndirFFire_GetGraph(TUndirFFire self) -> PUNGraph\n" + "\n" + "Parameters:\n" + " self: TUndirFFire const *\n" + "\n" + ""}, + { (char *)"TUndirFFire_GetNBurned", (PyCFunction)_wrap_TUndirFFire_GetNBurned, METH_O, (char *)"\n" + "TUndirFFire_GetNBurned(TUndirFFire self) -> int\n" + "\n" + "Parameters:\n" + " self: TUndirFFire const *\n" + "\n" + ""}, + { (char *)"TUndirFFire_GetBurnedNId", _wrap_TUndirFFire_GetBurnedNId, METH_VARARGS, (char *)"\n" + "TUndirFFire_GetBurnedNId(TUndirFFire self, int const & n) -> int\n" + "\n" + "Parameters:\n" + " self: TUndirFFire const *\n" + " n: int const &\n" + "\n" + ""}, + { (char *)"TUndirFFire_BurnGeoFire", _wrap_TUndirFFire_BurnGeoFire, METH_VARARGS, (char *)"\n" + "TUndirFFire_BurnGeoFire(TUndirFFire self, int const & StartNId) -> int\n" + "\n" + "Parameters:\n" + " self: TUndirFFire *\n" + " StartNId: int const &\n" + "\n" + ""}, + { (char *)"TUndirFFire_AddNodes", _wrap_TUndirFFire_AddNodes, METH_VARARGS, (char *)"\n" + "AddNodes(int const & GraphNodes, bool const & FloodStop=True) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " GraphNodes: int const &\n" + " FloodStop: bool const &\n" + "\n" + "TUndirFFire_AddNodes(TUndirFFire self, int const & GraphNodes) -> TFfGGen::TStopReason\n" + "\n" + "Parameters:\n" + " self: TUndirFFire *\n" + " GraphNodes: int const &\n" + "\n" + ""}, + { (char *)"delete_TUndirFFire", (PyCFunction)_wrap_delete_TUndirFFire, METH_O, (char *)"\n" + "delete_TUndirFFire(TUndirFFire self)\n" + "\n" + "Parameters:\n" + " self: TUndirFFire *\n" + "\n" + ""}, + { (char *)"TUndirFFire_swigregister", TUndirFFire_swigregister, METH_VARARGS, NULL}, + { (char *)"TUndirFFire_swiginit", TUndirFFire_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TCs", _wrap_new_TCs, METH_VARARGS, (char *)"\n" + "TCs()\n" + "TCs(TCs Cs)\n" + "\n" + "Parameters:\n" + " Cs: TCs const &\n" + "\n" + "new_TCs(int const & Int) -> TCs\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TCs___eq__", _wrap_TCs___eq__, METH_VARARGS, (char *)"\n" + "TCs___eq__(TCs self, TCs Cs) -> bool\n" + "\n" + "Parameters:\n" + " self: TCs const *\n" + " Cs: TCs const &\n" + "\n" + ""}, + { (char *)"TCs___iadd__", _wrap_TCs___iadd__, METH_VARARGS, (char *)"\n" + "__iadd__(TCs Cs) -> TCs\n" + "\n" + "Parameters:\n" + " Cs: TCs const &\n" + "\n" + "__iadd__(char const & Ch) -> TCs\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + "TCs___iadd__(TCs self, int const & Int) -> TCs\n" + "\n" + "Parameters:\n" + " self: TCs *\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TCs_Get", (PyCFunction)_wrap_TCs_Get, METH_O, (char *)"\n" + "TCs_Get(TCs self) -> int\n" + "\n" + "Parameters:\n" + " self: TCs const *\n" + "\n" + ""}, + { (char *)"TCs_GetCsFromBf", _wrap_TCs_GetCsFromBf, METH_VARARGS, (char *)"\n" + "TCs_GetCsFromBf(char * Bf, int const & BfL) -> TCs\n" + "\n" + "Parameters:\n" + " Bf: char *\n" + " BfL: int const &\n" + "\n" + ""}, + { (char *)"delete_TCs", (PyCFunction)_wrap_delete_TCs, METH_O, (char *)"\n" + "delete_TCs(TCs self)\n" + "\n" + "Parameters:\n" + " self: TCs *\n" + "\n" + ""}, + { (char *)"TCs_swigregister", TCs_swigregister, METH_VARARGS, NULL}, + { (char *)"TCs_swiginit", TCs_swiginit, METH_VARARGS, NULL}, + { (char *)"TSOutMnp___call__", _wrap_TSOutMnp___call__, METH_VARARGS, (char *)"\n" + "TSOutMnp___call__(TSOutMnp self, TSOut SOut) -> TSOut\n" + "\n" + "Parameters:\n" + " self: TSOutMnp const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"delete_TSOutMnp", (PyCFunction)_wrap_delete_TSOutMnp, METH_O, (char *)"\n" + "delete_TSOutMnp(TSOutMnp self)\n" + "\n" + "Parameters:\n" + " self: TSOutMnp *\n" + "\n" + ""}, + { (char *)"TSOutMnp_swigregister", TSOutMnp_swigregister, METH_VARARGS, NULL}, + { (char *)"new_TSBase", (PyCFunction)_wrap_new_TSBase, METH_O, (char *)"\n" + "new_TSBase(TSStr Nm) -> TSBase\n" + "\n" + "Parameters:\n" + " Nm: TSStr const &\n" + "\n" + ""}, + { (char *)"delete_TSBase", (PyCFunction)_wrap_delete_TSBase, METH_O, (char *)"\n" + "delete_TSBase(TSBase self)\n" + "\n" + "Parameters:\n" + " self: TSBase *\n" + "\n" + ""}, + { (char *)"TSBase_GetSNm", (PyCFunction)_wrap_TSBase_GetSNm, METH_O, (char *)"\n" + "TSBase_GetSNm(TSBase self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TSBase const *\n" + "\n" + ""}, + { (char *)"TSBase_swigregister", TSBase_swigregister, METH_VARARGS, NULL}, + { (char *)"TSBase_swiginit", TSBase_swiginit, METH_VARARGS, NULL}, + { (char *)"delete_TSIn", (PyCFunction)_wrap_delete_TSIn, METH_O, (char *)"\n" + "delete_TSIn(TSIn self)\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + "\n" + ""}, + { (char *)"TSIn_Eof", (PyCFunction)_wrap_TSIn_Eof, METH_O, (char *)"\n" + "TSIn_Eof(TSIn self) -> bool\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + "\n" + ""}, + { (char *)"TSIn_Len", (PyCFunction)_wrap_TSIn_Len, METH_O, (char *)"\n" + "TSIn_Len(TSIn self) -> int\n" + "\n" + "Parameters:\n" + " self: TSIn const *\n" + "\n" + ""}, + { (char *)"TSIn_GetCh", (PyCFunction)_wrap_TSIn_GetCh, METH_O, (char *)"\n" + "TSIn_GetCh(TSIn self) -> char\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + "\n" + ""}, + { (char *)"TSIn_PeekCh", (PyCFunction)_wrap_TSIn_PeekCh, METH_O, (char *)"\n" + "TSIn_PeekCh(TSIn self) -> char\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + "\n" + ""}, + { (char *)"TSIn_GetBf", _wrap_TSIn_GetBf, METH_VARARGS, (char *)"\n" + "TSIn_GetBf(TSIn self, void const * Bf, TSize const & BfL) -> int\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " Bf: void const *\n" + " BfL: TSize const &\n" + "\n" + ""}, + { (char *)"TSIn_GetNextLnBf", _wrap_TSIn_GetNextLnBf, METH_VARARGS, (char *)"\n" + "TSIn_GetNextLnBf(TSIn self, TChA LnChA) -> bool\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " LnChA: TChA &\n" + "\n" + ""}, + { (char *)"TSIn_Reset", (PyCFunction)_wrap_TSIn_Reset, METH_O, (char *)"\n" + "TSIn_Reset(TSIn self)\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + "\n" + ""}, + { (char *)"TSIn_IsFastMode", (PyCFunction)_wrap_TSIn_IsFastMode, METH_O, (char *)"\n" + "TSIn_IsFastMode(TSIn self) -> bool\n" + "\n" + "Parameters:\n" + " self: TSIn const *\n" + "\n" + ""}, + { (char *)"TSIn_SetFastMode", _wrap_TSIn_SetFastMode, METH_VARARGS, (char *)"\n" + "TSIn_SetFastMode(TSIn self, bool const & _FastMode)\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " _FastMode: bool const &\n" + "\n" + ""}, + { (char *)"TSIn_LoadCs", (PyCFunction)_wrap_TSIn_LoadCs, METH_O, (char *)"\n" + "TSIn_LoadCs(TSIn self)\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + "\n" + ""}, + { (char *)"TSIn_LoadBf", _wrap_TSIn_LoadBf, METH_VARARGS, (char *)"\n" + "TSIn_LoadBf(TSIn self, void const * Bf, TSize const & BfL)\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " Bf: void const *\n" + " BfL: TSize const &\n" + "\n" + ""}, + { (char *)"TSIn_LoadNewBf", _wrap_TSIn_LoadNewBf, METH_VARARGS, (char *)"\n" + "TSIn_LoadNewBf(TSIn self, int const & BfL) -> void *\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " BfL: int const &\n" + "\n" + ""}, + { (char *)"TSIn_Load", _wrap_TSIn_Load, METH_VARARGS, (char *)"\n" + "Load(bool & Bool)\n" + "\n" + "Parameters:\n" + " Bool: bool &\n" + "\n" + "Load(uchar & UCh)\n" + "\n" + "Parameters:\n" + " UCh: uchar &\n" + "\n" + "Load(char & Ch)\n" + "\n" + "Parameters:\n" + " Ch: char &\n" + "\n" + "Load(short & Short)\n" + "\n" + "Parameters:\n" + " Short: short &\n" + "\n" + "Load(ushort & UShort)\n" + "\n" + "Parameters:\n" + " UShort: ushort &\n" + "\n" + "Load(int & Int)\n" + "\n" + "Parameters:\n" + " Int: int &\n" + "\n" + "Load(uint & UInt)\n" + "\n" + "Parameters:\n" + " UInt: uint &\n" + "\n" + "Load(int64 & Int)\n" + "\n" + "Parameters:\n" + " Int: int64 &\n" + "\n" + "Load(uint64 & UInt)\n" + "\n" + "Parameters:\n" + " UInt: uint64 &\n" + "\n" + "Load(double & Flt)\n" + "\n" + "Parameters:\n" + " Flt: double &\n" + "\n" + "Load(sdouble & SFlt)\n" + "\n" + "Parameters:\n" + " SFlt: sdouble &\n" + "\n" + "Load(ldouble & LFlt)\n" + "\n" + "Parameters:\n" + " LFlt: ldouble &\n" + "\n" + "Load(char *& CStr, int const & MxCStrLen, int const & CStrLen)\n" + "\n" + "Parameters:\n" + " CStr: char *&\n" + " MxCStrLen: int const &\n" + " CStrLen: int const &\n" + "\n" + "TSIn_Load(TSIn self, char *& CStr)\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " CStr: char *&\n" + "\n" + ""}, + { (char *)"TSIn___rshift__", _wrap_TSIn___rshift__, METH_VARARGS, (char *)"\n" + "__rshift__(bool & Bool) -> TSIn\n" + "\n" + "Parameters:\n" + " Bool: bool &\n" + "\n" + "__rshift__(uchar & UCh) -> TSIn\n" + "\n" + "Parameters:\n" + " UCh: uchar &\n" + "\n" + "__rshift__(char & Ch) -> TSIn\n" + "\n" + "Parameters:\n" + " Ch: char &\n" + "\n" + "__rshift__(short & Sh) -> TSIn\n" + "\n" + "Parameters:\n" + " Sh: short &\n" + "\n" + "__rshift__(ushort & USh) -> TSIn\n" + "\n" + "Parameters:\n" + " USh: ushort &\n" + "\n" + "__rshift__(int & Int) -> TSIn\n" + "\n" + "Parameters:\n" + " Int: int &\n" + "\n" + "__rshift__(uint & UInt) -> TSIn\n" + "\n" + "Parameters:\n" + " UInt: uint &\n" + "\n" + "__rshift__(int64 & Int) -> TSIn\n" + "\n" + "Parameters:\n" + " Int: int64 &\n" + "\n" + "__rshift__(uint64 & UInt) -> TSIn\n" + "\n" + "Parameters:\n" + " UInt: uint64 &\n" + "\n" + "__rshift__(float & Flt) -> TSIn\n" + "\n" + "Parameters:\n" + " Flt: float &\n" + "\n" + "__rshift__(double & Double) -> TSIn\n" + "\n" + "Parameters:\n" + " Double: double &\n" + "\n" + "TSIn___rshift__(TSIn self, long double & LDouble) -> TSIn\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " LDouble: long double &\n" + "\n" + ""}, + { (char *)"TSIn_GetNextLn", _wrap_TSIn_GetNextLn, METH_VARARGS, (char *)"\n" + "GetNextLn(TStr LnStr) -> bool\n" + "\n" + "Parameters:\n" + " LnStr: TStr &\n" + "\n" + "TSIn_GetNextLn(TSIn self, TChA LnChA) -> bool\n" + "\n" + "Parameters:\n" + " self: TSIn *\n" + " LnChA: TChA &\n" + "\n" + ""}, + { (char *)"TSIn_swigregister", TSIn_swigregister, METH_VARARGS, NULL}, + { (char *)"delete_TSOut", (PyCFunction)_wrap_delete_TSOut, METH_O, (char *)"\n" + "delete_TSOut(TSOut self)\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_EnableLnTrunc", _wrap_TSOut_EnableLnTrunc, METH_VARARGS, (char *)"\n" + "TSOut_EnableLnTrunc(TSOut self, int const & _MxLnLen)\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " _MxLnLen: int const &\n" + "\n" + ""}, + { (char *)"TSOut_DisableLnTrunc", (PyCFunction)_wrap_TSOut_DisableLnTrunc, METH_O, (char *)"\n" + "TSOut_DisableLnTrunc(TSOut self)\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_PutBf", _wrap_TSOut_PutBf, METH_VARARGS, (char *)"\n" + "TSOut_PutBf(TSOut self, void const * LBf, TSize const & LBfL) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " LBf: void const *\n" + " LBfL: TSize const &\n" + "\n" + ""}, + { (char *)"TSOut_Flush", (PyCFunction)_wrap_TSOut_Flush, METH_O, (char *)"\n" + "TSOut_Flush(TSOut self)\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_GetFileId", (PyCFunction)_wrap_TSOut_GetFileId, METH_O, (char *)"\n" + "TSOut_GetFileId(TSOut self) -> TFileId\n" + "\n" + "Parameters:\n" + " self: TSOut const *\n" + "\n" + ""}, + { (char *)"TSOut_PutMem", _wrap_TSOut_PutMem, METH_VARARGS, (char *)"\n" + "TSOut_PutMem(TSOut self, TMem Mem) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Mem: TMem const &\n" + "\n" + ""}, + { (char *)"TSOut_PutCh", _wrap_TSOut_PutCh, METH_VARARGS, (char *)"\n" + "PutCh(char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + "TSOut_PutCh(TSOut self, char const & Ch, int const & Chs) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Ch: char const &\n" + " Chs: int const &\n" + "\n" + ""}, + { (char *)"TSOut_PutBool", _wrap_TSOut_PutBool, METH_VARARGS, (char *)"\n" + "TSOut_PutBool(TSOut self, bool const & Bool) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Bool: bool const &\n" + "\n" + ""}, + { (char *)"TSOut_PutInt", _wrap_TSOut_PutInt, METH_VARARGS, (char *)"\n" + "PutInt(int const & Int) -> int\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + "TSOut_PutInt(TSOut self, int const & Int, char const * FmtStr) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Int: int const &\n" + " FmtStr: char const *\n" + "\n" + ""}, + { (char *)"TSOut_PutUInt", _wrap_TSOut_PutUInt, METH_VARARGS, (char *)"\n" + "PutUInt(uint const & Int) -> int\n" + "\n" + "Parameters:\n" + " Int: uint const &\n" + "\n" + "TSOut_PutUInt(TSOut self, uint const & Int, char const * FmtStr) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Int: uint const &\n" + " FmtStr: char const *\n" + "\n" + ""}, + { (char *)"TSOut_PutFlt", _wrap_TSOut_PutFlt, METH_VARARGS, (char *)"\n" + "PutFlt(double const & Flt) -> int\n" + "\n" + "Parameters:\n" + " Flt: double const &\n" + "\n" + "TSOut_PutFlt(TSOut self, double const & Flt, char const * FmtStr) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Flt: double const &\n" + " FmtStr: char const *\n" + "\n" + ""}, + { (char *)"TSOut_PutStr", _wrap_TSOut_PutStr, METH_VARARGS, (char *)"\n" + "PutStr(char const * CStr) -> int\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "PutStr(TChA ChA) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + "PutStr(TStr Str, char const * FmtStr) -> int\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + " FmtStr: char const *\n" + "\n" + "PutStr(TStr Str, bool const & ForceInLn=False) -> int\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + " ForceInLn: bool const &\n" + "\n" + "TSOut_PutStr(TSOut self, TStr Str) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TSOut_PutStrLn", _wrap_TSOut_PutStrLn, METH_VARARGS, (char *)"\n" + "PutStrLn(TStr Str, bool const & ForceInLn=False) -> int\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + " ForceInLn: bool const &\n" + "\n" + "TSOut_PutStrLn(TSOut self, TStr Str) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TSOut_PutStrFmt", _wrap_TSOut_PutStrFmt, METH_VARARGS, (char *)"\n" + "TSOut_PutStrFmt(TSOut self, char const * FmtStr) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " FmtStr: char const *\n" + "\n" + ""}, + { (char *)"TSOut_PutStrFmtLn", _wrap_TSOut_PutStrFmtLn, METH_VARARGS, (char *)"\n" + "TSOut_PutStrFmtLn(TSOut self, char const * FmtStr) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " FmtStr: char const *\n" + "\n" + ""}, + { (char *)"TSOut_PutIndent", _wrap_TSOut_PutIndent, METH_VARARGS, (char *)"\n" + "PutIndent(int const & IndentLev=1) -> int\n" + "\n" + "Parameters:\n" + " IndentLev: int const &\n" + "\n" + "TSOut_PutIndent(TSOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_PutLn", _wrap_TSOut_PutLn, METH_VARARGS, (char *)"\n" + "PutLn(int const & Lns=1) -> int\n" + "\n" + "Parameters:\n" + " Lns: int const &\n" + "\n" + "TSOut_PutLn(TSOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_PutDosLn", _wrap_TSOut_PutDosLn, METH_VARARGS, (char *)"\n" + "PutDosLn(int const & Lns=1) -> int\n" + "\n" + "Parameters:\n" + " Lns: int const &\n" + "\n" + "TSOut_PutDosLn(TSOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_PutSep", _wrap_TSOut_PutSep, METH_VARARGS, (char *)"\n" + "PutSep(int const & NextStrLen=0) -> int\n" + "\n" + "Parameters:\n" + " NextStrLen: int const &\n" + "\n" + "TSOut_PutSep(TSOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_PutSepLn", _wrap_TSOut_PutSepLn, METH_VARARGS, (char *)"\n" + "PutSepLn(int const & Lns=0) -> int\n" + "\n" + "Parameters:\n" + " Lns: int const &\n" + "\n" + "TSOut_PutSepLn(TSOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_SaveCs", (PyCFunction)_wrap_TSOut_SaveCs, METH_O, (char *)"\n" + "TSOut_SaveCs(TSOut self)\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + "\n" + ""}, + { (char *)"TSOut_SaveBf", _wrap_TSOut_SaveBf, METH_VARARGS, (char *)"\n" + "TSOut_SaveBf(TSOut self, void const * Bf, TSize const & BfL)\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Bf: void const *\n" + " BfL: TSize const &\n" + "\n" + ""}, + { (char *)"TSOut_Save", _wrap_TSOut_Save, METH_VARARGS, (char *)"\n" + "Save(bool const & Bool)\n" + "\n" + "Parameters:\n" + " Bool: bool const &\n" + "\n" + "Save(char const & Ch)\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + "Save(uchar const & UCh)\n" + "\n" + "Parameters:\n" + " UCh: uchar const &\n" + "\n" + "Save(short const & Short)\n" + "\n" + "Parameters:\n" + " Short: short const &\n" + "\n" + "Save(ushort const & UShort)\n" + "\n" + "Parameters:\n" + " UShort: ushort const &\n" + "\n" + "Save(int const & Int)\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + "Save(uint const & UInt)\n" + "\n" + "Parameters:\n" + " UInt: uint const &\n" + "\n" + "Save(int64 const & Int)\n" + "\n" + "Parameters:\n" + " Int: int64 const &\n" + "\n" + "Save(uint64 const & UInt)\n" + "\n" + "Parameters:\n" + " UInt: uint64 const &\n" + "\n" + "Save(double const & Flt)\n" + "\n" + "Parameters:\n" + " Flt: double const &\n" + "\n" + "Save(sdouble const & SFlt)\n" + "\n" + "Parameters:\n" + " SFlt: sdouble const &\n" + "\n" + "Save(ldouble const & LFlt)\n" + "\n" + "Parameters:\n" + " LFlt: ldouble const &\n" + "\n" + "Save(char const * CStr, TSize const & CStrLen)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + " CStrLen: TSize const &\n" + "\n" + "Save(char const * CStr)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "Save(TSIn SIn, TSize const & BfL=-1)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " BfL: TSize const &\n" + "\n" + "Save(TSIn SIn)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "Save(PSIn const & SIn, TSize const & BfL=-1)\n" + "\n" + "Parameters:\n" + " SIn: PSIn const &\n" + " BfL: TSize const &\n" + "\n" + "Save(PSIn const & SIn)\n" + "\n" + "Parameters:\n" + " SIn: PSIn const &\n" + "\n" + "TSOut_Save(TSOut self, void const * Bf, TSize const & BfL)\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " Bf: void const *\n" + " BfL: TSize const &\n" + "\n" + ""}, + { (char *)"TSOut___lshift__", _wrap_TSOut___lshift__, METH_VARARGS, (char *)"\n" + "__lshift__(bool const & Bool) -> TSOut\n" + "\n" + "Parameters:\n" + " Bool: bool const &\n" + "\n" + "__lshift__(uchar const & UCh) -> TSOut\n" + "\n" + "Parameters:\n" + " UCh: uchar const &\n" + "\n" + "__lshift__(char const & Ch) -> TSOut\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + "__lshift__(short const & Sh) -> TSOut\n" + "\n" + "Parameters:\n" + " Sh: short const &\n" + "\n" + "__lshift__(ushort const & USh) -> TSOut\n" + "\n" + "Parameters:\n" + " USh: ushort const &\n" + "\n" + "__lshift__(int const & Int) -> TSOut\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + "__lshift__(uint const & Int) -> TSOut\n" + "\n" + "Parameters:\n" + " Int: uint const &\n" + "\n" + "__lshift__(int64 const & Int) -> TSOut\n" + "\n" + "Parameters:\n" + " Int: int64 const &\n" + "\n" + "__lshift__(uint64 const & UInt) -> TSOut\n" + "\n" + "Parameters:\n" + " UInt: uint64 const &\n" + "\n" + "__lshift__(float const & Flt) -> TSOut\n" + "\n" + "Parameters:\n" + " Flt: float const &\n" + "\n" + "__lshift__(double const & Double) -> TSOut\n" + "\n" + "Parameters:\n" + " Double: double const &\n" + "\n" + "__lshift__(long double const & LDouble) -> TSOut\n" + "\n" + "Parameters:\n" + " LDouble: long double const &\n" + "\n" + "__lshift__(TSOutMnp Mnp) -> TSOut\n" + "\n" + "Parameters:\n" + " Mnp: TSOutMnp const &\n" + "\n" + "__lshift__(TSOut &(*)(TSOut &) FuncPt) -> TSOut\n" + "\n" + "Parameters:\n" + " FuncPt: TSOut &(*)(TSOut &)\n" + "\n" + "__lshift__(TSIn SIn) -> TSOut\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "TSOut___lshift__(TSOut self, PSIn & SIn) -> TSOut\n" + "\n" + "Parameters:\n" + " self: TSOut *\n" + " SIn: PSIn &\n" + "\n" + ""}, + { (char *)"TSOut_swigregister", TSOut_swigregister, METH_VARARGS, NULL}, + { (char *)"delete_TSInOut", (PyCFunction)_wrap_delete_TSInOut, METH_O, (char *)"\n" + "delete_TSInOut(TSInOut self)\n" + "\n" + "Parameters:\n" + " self: TSInOut *\n" + "\n" + ""}, + { (char *)"TSInOut_SetPos", _wrap_TSInOut_SetPos, METH_VARARGS, (char *)"\n" + "TSInOut_SetPos(TSInOut self, int const & Pos)\n" + "\n" + "Parameters:\n" + " self: TSInOut *\n" + " Pos: int const &\n" + "\n" + ""}, + { (char *)"TSInOut_MovePos", _wrap_TSInOut_MovePos, METH_VARARGS, (char *)"\n" + "TSInOut_MovePos(TSInOut self, int const & DPos)\n" + "\n" + "Parameters:\n" + " self: TSInOut *\n" + " DPos: int const &\n" + "\n" + ""}, + { (char *)"TSInOut_GetPos", (PyCFunction)_wrap_TSInOut_GetPos, METH_O, (char *)"\n" + "TSInOut_GetPos(TSInOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TSInOut const *\n" + "\n" + ""}, + { (char *)"TSInOut_GetSize", (PyCFunction)_wrap_TSInOut_GetSize, METH_O, (char *)"\n" + "TSInOut_GetSize(TSInOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TSInOut const *\n" + "\n" + ""}, + { (char *)"TSInOut_Clr", (PyCFunction)_wrap_TSInOut_Clr, METH_O, (char *)"\n" + "TSInOut_Clr(TSInOut self)\n" + "\n" + "Parameters:\n" + " self: TSInOut *\n" + "\n" + ""}, + { (char *)"TSInOut_swigregister", TSInOut_swigregister, METH_VARARGS, NULL}, + { (char *)"new_TStdIn", (PyCFunction)_wrap_new_TStdIn, METH_NOARGS, (char *)"new_TStdIn() -> TStdIn"}, + { (char *)"TStdIn_New", (PyCFunction)_wrap_TStdIn_New, METH_NOARGS, (char *)"TStdIn_New() -> TPt< TSIn >"}, + { (char *)"delete_TStdIn", (PyCFunction)_wrap_delete_TStdIn, METH_O, (char *)"\n" + "delete_TStdIn(TStdIn self)\n" + "\n" + "Parameters:\n" + " self: TStdIn *\n" + "\n" + ""}, + { (char *)"TStdIn_swigregister", TStdIn_swigregister, METH_VARARGS, NULL}, + { (char *)"TStdIn_swiginit", TStdIn_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TStdOut", (PyCFunction)_wrap_new_TStdOut, METH_NOARGS, (char *)"new_TStdOut() -> TStdOut"}, + { (char *)"TStdOut_New", (PyCFunction)_wrap_TStdOut_New, METH_NOARGS, (char *)"TStdOut_New() -> TPt< TSOut >"}, + { (char *)"delete_TStdOut", (PyCFunction)_wrap_delete_TStdOut, METH_O, (char *)"\n" + "delete_TStdOut(TStdOut self)\n" + "\n" + "Parameters:\n" + " self: TStdOut *\n" + "\n" + ""}, + { (char *)"TStdOut_swigregister", TStdOut_swigregister, METH_VARARGS, NULL}, + { (char *)"TStdOut_swiginit", TStdOut_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TFIn", _wrap_new_TFIn, METH_VARARGS, (char *)"\n" + "TFIn(TStr FNm)\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + "new_TFIn(TStr FNm, bool & OpenedP) -> TFIn\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " OpenedP: bool &\n" + "\n" + ""}, + { (char *)"TFIn_New", _wrap_TFIn_New, METH_VARARGS, (char *)"\n" + "New(TStr FNm) -> PSIn\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + "TFIn_New(TStr FNm, bool & OpenedP) -> PSIn\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " OpenedP: bool &\n" + "\n" + ""}, + { (char *)"delete_TFIn", (PyCFunction)_wrap_delete_TFIn, METH_O, (char *)"\n" + "delete_TFIn(TFIn self)\n" + "\n" + "Parameters:\n" + " self: TFIn *\n" + "\n" + ""}, + { (char *)"TFIn_swigregister", TFIn_swigregister, METH_VARARGS, NULL}, + { (char *)"TFIn_swiginit", TFIn_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TFOut", _wrap_new_TFOut, METH_VARARGS, (char *)"\n" + "TFOut(TStr _FNm, bool const & Append=False)\n" + "\n" + "Parameters:\n" + " _FNm: TStr const &\n" + " Append: bool const &\n" + "\n" + "TFOut(TStr _FNm)\n" + "\n" + "Parameters:\n" + " _FNm: TStr const &\n" + "\n" + "new_TFOut(TStr _FNm, bool const & Append, bool & OpenedP) -> TFOut\n" + "\n" + "Parameters:\n" + " _FNm: TStr const &\n" + " Append: bool const &\n" + " OpenedP: bool &\n" + "\n" + ""}, + { (char *)"TFOut_New", _wrap_TFOut_New, METH_VARARGS, (char *)"\n" + "New(TStr FNm, bool const & Append=False) -> PSOut\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " Append: bool const &\n" + "\n" + "New(TStr FNm) -> PSOut\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + "TFOut_New(TStr FNm, bool const & Append, bool & OpenedP) -> PSOut\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " Append: bool const &\n" + " OpenedP: bool &\n" + "\n" + ""}, + { (char *)"delete_TFOut", (PyCFunction)_wrap_delete_TFOut, METH_O, (char *)"\n" + "delete_TFOut(TFOut self)\n" + "\n" + "Parameters:\n" + " self: TFOut *\n" + "\n" + ""}, + { (char *)"TFOut_swigregister", TFOut_swigregister, METH_VARARGS, NULL}, + { (char *)"TFOut_swiginit", TFOut_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TMIn", _wrap_new_TMIn, METH_VARARGS, (char *)"\n" + "TMIn(void const * _Bf, int const & _BfL, bool const & TakeBf=False)\n" + "\n" + "Parameters:\n" + " _Bf: void const *\n" + " _BfL: int const &\n" + " TakeBf: bool const &\n" + "\n" + "TMIn(void const * _Bf, int const & _BfL)\n" + "\n" + "Parameters:\n" + " _Bf: void const *\n" + " _BfL: int const &\n" + "\n" + "TMIn(TSIn SIn)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "TMIn(char const * CStr)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TMIn(TStr Str)\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "new_TMIn(TChA ChA) -> TMIn\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + ""}, + { (char *)"TMIn_New", _wrap_TMIn_New, METH_VARARGS, (char *)"\n" + "New(void const * _Bf, int const & _BfL, bool const & TakeBf=False) -> PSIn\n" + "\n" + "Parameters:\n" + " _Bf: void const *\n" + " _BfL: int const &\n" + " TakeBf: bool const &\n" + "\n" + "New(void const * _Bf, int const & _BfL) -> PSIn\n" + "\n" + "Parameters:\n" + " _Bf: void const *\n" + " _BfL: int const &\n" + "\n" + "New(char const * CStr) -> PSIn\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "New(TStr Str) -> PSIn\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TMIn_New(TChA ChA) -> PSIn\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + ""}, + { (char *)"delete_TMIn", (PyCFunction)_wrap_delete_TMIn, METH_O, (char *)"\n" + "delete_TMIn(TMIn self)\n" + "\n" + "Parameters:\n" + " self: TMIn *\n" + "\n" + ""}, + { (char *)"TMIn_GetBfAddr", (PyCFunction)_wrap_TMIn_GetBfAddr, METH_O, (char *)"\n" + "TMIn_GetBfAddr(TMIn self) -> char *\n" + "\n" + "Parameters:\n" + " self: TMIn *\n" + "\n" + ""}, + { (char *)"TMIn_swigregister", TMIn_swigregister, METH_VARARGS, NULL}, + { (char *)"TMIn_swiginit", TMIn_swiginit, METH_VARARGS, NULL}, + { (char *)"TMOut_New", _wrap_TMOut_New, METH_VARARGS, (char *)"\n" + "New(int const & MxBfL=1024) -> PSOut\n" + "\n" + "Parameters:\n" + " MxBfL: int const &\n" + "\n" + "TMOut_New() -> PSOut\n" + ""}, + { (char *)"new_TMOut", _wrap_new_TMOut, METH_VARARGS, (char *)"\n" + "TMOut(int const & _MxBfL=1024)\n" + "\n" + "Parameters:\n" + " _MxBfL: int const &\n" + "\n" + "TMOut()\n" + "new_TMOut(char * _Bf, int const & _MxBfL) -> TMOut\n" + "\n" + "Parameters:\n" + " _Bf: char *\n" + " _MxBfL: int const &\n" + "\n" + ""}, + { (char *)"delete_TMOut", (PyCFunction)_wrap_delete_TMOut, METH_O, (char *)"\n" + "delete_TMOut(TMOut self)\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + "\n" + ""}, + { (char *)"TMOut_AppendBf", _wrap_TMOut_AppendBf, METH_VARARGS, (char *)"\n" + "TMOut_AppendBf(TMOut self, void const * LBf, TSize const & LBfL)\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + " LBf: void const *\n" + " LBfL: TSize const &\n" + "\n" + ""}, + { (char *)"TMOut_Len", (PyCFunction)_wrap_TMOut_Len, METH_O, (char *)"\n" + "TMOut_Len(TMOut self) -> int\n" + "\n" + "Parameters:\n" + " self: TMOut const *\n" + "\n" + ""}, + { (char *)"TMOut_Clr", (PyCFunction)_wrap_TMOut_Clr, METH_O, (char *)"\n" + "TMOut_Clr(TMOut self)\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + "\n" + ""}, + { (char *)"TMOut_GetCh", _wrap_TMOut_GetCh, METH_VARARGS, (char *)"\n" + "TMOut_GetCh(TMOut self, int const & ChN) -> char\n" + "\n" + "Parameters:\n" + " self: TMOut const *\n" + " ChN: int const &\n" + "\n" + ""}, + { (char *)"TMOut_GetAsStr", (PyCFunction)_wrap_TMOut_GetAsStr, METH_O, (char *)"\n" + "TMOut_GetAsStr(TMOut self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TMOut const *\n" + "\n" + ""}, + { (char *)"TMOut_CutBf", _wrap_TMOut_CutBf, METH_VARARGS, (char *)"\n" + "TMOut_CutBf(TMOut self, int const & CutBfL)\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + " CutBfL: int const &\n" + "\n" + ""}, + { (char *)"TMOut_GetSIn", _wrap_TMOut_GetSIn, METH_VARARGS, (char *)"\n" + "GetSIn(bool const & IsCut=True, int const & CutBfL=-1) -> PSIn\n" + "\n" + "Parameters:\n" + " IsCut: bool const &\n" + " CutBfL: int const &\n" + "\n" + "GetSIn(bool const & IsCut=True) -> PSIn\n" + "\n" + "Parameters:\n" + " IsCut: bool const &\n" + "\n" + "TMOut_GetSIn(TMOut self) -> PSIn\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + "\n" + ""}, + { (char *)"TMOut_GetBfAddr", (PyCFunction)_wrap_TMOut_GetBfAddr, METH_O, (char *)"\n" + "TMOut_GetBfAddr(TMOut self) -> char *\n" + "\n" + "Parameters:\n" + " self: TMOut const *\n" + "\n" + ""}, + { (char *)"TMOut_IsCrLfLn", (PyCFunction)_wrap_TMOut_IsCrLfLn, METH_O, (char *)"\n" + "TMOut_IsCrLfLn(TMOut self) -> bool\n" + "\n" + "Parameters:\n" + " self: TMOut const *\n" + "\n" + ""}, + { (char *)"TMOut_GetCrLfLn", (PyCFunction)_wrap_TMOut_GetCrLfLn, METH_O, (char *)"\n" + "TMOut_GetCrLfLn(TMOut self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + "\n" + ""}, + { (char *)"TMOut_IsEolnLn", (PyCFunction)_wrap_TMOut_IsEolnLn, METH_O, (char *)"\n" + "TMOut_IsEolnLn(TMOut self) -> bool\n" + "\n" + "Parameters:\n" + " self: TMOut const *\n" + "\n" + ""}, + { (char *)"TMOut_GetEolnLn", _wrap_TMOut_GetEolnLn, METH_VARARGS, (char *)"\n" + "TMOut_GetEolnLn(TMOut self, bool const & DoAddEoln, bool const & DoCutBf) -> TStr\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + " DoAddEoln: bool const &\n" + " DoCutBf: bool const &\n" + "\n" + ""}, + { (char *)"TMOut_MkEolnLn", (PyCFunction)_wrap_TMOut_MkEolnLn, METH_O, (char *)"\n" + "TMOut_MkEolnLn(TMOut self)\n" + "\n" + "Parameters:\n" + " self: TMOut *\n" + "\n" + ""}, + { (char *)"TMOut_swigregister", TMOut_swigregister, METH_VARARGS, NULL}, + { (char *)"TMOut_swiginit", TMOut_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TChRet", _wrap_new_TChRet, METH_VARARGS, (char *)"\n" + "TChRet(PSIn const & _SIn, char const & _EofCh=0)\n" + "\n" + "Parameters:\n" + " _SIn: PSIn const &\n" + " _EofCh: char const &\n" + "\n" + "new_TChRet(PSIn const & _SIn) -> TChRet\n" + "\n" + "Parameters:\n" + " _SIn: PSIn const &\n" + "\n" + ""}, + { (char *)"TChRet_Eof", (PyCFunction)_wrap_TChRet_Eof, METH_O, (char *)"\n" + "TChRet_Eof(TChRet self) -> bool\n" + "\n" + "Parameters:\n" + " self: TChRet const *\n" + "\n" + ""}, + { (char *)"TChRet_GetCh", (PyCFunction)_wrap_TChRet_GetCh, METH_O, (char *)"\n" + "TChRet_GetCh(TChRet self) -> char\n" + "\n" + "Parameters:\n" + " self: TChRet *\n" + "\n" + ""}, + { (char *)"TChRet___call__", (PyCFunction)_wrap_TChRet___call__, METH_O, (char *)"\n" + "TChRet___call__(TChRet self) -> char\n" + "\n" + "Parameters:\n" + " self: TChRet *\n" + "\n" + ""}, + { (char *)"delete_TChRet", (PyCFunction)_wrap_delete_TChRet, METH_O, (char *)"\n" + "delete_TChRet(TChRet self)\n" + "\n" + "Parameters:\n" + " self: TChRet *\n" + "\n" + ""}, + { (char *)"TChRet_swigregister", TChRet_swigregister, METH_VARARGS, NULL}, + { (char *)"TChRet_swiginit", TChRet_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TLnRet", (PyCFunction)_wrap_new_TLnRet, METH_O, (char *)"\n" + "new_TLnRet(PSIn const & _SIn) -> TLnRet\n" + "\n" + "Parameters:\n" + " _SIn: PSIn const &\n" + "\n" + ""}, + { (char *)"TLnRet_NextLn", _wrap_TLnRet_NextLn, METH_VARARGS, (char *)"\n" + "TLnRet_NextLn(TLnRet self, TStr LnStr) -> bool\n" + "\n" + "Parameters:\n" + " self: TLnRet *\n" + " LnStr: TStr &\n" + "\n" + ""}, + { (char *)"delete_TLnRet", (PyCFunction)_wrap_delete_TLnRet, METH_O, (char *)"\n" + "delete_TLnRet(TLnRet self)\n" + "\n" + "Parameters:\n" + " self: TLnRet *\n" + "\n" + ""}, + { (char *)"TLnRet_swigregister", TLnRet_swigregister, METH_VARARGS, NULL}, + { (char *)"TLnRet_swiginit", TLnRet_swiginit, METH_VARARGS, NULL}, + { (char *)"TFile_Exists", (PyCFunction)_wrap_TFile_Exists, METH_O, (char *)"\n" + "TFile_Exists(TStr FNm) -> bool\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"TFile_Del", _wrap_TFile_Del, METH_VARARGS, (char *)"\n" + "Del(TStr FNm, bool const & ThrowExceptP=True)\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " ThrowExceptP: bool const &\n" + "\n" + "TFile_Del(TStr FNm)\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"TFile_DelWc", _wrap_TFile_DelWc, METH_VARARGS, (char *)"\n" + "DelWc(TStr WcStr, bool const & RecurseDirP=False)\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + " RecurseDirP: bool const &\n" + "\n" + "TFile_DelWc(TStr WcStr)\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + "\n" + ""}, + { (char *)"TFile_Rename", _wrap_TFile_Rename, METH_VARARGS, (char *)"\n" + "TFile_Rename(TStr SrcFNm, TStr DstFNm)\n" + "\n" + "Parameters:\n" + " SrcFNm: TStr const &\n" + " DstFNm: TStr const &\n" + "\n" + ""}, + { (char *)"TFile_GetUniqueFNm", (PyCFunction)_wrap_TFile_GetUniqueFNm, METH_O, (char *)"\n" + "TFile_GetUniqueFNm(TStr FNm) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"new_TFile", (PyCFunction)_wrap_new_TFile, METH_NOARGS, (char *)"new_TFile() -> TFile"}, + { (char *)"delete_TFile", (PyCFunction)_wrap_delete_TFile, METH_O, (char *)"\n" + "delete_TFile(TFile self)\n" + "\n" + "Parameters:\n" + " self: TFile *\n" + "\n" + ""}, + { (char *)"TFile_swigregister", TFile_swigregister, METH_VARARGS, NULL}, + { (char *)"TFile_swiginit", TFile_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TUNGraph", _wrap_new_TUNGraph, METH_VARARGS, (char *)"\n" + "TUNGraph()\n" + "TUNGraph(int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + "TUNGraph(TUNGraph Graph)\n" + "\n" + "Parameters:\n" + " Graph: TUNGraph const &\n" + "\n" + "new_TUNGraph(TSIn SIn) -> TUNGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TUNGraph_Save", _wrap_TUNGraph_Save, METH_VARARGS, (char *)"\n" + "TUNGraph_Save(TUNGraph self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TUNGraph_New", _wrap_TUNGraph_New, METH_VARARGS, (char *)"\n" + "New() -> PUNGraph\n" + "TUNGraph_New(int const & Nodes, int const & Edges) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_Load", (PyCFunction)_wrap_TUNGraph_Load, METH_O, (char *)"\n" + "TUNGraph_Load(TSIn SIn) -> PUNGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TUNGraph_HasFlag", _wrap_TUNGraph_HasFlag, METH_VARARGS, (char *)"\n" + "TUNGraph_HasFlag(TUNGraph self, TGraphFlag const & Flag) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + " Flag: TGraphFlag const &\n" + "\n" + ""}, + { (char *)"TUNGraph_GetNodes", (PyCFunction)_wrap_TUNGraph_GetNodes, METH_O, (char *)"\n" + "TUNGraph_GetNodes(TUNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_AddNode", _wrap_TUNGraph_AddNode, METH_VARARGS, (char *)"\n" + "AddNode(int NId=-1) -> int\n" + "\n" + "Parameters:\n" + " NId: int\n" + "\n" + "AddNode() -> int\n" + "AddNode(TUNGraph::TNodeI const & NodeI) -> int\n" + "\n" + "Parameters:\n" + " NodeI: TUNGraph::TNodeI const &\n" + "\n" + "AddNode(int const & NId, TIntV NbrNIdV) -> int\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + " NbrNIdV: TIntV const &\n" + "\n" + "TUNGraph_AddNode(TUNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & NIdVId) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + " NId: int const &\n" + " Pool: TVecPool< TInt > const &\n" + " NIdVId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_DelNode", _wrap_TUNGraph_DelNode, METH_VARARGS, (char *)"\n" + "DelNode(int const & NId)\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + "\n" + "TUNGraph_DelNode(TUNGraph self, TUNGraph::TNode const & NodeI)\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + " NodeI: TUNGraph::TNode const &\n" + "\n" + ""}, + { (char *)"TUNGraph_IsNode", _wrap_TUNGraph_IsNode, METH_VARARGS, (char *)"\n" + "TUNGraph_IsNode(TUNGraph self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_BegNI", (PyCFunction)_wrap_TUNGraph_BegNI, METH_O, (char *)"\n" + "TUNGraph_BegNI(TUNGraph self) -> TUNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_EndNI", (PyCFunction)_wrap_TUNGraph_EndNI, METH_O, (char *)"\n" + "TUNGraph_EndNI(TUNGraph self) -> TUNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_GetNI", _wrap_TUNGraph_GetNI, METH_VARARGS, (char *)"\n" + "TUNGraph_GetNI(TUNGraph self, int const & NId) -> TUNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_GetMxNId", (PyCFunction)_wrap_TUNGraph_GetMxNId, METH_O, (char *)"\n" + "TUNGraph_GetMxNId(TUNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_GetEdges", (PyCFunction)_wrap_TUNGraph_GetEdges, METH_O, (char *)"\n" + "TUNGraph_GetEdges(TUNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_AddEdge", _wrap_TUNGraph_AddEdge, METH_VARARGS, (char *)"\n" + "AddEdge(int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "TUNGraph_AddEdge(TUNGraph self, TUNGraph::TEdgeI const & EdgeI) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + " EdgeI: TUNGraph::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TUNGraph_DelEdge", _wrap_TUNGraph_DelEdge, METH_VARARGS, (char *)"\n" + "TUNGraph_DelEdge(TUNGraph self, int const & SrcNId, int const & DstNId)\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_IsEdge", _wrap_TUNGraph_IsEdge, METH_VARARGS, (char *)"\n" + "TUNGraph_IsEdge(TUNGraph self, int const & SrcNId, int const & DstNId) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_BegEI", (PyCFunction)_wrap_TUNGraph_BegEI, METH_O, (char *)"\n" + "TUNGraph_BegEI(TUNGraph self) -> TUNGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_EndEI", (PyCFunction)_wrap_TUNGraph_EndEI, METH_O, (char *)"\n" + "TUNGraph_EndEI(TUNGraph self) -> TUNGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_GetEI", _wrap_TUNGraph_GetEI, METH_VARARGS, (char *)"\n" + "TUNGraph_GetEI(TUNGraph self, int const & SrcNId, int const & DstNId) -> TUNGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_GetRndNId", _wrap_TUNGraph_GetRndNId, METH_VARARGS, (char *)"\n" + "GetRndNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TUNGraph_GetRndNId(TUNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + "\n" + ""}, + { (char *)"TUNGraph_GetRndNI", _wrap_TUNGraph_GetRndNI, METH_VARARGS, (char *)"\n" + "GetRndNI(TRnd Rnd=Rnd) -> TUNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TUNGraph_GetRndNI(TUNGraph self) -> TUNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + "\n" + ""}, + { (char *)"TUNGraph_GetNIdV", _wrap_TUNGraph_GetNIdV, METH_VARARGS, (char *)"\n" + "TUNGraph_GetNIdV(TUNGraph self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TUNGraph_Empty", (PyCFunction)_wrap_TUNGraph_Empty, METH_O, (char *)"\n" + "TUNGraph_Empty(TUNGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_Clr", (PyCFunction)_wrap_TUNGraph_Clr, METH_O, (char *)"\n" + "TUNGraph_Clr(TUNGraph self)\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + "\n" + ""}, + { (char *)"TUNGraph_Reserve", _wrap_TUNGraph_Reserve, METH_VARARGS, (char *)"\n" + "TUNGraph_Reserve(TUNGraph self, int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_ReserveNIdDeg", _wrap_TUNGraph_ReserveNIdDeg, METH_VARARGS, (char *)"\n" + "TUNGraph_ReserveNIdDeg(TUNGraph self, int const & NId, int const & Deg)\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + " NId: int const &\n" + " Deg: int const &\n" + "\n" + ""}, + { (char *)"TUNGraph_Defrag", _wrap_TUNGraph_Defrag, METH_VARARGS, (char *)"\n" + "Defrag(bool const & OnlyNodeLinks=False)\n" + "\n" + "Parameters:\n" + " OnlyNodeLinks: bool const &\n" + "\n" + "TUNGraph_Defrag(TUNGraph self)\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + "\n" + ""}, + { (char *)"TUNGraph_IsOk", _wrap_TUNGraph_IsOk, METH_VARARGS, (char *)"\n" + "IsOk(bool const & ThrowExcept=True) -> bool\n" + "\n" + "Parameters:\n" + " ThrowExcept: bool const &\n" + "\n" + "TUNGraph_IsOk(TUNGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_Dump", _wrap_TUNGraph_Dump, METH_VARARGS, (char *)"\n" + "Dump(FILE * OutF=stdout)\n" + "\n" + "Parameters:\n" + " OutF: FILE *\n" + "\n" + "TUNGraph_Dump(TUNGraph self)\n" + "\n" + "Parameters:\n" + " self: TUNGraph const *\n" + "\n" + ""}, + { (char *)"TUNGraph_GetSmallGraph", (PyCFunction)_wrap_TUNGraph_GetSmallGraph, METH_NOARGS, (char *)"TUNGraph_GetSmallGraph() -> PUNGraph"}, + { (char *)"delete_TUNGraph", (PyCFunction)_wrap_delete_TUNGraph, METH_O, (char *)"\n" + "delete_TUNGraph(TUNGraph self)\n" + "\n" + "Parameters:\n" + " self: TUNGraph *\n" + "\n" + ""}, + { (char *)"TUNGraph_swigregister", TUNGraph_swigregister, METH_VARARGS, NULL}, + { (char *)"TUNGraph_swiginit", TUNGraph_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNGraph", _wrap_new_TNGraph, METH_VARARGS, (char *)"\n" + "TNGraph()\n" + "TNGraph(int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + "TNGraph(TNGraph Graph)\n" + "\n" + "Parameters:\n" + " Graph: TNGraph const &\n" + "\n" + "new_TNGraph(TSIn SIn) -> TNGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TNGraph_Save", _wrap_TNGraph_Save, METH_VARARGS, (char *)"\n" + "TNGraph_Save(TNGraph self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TNGraph_New", _wrap_TNGraph_New, METH_VARARGS, (char *)"\n" + "New() -> PNGraph\n" + "TNGraph_New(int const & Nodes, int const & Edges) -> PNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_Load", (PyCFunction)_wrap_TNGraph_Load, METH_O, (char *)"\n" + "TNGraph_Load(TSIn SIn) -> PNGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TNGraph_HasFlag", _wrap_TNGraph_HasFlag, METH_VARARGS, (char *)"\n" + "TNGraph_HasFlag(TNGraph self, TGraphFlag const & Flag) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + " Flag: TGraphFlag const &\n" + "\n" + ""}, + { (char *)"TNGraph_GetNodes", (PyCFunction)_wrap_TNGraph_GetNodes, METH_O, (char *)"\n" + "TNGraph_GetNodes(TNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_AddNode", _wrap_TNGraph_AddNode, METH_VARARGS, (char *)"\n" + "AddNode(int NId=-1) -> int\n" + "\n" + "Parameters:\n" + " NId: int\n" + "\n" + "AddNode() -> int\n" + "AddNode(TNGraph::TNodeI const & NodeId) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNGraph::TNodeI const &\n" + "\n" + "AddNode(int const & NId, TIntV InNIdV, TIntV OutNIdV) -> int\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + " InNIdV: TIntV const &\n" + " OutNIdV: TIntV const &\n" + "\n" + "TNGraph_AddNode(TNGraph self, int const & NId, TVecPool< TInt > const & Pool, int const & SrcVId, \n" + " int const & DstVId) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + " NId: int const &\n" + " Pool: TVecPool< TInt > const &\n" + " SrcVId: int const &\n" + " DstVId: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_DelNode", _wrap_TNGraph_DelNode, METH_VARARGS, (char *)"\n" + "DelNode(int const & NId)\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + "\n" + "TNGraph_DelNode(TNGraph self, TNGraph::TNode const & NodeI)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + " NodeI: TNGraph::TNode const &\n" + "\n" + ""}, + { (char *)"TNGraph_IsNode", _wrap_TNGraph_IsNode, METH_VARARGS, (char *)"\n" + "TNGraph_IsNode(TNGraph self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_BegNI", (PyCFunction)_wrap_TNGraph_BegNI, METH_O, (char *)"\n" + "TNGraph_BegNI(TNGraph self) -> TNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_EndNI", (PyCFunction)_wrap_TNGraph_EndNI, METH_O, (char *)"\n" + "TNGraph_EndNI(TNGraph self) -> TNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_GetNI", _wrap_TNGraph_GetNI, METH_VARARGS, (char *)"\n" + "TNGraph_GetNI(TNGraph self, int const & NId) -> TNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_GetMxNId", (PyCFunction)_wrap_TNGraph_GetMxNId, METH_O, (char *)"\n" + "TNGraph_GetMxNId(TNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_GetEdges", (PyCFunction)_wrap_TNGraph_GetEdges, METH_O, (char *)"\n" + "TNGraph_GetEdges(TNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_AddEdge", _wrap_TNGraph_AddEdge, METH_VARARGS, (char *)"\n" + "AddEdge(int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "TNGraph_AddEdge(TNGraph self, TNGraph::TEdgeI const & EdgeI) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + " EdgeI: TNGraph::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TNGraph_DelEdge", _wrap_TNGraph_DelEdge, METH_VARARGS, (char *)"\n" + "DelEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True)\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "TNGraph_DelEdge(TNGraph self, int const & SrcNId, int const & DstNId)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_IsEdge", _wrap_TNGraph_IsEdge, METH_VARARGS, (char *)"\n" + "IsEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "TNGraph_IsEdge(TNGraph self, int const & SrcNId, int const & DstNId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_BegEI", (PyCFunction)_wrap_TNGraph_BegEI, METH_O, (char *)"\n" + "TNGraph_BegEI(TNGraph self) -> TNGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_EndEI", (PyCFunction)_wrap_TNGraph_EndEI, METH_O, (char *)"\n" + "TNGraph_EndEI(TNGraph self) -> TNGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_GetEI", _wrap_TNGraph_GetEI, METH_VARARGS, (char *)"\n" + "TNGraph_GetEI(TNGraph self, int const & SrcNId, int const & DstNId) -> TNGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_GetRndNId", _wrap_TNGraph_GetRndNId, METH_VARARGS, (char *)"\n" + "GetRndNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNGraph_GetRndNId(TNGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + "\n" + ""}, + { (char *)"TNGraph_GetRndNI", _wrap_TNGraph_GetRndNI, METH_VARARGS, (char *)"\n" + "GetRndNI(TRnd Rnd=Rnd) -> TNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNGraph_GetRndNI(TNGraph self) -> TNGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + "\n" + ""}, + { (char *)"TNGraph_GetNIdV", _wrap_TNGraph_GetNIdV, METH_VARARGS, (char *)"\n" + "TNGraph_GetNIdV(TNGraph self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TNGraph_Empty", (PyCFunction)_wrap_TNGraph_Empty, METH_O, (char *)"\n" + "TNGraph_Empty(TNGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_Clr", (PyCFunction)_wrap_TNGraph_Clr, METH_O, (char *)"\n" + "TNGraph_Clr(TNGraph self)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + "\n" + ""}, + { (char *)"TNGraph_Reserve", _wrap_TNGraph_Reserve, METH_VARARGS, (char *)"\n" + "TNGraph_Reserve(TNGraph self, int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_ReserveNIdInDeg", _wrap_TNGraph_ReserveNIdInDeg, METH_VARARGS, (char *)"\n" + "TNGraph_ReserveNIdInDeg(TNGraph self, int const & NId, int const & InDeg)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + " NId: int const &\n" + " InDeg: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_ReserveNIdOutDeg", _wrap_TNGraph_ReserveNIdOutDeg, METH_VARARGS, (char *)"\n" + "TNGraph_ReserveNIdOutDeg(TNGraph self, int const & NId, int const & OutDeg)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + " NId: int const &\n" + " OutDeg: int const &\n" + "\n" + ""}, + { (char *)"TNGraph_Defrag", _wrap_TNGraph_Defrag, METH_VARARGS, (char *)"\n" + "Defrag(bool const & OnlyNodeLinks=False)\n" + "\n" + "Parameters:\n" + " OnlyNodeLinks: bool const &\n" + "\n" + "TNGraph_Defrag(TNGraph self)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + "\n" + ""}, + { (char *)"TNGraph_IsOk", _wrap_TNGraph_IsOk, METH_VARARGS, (char *)"\n" + "IsOk(bool const & ThrowExcept=True) -> bool\n" + "\n" + "Parameters:\n" + " ThrowExcept: bool const &\n" + "\n" + "TNGraph_IsOk(TNGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_Dump", _wrap_TNGraph_Dump, METH_VARARGS, (char *)"\n" + "Dump(FILE * OutF=stdout)\n" + "\n" + "Parameters:\n" + " OutF: FILE *\n" + "\n" + "TNGraph_Dump(TNGraph self)\n" + "\n" + "Parameters:\n" + " self: TNGraph const *\n" + "\n" + ""}, + { (char *)"TNGraph_GetSmallGraph", (PyCFunction)_wrap_TNGraph_GetSmallGraph, METH_NOARGS, (char *)"TNGraph_GetSmallGraph() -> PNGraph"}, + { (char *)"delete_TNGraph", (PyCFunction)_wrap_delete_TNGraph, METH_O, (char *)"\n" + "delete_TNGraph(TNGraph self)\n" + "\n" + "Parameters:\n" + " self: TNGraph *\n" + "\n" + ""}, + { (char *)"TNGraph_swigregister", TNGraph_swigregister, METH_VARARGS, NULL}, + { (char *)"TNGraph_swiginit", TNGraph_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNEGraph", _wrap_new_TNEGraph, METH_VARARGS, (char *)"\n" + "TNEGraph()\n" + "TNEGraph(int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + "TNEGraph(TNEGraph Graph)\n" + "\n" + "Parameters:\n" + " Graph: TNEGraph const &\n" + "\n" + "new_TNEGraph(TSIn SIn) -> TNEGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TNEGraph_Save", _wrap_TNEGraph_Save, METH_VARARGS, (char *)"\n" + "TNEGraph_Save(TNEGraph self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TNEGraph_New", _wrap_TNEGraph_New, METH_VARARGS, (char *)"\n" + "New() -> PNEGraph\n" + "TNEGraph_New(int const & Nodes, int const & Edges) -> PNEGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TNEGraph_Load", (PyCFunction)_wrap_TNEGraph_Load, METH_O, (char *)"\n" + "TNEGraph_Load(TSIn SIn) -> PNEGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TNEGraph_HasFlag", _wrap_TNEGraph_HasFlag, METH_VARARGS, (char *)"\n" + "TNEGraph_HasFlag(TNEGraph self, TGraphFlag const & Flag) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " Flag: TGraphFlag const &\n" + "\n" + ""}, + { (char *)"TNEGraph_GetNodes", (PyCFunction)_wrap_TNEGraph_GetNodes, METH_O, (char *)"\n" + "TNEGraph_GetNodes(TNEGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_AddNode", _wrap_TNEGraph_AddNode, METH_VARARGS, (char *)"\n" + "AddNode(int NId=-1) -> int\n" + "\n" + "Parameters:\n" + " NId: int\n" + "\n" + "AddNode() -> int\n" + "TNEGraph_AddNode(TNEGraph self, TNEGraph::TNodeI const & NodeId) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + " NodeId: TNEGraph::TNodeI const &\n" + "\n" + ""}, + { (char *)"TNEGraph_DelNode", _wrap_TNEGraph_DelNode, METH_VARARGS, (char *)"\n" + "DelNode(int const & NId)\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + "\n" + "TNEGraph_DelNode(TNEGraph self, TNEGraph::TNode const & NodeI)\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + " NodeI: TNEGraph::TNode const &\n" + "\n" + ""}, + { (char *)"TNEGraph_IsNode", _wrap_TNEGraph_IsNode, METH_VARARGS, (char *)"\n" + "TNEGraph_IsNode(TNEGraph self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEGraph_BegNI", (PyCFunction)_wrap_TNEGraph_BegNI, METH_O, (char *)"\n" + "TNEGraph_BegNI(TNEGraph self) -> TNEGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_EndNI", (PyCFunction)_wrap_TNEGraph_EndNI, METH_O, (char *)"\n" + "TNEGraph_EndNI(TNEGraph self) -> TNEGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_GetNI", _wrap_TNEGraph_GetNI, METH_VARARGS, (char *)"\n" + "TNEGraph_GetNI(TNEGraph self, int const & NId) -> TNEGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEGraph_GetMxNId", (PyCFunction)_wrap_TNEGraph_GetMxNId, METH_O, (char *)"\n" + "TNEGraph_GetMxNId(TNEGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_GetEdges", (PyCFunction)_wrap_TNEGraph_GetEdges, METH_O, (char *)"\n" + "TNEGraph_GetEdges(TNEGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_AddEdge", _wrap_TNEGraph_AddEdge, METH_VARARGS, (char *)"\n" + "AddEdge(int const & SrcNId, int const & DstNId, int EId=-1) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int\n" + "\n" + "AddEdge(int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "TNEGraph_AddEdge(TNEGraph self, TNEGraph::TEdgeI const & EdgeI) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + " EdgeI: TNEGraph::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TNEGraph_DelEdge", _wrap_TNEGraph_DelEdge, METH_VARARGS, (char *)"\n" + "DelEdge(int const & EId)\n" + "\n" + "Parameters:\n" + " EId: int const &\n" + "\n" + "DelEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True)\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "TNEGraph_DelEdge(TNEGraph self, int const & SrcNId, int const & DstNId)\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNEGraph_IsEdge", _wrap_TNEGraph_IsEdge, METH_VARARGS, (char *)"\n" + "IsEdge(int const & EId) -> bool\n" + "\n" + "Parameters:\n" + " EId: int const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int &\n" + " IsDir: bool const &\n" + "\n" + "TNEGraph_IsEdge(TNEGraph self, int const & SrcNId, int const & DstNId, int & EId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int &\n" + "\n" + ""}, + { (char *)"TNEGraph_GetEId", _wrap_TNEGraph_GetEId, METH_VARARGS, (char *)"\n" + "TNEGraph_GetEId(TNEGraph self, int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNEGraph_BegEI", (PyCFunction)_wrap_TNEGraph_BegEI, METH_O, (char *)"\n" + "TNEGraph_BegEI(TNEGraph self) -> TNEGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_EndEI", (PyCFunction)_wrap_TNEGraph_EndEI, METH_O, (char *)"\n" + "TNEGraph_EndEI(TNEGraph self) -> TNEGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_GetEI", _wrap_TNEGraph_GetEI, METH_VARARGS, (char *)"\n" + "GetEI(int const & EId) -> TNEGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " EId: int const &\n" + "\n" + "TNEGraph_GetEI(TNEGraph self, int const & SrcNId, int const & DstNId) -> TNEGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNEGraph_GetRndNId", _wrap_TNEGraph_GetRndNId, METH_VARARGS, (char *)"\n" + "GetRndNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEGraph_GetRndNId(TNEGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + "\n" + ""}, + { (char *)"TNEGraph_GetRndNI", _wrap_TNEGraph_GetRndNI, METH_VARARGS, (char *)"\n" + "GetRndNI(TRnd Rnd=Rnd) -> TNEGraph::TNodeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEGraph_GetRndNI(TNEGraph self) -> TNEGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + "\n" + ""}, + { (char *)"TNEGraph_GetRndEId", _wrap_TNEGraph_GetRndEId, METH_VARARGS, (char *)"\n" + "GetRndEId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEGraph_GetRndEId(TNEGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + "\n" + ""}, + { (char *)"TNEGraph_GetRndEI", _wrap_TNEGraph_GetRndEI, METH_VARARGS, (char *)"\n" + "GetRndEI(TRnd Rnd=Rnd) -> TNEGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEGraph_GetRndEI(TNEGraph self) -> TNEGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + "\n" + ""}, + { (char *)"TNEGraph_GetNIdV", _wrap_TNEGraph_GetNIdV, METH_VARARGS, (char *)"\n" + "TNEGraph_GetNIdV(TNEGraph self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TNEGraph_GetEIdV", _wrap_TNEGraph_GetEIdV, METH_VARARGS, (char *)"\n" + "TNEGraph_GetEIdV(TNEGraph self, TIntV EIdV)\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + " EIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TNEGraph_Empty", (PyCFunction)_wrap_TNEGraph_Empty, METH_O, (char *)"\n" + "TNEGraph_Empty(TNEGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_Clr", (PyCFunction)_wrap_TNEGraph_Clr, METH_O, (char *)"\n" + "TNEGraph_Clr(TNEGraph self)\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + "\n" + ""}, + { (char *)"TNEGraph_Reserve", _wrap_TNEGraph_Reserve, METH_VARARGS, (char *)"\n" + "TNEGraph_Reserve(TNEGraph self, int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TNEGraph_Defrag", _wrap_TNEGraph_Defrag, METH_VARARGS, (char *)"\n" + "Defrag(bool const & OnlyNodeLinks=False)\n" + "\n" + "Parameters:\n" + " OnlyNodeLinks: bool const &\n" + "\n" + "TNEGraph_Defrag(TNEGraph self)\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + "\n" + ""}, + { (char *)"TNEGraph_IsOk", _wrap_TNEGraph_IsOk, METH_VARARGS, (char *)"\n" + "IsOk(bool const & ThrowExcept=True) -> bool\n" + "\n" + "Parameters:\n" + " ThrowExcept: bool const &\n" + "\n" + "TNEGraph_IsOk(TNEGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"TNEGraph_Dump", _wrap_TNEGraph_Dump, METH_VARARGS, (char *)"\n" + "Dump(FILE * OutF=stdout)\n" + "\n" + "Parameters:\n" + " OutF: FILE *\n" + "\n" + "TNEGraph_Dump(TNEGraph self)\n" + "\n" + "Parameters:\n" + " self: TNEGraph const *\n" + "\n" + ""}, + { (char *)"delete_TNEGraph", (PyCFunction)_wrap_delete_TNEGraph, METH_O, (char *)"\n" + "delete_TNEGraph(TNEGraph self)\n" + "\n" + "Parameters:\n" + " self: TNEGraph *\n" + "\n" + ""}, + { (char *)"TNEGraph_swigregister", TNEGraph_swigregister, METH_VARARGS, NULL}, + { (char *)"TNEGraph_swiginit", TNEGraph_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TBPGraph", _wrap_new_TBPGraph, METH_VARARGS, (char *)"\n" + "TBPGraph()\n" + "TBPGraph(int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + "TBPGraph(TBPGraph BPGraph)\n" + "\n" + "Parameters:\n" + " BPGraph: TBPGraph const &\n" + "\n" + "new_TBPGraph(TSIn SIn) -> TBPGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TBPGraph_Save", _wrap_TBPGraph_Save, METH_VARARGS, (char *)"\n" + "TBPGraph_Save(TBPGraph self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TBPGraph_New", _wrap_TBPGraph_New, METH_VARARGS, (char *)"\n" + "New() -> PBPGraph\n" + "TBPGraph_New(int const & Nodes, int const & Edges) -> PBPGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_Load", (PyCFunction)_wrap_TBPGraph_Load, METH_O, (char *)"\n" + "TBPGraph_Load(TSIn SIn) -> PBPGraph\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TBPGraph_GetNodes", (PyCFunction)_wrap_TBPGraph_GetNodes, METH_O, (char *)"\n" + "TBPGraph_GetNodes(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetLNodes", (PyCFunction)_wrap_TBPGraph_GetLNodes, METH_O, (char *)"\n" + "TBPGraph_GetLNodes(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetRNodes", (PyCFunction)_wrap_TBPGraph_GetRNodes, METH_O, (char *)"\n" + "TBPGraph_GetRNodes(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_AddNode", _wrap_TBPGraph_AddNode, METH_VARARGS, (char *)"\n" + "AddNode(int NId=-1, bool const & LeftNode=True) -> int\n" + "\n" + "Parameters:\n" + " NId: int\n" + " LeftNode: bool const &\n" + "\n" + "AddNode(int NId=-1) -> int\n" + "\n" + "Parameters:\n" + " NId: int\n" + "\n" + "AddNode() -> int\n" + "TBPGraph_AddNode(TBPGraph self, TBPGraph::TNodeI const & NodeI) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + " NodeI: TBPGraph::TNodeI const &\n" + "\n" + ""}, + { (char *)"TBPGraph_DelNode", _wrap_TBPGraph_DelNode, METH_VARARGS, (char *)"\n" + "DelNode(int const & NId)\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + "\n" + "TBPGraph_DelNode(TBPGraph self, TBPGraph::TNode const & NodeI)\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + " NodeI: TBPGraph::TNode const &\n" + "\n" + ""}, + { (char *)"TBPGraph_IsNode", _wrap_TBPGraph_IsNode, METH_VARARGS, (char *)"\n" + "TBPGraph_IsNode(TBPGraph self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_IsLNode", _wrap_TBPGraph_IsLNode, METH_VARARGS, (char *)"\n" + "TBPGraph_IsLNode(TBPGraph self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_IsRNode", _wrap_TBPGraph_IsRNode, METH_VARARGS, (char *)"\n" + "TBPGraph_IsRNode(TBPGraph self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_GetMxNId", (PyCFunction)_wrap_TBPGraph_GetMxNId, METH_O, (char *)"\n" + "TBPGraph_GetMxNId(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_BegNI", (PyCFunction)_wrap_TBPGraph_BegNI, METH_O, (char *)"\n" + "TBPGraph_BegNI(TBPGraph self) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_EndNI", (PyCFunction)_wrap_TBPGraph_EndNI, METH_O, (char *)"\n" + "TBPGraph_EndNI(TBPGraph self) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetNI", _wrap_TBPGraph_GetNI, METH_VARARGS, (char *)"\n" + "TBPGraph_GetNI(TBPGraph self, int const & NId) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_BegLNI", (PyCFunction)_wrap_TBPGraph_BegLNI, METH_O, (char *)"\n" + "TBPGraph_BegLNI(TBPGraph self) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_EndLNI", (PyCFunction)_wrap_TBPGraph_EndLNI, METH_O, (char *)"\n" + "TBPGraph_EndLNI(TBPGraph self) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_BegRNI", (PyCFunction)_wrap_TBPGraph_BegRNI, METH_O, (char *)"\n" + "TBPGraph_BegRNI(TBPGraph self) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_EndRNI", (PyCFunction)_wrap_TBPGraph_EndRNI, METH_O, (char *)"\n" + "TBPGraph_EndRNI(TBPGraph self) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetEdges", (PyCFunction)_wrap_TBPGraph_GetEdges, METH_O, (char *)"\n" + "TBPGraph_GetEdges(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_AddEdge", _wrap_TBPGraph_AddEdge, METH_VARARGS, (char *)"\n" + "AddEdge(int const & LeftNId, int const & RightNId) -> int\n" + "\n" + "Parameters:\n" + " LeftNId: int const &\n" + " RightNId: int const &\n" + "\n" + "TBPGraph_AddEdge(TBPGraph self, TBPGraph::TEdgeI const & EdgeI) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + " EdgeI: TBPGraph::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TBPGraph_DelEdge", _wrap_TBPGraph_DelEdge, METH_VARARGS, (char *)"\n" + "TBPGraph_DelEdge(TBPGraph self, int const & LeftNId, int const & RightNId)\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + " LeftNId: int const &\n" + " RightNId: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_IsEdge", _wrap_TBPGraph_IsEdge, METH_VARARGS, (char *)"\n" + "TBPGraph_IsEdge(TBPGraph self, int const & LeftNId, int const & RightNId) -> bool\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " LeftNId: int const &\n" + " RightNId: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_BegEI", (PyCFunction)_wrap_TBPGraph_BegEI, METH_O, (char *)"\n" + "TBPGraph_BegEI(TBPGraph self) -> TBPGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_EndEI", (PyCFunction)_wrap_TBPGraph_EndEI, METH_O, (char *)"\n" + "TBPGraph_EndEI(TBPGraph self) -> TBPGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetEI", _wrap_TBPGraph_GetEI, METH_VARARGS, (char *)"\n" + "TBPGraph_GetEI(TBPGraph self, int const & LeftNId, int const & RightNId) -> TBPGraph::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " LeftNId: int const &\n" + " RightNId: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_GetRndNId", _wrap_TBPGraph_GetRndNId, METH_VARARGS, (char *)"\n" + "GetRndNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TBPGraph_GetRndNId(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetRndLNId", _wrap_TBPGraph_GetRndLNId, METH_VARARGS, (char *)"\n" + "GetRndLNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TBPGraph_GetRndLNId(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetRndRNId", _wrap_TBPGraph_GetRndRNId, METH_VARARGS, (char *)"\n" + "GetRndRNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TBPGraph_GetRndRNId(TBPGraph self) -> int\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetRndNI", _wrap_TBPGraph_GetRndNI, METH_VARARGS, (char *)"\n" + "GetRndNI(TRnd Rnd=Rnd) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TBPGraph_GetRndNI(TBPGraph self) -> TBPGraph::TNodeI\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetNIdV", _wrap_TBPGraph_GetNIdV, METH_VARARGS, (char *)"\n" + "TBPGraph_GetNIdV(TBPGraph self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TBPGraph_GetLNIdV", _wrap_TBPGraph_GetLNIdV, METH_VARARGS, (char *)"\n" + "TBPGraph_GetLNIdV(TBPGraph self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TBPGraph_GetRNIdV", _wrap_TBPGraph_GetRNIdV, METH_VARARGS, (char *)"\n" + "TBPGraph_GetRNIdV(TBPGraph self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TBPGraph_Empty", (PyCFunction)_wrap_TBPGraph_Empty, METH_O, (char *)"\n" + "TBPGraph_Empty(TBPGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_Clr", (PyCFunction)_wrap_TBPGraph_Clr, METH_O, (char *)"\n" + "TBPGraph_Clr(TBPGraph self)\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + "\n" + ""}, + { (char *)"TBPGraph_Reserve", _wrap_TBPGraph_Reserve, METH_VARARGS, (char *)"\n" + "TBPGraph_Reserve(TBPGraph self, int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TBPGraph_Defrag", _wrap_TBPGraph_Defrag, METH_VARARGS, (char *)"\n" + "Defrag(bool const & OnlyNodeLinks=False)\n" + "\n" + "Parameters:\n" + " OnlyNodeLinks: bool const &\n" + "\n" + "TBPGraph_Defrag(TBPGraph self)\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + "\n" + ""}, + { (char *)"TBPGraph_IsOk", _wrap_TBPGraph_IsOk, METH_VARARGS, (char *)"\n" + "IsOk(bool const & ThrowExcept=True) -> bool\n" + "\n" + "Parameters:\n" + " ThrowExcept: bool const &\n" + "\n" + "TBPGraph_IsOk(TBPGraph self) -> bool\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_Dump", _wrap_TBPGraph_Dump, METH_VARARGS, (char *)"\n" + "Dump(FILE * OutF=stdout)\n" + "\n" + "Parameters:\n" + " OutF: FILE *\n" + "\n" + "TBPGraph_Dump(TBPGraph self)\n" + "\n" + "Parameters:\n" + " self: TBPGraph const *\n" + "\n" + ""}, + { (char *)"TBPGraph_GetSmallGraph", (PyCFunction)_wrap_TBPGraph_GetSmallGraph, METH_NOARGS, (char *)"TBPGraph_GetSmallGraph() -> PBPGraph"}, + { (char *)"delete_TBPGraph", (PyCFunction)_wrap_delete_TBPGraph, METH_O, (char *)"\n" + "delete_TBPGraph(TBPGraph self)\n" + "\n" + "Parameters:\n" + " self: TBPGraph *\n" + "\n" + ""}, + { (char *)"TBPGraph_swigregister", TBPGraph_swigregister, METH_VARARGS, NULL}, + { (char *)"TBPGraph_swiginit", TBPGraph_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNGraphMtx", _wrap_new_TNGraphMtx, METH_VARARGS, (char *)"\n" + "TNGraphMtx(PNGraph const & GraphPt)\n" + "\n" + "Parameters:\n" + " GraphPt: PNGraph const &\n" + "\n" + "new_TNGraphMtx(TNGraphMtx GraphMtx) -> TNGraphMtx\n" + "\n" + "Parameters:\n" + " GraphMtx: TNGraphMtx const &\n" + "\n" + ""}, + { (char *)"TNGraphMtx_PGetRows", (PyCFunction)_wrap_TNGraphMtx_PGetRows, METH_O, (char *)"\n" + "TNGraphMtx_PGetRows(TNGraphMtx self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphMtx const *\n" + "\n" + ""}, + { (char *)"TNGraphMtx_PGetCols", (PyCFunction)_wrap_TNGraphMtx_PGetCols, METH_O, (char *)"\n" + "TNGraphMtx_PGetCols(TNGraphMtx self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphMtx const *\n" + "\n" + ""}, + { (char *)"TNGraphMtx_PMultiply", _wrap_TNGraphMtx_PMultiply, METH_VARARGS, (char *)"\n" + "PMultiply(TFltVV const & B, int ColId, TFltV & Result)\n" + "\n" + "Parameters:\n" + " B: TFltVV const &\n" + " ColId: int\n" + " Result: TFltV &\n" + "\n" + "TNGraphMtx_PMultiply(TNGraphMtx self, TFltV const & Vec, TFltV & Result)\n" + "\n" + "Parameters:\n" + " self: TNGraphMtx const *\n" + " Vec: TFltV const &\n" + " Result: TFltV &\n" + "\n" + ""}, + { (char *)"TNGraphMtx_PMultiplyT", _wrap_TNGraphMtx_PMultiplyT, METH_VARARGS, (char *)"\n" + "PMultiplyT(TFltVV const & B, int ColId, TFltV & Result)\n" + "\n" + "Parameters:\n" + " B: TFltVV const &\n" + " ColId: int\n" + " Result: TFltV &\n" + "\n" + "TNGraphMtx_PMultiplyT(TNGraphMtx self, TFltV const & Vec, TFltV & Result)\n" + "\n" + "Parameters:\n" + " self: TNGraphMtx const *\n" + " Vec: TFltV const &\n" + " Result: TFltV &\n" + "\n" + ""}, + { (char *)"delete_TNGraphMtx", (PyCFunction)_wrap_delete_TNGraphMtx, METH_O, (char *)"\n" + "delete_TNGraphMtx(TNGraphMtx self)\n" + "\n" + "Parameters:\n" + " self: TNGraphMtx *\n" + "\n" + ""}, + { (char *)"TNGraphMtx_swigregister", TNGraphMtx_swigregister, METH_VARARGS, NULL}, + { (char *)"TNGraphMtx_swiginit", TNGraphMtx_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TUNGraphMtx", _wrap_new_TUNGraphMtx, METH_VARARGS, (char *)"\n" + "TUNGraphMtx(PUNGraph const & GraphPt)\n" + "\n" + "Parameters:\n" + " GraphPt: PUNGraph const &\n" + "\n" + "new_TUNGraphMtx(TUNGraphMtx GraphMtx) -> TUNGraphMtx\n" + "\n" + "Parameters:\n" + " GraphMtx: TUNGraphMtx const &\n" + "\n" + ""}, + { (char *)"TUNGraphMtx_PGetRows", (PyCFunction)_wrap_TUNGraphMtx_PGetRows, METH_O, (char *)"\n" + "TUNGraphMtx_PGetRows(TUNGraphMtx self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphMtx const *\n" + "\n" + ""}, + { (char *)"TUNGraphMtx_PGetCols", (PyCFunction)_wrap_TUNGraphMtx_PGetCols, METH_O, (char *)"\n" + "TUNGraphMtx_PGetCols(TUNGraphMtx self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphMtx const *\n" + "\n" + ""}, + { (char *)"TUNGraphMtx_PMultiply", _wrap_TUNGraphMtx_PMultiply, METH_VARARGS, (char *)"\n" + "PMultiply(TFltVV const & B, int ColId, TFltV & Result)\n" + "\n" + "Parameters:\n" + " B: TFltVV const &\n" + " ColId: int\n" + " Result: TFltV &\n" + "\n" + "TUNGraphMtx_PMultiply(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)\n" + "\n" + "Parameters:\n" + " self: TUNGraphMtx const *\n" + " Vec: TFltV const &\n" + " Result: TFltV &\n" + "\n" + ""}, + { (char *)"TUNGraphMtx_PMultiplyT", _wrap_TUNGraphMtx_PMultiplyT, METH_VARARGS, (char *)"\n" + "PMultiplyT(TFltVV const & B, int ColId, TFltV & Result)\n" + "\n" + "Parameters:\n" + " B: TFltVV const &\n" + " ColId: int\n" + " Result: TFltV &\n" + "\n" + "TUNGraphMtx_PMultiplyT(TUNGraphMtx self, TFltV const & Vec, TFltV & Result)\n" + "\n" + "Parameters:\n" + " self: TUNGraphMtx const *\n" + " Vec: TFltV const &\n" + " Result: TFltV &\n" + "\n" + ""}, + { (char *)"delete_TUNGraphMtx", (PyCFunction)_wrap_delete_TUNGraphMtx, METH_O, (char *)"\n" + "delete_TUNGraphMtx(TUNGraphMtx self)\n" + "\n" + "Parameters:\n" + " self: TUNGraphMtx *\n" + "\n" + ""}, + { (char *)"TUNGraphMtx_swigregister", TUNGraphMtx_swigregister, METH_VARARGS, NULL}, + { (char *)"TUNGraphMtx_swiginit", TUNGraphMtx_swiginit, METH_VARARGS, NULL}, + { (char *)"GetSngVals", _wrap_GetSngVals, METH_VARARGS, (char *)"\n" + "GetSngVals(PNGraph const & Graph, int const & SngVals, TFltV & SngValV)\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + " SngVals: int const &\n" + " SngValV: TFltV &\n" + "\n" + ""}, + { (char *)"GetSngVec", _wrap_GetSngVec, METH_VARARGS, (char *)"\n" + "GetSngVec(PNGraph const & Graph, TFltV & LeftSV, TFltV & RightSV)\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + " LeftSV: TFltV &\n" + " RightSV: TFltV &\n" + "\n" + "GetSngVec(PNGraph const & Graph, int const & SngVecs, TFltV & SngValV, TVec< TFltV > & LeftSV, \n" + " TVec< TFltV > & RightSV)\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + " SngVecs: int const &\n" + " SngValV: TFltV &\n" + " LeftSV: TVec< TFltV > &\n" + " RightSV: TVec< TFltV > &\n" + "\n" + ""}, + { (char *)"GetEigVals", _wrap_GetEigVals, METH_VARARGS, (char *)"\n" + "GetEigVals(PUNGraph const & Graph, int const & EigVals, TFltV & EigValV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " EigVals: int const &\n" + " EigValV: TFltV &\n" + "\n" + ""}, + { (char *)"GetEigVec", _wrap_GetEigVec, METH_VARARGS, (char *)"\n" + "GetEigVec(PUNGraph const & Graph, TFltV & EigVecV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " EigVecV: TFltV &\n" + "\n" + "GetEigVec(PUNGraph const & Graph, int const & EigVecs, TFltV & EigValV, TVec< TFltV > & EigVecV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " EigVecs: int const &\n" + " EigValV: TFltV &\n" + " EigVecV: TVec< TFltV > &\n" + "\n" + ""}, + { (char *)"GetInvParticipRat", _wrap_GetInvParticipRat, METH_VARARGS, (char *)"\n" + "GetInvParticipRat(PUNGraph const & Graph, int MaxEigVecs, int TimeLimit, TFltPrV & EigValIprV)\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " MaxEigVecs: int\n" + " TimeLimit: int\n" + " EigValIprV: TFltPrV &\n" + "\n" + ""}, + { (char *)"GetInvParticipRatEig", (PyCFunction)_wrap_GetInvParticipRatEig, METH_O, (char *)"\n" + "GetInvParticipRatEig(TFltV const & EigVec) -> double\n" + "\n" + "Parameters:\n" + " EigVec: TFltV const &\n" + "\n" + ""}, + { (char *)"LoadDyNet", (PyCFunction)_wrap_LoadDyNet, METH_O, (char *)"\n" + "LoadDyNet(TStr FNm) -> PNGraph\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"LoadDyNetGraphV", (PyCFunction)_wrap_LoadDyNetGraphV, METH_O, (char *)"\n" + "LoadDyNetGraphV(TStr FNm) -> TVec< PNGraph >\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"GVizDoLayout", _wrap_GVizDoLayout, METH_VARARGS, (char *)"\n" + "GVizDoLayout(TStr GraphInFNm, TStr OutFNm, TGVizLayout const & Layout)\n" + "\n" + "Parameters:\n" + " GraphInFNm: TStr const &\n" + " OutFNm: TStr\n" + " Layout: TGVizLayout const &\n" + "\n" + ""}, + { (char *)"GVizGetLayoutStr", (PyCFunction)_wrap_GVizGetLayoutStr, METH_O, (char *)"\n" + "GVizGetLayoutStr(TGVizLayout const & Layout) -> TStr\n" + "\n" + "Parameters:\n" + " Layout: TGVizLayout const &\n" + "\n" + ""}, + { (char *)"new_TBigStrPool", _wrap_new_TBigStrPool, METH_VARARGS, (char *)"\n" + "TBigStrPool(TSize MxBfLen=0, uint _GrowBy=16*1024*1024)\n" + "\n" + "Parameters:\n" + " MxBfLen: TSize\n" + " _GrowBy: uint\n" + "\n" + "TBigStrPool(TSize MxBfLen=0)\n" + "\n" + "Parameters:\n" + " MxBfLen: TSize\n" + "\n" + "TBigStrPool()\n" + "TBigStrPool(TSIn SIn, bool LoadCompact=True)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " LoadCompact: bool\n" + "\n" + "TBigStrPool(TSIn SIn)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "new_TBigStrPool(TBigStrPool Pool) -> TBigStrPool\n" + "\n" + "Parameters:\n" + " Pool: TBigStrPool const &\n" + "\n" + ""}, + { (char *)"delete_TBigStrPool", (PyCFunction)_wrap_delete_TBigStrPool, METH_O, (char *)"\n" + "delete_TBigStrPool(TBigStrPool self)\n" + "\n" + "Parameters:\n" + " self: TBigStrPool *\n" + "\n" + ""}, + { (char *)"TBigStrPool_New", _wrap_TBigStrPool_New, METH_VARARGS, (char *)"\n" + "New(TSize _MxBfLen=0, uint _GrowBy=16*1024*1024) -> PBigStrPool\n" + "\n" + "Parameters:\n" + " _MxBfLen: TSize\n" + " _GrowBy: uint\n" + "\n" + "New(TSize _MxBfLen=0) -> PBigStrPool\n" + "\n" + "Parameters:\n" + " _MxBfLen: TSize\n" + "\n" + "New() -> PBigStrPool\n" + "New(TSIn SIn) -> PBigStrPool\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "TBigStrPool_New(TStr fileName) -> PBigStrPool\n" + "\n" + "Parameters:\n" + " fileName: TStr const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_Load", _wrap_TBigStrPool_Load, METH_VARARGS, (char *)"\n" + "Load(TSIn SIn, bool LoadCompacted=True) -> PBigStrPool\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " LoadCompacted: bool\n" + "\n" + "TBigStrPool_Load(TSIn SIn) -> PBigStrPool\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TBigStrPool_Save", _wrap_TBigStrPool_Save, METH_VARARGS, (char *)"\n" + "Save(TSOut SOut)\n" + "\n" + "Parameters:\n" + " SOut: TSOut &\n" + "\n" + "TBigStrPool_Save(TBigStrPool self, TStr fileName)\n" + "\n" + "Parameters:\n" + " self: TBigStrPool *\n" + " fileName: TStr const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_GetStrs", (PyCFunction)_wrap_TBigStrPool_GetStrs, METH_O, (char *)"\n" + "TBigStrPool_GetStrs(TBigStrPool self) -> int\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + "\n" + ""}, + { (char *)"TBigStrPool_Len", (PyCFunction)_wrap_TBigStrPool_Len, METH_O, (char *)"\n" + "TBigStrPool_Len(TBigStrPool self) -> TSize\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + "\n" + ""}, + { (char *)"TBigStrPool_Size", (PyCFunction)_wrap_TBigStrPool_Size, METH_O, (char *)"\n" + "TBigStrPool_Size(TBigStrPool self) -> TSize\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + "\n" + ""}, + { (char *)"TBigStrPool_Empty", (PyCFunction)_wrap_TBigStrPool_Empty, METH_O, (char *)"\n" + "TBigStrPool_Empty(TBigStrPool self) -> bool\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + "\n" + ""}, + { (char *)"TBigStrPool___call__", (PyCFunction)_wrap_TBigStrPool___call__, METH_O, (char *)"\n" + "TBigStrPool___call__(TBigStrPool self) -> char *\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + "\n" + ""}, + { (char *)"TBigStrPool_AddStr", _wrap_TBigStrPool_AddStr, METH_VARARGS, (char *)"\n" + "AddStr(char const * Str, uint Len) -> int\n" + "\n" + "Parameters:\n" + " Str: char const *\n" + " Len: uint\n" + "\n" + "AddStr(char const * Str) -> int\n" + "\n" + "Parameters:\n" + " Str: char const *\n" + "\n" + "TBigStrPool_AddStr(TBigStrPool self, TStr Str) -> int\n" + "\n" + "Parameters:\n" + " self: TBigStrPool *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_GetCStr", _wrap_TBigStrPool_GetCStr, METH_VARARGS, (char *)"\n" + "TBigStrPool_GetCStr(TBigStrPool self, int const & StrId) -> char const *\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + " StrId: int const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_GetStrFromOffset", _wrap_TBigStrPool_GetStrFromOffset, METH_VARARGS, (char *)"\n" + "TBigStrPool_GetStrFromOffset(TBigStrPool self, TSize const & Offset) -> TStr\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + " Offset: TSize const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_GetCStrFromOffset", _wrap_TBigStrPool_GetCStrFromOffset, METH_VARARGS, (char *)"\n" + "TBigStrPool_GetCStrFromOffset(TBigStrPool self, TSize const & Offset) -> char const *\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + " Offset: TSize const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_Clr", _wrap_TBigStrPool_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool DoDel=False)\n" + "\n" + "Parameters:\n" + " DoDel: bool\n" + "\n" + "TBigStrPool_Clr(TBigStrPool self)\n" + "\n" + "Parameters:\n" + " self: TBigStrPool *\n" + "\n" + ""}, + { (char *)"TBigStrPool_Cmp", _wrap_TBigStrPool_Cmp, METH_VARARGS, (char *)"\n" + "TBigStrPool_Cmp(TBigStrPool self, int const & StrId, char const * Str) -> int\n" + "\n" + "Parameters:\n" + " self: TBigStrPool const *\n" + " StrId: int const &\n" + " Str: char const *\n" + "\n" + ""}, + { (char *)"TBigStrPool_GetPrimHashCd", _wrap_TBigStrPool_GetPrimHashCd, METH_VARARGS, (char *)"\n" + "GetPrimHashCd(char const * CStr) -> int\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TBigStrPool_GetPrimHashCd(TBigStrPool self, int const & StrId) -> int\n" + "\n" + "Parameters:\n" + " self: TBigStrPool *\n" + " StrId: int const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_GetSecHashCd", _wrap_TBigStrPool_GetSecHashCd, METH_VARARGS, (char *)"\n" + "GetSecHashCd(char const * CStr) -> int\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TBigStrPool_GetSecHashCd(TBigStrPool self, int const & StrId) -> int\n" + "\n" + "Parameters:\n" + " self: TBigStrPool *\n" + " StrId: int const &\n" + "\n" + ""}, + { (char *)"TBigStrPool_swigregister", TBigStrPool_swigregister, METH_VARARGS, NULL}, + { (char *)"TBigStrPool_swiginit", TBigStrPool_swiginit, METH_VARARGS, NULL}, + { (char *)"TStrHashF_OldGLib_GetPrimHashCd", _wrap_TStrHashF_OldGLib_GetPrimHashCd, METH_VARARGS, (char *)"\n" + "GetPrimHashCd(char const * p) -> int\n" + "\n" + "Parameters:\n" + " p: char const *\n" + "\n" + "TStrHashF_OldGLib_GetPrimHashCd(TStr s) -> int\n" + "\n" + "Parameters:\n" + " s: TStr const &\n" + "\n" + ""}, + { (char *)"TStrHashF_OldGLib_GetSecHashCd", _wrap_TStrHashF_OldGLib_GetSecHashCd, METH_VARARGS, (char *)"\n" + "GetSecHashCd(char const * p) -> int\n" + "\n" + "Parameters:\n" + " p: char const *\n" + "\n" + "TStrHashF_OldGLib_GetSecHashCd(TStr s) -> int\n" + "\n" + "Parameters:\n" + " s: TStr const &\n" + "\n" + ""}, + { (char *)"new_TStrHashF_OldGLib", (PyCFunction)_wrap_new_TStrHashF_OldGLib, METH_NOARGS, (char *)"new_TStrHashF_OldGLib() -> TStrHashF_OldGLib"}, + { (char *)"delete_TStrHashF_OldGLib", (PyCFunction)_wrap_delete_TStrHashF_OldGLib, METH_O, (char *)"\n" + "delete_TStrHashF_OldGLib(TStrHashF_OldGLib self)\n" + "\n" + "Parameters:\n" + " self: TStrHashF_OldGLib *\n" + "\n" + ""}, + { (char *)"TStrHashF_OldGLib_swigregister", TStrHashF_OldGLib_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrHashF_OldGLib_swiginit", TStrHashF_OldGLib_swiginit, METH_VARARGS, NULL}, + { (char *)"TStrHashF_Md5_GetPrimHashCd", _wrap_TStrHashF_Md5_GetPrimHashCd, METH_VARARGS, (char *)"\n" + "GetPrimHashCd(char const * p) -> int\n" + "\n" + "Parameters:\n" + " p: char const *\n" + "\n" + "TStrHashF_Md5_GetPrimHashCd(TStr s) -> int\n" + "\n" + "Parameters:\n" + " s: TStr const &\n" + "\n" + ""}, + { (char *)"TStrHashF_Md5_GetSecHashCd", _wrap_TStrHashF_Md5_GetSecHashCd, METH_VARARGS, (char *)"\n" + "GetSecHashCd(char const * p) -> int\n" + "\n" + "Parameters:\n" + " p: char const *\n" + "\n" + "TStrHashF_Md5_GetSecHashCd(TStr s) -> int\n" + "\n" + "Parameters:\n" + " s: TStr const &\n" + "\n" + ""}, + { (char *)"new_TStrHashF_Md5", (PyCFunction)_wrap_new_TStrHashF_Md5, METH_NOARGS, (char *)"new_TStrHashF_Md5() -> TStrHashF_Md5"}, + { (char *)"delete_TStrHashF_Md5", (PyCFunction)_wrap_delete_TStrHashF_Md5, METH_O, (char *)"\n" + "delete_TStrHashF_Md5(TStrHashF_Md5 self)\n" + "\n" + "Parameters:\n" + " self: TStrHashF_Md5 *\n" + "\n" + ""}, + { (char *)"TStrHashF_Md5_swigregister", TStrHashF_Md5_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrHashF_Md5_swiginit", TStrHashF_Md5_swiginit, METH_VARARGS, NULL}, + { (char *)"TStrHashF_DJB_GetPrimHashCd", _wrap_TStrHashF_DJB_GetPrimHashCd, METH_VARARGS, (char *)"\n" + "GetPrimHashCd(char const * p) -> int\n" + "\n" + "Parameters:\n" + " p: char const *\n" + "\n" + "TStrHashF_DJB_GetPrimHashCd(TStr s) -> int\n" + "\n" + "Parameters:\n" + " s: TStr const &\n" + "\n" + ""}, + { (char *)"TStrHashF_DJB_GetSecHashCd", _wrap_TStrHashF_DJB_GetSecHashCd, METH_VARARGS, (char *)"\n" + "GetSecHashCd(char const * p) -> int\n" + "\n" + "Parameters:\n" + " p: char const *\n" + "\n" + "TStrHashF_DJB_GetSecHashCd(TStr s) -> int\n" + "\n" + "Parameters:\n" + " s: TStr const &\n" + "\n" + ""}, + { (char *)"new_TStrHashF_DJB", (PyCFunction)_wrap_new_TStrHashF_DJB, METH_NOARGS, (char *)"new_TStrHashF_DJB() -> TStrHashF_DJB"}, + { (char *)"delete_TStrHashF_DJB", (PyCFunction)_wrap_delete_TStrHashF_DJB, METH_O, (char *)"\n" + "delete_TStrHashF_DJB(TStrHashF_DJB self)\n" + "\n" + "Parameters:\n" + " self: TStrHashF_DJB *\n" + "\n" + ""}, + { (char *)"TStrHashF_DJB_swigregister", TStrHashF_DJB_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrHashF_DJB_swiginit", TStrHashF_DJB_swiginit, METH_VARARGS, NULL}, + { (char *)"GenRndBipart", _wrap_GenRndBipart, METH_VARARGS, (char *)"\n" + "GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges, TRnd Rnd=Rnd) -> PBPGraph\n" + "\n" + "Parameters:\n" + " LeftNodes: int const &\n" + " RightNodes: int const &\n" + " Edges: int const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRndBipart(int const & LeftNodes, int const & RightNodes, int const & Edges) -> PBPGraph\n" + "\n" + "Parameters:\n" + " LeftNodes: int const &\n" + " RightNodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"GenRndDegK", _wrap_GenRndDegK, METH_VARARGS, (char *)"\n" + "GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " NodeDeg: int const &\n" + " NSwitch: int const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRndDegK(int const & Nodes, int const & NodeDeg, int const & NSwitch=100) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " NodeDeg: int const &\n" + " NSwitch: int const &\n" + "\n" + "GenRndDegK(int const & Nodes, int const & NodeDeg) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " NodeDeg: int const &\n" + "\n" + ""}, + { (char *)"GenRndPowerLaw", _wrap_GenRndPowerLaw, METH_VARARGS, (char *)"\n" + "GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " PowerExp: double const &\n" + " ConfModel: bool const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRndPowerLaw(int const & Nodes, double const & PowerExp, bool const & ConfModel=True) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " PowerExp: double const &\n" + " ConfModel: bool const &\n" + "\n" + "GenRndPowerLaw(int const & Nodes, double const & PowerExp) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " PowerExp: double const &\n" + "\n" + ""}, + { (char *)"GenDegSeq", _wrap_GenDegSeq, METH_VARARGS, (char *)"\n" + "GenDegSeq(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " DegSeqV: TIntV const &\n" + " Rnd: TRnd &\n" + "\n" + "GenDegSeq(TIntV DegSeqV) -> PUNGraph\n" + "\n" + "Parameters:\n" + " DegSeqV: TIntV const &\n" + "\n" + ""}, + { (char *)"GenPrefAttach", _wrap_GenPrefAttach, METH_VARARGS, (char *)"\n" + "GenPrefAttach(int const & Nodes, int const & NodeOutDeg, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " NodeOutDeg: int const &\n" + " Rnd: TRnd &\n" + "\n" + "GenPrefAttach(int const & Nodes, int const & NodeOutDeg) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " NodeOutDeg: int const &\n" + "\n" + ""}, + { (char *)"GenGeoPrefAttach", _wrap_GenGeoPrefAttach, METH_VARARGS, (char *)"\n" + "GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " OutDeg: int const &\n" + " Beta: double const &\n" + " Rnd: TRnd &\n" + "\n" + "GenGeoPrefAttach(int const & Nodes, int const & OutDeg, double const & Beta) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " OutDeg: int const &\n" + " Beta: double const &\n" + "\n" + ""}, + { (char *)"GenSmallWorld", _wrap_GenSmallWorld, METH_VARARGS, (char *)"\n" + "GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " NodeOutDeg: int const &\n" + " RewireProb: double const &\n" + " Rnd: TRnd &\n" + "\n" + "GenSmallWorld(int const & Nodes, int const & NodeOutDeg, double const & RewireProb) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " NodeOutDeg: int const &\n" + " RewireProb: double const &\n" + "\n" + ""}, + { (char *)"GenForestFire", _wrap_GenForestFire, METH_VARARGS, (char *)"\n" + "GenForestFire(int const & Nodes, double const & FwdProb, double const & BckProb) -> PNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " FwdProb: double const &\n" + " BckProb: double const &\n" + "\n" + ""}, + { (char *)"GenCopyModel", _wrap_GenCopyModel, METH_VARARGS, (char *)"\n" + "GenCopyModel(int const & Nodes, double const & Beta, TRnd Rnd=Rnd) -> PNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Beta: double const &\n" + " Rnd: TRnd &\n" + "\n" + "GenCopyModel(int const & Nodes, double const & Beta) -> PNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Beta: double const &\n" + "\n" + ""}, + { (char *)"GenRMat", _wrap_GenRMat, METH_VARARGS, (char *)"\n" + "GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C, \n" + " TRnd Rnd=Rnd) -> PNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + " A: double const &\n" + " B: double const &\n" + " C: double const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRMat(int const & Nodes, int const & Edges, double const & A, double const & B, double const & C) -> PNGraph\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + " A: double const &\n" + " B: double const &\n" + " C: double const &\n" + "\n" + ""}, + { (char *)"GenRMatEpinions", (PyCFunction)_wrap_GenRMatEpinions, METH_NOARGS, (char *)"GenRMatEpinions() -> PNGraph"}, + { (char *)"GenRewire", _wrap_GenRewire, METH_VARARGS, (char *)"\n" + "GenRewire(PUNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NSwitch: int const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRewire(PUNGraph const & Graph, int const & NSwitch=100) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NSwitch: int const &\n" + "\n" + "GenRewire(PUNGraph const & Graph) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + "\n" + "GenRewire(PNGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PNGraph\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + " NSwitch: int const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRewire(PNGraph const & Graph, int const & NSwitch=100) -> PNGraph\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + " NSwitch: int const &\n" + "\n" + "GenRewire(PNGraph const & Graph) -> PNGraph\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + "\n" + "GenRewire(PBPGraph const & Graph, int const & NSwitch=100, TRnd Rnd=Rnd) -> PBPGraph\n" + "\n" + "Parameters:\n" + " Graph: PBPGraph const &\n" + " NSwitch: int const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRewire(PBPGraph const & Graph, int const & NSwitch=100) -> PBPGraph\n" + "\n" + "Parameters:\n" + " Graph: PBPGraph const &\n" + " NSwitch: int const &\n" + "\n" + "GenRewire(PBPGraph const & Graph) -> PBPGraph\n" + "\n" + "Parameters:\n" + " Graph: PBPGraph const &\n" + "\n" + ""}, + { (char *)"GenConfModel", _wrap_GenConfModel, METH_VARARGS, (char *)"\n" + "GenConfModel(TIntV DegSeqV, TRnd Rnd=Rnd) -> PUNGraph\n" + "\n" + "Parameters:\n" + " DegSeqV: TIntV const &\n" + " Rnd: TRnd &\n" + "\n" + "GenConfModel(TIntV DegSeqV) -> PUNGraph\n" + "\n" + "Parameters:\n" + " DegSeqV: TIntV const &\n" + "\n" + "GenConfModel(PUNGraph const & G) -> PUNGraph\n" + "\n" + "Parameters:\n" + " G: PUNGraph const &\n" + "\n" + ""}, + { (char *)"GetSubGraph", _wrap_GetSubGraph, METH_VARARGS, (char *)"\n" + "GetSubGraph(PUNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdV: TIntV const &\n" + " RenumberNodes: bool const &\n" + "\n" + "GetSubGraph(PUNGraph const & Graph, TIntV NIdV) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " NIdV: TIntV const &\n" + "\n" + "GetSubGraph(PNGraph const & Graph, TIntV NIdV, bool const & RenumberNodes=False) -> PNGraph\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + " NIdV: TIntV const &\n" + " RenumberNodes: bool const &\n" + "\n" + "GetSubGraph(PNGraph const & Graph, TIntV NIdV) -> PNGraph\n" + "\n" + "Parameters:\n" + " Graph: PNGraph const &\n" + " NIdV: TIntV const &\n" + "\n" + ""}, + { (char *)"TGUtil_GetCdf", _wrap_TGUtil_GetCdf, METH_VARARGS, (char *)"\n" + "GetCdf(TIntPrV const & PdfV, TIntPrV & CdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TIntPrV const &\n" + " CdfV: TIntPrV &\n" + "\n" + "GetCdf(TFltPrV const & PdfV, TFltPrV & CdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TFltPrV const &\n" + " CdfV: TFltPrV &\n" + "\n" + "GetCdf(TIntFltKdV const & PdfV, TIntFltKdV & CdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TIntFltKdV const &\n" + " CdfV: TIntFltKdV &\n" + "\n" + "GetCdf(TIntPrV const & PdfV) -> TIntPrV\n" + "\n" + "Parameters:\n" + " PdfV: TIntPrV const &\n" + "\n" + "TGUtil_GetCdf(TFltPrV const & PdfV) -> TFltPrV\n" + "\n" + "Parameters:\n" + " PdfV: TFltPrV const &\n" + "\n" + ""}, + { (char *)"TGUtil_GetCCdf", _wrap_TGUtil_GetCCdf, METH_VARARGS, (char *)"\n" + "GetCCdf(TIntPrV const & PdfV, TIntPrV & CCdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TIntPrV const &\n" + " CCdfV: TIntPrV &\n" + "\n" + "GetCCdf(TFltPrV const & PdfV, TFltPrV & CCdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TFltPrV const &\n" + " CCdfV: TFltPrV &\n" + "\n" + "GetCCdf(TIntFltKdV const & PdfV, TIntFltKdV & CCdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TIntFltKdV const &\n" + " CCdfV: TIntFltKdV &\n" + "\n" + "GetCCdf(TIntPrV const & PdfV) -> TIntPrV\n" + "\n" + "Parameters:\n" + " PdfV: TIntPrV const &\n" + "\n" + "TGUtil_GetCCdf(TFltPrV const & PdfV) -> TFltPrV\n" + "\n" + "Parameters:\n" + " PdfV: TFltPrV const &\n" + "\n" + ""}, + { (char *)"TGUtil_GetPdf", _wrap_TGUtil_GetPdf, METH_VARARGS, (char *)"\n" + "GetPdf(TIntPrV const & CdfV, TIntPrV & PdfV)\n" + "\n" + "Parameters:\n" + " CdfV: TIntPrV const &\n" + " PdfV: TIntPrV &\n" + "\n" + "GetPdf(TFltPrV const & CdfV, TFltPrV & PdfV)\n" + "\n" + "Parameters:\n" + " CdfV: TFltPrV const &\n" + " PdfV: TFltPrV &\n" + "\n" + "TGUtil_GetPdf(TIntFltKdV const & CdfV, TIntFltKdV & PdfV)\n" + "\n" + "Parameters:\n" + " CdfV: TIntFltKdV const &\n" + " PdfV: TIntFltKdV &\n" + "\n" + ""}, + { (char *)"TGUtil_Normalize", _wrap_TGUtil_Normalize, METH_VARARGS, (char *)"\n" + "Normalize(TFltPrV & PdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TFltPrV &\n" + "\n" + "TGUtil_Normalize(TIntFltKdV & PdfV)\n" + "\n" + "Parameters:\n" + " PdfV: TIntFltKdV &\n" + "\n" + ""}, + { (char *)"TGUtil_MakeExpBins", _wrap_TGUtil_MakeExpBins, METH_VARARGS, (char *)"\n" + "MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)\n" + "\n" + "Parameters:\n" + " XYValV: TFltPrV const &\n" + " ExpXYValV: TFltPrV &\n" + " BinFactor: double const &\n" + " MinYVal: double const &\n" + "\n" + "MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV, double const & BinFactor=2)\n" + "\n" + "Parameters:\n" + " XYValV: TFltPrV const &\n" + " ExpXYValV: TFltPrV &\n" + " BinFactor: double const &\n" + "\n" + "MakeExpBins(TFltPrV const & XYValV, TFltPrV & ExpXYValV)\n" + "\n" + "Parameters:\n" + " XYValV: TFltPrV const &\n" + " ExpXYValV: TFltPrV &\n" + "\n" + "MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2, double const & MinYVal=1)\n" + "\n" + "Parameters:\n" + " XYValV: TFltKdV const &\n" + " ExpXYValV: TFltKdV &\n" + " BinFactor: double const &\n" + " MinYVal: double const &\n" + "\n" + "MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV, double const & BinFactor=2)\n" + "\n" + "Parameters:\n" + " XYValV: TFltKdV const &\n" + " ExpXYValV: TFltKdV &\n" + " BinFactor: double const &\n" + "\n" + "MakeExpBins(TFltKdV const & XYValV, TFltKdV & ExpXYValV)\n" + "\n" + "Parameters:\n" + " XYValV: TFltKdV const &\n" + " ExpXYValV: TFltKdV &\n" + "\n" + "MakeExpBins(TFltV const & YValV, TFltV & ExpYValV, double const & BinFactor=1.01)\n" + "\n" + "Parameters:\n" + " YValV: TFltV const &\n" + " ExpYValV: TFltV &\n" + " BinFactor: double const &\n" + "\n" + "MakeExpBins(TFltV const & YValV, TFltV & ExpYValV)\n" + "\n" + "Parameters:\n" + " YValV: TFltV const &\n" + " ExpYValV: TFltV &\n" + "\n" + "MakeExpBins(TIntV YValV, TIntV ExpYValV, double const & BinFactor=1.01)\n" + "\n" + "Parameters:\n" + " YValV: TIntV const &\n" + " ExpYValV: TIntV &\n" + " BinFactor: double const &\n" + "\n" + "TGUtil_MakeExpBins(TIntV YValV, TIntV ExpYValV)\n" + "\n" + "Parameters:\n" + " YValV: TIntV const &\n" + " ExpYValV: TIntV &\n" + "\n" + ""}, + { (char *)"new_TGUtil", (PyCFunction)_wrap_new_TGUtil, METH_NOARGS, (char *)"new_TGUtil() -> TGUtil"}, + { (char *)"delete_TGUtil", (PyCFunction)_wrap_delete_TGUtil, METH_O, (char *)"\n" + "delete_TGUtil(TGUtil self)\n" + "\n" + "Parameters:\n" + " self: TGUtil *\n" + "\n" + ""}, + { (char *)"TGUtil_swigregister", TGUtil_swigregister, METH_VARARGS, NULL}, + { (char *)"TGUtil_swiginit", TGUtil_swiginit, METH_VARARGS, NULL}, + { (char *)"TStrUtil_GetXmlTagVal", _wrap_TStrUtil_GetXmlTagVal, METH_VARARGS, (char *)"\n" + "TStrUtil_GetXmlTagVal(TXmlLx & XmlLx, TChA TagNm) -> TChA\n" + "\n" + "Parameters:\n" + " XmlLx: TXmlLx &\n" + " TagNm: TChA const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetXmlTagNmVal", _wrap_TStrUtil_GetXmlTagNmVal, METH_VARARGS, (char *)"\n" + "TStrUtil_GetXmlTagNmVal(TXmlLx & XmlLx, TChA TagNm, TChA TagVal)\n" + "\n" + "Parameters:\n" + " XmlLx: TXmlLx &\n" + " TagNm: TChA &\n" + " TagVal: TChA &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetXmlTagNmVal2", _wrap_TStrUtil_GetXmlTagNmVal2, METH_VARARGS, (char *)"\n" + "TStrUtil_GetXmlTagNmVal2(TXmlLx & XmlLx, TChA TagNm, TChA TagVal, bool const & TakeTagNms) -> bool\n" + "\n" + "Parameters:\n" + " XmlLx: TXmlLx &\n" + " TagNm: TChA &\n" + " TagVal: TChA &\n" + " TakeTagNms: bool const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetDomNm", (PyCFunction)_wrap_TStrUtil_GetDomNm, METH_O, (char *)"\n" + "TStrUtil_GetDomNm(TChA UrlChA) -> TChA\n" + "\n" + "Parameters:\n" + " UrlChA: TChA const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetDomNm2", (PyCFunction)_wrap_TStrUtil_GetDomNm2, METH_O, (char *)"\n" + "TStrUtil_GetDomNm2(TChA UrlChA) -> TChA\n" + "\n" + "Parameters:\n" + " UrlChA: TChA const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetWebsiteNm", (PyCFunction)_wrap_TStrUtil_GetWebsiteNm, METH_O, (char *)"\n" + "TStrUtil_GetWebsiteNm(TChA UrlChA) -> TChA\n" + "\n" + "Parameters:\n" + " UrlChA: TChA const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetNormalizedUrl", _wrap_TStrUtil_GetNormalizedUrl, METH_VARARGS, (char *)"\n" + "TStrUtil_GetNormalizedUrl(TChA UrlIn, TChA BaseUrl, TChA UrlOut) -> bool\n" + "\n" + "Parameters:\n" + " UrlIn: TChA const &\n" + " BaseUrl: TChA const &\n" + " UrlOut: TChA &\n" + "\n" + ""}, + { (char *)"TStrUtil_StripEnd", _wrap_TStrUtil_StripEnd, METH_VARARGS, (char *)"\n" + "TStrUtil_StripEnd(TChA Str, TChA SearchStr, TChA NewStr) -> bool\n" + "\n" + "Parameters:\n" + " Str: TChA const &\n" + " SearchStr: TChA const &\n" + " NewStr: TChA &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetShorStr", _wrap_TStrUtil_GetShorStr, METH_VARARGS, (char *)"\n" + "GetShorStr(TChA LongStr, int const MaxLen=50) -> TChA\n" + "\n" + "Parameters:\n" + " LongStr: TChA const &\n" + " MaxLen: int const\n" + "\n" + "TStrUtil_GetShorStr(TChA LongStr) -> TChA\n" + "\n" + "Parameters:\n" + " LongStr: TChA const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetCleanStr", (PyCFunction)_wrap_TStrUtil_GetCleanStr, METH_O, (char *)"\n" + "TStrUtil_GetCleanStr(TChA ChA) -> TChA\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetCleanWrdStr", (PyCFunction)_wrap_TStrUtil_GetCleanWrdStr, METH_O, (char *)"\n" + "TStrUtil_GetCleanWrdStr(TChA ChA) -> TChA\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + ""}, + { (char *)"TStrUtil_CountWords", _wrap_TStrUtil_CountWords, METH_VARARGS, (char *)"\n" + "CountWords(char const * CStr) -> int\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "CountWords(TChA ChA) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + "TStrUtil_CountWords(TChA ChA, TStrHash< TInt > const & StopWordH) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + " StopWordH: TStrHash< TInt > const &\n" + "\n" + ""}, + { (char *)"TStrUtil_SplitWords", _wrap_TStrUtil_SplitWords, METH_VARARGS, (char *)"\n" + "SplitWords(TChA ChA, TVec< char * > & WrdV, bool const & SplitOnWs=True) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA &\n" + " WrdV: TVec< char * > &\n" + " SplitOnWs: bool const &\n" + "\n" + "TStrUtil_SplitWords(TChA ChA, TVec< char * > & WrdV) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA &\n" + " WrdV: TVec< char * > &\n" + "\n" + ""}, + { (char *)"TStrUtil_SplitOnCh", _wrap_TStrUtil_SplitOnCh, METH_VARARGS, (char *)"\n" + "SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch, bool const & SkipEmpty=False) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA &\n" + " WrdV: TVec< char * > &\n" + " Ch: char const &\n" + " SkipEmpty: bool const &\n" + "\n" + "TStrUtil_SplitOnCh(TChA ChA, TVec< char * > & WrdV, char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA &\n" + " WrdV: TVec< char * > &\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStrUtil_SplitLines", _wrap_TStrUtil_SplitLines, METH_VARARGS, (char *)"\n" + "SplitLines(TChA ChA, TVec< char * > & LineV, bool const & SkipEmpty=False) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA &\n" + " LineV: TVec< char * > &\n" + " SkipEmpty: bool const &\n" + "\n" + "TStrUtil_SplitLines(TChA ChA, TVec< char * > & LineV) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA &\n" + " LineV: TVec< char * > &\n" + "\n" + ""}, + { (char *)"TStrUtil_SplitSentences", _wrap_TStrUtil_SplitSentences, METH_VARARGS, (char *)"\n" + "TStrUtil_SplitSentences(TChA ChA, TVec< char * > & SentenceV) -> int\n" + "\n" + "Parameters:\n" + " ChA: TChA &\n" + " SentenceV: TVec< char * > &\n" + "\n" + ""}, + { (char *)"TStrUtil_RemoveHtmlTags", _wrap_TStrUtil_RemoveHtmlTags, METH_VARARGS, (char *)"\n" + "TStrUtil_RemoveHtmlTags(TChA HtmlStr, TChA TextStr)\n" + "\n" + "Parameters:\n" + " HtmlStr: TChA const &\n" + " TextStr: TChA &\n" + "\n" + ""}, + { (char *)"TStrUtil_IsLatinStr", _wrap_TStrUtil_IsLatinStr, METH_VARARGS, (char *)"\n" + "TStrUtil_IsLatinStr(TChA Str, double const & MinAlFrac) -> bool\n" + "\n" + "Parameters:\n" + " Str: TChA const &\n" + " MinAlFrac: double const &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetWIdV", _wrap_TStrUtil_GetWIdV, METH_VARARGS, (char *)"\n" + "TStrUtil_GetWIdV(TStrHash< TInt > const & StrH, char const * CStr, TIntV WIdV)\n" + "\n" + "Parameters:\n" + " StrH: TStrHash< TInt > const &\n" + " CStr: char const *\n" + " WIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetAddWIdV", _wrap_TStrUtil_GetAddWIdV, METH_VARARGS, (char *)"\n" + "TStrUtil_GetAddWIdV(TStrHash< TInt > & StrH, char const * CStr, TIntV WIdV)\n" + "\n" + "Parameters:\n" + " StrH: TStrHash< TInt > &\n" + " CStr: char const *\n" + " WIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetTmFromStr", _wrap_TStrUtil_GetTmFromStr, METH_VARARGS, (char *)"\n" + "TStrUtil_GetTmFromStr(char const * TmStr, TSecTm & Tm) -> bool\n" + "\n" + "Parameters:\n" + " TmStr: char const *\n" + " Tm: TSecTm &\n" + "\n" + ""}, + { (char *)"TStrUtil_GetStdName", (PyCFunction)_wrap_TStrUtil_GetStdName, METH_O, (char *)"\n" + "TStrUtil_GetStdName(TStr AuthorName) -> TStr\n" + "\n" + "Parameters:\n" + " AuthorName: TStr\n" + "\n" + ""}, + { (char *)"TStrUtil_GetStdNameV", _wrap_TStrUtil_GetStdNameV, METH_VARARGS, (char *)"\n" + "TStrUtil_GetStdNameV(TStr AuthorNames, TStrV StdNameV)\n" + "\n" + "Parameters:\n" + " AuthorNames: TStr\n" + " StdNameV: TStrV &\n" + "\n" + ""}, + { (char *)"new_TStrUtil", (PyCFunction)_wrap_new_TStrUtil, METH_NOARGS, (char *)"new_TStrUtil() -> TStrUtil"}, + { (char *)"delete_TStrUtil", (PyCFunction)_wrap_delete_TStrUtil, METH_O, (char *)"\n" + "delete_TStrUtil(TStrUtil self)\n" + "\n" + "Parameters:\n" + " self: TStrUtil *\n" + "\n" + ""}, + { (char *)"TStrUtil_swigregister", TStrUtil_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrUtil_swiginit", TStrUtil_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TRnd", _wrap_new_TRnd, METH_VARARGS, (char *)"\n" + "TRnd(int const & _Seed=1, int const & Steps=0)\n" + "\n" + "Parameters:\n" + " _Seed: int const &\n" + " Steps: int const &\n" + "\n" + "TRnd(int const & _Seed=1)\n" + "\n" + "Parameters:\n" + " _Seed: int const &\n" + "\n" + "TRnd()\n" + "new_TRnd(TSIn SIn) -> TRnd\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TRnd_Save", _wrap_TRnd_Save, METH_VARARGS, (char *)"\n" + "TRnd_Save(TRnd self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TRnd const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TRnd_LoadXml", _wrap_TRnd_LoadXml, METH_VARARGS, (char *)"\n" + "TRnd_LoadXml(TRnd self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TRnd_SaveXml", _wrap_TRnd_SaveXml, METH_VARARGS, (char *)"\n" + "TRnd_SaveXml(TRnd self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TRnd const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TRnd___eq__", _wrap_TRnd___eq__, METH_VARARGS, (char *)"\n" + "TRnd___eq__(TRnd self, TRnd arg2) -> bool\n" + "\n" + "Parameters:\n" + " self: TRnd const *\n" + " arg2: TRnd const &\n" + "\n" + ""}, + { (char *)"TRnd_GetUniDev", (PyCFunction)_wrap_TRnd_GetUniDev, METH_O, (char *)"\n" + "TRnd_GetUniDev(TRnd self) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + "\n" + ""}, + { (char *)"TRnd_GetUniDevInt", _wrap_TRnd_GetUniDevInt, METH_VARARGS, (char *)"\n" + "GetUniDevInt(int const & Range=0) -> int\n" + "\n" + "Parameters:\n" + " Range: int const &\n" + "\n" + "GetUniDevInt() -> int\n" + "TRnd_GetUniDevInt(TRnd self, int const & MnVal, int const & MxVal) -> int\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " MnVal: int const &\n" + " MxVal: int const &\n" + "\n" + ""}, + { (char *)"TRnd_GetUniDevUInt", _wrap_TRnd_GetUniDevUInt, METH_VARARGS, (char *)"\n" + "GetUniDevUInt(uint const & Range=0) -> uint\n" + "\n" + "Parameters:\n" + " Range: uint const &\n" + "\n" + "TRnd_GetUniDevUInt(TRnd self) -> uint\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + "\n" + ""}, + { (char *)"TRnd_GetUniDevInt64", _wrap_TRnd_GetUniDevInt64, METH_VARARGS, (char *)"\n" + "GetUniDevInt64(int64 const & Range=0) -> int64\n" + "\n" + "Parameters:\n" + " Range: int64 const &\n" + "\n" + "TRnd_GetUniDevInt64(TRnd self) -> int64\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + "\n" + ""}, + { (char *)"TRnd_GetUniDevUInt64", _wrap_TRnd_GetUniDevUInt64, METH_VARARGS, (char *)"\n" + "GetUniDevUInt64(uint64 const & Range=0) -> uint64\n" + "\n" + "Parameters:\n" + " Range: uint64 const &\n" + "\n" + "TRnd_GetUniDevUInt64(TRnd self) -> uint64\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + "\n" + ""}, + { (char *)"TRnd_GetNrmDev", _wrap_TRnd_GetNrmDev, METH_VARARGS, (char *)"\n" + "GetNrmDev() -> double\n" + "TRnd_GetNrmDev(TRnd self, double const & Mean, double const & SDev, double const & Mn, double const & Mx) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Mean: double const &\n" + " SDev: double const &\n" + " Mn: double const &\n" + " Mx: double const &\n" + "\n" + ""}, + { (char *)"TRnd_GetExpDev", _wrap_TRnd_GetExpDev, METH_VARARGS, (char *)"\n" + "GetExpDev() -> double\n" + "TRnd_GetExpDev(TRnd self, double const & Lambda) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Lambda: double const &\n" + "\n" + ""}, + { (char *)"TRnd_GetGammaDev", _wrap_TRnd_GetGammaDev, METH_VARARGS, (char *)"\n" + "TRnd_GetGammaDev(TRnd self, int const & Order) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Order: int const &\n" + "\n" + ""}, + { (char *)"TRnd_GetPoissonDev", _wrap_TRnd_GetPoissonDev, METH_VARARGS, (char *)"\n" + "TRnd_GetPoissonDev(TRnd self, double const & Mean) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Mean: double const &\n" + "\n" + ""}, + { (char *)"TRnd_GetBinomialDev", _wrap_TRnd_GetBinomialDev, METH_VARARGS, (char *)"\n" + "TRnd_GetBinomialDev(TRnd self, double const & Prb, int const & Trials) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Prb: double const &\n" + " Trials: int const &\n" + "\n" + ""}, + { (char *)"TRnd_GetGeoDev", _wrap_TRnd_GetGeoDev, METH_VARARGS, (char *)"\n" + "TRnd_GetGeoDev(TRnd self, double const & Prb) -> int\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Prb: double const &\n" + "\n" + ""}, + { (char *)"TRnd_GetPowerDev", _wrap_TRnd_GetPowerDev, METH_VARARGS, (char *)"\n" + "TRnd_GetPowerDev(TRnd self, double const & AlphaSlope) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " AlphaSlope: double const &\n" + "\n" + ""}, + { (char *)"TRnd_GetRayleigh", _wrap_TRnd_GetRayleigh, METH_VARARGS, (char *)"\n" + "TRnd_GetRayleigh(TRnd self, double const & Sigma) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Sigma: double const &\n" + "\n" + ""}, + { (char *)"TRnd_GetWeibull", _wrap_TRnd_GetWeibull, METH_VARARGS, (char *)"\n" + "TRnd_GetWeibull(TRnd self, double const & K, double const & Lambda) -> double\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " K: double const &\n" + " Lambda: double const &\n" + "\n" + ""}, + { (char *)"TRnd_PutSeed", _wrap_TRnd_PutSeed, METH_VARARGS, (char *)"\n" + "TRnd_PutSeed(TRnd self, int const & _Seed)\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " _Seed: int const &\n" + "\n" + ""}, + { (char *)"TRnd_GetSeed", (PyCFunction)_wrap_TRnd_GetSeed, METH_O, (char *)"\n" + "TRnd_GetSeed(TRnd self) -> int\n" + "\n" + "Parameters:\n" + " self: TRnd const *\n" + "\n" + ""}, + { (char *)"TRnd_Randomize", (PyCFunction)_wrap_TRnd_Randomize, METH_O, (char *)"\n" + "TRnd_Randomize(TRnd self)\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + "\n" + ""}, + { (char *)"TRnd_Move", _wrap_TRnd_Move, METH_VARARGS, (char *)"\n" + "TRnd_Move(TRnd self, int const & Steps)\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + " Steps: int const &\n" + "\n" + ""}, + { (char *)"TRnd_Check", (PyCFunction)_wrap_TRnd_Check, METH_O, (char *)"\n" + "TRnd_Check(TRnd self) -> bool\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + "\n" + ""}, + { (char *)"TRnd_GetUniDevStep", _wrap_TRnd_GetUniDevStep, METH_VARARGS, (char *)"\n" + "TRnd_GetUniDevStep(int const & Seed, int const & Steps) -> double\n" + "\n" + "Parameters:\n" + " Seed: int const &\n" + " Steps: int const &\n" + "\n" + ""}, + { (char *)"TRnd_GetNrmDevStep", _wrap_TRnd_GetNrmDevStep, METH_VARARGS, (char *)"\n" + "TRnd_GetNrmDevStep(int const & Seed, int const & Steps) -> double\n" + "\n" + "Parameters:\n" + " Seed: int const &\n" + " Steps: int const &\n" + "\n" + ""}, + { (char *)"TRnd_GetExpDevStep", _wrap_TRnd_GetExpDevStep, METH_VARARGS, (char *)"\n" + "TRnd_GetExpDevStep(int const & Seed, int const & Steps) -> double\n" + "\n" + "Parameters:\n" + " Seed: int const &\n" + " Steps: int const &\n" + "\n" + ""}, + { (char *)"TRnd_LoadTxt", (PyCFunction)_wrap_TRnd_LoadTxt, METH_O, (char *)"\n" + "TRnd_LoadTxt(TILx & Lx) -> TRnd\n" + "\n" + "Parameters:\n" + " Lx: TILx &\n" + "\n" + ""}, + { (char *)"TRnd_SaveTxt", _wrap_TRnd_SaveTxt, METH_VARARGS, (char *)"\n" + "TRnd_SaveTxt(TRnd self, TOLx & Lx)\n" + "\n" + "Parameters:\n" + " self: TRnd const *\n" + " Lx: TOLx &\n" + "\n" + ""}, + { (char *)"delete_TRnd", (PyCFunction)_wrap_delete_TRnd, METH_O, (char *)"\n" + "delete_TRnd(TRnd self)\n" + "\n" + "Parameters:\n" + " self: TRnd *\n" + "\n" + ""}, + { (char *)"TRnd_swigregister", TRnd_swigregister, METH_VARARGS, NULL}, + { (char *)"TRnd_swiginit", TRnd_swiginit, METH_VARARGS, NULL}, + { (char *)"TMem_New", _wrap_TMem_New, METH_VARARGS, (char *)"\n" + "New(int const & MxBfL=0) -> PMem\n" + "\n" + "Parameters:\n" + " MxBfL: int const &\n" + "\n" + "New() -> PMem\n" + "New(void const * Bf, int const & BfL) -> PMem\n" + "\n" + "Parameters:\n" + " Bf: void const *\n" + " BfL: int const &\n" + "\n" + "New(TMem Mem) -> PMem\n" + "\n" + "Parameters:\n" + " Mem: TMem const &\n" + "\n" + "New(PMem const & Mem) -> PMem\n" + "\n" + "Parameters:\n" + " Mem: PMem const &\n" + "\n" + "TMem_New(TStr Str) -> PMem\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"delete_TMem", (PyCFunction)_wrap_delete_TMem, METH_O, (char *)"\n" + "delete_TMem(TMem self)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + "\n" + ""}, + { (char *)"new_TMem", _wrap_new_TMem, METH_VARARGS, (char *)"\n" + "TMem(int const & _MxBfL=0)\n" + "\n" + "Parameters:\n" + " _MxBfL: int const &\n" + "\n" + "TMem()\n" + "TMem(void const * _Bf, int const & _BfL)\n" + "\n" + "Parameters:\n" + " _Bf: void const *\n" + " _BfL: int const &\n" + "\n" + "TMem(TMem Mem)\n" + "\n" + "Parameters:\n" + " Mem: TMem const &\n" + "\n" + "TMem(TStr Str)\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "new_TMem(TSIn SIn) -> TMem\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TMem_Save", _wrap_TMem_Save, METH_VARARGS, (char *)"\n" + "TMem_Save(TMem self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TMem_SaveXml", _wrap_TMem_SaveXml, METH_VARARGS, (char *)"\n" + "TMem_SaveXml(TMem self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TMem___call__", (PyCFunction)_wrap_TMem___call__, METH_O, (char *)"\n" + "TMem___call__(TMem self) -> char *\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + "\n" + ""}, + { (char *)"TMem___iadd__", _wrap_TMem___iadd__, METH_VARARGS, (char *)"\n" + "__iadd__(char const & Ch) -> TMem\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + "__iadd__(TMem Mem) -> TMem\n" + "\n" + "Parameters:\n" + " Mem: TMem const &\n" + "\n" + "__iadd__(TStr Str) -> TMem\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TMem___iadd__(TMem self, PSIn const & SIn) -> TMem\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " SIn: PSIn const &\n" + "\n" + ""}, + { (char *)"TMem_GetMemUsed", (PyCFunction)_wrap_TMem_GetMemUsed, METH_O, (char *)"\n" + "TMem_GetMemUsed(TMem self) -> int\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + "\n" + ""}, + { (char *)"TMem_Gen", _wrap_TMem_Gen, METH_VARARGS, (char *)"\n" + "TMem_Gen(TMem self, int const & _BfL)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " _BfL: int const &\n" + "\n" + ""}, + { (char *)"TMem_GenZeros", _wrap_TMem_GenZeros, METH_VARARGS, (char *)"\n" + "TMem_GenZeros(TMem self, int const & _BfL)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " _BfL: int const &\n" + "\n" + ""}, + { (char *)"TMem_Reserve", _wrap_TMem_Reserve, METH_VARARGS, (char *)"\n" + "Reserve(int const & _MxBfL, bool const & DoClr=True)\n" + "\n" + "Parameters:\n" + " _MxBfL: int const &\n" + " DoClr: bool const &\n" + "\n" + "TMem_Reserve(TMem self, int const & _MxBfL)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " _MxBfL: int const &\n" + "\n" + ""}, + { (char *)"TMem_Del", _wrap_TMem_Del, METH_VARARGS, (char *)"\n" + "TMem_Del(TMem self, int const & BChN, int const & EChN)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " BChN: int const &\n" + " EChN: int const &\n" + "\n" + ""}, + { (char *)"TMem_Clr", _wrap_TMem_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool const & DoDel=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + "\n" + "TMem_Clr(TMem self)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + "\n" + ""}, + { (char *)"TMem_Len", (PyCFunction)_wrap_TMem_Len, METH_O, (char *)"\n" + "TMem_Len(TMem self) -> int\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + "\n" + ""}, + { (char *)"TMem_Empty", (PyCFunction)_wrap_TMem_Empty, METH_O, (char *)"\n" + "TMem_Empty(TMem self) -> bool\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + "\n" + ""}, + { (char *)"TMem_Trunc", _wrap_TMem_Trunc, METH_VARARGS, (char *)"\n" + "TMem_Trunc(TMem self, int const & _BfL)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " _BfL: int const &\n" + "\n" + ""}, + { (char *)"TMem_Push", _wrap_TMem_Push, METH_VARARGS, (char *)"\n" + "TMem_Push(TMem self, char const & Ch)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TMem_Pop", (PyCFunction)_wrap_TMem_Pop, METH_O, (char *)"\n" + "TMem_Pop(TMem self) -> char\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + "\n" + ""}, + { (char *)"TMem_DoFitStr", _wrap_TMem_DoFitStr, METH_VARARGS, (char *)"\n" + "TMem_DoFitStr(TMem self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TMem_AddBf", _wrap_TMem_AddBf, METH_VARARGS, (char *)"\n" + "TMem_AddBf(TMem self, void const * Bf, int const & BfL)\n" + "\n" + "Parameters:\n" + " self: TMem *\n" + " Bf: void const *\n" + " BfL: int const &\n" + "\n" + ""}, + { (char *)"TMem_GetBf", (PyCFunction)_wrap_TMem_GetBf, METH_O, (char *)"\n" + "TMem_GetBf(TMem self) -> char *\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + "\n" + ""}, + { (char *)"TMem_GetAsStr", _wrap_TMem_GetAsStr, METH_VARARGS, (char *)"\n" + "GetAsStr(char const & NewNullCh='\\0') -> TStr\n" + "\n" + "Parameters:\n" + " NewNullCh: char const &\n" + "\n" + "TMem_GetAsStr(TMem self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + "\n" + ""}, + { (char *)"TMem_GetSIn", (PyCFunction)_wrap_TMem_GetSIn, METH_O, (char *)"\n" + "TMem_GetSIn(TMem self) -> PSIn\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + "\n" + ""}, + { (char *)"TMem_LoadMem", _wrap_TMem_LoadMem, METH_VARARGS, (char *)"\n" + "LoadMem(PSIn const & SIn, TMem Mem)\n" + "\n" + "Parameters:\n" + " SIn: PSIn const &\n" + " Mem: TMem &\n" + "\n" + "TMem_LoadMem(PSIn const & SIn, PMem const & Mem)\n" + "\n" + "Parameters:\n" + " SIn: PSIn const &\n" + " Mem: PMem const &\n" + "\n" + ""}, + { (char *)"TMem_SaveMem", _wrap_TMem_SaveMem, METH_VARARGS, (char *)"\n" + "TMem_SaveMem(TMem self, PSOut const & SOut)\n" + "\n" + "Parameters:\n" + " self: TMem const *\n" + " SOut: PSOut const &\n" + "\n" + ""}, + { (char *)"TMem_swigregister", TMem_swigregister, METH_VARARGS, NULL}, + { (char *)"TMem_swiginit", TMem_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TMemIn", _wrap_new_TMemIn, METH_VARARGS, (char *)"\n" + "TMemIn(TMem _Mem, int const & _BfC=0)\n" + "\n" + "Parameters:\n" + " _Mem: TMem const &\n" + " _BfC: int const &\n" + "\n" + "new_TMemIn(TMem _Mem) -> TMemIn\n" + "\n" + "Parameters:\n" + " _Mem: TMem const &\n" + "\n" + ""}, + { (char *)"TMemIn_New", _wrap_TMemIn_New, METH_VARARGS, (char *)"\n" + "New(TMem Mem) -> PSIn\n" + "\n" + "Parameters:\n" + " Mem: TMem const &\n" + "\n" + "TMemIn_New(PMem const & Mem) -> PSIn\n" + "\n" + "Parameters:\n" + " Mem: PMem const &\n" + "\n" + ""}, + { (char *)"delete_TMemIn", (PyCFunction)_wrap_delete_TMemIn, METH_O, (char *)"\n" + "delete_TMemIn(TMemIn self)\n" + "\n" + "Parameters:\n" + " self: TMemIn *\n" + "\n" + ""}, + { (char *)"TMemIn_swigregister", TMemIn_swigregister, METH_VARARGS, NULL}, + { (char *)"TMemIn_swiginit", TMemIn_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TMemOut", (PyCFunction)_wrap_new_TMemOut, METH_O, (char *)"\n" + "new_TMemOut(PMem const & _Mem) -> TMemOut\n" + "\n" + "Parameters:\n" + " _Mem: PMem const &\n" + "\n" + ""}, + { (char *)"TMemOut_New", (PyCFunction)_wrap_TMemOut_New, METH_O, (char *)"\n" + "TMemOut_New(PMem const & Mem) -> PSOut\n" + "\n" + "Parameters:\n" + " Mem: PMem const &\n" + "\n" + ""}, + { (char *)"delete_TMemOut", (PyCFunction)_wrap_delete_TMemOut, METH_O, (char *)"\n" + "delete_TMemOut(TMemOut self)\n" + "\n" + "Parameters:\n" + " self: TMemOut *\n" + "\n" + ""}, + { (char *)"TMemOut_swigregister", TMemOut_swigregister, METH_VARARGS, NULL}, + { (char *)"TMemOut_swiginit", TMemOut_swiginit, METH_VARARGS, NULL}, + { (char *)"delete_TChA", (PyCFunction)_wrap_delete_TChA, METH_O, (char *)"\n" + "delete_TChA(TChA self)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"new_TChA", _wrap_new_TChA, METH_VARARGS, (char *)"\n" + "TChA(int const & _MxBfL=256)\n" + "\n" + "Parameters:\n" + " _MxBfL: int const &\n" + "\n" + "TChA()\n" + "TChA(char const * CStr)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TChA(char const * CStr, int const & StrLen)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + " StrLen: int const &\n" + "\n" + "TChA(TChA ChA)\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + "TChA(TStr Str)\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TChA(TMem Mem)\n" + "\n" + "Parameters:\n" + " Mem: TMem const &\n" + "\n" + "new_TChA(TSIn SIn) -> TChA\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TChA_Load", _wrap_TChA_Load, METH_VARARGS, (char *)"\n" + "TChA_Load(TChA self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TChA_Save", _wrap_TChA_Save, METH_VARARGS, (char *)"\n" + "Save(TSOut SOut, bool const & SaveCompact=True)\n" + "\n" + "Parameters:\n" + " SOut: TSOut &\n" + " SaveCompact: bool const &\n" + "\n" + "TChA_Save(TChA self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TChA_SaveXml", _wrap_TChA_SaveXml, METH_VARARGS, (char *)"\n" + "TChA_SaveXml(TChA self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TChA___eq__", _wrap_TChA___eq__, METH_VARARGS, (char *)"\n" + "__eq__(TChA ChA) -> bool\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + "__eq__(char const * _CStr) -> bool\n" + "\n" + "Parameters:\n" + " _CStr: char const *\n" + "\n" + "TChA___eq__(TChA self, char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA___ne__", _wrap_TChA___ne__, METH_VARARGS, (char *)"\n" + "__ne__(TChA ChA) -> bool\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + "__ne__(char const * _CStr) -> bool\n" + "\n" + "Parameters:\n" + " _CStr: char const *\n" + "\n" + "TChA___ne__(TChA self, char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA___lt__", _wrap_TChA___lt__, METH_VARARGS, (char *)"\n" + "TChA___lt__(TChA self, TChA ChA) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " ChA: TChA const &\n" + "\n" + ""}, + { (char *)"TChA___iadd__", _wrap_TChA___iadd__, METH_VARARGS, (char *)"\n" + "__iadd__(TMem Mem) -> TChA\n" + "\n" + "Parameters:\n" + " Mem: TMem const &\n" + "\n" + "__iadd__(TChA ChA) -> TChA\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + "__iadd__(TStr Str) -> TChA\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "__iadd__(char const * CStr) -> TChA\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TChA___iadd__(TChA self, char const & Ch) -> TChA\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_GetMemUsed", (PyCFunction)_wrap_TChA_GetMemUsed, METH_O, (char *)"\n" + "TChA_GetMemUsed(TChA self) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA___call__", _wrap_TChA___call__, METH_VARARGS, (char *)"\n" + "__call__() -> char\n" + "TChA___call__(TChA self) -> char const *\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_CStr", _wrap_TChA_CStr, METH_VARARGS, (char *)"\n" + "CStr() -> char\n" + "TChA_CStr(TChA self) -> char const *\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_Clr", (PyCFunction)_wrap_TChA_Clr, METH_O, (char *)"\n" + "TChA_Clr(TChA self)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_Len", (PyCFunction)_wrap_TChA_Len, METH_O, (char *)"\n" + "TChA_Len(TChA self) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_Empty", (PyCFunction)_wrap_TChA_Empty, METH_O, (char *)"\n" + "TChA_Empty(TChA self) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_Ins", _wrap_TChA_Ins, METH_VARARGS, (char *)"\n" + "TChA_Ins(TChA self, int const & BChN, char const * CStr)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " BChN: int const &\n" + " CStr: char const *\n" + "\n" + ""}, + { (char *)"TChA_Del", _wrap_TChA_Del, METH_VARARGS, (char *)"\n" + "TChA_Del(TChA self, int const & ChN)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " ChN: int const &\n" + "\n" + ""}, + { (char *)"TChA_DelLastCh", (PyCFunction)_wrap_TChA_DelLastCh, METH_O, (char *)"\n" + "TChA_DelLastCh(TChA self)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_Push", _wrap_TChA_Push, METH_VARARGS, (char *)"\n" + "TChA_Push(TChA self, char const & Ch)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_Pop", (PyCFunction)_wrap_TChA_Pop, METH_O, (char *)"\n" + "TChA_Pop(TChA self) -> char\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_Trunc", _wrap_TChA_Trunc, METH_VARARGS, (char *)"\n" + "Trunc()\n" + "TChA_Trunc(TChA self, int const & _BfL)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " _BfL: int const &\n" + "\n" + ""}, + { (char *)"TChA_Reverse", (PyCFunction)_wrap_TChA_Reverse, METH_O, (char *)"\n" + "TChA_Reverse(TChA self)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_AddCh", _wrap_TChA_AddCh, METH_VARARGS, (char *)"\n" + "AddCh(char const & Ch, int const & MxLen=-1)\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + " MxLen: int const &\n" + "\n" + "TChA_AddCh(TChA self, char const & Ch)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_AddChTo", _wrap_TChA_AddChTo, METH_VARARGS, (char *)"\n" + "TChA_AddChTo(TChA self, char const & Ch, int const & ToChN)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " Ch: char const &\n" + " ToChN: int const &\n" + "\n" + ""}, + { (char *)"TChA_AddBf", _wrap_TChA_AddBf, METH_VARARGS, (char *)"\n" + "TChA_AddBf(TChA self, char * NewBf, int const & BfS)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " NewBf: char *\n" + " BfS: int const &\n" + "\n" + ""}, + { (char *)"TChA_PutCh", _wrap_TChA_PutCh, METH_VARARGS, (char *)"\n" + "TChA_PutCh(TChA self, int const & ChN, char const & Ch)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " ChN: int const &\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_GetCh", _wrap_TChA_GetCh, METH_VARARGS, (char *)"\n" + "TChA_GetCh(TChA self, int const & ChN) -> char\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " ChN: int const &\n" + "\n" + ""}, + { (char *)"TChA_LastCh", (PyCFunction)_wrap_TChA_LastCh, METH_O, (char *)"\n" + "TChA_LastCh(TChA self) -> char\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_LastLastCh", (PyCFunction)_wrap_TChA_LastLastCh, METH_O, (char *)"\n" + "TChA_LastLastCh(TChA self) -> char\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_GetSubStr", _wrap_TChA_GetSubStr, METH_VARARGS, (char *)"\n" + "TChA_GetSubStr(TChA self, int const & BChN, int const & EChN) -> TChA\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " BChN: int const &\n" + " EChN: int const &\n" + "\n" + ""}, + { (char *)"TChA_CountCh", _wrap_TChA_CountCh, METH_VARARGS, (char *)"\n" + "CountCh(char const & Ch, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + " BChN: int const &\n" + "\n" + "TChA_CountCh(TChA self, char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_SearchCh", _wrap_TChA_SearchCh, METH_VARARGS, (char *)"\n" + "SearchCh(char const & Ch, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + " BChN: int const &\n" + "\n" + "TChA_SearchCh(TChA self, char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_SearchChBack", _wrap_TChA_SearchChBack, METH_VARARGS, (char *)"\n" + "SearchChBack(char const & Ch, int BChN=-1) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + " BChN: int\n" + "\n" + "TChA_SearchChBack(TChA self, char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_SearchStr", _wrap_TChA_SearchStr, METH_VARARGS, (char *)"\n" + "SearchStr(TChA Str, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " Str: TChA const &\n" + " BChN: int const &\n" + "\n" + "SearchStr(TChA Str) -> int\n" + "\n" + "Parameters:\n" + " Str: TChA const &\n" + "\n" + "SearchStr(TStr Str, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + " BChN: int const &\n" + "\n" + "SearchStr(TStr Str) -> int\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "SearchStr(char const * CStr, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + " BChN: int const &\n" + "\n" + "TChA_SearchStr(TChA self, char const * CStr) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " CStr: char const *\n" + "\n" + ""}, + { (char *)"TChA_IsStrIn", _wrap_TChA_IsStrIn, METH_VARARGS, (char *)"\n" + "TChA_IsStrIn(TChA self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TChA_IsPrefix", _wrap_TChA_IsPrefix, METH_VARARGS, (char *)"\n" + "IsPrefix(char const * CStr, int const & BChN=0) -> bool\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + " BChN: int const &\n" + "\n" + "IsPrefix(char const * CStr) -> bool\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "IsPrefix(TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TChA_IsPrefix(TChA self, TChA Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Str: TChA const &\n" + "\n" + ""}, + { (char *)"TChA_IsSuffix", _wrap_TChA_IsSuffix, METH_VARARGS, (char *)"\n" + "IsSuffix(char const * CStr) -> bool\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "IsSuffix(TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TChA_IsSuffix(TChA self, TChA Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Str: TChA const &\n" + "\n" + ""}, + { (char *)"TChA_IsChIn", _wrap_TChA_IsChIn, METH_VARARGS, (char *)"\n" + "TChA_IsChIn(TChA self, char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TChA_ChangeCh", _wrap_TChA_ChangeCh, METH_VARARGS, (char *)"\n" + "TChA_ChangeCh(TChA self, char const & SrcCh, char const & DstCh)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " SrcCh: char const &\n" + " DstCh: char const &\n" + "\n" + ""}, + { (char *)"TChA_ToUc", (PyCFunction)_wrap_TChA_ToUc, METH_O, (char *)"\n" + "TChA_ToUc(TChA self) -> TChA\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_ToLc", (PyCFunction)_wrap_TChA_ToLc, METH_O, (char *)"\n" + "TChA_ToLc(TChA self) -> TChA\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_ToTrunc", (PyCFunction)_wrap_TChA_ToTrunc, METH_O, (char *)"\n" + "TChA_ToTrunc(TChA self) -> TChA\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_CompressWs", (PyCFunction)_wrap_TChA_CompressWs, METH_O, (char *)"\n" + "TChA_CompressWs(TChA self)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + "\n" + ""}, + { (char *)"TChA_Swap", _wrap_TChA_Swap, METH_VARARGS, (char *)"\n" + "Swap(int const & ChN1, int const & ChN2)\n" + "\n" + "Parameters:\n" + " ChN1: int const &\n" + " ChN2: int const &\n" + "\n" + "TChA_Swap(TChA self, TChA ChA)\n" + "\n" + "Parameters:\n" + " self: TChA *\n" + " ChA: TChA &\n" + "\n" + ""}, + { (char *)"TChA_GetPrimHashCd", (PyCFunction)_wrap_TChA_GetPrimHashCd, METH_O, (char *)"\n" + "TChA_GetPrimHashCd(TChA self) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_GetSecHashCd", (PyCFunction)_wrap_TChA_GetSecHashCd, METH_O, (char *)"\n" + "TChA_GetSecHashCd(TChA self) -> int\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + "\n" + ""}, + { (char *)"TChA_LoadTxt", _wrap_TChA_LoadTxt, METH_VARARGS, (char *)"\n" + "TChA_LoadTxt(PSIn const & SIn, TChA ChA)\n" + "\n" + "Parameters:\n" + " SIn: PSIn const &\n" + " ChA: TChA &\n" + "\n" + ""}, + { (char *)"TChA_SaveTxt", _wrap_TChA_SaveTxt, METH_VARARGS, (char *)"\n" + "TChA_SaveTxt(TChA self, PSOut const & SOut)\n" + "\n" + "Parameters:\n" + " self: TChA const *\n" + " SOut: PSOut const &\n" + "\n" + ""}, + { (char *)"TChA_swigregister", TChA_swigregister, METH_VARARGS, NULL}, + { (char *)"TChA_swiginit", TChA_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TChAIn", _wrap_new_TChAIn, METH_VARARGS, (char *)"\n" + "TChAIn(TChA ChA, int const & _BfC=0)\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + " _BfC: int const &\n" + "\n" + "new_TChAIn(TChA ChA) -> TChAIn\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + ""}, + { (char *)"TChAIn_New", (PyCFunction)_wrap_TChAIn_New, METH_O, (char *)"\n" + "TChAIn_New(TChA ChA) -> PSIn\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + ""}, + { (char *)"delete_TChAIn", (PyCFunction)_wrap_delete_TChAIn, METH_O, (char *)"\n" + "delete_TChAIn(TChAIn self)\n" + "\n" + "Parameters:\n" + " self: TChAIn *\n" + "\n" + ""}, + { (char *)"TChAIn_swigregister", TChAIn_swigregister, METH_VARARGS, NULL}, + { (char *)"TChAIn_swiginit", TChAIn_swiginit, METH_VARARGS, NULL}, + { (char *)"TRStr_Bf_set", _wrap_TRStr_Bf_set, METH_VARARGS, (char *)"\n" + "TRStr_Bf_set(TRStr self, char * Bf)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + " Bf: char *\n" + "\n" + ""}, + { (char *)"TRStr_Bf_get", (PyCFunction)_wrap_TRStr_Bf_get, METH_O, (char *)"\n" + "TRStr_Bf_get(TRStr self) -> char *\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_Refs_set", _wrap_TRStr_Refs_set, METH_VARARGS, (char *)"\n" + "TRStr_Refs_set(TRStr self, int Refs)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + " Refs: int\n" + "\n" + ""}, + { (char *)"TRStr_Refs_get", (PyCFunction)_wrap_TRStr_Refs_get, METH_O, (char *)"\n" + "TRStr_Refs_get(TRStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"delete_TRStr", (PyCFunction)_wrap_delete_TRStr, METH_O, (char *)"\n" + "delete_TRStr(TRStr self)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"new_TRStr", _wrap_new_TRStr, METH_VARARGS, (char *)"\n" + "TRStr()\n" + "TRStr(int const & Len)\n" + "\n" + "Parameters:\n" + " Len: int const &\n" + "\n" + "TRStr(char const * CStr)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TRStr(char const * CStr, int const & MxLen)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + " MxLen: int const &\n" + "\n" + "TRStr(char const * CStr1, char const * CStr2)\n" + "\n" + "Parameters:\n" + " CStr1: char const *\n" + " CStr2: char const *\n" + "\n" + "TRStr(char const & Ch)\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + "TRStr(char const & Ch1, char const & Ch2)\n" + "\n" + "Parameters:\n" + " Ch1: char const &\n" + " Ch2: char const &\n" + "\n" + "new_TRStr(TSIn SIn, bool const & IsSmall) -> TRStr\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " IsSmall: bool const &\n" + "\n" + ""}, + { (char *)"TRStr_Save", _wrap_TRStr_Save, METH_VARARGS, (char *)"\n" + "TRStr_Save(TRStr self, TSOut SOut, bool const & IsSmall)\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + " SOut: TSOut &\n" + " IsSmall: bool const &\n" + "\n" + ""}, + { (char *)"TRStr_GetMemUsed", (PyCFunction)_wrap_TRStr_GetMemUsed, METH_O, (char *)"\n" + "TRStr_GetMemUsed(TRStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + "\n" + ""}, + { (char *)"TRStr_MkRef", (PyCFunction)_wrap_TRStr_MkRef, METH_O, (char *)"\n" + "TRStr_MkRef(TRStr self)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_UnRef", (PyCFunction)_wrap_TRStr_UnRef, METH_O, (char *)"\n" + "TRStr_UnRef(TRStr self)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_CStr", _wrap_TRStr_CStr, METH_VARARGS, (char *)"\n" + "CStr() -> char const\n" + "TRStr_CStr(TRStr self) -> char *\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_Empty", (PyCFunction)_wrap_TRStr_Empty, METH_O, (char *)"\n" + "TRStr_Empty(TRStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + "\n" + ""}, + { (char *)"TRStr_Len", (PyCFunction)_wrap_TRStr_Len, METH_O, (char *)"\n" + "TRStr_Len(TRStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + "\n" + ""}, + { (char *)"TRStr_PutCh", _wrap_TRStr_PutCh, METH_VARARGS, (char *)"\n" + "TRStr_PutCh(TRStr self, int const & ChN, char const & Ch)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + " ChN: int const &\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TRStr_GetCh", _wrap_TRStr_GetCh, METH_VARARGS, (char *)"\n" + "TRStr_GetCh(TRStr self, int const & ChN) -> char\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + " ChN: int const &\n" + "\n" + ""}, + { (char *)"TRStr_IsUc", (PyCFunction)_wrap_TRStr_IsUc, METH_O, (char *)"\n" + "TRStr_IsUc(TRStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + "\n" + ""}, + { (char *)"TRStr_ToUc", (PyCFunction)_wrap_TRStr_ToUc, METH_O, (char *)"\n" + "TRStr_ToUc(TRStr self)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_IsLc", (PyCFunction)_wrap_TRStr_IsLc, METH_O, (char *)"\n" + "TRStr_IsLc(TRStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + "\n" + ""}, + { (char *)"TRStr_ToLc", (PyCFunction)_wrap_TRStr_ToLc, METH_O, (char *)"\n" + "TRStr_ToLc(TRStr self)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_ToCap", (PyCFunction)_wrap_TRStr_ToCap, METH_O, (char *)"\n" + "TRStr_ToCap(TRStr self)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_ConvUsFromYuAscii", (PyCFunction)_wrap_TRStr_ConvUsFromYuAscii, METH_O, (char *)"\n" + "TRStr_ConvUsFromYuAscii(TRStr self)\n" + "\n" + "Parameters:\n" + " self: TRStr *\n" + "\n" + ""}, + { (char *)"TRStr_CmpI", _wrap_TRStr_CmpI, METH_VARARGS, (char *)"\n" + "TRStr_CmpI(char const * CStr1, char const * CStr2) -> int\n" + "\n" + "Parameters:\n" + " CStr1: char const *\n" + " CStr2: char const *\n" + "\n" + ""}, + { (char *)"TRStr_GetPrimHashCd", (PyCFunction)_wrap_TRStr_GetPrimHashCd, METH_O, (char *)"\n" + "TRStr_GetPrimHashCd(TRStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + "\n" + ""}, + { (char *)"TRStr_GetSecHashCd", (PyCFunction)_wrap_TRStr_GetSecHashCd, METH_O, (char *)"\n" + "TRStr_GetSecHashCd(TRStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TRStr const *\n" + "\n" + ""}, + { (char *)"TRStr_GetNullRStr", (PyCFunction)_wrap_TRStr_GetNullRStr, METH_NOARGS, (char *)"TRStr_GetNullRStr() -> TRStr"}, + { (char *)"TRStr_swigregister", TRStr_swigregister, METH_VARARGS, NULL}, + { (char *)"TRStr_swiginit", TRStr_swiginit, METH_VARARGS, NULL}, + { (char *)"delete_TStr", (PyCFunction)_wrap_delete_TStr, METH_O, (char *)"\n" + "delete_TStr(TStr self)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"new_TStr", _wrap_new_TStr, METH_VARARGS, (char *)"\n" + "TStr()\n" + "TStr(TStr Str)\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TStr(TChA ChA)\n" + "\n" + "Parameters:\n" + " ChA: TChA const &\n" + "\n" + "TStr(TSStr SStr)\n" + "\n" + "Parameters:\n" + " SStr: TSStr const &\n" + "\n" + "TStr(char const * CStr)\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TStr(char const & Ch)\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + "TStr(TMem Mem)\n" + "\n" + "Parameters:\n" + " Mem: TMem const &\n" + "\n" + "TStr(PSIn const & SIn)\n" + "\n" + "Parameters:\n" + " SIn: PSIn const &\n" + "\n" + "TStr(TSIn SIn, bool const & IsSmall=False)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " IsSmall: bool const &\n" + "\n" + "new_TStr(TSIn SIn) -> TStr\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TStr_Load", _wrap_TStr_Load, METH_VARARGS, (char *)"\n" + "Load(TSIn SIn, bool const & IsSmall=False)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " IsSmall: bool const &\n" + "\n" + "TStr_Load(TStr self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TStr_Save", _wrap_TStr_Save, METH_VARARGS, (char *)"\n" + "Save(TSOut SOut, bool const & IsSmall=False)\n" + "\n" + "Parameters:\n" + " SOut: TSOut &\n" + " IsSmall: bool const &\n" + "\n" + "TStr_Save(TStr self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TStr_LoadXml", _wrap_TStr_LoadXml, METH_VARARGS, (char *)"\n" + "TStr_LoadXml(TStr self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_SaveXml", _wrap_TStr_SaveXml, METH_VARARGS, (char *)"\n" + "TStr_SaveXml(TStr self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TStr___iadd__", _wrap_TStr___iadd__, METH_VARARGS, (char *)"\n" + "__iadd__(TStr Str) -> TStr\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TStr___iadd__(TStr self, char const * CStr) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " CStr: char const *\n" + "\n" + ""}, + { (char *)"TStr___eq__", _wrap_TStr___eq__, METH_VARARGS, (char *)"\n" + "__eq__(TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TStr___eq__(TStr self, char const * CStr) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " CStr: char const *\n" + "\n" + ""}, + { (char *)"TStr___ne__", _wrap_TStr___ne__, METH_VARARGS, (char *)"\n" + "TStr___ne__(TStr self, char const * CStr) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " CStr: char const *\n" + "\n" + ""}, + { (char *)"TStr___lt__", _wrap_TStr___lt__, METH_VARARGS, (char *)"\n" + "TStr___lt__(TStr self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetMemUsed", (PyCFunction)_wrap_TStr_GetMemUsed, METH_O, (char *)"\n" + "TStr_GetMemUsed(TStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_CStr", _wrap_TStr_CStr, METH_VARARGS, (char *)"\n" + "CStr() -> char\n" + "TStr_CStr(TStr self) -> char const *\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_PutCh", _wrap_TStr_PutCh, METH_VARARGS, (char *)"\n" + "TStr_PutCh(TStr self, int const & ChN, char const & Ch)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " ChN: int const &\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStr_GetCh", _wrap_TStr_GetCh, METH_VARARGS, (char *)"\n" + "TStr_GetCh(TStr self, int const & ChN) -> char\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " ChN: int const &\n" + "\n" + ""}, + { (char *)"TStr_LastCh", (PyCFunction)_wrap_TStr_LastCh, METH_O, (char *)"\n" + "TStr_LastCh(TStr self) -> char\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_Clr", (PyCFunction)_wrap_TStr_Clr, METH_O, (char *)"\n" + "TStr_Clr(TStr self)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_Len", (PyCFunction)_wrap_TStr_Len, METH_O, (char *)"\n" + "TStr_Len(TStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_Empty", (PyCFunction)_wrap_TStr_Empty, METH_O, (char *)"\n" + "TStr_Empty(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_IsUc", (PyCFunction)_wrap_TStr_IsUc, METH_O, (char *)"\n" + "TStr_IsUc(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_ToUc", (PyCFunction)_wrap_TStr_ToUc, METH_O, (char *)"\n" + "TStr_ToUc(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_GetUc", (PyCFunction)_wrap_TStr_GetUc, METH_O, (char *)"\n" + "TStr_GetUc(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_CmpI", _wrap_TStr_CmpI, METH_VARARGS, (char *)"\n" + "TStr_CmpI(TStr self, TStr Str) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_EqI", _wrap_TStr_EqI, METH_VARARGS, (char *)"\n" + "TStr_EqI(TStr self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_IsLc", (PyCFunction)_wrap_TStr_IsLc, METH_O, (char *)"\n" + "TStr_IsLc(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_ToLc", (PyCFunction)_wrap_TStr_ToLc, METH_O, (char *)"\n" + "TStr_ToLc(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_GetLc", (PyCFunction)_wrap_TStr_GetLc, METH_O, (char *)"\n" + "TStr_GetLc(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_ToCap", (PyCFunction)_wrap_TStr_ToCap, METH_O, (char *)"\n" + "TStr_ToCap(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_GetCap", (PyCFunction)_wrap_TStr_GetCap, METH_O, (char *)"\n" + "TStr_GetCap(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_ToTrunc", (PyCFunction)_wrap_TStr_ToTrunc, METH_O, (char *)"\n" + "TStr_ToTrunc(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_GetTrunc", (PyCFunction)_wrap_TStr_GetTrunc, METH_O, (char *)"\n" + "TStr_GetTrunc(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_ConvUsFromYuAscii", (PyCFunction)_wrap_TStr_ConvUsFromYuAscii, METH_O, (char *)"\n" + "TStr_ConvUsFromYuAscii(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_GetUsFromYuAscii", (PyCFunction)_wrap_TStr_GetUsFromYuAscii, METH_O, (char *)"\n" + "TStr_GetUsFromYuAscii(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_ToHex", (PyCFunction)_wrap_TStr_ToHex, METH_O, (char *)"\n" + "TStr_ToHex(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_GetHex", (PyCFunction)_wrap_TStr_GetHex, METH_O, (char *)"\n" + "TStr_GetHex(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_FromHex", (PyCFunction)_wrap_TStr_FromHex, METH_O, (char *)"\n" + "TStr_FromHex(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + "\n" + ""}, + { (char *)"TStr_GetFromHex", (PyCFunction)_wrap_TStr_GetFromHex, METH_O, (char *)"\n" + "TStr_GetFromHex(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetSubStr", _wrap_TStr_GetSubStr, METH_VARARGS, (char *)"\n" + "GetSubStr(int const & BChN, int const & EChN) -> TStr\n" + "\n" + "Parameters:\n" + " BChN: int const &\n" + " EChN: int const &\n" + "\n" + "TStr_GetSubStr(TStr self, int const & BChN) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " BChN: int const &\n" + "\n" + ""}, + { (char *)"TStr_InsStr", _wrap_TStr_InsStr, METH_VARARGS, (char *)"\n" + "TStr_InsStr(TStr self, int const & BChN, TStr Str)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " BChN: int const &\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_DelChAll", _wrap_TStr_DelChAll, METH_VARARGS, (char *)"\n" + "TStr_DelChAll(TStr self, char const & Ch)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStr_DelSubStr", _wrap_TStr_DelSubStr, METH_VARARGS, (char *)"\n" + "TStr_DelSubStr(TStr self, int const & BChN, int const & EChN)\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " BChN: int const &\n" + " EChN: int const &\n" + "\n" + ""}, + { (char *)"TStr_DelStr", _wrap_TStr_DelStr, METH_VARARGS, (char *)"\n" + "TStr_DelStr(TStr self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_LeftOf", _wrap_TStr_LeftOf, METH_VARARGS, (char *)"\n" + "TStr_LeftOf(TStr self, char const & SplitCh) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SplitCh: char const &\n" + "\n" + ""}, + { (char *)"TStr_LeftOfLast", _wrap_TStr_LeftOfLast, METH_VARARGS, (char *)"\n" + "TStr_LeftOfLast(TStr self, char const & SplitCh) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SplitCh: char const &\n" + "\n" + ""}, + { (char *)"TStr_RightOf", _wrap_TStr_RightOf, METH_VARARGS, (char *)"\n" + "TStr_RightOf(TStr self, char const & SplitCh) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SplitCh: char const &\n" + "\n" + ""}, + { (char *)"TStr_RightOfLast", _wrap_TStr_RightOfLast, METH_VARARGS, (char *)"\n" + "TStr_RightOfLast(TStr self, char const & SplitCh) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SplitCh: char const &\n" + "\n" + ""}, + { (char *)"TStr_SplitOnCh", _wrap_TStr_SplitOnCh, METH_VARARGS, (char *)"\n" + "TStr_SplitOnCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " LStr: TStr &\n" + " SplitCh: char const &\n" + " RStr: TStr &\n" + "\n" + ""}, + { (char *)"TStr_SplitOnLastCh", _wrap_TStr_SplitOnLastCh, METH_VARARGS, (char *)"\n" + "TStr_SplitOnLastCh(TStr self, TStr LStr, char const & SplitCh, TStr RStr)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " LStr: TStr &\n" + " SplitCh: char const &\n" + " RStr: TStr &\n" + "\n" + ""}, + { (char *)"TStr_SplitOnAllCh", _wrap_TStr_SplitOnAllCh, METH_VARARGS, (char *)"\n" + "SplitOnAllCh(char const & SplitCh, TStrV StrV, bool const & SkipEmpty=True)\n" + "\n" + "Parameters:\n" + " SplitCh: char const &\n" + " StrV: TStrV &\n" + " SkipEmpty: bool const &\n" + "\n" + "TStr_SplitOnAllCh(TStr self, char const & SplitCh, TStrV StrV)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SplitCh: char const &\n" + " StrV: TStrV &\n" + "\n" + ""}, + { (char *)"TStr_SplitOnAllAnyCh", _wrap_TStr_SplitOnAllAnyCh, METH_VARARGS, (char *)"\n" + "SplitOnAllAnyCh(TStr SplitChStr, TStrV StrV, bool const & SkipEmpty=True)\n" + "\n" + "Parameters:\n" + " SplitChStr: TStr const &\n" + " StrV: TStrV &\n" + " SkipEmpty: bool const &\n" + "\n" + "TStr_SplitOnAllAnyCh(TStr self, TStr SplitChStr, TStrV StrV)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " SplitChStr: TStr const &\n" + " StrV: TStrV &\n" + "\n" + ""}, + { (char *)"TStr_SplitOnWs", _wrap_TStr_SplitOnWs, METH_VARARGS, (char *)"\n" + "TStr_SplitOnWs(TStr self, TStrV StrV)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " StrV: TStrV &\n" + "\n" + ""}, + { (char *)"TStr_SplitOnNonAlNum", _wrap_TStr_SplitOnNonAlNum, METH_VARARGS, (char *)"\n" + "TStr_SplitOnNonAlNum(TStr self, TStrV StrV)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " StrV: TStrV &\n" + "\n" + ""}, + { (char *)"TStr_SplitOnStr", _wrap_TStr_SplitOnStr, METH_VARARGS, (char *)"\n" + "SplitOnStr(TStr SplitStr, TStrV StrV)\n" + "\n" + "Parameters:\n" + " SplitStr: TStr const &\n" + " StrV: TStrV &\n" + "\n" + "TStr_SplitOnStr(TStr self, TStr LeftStr, TStr MidStr, TStr RightStr)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " LeftStr: TStr &\n" + " MidStr: TStr const &\n" + " RightStr: TStr &\n" + "\n" + ""}, + { (char *)"TStr_Mid", _wrap_TStr_Mid, METH_VARARGS, (char *)"\n" + "Mid(int const & BChN, int const & Chs) -> TStr\n" + "\n" + "Parameters:\n" + " BChN: int const &\n" + " Chs: int const &\n" + "\n" + "TStr_Mid(TStr self, int const & BChN) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " BChN: int const &\n" + "\n" + ""}, + { (char *)"TStr_Left", _wrap_TStr_Left, METH_VARARGS, (char *)"\n" + "TStr_Left(TStr self, int const & EChN) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " EChN: int const &\n" + "\n" + ""}, + { (char *)"TStr_Right", _wrap_TStr_Right, METH_VARARGS, (char *)"\n" + "TStr_Right(TStr self, int const & BChN) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " BChN: int const &\n" + "\n" + ""}, + { (char *)"TStr_Slice", _wrap_TStr_Slice, METH_VARARGS, (char *)"\n" + "TStr_Slice(TStr self, int BChN, int EChNP1) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " BChN: int\n" + " EChNP1: int\n" + "\n" + ""}, + { (char *)"TStr___call__", _wrap_TStr___call__, METH_VARARGS, (char *)"\n" + "__call__() -> char\n" + "__call__() -> char const\n" + "TStr___call__(TStr self, int const & BChN, int const & EChNP1) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " BChN: int const &\n" + " EChNP1: int const &\n" + "\n" + ""}, + { (char *)"TStr_CountCh", _wrap_TStr_CountCh, METH_VARARGS, (char *)"\n" + "CountCh(char const & Ch, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + " BChN: int const &\n" + "\n" + "TStr_CountCh(TStr self, char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStr_SearchCh", _wrap_TStr_SearchCh, METH_VARARGS, (char *)"\n" + "SearchCh(char const & Ch, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + " BChN: int const &\n" + "\n" + "TStr_SearchCh(TStr self, char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStr_SearchChBack", _wrap_TStr_SearchChBack, METH_VARARGS, (char *)"\n" + "SearchChBack(char const & Ch, int BChN=-1) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + " BChN: int\n" + "\n" + "TStr_SearchChBack(TStr self, char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStr_SearchStr", _wrap_TStr_SearchStr, METH_VARARGS, (char *)"\n" + "SearchStr(TStr Str, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + " BChN: int const &\n" + "\n" + "TStr_SearchStr(TStr self, TStr Str) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_IsChIn", _wrap_TStr_IsChIn, METH_VARARGS, (char *)"\n" + "TStr_IsChIn(TStr self, char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStr_IsStrIn", _wrap_TStr_IsStrIn, METH_VARARGS, (char *)"\n" + "TStr_IsStrIn(TStr self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_IsPrefix", _wrap_TStr_IsPrefix, METH_VARARGS, (char *)"\n" + "IsPrefix(char const * Str) -> bool\n" + "\n" + "Parameters:\n" + " Str: char const *\n" + "\n" + "TStr_IsPrefix(TStr self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_IsSuffix", _wrap_TStr_IsSuffix, METH_VARARGS, (char *)"\n" + "IsSuffix(char const * Str) -> bool\n" + "\n" + "Parameters:\n" + " Str: char const *\n" + "\n" + "TStr_IsSuffix(TStr self, TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_ChangeCh", _wrap_TStr_ChangeCh, METH_VARARGS, (char *)"\n" + "ChangeCh(char const & SrcCh, char const & DstCh, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " SrcCh: char const &\n" + " DstCh: char const &\n" + " BChN: int const &\n" + "\n" + "TStr_ChangeCh(TStr self, char const & SrcCh, char const & DstCh) -> int\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " SrcCh: char const &\n" + " DstCh: char const &\n" + "\n" + ""}, + { (char *)"TStr_ChangeChAll", _wrap_TStr_ChangeChAll, METH_VARARGS, (char *)"\n" + "TStr_ChangeChAll(TStr self, char const & SrcCh, char const & DstCh) -> int\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " SrcCh: char const &\n" + " DstCh: char const &\n" + "\n" + ""}, + { (char *)"TStr_ChangeStr", _wrap_TStr_ChangeStr, METH_VARARGS, (char *)"\n" + "ChangeStr(TStr SrcStr, TStr DstStr, int const & BChN=0) -> int\n" + "\n" + "Parameters:\n" + " SrcStr: TStr const &\n" + " DstStr: TStr const &\n" + " BChN: int const &\n" + "\n" + "TStr_ChangeStr(TStr self, TStr SrcStr, TStr DstStr) -> int\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " SrcStr: TStr const &\n" + " DstStr: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_ChangeStrAll", _wrap_TStr_ChangeStrAll, METH_VARARGS, (char *)"\n" + "ChangeStrAll(TStr SrcStr, TStr DstStr, bool const & FromStartP=False) -> int\n" + "\n" + "Parameters:\n" + " SrcStr: TStr const &\n" + " DstStr: TStr const &\n" + " FromStartP: bool const &\n" + "\n" + "TStr_ChangeStrAll(TStr self, TStr SrcStr, TStr DstStr) -> int\n" + "\n" + "Parameters:\n" + " self: TStr *\n" + " SrcStr: TStr const &\n" + " DstStr: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_Reverse", (PyCFunction)_wrap_TStr_Reverse, METH_O, (char *)"\n" + "TStr_Reverse(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetPrimHashCd", (PyCFunction)_wrap_TStr_GetPrimHashCd, METH_O, (char *)"\n" + "TStr_GetPrimHashCd(TStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetSecHashCd", (PyCFunction)_wrap_TStr_GetSecHashCd, METH_O, (char *)"\n" + "TStr_GetSecHashCd(TStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_IsBool", _wrap_TStr_IsBool, METH_VARARGS, (char *)"\n" + "TStr_IsBool(TStr self, bool & Val) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " Val: bool &\n" + "\n" + ""}, + { (char *)"TStr_IsInt", _wrap_TStr_IsInt, METH_VARARGS, (char *)"\n" + "IsInt(bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: int const &\n" + " MxVal: int const &\n" + " Val: int &\n" + "\n" + "IsInt(int & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: int &\n" + "\n" + "TStr_IsInt(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetInt", _wrap_TStr_GetInt, METH_VARARGS, (char *)"\n" + "GetInt() -> int\n" + "TStr_GetInt(TStr self, int const & DfVal) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " DfVal: int const &\n" + "\n" + ""}, + { (char *)"TStr_IsUInt", _wrap_TStr_IsUInt, METH_VARARGS, (char *)"\n" + "IsUInt(bool const & Check, uint const & MnVal, uint const & MxVal, uint & Val) -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: uint const &\n" + " MxVal: uint const &\n" + " Val: uint &\n" + "\n" + "IsUInt(uint & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: uint &\n" + "\n" + "TStr_IsUInt(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetUInt", _wrap_TStr_GetUInt, METH_VARARGS, (char *)"\n" + "GetUInt() -> uint\n" + "TStr_GetUInt(TStr self, uint const & DfVal) -> uint\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " DfVal: uint const &\n" + "\n" + ""}, + { (char *)"TStr_IsInt64", _wrap_TStr_IsInt64, METH_VARARGS, (char *)"\n" + "IsInt64(bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: int64 const &\n" + " MxVal: int64 const &\n" + " Val: int64 &\n" + "\n" + "IsInt64(int64 & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: int64 &\n" + "\n" + "TStr_IsInt64(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetInt64", _wrap_TStr_GetInt64, METH_VARARGS, (char *)"\n" + "GetInt64() -> int64\n" + "TStr_GetInt64(TStr self, int64 const & DfVal) -> int64\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " DfVal: int64 const &\n" + "\n" + ""}, + { (char *)"TStr_IsUInt64", _wrap_TStr_IsUInt64, METH_VARARGS, (char *)"\n" + "IsUInt64(bool const & Check, uint64 const & MnVal, uint64 const & MxVal, uint64 & Val) -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: uint64 const &\n" + " MxVal: uint64 const &\n" + " Val: uint64 &\n" + "\n" + "IsUInt64(uint64 & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: uint64 &\n" + "\n" + "TStr_IsUInt64(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetUInt64", _wrap_TStr_GetUInt64, METH_VARARGS, (char *)"\n" + "GetUInt64() -> uint64\n" + "TStr_GetUInt64(TStr self, uint64 const & DfVal) -> uint64\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " DfVal: uint64 const &\n" + "\n" + ""}, + { (char *)"TStr_IsHexInt", _wrap_TStr_IsHexInt, METH_VARARGS, (char *)"\n" + "IsHexInt(bool const & Check, int const & MnVal, int const & MxVal, int & Val) -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: int const &\n" + " MxVal: int const &\n" + " Val: int &\n" + "\n" + "IsHexInt(int & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: int &\n" + "\n" + "TStr_IsHexInt(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetHexInt", _wrap_TStr_GetHexInt, METH_VARARGS, (char *)"\n" + "GetHexInt() -> int\n" + "TStr_GetHexInt(TStr self, int const & DfVal) -> int\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " DfVal: int const &\n" + "\n" + ""}, + { (char *)"TStr_IsHexInt64", _wrap_TStr_IsHexInt64, METH_VARARGS, (char *)"\n" + "IsHexInt64(bool const & Check, int64 const & MnVal, int64 const & MxVal, int64 & Val) -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: int64 const &\n" + " MxVal: int64 const &\n" + " Val: int64 &\n" + "\n" + "IsHexInt64(int64 & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: int64 &\n" + "\n" + "TStr_IsHexInt64(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetHexInt64", _wrap_TStr_GetHexInt64, METH_VARARGS, (char *)"\n" + "GetHexInt64() -> int64\n" + "TStr_GetHexInt64(TStr self, int64 const & DfVal) -> int64\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " DfVal: int64 const &\n" + "\n" + ""}, + { (char *)"TStr_IsFlt", _wrap_TStr_IsFlt, METH_VARARGS, (char *)"\n" + "IsFlt(bool const & Check, double const & MnVal, double const & MxVal, double & Val, char const & DecDelimCh='.') -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: double const &\n" + " MxVal: double const &\n" + " Val: double &\n" + " DecDelimCh: char const &\n" + "\n" + "IsFlt(bool const & Check, double const & MnVal, double const & MxVal, double & Val) -> bool\n" + "\n" + "Parameters:\n" + " Check: bool const &\n" + " MnVal: double const &\n" + " MxVal: double const &\n" + " Val: double &\n" + "\n" + "IsFlt(double & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: double &\n" + "\n" + "TStr_IsFlt(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetFlt", _wrap_TStr_GetFlt, METH_VARARGS, (char *)"\n" + "GetFlt() -> double\n" + "TStr_GetFlt(TStr self, double const & DfVal) -> double\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " DfVal: double const &\n" + "\n" + ""}, + { (char *)"TStr_IsWord", _wrap_TStr_IsWord, METH_VARARGS, (char *)"\n" + "IsWord(bool const & WsPrefixP=True, bool const & FirstUcAllowedP=True) -> bool\n" + "\n" + "Parameters:\n" + " WsPrefixP: bool const &\n" + " FirstUcAllowedP: bool const &\n" + "\n" + "IsWord(bool const & WsPrefixP=True) -> bool\n" + "\n" + "Parameters:\n" + " WsPrefixP: bool const &\n" + "\n" + "TStr_IsWord(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_IsWs", (PyCFunction)_wrap_TStr_IsWs, METH_O, (char *)"\n" + "TStr_IsWs(TStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_IsWcMatch", _wrap_TStr_IsWcMatch, METH_VARARGS, (char *)"\n" + "IsWcMatch(int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*', \n" + " char const & QuestCh='?') -> bool\n" + "\n" + "Parameters:\n" + " StrBChN: int const &\n" + " WcStr: TStr const &\n" + " WcStrBChN: int const &\n" + " StarStrV: TStrV &\n" + " StarCh: char const &\n" + " QuestCh: char const &\n" + "\n" + "IsWcMatch(int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV, char const & StarCh='*') -> bool\n" + "\n" + "Parameters:\n" + " StrBChN: int const &\n" + " WcStr: TStr const &\n" + " WcStrBChN: int const &\n" + " StarStrV: TStrV &\n" + " StarCh: char const &\n" + "\n" + "IsWcMatch(int const & StrBChN, TStr WcStr, int const & WcStrBChN, TStrV StarStrV) -> bool\n" + "\n" + "Parameters:\n" + " StrBChN: int const &\n" + " WcStr: TStr const &\n" + " WcStrBChN: int const &\n" + " StarStrV: TStrV &\n" + "\n" + "IsWcMatch(TStr WcStr, TStrV StarStrV, char const & StarCh='*', char const & QuestCh='?') -> bool\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + " StarStrV: TStrV &\n" + " StarCh: char const &\n" + " QuestCh: char const &\n" + "\n" + "IsWcMatch(TStr WcStr, TStrV StarStrV, char const & StarCh='*') -> bool\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + " StarStrV: TStrV &\n" + " StarCh: char const &\n" + "\n" + "IsWcMatch(TStr WcStr, TStrV StarStrV) -> bool\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + " StarStrV: TStrV &\n" + "\n" + "IsWcMatch(TStr WcStr, char const & StarCh, char const & QuestCh) -> bool\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + " StarCh: char const &\n" + " QuestCh: char const &\n" + "\n" + "IsWcMatch(TStr WcStr, int const & StarStrN, TStr StarStr) -> bool\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + " StarStrN: int const &\n" + " StarStr: TStr &\n" + "\n" + "TStr_IsWcMatch(TStr self, TStr WcStr) -> bool\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " WcStr: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetWcMatch", _wrap_TStr_GetWcMatch, METH_VARARGS, (char *)"\n" + "GetWcMatch(TStr WcStr, int const & StarStrN=0) -> TStr\n" + "\n" + "Parameters:\n" + " WcStr: TStr const &\n" + " StarStrN: int const &\n" + "\n" + "TStr_GetWcMatch(TStr self, TStr WcStr) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " WcStr: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetFPath", (PyCFunction)_wrap_TStr_GetFPath, METH_O, (char *)"\n" + "TStr_GetFPath(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetFBase", (PyCFunction)_wrap_TStr_GetFBase, METH_O, (char *)"\n" + "TStr_GetFBase(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetFMid", (PyCFunction)_wrap_TStr_GetFMid, METH_O, (char *)"\n" + "TStr_GetFMid(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetFExt", (PyCFunction)_wrap_TStr_GetFExt, METH_O, (char *)"\n" + "TStr_GetFExt(TStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_GetNrFPath", (PyCFunction)_wrap_TStr_GetNrFPath, METH_O, (char *)"\n" + "TStr_GetNrFPath(TStr FPath) -> TStr\n" + "\n" + "Parameters:\n" + " FPath: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetNrFMid", (PyCFunction)_wrap_TStr_GetNrFMid, METH_O, (char *)"\n" + "TStr_GetNrFMid(TStr FMid) -> TStr\n" + "\n" + "Parameters:\n" + " FMid: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetNrFExt", (PyCFunction)_wrap_TStr_GetNrFExt, METH_O, (char *)"\n" + "TStr_GetNrFExt(TStr FExt) -> TStr\n" + "\n" + "Parameters:\n" + " FExt: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetNrNumFExt", (PyCFunction)_wrap_TStr_GetNrNumFExt, METH_O, (char *)"\n" + "TStr_GetNrNumFExt(int const & FExtN) -> TStr\n" + "\n" + "Parameters:\n" + " FExtN: int const &\n" + "\n" + ""}, + { (char *)"TStr_GetNrFNm", (PyCFunction)_wrap_TStr_GetNrFNm, METH_O, (char *)"\n" + "TStr_GetNrFNm(TStr FNm) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetNrAbsFPath", _wrap_TStr_GetNrAbsFPath, METH_VARARGS, (char *)"\n" + "GetNrAbsFPath(TStr FPath, TStr BaseFPath=TStr()) -> TStr\n" + "\n" + "Parameters:\n" + " FPath: TStr const &\n" + " BaseFPath: TStr const &\n" + "\n" + "TStr_GetNrAbsFPath(TStr FPath) -> TStr\n" + "\n" + "Parameters:\n" + " FPath: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_IsAbsFPath", (PyCFunction)_wrap_TStr_IsAbsFPath, METH_O, (char *)"\n" + "TStr_IsAbsFPath(TStr FPath) -> bool\n" + "\n" + "Parameters:\n" + " FPath: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_PutFExt", _wrap_TStr_PutFExt, METH_VARARGS, (char *)"\n" + "TStr_PutFExt(TStr FNm, TStr FExt) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " FExt: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_PutFExtIfEmpty", _wrap_TStr_PutFExtIfEmpty, METH_VARARGS, (char *)"\n" + "TStr_PutFExtIfEmpty(TStr FNm, TStr FExt) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " FExt: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_PutFBase", _wrap_TStr_PutFBase, METH_VARARGS, (char *)"\n" + "TStr_PutFBase(TStr FNm, TStr FBase) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " FBase: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_PutFBaseIfEmpty", _wrap_TStr_PutFBaseIfEmpty, METH_VARARGS, (char *)"\n" + "TStr_PutFBaseIfEmpty(TStr FNm, TStr FBase) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " FBase: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_AddToFMid", _wrap_TStr_AddToFMid, METH_VARARGS, (char *)"\n" + "TStr_AddToFMid(TStr FNm, TStr ExtFMid) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " ExtFMid: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetNumFNm", _wrap_TStr_GetNumFNm, METH_VARARGS, (char *)"\n" + "TStr_GetNumFNm(TStr FNm, int const & Num) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + " Num: int const &\n" + "\n" + ""}, + { (char *)"TStr_GetFNmStr", _wrap_TStr_GetFNmStr, METH_VARARGS, (char *)"\n" + "GetFNmStr(TStr Str, bool const & AlNumOnlyP=True) -> TStr\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + " AlNumOnlyP: bool const &\n" + "\n" + "TStr_GetFNmStr(TStr Str) -> TStr\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_LoadTxt", _wrap_TStr_LoadTxt, METH_VARARGS, (char *)"\n" + "LoadTxt(PSIn const & SIn) -> TStr\n" + "\n" + "Parameters:\n" + " SIn: PSIn const &\n" + "\n" + "TStr_LoadTxt(TStr FNm) -> TStr\n" + "\n" + "Parameters:\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_SaveTxt", _wrap_TStr_SaveTxt, METH_VARARGS, (char *)"\n" + "SaveTxt(PSOut const & SOut)\n" + "\n" + "Parameters:\n" + " SOut: PSOut const &\n" + "\n" + "TStr_SaveTxt(TStr self, TStr FNm)\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetChStr", (PyCFunction)_wrap_TStr_GetChStr, METH_O, (char *)"\n" + "TStr_GetChStr(char const & Ch) -> TStr\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TStr_GetDChStr", _wrap_TStr_GetDChStr, METH_VARARGS, (char *)"\n" + "TStr_GetDChStr(char const & Ch1, char const & Ch2) -> TStr\n" + "\n" + "Parameters:\n" + " Ch1: char const &\n" + " Ch2: char const &\n" + "\n" + ""}, + { (char *)"TStr_Fmt", _wrap_TStr_Fmt, METH_VARARGS, (char *)"\n" + "TStr_Fmt(char const * FmtStr) -> TStr\n" + "\n" + "Parameters:\n" + " FmtStr: char const *\n" + "\n" + ""}, + { (char *)"TStr_GetSpaceStr", (PyCFunction)_wrap_TStr_GetSpaceStr, METH_O, (char *)"\n" + "TStr_GetSpaceStr(int const & Spaces) -> TStr\n" + "\n" + "Parameters:\n" + " Spaces: int const &\n" + "\n" + ""}, + { (char *)"TStr_GetCStr", (PyCFunction)_wrap_TStr_GetCStr, METH_O, (char *)"\n" + "TStr_GetCStr(TStr self) -> char *\n" + "\n" + "Parameters:\n" + " self: TStr const *\n" + "\n" + ""}, + { (char *)"TStr_MkClone", (PyCFunction)_wrap_TStr_MkClone, METH_O, (char *)"\n" + "TStr_MkClone(TStr Str) -> TStr\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStr_GetNullStr", (PyCFunction)_wrap_TStr_GetNullStr, METH_NOARGS, (char *)"TStr_GetNullStr() -> TStr"}, + { (char *)"TStr_swigregister", TStr_swigregister, METH_VARARGS, NULL}, + { (char *)"TStr_swiginit", TStr_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TStrIn", (PyCFunction)_wrap_new_TStrIn, METH_O, (char *)"\n" + "new_TStrIn(TStr _Str) -> TStrIn\n" + "\n" + "Parameters:\n" + " _Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStrIn_New", (PyCFunction)_wrap_TStrIn_New, METH_O, (char *)"\n" + "TStrIn_New(TStr Str) -> PSIn\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"delete_TStrIn", (PyCFunction)_wrap_delete_TStrIn, METH_O, (char *)"\n" + "delete_TStrIn(TStrIn self)\n" + "\n" + "Parameters:\n" + " self: TStrIn *\n" + "\n" + ""}, + { (char *)"TStrIn_swigregister", TStrIn_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrIn_swiginit", TStrIn_swiginit, METH_VARARGS, NULL}, + { (char *)"TDbStr_Str1_set", _wrap_TDbStr_Str1_set, METH_VARARGS, (char *)"\n" + "TDbStr_Str1_set(TDbStr self, TStr Str1)\n" + "\n" + "Parameters:\n" + " self: TDbStr *\n" + " Str1: TStr *\n" + "\n" + ""}, + { (char *)"TDbStr_Str1_get", (PyCFunction)_wrap_TDbStr_Str1_get, METH_O, (char *)"\n" + "TDbStr_Str1_get(TDbStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TDbStr *\n" + "\n" + ""}, + { (char *)"TDbStr_Str2_set", _wrap_TDbStr_Str2_set, METH_VARARGS, (char *)"\n" + "TDbStr_Str2_set(TDbStr self, TStr Str2)\n" + "\n" + "Parameters:\n" + " self: TDbStr *\n" + " Str2: TStr *\n" + "\n" + ""}, + { (char *)"TDbStr_Str2_get", (PyCFunction)_wrap_TDbStr_Str2_get, METH_O, (char *)"\n" + "TDbStr_Str2_get(TDbStr self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TDbStr *\n" + "\n" + ""}, + { (char *)"new_TDbStr", _wrap_new_TDbStr, METH_VARARGS, (char *)"\n" + "TDbStr()\n" + "TDbStr(TDbStr DbStr)\n" + "\n" + "Parameters:\n" + " DbStr: TDbStr const &\n" + "\n" + "TDbStr(TStr _Str1)\n" + "\n" + "Parameters:\n" + " _Str1: TStr const &\n" + "\n" + "TDbStr(TStr _Str1, TStr _Str2)\n" + "\n" + "Parameters:\n" + " _Str1: TStr const &\n" + " _Str2: TStr const &\n" + "\n" + "new_TDbStr(TSIn SIn) -> TDbStr\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TDbStr_Save", _wrap_TDbStr_Save, METH_VARARGS, (char *)"\n" + "TDbStr_Save(TDbStr self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TDbStr const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TDbStr___eq__", _wrap_TDbStr___eq__, METH_VARARGS, (char *)"\n" + "TDbStr___eq__(TDbStr self, TDbStr DbStr) -> bool\n" + "\n" + "Parameters:\n" + " self: TDbStr const *\n" + " DbStr: TDbStr const &\n" + "\n" + ""}, + { (char *)"TDbStr___lt__", _wrap_TDbStr___lt__, METH_VARARGS, (char *)"\n" + "TDbStr___lt__(TDbStr self, TDbStr DbStr) -> bool\n" + "\n" + "Parameters:\n" + " self: TDbStr const *\n" + " DbStr: TDbStr const &\n" + "\n" + ""}, + { (char *)"TDbStr_GetPrimHashCd", (PyCFunction)_wrap_TDbStr_GetPrimHashCd, METH_O, (char *)"\n" + "TDbStr_GetPrimHashCd(TDbStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TDbStr const *\n" + "\n" + ""}, + { (char *)"TDbStr_GetSecHashCd", (PyCFunction)_wrap_TDbStr_GetSecHashCd, METH_O, (char *)"\n" + "TDbStr_GetSecHashCd(TDbStr self) -> int\n" + "\n" + "Parameters:\n" + " self: TDbStr const *\n" + "\n" + ""}, + { (char *)"TDbStr_Empty", (PyCFunction)_wrap_TDbStr_Empty, METH_O, (char *)"\n" + "TDbStr_Empty(TDbStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TDbStr const *\n" + "\n" + ""}, + { (char *)"TDbStr_Filled", (PyCFunction)_wrap_TDbStr_Filled, METH_O, (char *)"\n" + "TDbStr_Filled(TDbStr self) -> bool\n" + "\n" + "Parameters:\n" + " self: TDbStr const *\n" + "\n" + ""}, + { (char *)"delete_TDbStr", (PyCFunction)_wrap_delete_TDbStr, METH_O, (char *)"\n" + "delete_TDbStr(TDbStr self)\n" + "\n" + "Parameters:\n" + " self: TDbStr *\n" + "\n" + ""}, + { (char *)"TDbStr_swigregister", TDbStr_swigregister, METH_VARARGS, NULL}, + { (char *)"TDbStr_swiginit", TDbStr_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TStrPool", _wrap_new_TStrPool, METH_VARARGS, (char *)"\n" + "TStrPool(uint const & MxBfLen=0, uint const & _GrowBy=16*1024*1024)\n" + "\n" + "Parameters:\n" + " MxBfLen: uint const &\n" + " _GrowBy: uint const &\n" + "\n" + "TStrPool(uint const & MxBfLen=0)\n" + "\n" + "Parameters:\n" + " MxBfLen: uint const &\n" + "\n" + "TStrPool()\n" + "TStrPool(TSIn SIn, bool LoadCompact=True)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " LoadCompact: bool\n" + "\n" + "TStrPool(TSIn SIn)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "new_TStrPool(TStrPool Pool) -> TStrPool\n" + "\n" + "Parameters:\n" + " Pool: TStrPool const &\n" + "\n" + ""}, + { (char *)"delete_TStrPool", (PyCFunction)_wrap_delete_TStrPool, METH_O, (char *)"\n" + "delete_TStrPool(TStrPool self)\n" + "\n" + "Parameters:\n" + " self: TStrPool *\n" + "\n" + ""}, + { (char *)"TStrPool_New", _wrap_TStrPool_New, METH_VARARGS, (char *)"\n" + "New(uint const & _MxBfLen=0, uint const & _GrowBy=16*1024*1024) -> PStrPool\n" + "\n" + "Parameters:\n" + " _MxBfLen: uint const &\n" + " _GrowBy: uint const &\n" + "\n" + "New(uint const & _MxBfLen=0) -> PStrPool\n" + "\n" + "Parameters:\n" + " _MxBfLen: uint const &\n" + "\n" + "New() -> PStrPool\n" + "New(TSIn SIn) -> PStrPool\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "TStrPool_New(TStr fileName) -> PStrPool\n" + "\n" + "Parameters:\n" + " fileName: TStr const &\n" + "\n" + ""}, + { (char *)"TStrPool_Load", _wrap_TStrPool_Load, METH_VARARGS, (char *)"\n" + "Load(TSIn SIn, bool LoadCompacted=True) -> PStrPool\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " LoadCompacted: bool\n" + "\n" + "TStrPool_Load(TSIn SIn) -> PStrPool\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TStrPool_Save", _wrap_TStrPool_Save, METH_VARARGS, (char *)"\n" + "Save(TSOut SOut)\n" + "\n" + "Parameters:\n" + " SOut: TSOut &\n" + "\n" + "TStrPool_Save(TStrPool self, TStr FNm)\n" + "\n" + "Parameters:\n" + " self: TStrPool *\n" + " FNm: TStr const &\n" + "\n" + ""}, + { (char *)"TStrPool_Len", (PyCFunction)_wrap_TStrPool_Len, METH_O, (char *)"\n" + "TStrPool_Len(TStrPool self) -> uint\n" + "\n" + "Parameters:\n" + " self: TStrPool const *\n" + "\n" + ""}, + { (char *)"TStrPool_Size", (PyCFunction)_wrap_TStrPool_Size, METH_O, (char *)"\n" + "TStrPool_Size(TStrPool self) -> uint\n" + "\n" + "Parameters:\n" + " self: TStrPool const *\n" + "\n" + ""}, + { (char *)"TStrPool_Empty", (PyCFunction)_wrap_TStrPool_Empty, METH_O, (char *)"\n" + "TStrPool_Empty(TStrPool self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStrPool const *\n" + "\n" + ""}, + { (char *)"TStrPool___call__", (PyCFunction)_wrap_TStrPool___call__, METH_O, (char *)"\n" + "TStrPool___call__(TStrPool self) -> char *\n" + "\n" + "Parameters:\n" + " self: TStrPool const *\n" + "\n" + ""}, + { (char *)"TStrPool_AddStr", _wrap_TStrPool_AddStr, METH_VARARGS, (char *)"\n" + "AddStr(char const * Str, uint const & Len) -> uint\n" + "\n" + "Parameters:\n" + " Str: char const *\n" + " Len: uint const &\n" + "\n" + "AddStr(char const * Str) -> uint\n" + "\n" + "Parameters:\n" + " Str: char const *\n" + "\n" + "TStrPool_AddStr(TStrPool self, TStr Str) -> uint\n" + "\n" + "Parameters:\n" + " self: TStrPool *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStrPool_GetCStr", _wrap_TStrPool_GetCStr, METH_VARARGS, (char *)"\n" + "TStrPool_GetCStr(TStrPool self, uint const & Offset) -> char const *\n" + "\n" + "Parameters:\n" + " self: TStrPool const *\n" + " Offset: uint const &\n" + "\n" + ""}, + { (char *)"TStrPool_Clr", _wrap_TStrPool_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool DoDel=False)\n" + "\n" + "Parameters:\n" + " DoDel: bool\n" + "\n" + "TStrPool_Clr(TStrPool self)\n" + "\n" + "Parameters:\n" + " self: TStrPool *\n" + "\n" + ""}, + { (char *)"TStrPool_Cmp", _wrap_TStrPool_Cmp, METH_VARARGS, (char *)"\n" + "TStrPool_Cmp(TStrPool self, uint const & Offset, char const * Str) -> int\n" + "\n" + "Parameters:\n" + " self: TStrPool const *\n" + " Offset: uint const &\n" + " Str: char const *\n" + "\n" + ""}, + { (char *)"TStrPool_GetPrimHashCd", _wrap_TStrPool_GetPrimHashCd, METH_VARARGS, (char *)"\n" + "GetPrimHashCd(char const * CStr) -> int\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TStrPool_GetPrimHashCd(TStrPool self, uint const & Offset) -> int\n" + "\n" + "Parameters:\n" + " self: TStrPool *\n" + " Offset: uint const &\n" + "\n" + ""}, + { (char *)"TStrPool_GetSecHashCd", _wrap_TStrPool_GetSecHashCd, METH_VARARGS, (char *)"\n" + "GetSecHashCd(char const * CStr) -> int\n" + "\n" + "Parameters:\n" + " CStr: char const *\n" + "\n" + "TStrPool_GetSecHashCd(TStrPool self, uint const & Offset) -> int\n" + "\n" + "Parameters:\n" + " self: TStrPool *\n" + " Offset: uint const &\n" + "\n" + ""}, + { (char *)"TStrPool_swigregister", TStrPool_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrPool_swiginit", TStrPool_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TStrPool64", _wrap_new_TStrPool64, METH_VARARGS, (char *)"\n" + "TStrPool64(::TSize _MxBfL=0, ::TSize _GrowBy=16*1024*1024)\n" + "\n" + "Parameters:\n" + " _MxBfL: ::TSize\n" + " _GrowBy: ::TSize\n" + "\n" + "TStrPool64(::TSize _MxBfL=0)\n" + "\n" + "Parameters:\n" + " _MxBfL: ::TSize\n" + "\n" + "TStrPool64()\n" + "TStrPool64(TStrPool64 StrPool)\n" + "\n" + "Parameters:\n" + " StrPool: TStrPool64 const &\n" + "\n" + "TStrPool64(TSIn SIn, bool LoadCompact=True)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " LoadCompact: bool\n" + "\n" + "new_TStrPool64(TSIn SIn) -> TStrPool64\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"delete_TStrPool64", (PyCFunction)_wrap_delete_TStrPool64, METH_O, (char *)"\n" + "delete_TStrPool64(TStrPool64 self)\n" + "\n" + "Parameters:\n" + " self: TStrPool64 *\n" + "\n" + ""}, + { (char *)"TStrPool64_Save", _wrap_TStrPool64_Save, METH_VARARGS, (char *)"\n" + "TStrPool64_Save(TStrPool64 self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TStrPool64 const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TStrPool64_New", _wrap_TStrPool64_New, METH_VARARGS, (char *)"\n" + "New(::TSize MxBfL=0, ::TSize GrowBy=16*1024*1024) -> PStrPool64\n" + "\n" + "Parameters:\n" + " MxBfL: ::TSize\n" + " GrowBy: ::TSize\n" + "\n" + "New(::TSize MxBfL=0) -> PStrPool64\n" + "\n" + "Parameters:\n" + " MxBfL: ::TSize\n" + "\n" + "TStrPool64_New() -> PStrPool64\n" + ""}, + { (char *)"TStrPool64_Load", _wrap_TStrPool64_Load, METH_VARARGS, (char *)"\n" + "Load(TSIn SIn, bool LoadCompact=True) -> PStrPool64\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " LoadCompact: bool\n" + "\n" + "TStrPool64_Load(TSIn SIn) -> PStrPool64\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TStrPool64_GetMemUsed", (PyCFunction)_wrap_TStrPool64_GetMemUsed, METH_O, (char *)"\n" + "TStrPool64_GetMemUsed(TStrPool64 self) -> uint64\n" + "\n" + "Parameters:\n" + " self: TStrPool64 const *\n" + "\n" + ""}, + { (char *)"TStrPool64_Empty", (PyCFunction)_wrap_TStrPool64_Empty, METH_O, (char *)"\n" + "TStrPool64_Empty(TStrPool64 self) -> bool\n" + "\n" + "Parameters:\n" + " self: TStrPool64 const *\n" + "\n" + ""}, + { (char *)"TStrPool64_Len", (PyCFunction)_wrap_TStrPool64_Len, METH_O, (char *)"\n" + "TStrPool64_Len(TStrPool64 self) -> uint64\n" + "\n" + "Parameters:\n" + " self: TStrPool64 const *\n" + "\n" + ""}, + { (char *)"TStrPool64_Reserved", (PyCFunction)_wrap_TStrPool64_Reserved, METH_O, (char *)"\n" + "TStrPool64_Reserved(TStrPool64 self) -> uint64\n" + "\n" + "Parameters:\n" + " self: TStrPool64 const *\n" + "\n" + ""}, + { (char *)"TStrPool64_Clr", _wrap_TStrPool64_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool DoDel=False)\n" + "\n" + "Parameters:\n" + " DoDel: bool\n" + "\n" + "TStrPool64_Clr(TStrPool64 self)\n" + "\n" + "Parameters:\n" + " self: TStrPool64 *\n" + "\n" + ""}, + { (char *)"TStrPool64_Cmp", _wrap_TStrPool64_Cmp, METH_VARARGS, (char *)"\n" + "TStrPool64_Cmp(TStrPool64 self, uint64 Offset, char const * Str) -> int\n" + "\n" + "Parameters:\n" + " self: TStrPool64 const *\n" + " Offset: uint64\n" + " Str: char const *\n" + "\n" + ""}, + { (char *)"TStrPool64_AddStr", _wrap_TStrPool64_AddStr, METH_VARARGS, (char *)"\n" + "TStrPool64_AddStr(TStrPool64 self, TStr Str) -> uint64\n" + "\n" + "Parameters:\n" + " self: TStrPool64 *\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TStrPool64_swigregister", TStrPool64_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrPool64_swiginit", TStrPool64_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TVoid", _wrap_new_TVoid, METH_VARARGS, (char *)"\n" + "TVoid()\n" + "new_TVoid(TSIn arg1) -> TVoid\n" + "\n" + "Parameters:\n" + " arg1: TSIn &\n" + "\n" + ""}, + { (char *)"TVoid_Save", _wrap_TVoid_Save, METH_VARARGS, (char *)"\n" + "TVoid_Save(TVoid self, TSOut arg2)\n" + "\n" + "Parameters:\n" + " self: TVoid const *\n" + " arg2: TSOut &\n" + "\n" + ""}, + { (char *)"TVoid_LoadXml", _wrap_TVoid_LoadXml, METH_VARARGS, (char *)"\n" + "TVoid_LoadXml(TVoid self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TVoid *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TVoid_SaveXml", _wrap_TVoid_SaveXml, METH_VARARGS, (char *)"\n" + "TVoid_SaveXml(TVoid self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TVoid const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TVoid___eq__", _wrap_TVoid___eq__, METH_VARARGS, (char *)"\n" + "TVoid___eq__(TVoid self, TVoid arg2) -> bool\n" + "\n" + "Parameters:\n" + " self: TVoid const *\n" + " arg2: TVoid const &\n" + "\n" + ""}, + { (char *)"TVoid___lt__", _wrap_TVoid___lt__, METH_VARARGS, (char *)"\n" + "TVoid___lt__(TVoid self, TVoid arg2) -> bool\n" + "\n" + "Parameters:\n" + " self: TVoid const *\n" + " arg2: TVoid const &\n" + "\n" + ""}, + { (char *)"TVoid_GetMemUsed", (PyCFunction)_wrap_TVoid_GetMemUsed, METH_O, (char *)"\n" + "TVoid_GetMemUsed(TVoid self) -> int\n" + "\n" + "Parameters:\n" + " self: TVoid const *\n" + "\n" + ""}, + { (char *)"delete_TVoid", (PyCFunction)_wrap_delete_TVoid, METH_O, (char *)"\n" + "delete_TVoid(TVoid self)\n" + "\n" + "Parameters:\n" + " self: TVoid *\n" + "\n" + ""}, + { (char *)"TVoid_swigregister", TVoid_swigregister, METH_VARARGS, NULL}, + { (char *)"TVoid_swiginit", TVoid_swiginit, METH_VARARGS, NULL}, + { (char *)"TBool_Val_set", _wrap_TBool_Val_set, METH_VARARGS, (char *)"\n" + "TBool_Val_set(TBool self, bool Val)\n" + "\n" + "Parameters:\n" + " self: TBool *\n" + " Val: bool\n" + "\n" + ""}, + { (char *)"TBool_Val_get", (PyCFunction)_wrap_TBool_Val_get, METH_O, (char *)"\n" + "TBool_Val_get(TBool self) -> bool\n" + "\n" + "Parameters:\n" + " self: TBool *\n" + "\n" + ""}, + { (char *)"TBool_Rnd_get", _wrap_TBool_Rnd_get, METH_VARARGS, NULL}, + { (char *)"TBool_Rnd_set", _wrap_TBool_Rnd_set, METH_VARARGS, NULL}, + { (char *)"TBool___nonzero__", (PyCFunction)_wrap_TBool___nonzero__, METH_O, (char *)"\n" + "TBool___nonzero__(TBool self) -> bool\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + "\n" + ""}, + { (char *)"new_TBool", _wrap_new_TBool, METH_VARARGS, (char *)"\n" + "TBool()\n" + "TBool(bool const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: bool const &\n" + "\n" + "new_TBool(TSIn SIn) -> TBool\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TBool_Load", _wrap_TBool_Load, METH_VARARGS, (char *)"\n" + "TBool_Load(TBool self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TBool *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TBool_Save", _wrap_TBool_Save, METH_VARARGS, (char *)"\n" + "TBool_Save(TBool self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TBool_LoadXml", _wrap_TBool_LoadXml, METH_VARARGS, (char *)"\n" + "TBool_LoadXml(TBool self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TBool *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TBool_SaveXml", _wrap_TBool_SaveXml, METH_VARARGS, (char *)"\n" + "TBool_SaveXml(TBool self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TBool___eq__", _wrap_TBool___eq__, METH_VARARGS, (char *)"\n" + "TBool___eq__(TBool self, TBool Bool) -> bool\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + " Bool: TBool const &\n" + "\n" + ""}, + { (char *)"TBool___lt__", _wrap_TBool___lt__, METH_VARARGS, (char *)"\n" + "TBool___lt__(TBool self, TBool Bool) -> bool\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + " Bool: TBool const &\n" + "\n" + ""}, + { (char *)"TBool___call__", (PyCFunction)_wrap_TBool___call__, METH_O, (char *)"\n" + "TBool___call__(TBool self) -> bool\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + "\n" + ""}, + { (char *)"TBool_GetMemUsed", (PyCFunction)_wrap_TBool_GetMemUsed, METH_O, (char *)"\n" + "TBool_GetMemUsed(TBool self) -> int\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + "\n" + ""}, + { (char *)"TBool_GetPrimHashCd", (PyCFunction)_wrap_TBool_GetPrimHashCd, METH_O, (char *)"\n" + "TBool_GetPrimHashCd(TBool self) -> int\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + "\n" + ""}, + { (char *)"TBool_GetSecHashCd", (PyCFunction)_wrap_TBool_GetSecHashCd, METH_O, (char *)"\n" + "TBool_GetSecHashCd(TBool self) -> int\n" + "\n" + "Parameters:\n" + " self: TBool const *\n" + "\n" + ""}, + { (char *)"TBool_GetRnd", (PyCFunction)_wrap_TBool_GetRnd, METH_NOARGS, (char *)"TBool_GetRnd() -> bool"}, + { (char *)"TBool_GetYNStr", (PyCFunction)_wrap_TBool_GetYNStr, METH_O, (char *)"\n" + "TBool_GetYNStr(bool const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: bool const &\n" + "\n" + ""}, + { (char *)"TBool_GetYesNoStr", (PyCFunction)_wrap_TBool_GetYesNoStr, METH_O, (char *)"\n" + "TBool_GetYesNoStr(bool const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: bool const &\n" + "\n" + ""}, + { (char *)"TBool_Get01Str", (PyCFunction)_wrap_TBool_Get01Str, METH_O, (char *)"\n" + "TBool_Get01Str(bool const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: bool const &\n" + "\n" + ""}, + { (char *)"TBool_IsValStr", (PyCFunction)_wrap_TBool_IsValStr, METH_O, (char *)"\n" + "TBool_IsValStr(TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + ""}, + { (char *)"TBool_GetValFromStr", _wrap_TBool_GetValFromStr, METH_VARARGS, (char *)"\n" + "GetValFromStr(TStr Str) -> bool\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + "\n" + "TBool_GetValFromStr(TStr Str, bool const & DfVal) -> bool\n" + "\n" + "Parameters:\n" + " Str: TStr const &\n" + " DfVal: bool const &\n" + "\n" + ""}, + { (char *)"delete_TBool", (PyCFunction)_wrap_delete_TBool, METH_O, (char *)"\n" + "delete_TBool(TBool self)\n" + "\n" + "Parameters:\n" + " self: TBool *\n" + "\n" + ""}, + { (char *)"TBool_swigregister", TBool_swigregister, METH_VARARGS, NULL}, + { (char *)"TBool_swiginit", TBool_swiginit, METH_VARARGS, NULL}, + { (char *)"TCh_Val_set", _wrap_TCh_Val_set, METH_VARARGS, (char *)"\n" + "TCh_Val_set(TCh self, char Val)\n" + "\n" + "Parameters:\n" + " self: TCh *\n" + " Val: char\n" + "\n" + ""}, + { (char *)"TCh_Val_get", (PyCFunction)_wrap_TCh_Val_get, METH_O, (char *)"\n" + "TCh_Val_get(TCh self) -> char\n" + "\n" + "Parameters:\n" + " self: TCh *\n" + "\n" + ""}, + { (char *)"new_TCh", _wrap_new_TCh, METH_VARARGS, (char *)"\n" + "TCh()\n" + "TCh(char const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: char const &\n" + "\n" + "new_TCh(TSIn SIn) -> TCh\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TCh_Save", _wrap_TCh_Save, METH_VARARGS, (char *)"\n" + "TCh_Save(TCh self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TCh_LoadXml", _wrap_TCh_LoadXml, METH_VARARGS, (char *)"\n" + "TCh_LoadXml(TCh self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TCh *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TCh_SaveXml", _wrap_TCh_SaveXml, METH_VARARGS, (char *)"\n" + "TCh_SaveXml(TCh self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TCh___eq__", _wrap_TCh___eq__, METH_VARARGS, (char *)"\n" + "TCh___eq__(TCh self, TCh Ch) -> bool\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + " Ch: TCh const &\n" + "\n" + ""}, + { (char *)"TCh___lt__", _wrap_TCh___lt__, METH_VARARGS, (char *)"\n" + "TCh___lt__(TCh self, TCh Ch) -> bool\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + " Ch: TCh const &\n" + "\n" + ""}, + { (char *)"TCh___call__", (PyCFunction)_wrap_TCh___call__, METH_O, (char *)"\n" + "TCh___call__(TCh self) -> char\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + "\n" + ""}, + { (char *)"TCh_GetMemUsed", (PyCFunction)_wrap_TCh_GetMemUsed, METH_O, (char *)"\n" + "TCh_GetMemUsed(TCh self) -> int\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + "\n" + ""}, + { (char *)"TCh_GetPrimHashCd", (PyCFunction)_wrap_TCh_GetPrimHashCd, METH_O, (char *)"\n" + "TCh_GetPrimHashCd(TCh self) -> int\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + "\n" + ""}, + { (char *)"TCh_GetSecHashCd", (PyCFunction)_wrap_TCh_GetSecHashCd, METH_O, (char *)"\n" + "TCh_GetSecHashCd(TCh self) -> int\n" + "\n" + "Parameters:\n" + " self: TCh const *\n" + "\n" + ""}, + { (char *)"TCh_IsWs", (PyCFunction)_wrap_TCh_IsWs, METH_O, (char *)"\n" + "TCh_IsWs(char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_IsAlpha", (PyCFunction)_wrap_TCh_IsAlpha, METH_O, (char *)"\n" + "TCh_IsAlpha(char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_IsNum", (PyCFunction)_wrap_TCh_IsNum, METH_O, (char *)"\n" + "TCh_IsNum(char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_IsAlNum", (PyCFunction)_wrap_TCh_IsAlNum, METH_O, (char *)"\n" + "TCh_IsAlNum(char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_GetNum", (PyCFunction)_wrap_TCh_GetNum, METH_O, (char *)"\n" + "TCh_GetNum(char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_IsHex", (PyCFunction)_wrap_TCh_IsHex, METH_O, (char *)"\n" + "TCh_IsHex(char const & Ch) -> bool\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_GetHex", (PyCFunction)_wrap_TCh_GetHex, METH_O, (char *)"\n" + "TCh_GetHex(char const & Ch) -> int\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_GetHexCh", (PyCFunction)_wrap_TCh_GetHexCh, METH_O, (char *)"\n" + "TCh_GetHexCh(int const & Val) -> char\n" + "\n" + "Parameters:\n" + " Val: int const &\n" + "\n" + ""}, + { (char *)"TCh_IsUc", (PyCFunction)_wrap_TCh_IsUc, METH_O, (char *)"\n" + "TCh_IsUc(char const & Ch) -> char\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_GetUc", (PyCFunction)_wrap_TCh_GetUc, METH_O, (char *)"\n" + "TCh_GetUc(char const & Ch) -> char\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"TCh_GetUsFromYuAscii", (PyCFunction)_wrap_TCh_GetUsFromYuAscii, METH_O, (char *)"\n" + "TCh_GetUsFromYuAscii(char const & Ch) -> char\n" + "\n" + "Parameters:\n" + " Ch: char const &\n" + "\n" + ""}, + { (char *)"delete_TCh", (PyCFunction)_wrap_delete_TCh, METH_O, (char *)"\n" + "delete_TCh(TCh self)\n" + "\n" + "Parameters:\n" + " self: TCh *\n" + "\n" + ""}, + { (char *)"TCh_swigregister", TCh_swigregister, METH_VARARGS, NULL}, + { (char *)"TCh_swiginit", TCh_swiginit, METH_VARARGS, NULL}, + { (char *)"TUCh_Val_set", _wrap_TUCh_Val_set, METH_VARARGS, (char *)"\n" + "TUCh_Val_set(TUCh self, uchar Val)\n" + "\n" + "Parameters:\n" + " self: TUCh *\n" + " Val: uchar\n" + "\n" + ""}, + { (char *)"TUCh_Val_get", (PyCFunction)_wrap_TUCh_Val_get, METH_O, (char *)"\n" + "TUCh_Val_get(TUCh self) -> uchar\n" + "\n" + "Parameters:\n" + " self: TUCh *\n" + "\n" + ""}, + { (char *)"new_TUCh", _wrap_new_TUCh, METH_VARARGS, (char *)"\n" + "TUCh()\n" + "TUCh(uchar const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: uchar const &\n" + "\n" + "new_TUCh(TSIn SIn) -> TUCh\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TUCh_Save", _wrap_TUCh_Save, METH_VARARGS, (char *)"\n" + "TUCh_Save(TUCh self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TUCh_LoadXml", _wrap_TUCh_LoadXml, METH_VARARGS, (char *)"\n" + "TUCh_LoadXml(TUCh self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TUCh *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TUCh_SaveXml", _wrap_TUCh_SaveXml, METH_VARARGS, (char *)"\n" + "TUCh_SaveXml(TUCh self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TUCh___eq__", _wrap_TUCh___eq__, METH_VARARGS, (char *)"\n" + "TUCh___eq__(TUCh self, TUCh UCh) -> bool\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + " UCh: TUCh const &\n" + "\n" + ""}, + { (char *)"TUCh___lt__", _wrap_TUCh___lt__, METH_VARARGS, (char *)"\n" + "TUCh___lt__(TUCh self, TUCh UCh) -> bool\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + " UCh: TUCh const &\n" + "\n" + ""}, + { (char *)"TUCh___call__", (PyCFunction)_wrap_TUCh___call__, METH_O, (char *)"\n" + "TUCh___call__(TUCh self) -> uchar\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + "\n" + ""}, + { (char *)"TUCh_GetMemUsed", (PyCFunction)_wrap_TUCh_GetMemUsed, METH_O, (char *)"\n" + "TUCh_GetMemUsed(TUCh self) -> int\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + "\n" + ""}, + { (char *)"TUCh_GetPrimHashCd", (PyCFunction)_wrap_TUCh_GetPrimHashCd, METH_O, (char *)"\n" + "TUCh_GetPrimHashCd(TUCh self) -> int\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + "\n" + ""}, + { (char *)"TUCh_GetSecHashCd", (PyCFunction)_wrap_TUCh_GetSecHashCd, METH_O, (char *)"\n" + "TUCh_GetSecHashCd(TUCh self) -> int\n" + "\n" + "Parameters:\n" + " self: TUCh const *\n" + "\n" + ""}, + { (char *)"delete_TUCh", (PyCFunction)_wrap_delete_TUCh, METH_O, (char *)"\n" + "delete_TUCh(TUCh self)\n" + "\n" + "Parameters:\n" + " self: TUCh *\n" + "\n" + ""}, + { (char *)"TUCh_swigregister", TUCh_swigregister, METH_VARARGS, NULL}, + { (char *)"TUCh_swiginit", TUCh_swiginit, METH_VARARGS, NULL}, + { (char *)"TSInt_Val_set", _wrap_TSInt_Val_set, METH_VARARGS, (char *)"\n" + "TSInt_Val_set(TSInt self, int16 Val)\n" + "\n" + "Parameters:\n" + " self: TSInt *\n" + " Val: int16\n" + "\n" + ""}, + { (char *)"TSInt_Val_get", (PyCFunction)_wrap_TSInt_Val_get, METH_O, (char *)"\n" + "TSInt_Val_get(TSInt self) -> int16\n" + "\n" + "Parameters:\n" + " self: TSInt *\n" + "\n" + ""}, + { (char *)"new_TSInt", _wrap_new_TSInt, METH_VARARGS, (char *)"\n" + "TSInt()\n" + "TSInt(int16 const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: int16 const &\n" + "\n" + "new_TSInt(TSIn SIn) -> TSInt\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TSInt_Load", _wrap_TSInt_Load, METH_VARARGS, (char *)"\n" + "TSInt_Load(TSInt self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TSInt *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TSInt_Save", _wrap_TSInt_Save, METH_VARARGS, (char *)"\n" + "TSInt_Save(TSInt self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TSInt const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TSInt_GetPrimHashCd", (PyCFunction)_wrap_TSInt_GetPrimHashCd, METH_O, (char *)"\n" + "TSInt_GetPrimHashCd(TSInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TSInt const *\n" + "\n" + ""}, + { (char *)"TSInt_GetSecHashCd", (PyCFunction)_wrap_TSInt_GetSecHashCd, METH_O, (char *)"\n" + "TSInt_GetSecHashCd(TSInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TSInt const *\n" + "\n" + ""}, + { (char *)"delete_TSInt", (PyCFunction)_wrap_delete_TSInt, METH_O, (char *)"\n" + "delete_TSInt(TSInt self)\n" + "\n" + "Parameters:\n" + " self: TSInt *\n" + "\n" + ""}, + { (char *)"TSInt_swigregister", TSInt_swigregister, METH_VARARGS, NULL}, + { (char *)"TSInt_swiginit", TSInt_swiginit, METH_VARARGS, NULL}, + { (char *)"TInt_Val_set", _wrap_TInt_Val_set, METH_VARARGS, (char *)"\n" + "TInt_Val_set(TInt self, int Val)\n" + "\n" + "Parameters:\n" + " self: TInt *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TInt_Val_get", (PyCFunction)_wrap_TInt_Val_get, METH_O, (char *)"\n" + "TInt_Val_get(TInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TInt *\n" + "\n" + ""}, + { (char *)"TInt_Rnd_get", _wrap_TInt_Rnd_get, METH_VARARGS, NULL}, + { (char *)"TInt_Rnd_set", _wrap_TInt_Rnd_set, METH_VARARGS, NULL}, + { (char *)"new_TInt", _wrap_new_TInt, METH_VARARGS, (char *)"\n" + "TInt()\n" + "TInt(int const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: int const &\n" + "\n" + "new_TInt(TSIn SIn) -> TInt\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TInt_Load", _wrap_TInt_Load, METH_VARARGS, (char *)"\n" + "TInt_Load(TInt self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TInt *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TInt_Save", _wrap_TInt_Save, METH_VARARGS, (char *)"\n" + "TInt_Save(TInt self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TInt_LoadXml", _wrap_TInt_LoadXml, METH_VARARGS, (char *)"\n" + "TInt_LoadXml(TInt self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TInt *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TInt_SaveXml", _wrap_TInt_SaveXml, METH_VARARGS, (char *)"\n" + "TInt_SaveXml(TInt self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TInt___eq__", _wrap_TInt___eq__, METH_VARARGS, (char *)"\n" + "__eq__(TInt Int) -> bool\n" + "\n" + "Parameters:\n" + " Int: TInt const &\n" + "\n" + "TInt___eq__(TInt self, int const & Int) -> bool\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt___ne__", _wrap_TInt___ne__, METH_VARARGS, (char *)"\n" + "TInt___ne__(TInt self, int const & Int) -> bool\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt___lt__", _wrap_TInt___lt__, METH_VARARGS, (char *)"\n" + "__lt__(TInt Int) -> bool\n" + "\n" + "Parameters:\n" + " Int: TInt const &\n" + "\n" + "TInt___lt__(TInt self, int const & Int) -> bool\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt___call__", (PyCFunction)_wrap_TInt___call__, METH_O, (char *)"\n" + "TInt___call__(TInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + "\n" + ""}, + { (char *)"TInt___iadd__", _wrap_TInt___iadd__, METH_VARARGS, (char *)"\n" + "TInt___iadd__(TInt self, int const & Int) -> TInt\n" + "\n" + "Parameters:\n" + " self: TInt *\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt___isub__", _wrap_TInt___isub__, METH_VARARGS, (char *)"\n" + "TInt___isub__(TInt self, int const & Int) -> TInt\n" + "\n" + "Parameters:\n" + " self: TInt *\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt_GetMemUsed", (PyCFunction)_wrap_TInt_GetMemUsed, METH_O, (char *)"\n" + "TInt_GetMemUsed(TInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + "\n" + ""}, + { (char *)"TInt_GetPrimHashCd", (PyCFunction)_wrap_TInt_GetPrimHashCd, METH_O, (char *)"\n" + "TInt_GetPrimHashCd(TInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + "\n" + ""}, + { (char *)"TInt_GetSecHashCd", (PyCFunction)_wrap_TInt_GetSecHashCd, METH_O, (char *)"\n" + "TInt_GetSecHashCd(TInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TInt const *\n" + "\n" + ""}, + { (char *)"TInt_Abs", (PyCFunction)_wrap_TInt_Abs, METH_O, (char *)"\n" + "TInt_Abs(int const & Int) -> int\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt_Sign", (PyCFunction)_wrap_TInt_Sign, METH_O, (char *)"\n" + "TInt_Sign(int const & Int) -> int\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt_Swap", _wrap_TInt_Swap, METH_VARARGS, (char *)"\n" + "TInt_Swap(int & Int1, int & Int2)\n" + "\n" + "Parameters:\n" + " Int1: int &\n" + " Int2: int &\n" + "\n" + ""}, + { (char *)"TInt_GetRnd", _wrap_TInt_GetRnd, METH_VARARGS, (char *)"\n" + "GetRnd(int const & Range=0) -> int\n" + "\n" + "Parameters:\n" + " Range: int const &\n" + "\n" + "TInt_GetRnd() -> int\n" + ""}, + { (char *)"TInt_IsOdd", (PyCFunction)_wrap_TInt_IsOdd, METH_O, (char *)"\n" + "TInt_IsOdd(int const & Int) -> bool\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt_IsEven", (PyCFunction)_wrap_TInt_IsEven, METH_O, (char *)"\n" + "TInt_IsEven(int const & Int) -> bool\n" + "\n" + "Parameters:\n" + " Int: int const &\n" + "\n" + ""}, + { (char *)"TInt_GetMn", _wrap_TInt_GetMn, METH_VARARGS, (char *)"\n" + "GetMn(int const & Int1, int const & Int2) -> int\n" + "\n" + "Parameters:\n" + " Int1: int const &\n" + " Int2: int const &\n" + "\n" + "GetMn(int const & Int1, int const & Int2, int const & Int3) -> int\n" + "\n" + "Parameters:\n" + " Int1: int const &\n" + " Int2: int const &\n" + " Int3: int const &\n" + "\n" + "TInt_GetMn(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int\n" + "\n" + "Parameters:\n" + " Int1: int const &\n" + " Int2: int const &\n" + " Int3: int const &\n" + " Int4: int const &\n" + "\n" + ""}, + { (char *)"TInt_GetMx", _wrap_TInt_GetMx, METH_VARARGS, (char *)"\n" + "GetMx(int const & Int1, int const & Int2) -> int\n" + "\n" + "Parameters:\n" + " Int1: int const &\n" + " Int2: int const &\n" + "\n" + "GetMx(int const & Int1, int const & Int2, int const & Int3) -> int\n" + "\n" + "Parameters:\n" + " Int1: int const &\n" + " Int2: int const &\n" + " Int3: int const &\n" + "\n" + "TInt_GetMx(int const & Int1, int const & Int2, int const & Int3, int const & Int4) -> int\n" + "\n" + "Parameters:\n" + " Int1: int const &\n" + " Int2: int const &\n" + " Int3: int const &\n" + " Int4: int const &\n" + "\n" + ""}, + { (char *)"TInt_GetInRng", _wrap_TInt_GetInRng, METH_VARARGS, (char *)"\n" + "TInt_GetInRng(int const & Val, int const & Mn, int const & Mx) -> int\n" + "\n" + "Parameters:\n" + " Val: int const &\n" + " Mn: int const &\n" + " Mx: int const &\n" + "\n" + ""}, + { (char *)"TInt_GetHexStr", _wrap_TInt_GetHexStr, METH_VARARGS, (char *)"\n" + "GetHexStr(int const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: int const &\n" + "\n" + "TInt_GetHexStr(TInt Int) -> TStr\n" + "\n" + "Parameters:\n" + " Int: TInt const &\n" + "\n" + ""}, + { (char *)"TInt_GetKiloStr", (PyCFunction)_wrap_TInt_GetKiloStr, METH_O, (char *)"\n" + "TInt_GetKiloStr(int const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: int const &\n" + "\n" + ""}, + { (char *)"TInt_GetMegaStr", (PyCFunction)_wrap_TInt_GetMegaStr, METH_O, (char *)"\n" + "TInt_GetMegaStr(int const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: int const &\n" + "\n" + ""}, + { (char *)"TInt_SaveFrugalInt", _wrap_TInt_SaveFrugalInt, METH_VARARGS, (char *)"\n" + "TInt_SaveFrugalInt(char * pDest, int i) -> char *\n" + "\n" + "Parameters:\n" + " pDest: char *\n" + " i: int\n" + "\n" + ""}, + { (char *)"TInt_LoadFrugalInt", _wrap_TInt_LoadFrugalInt, METH_VARARGS, (char *)"\n" + "TInt_LoadFrugalInt(char * pSrc, int & i) -> char *\n" + "\n" + "Parameters:\n" + " pSrc: char *\n" + " i: int &\n" + "\n" + ""}, + { (char *)"TInt_TestFrugalInt", (PyCFunction)_wrap_TInt_TestFrugalInt, METH_NOARGS, (char *)"TInt_TestFrugalInt()"}, + { (char *)"TInt_SaveFrugalIntV", _wrap_TInt_SaveFrugalIntV, METH_VARARGS, (char *)"\n" + "TInt_SaveFrugalIntV(TSOut SOut, TIntV IntV)\n" + "\n" + "Parameters:\n" + " SOut: TSOut &\n" + " IntV: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TInt_LoadFrugalIntV", _wrap_TInt_LoadFrugalIntV, METH_VARARGS, (char *)"\n" + "LoadFrugalIntV(TSIn SIn, TIntV IntV, bool ClrP=True)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " IntV: TVec< TInt,int > &\n" + " ClrP: bool\n" + "\n" + "TInt_LoadFrugalIntV(TSIn SIn, TIntV IntV)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " IntV: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"delete_TInt", (PyCFunction)_wrap_delete_TInt, METH_O, (char *)"\n" + "delete_TInt(TInt self)\n" + "\n" + "Parameters:\n" + " self: TInt *\n" + "\n" + ""}, + { (char *)"TInt_swigregister", TInt_swigregister, METH_VARARGS, NULL}, + { (char *)"TInt_swiginit", TInt_swiginit, METH_VARARGS, NULL}, + { (char *)"TUInt_Val_set", _wrap_TUInt_Val_set, METH_VARARGS, (char *)"\n" + "TUInt_Val_set(TUInt self, uint Val)\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " Val: uint\n" + "\n" + ""}, + { (char *)"TUInt_Val_get", (PyCFunction)_wrap_TUInt_Val_get, METH_O, (char *)"\n" + "TUInt_Val_get(TUInt self) -> uint\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + "\n" + ""}, + { (char *)"TUInt_Rnd_get", _wrap_TUInt_Rnd_get, METH_VARARGS, NULL}, + { (char *)"TUInt_Rnd_set", _wrap_TUInt_Rnd_set, METH_VARARGS, NULL}, + { (char *)"new_TUInt", _wrap_new_TUInt, METH_VARARGS, (char *)"\n" + "TUInt()\n" + "TUInt(uint const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: uint const &\n" + "\n" + "new_TUInt(TSIn SIn) -> TUInt\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TUInt_Load", _wrap_TUInt_Load, METH_VARARGS, (char *)"\n" + "TUInt_Load(TUInt self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TUInt_Save", _wrap_TUInt_Save, METH_VARARGS, (char *)"\n" + "TUInt_Save(TUInt self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TUInt const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TUInt_LoadXml", _wrap_TUInt_LoadXml, METH_VARARGS, (char *)"\n" + "TUInt_LoadXml(TUInt self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TUInt_SaveXml", _wrap_TUInt_SaveXml, METH_VARARGS, (char *)"\n" + "TUInt_SaveXml(TUInt self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TUInt const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TUInt___call__", _wrap_TUInt___call__, METH_VARARGS, (char *)"\n" + "__call__() -> uint\n" + "TUInt___call__(TUInt self) -> uint &\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + "\n" + ""}, + { (char *)"TUInt___invert__", (PyCFunction)_wrap_TUInt___invert__, METH_O, (char *)"\n" + "TUInt___invert__(TUInt self) -> TUInt\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + "\n" + ""}, + { (char *)"TUInt___iand__", _wrap_TUInt___iand__, METH_VARARGS, (char *)"\n" + "TUInt___iand__(TUInt self, TUInt UInt) -> TUInt\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " UInt: TUInt const &\n" + "\n" + ""}, + { (char *)"TUInt___ior__", _wrap_TUInt___ior__, METH_VARARGS, (char *)"\n" + "TUInt___ior__(TUInt self, TUInt UInt) -> TUInt\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " UInt: TUInt const &\n" + "\n" + ""}, + { (char *)"TUInt___ixor__", _wrap_TUInt___ixor__, METH_VARARGS, (char *)"\n" + "TUInt___ixor__(TUInt self, TUInt UInt) -> TUInt\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " UInt: TUInt const &\n" + "\n" + ""}, + { (char *)"TUInt___irshift__", _wrap_TUInt___irshift__, METH_VARARGS, (char *)"\n" + "TUInt___irshift__(TUInt self, int const & ShiftBits) -> TUInt\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " ShiftBits: int const &\n" + "\n" + ""}, + { (char *)"TUInt___ilshift__", _wrap_TUInt___ilshift__, METH_VARARGS, (char *)"\n" + "TUInt___ilshift__(TUInt self, int const & ShiftBits) -> TUInt\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + " ShiftBits: int const &\n" + "\n" + ""}, + { (char *)"TUInt_GetMemUsed", (PyCFunction)_wrap_TUInt_GetMemUsed, METH_O, (char *)"\n" + "TUInt_GetMemUsed(TUInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TUInt const *\n" + "\n" + ""}, + { (char *)"TUInt_GetPrimHashCd", (PyCFunction)_wrap_TUInt_GetPrimHashCd, METH_O, (char *)"\n" + "TUInt_GetPrimHashCd(TUInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TUInt const *\n" + "\n" + ""}, + { (char *)"TUInt_GetSecHashCd", (PyCFunction)_wrap_TUInt_GetSecHashCd, METH_O, (char *)"\n" + "TUInt_GetSecHashCd(TUInt self) -> int\n" + "\n" + "Parameters:\n" + " self: TUInt const *\n" + "\n" + ""}, + { (char *)"TUInt_GetRnd", _wrap_TUInt_GetRnd, METH_VARARGS, (char *)"\n" + "GetRnd(uint const & Range=0) -> uint\n" + "\n" + "Parameters:\n" + " Range: uint const &\n" + "\n" + "TUInt_GetRnd() -> uint\n" + ""}, + { (char *)"TUInt_GetKiloStr", (PyCFunction)_wrap_TUInt_GetKiloStr, METH_O, (char *)"\n" + "TUInt_GetKiloStr(uint const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: uint const &\n" + "\n" + ""}, + { (char *)"TUInt_GetMegaStr", (PyCFunction)_wrap_TUInt_GetMegaStr, METH_O, (char *)"\n" + "TUInt_GetMegaStr(uint const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: uint const &\n" + "\n" + ""}, + { (char *)"TUInt_JavaUIntToCppUInt", (PyCFunction)_wrap_TUInt_JavaUIntToCppUInt, METH_O, (char *)"\n" + "TUInt_JavaUIntToCppUInt(uint const & JavaUInt) -> uint\n" + "\n" + "Parameters:\n" + " JavaUInt: uint const &\n" + "\n" + ""}, + { (char *)"TUInt_IsIpStr", _wrap_TUInt_IsIpStr, METH_VARARGS, (char *)"\n" + "IsIpStr(TStr IpStr, uint & Ip, char const & SplitCh='.') -> bool\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + " Ip: uint &\n" + " SplitCh: char const &\n" + "\n" + "IsIpStr(TStr IpStr, uint & Ip) -> bool\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + " Ip: uint &\n" + "\n" + "IsIpStr(TStr IpStr, char const & SplitCh='.') -> bool\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + " SplitCh: char const &\n" + "\n" + "TUInt_IsIpStr(TStr IpStr) -> bool\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + "\n" + ""}, + { (char *)"TUInt_GetUIntFromIpStr", _wrap_TUInt_GetUIntFromIpStr, METH_VARARGS, (char *)"\n" + "GetUIntFromIpStr(TStr IpStr, char const & SplitCh='.') -> uint\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + " SplitCh: char const &\n" + "\n" + "TUInt_GetUIntFromIpStr(TStr IpStr) -> uint\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + "\n" + ""}, + { (char *)"TUInt_GetStrFromIpUInt", (PyCFunction)_wrap_TUInt_GetStrFromIpUInt, METH_O, (char *)"\n" + "TUInt_GetStrFromIpUInt(uint const & Ip) -> TStr\n" + "\n" + "Parameters:\n" + " Ip: uint const &\n" + "\n" + ""}, + { (char *)"TUInt_IsIpv6Str", _wrap_TUInt_IsIpv6Str, METH_VARARGS, (char *)"\n" + "IsIpv6Str(TStr IpStr, char const & SplitCh=':') -> bool\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + " SplitCh: char const &\n" + "\n" + "TUInt_IsIpv6Str(TStr IpStr) -> bool\n" + "\n" + "Parameters:\n" + " IpStr: TStr const &\n" + "\n" + ""}, + { (char *)"delete_TUInt", (PyCFunction)_wrap_delete_TUInt, METH_O, (char *)"\n" + "delete_TUInt(TUInt self)\n" + "\n" + "Parameters:\n" + " self: TUInt *\n" + "\n" + ""}, + { (char *)"TUInt_swigregister", TUInt_swigregister, METH_VARARGS, NULL}, + { (char *)"TUInt_swiginit", TUInt_swiginit, METH_VARARGS, NULL}, + { (char *)"TUInt64_Val_set", _wrap_TUInt64_Val_set, METH_VARARGS, (char *)"\n" + "TUInt64_Val_set(TUInt64 self, uint64 Val)\n" + "\n" + "Parameters:\n" + " self: TUInt64 *\n" + " Val: uint64\n" + "\n" + ""}, + { (char *)"TUInt64_Val_get", (PyCFunction)_wrap_TUInt64_Val_get, METH_O, (char *)"\n" + "TUInt64_Val_get(TUInt64 self) -> uint64\n" + "\n" + "Parameters:\n" + " self: TUInt64 *\n" + "\n" + ""}, + { (char *)"new_TUInt64", _wrap_new_TUInt64, METH_VARARGS, (char *)"\n" + "TUInt64()\n" + "TUInt64(TUInt64 Int)\n" + "\n" + "Parameters:\n" + " Int: TUInt64 const &\n" + "\n" + "TUInt64(uint64 const & Int)\n" + "\n" + "Parameters:\n" + " Int: uint64 const &\n" + "\n" + "TUInt64(uint const & MsVal, uint const & LsVal)\n" + "\n" + "Parameters:\n" + " MsVal: uint const &\n" + " LsVal: uint const &\n" + "\n" + "TUInt64(void * Pt)\n" + "\n" + "Parameters:\n" + " Pt: void *\n" + "\n" + "new_TUInt64(TSIn SIn) -> TUInt64\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TUInt64_Load", _wrap_TUInt64_Load, METH_VARARGS, (char *)"\n" + "TUInt64_Load(TUInt64 self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TUInt64 *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TUInt64_Save", _wrap_TUInt64_Save, METH_VARARGS, (char *)"\n" + "TUInt64_Save(TUInt64 self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TUInt64 const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TUInt64_LoadXml", _wrap_TUInt64_LoadXml, METH_VARARGS, (char *)"\n" + "TUInt64_LoadXml(TUInt64 self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TUInt64 *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TUInt64_SaveXml", _wrap_TUInt64_SaveXml, METH_VARARGS, (char *)"\n" + "TUInt64_SaveXml(TUInt64 self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TUInt64 const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TUInt64___iadd__", _wrap_TUInt64___iadd__, METH_VARARGS, (char *)"\n" + "TUInt64___iadd__(TUInt64 self, TUInt64 Int) -> TUInt64\n" + "\n" + "Parameters:\n" + " self: TUInt64 *\n" + " Int: TUInt64 const &\n" + "\n" + ""}, + { (char *)"TUInt64___isub__", _wrap_TUInt64___isub__, METH_VARARGS, (char *)"\n" + "TUInt64___isub__(TUInt64 self, TUInt64 Int) -> TUInt64\n" + "\n" + "Parameters:\n" + " self: TUInt64 *\n" + " Int: TUInt64 const &\n" + "\n" + ""}, + { (char *)"TUInt64_GetMemUsed", (PyCFunction)_wrap_TUInt64_GetMemUsed, METH_O, (char *)"\n" + "TUInt64_GetMemUsed(TUInt64 self) -> int\n" + "\n" + "Parameters:\n" + " self: TUInt64 const *\n" + "\n" + ""}, + { (char *)"TUInt64_GetPrimHashCd", (PyCFunction)_wrap_TUInt64_GetPrimHashCd, METH_O, (char *)"\n" + "TUInt64_GetPrimHashCd(TUInt64 self) -> int\n" + "\n" + "Parameters:\n" + " self: TUInt64 const *\n" + "\n" + ""}, + { (char *)"TUInt64_GetSecHashCd", (PyCFunction)_wrap_TUInt64_GetSecHashCd, METH_O, (char *)"\n" + "TUInt64_GetSecHashCd(TUInt64 self) -> int\n" + "\n" + "Parameters:\n" + " self: TUInt64 const *\n" + "\n" + ""}, + { (char *)"TUInt64_GetMsVal", (PyCFunction)_wrap_TUInt64_GetMsVal, METH_O, (char *)"\n" + "TUInt64_GetMsVal(TUInt64 self) -> uint\n" + "\n" + "Parameters:\n" + " self: TUInt64 const *\n" + "\n" + ""}, + { (char *)"TUInt64_GetLsVal", (PyCFunction)_wrap_TUInt64_GetLsVal, METH_O, (char *)"\n" + "TUInt64_GetLsVal(TUInt64 self) -> uint\n" + "\n" + "Parameters:\n" + " self: TUInt64 const *\n" + "\n" + ""}, + { (char *)"TUInt64_GetHexStr", (PyCFunction)_wrap_TUInt64_GetHexStr, METH_O, (char *)"\n" + "TUInt64_GetHexStr(TUInt64 Int) -> TStr\n" + "\n" + "Parameters:\n" + " Int: TUInt64 const &\n" + "\n" + ""}, + { (char *)"TUInt64_GetKiloStr", (PyCFunction)_wrap_TUInt64_GetKiloStr, METH_O, (char *)"\n" + "TUInt64_GetKiloStr(uint64 const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: uint64 const &\n" + "\n" + ""}, + { (char *)"TUInt64_GetMegaStr", (PyCFunction)_wrap_TUInt64_GetMegaStr, METH_O, (char *)"\n" + "TUInt64_GetMegaStr(uint64 const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: uint64 const &\n" + "\n" + ""}, + { (char *)"delete_TUInt64", (PyCFunction)_wrap_delete_TUInt64, METH_O, (char *)"\n" + "delete_TUInt64(TUInt64 self)\n" + "\n" + "Parameters:\n" + " self: TUInt64 *\n" + "\n" + ""}, + { (char *)"TUInt64_swigregister", TUInt64_swigregister, METH_VARARGS, NULL}, + { (char *)"TUInt64_swiginit", TUInt64_swiginit, METH_VARARGS, NULL}, + { (char *)"TFlt_Val_set", _wrap_TFlt_Val_set, METH_VARARGS, (char *)"\n" + "TFlt_Val_set(TFlt self, double Val)\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + " Val: double\n" + "\n" + ""}, + { (char *)"TFlt_Val_get", (PyCFunction)_wrap_TFlt_Val_get, METH_O, (char *)"\n" + "TFlt_Val_get(TFlt self) -> double\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + "\n" + ""}, + { (char *)"TFlt_Rnd_get", _wrap_TFlt_Rnd_get, METH_VARARGS, NULL}, + { (char *)"TFlt_Rnd_set", _wrap_TFlt_Rnd_set, METH_VARARGS, NULL}, + { (char *)"new_TFlt", _wrap_new_TFlt, METH_VARARGS, (char *)"\n" + "TFlt()\n" + "TFlt(double const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: double const &\n" + "\n" + "TFlt(TSIn SIn)\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + "new_TFlt(TSIn SIn, bool const & IsTxt) -> TFlt\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + " IsTxt: bool const &\n" + "\n" + ""}, + { (char *)"TFlt_Load", _wrap_TFlt_Load, METH_VARARGS, (char *)"\n" + "TFlt_Load(TFlt self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TFlt_Save", _wrap_TFlt_Save, METH_VARARGS, (char *)"\n" + "Save(TSOut SOut)\n" + "\n" + "Parameters:\n" + " SOut: TSOut &\n" + "\n" + "TFlt_Save(TFlt self, TSOut SOut, bool const & IsTxt)\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + " SOut: TSOut &\n" + " IsTxt: bool const &\n" + "\n" + ""}, + { (char *)"TFlt_LoadXml", _wrap_TFlt_LoadXml, METH_VARARGS, (char *)"\n" + "TFlt_LoadXml(TFlt self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TFlt_SaveXml", _wrap_TFlt_SaveXml, METH_VARARGS, (char *)"\n" + "TFlt_SaveXml(TFlt self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TFlt___eq__", _wrap_TFlt___eq__, METH_VARARGS, (char *)"\n" + "__eq__(TFlt Flt) -> bool\n" + "\n" + "Parameters:\n" + " Flt: TFlt const &\n" + "\n" + "TFlt___eq__(TFlt self, double const & Flt) -> bool\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt___ne__", _wrap_TFlt___ne__, METH_VARARGS, (char *)"\n" + "TFlt___ne__(TFlt self, double const & Flt) -> bool\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt___call__", (PyCFunction)_wrap_TFlt___call__, METH_O, (char *)"\n" + "TFlt___call__(TFlt self) -> double\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + "\n" + ""}, + { (char *)"TFlt___iadd__", _wrap_TFlt___iadd__, METH_VARARGS, (char *)"\n" + "TFlt___iadd__(TFlt self, double const & Flt) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt___isub__", _wrap_TFlt___isub__, METH_VARARGS, (char *)"\n" + "TFlt___isub__(TFlt self, double const & Flt) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt___imul__", _wrap_TFlt___imul__, METH_VARARGS, (char *)"\n" + "TFlt___imul__(TFlt self, double const & Flt) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt___idiv__", _wrap_TFlt___idiv__, METH_VARARGS, (char *)"\n" + "TFlt___idiv__(TFlt self, double const & Flt) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetMemUsed", (PyCFunction)_wrap_TFlt_GetMemUsed, METH_O, (char *)"\n" + "TFlt_GetMemUsed(TFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + "\n" + ""}, + { (char *)"TFlt_GetPrimHashCd", (PyCFunction)_wrap_TFlt_GetPrimHashCd, METH_O, (char *)"\n" + "TFlt_GetPrimHashCd(TFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + "\n" + ""}, + { (char *)"TFlt_GetSecHashCd", (PyCFunction)_wrap_TFlt_GetSecHashCd, METH_O, (char *)"\n" + "TFlt_GetSecHashCd(TFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + "\n" + ""}, + { (char *)"TFlt_Abs", (PyCFunction)_wrap_TFlt_Abs, METH_O, (char *)"\n" + "TFlt_Abs(double const & Flt) -> double\n" + "\n" + "Parameters:\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt_Sign", (PyCFunction)_wrap_TFlt_Sign, METH_O, (char *)"\n" + "TFlt_Sign(double const & Flt) -> int\n" + "\n" + "Parameters:\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt_Round", (PyCFunction)_wrap_TFlt_Round, METH_O, (char *)"\n" + "TFlt_Round(double const & Flt) -> int\n" + "\n" + "Parameters:\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetRnd", (PyCFunction)_wrap_TFlt_GetRnd, METH_NOARGS, (char *)"TFlt_GetRnd() -> double"}, + { (char *)"TFlt_Eq6", _wrap_TFlt_Eq6, METH_VARARGS, (char *)"\n" + "TFlt_Eq6(double const & LFlt, double const & RFlt) -> bool\n" + "\n" + "Parameters:\n" + " LFlt: double const &\n" + " RFlt: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetMn", _wrap_TFlt_GetMn, METH_VARARGS, (char *)"\n" + "GetMn(double const & Flt1, double const & Flt2) -> double\n" + "\n" + "Parameters:\n" + " Flt1: double const &\n" + " Flt2: double const &\n" + "\n" + "GetMn(double const & Flt1, double const & Flt2, double const & Flt3) -> double\n" + "\n" + "Parameters:\n" + " Flt1: double const &\n" + " Flt2: double const &\n" + " Flt3: double const &\n" + "\n" + "TFlt_GetMn(double const & Flt1, double const & Flt2, double const & Flt3, double const & Flt4) -> double\n" + "\n" + "Parameters:\n" + " Flt1: double const &\n" + " Flt2: double const &\n" + " Flt3: double const &\n" + " Flt4: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetMx", _wrap_TFlt_GetMx, METH_VARARGS, (char *)"\n" + "GetMx(double const & Flt1, double const & Flt2) -> double\n" + "\n" + "Parameters:\n" + " Flt1: double const &\n" + " Flt2: double const &\n" + "\n" + "GetMx(double const & Flt1, double const & Flt2, double const Flt3) -> double\n" + "\n" + "Parameters:\n" + " Flt1: double const &\n" + " Flt2: double const &\n" + " Flt3: double const\n" + "\n" + "TFlt_GetMx(double const & Flt1, double const & Flt2, double const Flt3, double const & Flt4) -> double\n" + "\n" + "Parameters:\n" + " Flt1: double const &\n" + " Flt2: double const &\n" + " Flt3: double const\n" + " Flt4: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetInRng", _wrap_TFlt_GetInRng, METH_VARARGS, (char *)"\n" + "TFlt_GetInRng(double const & Val, double const & Mn, double const & Mx) -> double\n" + "\n" + "Parameters:\n" + " Val: double const &\n" + " Mn: double const &\n" + " Mx: double const &\n" + "\n" + ""}, + { (char *)"TFlt_IsNum", _wrap_TFlt_IsNum, METH_VARARGS, (char *)"\n" + "IsNum(double const & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: double const &\n" + "\n" + "TFlt_IsNum(TFlt self) -> bool\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + "\n" + ""}, + { (char *)"TFlt_IsNan", _wrap_TFlt_IsNan, METH_VARARGS, (char *)"\n" + "IsNan(double const & Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: double const &\n" + "\n" + "TFlt_IsNan(TFlt self) -> bool\n" + "\n" + "Parameters:\n" + " self: TFlt const *\n" + "\n" + ""}, + { (char *)"TFlt_GetPrcStr", _wrap_TFlt_GetPrcStr, METH_VARARGS, (char *)"\n" + "TFlt_GetPrcStr(double const & RelVal, double const & FullVal) -> TStr\n" + "\n" + "Parameters:\n" + " RelVal: double const &\n" + " FullVal: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetKiloStr", (PyCFunction)_wrap_TFlt_GetKiloStr, METH_O, (char *)"\n" + "TFlt_GetKiloStr(double const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetMegaStr", (PyCFunction)_wrap_TFlt_GetMegaStr, METH_O, (char *)"\n" + "TFlt_GetMegaStr(double const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: double const &\n" + "\n" + ""}, + { (char *)"TFlt_GetGigaStr", (PyCFunction)_wrap_TFlt_GetGigaStr, METH_O, (char *)"\n" + "TFlt_GetGigaStr(double const & Val) -> TStr\n" + "\n" + "Parameters:\n" + " Val: double const &\n" + "\n" + ""}, + { (char *)"delete_TFlt", (PyCFunction)_wrap_delete_TFlt, METH_O, (char *)"\n" + "delete_TFlt(TFlt self)\n" + "\n" + "Parameters:\n" + " self: TFlt *\n" + "\n" + ""}, + { (char *)"TFlt_swigregister", TFlt_swigregister, METH_VARARGS, NULL}, + { (char *)"TFlt_swiginit", TFlt_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TAscFlt", _wrap_new_TAscFlt, METH_VARARGS, (char *)"\n" + "TAscFlt()\n" + "TAscFlt(double const & Val)\n" + "\n" + "Parameters:\n" + " Val: double const &\n" + "\n" + "new_TAscFlt(TSIn SIn) -> TAscFlt\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TAscFlt_Save", _wrap_TAscFlt_Save, METH_VARARGS, (char *)"\n" + "TAscFlt_Save(TAscFlt self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TAscFlt const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"delete_TAscFlt", (PyCFunction)_wrap_delete_TAscFlt, METH_O, (char *)"\n" + "delete_TAscFlt(TAscFlt self)\n" + "\n" + "Parameters:\n" + " self: TAscFlt *\n" + "\n" + ""}, + { (char *)"TAscFlt_swigregister", TAscFlt_swigregister, METH_VARARGS, NULL}, + { (char *)"TAscFlt_swiginit", TAscFlt_swiginit, METH_VARARGS, NULL}, + { (char *)"TSFlt_Val_set", _wrap_TSFlt_Val_set, METH_VARARGS, (char *)"\n" + "TSFlt_Val_set(TSFlt self, sdouble Val)\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + " Val: sdouble\n" + "\n" + ""}, + { (char *)"TSFlt_Val_get", (PyCFunction)_wrap_TSFlt_Val_get, METH_O, (char *)"\n" + "TSFlt_Val_get(TSFlt self) -> sdouble\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + "\n" + ""}, + { (char *)"new_TSFlt", _wrap_new_TSFlt, METH_VARARGS, (char *)"\n" + "TSFlt()\n" + "TSFlt(sdouble const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: sdouble const &\n" + "\n" + "new_TSFlt(TSIn SIn) -> TSFlt\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TSFlt_Save", _wrap_TSFlt_Save, METH_VARARGS, (char *)"\n" + "TSFlt_Save(TSFlt self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TSFlt_LoadXml", _wrap_TSFlt_LoadXml, METH_VARARGS, (char *)"\n" + "TSFlt_LoadXml(TSFlt self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TSFlt_SaveXml", _wrap_TSFlt_SaveXml, METH_VARARGS, (char *)"\n" + "TSFlt_SaveXml(TSFlt self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TSFlt___eq__", _wrap_TSFlt___eq__, METH_VARARGS, (char *)"\n" + "__eq__(TSFlt SFlt) -> bool\n" + "\n" + "Parameters:\n" + " SFlt: TSFlt const &\n" + "\n" + "TSFlt___eq__(TSFlt self, double const & Flt) -> bool\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TSFlt___ne__", _wrap_TSFlt___ne__, METH_VARARGS, (char *)"\n" + "TSFlt___ne__(TSFlt self, double const & Flt) -> bool\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + " Flt: double const &\n" + "\n" + ""}, + { (char *)"TSFlt___lt__", _wrap_TSFlt___lt__, METH_VARARGS, (char *)"\n" + "TSFlt___lt__(TSFlt self, TSFlt SFlt) -> bool\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + " SFlt: TSFlt const &\n" + "\n" + ""}, + { (char *)"TSFlt___call__", (PyCFunction)_wrap_TSFlt___call__, METH_O, (char *)"\n" + "TSFlt___call__(TSFlt self) -> sdouble\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + "\n" + ""}, + { (char *)"TSFlt___iadd__", _wrap_TSFlt___iadd__, METH_VARARGS, (char *)"\n" + "TSFlt___iadd__(TSFlt self, double const & SFlt) -> TSFlt\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + " SFlt: double const &\n" + "\n" + ""}, + { (char *)"TSFlt___isub__", _wrap_TSFlt___isub__, METH_VARARGS, (char *)"\n" + "TSFlt___isub__(TSFlt self, double const & SFlt) -> TSFlt\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + " SFlt: double const &\n" + "\n" + ""}, + { (char *)"TSFlt___imul__", _wrap_TSFlt___imul__, METH_VARARGS, (char *)"\n" + "TSFlt___imul__(TSFlt self, double const & SFlt) -> TSFlt\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + " SFlt: double const &\n" + "\n" + ""}, + { (char *)"TSFlt___idiv__", _wrap_TSFlt___idiv__, METH_VARARGS, (char *)"\n" + "TSFlt___idiv__(TSFlt self, double const & SFlt) -> TSFlt\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + " SFlt: double const &\n" + "\n" + ""}, + { (char *)"TSFlt_GetMemUsed", (PyCFunction)_wrap_TSFlt_GetMemUsed, METH_O, (char *)"\n" + "TSFlt_GetMemUsed(TSFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + "\n" + ""}, + { (char *)"TSFlt_GetPrimHashCd", (PyCFunction)_wrap_TSFlt_GetPrimHashCd, METH_O, (char *)"\n" + "TSFlt_GetPrimHashCd(TSFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + "\n" + ""}, + { (char *)"TSFlt_GetSecHashCd", (PyCFunction)_wrap_TSFlt_GetSecHashCd, METH_O, (char *)"\n" + "TSFlt_GetSecHashCd(TSFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TSFlt const *\n" + "\n" + ""}, + { (char *)"delete_TSFlt", (PyCFunction)_wrap_delete_TSFlt, METH_O, (char *)"\n" + "delete_TSFlt(TSFlt self)\n" + "\n" + "Parameters:\n" + " self: TSFlt *\n" + "\n" + ""}, + { (char *)"TSFlt_swigregister", TSFlt_swigregister, METH_VARARGS, NULL}, + { (char *)"TSFlt_swiginit", TSFlt_swiginit, METH_VARARGS, NULL}, + { (char *)"TLFlt_Val_set", _wrap_TLFlt_Val_set, METH_VARARGS, (char *)"\n" + "TLFlt_Val_set(TLFlt self, ldouble Val)\n" + "\n" + "Parameters:\n" + " self: TLFlt *\n" + " Val: ldouble\n" + "\n" + ""}, + { (char *)"TLFlt_Val_get", (PyCFunction)_wrap_TLFlt_Val_get, METH_O, (char *)"\n" + "TLFlt_Val_get(TLFlt self) -> ldouble\n" + "\n" + "Parameters:\n" + " self: TLFlt *\n" + "\n" + ""}, + { (char *)"new_TLFlt", _wrap_new_TLFlt, METH_VARARGS, (char *)"\n" + "TLFlt()\n" + "TLFlt(ldouble const & _Val)\n" + "\n" + "Parameters:\n" + " _Val: ldouble const &\n" + "\n" + "new_TLFlt(TSIn SIn) -> TLFlt\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TLFlt_Save", _wrap_TLFlt_Save, METH_VARARGS, (char *)"\n" + "TLFlt_Save(TLFlt self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TLFlt_LoadXml", _wrap_TLFlt_LoadXml, METH_VARARGS, (char *)"\n" + "TLFlt_LoadXml(TLFlt self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TLFlt *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TLFlt_SaveXml", _wrap_TLFlt_SaveXml, METH_VARARGS, (char *)"\n" + "TLFlt_SaveXml(TLFlt self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TLFlt___eq__", _wrap_TLFlt___eq__, METH_VARARGS, (char *)"\n" + "__eq__(TLFlt LFlt) -> bool\n" + "\n" + "Parameters:\n" + " LFlt: TLFlt const &\n" + "\n" + "TLFlt___eq__(TLFlt self, ldouble const & LFlt) -> bool\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + " LFlt: ldouble const &\n" + "\n" + ""}, + { (char *)"TLFlt___ne__", _wrap_TLFlt___ne__, METH_VARARGS, (char *)"\n" + "TLFlt___ne__(TLFlt self, ldouble const & LFlt) -> bool\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + " LFlt: ldouble const &\n" + "\n" + ""}, + { (char *)"TLFlt___lt__", _wrap_TLFlt___lt__, METH_VARARGS, (char *)"\n" + "TLFlt___lt__(TLFlt self, TLFlt LFlt) -> bool\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + " LFlt: TLFlt const &\n" + "\n" + ""}, + { (char *)"TLFlt___call__", (PyCFunction)_wrap_TLFlt___call__, METH_O, (char *)"\n" + "TLFlt___call__(TLFlt self) -> ldouble\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + "\n" + ""}, + { (char *)"TLFlt___iadd__", _wrap_TLFlt___iadd__, METH_VARARGS, (char *)"\n" + "TLFlt___iadd__(TLFlt self, ldouble const & LFlt) -> TLFlt\n" + "\n" + "Parameters:\n" + " self: TLFlt *\n" + " LFlt: ldouble const &\n" + "\n" + ""}, + { (char *)"TLFlt___isub__", _wrap_TLFlt___isub__, METH_VARARGS, (char *)"\n" + "TLFlt___isub__(TLFlt self, ldouble const & LFlt) -> TLFlt\n" + "\n" + "Parameters:\n" + " self: TLFlt *\n" + " LFlt: ldouble const &\n" + "\n" + ""}, + { (char *)"TLFlt_GetMemUsed", (PyCFunction)_wrap_TLFlt_GetMemUsed, METH_O, (char *)"\n" + "TLFlt_GetMemUsed(TLFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + "\n" + ""}, + { (char *)"TLFlt_GetPrimHashCd", (PyCFunction)_wrap_TLFlt_GetPrimHashCd, METH_O, (char *)"\n" + "TLFlt_GetPrimHashCd(TLFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + "\n" + ""}, + { (char *)"TLFlt_GetSecHashCd", (PyCFunction)_wrap_TLFlt_GetSecHashCd, METH_O, (char *)"\n" + "TLFlt_GetSecHashCd(TLFlt self) -> int\n" + "\n" + "Parameters:\n" + " self: TLFlt const *\n" + "\n" + ""}, + { (char *)"delete_TLFlt", (PyCFunction)_wrap_delete_TLFlt, METH_O, (char *)"\n" + "delete_TLFlt(TLFlt self)\n" + "\n" + "Parameters:\n" + " self: TLFlt *\n" + "\n" + ""}, + { (char *)"TLFlt_swigregister", TLFlt_swigregister, METH_VARARGS, NULL}, + { (char *)"TLFlt_swiginit", TLFlt_swiginit, METH_VARARGS, NULL}, + { (char *)"TFltRect_MnX_set", _wrap_TFltRect_MnX_set, METH_VARARGS, (char *)"\n" + "TFltRect_MnX_set(TFltRect self, TFlt MnX)\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + " MnX: TFlt *\n" + "\n" + ""}, + { (char *)"TFltRect_MnX_get", (PyCFunction)_wrap_TFltRect_MnX_get, METH_O, (char *)"\n" + "TFltRect_MnX_get(TFltRect self) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + "\n" + ""}, + { (char *)"TFltRect_MnY_set", _wrap_TFltRect_MnY_set, METH_VARARGS, (char *)"\n" + "TFltRect_MnY_set(TFltRect self, TFlt MnY)\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + " MnY: TFlt *\n" + "\n" + ""}, + { (char *)"TFltRect_MnY_get", (PyCFunction)_wrap_TFltRect_MnY_get, METH_O, (char *)"\n" + "TFltRect_MnY_get(TFltRect self) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + "\n" + ""}, + { (char *)"TFltRect_MxX_set", _wrap_TFltRect_MxX_set, METH_VARARGS, (char *)"\n" + "TFltRect_MxX_set(TFltRect self, TFlt MxX)\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + " MxX: TFlt *\n" + "\n" + ""}, + { (char *)"TFltRect_MxX_get", (PyCFunction)_wrap_TFltRect_MxX_get, METH_O, (char *)"\n" + "TFltRect_MxX_get(TFltRect self) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + "\n" + ""}, + { (char *)"TFltRect_MxY_set", _wrap_TFltRect_MxY_set, METH_VARARGS, (char *)"\n" + "TFltRect_MxY_set(TFltRect self, TFlt MxY)\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + " MxY: TFlt *\n" + "\n" + ""}, + { (char *)"TFltRect_MxY_get", (PyCFunction)_wrap_TFltRect_MxY_get, METH_O, (char *)"\n" + "TFltRect_MxY_get(TFltRect self) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + "\n" + ""}, + { (char *)"new_TFltRect", _wrap_new_TFltRect, METH_VARARGS, (char *)"\n" + "TFltRect()\n" + "TFltRect(TFltRect FltRect)\n" + "\n" + "Parameters:\n" + " FltRect: TFltRect const &\n" + "\n" + "TFltRect(double const & _MnX, double const & _MnY, double const & _MxX, double const & _MxY)\n" + "\n" + "Parameters:\n" + " _MnX: double const &\n" + " _MnY: double const &\n" + " _MxX: double const &\n" + " _MxY: double const &\n" + "\n" + "new_TFltRect(TSIn SIn) -> TFltRect\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TFltRect_Save", _wrap_TFltRect_Save, METH_VARARGS, (char *)"\n" + "TFltRect_Save(TFltRect self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TFltRect_LoadXml", _wrap_TFltRect_LoadXml, METH_VARARGS, (char *)"\n" + "TFltRect_LoadXml(TFltRect self, PXmlTok const & XmlTok, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TFltRect_SaveXml", _wrap_TFltRect_SaveXml, METH_VARARGS, (char *)"\n" + "TFltRect_SaveXml(TFltRect self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TFltRect_GetMnX", (PyCFunction)_wrap_TFltRect_GetMnX, METH_O, (char *)"\n" + "TFltRect_GetMnX(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_GetMnY", (PyCFunction)_wrap_TFltRect_GetMnY, METH_O, (char *)"\n" + "TFltRect_GetMnY(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_GetMxX", (PyCFunction)_wrap_TFltRect_GetMxX, METH_O, (char *)"\n" + "TFltRect_GetMxX(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_GetMxY", (PyCFunction)_wrap_TFltRect_GetMxY, METH_O, (char *)"\n" + "TFltRect_GetMxY(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_GetXLen", (PyCFunction)_wrap_TFltRect_GetXLen, METH_O, (char *)"\n" + "TFltRect_GetXLen(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_GetYLen", (PyCFunction)_wrap_TFltRect_GetYLen, METH_O, (char *)"\n" + "TFltRect_GetYLen(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_GetXCenter", (PyCFunction)_wrap_TFltRect_GetXCenter, METH_O, (char *)"\n" + "TFltRect_GetXCenter(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_GetYCenter", (PyCFunction)_wrap_TFltRect_GetYCenter, METH_O, (char *)"\n" + "TFltRect_GetYCenter(TFltRect self) -> double\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + "\n" + ""}, + { (char *)"TFltRect_IsXYIn", _wrap_TFltRect_IsXYIn, METH_VARARGS, (char *)"\n" + "TFltRect_IsXYIn(TFltRect self, double const & X, double const & Y) -> bool\n" + "\n" + "Parameters:\n" + " self: TFltRect const *\n" + " X: double const &\n" + " Y: double const &\n" + "\n" + ""}, + { (char *)"TFltRect_Intersection", _wrap_TFltRect_Intersection, METH_VARARGS, (char *)"\n" + "TFltRect_Intersection(TFltRect Rect1, TFltRect Rect2) -> bool\n" + "\n" + "Parameters:\n" + " Rect1: TFltRect const &\n" + " Rect2: TFltRect const &\n" + "\n" + ""}, + { (char *)"delete_TFltRect", (PyCFunction)_wrap_delete_TFltRect, METH_O, (char *)"\n" + "delete_TFltRect(TFltRect self)\n" + "\n" + "Parameters:\n" + " self: TFltRect *\n" + "\n" + ""}, + { (char *)"TFltRect_swigregister", TFltRect_swigregister, METH_VARARGS, NULL}, + { (char *)"TFltRect_swiginit", TFltRect_swiginit, METH_VARARGS, NULL}, + { (char *)"delete_TIntV", (PyCFunction)_wrap_delete_TIntV, METH_O, (char *)"\n" + "delete_TIntV(TIntV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"new_TIntV", _wrap_new_TIntV, METH_VARARGS, (char *)"\n" + "TIntV()\n" + "TIntV(TIntV Vec)\n" + "\n" + "Parameters:\n" + " Vec: TVec< TInt,int > const &\n" + "\n" + "TIntV(int const & _Vals)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TIntV(int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + "TIntV(TInt _ValT, int const & _Vals)\n" + "\n" + "Parameters:\n" + " _ValT: TInt *\n" + " _Vals: int const &\n" + "\n" + "new_TIntV(TSIn SIn) -> TIntV\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntV_Load", _wrap_TIntV_Load, METH_VARARGS, (char *)"\n" + "TIntV_Load(TIntV self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntV_Save", _wrap_TIntV_Save, METH_VARARGS, (char *)"\n" + "TIntV_Save(TIntV self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TIntV_LoadXml", _wrap_TIntV_LoadXml, METH_VARARGS, (char *)"\n" + "LoadXml(PXmlTok const & XmlTok, TStr Nm=\"\")\n" + "\n" + "Parameters:\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + "TIntV_LoadXml(TIntV self, PXmlTok const & XmlTok)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " XmlTok: PXmlTok const &\n" + "\n" + ""}, + { (char *)"TIntV_SaveXml", _wrap_TIntV_SaveXml, METH_VARARGS, (char *)"\n" + "TIntV_SaveXml(TIntV self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TIntV___add__", _wrap_TIntV___add__, METH_VARARGS, (char *)"\n" + "TIntV___add__(TIntV self, TInt Val) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV___eq__", _wrap_TIntV___eq__, METH_VARARGS, (char *)"\n" + "TIntV___eq__(TIntV self, TIntV Vec) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Vec: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntV___lt__", _wrap_TIntV___lt__, METH_VARARGS, (char *)"\n" + "TIntV___lt__(TIntV self, TIntV Vec) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Vec: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntV_GetMemUsed", (PyCFunction)_wrap_TIntV_GetMemUsed, METH_O, (char *)"\n" + "TIntV_GetMemUsed(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_GetMemSize", (PyCFunction)_wrap_TIntV_GetMemSize, METH_O, (char *)"\n" + "TIntV_GetMemSize(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_GetPrimHashCd", (PyCFunction)_wrap_TIntV_GetPrimHashCd, METH_O, (char *)"\n" + "TIntV_GetPrimHashCd(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_GetSecHashCd", (PyCFunction)_wrap_TIntV_GetSecHashCd, METH_O, (char *)"\n" + "TIntV_GetSecHashCd(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_Gen", _wrap_TIntV_Gen, METH_VARARGS, (char *)"\n" + "Gen(int const & _Vals)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TIntV_Gen(TIntV self, int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TIntV_GenExt", _wrap_TIntV_GenExt, METH_VARARGS, (char *)"\n" + "TIntV_GenExt(TIntV self, TInt _ValT, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " _ValT: TInt *\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TIntV_IsExt", (PyCFunction)_wrap_TIntV_IsExt, METH_O, (char *)"\n" + "TIntV_IsExt(TIntV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_Reserve", _wrap_TIntV_Reserve, METH_VARARGS, (char *)"\n" + "Reserve(int const & _MxVals)\n" + "\n" + "Parameters:\n" + " _MxVals: int const &\n" + "\n" + "TIntV_Reserve(TIntV self, int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TIntV_Clr", _wrap_TIntV_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool const & DoDel=True, int const & NoDelLim=-1)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + " NoDelLim: int const &\n" + "\n" + "Clr(bool const & DoDel=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + "\n" + "TIntV_Clr(TIntV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_Trunc", _wrap_TIntV_Trunc, METH_VARARGS, (char *)"\n" + "Trunc(int const & _Vals=-1)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TIntV_Trunc(TIntV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_Pack", (PyCFunction)_wrap_TIntV_Pack, METH_O, (char *)"\n" + "TIntV_Pack(TIntV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_MoveFrom", _wrap_TIntV_MoveFrom, METH_VARARGS, (char *)"\n" + "TIntV_MoveFrom(TIntV self, TIntV Vec)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Vec: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"TIntV_Empty", (PyCFunction)_wrap_TIntV_Empty, METH_O, (char *)"\n" + "TIntV_Empty(TIntV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_Len", (PyCFunction)_wrap_TIntV_Len, METH_O, (char *)"\n" + "TIntV_Len(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_Reserved", (PyCFunction)_wrap_TIntV_Reserved, METH_O, (char *)"\n" + "TIntV_Reserved(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_Last", _wrap_TIntV_Last, METH_VARARGS, (char *)"\n" + "Last() -> TInt\n" + "TIntV_Last(TIntV self) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_LastValN", (PyCFunction)_wrap_TIntV_LastValN, METH_O, (char *)"\n" + "TIntV_LastValN(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_LastLast", _wrap_TIntV_LastLast, METH_VARARGS, (char *)"\n" + "LastLast() -> TInt\n" + "TIntV_LastLast(TIntV self) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_BegI", (PyCFunction)_wrap_TIntV_BegI, METH_O, (char *)"\n" + "TIntV_BegI(TIntV self) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_EndI", (PyCFunction)_wrap_TIntV_EndI, METH_O, (char *)"\n" + "TIntV_EndI(TIntV self) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_GetI", _wrap_TIntV_GetI, METH_VARARGS, (char *)"\n" + "TIntV_GetI(TIntV self, int const & ValN) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " ValN: int const &\n" + "\n" + ""}, + { (char *)"TIntV_AddV", _wrap_TIntV_AddV, METH_VARARGS, (char *)"\n" + "TIntV_AddV(TIntV self, TIntV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntV_AddSorted", _wrap_TIntV_AddSorted, METH_VARARGS, (char *)"\n" + "AddSorted(TInt Val, bool const & Asc=True, int const & _MxVals=-1) -> int\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + " Asc: bool const &\n" + " _MxVals: int const &\n" + "\n" + "AddSorted(TInt Val, bool const & Asc=True) -> int\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + " Asc: bool const &\n" + "\n" + "TIntV_AddSorted(TIntV self, TInt Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_AddBackSorted", _wrap_TIntV_AddBackSorted, METH_VARARGS, (char *)"\n" + "TIntV_AddBackSorted(TIntV self, TInt Val, bool const & Asc) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntV_AddVMerged", _wrap_TIntV_AddVMerged, METH_VARARGS, (char *)"\n" + "TIntV_AddVMerged(TIntV self, TIntV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntV_AddUnique", _wrap_TIntV_AddUnique, METH_VARARGS, (char *)"\n" + "TIntV_AddUnique(TIntV self, TInt Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_GetVal", _wrap_TIntV_GetVal, METH_VARARGS, (char *)"\n" + "GetVal(int const & ValN) -> TInt\n" + "\n" + "Parameters:\n" + " ValN: int const &\n" + "\n" + "TIntV_GetVal(TIntV self, int const & ValN) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " ValN: int const &\n" + "\n" + ""}, + { (char *)"TIntV_GetSubValV", _wrap_TIntV_GetSubValV, METH_VARARGS, (char *)"\n" + "TIntV_GetSubValV(TIntV self, int const & BValN, int const & EValN, TIntV ValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " BValN: int const &\n" + " EValN: int const &\n" + " ValV: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"TIntV_Ins", _wrap_TIntV_Ins, METH_VARARGS, (char *)"\n" + "TIntV_Ins(TIntV self, int const & ValN, TInt Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " ValN: int const &\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_Del", _wrap_TIntV_Del, METH_VARARGS, (char *)"\n" + "Del(int const & ValN)\n" + "\n" + "Parameters:\n" + " ValN: int const &\n" + "\n" + "TIntV_Del(TIntV self, int const & MnValN, int const & MxValN)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " MnValN: int const &\n" + " MxValN: int const &\n" + "\n" + ""}, + { (char *)"TIntV_DelLast", (PyCFunction)_wrap_TIntV_DelLast, METH_O, (char *)"\n" + "TIntV_DelLast(TIntV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_DelIfIn", _wrap_TIntV_DelIfIn, METH_VARARGS, (char *)"\n" + "TIntV_DelIfIn(TIntV self, TInt Val) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_DelAll", _wrap_TIntV_DelAll, METH_VARARGS, (char *)"\n" + "TIntV_DelAll(TIntV self, TInt Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_PutAll", _wrap_TIntV_PutAll, METH_VARARGS, (char *)"\n" + "TIntV_PutAll(TIntV self, TInt Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_Swap", _wrap_TIntV_Swap, METH_VARARGS, (char *)"\n" + "Swap(TIntV Vec)\n" + "\n" + "Parameters:\n" + " Vec: TVec< TInt,int > &\n" + "\n" + "TIntV_Swap(TIntV self, int const & ValN1, int const & ValN2)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " ValN1: int const &\n" + " ValN2: int const &\n" + "\n" + ""}, + { (char *)"TIntV_SwapI", _wrap_TIntV_SwapI, METH_VARARGS, (char *)"\n" + "TIntV_SwapI(TInt LVal, TInt RVal)\n" + "\n" + "Parameters:\n" + " LVal: TVec< TInt,int >::TIter\n" + " RVal: TVec< TInt,int >::TIter\n" + "\n" + ""}, + { (char *)"TIntV_NextPerm", (PyCFunction)_wrap_TIntV_NextPerm, METH_O, (char *)"\n" + "TIntV_NextPerm(TIntV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_PrevPerm", (PyCFunction)_wrap_TIntV_PrevPerm, METH_O, (char *)"\n" + "TIntV_PrevPerm(TIntV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_GetPivotValN", _wrap_TIntV_GetPivotValN, METH_VARARGS, (char *)"\n" + "TIntV_GetPivotValN(TIntV self, int const & LValN, int const & RValN) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " LValN: int const &\n" + " RValN: int const &\n" + "\n" + ""}, + { (char *)"TIntV_BSort", _wrap_TIntV_BSort, METH_VARARGS, (char *)"\n" + "TIntV_BSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntV_ISort", _wrap_TIntV_ISort, METH_VARARGS, (char *)"\n" + "TIntV_ISort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntV_Partition", _wrap_TIntV_Partition, METH_VARARGS, (char *)"\n" + "TIntV_Partition(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntV_QSort", _wrap_TIntV_QSort, METH_VARARGS, (char *)"\n" + "TIntV_QSort(TIntV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntV_Sort", _wrap_TIntV_Sort, METH_VARARGS, (char *)"\n" + "Sort(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntV_Sort(TIntV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_IsSorted", _wrap_TIntV_IsSorted, METH_VARARGS, (char *)"\n" + "IsSorted(bool const & Asc=True) -> bool\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntV_IsSorted(TIntV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_Shuffle", _wrap_TIntV_Shuffle, METH_VARARGS, (char *)"\n" + "TIntV_Shuffle(TIntV self, TRnd Rnd)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Rnd: TRnd &\n" + "\n" + ""}, + { (char *)"TIntV_Reverse", _wrap_TIntV_Reverse, METH_VARARGS, (char *)"\n" + "Reverse()\n" + "TIntV_Reverse(TIntV self, int LValN, int RValN)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " LValN: int\n" + " RValN: int\n" + "\n" + ""}, + { (char *)"TIntV_Merge", (PyCFunction)_wrap_TIntV_Merge, METH_O, (char *)"\n" + "TIntV_Merge(TIntV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + "\n" + ""}, + { (char *)"TIntV_Intrs", _wrap_TIntV_Intrs, METH_VARARGS, (char *)"\n" + "Intrs(TIntV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + "TIntV_Intrs(TIntV self, TIntV ValV, TIntV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " ValV: TVec< TInt,int > const &\n" + " DstValV: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"TIntV_Union", _wrap_TIntV_Union, METH_VARARGS, (char *)"\n" + "Union(TIntV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + "TIntV_Union(TIntV self, TIntV ValV, TIntV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " ValV: TVec< TInt,int > const &\n" + " DstValV: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"TIntV_Diff", _wrap_TIntV_Diff, METH_VARARGS, (char *)"\n" + "Diff(TIntV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + "TIntV_Diff(TIntV self, TIntV ValV, TIntV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " ValV: TVec< TInt,int > const &\n" + " DstValV: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"TIntV_IntrsLen", _wrap_TIntV_IntrsLen, METH_VARARGS, (char *)"\n" + "TIntV_IntrsLen(TIntV self, TIntV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntV_UnionLen", _wrap_TIntV_UnionLen, METH_VARARGS, (char *)"\n" + "TIntV_UnionLen(TIntV self, TIntV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntV_Count", _wrap_TIntV_Count, METH_VARARGS, (char *)"\n" + "TIntV_Count(TIntV self, TInt Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_SearchBin", _wrap_TIntV_SearchBin, METH_VARARGS, (char *)"\n" + "SearchBin(TInt Val) -> int\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + "\n" + "TIntV_SearchBin(TIntV self, TInt Val, int & InsValN) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Val: TInt const &\n" + " InsValN: int &\n" + "\n" + ""}, + { (char *)"TIntV_SearchForw", _wrap_TIntV_SearchForw, METH_VARARGS, (char *)"\n" + "SearchForw(TInt Val, int const & BValN=0) -> int\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + " BValN: int const &\n" + "\n" + "TIntV_SearchForw(TIntV self, TInt Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_SearchBack", _wrap_TIntV_SearchBack, METH_VARARGS, (char *)"\n" + "TIntV_SearchBack(TIntV self, TInt Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_SearchVForw", _wrap_TIntV_SearchVForw, METH_VARARGS, (char *)"\n" + "SearchVForw(TIntV ValV, int const & BValN=0) -> int\n" + "\n" + "Parameters:\n" + " ValV: TVec< TInt,int > const &\n" + " BValN: int const &\n" + "\n" + "TIntV_SearchVForw(TIntV self, TIntV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " ValV: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntV_IsIn", _wrap_TIntV_IsIn, METH_VARARGS, (char *)"\n" + "IsIn(TInt Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + "\n" + "TIntV_IsIn(TIntV self, TInt Val, int & ValN) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Val: TInt const &\n" + " ValN: int &\n" + "\n" + ""}, + { (char *)"TIntV_IsInBin", _wrap_TIntV_IsInBin, METH_VARARGS, (char *)"\n" + "TIntV_IsInBin(TIntV self, TInt Val) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_GetDat", _wrap_TIntV_GetDat, METH_VARARGS, (char *)"\n" + "TIntV_GetDat(TIntV self, TInt Val) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_GetAddDat", _wrap_TIntV_GetAddDat, METH_VARARGS, (char *)"\n" + "TIntV_GetAddDat(TIntV self, TInt Val) -> TInt\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_GetMxValN", (PyCFunction)_wrap_TIntV_GetMxValN, METH_O, (char *)"\n" + "TIntV_GetMxValN(TIntV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > const *\n" + "\n" + ""}, + { (char *)"TIntV_GetV", _wrap_TIntV_GetV, METH_VARARGS, (char *)"\n" + "GetV(TInt Val1) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + "\n" + "GetV(TInt Val1, TInt Val2) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + "\n" + "GetV(TInt Val1, TInt Val2, TInt Val3) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + " Val3: TInt const &\n" + "\n" + "GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + " Val3: TInt const &\n" + " Val4: TInt const &\n" + "\n" + "GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + " Val3: TInt const &\n" + " Val4: TInt const &\n" + " Val5: TInt const &\n" + "\n" + "GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + " Val3: TInt const &\n" + " Val4: TInt const &\n" + " Val5: TInt const &\n" + " Val6: TInt const &\n" + "\n" + "GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + " Val3: TInt const &\n" + " Val4: TInt const &\n" + " Val5: TInt const &\n" + " Val6: TInt const &\n" + " Val7: TInt const &\n" + "\n" + "GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + " Val3: TInt const &\n" + " Val4: TInt const &\n" + " Val5: TInt const &\n" + " Val6: TInt const &\n" + " Val7: TInt const &\n" + " Val8: TInt const &\n" + "\n" + "TIntV_GetV(TInt Val1, TInt Val2, TInt Val3, TInt Val4, TInt Val5, TInt Val6, TInt Val7, TInt Val8, \n" + " TInt Val9) -> TIntV\n" + "\n" + "Parameters:\n" + " Val1: TInt const &\n" + " Val2: TInt const &\n" + " Val3: TInt const &\n" + " Val4: TInt const &\n" + " Val5: TInt const &\n" + " Val6: TInt const &\n" + " Val7: TInt const &\n" + " Val8: TInt const &\n" + " Val9: TInt const &\n" + "\n" + ""}, + { (char *)"TIntV_Add", _wrap_TIntV_Add, METH_VARARGS, (char *)"\n" + "Add() -> int\n" + "Add(TInt Val) -> int\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + "\n" + "Add(TInt Val, int const & ResizeLen) -> int\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + " ResizeLen: int const &\n" + "\n" + "TIntV_Add(TIntV self, int Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TIntV_AddMerged", _wrap_TIntV_AddMerged, METH_VARARGS, (char *)"\n" + "AddMerged(TInt Val) -> int\n" + "\n" + "Parameters:\n" + " Val: TInt const &\n" + "\n" + "TIntV_AddMerged(TIntV self, int Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TInt,int > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TIntV_swigregister", TIntV_swigregister, METH_VARARGS, NULL}, + { (char *)"TIntV_swiginit", TIntV_swiginit, METH_VARARGS, NULL}, + { (char *)"delete_TIntIntVV", (PyCFunction)_wrap_delete_TIntIntVV, METH_O, (char *)"\n" + "delete_TIntIntVV(TIntIntVV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"new_TIntIntVV", _wrap_new_TIntIntVV, METH_VARARGS, (char *)"\n" + "TIntIntVV()\n" + "TIntIntVV(TIntIntVV Vec)\n" + "\n" + "Parameters:\n" + " Vec: TVec< TVec< TInt,int >,int > const &\n" + "\n" + "TIntIntVV(int const & _Vals)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TIntIntVV(int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + "TIntIntVV(TIntV _ValT, int const & _Vals)\n" + "\n" + "Parameters:\n" + " _ValT: TVec< TInt,int > *\n" + " _Vals: int const &\n" + "\n" + "new_TIntIntVV(TSIn SIn) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Load", _wrap_TIntIntVV_Load, METH_VARARGS, (char *)"\n" + "TIntIntVV_Load(TIntIntVV self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Save", _wrap_TIntIntVV_Save, METH_VARARGS, (char *)"\n" + "TIntIntVV_Save(TIntIntVV self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TIntIntVV_LoadXml", _wrap_TIntIntVV_LoadXml, METH_VARARGS, (char *)"\n" + "LoadXml(PXmlTok const & XmlTok, TStr Nm=\"\")\n" + "\n" + "Parameters:\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + "TIntIntVV_LoadXml(TIntIntVV self, PXmlTok const & XmlTok)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " XmlTok: PXmlTok const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_SaveXml", _wrap_TIntIntVV_SaveXml, METH_VARARGS, (char *)"\n" + "TIntIntVV_SaveXml(TIntIntVV self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TIntIntVV___add__", _wrap_TIntIntVV___add__, METH_VARARGS, (char *)"\n" + "TIntIntVV___add__(TIntIntVV self, TIntV Val) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV___eq__", _wrap_TIntIntVV___eq__, METH_VARARGS, (char *)"\n" + "TIntIntVV___eq__(TIntIntVV self, TIntIntVV Vec) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Vec: TVec< TVec< TInt,int >,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV___lt__", _wrap_TIntIntVV___lt__, METH_VARARGS, (char *)"\n" + "TIntIntVV___lt__(TIntIntVV self, TIntIntVV Vec) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Vec: TVec< TVec< TInt,int >,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetMemUsed", (PyCFunction)_wrap_TIntIntVV_GetMemUsed, METH_O, (char *)"\n" + "TIntIntVV_GetMemUsed(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetMemSize", (PyCFunction)_wrap_TIntIntVV_GetMemSize, METH_O, (char *)"\n" + "TIntIntVV_GetMemSize(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetPrimHashCd", (PyCFunction)_wrap_TIntIntVV_GetPrimHashCd, METH_O, (char *)"\n" + "TIntIntVV_GetPrimHashCd(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetSecHashCd", (PyCFunction)_wrap_TIntIntVV_GetSecHashCd, METH_O, (char *)"\n" + "TIntIntVV_GetSecHashCd(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Gen", _wrap_TIntIntVV_Gen, METH_VARARGS, (char *)"\n" + "Gen(int const & _Vals)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TIntIntVV_Gen(TIntIntVV self, int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_GenExt", _wrap_TIntIntVV_GenExt, METH_VARARGS, (char *)"\n" + "TIntIntVV_GenExt(TIntIntVV self, TIntV _ValT, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " _ValT: TVec< TInt,int > *\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_IsExt", (PyCFunction)_wrap_TIntIntVV_IsExt, METH_O, (char *)"\n" + "TIntIntVV_IsExt(TIntIntVV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Reserve", _wrap_TIntIntVV_Reserve, METH_VARARGS, (char *)"\n" + "Reserve(int const & _MxVals)\n" + "\n" + "Parameters:\n" + " _MxVals: int const &\n" + "\n" + "TIntIntVV_Reserve(TIntIntVV self, int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Clr", _wrap_TIntIntVV_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool const & DoDel=True, int const & NoDelLim=-1)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + " NoDelLim: int const &\n" + "\n" + "Clr(bool const & DoDel=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + "\n" + "TIntIntVV_Clr(TIntIntVV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Trunc", _wrap_TIntIntVV_Trunc, METH_VARARGS, (char *)"\n" + "Trunc(int const & _Vals=-1)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TIntIntVV_Trunc(TIntIntVV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Pack", (PyCFunction)_wrap_TIntIntVV_Pack, METH_O, (char *)"\n" + "TIntIntVV_Pack(TIntIntVV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_MoveFrom", _wrap_TIntIntVV_MoveFrom, METH_VARARGS, (char *)"\n" + "TIntIntVV_MoveFrom(TIntIntVV self, TIntIntVV Vec)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Vec: TVec< TVec< TInt,int >,int > &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Empty", (PyCFunction)_wrap_TIntIntVV_Empty, METH_O, (char *)"\n" + "TIntIntVV_Empty(TIntIntVV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Len", (PyCFunction)_wrap_TIntIntVV_Len, METH_O, (char *)"\n" + "TIntIntVV_Len(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Reserved", (PyCFunction)_wrap_TIntIntVV_Reserved, METH_O, (char *)"\n" + "TIntIntVV_Reserved(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Last", _wrap_TIntIntVV_Last, METH_VARARGS, (char *)"\n" + "Last() -> TIntV\n" + "TIntIntVV_Last(TIntIntVV self) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_LastValN", (PyCFunction)_wrap_TIntIntVV_LastValN, METH_O, (char *)"\n" + "TIntIntVV_LastValN(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_LastLast", _wrap_TIntIntVV_LastLast, METH_VARARGS, (char *)"\n" + "LastLast() -> TIntV\n" + "TIntIntVV_LastLast(TIntIntVV self) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_BegI", (PyCFunction)_wrap_TIntIntVV_BegI, METH_O, (char *)"\n" + "TIntIntVV_BegI(TIntIntVV self) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_EndI", (PyCFunction)_wrap_TIntIntVV_EndI, METH_O, (char *)"\n" + "TIntIntVV_EndI(TIntIntVV self) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetI", _wrap_TIntIntVV_GetI, METH_VARARGS, (char *)"\n" + "TIntIntVV_GetI(TIntIntVV self, int const & ValN) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " ValN: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_AddV", _wrap_TIntIntVV_AddV, METH_VARARGS, (char *)"\n" + "TIntIntVV_AddV(TIntIntVV self, TIntIntVV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_AddSorted", _wrap_TIntIntVV_AddSorted, METH_VARARGS, (char *)"\n" + "AddSorted(TIntV Val, bool const & Asc=True, int const & _MxVals=-1) -> int\n" + "\n" + "Parameters:\n" + " Val: TVec< TInt,int > const &\n" + " Asc: bool const &\n" + " _MxVals: int const &\n" + "\n" + "AddSorted(TIntV Val, bool const & Asc=True) -> int\n" + "\n" + "Parameters:\n" + " Val: TVec< TInt,int > const &\n" + " Asc: bool const &\n" + "\n" + "TIntIntVV_AddSorted(TIntIntVV self, TIntV Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_AddBackSorted", _wrap_TIntIntVV_AddBackSorted, METH_VARARGS, (char *)"\n" + "TIntIntVV_AddBackSorted(TIntIntVV self, TIntV Val, bool const & Asc) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_AddVMerged", _wrap_TIntIntVV_AddVMerged, METH_VARARGS, (char *)"\n" + "TIntIntVV_AddVMerged(TIntIntVV self, TIntIntVV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_AddUnique", _wrap_TIntIntVV_AddUnique, METH_VARARGS, (char *)"\n" + "TIntIntVV_AddUnique(TIntIntVV self, TIntV Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetVal", _wrap_TIntIntVV_GetVal, METH_VARARGS, (char *)"\n" + "GetVal(int const & ValN) -> TIntV\n" + "\n" + "Parameters:\n" + " ValN: int const &\n" + "\n" + "TIntIntVV_GetVal(TIntIntVV self, int const & ValN) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " ValN: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetSubValV", _wrap_TIntIntVV_GetSubValV, METH_VARARGS, (char *)"\n" + "TIntIntVV_GetSubValV(TIntIntVV self, int const & BValN, int const & EValN, TIntIntVV ValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " BValN: int const &\n" + " EValN: int const &\n" + " ValV: TVec< TVec< TInt,int >,int > &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Ins", _wrap_TIntIntVV_Ins, METH_VARARGS, (char *)"\n" + "TIntIntVV_Ins(TIntIntVV self, int const & ValN, TIntV Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " ValN: int const &\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Del", _wrap_TIntIntVV_Del, METH_VARARGS, (char *)"\n" + "Del(int const & ValN)\n" + "\n" + "Parameters:\n" + " ValN: int const &\n" + "\n" + "TIntIntVV_Del(TIntIntVV self, int const & MnValN, int const & MxValN)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " MnValN: int const &\n" + " MxValN: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_DelLast", (PyCFunction)_wrap_TIntIntVV_DelLast, METH_O, (char *)"\n" + "TIntIntVV_DelLast(TIntIntVV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_DelIfIn", _wrap_TIntIntVV_DelIfIn, METH_VARARGS, (char *)"\n" + "TIntIntVV_DelIfIn(TIntIntVV self, TIntV Val) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_DelAll", _wrap_TIntIntVV_DelAll, METH_VARARGS, (char *)"\n" + "TIntIntVV_DelAll(TIntIntVV self, TIntV Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_PutAll", _wrap_TIntIntVV_PutAll, METH_VARARGS, (char *)"\n" + "TIntIntVV_PutAll(TIntIntVV self, TIntV Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Swap", _wrap_TIntIntVV_Swap, METH_VARARGS, (char *)"\n" + "Swap(TIntIntVV Vec)\n" + "\n" + "Parameters:\n" + " Vec: TVec< TVec< TInt,int >,int > &\n" + "\n" + "TIntIntVV_Swap(TIntIntVV self, int const & ValN1, int const & ValN2)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " ValN1: int const &\n" + " ValN2: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_SwapI", _wrap_TIntIntVV_SwapI, METH_VARARGS, (char *)"\n" + "TIntIntVV_SwapI(TIntV LVal, TIntV RVal)\n" + "\n" + "Parameters:\n" + " LVal: TVec< TVec< TInt,int >,int >::TIter\n" + " RVal: TVec< TVec< TInt,int >,int >::TIter\n" + "\n" + ""}, + { (char *)"TIntIntVV_NextPerm", (PyCFunction)_wrap_TIntIntVV_NextPerm, METH_O, (char *)"\n" + "TIntIntVV_NextPerm(TIntIntVV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_PrevPerm", (PyCFunction)_wrap_TIntIntVV_PrevPerm, METH_O, (char *)"\n" + "TIntIntVV_PrevPerm(TIntIntVV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetPivotValN", _wrap_TIntIntVV_GetPivotValN, METH_VARARGS, (char *)"\n" + "TIntIntVV_GetPivotValN(TIntIntVV self, int const & LValN, int const & RValN) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " LValN: int const &\n" + " RValN: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_BSort", _wrap_TIntIntVV_BSort, METH_VARARGS, (char *)"\n" + "TIntIntVV_BSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_ISort", _wrap_TIntIntVV_ISort, METH_VARARGS, (char *)"\n" + "TIntIntVV_ISort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Partition", _wrap_TIntIntVV_Partition, METH_VARARGS, (char *)"\n" + "TIntIntVV_Partition(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_QSort", _wrap_TIntIntVV_QSort, METH_VARARGS, (char *)"\n" + "TIntIntVV_QSort(TIntIntVV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Sort", _wrap_TIntIntVV_Sort, METH_VARARGS, (char *)"\n" + "Sort(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntIntVV_Sort(TIntIntVV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_IsSorted", _wrap_TIntIntVV_IsSorted, METH_VARARGS, (char *)"\n" + "IsSorted(bool const & Asc=True) -> bool\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntIntVV_IsSorted(TIntIntVV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Shuffle", _wrap_TIntIntVV_Shuffle, METH_VARARGS, (char *)"\n" + "TIntIntVV_Shuffle(TIntIntVV self, TRnd Rnd)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Rnd: TRnd &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Reverse", _wrap_TIntIntVV_Reverse, METH_VARARGS, (char *)"\n" + "Reverse()\n" + "TIntIntVV_Reverse(TIntIntVV self, int LValN, int RValN)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " LValN: int\n" + " RValN: int\n" + "\n" + ""}, + { (char *)"TIntIntVV_Merge", (PyCFunction)_wrap_TIntIntVV_Merge, METH_O, (char *)"\n" + "TIntIntVV_Merge(TIntIntVV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + "\n" + ""}, + { (char *)"TIntIntVV_Intrs", _wrap_TIntIntVV_Intrs, METH_VARARGS, (char *)"\n" + "Intrs(TIntIntVV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + "TIntIntVV_Intrs(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + " DstValV: TVec< TVec< TInt,int >,int > &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Union", _wrap_TIntIntVV_Union, METH_VARARGS, (char *)"\n" + "Union(TIntIntVV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + "TIntIntVV_Union(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + " DstValV: TVec< TVec< TInt,int >,int > &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Diff", _wrap_TIntIntVV_Diff, METH_VARARGS, (char *)"\n" + "Diff(TIntIntVV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + "TIntIntVV_Diff(TIntIntVV self, TIntIntVV ValV, TIntIntVV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + " DstValV: TVec< TVec< TInt,int >,int > &\n" + "\n" + ""}, + { (char *)"TIntIntVV_IntrsLen", _wrap_TIntIntVV_IntrsLen, METH_VARARGS, (char *)"\n" + "TIntIntVV_IntrsLen(TIntIntVV self, TIntIntVV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_UnionLen", _wrap_TIntIntVV_UnionLen, METH_VARARGS, (char *)"\n" + "TIntIntVV_UnionLen(TIntIntVV self, TIntIntVV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_Count", _wrap_TIntIntVV_Count, METH_VARARGS, (char *)"\n" + "TIntIntVV_Count(TIntIntVV self, TIntV Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_SearchBin", _wrap_TIntIntVV_SearchBin, METH_VARARGS, (char *)"\n" + "SearchBin(TIntV Val) -> int\n" + "\n" + "Parameters:\n" + " Val: TVec< TInt,int > const &\n" + "\n" + "TIntIntVV_SearchBin(TIntIntVV self, TIntV Val, int & InsValN) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Val: TVec< TInt,int > const &\n" + " InsValN: int &\n" + "\n" + ""}, + { (char *)"TIntIntVV_SearchForw", _wrap_TIntIntVV_SearchForw, METH_VARARGS, (char *)"\n" + "SearchForw(TIntV Val, int const & BValN=0) -> int\n" + "\n" + "Parameters:\n" + " Val: TVec< TInt,int > const &\n" + " BValN: int const &\n" + "\n" + "TIntIntVV_SearchForw(TIntIntVV self, TIntV Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_SearchBack", _wrap_TIntIntVV_SearchBack, METH_VARARGS, (char *)"\n" + "TIntIntVV_SearchBack(TIntIntVV self, TIntV Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_SearchVForw", _wrap_TIntIntVV_SearchVForw, METH_VARARGS, (char *)"\n" + "SearchVForw(TIntIntVV ValV, int const & BValN=0) -> int\n" + "\n" + "Parameters:\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + " BValN: int const &\n" + "\n" + "TIntIntVV_SearchVForw(TIntIntVV self, TIntIntVV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " ValV: TVec< TVec< TInt,int >,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_IsIn", _wrap_TIntIntVV_IsIn, METH_VARARGS, (char *)"\n" + "IsIn(TIntV Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: TVec< TInt,int > const &\n" + "\n" + "TIntIntVV_IsIn(TIntIntVV self, TIntV Val, int & ValN) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Val: TVec< TInt,int > const &\n" + " ValN: int &\n" + "\n" + ""}, + { (char *)"TIntIntVV_IsInBin", _wrap_TIntIntVV_IsInBin, METH_VARARGS, (char *)"\n" + "TIntIntVV_IsInBin(TIntIntVV self, TIntV Val) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetDat", _wrap_TIntIntVV_GetDat, METH_VARARGS, (char *)"\n" + "TIntIntVV_GetDat(TIntIntVV self, TIntV Val) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetAddDat", _wrap_TIntIntVV_GetAddDat, METH_VARARGS, (char *)"\n" + "TIntIntVV_GetAddDat(TIntIntVV self, TIntV Val) -> TIntV\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > *\n" + " Val: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetMxValN", (PyCFunction)_wrap_TIntIntVV_GetMxValN, METH_O, (char *)"\n" + "TIntIntVV_GetMxValN(TIntIntVV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TVec< TInt,int >,int > const *\n" + "\n" + ""}, + { (char *)"TIntIntVV_GetV", _wrap_TIntIntVV_GetV, METH_VARARGS, (char *)"\n" + "GetV(TIntV Val1) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + "\n" + "GetV(TIntV Val1, TIntV Val2) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + "\n" + "GetV(TIntV Val1, TIntV Val2, TIntV Val3) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + " Val3: TVec< TInt,int > const &\n" + "\n" + "GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + " Val3: TVec< TInt,int > const &\n" + " Val4: TVec< TInt,int > const &\n" + "\n" + "GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + " Val3: TVec< TInt,int > const &\n" + " Val4: TVec< TInt,int > const &\n" + " Val5: TVec< TInt,int > const &\n" + "\n" + "GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + " Val3: TVec< TInt,int > const &\n" + " Val4: TVec< TInt,int > const &\n" + " Val5: TVec< TInt,int > const &\n" + " Val6: TVec< TInt,int > const &\n" + "\n" + "GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + " Val3: TVec< TInt,int > const &\n" + " Val4: TVec< TInt,int > const &\n" + " Val5: TVec< TInt,int > const &\n" + " Val6: TVec< TInt,int > const &\n" + " Val7: TVec< TInt,int > const &\n" + "\n" + "GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, \n" + " TIntV Val8) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + " Val3: TVec< TInt,int > const &\n" + " Val4: TVec< TInt,int > const &\n" + " Val5: TVec< TInt,int > const &\n" + " Val6: TVec< TInt,int > const &\n" + " Val7: TVec< TInt,int > const &\n" + " Val8: TVec< TInt,int > const &\n" + "\n" + "TIntIntVV_GetV(TIntV Val1, TIntV Val2, TIntV Val3, TIntV Val4, TIntV Val5, TIntV Val6, TIntV Val7, \n" + " TIntV Val8, TIntV Val9) -> TIntIntVV\n" + "\n" + "Parameters:\n" + " Val1: TVec< TInt,int > const &\n" + " Val2: TVec< TInt,int > const &\n" + " Val3: TVec< TInt,int > const &\n" + " Val4: TVec< TInt,int > const &\n" + " Val5: TVec< TInt,int > const &\n" + " Val6: TVec< TInt,int > const &\n" + " Val7: TVec< TInt,int > const &\n" + " Val8: TVec< TInt,int > const &\n" + " Val9: TVec< TInt,int > const &\n" + "\n" + ""}, + { (char *)"TIntIntVV_swigregister", TIntIntVV_swigregister, METH_VARARGS, NULL}, + { (char *)"TIntIntVV_swiginit", TIntIntVV_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TIntIntVH", _wrap_new_TIntIntVH, METH_VARARGS, (char *)"\n" + "TIntIntVH()\n" + "TIntIntVH(TIntIntVH Hash)\n" + "\n" + "Parameters:\n" + " Hash: THash< TInt,TVec< TInt,int > > const &\n" + "\n" + "TIntIntVH(int const & ExpectVals, bool const & _AutoSizeP=False)\n" + "\n" + "Parameters:\n" + " ExpectVals: int const &\n" + " _AutoSizeP: bool const &\n" + "\n" + "TIntIntVH(int const & ExpectVals)\n" + "\n" + "Parameters:\n" + " ExpectVals: int const &\n" + "\n" + "new_TIntIntVH(TSIn SIn) -> TIntIntVH\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntIntVH_Load", _wrap_TIntIntVH_Load, METH_VARARGS, (char *)"\n" + "TIntIntVH_Load(TIntIntVH self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntIntVH_Save", _wrap_TIntIntVH_Save, METH_VARARGS, (char *)"\n" + "TIntIntVH_Save(TIntIntVH self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TIntIntVH_LoadXml", _wrap_TIntIntVH_LoadXml, METH_VARARGS, (char *)"\n" + "LoadXml(PXmlTok const & XmlTok, TStr Nm=\"\")\n" + "\n" + "Parameters:\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + "TIntIntVH_LoadXml(TIntIntVH self, PXmlTok const & XmlTok)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " XmlTok: PXmlTok const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_SaveXml", _wrap_TIntIntVH_SaveXml, METH_VARARGS, (char *)"\n" + "TIntIntVH_SaveXml(TIntIntVH self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TIntIntVH___eq__", _wrap_TIntIntVH___eq__, METH_VARARGS, (char *)"\n" + "TIntIntVH___eq__(TIntIntVH self, TIntIntVH Hash) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " Hash: THash< TInt,TVec< TInt,int > > const &\n" + "\n" + ""}, + { (char *)"TIntIntVH___lt__", _wrap_TIntIntVH___lt__, METH_VARARGS, (char *)"\n" + "TIntIntVH___lt__(TIntIntVH self, TIntIntVH Hash) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " Hash: THash< TInt,TVec< TInt,int > > const &\n" + "\n" + ""}, + { (char *)"TIntIntVH___call__", _wrap_TIntIntVH___call__, METH_VARARGS, (char *)"\n" + "TIntIntVH___call__(TIntIntVH self, TInt Key) -> TIntV\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetMemUsed", (PyCFunction)_wrap_TIntIntVH_GetMemUsed, METH_O, (char *)"\n" + "TIntIntVH_GetMemUsed(TIntIntVH self) -> ::TSize\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_BegI", (PyCFunction)_wrap_TIntIntVH_BegI, METH_O, (char *)"\n" + "TIntIntVH_BegI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_EndI", (PyCFunction)_wrap_TIntIntVH_EndI, METH_O, (char *)"\n" + "TIntIntVH_EndI(TIntIntVH self) -> THash< TInt,TVec< TInt,int > >::TIter\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetI", _wrap_TIntIntVH_GetI, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetI(TIntIntVH self, TInt Key) -> THash< TInt,TVec< TInt,int > >::TIter\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_Gen", _wrap_TIntIntVH_Gen, METH_VARARGS, (char *)"\n" + "TIntIntVH_Gen(TIntIntVH self, int const & ExpectVals)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " ExpectVals: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_Clr", _wrap_TIntIntVH_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + " NoDelLim: int const &\n" + " ResetDat: bool const &\n" + "\n" + "Clr(bool const & DoDel=True, int const & NoDelLim=-1)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + " NoDelLim: int const &\n" + "\n" + "Clr(bool const & DoDel=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + "\n" + "TIntIntVH_Clr(TIntIntVH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + "\n" + ""}, + { (char *)"TIntIntVH_Empty", (PyCFunction)_wrap_TIntIntVH_Empty, METH_O, (char *)"\n" + "TIntIntVH_Empty(TIntIntVH self) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_Len", (PyCFunction)_wrap_TIntIntVH_Len, METH_O, (char *)"\n" + "TIntIntVH_Len(TIntIntVH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetPorts", (PyCFunction)_wrap_TIntIntVH_GetPorts, METH_O, (char *)"\n" + "TIntIntVH_GetPorts(TIntIntVH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_IsAutoSize", (PyCFunction)_wrap_TIntIntVH_IsAutoSize, METH_O, (char *)"\n" + "TIntIntVH_IsAutoSize(TIntIntVH self) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetMxKeyIds", (PyCFunction)_wrap_TIntIntVH_GetMxKeyIds, METH_O, (char *)"\n" + "TIntIntVH_GetMxKeyIds(TIntIntVH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetReservedKeyIds", (PyCFunction)_wrap_TIntIntVH_GetReservedKeyIds, METH_O, (char *)"\n" + "TIntIntVH_GetReservedKeyIds(TIntIntVH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_IsKeyIdEqKeyN", (PyCFunction)_wrap_TIntIntVH_IsKeyIdEqKeyN, METH_O, (char *)"\n" + "TIntIntVH_IsKeyIdEqKeyN(TIntIntVH self) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_DelKey", _wrap_TIntIntVH_DelKey, METH_VARARGS, (char *)"\n" + "TIntIntVH_DelKey(TIntIntVH self, TInt Key)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_DelIfKey", _wrap_TIntIntVH_DelIfKey, METH_VARARGS, (char *)"\n" + "TIntIntVH_DelIfKey(TIntIntVH self, TInt Key) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_DelKeyId", _wrap_TIntIntVH_DelKeyId, METH_VARARGS, (char *)"\n" + "TIntIntVH_DelKeyId(TIntIntVH self, int const & KeyId)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_DelKeyIdV", _wrap_TIntIntVH_DelKeyIdV, METH_VARARGS, (char *)"\n" + "TIntIntVH_DelKeyIdV(TIntIntVH self, TIntV KeyIdV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " KeyIdV: TIntV const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_MarkDelKey", _wrap_TIntIntVH_MarkDelKey, METH_VARARGS, (char *)"\n" + "TIntIntVH_MarkDelKey(TIntIntVH self, TInt Key)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_MarkDelKeyId", _wrap_TIntIntVH_MarkDelKeyId, METH_VARARGS, (char *)"\n" + "TIntIntVH_MarkDelKeyId(TIntIntVH self, int const & KeyId)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetKey", _wrap_TIntIntVH_GetKey, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetKey(TIntIntVH self, int const & KeyId) -> TInt\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetKeyId", _wrap_TIntIntVH_GetKeyId, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetKeyId(TIntIntVH self, TInt Key) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetRndKeyId", _wrap_TIntIntVH_GetRndKeyId, METH_VARARGS, (char *)"\n" + "GetRndKeyId(TRnd Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TIntIntVH_GetRndKeyId(TIntIntVH self, TRnd Rnd, double const & EmptyFrac) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Rnd: TRnd &\n" + " EmptyFrac: double const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_IsKeyId", _wrap_TIntIntVH_IsKeyId, METH_VARARGS, (char *)"\n" + "TIntIntVH_IsKeyId(TIntIntVH self, int const & KeyId) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetKeyDat", _wrap_TIntIntVH_GetKeyDat, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetKeyDat(TIntIntVH self, int const & KeyId, TInt Key, TIntV Dat)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " KeyId: int const &\n" + " Key: TInt &\n" + " Dat: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_IsKeyGetDat", _wrap_TIntIntVH_IsKeyGetDat, METH_VARARGS, (char *)"\n" + "TIntIntVH_IsKeyGetDat(TIntIntVH self, TInt Key, TIntV Dat) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " Key: TInt const &\n" + " Dat: TVec< TInt,int > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_FFirstKeyId", (PyCFunction)_wrap_TIntIntVH_FFirstKeyId, METH_O, (char *)"\n" + "TIntIntVH_FFirstKeyId(TIntIntVH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + "\n" + ""}, + { (char *)"TIntIntVH_FNextKeyId", _wrap_TIntIntVH_FNextKeyId, METH_VARARGS, (char *)"\n" + "TIntIntVH_FNextKeyId(TIntIntVH self, int & KeyId) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " KeyId: int &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetKeyV", _wrap_TIntIntVH_GetKeyV, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetKeyV(TIntIntVH self, TIntV KeyV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " KeyV: TVec< TInt > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetDatV", _wrap_TIntIntVH_GetDatV, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetDatV(TIntIntVH self, TIntIntVV DatV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " DatV: TVec< TVec< TInt,int > > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetKeyDatPrV", _wrap_TIntIntVH_GetKeyDatPrV, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetKeyDatPrV(TIntIntVH self, TVec< TPair< TInt,TVec< TInt,int > > > & KeyDatPrV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " KeyDatPrV: TVec< TPair< TInt,TVec< TInt,int > > > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetDatKeyPrV", _wrap_TIntIntVH_GetDatKeyPrV, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetDatKeyPrV(TIntIntVH self, TVec< TPair< TVec< TInt,int >,TInt > > & DatKeyPrV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " DatKeyPrV: TVec< TPair< TVec< TInt,int >,TInt > > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetKeyDatKdV", _wrap_TIntIntVH_GetKeyDatKdV, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetKeyDatKdV(TIntIntVH self, TVec< TKeyDat< TInt,TVec< TInt,int > > > & KeyDatKdV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " KeyDatKdV: TVec< TKeyDat< TInt,TVec< TInt,int > > > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetDatKeyKdV", _wrap_TIntIntVH_GetDatKeyKdV, METH_VARARGS, (char *)"\n" + "TIntIntVH_GetDatKeyKdV(TIntIntVH self, TVec< TKeyDat< TVec< TInt,int >,TInt > > & DatKeyKdV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > const *\n" + " DatKeyKdV: TVec< TKeyDat< TVec< TInt,int >,TInt > > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_Swap", _wrap_TIntIntVH_Swap, METH_VARARGS, (char *)"\n" + "TIntIntVH_Swap(TIntIntVH self, TIntIntVH Hash)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Hash: THash< TInt,TVec< TInt,int > > &\n" + "\n" + ""}, + { (char *)"TIntIntVH_Defrag", (PyCFunction)_wrap_TIntIntVH_Defrag, METH_O, (char *)"\n" + "TIntIntVH_Defrag(TIntIntVH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + "\n" + ""}, + { (char *)"TIntIntVH_Pack", (PyCFunction)_wrap_TIntIntVH_Pack, METH_O, (char *)"\n" + "TIntIntVH_Pack(TIntIntVH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + "\n" + ""}, + { (char *)"TIntIntVH_Sort", _wrap_TIntIntVH_Sort, METH_VARARGS, (char *)"\n" + "TIntIntVH_Sort(TIntIntVH self, bool const & CmpKey, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " CmpKey: bool const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntIntVH_SortByKey", _wrap_TIntIntVH_SortByKey, METH_VARARGS, (char *)"\n" + "SortByKey(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntIntVH_SortByKey(TIntIntVH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + "\n" + ""}, + { (char *)"TIntIntVH_SortByDat", _wrap_TIntIntVH_SortByDat, METH_VARARGS, (char *)"\n" + "SortByDat(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntIntVH_SortByDat(TIntIntVH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + "\n" + ""}, + { (char *)"TIntIntVH_AddKey", _wrap_TIntIntVH_AddKey, METH_VARARGS, (char *)"\n" + "AddKey(TInt Key) -> int\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "TIntIntVH_AddKey(TIntIntVH self, int Val) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TIntIntVH_IsKey", _wrap_TIntIntVH_IsKey, METH_VARARGS, (char *)"\n" + "IsKey(TInt Key) -> bool\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "IsKey(TInt Key, int & KeyId) -> bool\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + " KeyId: int &\n" + "\n" + "TIntIntVH_IsKey(TIntIntVH self, int Val) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TIntIntVH_GetDat", _wrap_TIntIntVH_GetDat, METH_VARARGS, (char *)"\n" + "GetDat(TInt Key) -> TIntV\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "GetDat(TInt Key) -> TIntV\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "TIntIntVH_GetDat(TIntIntVH self, int Val) -> TIntV\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"delete_TIntIntVH", (PyCFunction)_wrap_delete_TIntIntVH, METH_O, (char *)"\n" + "delete_TIntIntVH(TIntIntVH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TVec< TInt,int > > *\n" + "\n" + ""}, + { (char *)"TIntIntVH_swigregister", TIntIntVH_swigregister, METH_VARARGS, NULL}, + { (char *)"TIntIntVH_swiginit", TIntIntVH_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TIntH", _wrap_new_TIntH, METH_VARARGS, (char *)"\n" + "TIntH()\n" + "TIntH(TIntH Hash)\n" + "\n" + "Parameters:\n" + " Hash: THash< TInt,TInt > const &\n" + "\n" + "TIntH(int const & ExpectVals, bool const & _AutoSizeP=False)\n" + "\n" + "Parameters:\n" + " ExpectVals: int const &\n" + " _AutoSizeP: bool const &\n" + "\n" + "TIntH(int const & ExpectVals)\n" + "\n" + "Parameters:\n" + " ExpectVals: int const &\n" + "\n" + "new_TIntH(TSIn SIn) -> TIntH\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntH_Load", _wrap_TIntH_Load, METH_VARARGS, (char *)"\n" + "TIntH_Load(TIntH self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TIntH_Save", _wrap_TIntH_Save, METH_VARARGS, (char *)"\n" + "TIntH_Save(TIntH self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TIntH_LoadXml", _wrap_TIntH_LoadXml, METH_VARARGS, (char *)"\n" + "LoadXml(PXmlTok const & XmlTok, TStr Nm=\"\")\n" + "\n" + "Parameters:\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + "TIntH_LoadXml(TIntH self, PXmlTok const & XmlTok)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " XmlTok: PXmlTok const &\n" + "\n" + ""}, + { (char *)"TIntH_SaveXml", _wrap_TIntH_SaveXml, METH_VARARGS, (char *)"\n" + "TIntH_SaveXml(TIntH self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TIntH___eq__", _wrap_TIntH___eq__, METH_VARARGS, (char *)"\n" + "TIntH___eq__(TIntH self, TIntH Hash) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " Hash: THash< TInt,TInt > const &\n" + "\n" + ""}, + { (char *)"TIntH___lt__", _wrap_TIntH___lt__, METH_VARARGS, (char *)"\n" + "TIntH___lt__(TIntH self, TIntH Hash) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " Hash: THash< TInt,TInt > const &\n" + "\n" + ""}, + { (char *)"TIntH___call__", _wrap_TIntH___call__, METH_VARARGS, (char *)"\n" + "TIntH___call__(TIntH self, TInt Key) -> TInt\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntH_GetMemUsed", (PyCFunction)_wrap_TIntH_GetMemUsed, METH_O, (char *)"\n" + "TIntH_GetMemUsed(TIntH self) -> ::TSize\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_BegI", (PyCFunction)_wrap_TIntH_BegI, METH_O, (char *)"\n" + "TIntH_BegI(TIntH self) -> TIntHI\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_EndI", (PyCFunction)_wrap_TIntH_EndI, METH_O, (char *)"\n" + "TIntH_EndI(TIntH self) -> TIntHI\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_GetI", _wrap_TIntH_GetI, METH_VARARGS, (char *)"\n" + "TIntH_GetI(TIntH self, TInt Key) -> TIntHI\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntH_Gen", _wrap_TIntH_Gen, METH_VARARGS, (char *)"\n" + "TIntH_Gen(TIntH self, int const & ExpectVals)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " ExpectVals: int const &\n" + "\n" + ""}, + { (char *)"TIntH_Clr", _wrap_TIntH_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool const & DoDel=True, int const & NoDelLim=-1, bool const & ResetDat=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + " NoDelLim: int const &\n" + " ResetDat: bool const &\n" + "\n" + "Clr(bool const & DoDel=True, int const & NoDelLim=-1)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + " NoDelLim: int const &\n" + "\n" + "Clr(bool const & DoDel=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + "\n" + "TIntH_Clr(TIntH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntH_Empty", (PyCFunction)_wrap_TIntH_Empty, METH_O, (char *)"\n" + "TIntH_Empty(TIntH self) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_Len", (PyCFunction)_wrap_TIntH_Len, METH_O, (char *)"\n" + "TIntH_Len(TIntH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_GetPorts", (PyCFunction)_wrap_TIntH_GetPorts, METH_O, (char *)"\n" + "TIntH_GetPorts(TIntH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_IsAutoSize", (PyCFunction)_wrap_TIntH_IsAutoSize, METH_O, (char *)"\n" + "TIntH_IsAutoSize(TIntH self) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_GetMxKeyIds", (PyCFunction)_wrap_TIntH_GetMxKeyIds, METH_O, (char *)"\n" + "TIntH_GetMxKeyIds(TIntH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_GetReservedKeyIds", (PyCFunction)_wrap_TIntH_GetReservedKeyIds, METH_O, (char *)"\n" + "TIntH_GetReservedKeyIds(TIntH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_IsKeyIdEqKeyN", (PyCFunction)_wrap_TIntH_IsKeyIdEqKeyN, METH_O, (char *)"\n" + "TIntH_IsKeyIdEqKeyN(TIntH self) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_AddDatId", _wrap_TIntH_AddDatId, METH_VARARGS, (char *)"\n" + "TIntH_AddDatId(TIntH self, TInt Key) -> TInt\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntH_DelKey", _wrap_TIntH_DelKey, METH_VARARGS, (char *)"\n" + "TIntH_DelKey(TIntH self, TInt Key)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntH_DelIfKey", _wrap_TIntH_DelIfKey, METH_VARARGS, (char *)"\n" + "TIntH_DelIfKey(TIntH self, TInt Key) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntH_DelKeyId", _wrap_TIntH_DelKeyId, METH_VARARGS, (char *)"\n" + "TIntH_DelKeyId(TIntH self, int const & KeyId)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntH_DelKeyIdV", _wrap_TIntH_DelKeyIdV, METH_VARARGS, (char *)"\n" + "TIntH_DelKeyIdV(TIntH self, TIntV KeyIdV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " KeyIdV: TIntV const &\n" + "\n" + ""}, + { (char *)"TIntH_MarkDelKey", _wrap_TIntH_MarkDelKey, METH_VARARGS, (char *)"\n" + "TIntH_MarkDelKey(TIntH self, TInt Key)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntH_MarkDelKeyId", _wrap_TIntH_MarkDelKeyId, METH_VARARGS, (char *)"\n" + "TIntH_MarkDelKeyId(TIntH self, int const & KeyId)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntH_GetKey", _wrap_TIntH_GetKey, METH_VARARGS, (char *)"\n" + "TIntH_GetKey(TIntH self, int const & KeyId) -> TInt\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntH_GetKeyId", _wrap_TIntH_GetKeyId, METH_VARARGS, (char *)"\n" + "TIntH_GetKeyId(TIntH self, TInt Key) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " Key: TInt const &\n" + "\n" + ""}, + { (char *)"TIntH_GetRndKeyId", _wrap_TIntH_GetRndKeyId, METH_VARARGS, (char *)"\n" + "GetRndKeyId(TRnd Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TIntH_GetRndKeyId(TIntH self, TRnd Rnd, double const & EmptyFrac) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Rnd: TRnd &\n" + " EmptyFrac: double const &\n" + "\n" + ""}, + { (char *)"TIntH_IsKeyId", _wrap_TIntH_IsKeyId, METH_VARARGS, (char *)"\n" + "TIntH_IsKeyId(TIntH self, int const & KeyId) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " KeyId: int const &\n" + "\n" + ""}, + { (char *)"TIntH_GetKeyDat", _wrap_TIntH_GetKeyDat, METH_VARARGS, (char *)"\n" + "TIntH_GetKeyDat(TIntH self, int const & KeyId, TInt Key, TInt Dat)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " KeyId: int const &\n" + " Key: TInt &\n" + " Dat: TInt &\n" + "\n" + ""}, + { (char *)"TIntH_IsKeyGetDat", _wrap_TIntH_IsKeyGetDat, METH_VARARGS, (char *)"\n" + "TIntH_IsKeyGetDat(TIntH self, TInt Key, TInt Dat) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " Key: TInt const &\n" + " Dat: TInt &\n" + "\n" + ""}, + { (char *)"TIntH_FFirstKeyId", (PyCFunction)_wrap_TIntH_FFirstKeyId, METH_O, (char *)"\n" + "TIntH_FFirstKeyId(TIntH self) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntH_FNextKeyId", _wrap_TIntH_FNextKeyId, METH_VARARGS, (char *)"\n" + "TIntH_FNextKeyId(TIntH self, int & KeyId) -> bool\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " KeyId: int &\n" + "\n" + ""}, + { (char *)"TIntH_GetKeyV", _wrap_TIntH_GetKeyV, METH_VARARGS, (char *)"\n" + "TIntH_GetKeyV(TIntH self, TIntV KeyV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " KeyV: TVec< TInt > &\n" + "\n" + ""}, + { (char *)"TIntH_GetDatV", _wrap_TIntH_GetDatV, METH_VARARGS, (char *)"\n" + "TIntH_GetDatV(TIntH self, TIntV DatV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " DatV: TVec< TInt > &\n" + "\n" + ""}, + { (char *)"TIntH_GetKeyDatPrV", _wrap_TIntH_GetKeyDatPrV, METH_VARARGS, (char *)"\n" + "TIntH_GetKeyDatPrV(TIntH self, TVec< TPair< TInt,TInt > > & KeyDatPrV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " KeyDatPrV: TVec< TPair< TInt,TInt > > &\n" + "\n" + ""}, + { (char *)"TIntH_GetDatKeyPrV", _wrap_TIntH_GetDatKeyPrV, METH_VARARGS, (char *)"\n" + "TIntH_GetDatKeyPrV(TIntH self, TVec< TPair< TInt,TInt > > & DatKeyPrV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " DatKeyPrV: TVec< TPair< TInt,TInt > > &\n" + "\n" + ""}, + { (char *)"TIntH_GetKeyDatKdV", _wrap_TIntH_GetKeyDatKdV, METH_VARARGS, (char *)"\n" + "TIntH_GetKeyDatKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & KeyDatKdV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " KeyDatKdV: TVec< TKeyDat< TInt,TInt > > &\n" + "\n" + ""}, + { (char *)"TIntH_GetDatKeyKdV", _wrap_TIntH_GetDatKeyKdV, METH_VARARGS, (char *)"\n" + "TIntH_GetDatKeyKdV(TIntH self, TVec< TKeyDat< TInt,TInt > > & DatKeyKdV)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > const *\n" + " DatKeyKdV: TVec< TKeyDat< TInt,TInt > > &\n" + "\n" + ""}, + { (char *)"TIntH_Swap", _wrap_TIntH_Swap, METH_VARARGS, (char *)"\n" + "TIntH_Swap(TIntH self, TIntH Hash)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Hash: THash< TInt,TInt > &\n" + "\n" + ""}, + { (char *)"TIntH_Defrag", (PyCFunction)_wrap_TIntH_Defrag, METH_O, (char *)"\n" + "TIntH_Defrag(TIntH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntH_Pack", (PyCFunction)_wrap_TIntH_Pack, METH_O, (char *)"\n" + "TIntH_Pack(TIntH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntH_Sort", _wrap_TIntH_Sort, METH_VARARGS, (char *)"\n" + "TIntH_Sort(TIntH self, bool const & CmpKey, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " CmpKey: bool const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TIntH_SortByKey", _wrap_TIntH_SortByKey, METH_VARARGS, (char *)"\n" + "SortByKey(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntH_SortByKey(TIntH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntH_SortByDat", _wrap_TIntH_SortByDat, METH_VARARGS, (char *)"\n" + "SortByDat(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TIntH_SortByDat(TIntH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntH_AddKey", _wrap_TIntH_AddKey, METH_VARARGS, (char *)"\n" + "AddKey(TInt Key) -> int\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "TIntH_AddKey(TIntH self, int Val) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TIntH_IsKey", _wrap_TIntH_IsKey, METH_VARARGS, (char *)"\n" + "IsKey(TInt Key) -> bool\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "IsKey(TInt Key, int & KeyId) -> bool\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + " KeyId: int &\n" + "\n" + "TIntH_IsKey(TIntH self, int Val) -> int\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TIntH_GetDat", _wrap_TIntH_GetDat, METH_VARARGS, (char *)"\n" + "GetDat(TInt Key) -> TInt\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "GetDat(TInt Key) -> TInt\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "TIntH_GetDat(TIntH self, int Val) -> TInt\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Val: int\n" + "\n" + ""}, + { (char *)"TIntH_AddDat", _wrap_TIntH_AddDat, METH_VARARGS, (char *)"\n" + "AddDat(TInt Key) -> TInt\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + "\n" + "AddDat(TInt Key, TInt Dat) -> TInt\n" + "\n" + "Parameters:\n" + " Key: TInt const &\n" + " Dat: TInt const &\n" + "\n" + "TIntH_AddDat(TIntH self, int Key, int Val) -> TInt\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + " Key: int\n" + " Val: int\n" + "\n" + ""}, + { (char *)"delete_TIntH", (PyCFunction)_wrap_delete_TIntH, METH_O, (char *)"\n" + "delete_TIntH(TIntH self)\n" + "\n" + "Parameters:\n" + " self: THash< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntH_swigregister", TIntH_swigregister, METH_VARARGS, NULL}, + { (char *)"TIntH_swiginit", TIntH_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TIntHI", _wrap_new_TIntHI, METH_VARARGS, (char *)"\n" + "TIntHI()\n" + "TIntHI(TIntHI _HashKeyDatI)\n" + "\n" + "Parameters:\n" + " _HashKeyDatI: THashKeyDatI< TInt,TInt > const &\n" + "\n" + "new_TIntHI(THashKeyDatI< TInt,TInt >::THKeyDat const * _KeyDatI, THashKeyDatI< TInt,TInt >::THKeyDat const * _EndI) -> TIntHI\n" + "\n" + "Parameters:\n" + " _KeyDatI: THashKeyDatI< TInt,TInt >::THKeyDat const *\n" + " _EndI: THashKeyDatI< TInt,TInt >::THKeyDat const *\n" + "\n" + ""}, + { (char *)"TIntHI___eq__", _wrap_TIntHI___eq__, METH_VARARGS, (char *)"\n" + "TIntHI___eq__(TIntHI self, TIntHI HashKeyDatI) -> bool\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + " HashKeyDatI: THashKeyDatI< TInt,TInt > const &\n" + "\n" + ""}, + { (char *)"TIntHI___lt__", _wrap_TIntHI___lt__, METH_VARARGS, (char *)"\n" + "TIntHI___lt__(TIntHI self, TIntHI HashKeyDatI) -> bool\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + " HashKeyDatI: THashKeyDatI< TInt,TInt > const &\n" + "\n" + ""}, + { (char *)"TIntHI___ref__", (PyCFunction)_wrap_TIntHI___ref__, METH_O, (char *)"\n" + "TIntHI___ref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntHI___call__", (PyCFunction)_wrap_TIntHI___call__, METH_O, (char *)"\n" + "TIntHI___call__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat &\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntHI___deref__", (PyCFunction)_wrap_TIntHI___deref__, METH_O, (char *)"\n" + "TIntHI___deref__(TIntHI self) -> THashKeyDatI< TInt,TInt >::THKeyDat *\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntHI_Next", (PyCFunction)_wrap_TIntHI_Next, METH_O, (char *)"\n" + "TIntHI_Next(TIntHI self) -> TIntHI\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntHI_IsEmpty", (PyCFunction)_wrap_TIntHI_IsEmpty, METH_O, (char *)"\n" + "TIntHI_IsEmpty(TIntHI self) -> bool\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntHI_IsEnd", (PyCFunction)_wrap_TIntHI_IsEnd, METH_O, (char *)"\n" + "TIntHI_IsEnd(TIntHI self) -> bool\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntHI_GetKey", (PyCFunction)_wrap_TIntHI_GetKey, METH_O, (char *)"\n" + "TIntHI_GetKey(TIntHI self) -> TInt\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > const *\n" + "\n" + ""}, + { (char *)"TIntHI_GetDat", _wrap_TIntHI_GetDat, METH_VARARGS, (char *)"\n" + "GetDat() -> TInt\n" + "TIntHI_GetDat(TIntHI self) -> TInt\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"delete_TIntHI", (PyCFunction)_wrap_delete_TIntHI, METH_O, (char *)"\n" + "delete_TIntHI(TIntHI self)\n" + "\n" + "Parameters:\n" + " self: THashKeyDatI< TInt,TInt > *\n" + "\n" + ""}, + { (char *)"TIntHI_swigregister", TIntHI_swigregister, METH_VARARGS, NULL}, + { (char *)"TIntHI_swiginit", TIntHI_swiginit, METH_VARARGS, NULL}, + { (char *)"delete_TStrV", (PyCFunction)_wrap_delete_TStrV, METH_O, (char *)"\n" + "delete_TStrV(TStrV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"new_TStrV", _wrap_new_TStrV, METH_VARARGS, (char *)"\n" + "TStrV()\n" + "TStrV(TStrV Vec)\n" + "\n" + "Parameters:\n" + " Vec: TVec< TStr,int > const &\n" + "\n" + "TStrV(int const & _Vals)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TStrV(int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + "TStrV(TStr _ValT, int const & _Vals)\n" + "\n" + "Parameters:\n" + " _ValT: TStr *\n" + " _Vals: int const &\n" + "\n" + "new_TStrV(TSIn SIn) -> TStrV\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TStrV_Load", _wrap_TStrV_Load, METH_VARARGS, (char *)"\n" + "TStrV_Load(TStrV self, TSIn SIn)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TStrV_Save", _wrap_TStrV_Save, METH_VARARGS, (char *)"\n" + "TStrV_Save(TStrV self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TStrV_LoadXml", _wrap_TStrV_LoadXml, METH_VARARGS, (char *)"\n" + "LoadXml(PXmlTok const & XmlTok, TStr Nm=\"\")\n" + "\n" + "Parameters:\n" + " XmlTok: PXmlTok const &\n" + " Nm: TStr const &\n" + "\n" + "TStrV_LoadXml(TStrV self, PXmlTok const & XmlTok)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " XmlTok: PXmlTok const &\n" + "\n" + ""}, + { (char *)"TStrV_SaveXml", _wrap_TStrV_SaveXml, METH_VARARGS, (char *)"\n" + "TStrV_SaveXml(TStrV self, TSOut SOut, TStr Nm)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " SOut: TSOut &\n" + " Nm: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV___add__", _wrap_TStrV___add__, METH_VARARGS, (char *)"\n" + "TStrV___add__(TStrV self, TStr Val) -> TStrV\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV___eq__", _wrap_TStrV___eq__, METH_VARARGS, (char *)"\n" + "TStrV___eq__(TStrV self, TStrV Vec) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Vec: TVec< TStr,int > const &\n" + "\n" + ""}, + { (char *)"TStrV___lt__", _wrap_TStrV___lt__, METH_VARARGS, (char *)"\n" + "TStrV___lt__(TStrV self, TStrV Vec) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Vec: TVec< TStr,int > const &\n" + "\n" + ""}, + { (char *)"TStrV_GetMemUsed", (PyCFunction)_wrap_TStrV_GetMemUsed, METH_O, (char *)"\n" + "TStrV_GetMemUsed(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_GetMemSize", (PyCFunction)_wrap_TStrV_GetMemSize, METH_O, (char *)"\n" + "TStrV_GetMemSize(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_GetPrimHashCd", (PyCFunction)_wrap_TStrV_GetPrimHashCd, METH_O, (char *)"\n" + "TStrV_GetPrimHashCd(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_GetSecHashCd", (PyCFunction)_wrap_TStrV_GetSecHashCd, METH_O, (char *)"\n" + "TStrV_GetSecHashCd(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_Gen", _wrap_TStrV_Gen, METH_VARARGS, (char *)"\n" + "Gen(int const & _Vals)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TStrV_Gen(TStrV self, int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TStrV_GenExt", _wrap_TStrV_GenExt, METH_VARARGS, (char *)"\n" + "TStrV_GenExt(TStrV self, TStr _ValT, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " _ValT: TStr *\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TStrV_IsExt", (PyCFunction)_wrap_TStrV_IsExt, METH_O, (char *)"\n" + "TStrV_IsExt(TStrV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_Reserve", _wrap_TStrV_Reserve, METH_VARARGS, (char *)"\n" + "Reserve(int const & _MxVals)\n" + "\n" + "Parameters:\n" + " _MxVals: int const &\n" + "\n" + "TStrV_Reserve(TStrV self, int const & _MxVals, int const & _Vals)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " _MxVals: int const &\n" + " _Vals: int const &\n" + "\n" + ""}, + { (char *)"TStrV_Clr", _wrap_TStrV_Clr, METH_VARARGS, (char *)"\n" + "Clr(bool const & DoDel=True, int const & NoDelLim=-1)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + " NoDelLim: int const &\n" + "\n" + "Clr(bool const & DoDel=True)\n" + "\n" + "Parameters:\n" + " DoDel: bool const &\n" + "\n" + "TStrV_Clr(TStrV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_Trunc", _wrap_TStrV_Trunc, METH_VARARGS, (char *)"\n" + "Trunc(int const & _Vals=-1)\n" + "\n" + "Parameters:\n" + " _Vals: int const &\n" + "\n" + "TStrV_Trunc(TStrV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_Pack", (PyCFunction)_wrap_TStrV_Pack, METH_O, (char *)"\n" + "TStrV_Pack(TStrV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_MoveFrom", _wrap_TStrV_MoveFrom, METH_VARARGS, (char *)"\n" + "TStrV_MoveFrom(TStrV self, TStrV Vec)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Vec: TVec< TStr,int > &\n" + "\n" + ""}, + { (char *)"TStrV_Empty", (PyCFunction)_wrap_TStrV_Empty, METH_O, (char *)"\n" + "TStrV_Empty(TStrV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_Len", (PyCFunction)_wrap_TStrV_Len, METH_O, (char *)"\n" + "TStrV_Len(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_Reserved", (PyCFunction)_wrap_TStrV_Reserved, METH_O, (char *)"\n" + "TStrV_Reserved(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_Last", _wrap_TStrV_Last, METH_VARARGS, (char *)"\n" + "Last() -> TStr\n" + "TStrV_Last(TStrV self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_LastValN", (PyCFunction)_wrap_TStrV_LastValN, METH_O, (char *)"\n" + "TStrV_LastValN(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_LastLast", _wrap_TStrV_LastLast, METH_VARARGS, (char *)"\n" + "LastLast() -> TStr\n" + "TStrV_LastLast(TStrV self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_BegI", (PyCFunction)_wrap_TStrV_BegI, METH_O, (char *)"\n" + "TStrV_BegI(TStrV self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_EndI", (PyCFunction)_wrap_TStrV_EndI, METH_O, (char *)"\n" + "TStrV_EndI(TStrV self) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_GetI", _wrap_TStrV_GetI, METH_VARARGS, (char *)"\n" + "TStrV_GetI(TStrV self, int const & ValN) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " ValN: int const &\n" + "\n" + ""}, + { (char *)"TStrV_AddV", _wrap_TStrV_AddV, METH_VARARGS, (char *)"\n" + "TStrV_AddV(TStrV self, TStrV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + ""}, + { (char *)"TStrV_AddSorted", _wrap_TStrV_AddSorted, METH_VARARGS, (char *)"\n" + "AddSorted(TStr Val, bool const & Asc=True, int const & _MxVals=-1) -> int\n" + "\n" + "Parameters:\n" + " Val: TStr const &\n" + " Asc: bool const &\n" + " _MxVals: int const &\n" + "\n" + "AddSorted(TStr Val, bool const & Asc=True) -> int\n" + "\n" + "Parameters:\n" + " Val: TStr const &\n" + " Asc: bool const &\n" + "\n" + "TStrV_AddSorted(TStrV self, TStr Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_AddBackSorted", _wrap_TStrV_AddBackSorted, METH_VARARGS, (char *)"\n" + "TStrV_AddBackSorted(TStrV self, TStr Val, bool const & Asc) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TStrV_AddVMerged", _wrap_TStrV_AddVMerged, METH_VARARGS, (char *)"\n" + "TStrV_AddVMerged(TStrV self, TStrV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + ""}, + { (char *)"TStrV_AddUnique", _wrap_TStrV_AddUnique, METH_VARARGS, (char *)"\n" + "TStrV_AddUnique(TStrV self, TStr Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_GetVal", _wrap_TStrV_GetVal, METH_VARARGS, (char *)"\n" + "GetVal(int const & ValN) -> TStr\n" + "\n" + "Parameters:\n" + " ValN: int const &\n" + "\n" + "TStrV_GetVal(TStrV self, int const & ValN) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " ValN: int const &\n" + "\n" + ""}, + { (char *)"TStrV_GetSubValV", _wrap_TStrV_GetSubValV, METH_VARARGS, (char *)"\n" + "TStrV_GetSubValV(TStrV self, int const & BValN, int const & EValN, TStrV ValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " BValN: int const &\n" + " EValN: int const &\n" + " ValV: TVec< TStr,int > &\n" + "\n" + ""}, + { (char *)"TStrV_Ins", _wrap_TStrV_Ins, METH_VARARGS, (char *)"\n" + "TStrV_Ins(TStrV self, int const & ValN, TStr Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " ValN: int const &\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_Del", _wrap_TStrV_Del, METH_VARARGS, (char *)"\n" + "Del(int const & ValN)\n" + "\n" + "Parameters:\n" + " ValN: int const &\n" + "\n" + "TStrV_Del(TStrV self, int const & MnValN, int const & MxValN)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " MnValN: int const &\n" + " MxValN: int const &\n" + "\n" + ""}, + { (char *)"TStrV_DelLast", (PyCFunction)_wrap_TStrV_DelLast, METH_O, (char *)"\n" + "TStrV_DelLast(TStrV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_DelIfIn", _wrap_TStrV_DelIfIn, METH_VARARGS, (char *)"\n" + "TStrV_DelIfIn(TStrV self, TStr Val) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_DelAll", _wrap_TStrV_DelAll, METH_VARARGS, (char *)"\n" + "TStrV_DelAll(TStrV self, TStr Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_PutAll", _wrap_TStrV_PutAll, METH_VARARGS, (char *)"\n" + "TStrV_PutAll(TStrV self, TStr Val)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_Swap", _wrap_TStrV_Swap, METH_VARARGS, (char *)"\n" + "Swap(TStrV Vec)\n" + "\n" + "Parameters:\n" + " Vec: TVec< TStr,int > &\n" + "\n" + "TStrV_Swap(TStrV self, int const & ValN1, int const & ValN2)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " ValN1: int const &\n" + " ValN2: int const &\n" + "\n" + ""}, + { (char *)"TStrV_SwapI", _wrap_TStrV_SwapI, METH_VARARGS, (char *)"\n" + "TStrV_SwapI(TStr LVal, TStr RVal)\n" + "\n" + "Parameters:\n" + " LVal: TVec< TStr,int >::TIter\n" + " RVal: TVec< TStr,int >::TIter\n" + "\n" + ""}, + { (char *)"TStrV_NextPerm", (PyCFunction)_wrap_TStrV_NextPerm, METH_O, (char *)"\n" + "TStrV_NextPerm(TStrV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_PrevPerm", (PyCFunction)_wrap_TStrV_PrevPerm, METH_O, (char *)"\n" + "TStrV_PrevPerm(TStrV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_GetPivotValN", _wrap_TStrV_GetPivotValN, METH_VARARGS, (char *)"\n" + "TStrV_GetPivotValN(TStrV self, int const & LValN, int const & RValN) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " LValN: int const &\n" + " RValN: int const &\n" + "\n" + ""}, + { (char *)"TStrV_BSort", _wrap_TStrV_BSort, METH_VARARGS, (char *)"\n" + "TStrV_BSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TStrV_ISort", _wrap_TStrV_ISort, METH_VARARGS, (char *)"\n" + "TStrV_ISort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TStrV_Partition", _wrap_TStrV_Partition, METH_VARARGS, (char *)"\n" + "TStrV_Partition(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TStrV_QSort", _wrap_TStrV_QSort, METH_VARARGS, (char *)"\n" + "TStrV_QSort(TStrV self, int const & MnLValN, int const & MxRValN, bool const & Asc)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " MnLValN: int const &\n" + " MxRValN: int const &\n" + " Asc: bool const &\n" + "\n" + ""}, + { (char *)"TStrV_Sort", _wrap_TStrV_Sort, METH_VARARGS, (char *)"\n" + "Sort(bool const & Asc=True)\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TStrV_Sort(TStrV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_IsSorted", _wrap_TStrV_IsSorted, METH_VARARGS, (char *)"\n" + "IsSorted(bool const & Asc=True) -> bool\n" + "\n" + "Parameters:\n" + " Asc: bool const &\n" + "\n" + "TStrV_IsSorted(TStrV self) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_Shuffle", _wrap_TStrV_Shuffle, METH_VARARGS, (char *)"\n" + "TStrV_Shuffle(TStrV self, TRnd Rnd)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Rnd: TRnd &\n" + "\n" + ""}, + { (char *)"TStrV_Reverse", _wrap_TStrV_Reverse, METH_VARARGS, (char *)"\n" + "Reverse()\n" + "TStrV_Reverse(TStrV self, int LValN, int RValN)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " LValN: int\n" + " RValN: int\n" + "\n" + ""}, + { (char *)"TStrV_Merge", (PyCFunction)_wrap_TStrV_Merge, METH_O, (char *)"\n" + "TStrV_Merge(TStrV self)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + "\n" + ""}, + { (char *)"TStrV_Intrs", _wrap_TStrV_Intrs, METH_VARARGS, (char *)"\n" + "Intrs(TStrV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + "TStrV_Intrs(TStrV self, TStrV ValV, TStrV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " ValV: TVec< TStr,int > const &\n" + " DstValV: TVec< TStr,int > &\n" + "\n" + ""}, + { (char *)"TStrV_Union", _wrap_TStrV_Union, METH_VARARGS, (char *)"\n" + "Union(TStrV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + "TStrV_Union(TStrV self, TStrV ValV, TStrV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " ValV: TVec< TStr,int > const &\n" + " DstValV: TVec< TStr,int > &\n" + "\n" + ""}, + { (char *)"TStrV_Diff", _wrap_TStrV_Diff, METH_VARARGS, (char *)"\n" + "Diff(TStrV ValV)\n" + "\n" + "Parameters:\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + "TStrV_Diff(TStrV self, TStrV ValV, TStrV DstValV)\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " ValV: TVec< TStr,int > const &\n" + " DstValV: TVec< TStr,int > &\n" + "\n" + ""}, + { (char *)"TStrV_IntrsLen", _wrap_TStrV_IntrsLen, METH_VARARGS, (char *)"\n" + "TStrV_IntrsLen(TStrV self, TStrV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + ""}, + { (char *)"TStrV_UnionLen", _wrap_TStrV_UnionLen, METH_VARARGS, (char *)"\n" + "TStrV_UnionLen(TStrV self, TStrV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + ""}, + { (char *)"TStrV_Count", _wrap_TStrV_Count, METH_VARARGS, (char *)"\n" + "TStrV_Count(TStrV self, TStr Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_SearchBin", _wrap_TStrV_SearchBin, METH_VARARGS, (char *)"\n" + "SearchBin(TStr Val) -> int\n" + "\n" + "Parameters:\n" + " Val: TStr const &\n" + "\n" + "TStrV_SearchBin(TStrV self, TStr Val, int & InsValN) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Val: TStr const &\n" + " InsValN: int &\n" + "\n" + ""}, + { (char *)"TStrV_SearchForw", _wrap_TStrV_SearchForw, METH_VARARGS, (char *)"\n" + "SearchForw(TStr Val, int const & BValN=0) -> int\n" + "\n" + "Parameters:\n" + " Val: TStr const &\n" + " BValN: int const &\n" + "\n" + "TStrV_SearchForw(TStrV self, TStr Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_SearchBack", _wrap_TStrV_SearchBack, METH_VARARGS, (char *)"\n" + "TStrV_SearchBack(TStrV self, TStr Val) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_SearchVForw", _wrap_TStrV_SearchVForw, METH_VARARGS, (char *)"\n" + "SearchVForw(TStrV ValV, int const & BValN=0) -> int\n" + "\n" + "Parameters:\n" + " ValV: TVec< TStr,int > const &\n" + " BValN: int const &\n" + "\n" + "TStrV_SearchVForw(TStrV self, TStrV ValV) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " ValV: TVec< TStr,int > const &\n" + "\n" + ""}, + { (char *)"TStrV_IsIn", _wrap_TStrV_IsIn, METH_VARARGS, (char *)"\n" + "IsIn(TStr Val) -> bool\n" + "\n" + "Parameters:\n" + " Val: TStr const &\n" + "\n" + "TStrV_IsIn(TStrV self, TStr Val, int & ValN) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Val: TStr const &\n" + " ValN: int &\n" + "\n" + ""}, + { (char *)"TStrV_IsInBin", _wrap_TStrV_IsInBin, METH_VARARGS, (char *)"\n" + "TStrV_IsInBin(TStrV self, TStr Val) -> bool\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_GetDat", _wrap_TStrV_GetDat, METH_VARARGS, (char *)"\n" + "TStrV_GetDat(TStrV self, TStr Val) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_GetAddDat", _wrap_TStrV_GetAddDat, METH_VARARGS, (char *)"\n" + "TStrV_GetAddDat(TStrV self, TStr Val) -> TStr\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > *\n" + " Val: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_GetMxValN", (PyCFunction)_wrap_TStrV_GetMxValN, METH_O, (char *)"\n" + "TStrV_GetMxValN(TStrV self) -> int\n" + "\n" + "Parameters:\n" + " self: TVec< TStr,int > const *\n" + "\n" + ""}, + { (char *)"TStrV_GetV", _wrap_TStrV_GetV, METH_VARARGS, (char *)"\n" + "GetV(TStr Val1) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + "\n" + "GetV(TStr Val1, TStr Val2) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + "\n" + "GetV(TStr Val1, TStr Val2, TStr Val3) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + " Val3: TStr const &\n" + "\n" + "GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + " Val3: TStr const &\n" + " Val4: TStr const &\n" + "\n" + "GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + " Val3: TStr const &\n" + " Val4: TStr const &\n" + " Val5: TStr const &\n" + "\n" + "GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + " Val3: TStr const &\n" + " Val4: TStr const &\n" + " Val5: TStr const &\n" + " Val6: TStr const &\n" + "\n" + "GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + " Val3: TStr const &\n" + " Val4: TStr const &\n" + " Val5: TStr const &\n" + " Val6: TStr const &\n" + " Val7: TStr const &\n" + "\n" + "GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + " Val3: TStr const &\n" + " Val4: TStr const &\n" + " Val5: TStr const &\n" + " Val6: TStr const &\n" + " Val7: TStr const &\n" + " Val8: TStr const &\n" + "\n" + "TStrV_GetV(TStr Val1, TStr Val2, TStr Val3, TStr Val4, TStr Val5, TStr Val6, TStr Val7, TStr Val8, \n" + " TStr Val9) -> TStrV\n" + "\n" + "Parameters:\n" + " Val1: TStr const &\n" + " Val2: TStr const &\n" + " Val3: TStr const &\n" + " Val4: TStr const &\n" + " Val5: TStr const &\n" + " Val6: TStr const &\n" + " Val7: TStr const &\n" + " Val8: TStr const &\n" + " Val9: TStr const &\n" + "\n" + ""}, + { (char *)"TStrV_swigregister", TStrV_swigregister, METH_VARARGS, NULL}, + { (char *)"TStrV_swiginit", TStrV_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNGraphNodeI", _wrap_new_TNGraphNodeI, METH_VARARGS, (char *)"\n" + "TNGraphNodeI()\n" + "new_TNGraphNodeI(TNGraph::TNodeI const & NodeI) -> TNGraphNodeI\n" + "\n" + "Parameters:\n" + " NodeI: TNGraph::TNodeI const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_Next", (PyCFunction)_wrap_TNGraphNodeI_Next, METH_O, (char *)"\n" + "TNGraphNodeI_Next(TNGraphNodeI self) -> TNGraphNodeI\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI *\n" + "\n" + ""}, + { (char *)"TNGraphNodeI___lt__", _wrap_TNGraphNodeI___lt__, METH_VARARGS, (char *)"\n" + "TNGraphNodeI___lt__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NodeI: TNGraphNodeI const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI___eq__", _wrap_TNGraphNodeI___eq__, METH_VARARGS, (char *)"\n" + "TNGraphNodeI___eq__(TNGraphNodeI self, TNGraphNodeI NodeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NodeI: TNGraphNodeI const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_GetId", (PyCFunction)_wrap_TNGraphNodeI_GetId, METH_O, (char *)"\n" + "TNGraphNodeI_GetId(TNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_GetDeg", (PyCFunction)_wrap_TNGraphNodeI_GetDeg, METH_O, (char *)"\n" + "TNGraphNodeI_GetDeg(TNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_GetInDeg", (PyCFunction)_wrap_TNGraphNodeI_GetInDeg, METH_O, (char *)"\n" + "TNGraphNodeI_GetInDeg(TNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_GetOutDeg", (PyCFunction)_wrap_TNGraphNodeI_GetOutDeg, METH_O, (char *)"\n" + "TNGraphNodeI_GetOutDeg(TNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_GetInNId", _wrap_TNGraphNodeI_GetInNId, METH_VARARGS, (char *)"\n" + "TNGraphNodeI_GetInNId(TNGraphNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_GetOutNId", _wrap_TNGraphNodeI_GetOutNId, METH_VARARGS, (char *)"\n" + "TNGraphNodeI_GetOutNId(TNGraphNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_GetNbrNId", _wrap_TNGraphNodeI_GetNbrNId, METH_VARARGS, (char *)"\n" + "TNGraphNodeI_GetNbrNId(TNGraphNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_IsInNId", _wrap_TNGraphNodeI_IsInNId, METH_VARARGS, (char *)"\n" + "TNGraphNodeI_IsInNId(TNGraphNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_IsOutNId", _wrap_TNGraphNodeI_IsOutNId, METH_VARARGS, (char *)"\n" + "TNGraphNodeI_IsOutNId(TNGraphNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_IsNbrNId", _wrap_TNGraphNodeI_IsNbrNId, METH_VARARGS, (char *)"\n" + "TNGraphNodeI_IsNbrNId(TNGraphNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"delete_TNGraphNodeI", (PyCFunction)_wrap_delete_TNGraphNodeI, METH_O, (char *)"\n" + "delete_TNGraphNodeI(TNGraphNodeI self)\n" + "\n" + "Parameters:\n" + " self: TNGraphNodeI *\n" + "\n" + ""}, + { (char *)"TNGraphNodeI_swigregister", TNGraphNodeI_swigregister, METH_VARARGS, NULL}, + { (char *)"TNGraphNodeI_swiginit", TNGraphNodeI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNGraphEdgeI", _wrap_new_TNGraphEdgeI, METH_VARARGS, (char *)"\n" + "TNGraphEdgeI()\n" + "new_TNGraphEdgeI(TNGraph::TEdgeI const & EdgeI) -> TNGraphEdgeI\n" + "\n" + "Parameters:\n" + " EdgeI: TNGraph::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TNGraphEdgeI_Next", (PyCFunction)_wrap_TNGraphEdgeI_Next, METH_O, (char *)"\n" + "TNGraphEdgeI_Next(TNGraphEdgeI self) -> TNGraphEdgeI\n" + "\n" + "Parameters:\n" + " self: TNGraphEdgeI *\n" + "\n" + ""}, + { (char *)"TNGraphEdgeI___lt__", _wrap_TNGraphEdgeI___lt__, METH_VARARGS, (char *)"\n" + "TNGraphEdgeI___lt__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraphEdgeI const *\n" + " EdgeI: TNGraphEdgeI const &\n" + "\n" + ""}, + { (char *)"TNGraphEdgeI___eq__", _wrap_TNGraphEdgeI___eq__, METH_VARARGS, (char *)"\n" + "TNGraphEdgeI___eq__(TNGraphEdgeI self, TNGraphEdgeI EdgeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNGraphEdgeI const *\n" + " EdgeI: TNGraphEdgeI const &\n" + "\n" + ""}, + { (char *)"TNGraphEdgeI_GetId", (PyCFunction)_wrap_TNGraphEdgeI_GetId, METH_O, (char *)"\n" + "TNGraphEdgeI_GetId(TNGraphEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphEdgeI const *\n" + "\n" + ""}, + { (char *)"TNGraphEdgeI_GetSrcNId", (PyCFunction)_wrap_TNGraphEdgeI_GetSrcNId, METH_O, (char *)"\n" + "TNGraphEdgeI_GetSrcNId(TNGraphEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphEdgeI const *\n" + "\n" + ""}, + { (char *)"TNGraphEdgeI_GetDstNId", (PyCFunction)_wrap_TNGraphEdgeI_GetDstNId, METH_O, (char *)"\n" + "TNGraphEdgeI_GetDstNId(TNGraphEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNGraphEdgeI const *\n" + "\n" + ""}, + { (char *)"delete_TNGraphEdgeI", (PyCFunction)_wrap_delete_TNGraphEdgeI, METH_O, (char *)"\n" + "delete_TNGraphEdgeI(TNGraphEdgeI self)\n" + "\n" + "Parameters:\n" + " self: TNGraphEdgeI *\n" + "\n" + ""}, + { (char *)"TNGraphEdgeI_swigregister", TNGraphEdgeI_swigregister, METH_VARARGS, NULL}, + { (char *)"TNGraphEdgeI_swiginit", TNGraphEdgeI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TUNGraphNodeI", _wrap_new_TUNGraphNodeI, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI()\n" + "new_TUNGraphNodeI(TUNGraph::TNodeI const & NodeI) -> TUNGraphNodeI\n" + "\n" + "Parameters:\n" + " NodeI: TUNGraph::TNodeI const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_Next", (PyCFunction)_wrap_TUNGraphNodeI_Next, METH_O, (char *)"\n" + "TUNGraphNodeI_Next(TUNGraphNodeI self) -> TUNGraphNodeI\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI *\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI___lt__", _wrap_TUNGraphNodeI___lt__, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI___lt__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NodeI: TUNGraphNodeI const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI___eq__", _wrap_TUNGraphNodeI___eq__, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI___eq__(TUNGraphNodeI self, TUNGraphNodeI NodeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NodeI: TUNGraphNodeI const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_GetId", (PyCFunction)_wrap_TUNGraphNodeI_GetId, METH_O, (char *)"\n" + "TUNGraphNodeI_GetId(TUNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_GetDeg", (PyCFunction)_wrap_TUNGraphNodeI_GetDeg, METH_O, (char *)"\n" + "TUNGraphNodeI_GetDeg(TUNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_GetInDeg", (PyCFunction)_wrap_TUNGraphNodeI_GetInDeg, METH_O, (char *)"\n" + "TUNGraphNodeI_GetInDeg(TUNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_GetOutDeg", (PyCFunction)_wrap_TUNGraphNodeI_GetOutDeg, METH_O, (char *)"\n" + "TUNGraphNodeI_GetOutDeg(TUNGraphNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_GetInNId", _wrap_TUNGraphNodeI_GetInNId, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI_GetInNId(TUNGraphNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_GetOutNId", _wrap_TUNGraphNodeI_GetOutNId, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI_GetOutNId(TUNGraphNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_GetNbrNId", _wrap_TUNGraphNodeI_GetNbrNId, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI_GetNbrNId(TUNGraphNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_IsInNId", _wrap_TUNGraphNodeI_IsInNId, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI_IsInNId(TUNGraphNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_IsOutNId", _wrap_TUNGraphNodeI_IsOutNId, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI_IsOutNId(TUNGraphNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_IsNbrNId", _wrap_TUNGraphNodeI_IsNbrNId, METH_VARARGS, (char *)"\n" + "TUNGraphNodeI_IsNbrNId(TUNGraphNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"delete_TUNGraphNodeI", (PyCFunction)_wrap_delete_TUNGraphNodeI, METH_O, (char *)"\n" + "delete_TUNGraphNodeI(TUNGraphNodeI self)\n" + "\n" + "Parameters:\n" + " self: TUNGraphNodeI *\n" + "\n" + ""}, + { (char *)"TUNGraphNodeI_swigregister", TUNGraphNodeI_swigregister, METH_VARARGS, NULL}, + { (char *)"TUNGraphNodeI_swiginit", TUNGraphNodeI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TUNGraphEdgeI", _wrap_new_TUNGraphEdgeI, METH_VARARGS, (char *)"\n" + "TUNGraphEdgeI()\n" + "new_TUNGraphEdgeI(TUNGraph::TEdgeI const & EdgeI) -> TUNGraphEdgeI\n" + "\n" + "Parameters:\n" + " EdgeI: TUNGraph::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TUNGraphEdgeI_Next", (PyCFunction)_wrap_TUNGraphEdgeI_Next, METH_O, (char *)"\n" + "TUNGraphEdgeI_Next(TUNGraphEdgeI self) -> TUNGraphEdgeI\n" + "\n" + "Parameters:\n" + " self: TUNGraphEdgeI *\n" + "\n" + ""}, + { (char *)"TUNGraphEdgeI___lt__", _wrap_TUNGraphEdgeI___lt__, METH_VARARGS, (char *)"\n" + "TUNGraphEdgeI___lt__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraphEdgeI const *\n" + " EdgeI: TUNGraphEdgeI const &\n" + "\n" + ""}, + { (char *)"TUNGraphEdgeI___eq__", _wrap_TUNGraphEdgeI___eq__, METH_VARARGS, (char *)"\n" + "TUNGraphEdgeI___eq__(TUNGraphEdgeI self, TUNGraphEdgeI EdgeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TUNGraphEdgeI const *\n" + " EdgeI: TUNGraphEdgeI const &\n" + "\n" + ""}, + { (char *)"TUNGraphEdgeI_GetId", (PyCFunction)_wrap_TUNGraphEdgeI_GetId, METH_O, (char *)"\n" + "TUNGraphEdgeI_GetId(TUNGraphEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphEdgeI const *\n" + "\n" + ""}, + { (char *)"TUNGraphEdgeI_GetSrcNId", (PyCFunction)_wrap_TUNGraphEdgeI_GetSrcNId, METH_O, (char *)"\n" + "TUNGraphEdgeI_GetSrcNId(TUNGraphEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphEdgeI const *\n" + "\n" + ""}, + { (char *)"TUNGraphEdgeI_GetDstNId", (PyCFunction)_wrap_TUNGraphEdgeI_GetDstNId, METH_O, (char *)"\n" + "TUNGraphEdgeI_GetDstNId(TUNGraphEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TUNGraphEdgeI const *\n" + "\n" + ""}, + { (char *)"delete_TUNGraphEdgeI", (PyCFunction)_wrap_delete_TUNGraphEdgeI, METH_O, (char *)"\n" + "delete_TUNGraphEdgeI(TUNGraphEdgeI self)\n" + "\n" + "Parameters:\n" + " self: TUNGraphEdgeI *\n" + "\n" + ""}, + { (char *)"TUNGraphEdgeI_swigregister", TUNGraphEdgeI_swigregister, METH_VARARGS, NULL}, + { (char *)"TUNGraphEdgeI_swiginit", TUNGraphEdgeI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNEANetNodeI", _wrap_new_TNEANetNodeI, METH_VARARGS, (char *)"\n" + "TNEANetNodeI()\n" + "new_TNEANetNodeI(TNEANet::TNodeI const & NodeI) -> TNEANetNodeI\n" + "\n" + "Parameters:\n" + " NodeI: TNEANet::TNodeI const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_Next", (PyCFunction)_wrap_TNEANetNodeI_Next, METH_O, (char *)"\n" + "TNEANetNodeI_Next(TNEANetNodeI self) -> TNEANetNodeI\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI *\n" + "\n" + ""}, + { (char *)"TNEANetNodeI___lt__", _wrap_TNEANetNodeI___lt__, METH_VARARGS, (char *)"\n" + "TNEANetNodeI___lt__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NodeI: TNEANetNodeI const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI___eq__", _wrap_TNEANetNodeI___eq__, METH_VARARGS, (char *)"\n" + "TNEANetNodeI___eq__(TNEANetNodeI self, TNEANetNodeI NodeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NodeI: TNEANetNodeI const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_GetId", (PyCFunction)_wrap_TNEANetNodeI_GetId, METH_O, (char *)"\n" + "TNEANetNodeI_GetId(TNEANetNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_GetDeg", (PyCFunction)_wrap_TNEANetNodeI_GetDeg, METH_O, (char *)"\n" + "TNEANetNodeI_GetDeg(TNEANetNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_GetInDeg", (PyCFunction)_wrap_TNEANetNodeI_GetInDeg, METH_O, (char *)"\n" + "TNEANetNodeI_GetInDeg(TNEANetNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_GetOutDeg", (PyCFunction)_wrap_TNEANetNodeI_GetOutDeg, METH_O, (char *)"\n" + "TNEANetNodeI_GetOutDeg(TNEANetNodeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_GetInNId", _wrap_TNEANetNodeI_GetInNId, METH_VARARGS, (char *)"\n" + "TNEANetNodeI_GetInNId(TNEANetNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_GetOutNId", _wrap_TNEANetNodeI_GetOutNId, METH_VARARGS, (char *)"\n" + "TNEANetNodeI_GetOutNId(TNEANetNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_GetNbrNId", _wrap_TNEANetNodeI_GetNbrNId, METH_VARARGS, (char *)"\n" + "TNEANetNodeI_GetNbrNId(TNEANetNodeI self, int const & NodeN) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NodeN: int const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_IsInNId", _wrap_TNEANetNodeI_IsInNId, METH_VARARGS, (char *)"\n" + "TNEANetNodeI_IsInNId(TNEANetNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_IsOutNId", _wrap_TNEANetNodeI_IsOutNId, METH_VARARGS, (char *)"\n" + "TNEANetNodeI_IsOutNId(TNEANetNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_IsNbrNId", _wrap_TNEANetNodeI_IsNbrNId, METH_VARARGS, (char *)"\n" + "TNEANetNodeI_IsNbrNId(TNEANetNodeI self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"delete_TNEANetNodeI", (PyCFunction)_wrap_delete_TNEANetNodeI, METH_O, (char *)"\n" + "delete_TNEANetNodeI(TNEANetNodeI self)\n" + "\n" + "Parameters:\n" + " self: TNEANetNodeI *\n" + "\n" + ""}, + { (char *)"TNEANetNodeI_swigregister", TNEANetNodeI_swigregister, METH_VARARGS, NULL}, + { (char *)"TNEANetNodeI_swiginit", TNEANetNodeI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNEANetEdgeI", _wrap_new_TNEANetEdgeI, METH_VARARGS, (char *)"\n" + "TNEANetEdgeI()\n" + "new_TNEANetEdgeI(TNEANet::TEdgeI const & EdgeI) -> TNEANetEdgeI\n" + "\n" + "Parameters:\n" + " EdgeI: TNEANet::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TNEANetEdgeI_Next", (PyCFunction)_wrap_TNEANetEdgeI_Next, METH_O, (char *)"\n" + "TNEANetEdgeI_Next(TNEANetEdgeI self) -> TNEANetEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEANetEdgeI *\n" + "\n" + ""}, + { (char *)"TNEANetEdgeI___lt__", _wrap_TNEANetEdgeI___lt__, METH_VARARGS, (char *)"\n" + "TNEANetEdgeI___lt__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetEdgeI const *\n" + " EdgeI: TNEANetEdgeI const &\n" + "\n" + ""}, + { (char *)"TNEANetEdgeI___eq__", _wrap_TNEANetEdgeI___eq__, METH_VARARGS, (char *)"\n" + "TNEANetEdgeI___eq__(TNEANetEdgeI self, TNEANetEdgeI EdgeI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetEdgeI const *\n" + " EdgeI: TNEANetEdgeI const &\n" + "\n" + ""}, + { (char *)"TNEANetEdgeI_GetId", (PyCFunction)_wrap_TNEANetEdgeI_GetId, METH_O, (char *)"\n" + "TNEANetEdgeI_GetId(TNEANetEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetEdgeI const *\n" + "\n" + ""}, + { (char *)"TNEANetEdgeI_GetSrcNId", (PyCFunction)_wrap_TNEANetEdgeI_GetSrcNId, METH_O, (char *)"\n" + "TNEANetEdgeI_GetSrcNId(TNEANetEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetEdgeI const *\n" + "\n" + ""}, + { (char *)"TNEANetEdgeI_GetDstNId", (PyCFunction)_wrap_TNEANetEdgeI_GetDstNId, METH_O, (char *)"\n" + "TNEANetEdgeI_GetDstNId(TNEANetEdgeI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetEdgeI const *\n" + "\n" + ""}, + { (char *)"delete_TNEANetEdgeI", (PyCFunction)_wrap_delete_TNEANetEdgeI, METH_O, (char *)"\n" + "delete_TNEANetEdgeI(TNEANetEdgeI self)\n" + "\n" + "Parameters:\n" + " self: TNEANetEdgeI *\n" + "\n" + ""}, + { (char *)"TNEANetEdgeI_swigregister", TNEANetEdgeI_swigregister, METH_VARARGS, NULL}, + { (char *)"TNEANetEdgeI_swiginit", TNEANetEdgeI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNEANetAIntI", _wrap_new_TNEANetAIntI, METH_VARARGS, (char *)"\n" + "TNEANetAIntI()\n" + "TNEANetAIntI(TIntVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt)\n" + "\n" + "Parameters:\n" + " HIter: TIntVecIter const &\n" + " attribute: TStr\n" + " isEdgeIter: bool\n" + " GraphPt: TNEANet const *\n" + "\n" + "new_TNEANetAIntI(TNEANet::TAIntI const & I) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " I: TNEANet::TAIntI const &\n" + "\n" + ""}, + { (char *)"TNEANetAIntI_Next", (PyCFunction)_wrap_TNEANetAIntI_Next, METH_O, (char *)"\n" + "TNEANetAIntI_Next(TNEANetAIntI self) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TNEANetAIntI *\n" + "\n" + ""}, + { (char *)"TNEANetAIntI___lt__", _wrap_TNEANetAIntI___lt__, METH_VARARGS, (char *)"\n" + "TNEANetAIntI___lt__(TNEANetAIntI self, TNEANetAIntI I) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAIntI const *\n" + " I: TNEANetAIntI const &\n" + "\n" + ""}, + { (char *)"TNEANetAIntI___eq__", _wrap_TNEANetAIntI___eq__, METH_VARARGS, (char *)"\n" + "TNEANetAIntI___eq__(TNEANetAIntI self, TNEANetAIntI I) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAIntI const *\n" + " I: TNEANetAIntI const &\n" + "\n" + ""}, + { (char *)"TNEANetAIntI_GetDat", (PyCFunction)_wrap_TNEANetAIntI_GetDat, METH_O, (char *)"\n" + "TNEANetAIntI_GetDat(TNEANetAIntI self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANetAIntI const *\n" + "\n" + ""}, + { (char *)"TNEANetAIntI_IsDeleted", (PyCFunction)_wrap_TNEANetAIntI_IsDeleted, METH_O, (char *)"\n" + "TNEANetAIntI_IsDeleted(TNEANetAIntI self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAIntI const *\n" + "\n" + ""}, + { (char *)"delete_TNEANetAIntI", (PyCFunction)_wrap_delete_TNEANetAIntI, METH_O, (char *)"\n" + "delete_TNEANetAIntI(TNEANetAIntI self)\n" + "\n" + "Parameters:\n" + " self: TNEANetAIntI *\n" + "\n" + ""}, + { (char *)"TNEANetAIntI_swigregister", TNEANetAIntI_swigregister, METH_VARARGS, NULL}, + { (char *)"TNEANetAIntI_swiginit", TNEANetAIntI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNEANetAStrI", _wrap_new_TNEANetAStrI, METH_VARARGS, (char *)"\n" + "TNEANetAStrI()\n" + "TNEANetAStrI(TStrVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt)\n" + "\n" + "Parameters:\n" + " HIter: TStrVecIter const &\n" + " attribute: TStr\n" + " isEdgeIter: bool\n" + " GraphPt: TNEANet const *\n" + "\n" + "new_TNEANetAStrI(TNEANet::TAStrI const & I) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " I: TNEANet::TAStrI const &\n" + "\n" + ""}, + { (char *)"TNEANetAStrI_Next", (PyCFunction)_wrap_TNEANetAStrI_Next, METH_O, (char *)"\n" + "TNEANetAStrI_Next(TNEANetAStrI self) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TNEANetAStrI *\n" + "\n" + ""}, + { (char *)"TNEANetAStrI___lt__", _wrap_TNEANetAStrI___lt__, METH_VARARGS, (char *)"\n" + "TNEANetAStrI___lt__(TNEANetAStrI self, TNEANetAStrI I) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAStrI const *\n" + " I: TNEANetAStrI const &\n" + "\n" + ""}, + { (char *)"TNEANetAStrI___eq__", _wrap_TNEANetAStrI___eq__, METH_VARARGS, (char *)"\n" + "TNEANetAStrI___eq__(TNEANetAStrI self, TNEANetAStrI I) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAStrI const *\n" + " I: TNEANetAStrI const &\n" + "\n" + ""}, + { (char *)"TNEANetAStrI_GetDat", (PyCFunction)_wrap_TNEANetAStrI_GetDat, METH_O, (char *)"\n" + "TNEANetAStrI_GetDat(TNEANetAStrI self) -> char *\n" + "\n" + "Parameters:\n" + " self: TNEANetAStrI const *\n" + "\n" + ""}, + { (char *)"TNEANetAStrI_IsDeleted", (PyCFunction)_wrap_TNEANetAStrI_IsDeleted, METH_O, (char *)"\n" + "TNEANetAStrI_IsDeleted(TNEANetAStrI self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAStrI const *\n" + "\n" + ""}, + { (char *)"delete_TNEANetAStrI", (PyCFunction)_wrap_delete_TNEANetAStrI, METH_O, (char *)"\n" + "delete_TNEANetAStrI(TNEANetAStrI self)\n" + "\n" + "Parameters:\n" + " self: TNEANetAStrI *\n" + "\n" + ""}, + { (char *)"TNEANetAStrI_swigregister", TNEANetAStrI_swigregister, METH_VARARGS, NULL}, + { (char *)"TNEANetAStrI_swiginit", TNEANetAStrI_swiginit, METH_VARARGS, NULL}, + { (char *)"new_TNEANetAFltI", _wrap_new_TNEANetAFltI, METH_VARARGS, (char *)"\n" + "TNEANetAFltI()\n" + "TNEANetAFltI(TFltVecIter const & HIter, TStr attribute, bool isEdgeIter, TNEANet GraphPt)\n" + "\n" + "Parameters:\n" + " HIter: TFltVecIter const &\n" + " attribute: TStr\n" + " isEdgeIter: bool\n" + " GraphPt: TNEANet const *\n" + "\n" + "new_TNEANetAFltI(TNEANet::TAFltI const & I) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " I: TNEANet::TAFltI const &\n" + "\n" + ""}, + { (char *)"TNEANetAFltI_Next", (PyCFunction)_wrap_TNEANetAFltI_Next, METH_O, (char *)"\n" + "TNEANetAFltI_Next(TNEANetAFltI self) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TNEANetAFltI *\n" + "\n" + ""}, + { (char *)"TNEANetAFltI___lt__", _wrap_TNEANetAFltI___lt__, METH_VARARGS, (char *)"\n" + "TNEANetAFltI___lt__(TNEANetAFltI self, TNEANetAFltI I) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAFltI const *\n" + " I: TNEANetAFltI const &\n" + "\n" + ""}, + { (char *)"TNEANetAFltI___eq__", _wrap_TNEANetAFltI___eq__, METH_VARARGS, (char *)"\n" + "TNEANetAFltI___eq__(TNEANetAFltI self, TNEANetAFltI I) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAFltI const *\n" + " I: TNEANetAFltI const &\n" + "\n" + ""}, + { (char *)"TNEANetAFltI_GetDat", (PyCFunction)_wrap_TNEANetAFltI_GetDat, METH_O, (char *)"\n" + "TNEANetAFltI_GetDat(TNEANetAFltI self) -> double\n" + "\n" + "Parameters:\n" + " self: TNEANetAFltI const *\n" + "\n" + ""}, + { (char *)"TNEANetAFltI_IsDeleted", (PyCFunction)_wrap_TNEANetAFltI_IsDeleted, METH_O, (char *)"\n" + "TNEANetAFltI_IsDeleted(TNEANetAFltI self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANetAFltI const *\n" + "\n" + ""}, + { (char *)"delete_TNEANetAFltI", (PyCFunction)_wrap_delete_TNEANetAFltI, METH_O, (char *)"\n" + "delete_TNEANetAFltI(TNEANetAFltI self)\n" + "\n" + "Parameters:\n" + " self: TNEANetAFltI *\n" + "\n" + ""}, + { (char *)"TNEANetAFltI_swigregister", TNEANetAFltI_swigregister, METH_VARARGS, NULL}, + { (char *)"TNEANetAFltI_swiginit", TNEANetAFltI_swiginit, METH_VARARGS, NULL}, + { (char *)"TPrGraph", (PyCFunction)_wrap_TPrGraph, METH_O, (char *)"\n" + "TPrGraph(PUNGraph G) -> TUNGraph\n" + "\n" + "Parameters:\n" + " G: PUNGraph\n" + "\n" + ""}, + { (char *)"accept_array", (PyCFunction)_wrap_accept_array, METH_O, (char *)"\n" + "accept_array(int [] array) -> int\n" + "\n" + "Parameters:\n" + " array: int []\n" + "\n" + ""}, + { (char *)"print_array", _wrap_print_array, METH_VARARGS, (char *)"\n" + "print_array(int * x, int length)\n" + "\n" + "Parameters:\n" + " x: int *\n" + " length: int\n" + "\n" + ""}, + { (char *)"PyTFltV", (PyCFunction)_wrap_PyTFltV, METH_O, (char *)"\n" + "PyTFltV(double [10] x) -> TFltV\n" + "\n" + "Parameters:\n" + " x: double [10]\n" + "\n" + ""}, + { (char *)"PyToTIntV", (PyCFunction)_wrap_PyToTIntV, METH_O, (char *)"\n" + "PyToTIntV(int * array) -> TIntV\n" + "\n" + "Parameters:\n" + " array: int *\n" + "\n" + ""}, + { (char *)"count", _wrap_count, METH_VARARGS, (char *)"\n" + "count(char * str, char c) -> int\n" + "\n" + "Parameters:\n" + " str: char *\n" + " c: char\n" + "\n" + ""}, + { (char *)"TIntVToPy", (PyCFunction)_wrap_TIntVToPy, METH_O, (char *)"\n" + "TIntVToPy(TIntV originalList)\n" + "\n" + "Parameters:\n" + " originalList: TIntV\n" + "\n" + ""}, + { (char *)"new_TNEANet", _wrap_new_TNEANet, METH_VARARGS, (char *)"\n" + "TNEANet()\n" + "TNEANet(int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + "TNEANet(TNEANet Graph)\n" + "\n" + "Parameters:\n" + " Graph: TNEANet const &\n" + "\n" + "new_TNEANet(TSIn SIn) -> TNEANet\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TNEANet_Save", _wrap_TNEANet_Save, METH_VARARGS, (char *)"\n" + "TNEANet_Save(TNEANet self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"TNEANet_New", _wrap_TNEANet_New, METH_VARARGS, (char *)"\n" + "New() -> PNEANet\n" + "TNEANet_New(int const & Nodes, int const & Edges) -> PNEANet\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_Load", (PyCFunction)_wrap_TNEANet_Load, METH_O, (char *)"\n" + "TNEANet_Load(TSIn SIn) -> PNEANet\n" + "\n" + "Parameters:\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"TNEANet_HasFlag", _wrap_TNEANet_HasFlag, METH_VARARGS, (char *)"\n" + "TNEANet_HasFlag(TNEANet self, TGraphFlag const & Flag) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " Flag: TGraphFlag const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetNodes", (PyCFunction)_wrap_TNEANet_GetNodes, METH_O, (char *)"\n" + "TNEANet_GetNodes(TNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + "\n" + ""}, + { (char *)"TNEANet_AddNode", _wrap_TNEANet_AddNode, METH_VARARGS, (char *)"\n" + "AddNode(int NId=-1) -> int\n" + "\n" + "Parameters:\n" + " NId: int\n" + "\n" + "AddNode() -> int\n" + "TNEANet_AddNode(TNEANet self, TNEANet::TNodeI const & NodeId) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NodeId: TNEANet::TNodeI const &\n" + "\n" + ""}, + { (char *)"TNEANet_DelNode", _wrap_TNEANet_DelNode, METH_VARARGS, (char *)"\n" + "DelNode(int const & NId)\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + "\n" + "TNEANet_DelNode(TNEANet self, TNEANet::TNode const & NodeI)\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NodeI: TNEANet::TNode const &\n" + "\n" + ""}, + { (char *)"TNEANet_IsNode", _wrap_TNEANet_IsNode, METH_VARARGS, (char *)"\n" + "TNEANet_IsNode(TNEANet self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetNI", _wrap_TNEANet_GetNI, METH_VARARGS, (char *)"\n" + "TNEANet_GetNI(TNEANet self, int const & NId) -> TNEANet::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetNAIntI", _wrap_TNEANet_GetNAIntI, METH_VARARGS, (char *)"\n" + "TNEANet_GetNAIntI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " attr: TStr const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetNAStrI", _wrap_TNEANet_GetNAStrI, METH_VARARGS, (char *)"\n" + "TNEANet_GetNAStrI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " attr: TStr const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetNAFltI", _wrap_TNEANet_GetNAFltI, METH_VARARGS, (char *)"\n" + "TNEANet_GetNAFltI(TNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " attr: TStr const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_AttrNameNI", _wrap_TNEANet_AttrNameNI, METH_VARARGS, (char *)"\n" + "AttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_AttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_AttrValueNI", _wrap_TNEANet_AttrValueNI, METH_VARARGS, (char *)"\n" + "AttrValueNI(TInt NId, TStrV Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "TNEANet_AttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_IntAttrNameNI", _wrap_TNEANet_IntAttrNameNI, METH_VARARGS, (char *)"\n" + "IntAttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_IntAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_IntAttrValueNI", _wrap_TNEANet_IntAttrValueNI, METH_VARARGS, (char *)"\n" + "IntAttrValueNI(TInt NId, TIntV Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TIntV &\n" + "\n" + "TNEANet_IntAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TIntV &\n" + "\n" + ""}, + { (char *)"TNEANet_StrAttrNameNI", _wrap_TNEANet_StrAttrNameNI, METH_VARARGS, (char *)"\n" + "StrAttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_StrAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_StrAttrValueNI", _wrap_TNEANet_StrAttrValueNI, METH_VARARGS, (char *)"\n" + "StrAttrValueNI(TInt NId, TStrV Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "TNEANet_StrAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_FltAttrNameNI", _wrap_TNEANet_FltAttrNameNI, METH_VARARGS, (char *)"\n" + "FltAttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_FltAttrNameNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_FltAttrValueNI", _wrap_TNEANet_FltAttrValueNI, METH_VARARGS, (char *)"\n" + "FltAttrValueNI(TInt NId, TFltV & Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TFltV &\n" + "\n" + "TNEANet_FltAttrValueNI(TNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TFltV &\n" + "\n" + ""}, + { (char *)"TNEANet_AttrNameEI", _wrap_TNEANet_AttrNameEI, METH_VARARGS, (char *)"\n" + "AttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_AttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_AttrValueEI", _wrap_TNEANet_AttrValueEI, METH_VARARGS, (char *)"\n" + "AttrValueEI(TInt EId, TStrV Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "TNEANet_AttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_IntAttrNameEI", _wrap_TNEANet_IntAttrNameEI, METH_VARARGS, (char *)"\n" + "IntAttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_IntAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_IntAttrValueEI", _wrap_TNEANet_IntAttrValueEI, METH_VARARGS, (char *)"\n" + "IntAttrValueEI(TInt EId, TIntV Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TIntV &\n" + "\n" + "TNEANet_IntAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TIntV &\n" + "\n" + ""}, + { (char *)"TNEANet_StrAttrNameEI", _wrap_TNEANet_StrAttrNameEI, METH_VARARGS, (char *)"\n" + "StrAttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_StrAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_StrAttrValueEI", _wrap_TNEANet_StrAttrValueEI, METH_VARARGS, (char *)"\n" + "StrAttrValueEI(TInt EId, TStrV Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "TNEANet_StrAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_FltAttrNameEI", _wrap_TNEANet_FltAttrNameEI, METH_VARARGS, (char *)"\n" + "FltAttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "TNEANet_FltAttrNameEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"TNEANet_FltAttrValueEI", _wrap_TNEANet_FltAttrValueEI, METH_VARARGS, (char *)"\n" + "FltAttrValueEI(TInt EId, TFltV & Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TFltV &\n" + "\n" + "TNEANet_FltAttrValueEI(TNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TFltV &\n" + "\n" + ""}, + { (char *)"TNEANet_GetEAIntI", _wrap_TNEANet_GetEAIntI, METH_VARARGS, (char *)"\n" + "TNEANet_GetEAIntI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " attr: TStr const &\n" + " EId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetEAStrI", _wrap_TNEANet_GetEAStrI, METH_VARARGS, (char *)"\n" + "TNEANet_GetEAStrI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " attr: TStr const &\n" + " EId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetEAFltI", _wrap_TNEANet_GetEAFltI, METH_VARARGS, (char *)"\n" + "TNEANet_GetEAFltI(TNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " attr: TStr const &\n" + " EId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetMxNId", (PyCFunction)_wrap_TNEANet_GetMxNId, METH_O, (char *)"\n" + "TNEANet_GetMxNId(TNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + "\n" + ""}, + { (char *)"TNEANet_GetEdges", (PyCFunction)_wrap_TNEANet_GetEdges, METH_O, (char *)"\n" + "TNEANet_GetEdges(TNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + "\n" + ""}, + { (char *)"TNEANet_AddEdge", _wrap_TNEANet_AddEdge, METH_VARARGS, (char *)"\n" + "AddEdge(int const & SrcNId, int const & DstNId, int EId=-1) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int\n" + "\n" + "AddEdge(int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "TNEANet_AddEdge(TNEANet self, TNEANet::TEdgeI const & EdgeI) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EdgeI: TNEANet::TEdgeI const &\n" + "\n" + ""}, + { (char *)"TNEANet_DelEdge", _wrap_TNEANet_DelEdge, METH_VARARGS, (char *)"\n" + "DelEdge(int const & EId)\n" + "\n" + "Parameters:\n" + " EId: int const &\n" + "\n" + "DelEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True)\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "TNEANet_DelEdge(TNEANet self, int const & SrcNId, int const & DstNId)\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_IsEdge", _wrap_TNEANet_IsEdge, METH_VARARGS, (char *)"\n" + "IsEdge(int const & EId) -> bool\n" + "\n" + "Parameters:\n" + " EId: int const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int &\n" + " IsDir: bool const &\n" + "\n" + "TNEANet_IsEdge(TNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int &\n" + "\n" + ""}, + { (char *)"TNEANet_GetEId", _wrap_TNEANet_GetEId, METH_VARARGS, (char *)"\n" + "TNEANet_GetEId(TNEANet self, int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetEI", _wrap_TNEANet_GetEI, METH_VARARGS, (char *)"\n" + "TNEANet_GetEI(TNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetRndNId", _wrap_TNEANet_GetRndNId, METH_VARARGS, (char *)"\n" + "GetRndNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEANet_GetRndNId(TNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_GetRndNI", _wrap_TNEANet_GetRndNI, METH_VARARGS, (char *)"\n" + "GetRndNI(TRnd Rnd=Rnd) -> TNEANet::TNodeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEANet_GetRndNI(TNEANet self) -> TNEANet::TNodeI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_GetRndEId", _wrap_TNEANet_GetRndEId, METH_VARARGS, (char *)"\n" + "GetRndEId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEANet_GetRndEId(TNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_GetRndEI", _wrap_TNEANet_GetRndEI, METH_VARARGS, (char *)"\n" + "GetRndEI(TRnd Rnd=Rnd) -> TNEANet::TEdgeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "TNEANet_GetRndEI(TNEANet self) -> TNEANet::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_GetNIdV", _wrap_TNEANet_GetNIdV, METH_VARARGS, (char *)"\n" + "TNEANet_GetNIdV(TNEANet self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TNEANet_GetEIdV", _wrap_TNEANet_GetEIdV, METH_VARARGS, (char *)"\n" + "TNEANet_GetEIdV(TNEANet self, TIntV EIdV)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EIdV: TIntV &\n" + "\n" + ""}, + { (char *)"TNEANet_Empty", (PyCFunction)_wrap_TNEANet_Empty, METH_O, (char *)"\n" + "TNEANet_Empty(TNEANet self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + "\n" + ""}, + { (char *)"TNEANet_Clr", (PyCFunction)_wrap_TNEANet_Clr, METH_O, (char *)"\n" + "TNEANet_Clr(TNEANet self)\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_Reserve", _wrap_TNEANet_Reserve, METH_VARARGS, (char *)"\n" + "TNEANet_Reserve(TNEANet self, int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"TNEANet_Defrag", _wrap_TNEANet_Defrag, METH_VARARGS, (char *)"\n" + "Defrag(bool const & OnlyNodeLinks=False)\n" + "\n" + "Parameters:\n" + " OnlyNodeLinks: bool const &\n" + "\n" + "TNEANet_Defrag(TNEANet self)\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_IsOk", _wrap_TNEANet_IsOk, METH_VARARGS, (char *)"\n" + "IsOk(bool const & ThrowExcept=True) -> bool\n" + "\n" + "Parameters:\n" + " ThrowExcept: bool const &\n" + "\n" + "TNEANet_IsOk(TNEANet self) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + "\n" + ""}, + { (char *)"TNEANet_Dump", _wrap_TNEANet_Dump, METH_VARARGS, (char *)"\n" + "Dump(FILE * OutF=stdout)\n" + "\n" + "Parameters:\n" + " OutF: FILE *\n" + "\n" + "TNEANet_Dump(TNEANet self)\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + "\n" + ""}, + { (char *)"TNEANet_AddIntAttrDatN", _wrap_TNEANet_AddIntAttrDatN, METH_VARARGS, (char *)"\n" + "AddIntAttrDatN(TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_AddIntAttrDatN(TNEANet self, int const & NId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NId: int const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddStrAttrDatN", _wrap_TNEANet_AddStrAttrDatN, METH_VARARGS, (char *)"\n" + "AddStrAttrDatN(TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_AddStrAttrDatN(TNEANet self, int const & NId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NId: int const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddFltAttrDatN", _wrap_TNEANet_AddFltAttrDatN, METH_VARARGS, (char *)"\n" + "AddFltAttrDatN(TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_AddFltAttrDatN(TNEANet self, int const & NId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NId: int const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddIntAttrDatE", _wrap_TNEANet_AddIntAttrDatE, METH_VARARGS, (char *)"\n" + "AddIntAttrDatE(TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_AddIntAttrDatE(TNEANet self, int const & EId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EId: int const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddStrAttrDatE", _wrap_TNEANet_AddStrAttrDatE, METH_VARARGS, (char *)"\n" + "AddStrAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_AddStrAttrDatE(TNEANet self, int const & EId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EId: int const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddFltAttrDatE", _wrap_TNEANet_AddFltAttrDatE, METH_VARARGS, (char *)"\n" + "AddFltAttrDatE(TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_AddFltAttrDatE(TNEANet self, int const & EId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EId: int const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetIntAttrDatN", _wrap_TNEANet_GetIntAttrDatN, METH_VARARGS, (char *)"\n" + "GetIntAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_GetIntAttrDatN(TNEANet self, int const & NId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetStrAttrDatN", _wrap_TNEANet_GetStrAttrDatN, METH_VARARGS, (char *)"\n" + "GetStrAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_GetStrAttrDatN(TNEANet self, int const & NId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetFltAttrDatN", _wrap_TNEANet_GetFltAttrDatN, METH_VARARGS, (char *)"\n" + "GetFltAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_GetFltAttrDatN(TNEANet self, int const & NId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetIntAttrDatE", _wrap_TNEANet_GetIntAttrDatE, METH_VARARGS, (char *)"\n" + "GetIntAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_GetIntAttrDatE(TNEANet self, int const & EId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetStrAttrDatE", _wrap_TNEANet_GetStrAttrDatE, METH_VARARGS, (char *)"\n" + "GetStrAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_GetStrAttrDatE(TNEANet self, int const & EId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetFltAttrDatE", _wrap_TNEANet_GetFltAttrDatE, METH_VARARGS, (char *)"\n" + "GetFltAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_GetFltAttrDatE(TNEANet self, int const & EId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_DelAttrDatN", _wrap_TNEANet_DelAttrDatN, METH_VARARGS, (char *)"\n" + "DelAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_DelAttrDatN(TNEANet self, int const & NId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_DelAttrDatE", _wrap_TNEANet_DelAttrDatE, METH_VARARGS, (char *)"\n" + "DelAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "TNEANet_DelAttrDatE(TNEANet self, int const & EId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddIntAttrN", _wrap_TNEANet_AddIntAttrN, METH_VARARGS, (char *)"\n" + "AddIntAttrN(TStr attr, TInt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TInt\n" + "\n" + "TNEANet_AddIntAttrN(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddStrAttrN", _wrap_TNEANet_AddStrAttrN, METH_VARARGS, (char *)"\n" + "AddStrAttrN(TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TStr\n" + "\n" + "TNEANet_AddStrAttrN(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddFltAttrN", _wrap_TNEANet_AddFltAttrN, METH_VARARGS, (char *)"\n" + "AddFltAttrN(TStr attr, TFlt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TFlt\n" + "\n" + "TNEANet_AddFltAttrN(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddIntAttrE", _wrap_TNEANet_AddIntAttrE, METH_VARARGS, (char *)"\n" + "AddIntAttrE(TStr attr, TInt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TInt\n" + "\n" + "TNEANet_AddIntAttrE(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddStrAttrE", _wrap_TNEANet_AddStrAttrE, METH_VARARGS, (char *)"\n" + "AddStrAttrE(TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TStr\n" + "\n" + "TNEANet_AddStrAttrE(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_AddFltAttrE", _wrap_TNEANet_AddFltAttrE, METH_VARARGS, (char *)"\n" + "AddFltAttrE(TStr attr, TFlt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TFlt\n" + "\n" + "TNEANet_AddFltAttrE(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_DelAttrN", _wrap_TNEANet_DelAttrN, METH_VARARGS, (char *)"\n" + "TNEANet_DelAttrN(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_DelAttrE", _wrap_TNEANet_DelAttrE, METH_VARARGS, (char *)"\n" + "TNEANet_DelAttrE(TNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_NodeAttrIsDeleted", _wrap_TNEANet_NodeAttrIsDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_NodeAttrIsDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_NodeAttrIsIntDeleted", _wrap_TNEANet_NodeAttrIsIntDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_NodeAttrIsIntDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_NodeAttrIsStrDeleted", _wrap_TNEANet_NodeAttrIsStrDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_NodeAttrIsStrDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_NodeAttrIsFltDeleted", _wrap_TNEANet_NodeAttrIsFltDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_NodeAttrIsFltDeleted(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_EdgeAttrIsDeleted", _wrap_TNEANet_EdgeAttrIsDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_EdgeAttrIsDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_EdgeAttrIsIntDeleted", _wrap_TNEANet_EdgeAttrIsIntDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_EdgeAttrIsIntDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_EdgeAttrIsStrDeleted", _wrap_TNEANet_EdgeAttrIsStrDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_EdgeAttrIsStrDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_EdgeAttrIsFltDeleted", _wrap_TNEANet_EdgeAttrIsFltDeleted, METH_VARARGS, (char *)"\n" + "TNEANet_EdgeAttrIsFltDeleted(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetNodeAttrValue", _wrap_TNEANet_GetNodeAttrValue, METH_VARARGS, (char *)"\n" + "TNEANet_GetNodeAttrValue(TNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_GetEdgeAttrValue", _wrap_TNEANet_GetEdgeAttrValue, METH_VARARGS, (char *)"\n" + "TNEANet_GetEdgeAttrValue(TNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr\n" + "\n" + "Parameters:\n" + " self: TNEANet const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"TNEANet_BegNI", _wrap_TNEANet_BegNI, METH_VARARGS, (char *)"\n" + "BegNI() -> TNEANet::TNodeI\n" + "TNEANet_BegNI(TNEANet self) -> TNEANetNodeI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_EndNI", _wrap_TNEANet_EndNI, METH_VARARGS, (char *)"\n" + "EndNI() -> TNEANet::TNodeI\n" + "TNEANet_EndNI(TNEANet self) -> TNEANetNodeI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_BegEI", _wrap_TNEANet_BegEI, METH_VARARGS, (char *)"\n" + "BegEI() -> TNEANet::TEdgeI\n" + "TNEANet_BegEI(TNEANet self) -> TNEANetEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_EndEI", _wrap_TNEANet_EndEI, METH_VARARGS, (char *)"\n" + "EndEI() -> TNEANet::TEdgeI\n" + "TNEANet_EndEI(TNEANet self) -> TNEANetEdgeI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_BegNAIntI", _wrap_TNEANet_BegNAIntI, METH_VARARGS, (char *)"\n" + "BegNAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_BegNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_EndNAIntI", _wrap_TNEANet_EndNAIntI, METH_VARARGS, (char *)"\n" + "EndNAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_EndNAIntI(TNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_BegNAStrI", _wrap_TNEANet_BegNAStrI, METH_VARARGS, (char *)"\n" + "BegNAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_BegNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_EndNAStrI", _wrap_TNEANet_EndNAStrI, METH_VARARGS, (char *)"\n" + "EndNAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_EndNAStrI(TNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_BegNAFltI", _wrap_TNEANet_BegNAFltI, METH_VARARGS, (char *)"\n" + "BegNAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_BegNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_EndNAFltI", _wrap_TNEANet_EndNAFltI, METH_VARARGS, (char *)"\n" + "EndNAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_EndNAFltI(TNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_BegEAIntI", _wrap_TNEANet_BegEAIntI, METH_VARARGS, (char *)"\n" + "BegEAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_BegEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_EndEAIntI", _wrap_TNEANet_EndEAIntI, METH_VARARGS, (char *)"\n" + "EndEAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_EndEAIntI(TNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_BegEAStrI", _wrap_TNEANet_BegEAStrI, METH_VARARGS, (char *)"\n" + "BegEAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_BegEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_EndEAStrI", _wrap_TNEANet_EndEAStrI, METH_VARARGS, (char *)"\n" + "EndEAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_EndEAStrI(TNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_BegEAFltI", _wrap_TNEANet_BegEAFltI, METH_VARARGS, (char *)"\n" + "BegEAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_BegEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"TNEANet_EndEAFltI", _wrap_TNEANet_EndEAFltI, METH_VARARGS, (char *)"\n" + "EndEAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "TNEANet_EndEAFltI(TNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"delete_TNEANet", (PyCFunction)_wrap_delete_TNEANet, METH_O, (char *)"\n" + "delete_TNEANet(TNEANet self)\n" + "\n" + "Parameters:\n" + " self: TNEANet *\n" + "\n" + ""}, + { (char *)"TNEANet_swigregister", TNEANet_swigregister, METH_VARARGS, NULL}, + { (char *)"TNEANet_swiginit", TNEANet_swiginit, METH_VARARGS, NULL}, + { (char *)"PercentDegree", _wrap_PercentDegree, METH_VARARGS, (char *)"\n" + "PercentDegree(PNEANet Graph, int const Threshold=0) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " Threshold: int const\n" + "\n" + "PercentDegree(PNEANet Graph) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"PercentMxWcc", (PyCFunction)_wrap_PercentMxWcc, METH_O, (char *)"\n" + "PercentMxWcc(PNEANet Graph) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"PercentMxScc", (PyCFunction)_wrap_PercentMxScc, METH_O, (char *)"\n" + "PercentMxScc(PNEANet Graph) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"LoadEdgeList", _wrap_LoadEdgeList, METH_VARARGS, (char *)"\n" + "LoadEdgeList(TStr InFNm, int const & SrcColId=0, int const & DstColId=1) -> PNEANet\n" + "\n" + "Parameters:\n" + " InFNm: TStr const &\n" + " SrcColId: int const &\n" + " DstColId: int const &\n" + "\n" + "LoadEdgeList(TStr InFNm, int const & SrcColId=0) -> PNEANet\n" + "\n" + "Parameters:\n" + " InFNm: TStr const &\n" + " SrcColId: int const &\n" + "\n" + "LoadEdgeList(TStr InFNm) -> PNEANet\n" + "\n" + "Parameters:\n" + " InFNm: TStr const &\n" + "\n" + "LoadEdgeList(TStr InFNm, int const & SrcColId, int const & DstColId, char const & Separator) -> PNEANet\n" + "\n" + "Parameters:\n" + " InFNm: TStr const &\n" + " SrcColId: int const &\n" + " DstColId: int const &\n" + " Separator: char const &\n" + "\n" + ""}, + { (char *)"PrintGraphStatTable", _wrap_PrintGraphStatTable, METH_VARARGS, (char *)"\n" + "PrintGraphStatTable(PNEANet G, TStr OutFNm, TStr Desc=\"\")\n" + "\n" + "Parameters:\n" + " G: TPt< TNEANet > const &\n" + " OutFNm: TStr\n" + " Desc: TStr\n" + "\n" + "PrintGraphStatTable(PNEANet G, TStr OutFNm)\n" + "\n" + "Parameters:\n" + " G: TPt< TNEANet > const &\n" + " OutFNm: TStr\n" + "\n" + ""}, + { (char *)"GenRndGnm", _wrap_GenRndGnm, METH_VARARGS, (char *)"\n" + "GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True, TRnd Rnd=Rnd) -> PNEANet\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + " IsDir: bool const &\n" + " Rnd: TRnd &\n" + "\n" + "GenRndGnm(int const & Nodes, int const & Edges, bool const & IsDir=True) -> PNEANet\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + " IsDir: bool const &\n" + "\n" + "GenRndGnm(int const & Nodes, int const & Edges) -> PNEANet\n" + "\n" + "Parameters:\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"NodesGTEDegree", _wrap_NodesGTEDegree, METH_VARARGS, (char *)"\n" + "NodesGTEDegree(PNEANet Graph, int const Threshold=0) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " Threshold: int const\n" + "\n" + "NodesGTEDegree(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"MxDegree", (PyCFunction)_wrap_MxDegree, METH_O, (char *)"\n" + "MxDegree(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"MxSccSz", (PyCFunction)_wrap_MxSccSz, METH_O, (char *)"\n" + "MxSccSz(PNEANet Graph) -> PNEANet\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"MxWccSz", (PyCFunction)_wrap_MxWccSz, METH_O, (char *)"\n" + "MxWccSz(PNEANet Graph) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"PNEANet_New", (PyCFunction)_wrap_PNEANet_New, METH_NOARGS, (char *)"PNEANet_New() -> PNEANet"}, + { (char *)"delete_PNEANet", (PyCFunction)_wrap_delete_PNEANet, METH_O, (char *)"\n" + "delete_PNEANet(PNEANet self)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_Save", _wrap_PNEANet_Save, METH_VARARGS, (char *)"\n" + "PNEANet_Save(PNEANet self, TSOut SOut)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " SOut: TSOut &\n" + "\n" + ""}, + { (char *)"PNEANet___deref__", (PyCFunction)_wrap_PNEANet___deref__, METH_O, (char *)"\n" + "PNEANet___deref__(PNEANet self) -> TNEANet\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet___ref__", (PyCFunction)_wrap_PNEANet___ref__, METH_O, (char *)"\n" + "PNEANet___ref__(PNEANet self) -> TNEANet\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet___call__", (PyCFunction)_wrap_PNEANet___call__, METH_O, (char *)"\n" + "PNEANet___call__(PNEANet self) -> TNEANet\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_Empty", (PyCFunction)_wrap_PNEANet_Empty, METH_O, (char *)"\n" + "PNEANet_Empty(PNEANet self) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_Clr", (PyCFunction)_wrap_PNEANet_Clr, METH_O, (char *)"\n" + "PNEANet_Clr(PNEANet self)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_GetRefs", (PyCFunction)_wrap_PNEANet_GetRefs, METH_O, (char *)"\n" + "PNEANet_GetRefs(PNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_Load", _wrap_PNEANet_Load, METH_VARARGS, (char *)"\n" + "PNEANet_Load(PNEANet self, TSIn SIn) -> PNEANet\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " SIn: TSIn &\n" + "\n" + ""}, + { (char *)"PNEANet_HasFlag", _wrap_PNEANet_HasFlag, METH_VARARGS, (char *)"\n" + "PNEANet_HasFlag(PNEANet self, TGraphFlag const & Flag) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " Flag: TGraphFlag const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetNodes", (PyCFunction)_wrap_PNEANet_GetNodes, METH_O, (char *)"\n" + "PNEANet_GetNodes(PNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_AddNode", _wrap_PNEANet_AddNode, METH_VARARGS, (char *)"\n" + "AddNode(int NId=-1) -> int\n" + "\n" + "Parameters:\n" + " NId: int\n" + "\n" + "AddNode() -> int\n" + "PNEANet_AddNode(PNEANet self, TNEANet::TNodeI const & NodeId) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NodeId: TNEANet::TNodeI const &\n" + "\n" + ""}, + { (char *)"PNEANet_DelNode", _wrap_PNEANet_DelNode, METH_VARARGS, (char *)"\n" + "DelNode(int const & NId)\n" + "\n" + "Parameters:\n" + " NId: int const &\n" + "\n" + "PNEANet_DelNode(PNEANet self, TNEANet::TNode const & NodeI)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NodeI: TNEANet::TNode const &\n" + "\n" + ""}, + { (char *)"PNEANet_IsNode", _wrap_PNEANet_IsNode, METH_VARARGS, (char *)"\n" + "PNEANet_IsNode(PNEANet self, int const & NId) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_BegNI", _wrap_PNEANet_BegNI, METH_VARARGS, (char *)"\n" + "BegNI() -> TNEANet::TNodeI\n" + "PNEANet_BegNI(PNEANet self) -> TNEANetNodeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_EndNI", _wrap_PNEANet_EndNI, METH_VARARGS, (char *)"\n" + "EndNI() -> TNEANet::TNodeI\n" + "PNEANet_EndNI(PNEANet self) -> TNEANetNodeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_GetNI", _wrap_PNEANet_GetNI, METH_VARARGS, (char *)"\n" + "PNEANet_GetNI(PNEANet self, int const & NId) -> TNEANet::TNodeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_BegNAIntI", _wrap_PNEANet_BegNAIntI, METH_VARARGS, (char *)"\n" + "BegNAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_BegNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_EndNAIntI", _wrap_PNEANet_EndNAIntI, METH_VARARGS, (char *)"\n" + "EndNAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_EndNAIntI(PNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetNAIntI", _wrap_PNEANet_GetNAIntI, METH_VARARGS, (char *)"\n" + "PNEANet_GetNAIntI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " attr: TStr const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_BegNAStrI", _wrap_PNEANet_BegNAStrI, METH_VARARGS, (char *)"\n" + "BegNAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_BegNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_EndNAStrI", _wrap_PNEANet_EndNAStrI, METH_VARARGS, (char *)"\n" + "EndNAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_EndNAStrI(PNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetNAStrI", _wrap_PNEANet_GetNAStrI, METH_VARARGS, (char *)"\n" + "PNEANet_GetNAStrI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " attr: TStr const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_BegNAFltI", _wrap_PNEANet_BegNAFltI, METH_VARARGS, (char *)"\n" + "BegNAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_BegNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_EndNAFltI", _wrap_PNEANet_EndNAFltI, METH_VARARGS, (char *)"\n" + "EndNAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_EndNAFltI(PNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetNAFltI", _wrap_PNEANet_GetNAFltI, METH_VARARGS, (char *)"\n" + "PNEANet_GetNAFltI(PNEANet self, TStr attr, int const & NId) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " attr: TStr const &\n" + " NId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_AttrNameNI", _wrap_PNEANet_AttrNameNI, METH_VARARGS, (char *)"\n" + "AttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_AttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_AttrValueNI", _wrap_PNEANet_AttrValueNI, METH_VARARGS, (char *)"\n" + "AttrValueNI(TInt NId, TStrV Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "PNEANet_AttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_IntAttrNameNI", _wrap_PNEANet_IntAttrNameNI, METH_VARARGS, (char *)"\n" + "IntAttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_IntAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_IntAttrValueNI", _wrap_PNEANet_IntAttrValueNI, METH_VARARGS, (char *)"\n" + "IntAttrValueNI(TInt NId, TIntV Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TIntV &\n" + "\n" + "PNEANet_IntAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TIntV Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TIntV &\n" + "\n" + ""}, + { (char *)"PNEANet_StrAttrNameNI", _wrap_PNEANet_StrAttrNameNI, METH_VARARGS, (char *)"\n" + "StrAttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_StrAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_StrAttrValueNI", _wrap_PNEANet_StrAttrValueNI, METH_VARARGS, (char *)"\n" + "StrAttrValueNI(TInt NId, TStrV Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "PNEANet_StrAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_FltAttrNameNI", _wrap_PNEANet_FltAttrNameNI, METH_VARARGS, (char *)"\n" + "FltAttrNameNI(TInt NId, TStrV Names)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_FltAttrNameNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_FltAttrValueNI", _wrap_PNEANet_FltAttrValueNI, METH_VARARGS, (char *)"\n" + "FltAttrValueNI(TInt NId, TFltV & Values)\n" + "\n" + "Parameters:\n" + " NId: TInt const &\n" + " Values: TFltV &\n" + "\n" + "PNEANet_FltAttrValueNI(PNEANet self, TInt NId, TStrIntPrH::TIter NodeHI, TFltV & Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: TInt const &\n" + " NodeHI: TStrIntPrH::TIter\n" + " Values: TFltV &\n" + "\n" + ""}, + { (char *)"PNEANet_AttrNameEI", _wrap_PNEANet_AttrNameEI, METH_VARARGS, (char *)"\n" + "AttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_AttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_AttrValueEI", _wrap_PNEANet_AttrValueEI, METH_VARARGS, (char *)"\n" + "AttrValueEI(TInt EId, TStrV Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "PNEANet_AttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_IntAttrNameEI", _wrap_PNEANet_IntAttrNameEI, METH_VARARGS, (char *)"\n" + "IntAttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_IntAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_IntAttrValueEI", _wrap_PNEANet_IntAttrValueEI, METH_VARARGS, (char *)"\n" + "IntAttrValueEI(TInt EId, TIntV Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TIntV &\n" + "\n" + "PNEANet_IntAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TIntV Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TIntV &\n" + "\n" + ""}, + { (char *)"PNEANet_StrAttrNameEI", _wrap_PNEANet_StrAttrNameEI, METH_VARARGS, (char *)"\n" + "StrAttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_StrAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_StrAttrValueEI", _wrap_PNEANet_StrAttrValueEI, METH_VARARGS, (char *)"\n" + "StrAttrValueEI(TInt EId, TStrV Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TStrV &\n" + "\n" + "PNEANet_StrAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_FltAttrNameEI", _wrap_PNEANet_FltAttrNameEI, METH_VARARGS, (char *)"\n" + "FltAttrNameEI(TInt EId, TStrV Names)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Names: TStrV &\n" + "\n" + "PNEANet_FltAttrNameEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TStrV Names)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Names: TStrV &\n" + "\n" + ""}, + { (char *)"PNEANet_FltAttrValueEI", _wrap_PNEANet_FltAttrValueEI, METH_VARARGS, (char *)"\n" + "FltAttrValueEI(TInt EId, TFltV & Values)\n" + "\n" + "Parameters:\n" + " EId: TInt const &\n" + " Values: TFltV &\n" + "\n" + "PNEANet_FltAttrValueEI(PNEANet self, TInt EId, TStrIntPrH::TIter EdgeHI, TFltV & Values)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: TInt const &\n" + " EdgeHI: TStrIntPrH::TIter\n" + " Values: TFltV &\n" + "\n" + ""}, + { (char *)"PNEANet_BegEAIntI", _wrap_PNEANet_BegEAIntI, METH_VARARGS, (char *)"\n" + "BegEAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_BegEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_EndEAIntI", _wrap_PNEANet_EndEAIntI, METH_VARARGS, (char *)"\n" + "EndEAIntI(TStr attr) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_EndEAIntI(PNEANet self, TStr attr) -> TNEANetAIntI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetEAIntI", _wrap_PNEANet_GetEAIntI, METH_VARARGS, (char *)"\n" + "PNEANet_GetEAIntI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAIntI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " attr: TStr const &\n" + " EId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_BegEAStrI", _wrap_PNEANet_BegEAStrI, METH_VARARGS, (char *)"\n" + "BegEAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_BegEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_EndEAStrI", _wrap_PNEANet_EndEAStrI, METH_VARARGS, (char *)"\n" + "EndEAStrI(TStr attr) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_EndEAStrI(PNEANet self, TStr attr) -> TNEANetAStrI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetEAStrI", _wrap_PNEANet_GetEAStrI, METH_VARARGS, (char *)"\n" + "PNEANet_GetEAStrI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAStrI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " attr: TStr const &\n" + " EId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_BegEAFltI", _wrap_PNEANet_BegEAFltI, METH_VARARGS, (char *)"\n" + "BegEAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_BegEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_EndEAFltI", _wrap_PNEANet_EndEAFltI, METH_VARARGS, (char *)"\n" + "EndEAFltI(TStr attr) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + "\n" + "PNEANet_EndEAFltI(PNEANet self, TStr attr) -> TNEANetAFltI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetEAFltI", _wrap_PNEANet_GetEAFltI, METH_VARARGS, (char *)"\n" + "PNEANet_GetEAFltI(PNEANet self, TStr attr, int const & EId) -> TNEANet::TAFltI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " attr: TStr const &\n" + " EId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetMxNId", (PyCFunction)_wrap_PNEANet_GetMxNId, METH_O, (char *)"\n" + "PNEANet_GetMxNId(PNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_GetEdges", (PyCFunction)_wrap_PNEANet_GetEdges, METH_O, (char *)"\n" + "PNEANet_GetEdges(PNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_AddEdge", _wrap_PNEANet_AddEdge, METH_VARARGS, (char *)"\n" + "AddEdge(int const & SrcNId, int const & DstNId, int EId=-1) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int\n" + "\n" + "AddEdge(int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "PNEANet_AddEdge(PNEANet self, TNEANet::TEdgeI const & EdgeI) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EdgeI: TNEANet::TEdgeI const &\n" + "\n" + ""}, + { (char *)"PNEANet_DelEdge", _wrap_PNEANet_DelEdge, METH_VARARGS, (char *)"\n" + "DelEdge(int const & EId)\n" + "\n" + "Parameters:\n" + " EId: int const &\n" + "\n" + "DelEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True)\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "PNEANet_DelEdge(PNEANet self, int const & SrcNId, int const & DstNId)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_IsEdge", _wrap_PNEANet_IsEdge, METH_VARARGS, (char *)"\n" + "IsEdge(int const & EId) -> bool\n" + "\n" + "Parameters:\n" + " EId: int const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId, bool const & IsDir=True) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "IsEdge(int const & SrcNId, int const & DstNId, int & EId, bool const & IsDir=True) -> bool\n" + "\n" + "Parameters:\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int &\n" + " IsDir: bool const &\n" + "\n" + "PNEANet_IsEdge(PNEANet self, int const & SrcNId, int const & DstNId, int & EId) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " EId: int &\n" + "\n" + ""}, + { (char *)"PNEANet_GetEId", _wrap_PNEANet_GetEId, METH_VARARGS, (char *)"\n" + "PNEANet_GetEId(PNEANet self, int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_BegEI", _wrap_PNEANet_BegEI, METH_VARARGS, (char *)"\n" + "BegEI() -> TNEANet::TEdgeI\n" + "PNEANet_BegEI(PNEANet self) -> TNEANetEdgeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_EndEI", _wrap_PNEANet_EndEI, METH_VARARGS, (char *)"\n" + "EndEI() -> TNEANet::TEdgeI\n" + "PNEANet_EndEI(PNEANet self) -> TNEANetEdgeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_GetEI", _wrap_PNEANet_GetEI, METH_VARARGS, (char *)"\n" + "PNEANet_GetEI(PNEANet self, int const & SrcNId, int const & DstNId) -> TNEANet::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetRndNId", _wrap_PNEANet_GetRndNId, METH_VARARGS, (char *)"\n" + "GetRndNId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "PNEANet_GetRndNId(PNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_GetRndNI", _wrap_PNEANet_GetRndNI, METH_VARARGS, (char *)"\n" + "GetRndNI(TRnd Rnd=Rnd) -> TNEANet::TNodeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "PNEANet_GetRndNI(PNEANet self) -> TNEANet::TNodeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_GetRndEId", _wrap_PNEANet_GetRndEId, METH_VARARGS, (char *)"\n" + "GetRndEId(TRnd Rnd=Rnd) -> int\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "PNEANet_GetRndEId(PNEANet self) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_GetRndEI", _wrap_PNEANet_GetRndEI, METH_VARARGS, (char *)"\n" + "GetRndEI(TRnd Rnd=Rnd) -> TNEANet::TEdgeI\n" + "\n" + "Parameters:\n" + " Rnd: TRnd &\n" + "\n" + "PNEANet_GetRndEI(PNEANet self) -> TNEANet::TEdgeI\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_GetNIdV", _wrap_PNEANet_GetNIdV, METH_VARARGS, (char *)"\n" + "PNEANet_GetNIdV(PNEANet self, TIntV NIdV)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"PNEANet_GetEIdV", _wrap_PNEANet_GetEIdV, METH_VARARGS, (char *)"\n" + "PNEANet_GetEIdV(PNEANet self, TIntV EIdV)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EIdV: TIntV &\n" + "\n" + ""}, + { (char *)"PNEANet_Reserve", _wrap_PNEANet_Reserve, METH_VARARGS, (char *)"\n" + "PNEANet_Reserve(PNEANet self, int const & Nodes, int const & Edges)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " Nodes: int const &\n" + " Edges: int const &\n" + "\n" + ""}, + { (char *)"PNEANet_Defrag", _wrap_PNEANet_Defrag, METH_VARARGS, (char *)"\n" + "Defrag(bool const & OnlyNodeLinks=False)\n" + "\n" + "Parameters:\n" + " OnlyNodeLinks: bool const &\n" + "\n" + "PNEANet_Defrag(PNEANet self)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + "\n" + ""}, + { (char *)"PNEANet_IsOk", _wrap_PNEANet_IsOk, METH_VARARGS, (char *)"\n" + "IsOk(bool const & ThrowExcept=True) -> bool\n" + "\n" + "Parameters:\n" + " ThrowExcept: bool const &\n" + "\n" + "PNEANet_IsOk(PNEANet self) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_Dump", _wrap_PNEANet_Dump, METH_VARARGS, (char *)"\n" + "Dump(FILE * OutF=stdout)\n" + "\n" + "Parameters:\n" + " OutF: FILE *\n" + "\n" + "PNEANet_Dump(PNEANet self)\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + "\n" + ""}, + { (char *)"PNEANet_AddIntAttrDatN", _wrap_PNEANet_AddIntAttrDatN, METH_VARARGS, (char *)"\n" + "AddIntAttrDatN(TNEANet::TNodeI const & NodeId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_AddIntAttrDatN(PNEANet self, int const & NId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NId: int const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddStrAttrDatN", _wrap_PNEANet_AddStrAttrDatN, METH_VARARGS, (char *)"\n" + "AddStrAttrDatN(TNEANet::TNodeI const & NodeId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_AddStrAttrDatN(PNEANet self, int const & NId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NId: int const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddFltAttrDatN", _wrap_PNEANet_AddFltAttrDatN, METH_VARARGS, (char *)"\n" + "AddFltAttrDatN(TNEANet::TNodeI const & NodeId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_AddFltAttrDatN(PNEANet self, int const & NId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NId: int const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddIntAttrDatE", _wrap_PNEANet_AddIntAttrDatE, METH_VARARGS, (char *)"\n" + "AddIntAttrDatE(TNEANet::TEdgeI const & EdgeId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_AddIntAttrDatE(PNEANet self, int const & EId, TInt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EId: int const &\n" + " value: TInt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddStrAttrDatE", _wrap_PNEANet_AddStrAttrDatE, METH_VARARGS, (char *)"\n" + "AddStrAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_AddStrAttrDatE(PNEANet self, int const & EId, TStr value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EId: int const &\n" + " value: TStr const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddFltAttrDatE", _wrap_PNEANet_AddFltAttrDatE, METH_VARARGS, (char *)"\n" + "AddFltAttrDatE(TNEANet::TEdgeI const & EdgeId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_AddFltAttrDatE(PNEANet self, int const & EId, TFlt value, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EId: int const &\n" + " value: TFlt const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetIntAttrDatN", _wrap_PNEANet_GetIntAttrDatN, METH_VARARGS, (char *)"\n" + "GetIntAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_GetIntAttrDatN(PNEANet self, int const & NId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetStrAttrDatN", _wrap_PNEANet_GetStrAttrDatN, METH_VARARGS, (char *)"\n" + "GetStrAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_GetStrAttrDatN(PNEANet self, int const & NId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetFltAttrDatN", _wrap_PNEANet_GetFltAttrDatN, METH_VARARGS, (char *)"\n" + "GetFltAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_GetFltAttrDatN(PNEANet self, int const & NId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetIntAttrDatE", _wrap_PNEANet_GetIntAttrDatE, METH_VARARGS, (char *)"\n" + "GetIntAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_GetIntAttrDatE(PNEANet self, int const & EId, TStr attr) -> TInt\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetStrAttrDatE", _wrap_PNEANet_GetStrAttrDatE, METH_VARARGS, (char *)"\n" + "GetStrAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_GetStrAttrDatE(PNEANet self, int const & EId, TStr attr) -> TStr\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetFltAttrDatE", _wrap_PNEANet_GetFltAttrDatE, METH_VARARGS, (char *)"\n" + "GetFltAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_GetFltAttrDatE(PNEANet self, int const & EId, TStr attr) -> TFlt\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_DelAttrDatN", _wrap_PNEANet_DelAttrDatN, METH_VARARGS, (char *)"\n" + "DelAttrDatN(TNEANet::TNodeI const & NodeId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " NodeId: TNEANet::TNodeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_DelAttrDatN(PNEANet self, int const & NId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " NId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_DelAttrDatE", _wrap_PNEANet_DelAttrDatE, METH_VARARGS, (char *)"\n" + "DelAttrDatE(TNEANet::TEdgeI const & EdgeId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " EdgeId: TNEANet::TEdgeI const &\n" + " attr: TStr const &\n" + "\n" + "PNEANet_DelAttrDatE(PNEANet self, int const & EId, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " EId: int const &\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddIntAttrN", _wrap_PNEANet_AddIntAttrN, METH_VARARGS, (char *)"\n" + "AddIntAttrN(TStr attr, TInt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TInt\n" + "\n" + "PNEANet_AddIntAttrN(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddStrAttrN", _wrap_PNEANet_AddStrAttrN, METH_VARARGS, (char *)"\n" + "AddStrAttrN(TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TStr\n" + "\n" + "PNEANet_AddStrAttrN(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddFltAttrN", _wrap_PNEANet_AddFltAttrN, METH_VARARGS, (char *)"\n" + "AddFltAttrN(TStr attr, TFlt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TFlt\n" + "\n" + "PNEANet_AddFltAttrN(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddIntAttrE", _wrap_PNEANet_AddIntAttrE, METH_VARARGS, (char *)"\n" + "AddIntAttrE(TStr attr, TInt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TInt\n" + "\n" + "PNEANet_AddIntAttrE(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddStrAttrE", _wrap_PNEANet_AddStrAttrE, METH_VARARGS, (char *)"\n" + "AddStrAttrE(TStr attr, TStr defaultValue=TStr::GetNullStr()) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TStr\n" + "\n" + "PNEANet_AddStrAttrE(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_AddFltAttrE", _wrap_PNEANet_AddFltAttrE, METH_VARARGS, (char *)"\n" + "AddFltAttrE(TStr attr, TFlt defaultValue=Mn) -> int\n" + "\n" + "Parameters:\n" + " attr: TStr const &\n" + " defaultValue: TFlt\n" + "\n" + "PNEANet_AddFltAttrE(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_DelAttrN", _wrap_PNEANet_DelAttrN, METH_VARARGS, (char *)"\n" + "PNEANet_DelAttrN(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_DelAttrE", _wrap_PNEANet_DelAttrE, METH_VARARGS, (char *)"\n" + "PNEANet_DelAttrE(PNEANet self, TStr attr) -> int\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > *\n" + " attr: TStr const &\n" + "\n" + ""}, + { (char *)"PNEANet_NodeAttrIsDeleted", _wrap_PNEANet_NodeAttrIsDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_NodeAttrIsDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_NodeAttrIsIntDeleted", _wrap_PNEANet_NodeAttrIsIntDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_NodeAttrIsIntDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_NodeAttrIsStrDeleted", _wrap_PNEANet_NodeAttrIsStrDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_NodeAttrIsStrDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_NodeAttrIsFltDeleted", _wrap_PNEANet_NodeAttrIsFltDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_NodeAttrIsFltDeleted(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_EdgeAttrIsDeleted", _wrap_PNEANet_EdgeAttrIsDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_EdgeAttrIsDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_EdgeAttrIsIntDeleted", _wrap_PNEANet_EdgeAttrIsIntDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_EdgeAttrIsIntDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_EdgeAttrIsStrDeleted", _wrap_PNEANet_EdgeAttrIsStrDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_EdgeAttrIsStrDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_EdgeAttrIsFltDeleted", _wrap_PNEANet_EdgeAttrIsFltDeleted, METH_VARARGS, (char *)"\n" + "PNEANet_EdgeAttrIsFltDeleted(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> bool\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetNodeAttrValue", _wrap_PNEANet_GetNodeAttrValue, METH_VARARGS, (char *)"\n" + "PNEANet_GetNodeAttrValue(PNEANet self, int const & NId, TStrIntPrH::TIter const & NodeHI) -> TStr\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " NId: int const &\n" + " NodeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_GetEdgeAttrValue", _wrap_PNEANet_GetEdgeAttrValue, METH_VARARGS, (char *)"\n" + "PNEANet_GetEdgeAttrValue(PNEANet self, int const & EId, TStrIntPrH::TIter const & EdgeHI) -> TStr\n" + "\n" + "Parameters:\n" + " self: TPt< TNEANet > const *\n" + " EId: int const &\n" + " EdgeHI: TStrIntPrH::TIter const &\n" + "\n" + ""}, + { (char *)"PNEANet_swigregister", PNEANet_swigregister, METH_VARARGS, NULL}, + { (char *)"GetNodeWcc", _wrap_GetNodeWcc, METH_VARARGS, (char *)"\n" + "GetNodeWcc(PNEANet Graph, int const & NId, TIntV CnCom)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NId: int const &\n" + " CnCom: TIntV &\n" + "\n" + ""}, + { (char *)"IsConnected", (PyCFunction)_wrap_IsConnected, METH_O, (char *)"\n" + "IsConnected(PNEANet Graph) -> bool\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"IsWeaklyConn", (PyCFunction)_wrap_IsWeaklyConn, METH_O, (char *)"\n" + "IsWeaklyConn(PNEANet Graph) -> bool\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetWccSzCnt", _wrap_GetWccSzCnt, METH_VARARGS, (char *)"\n" + "GetWccSzCnt(PNEANet Graph, TIntPrV & WccSzCnt)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " WccSzCnt: TIntPrV &\n" + "\n" + ""}, + { (char *)"GetWccs", _wrap_GetWccs, METH_VARARGS, (char *)"\n" + "GetWccs(PNEANet Graph, TCnComV & CnComV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " CnComV: TCnComV &\n" + "\n" + ""}, + { (char *)"GetSccSzCnt", _wrap_GetSccSzCnt, METH_VARARGS, (char *)"\n" + "GetSccSzCnt(PNEANet Graph, TIntPrV & SccSzCnt)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SccSzCnt: TIntPrV &\n" + "\n" + ""}, + { (char *)"GetSccs", _wrap_GetSccs, METH_VARARGS, (char *)"\n" + "GetSccs(PNEANet Graph, TCnComV & CnComV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " CnComV: TCnComV &\n" + "\n" + ""}, + { (char *)"GetMxWccSz", (PyCFunction)_wrap_GetMxWccSz, METH_O, (char *)"\n" + "GetMxWccSz(PNEANet Graph) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetMxWcc", (PyCFunction)_wrap_GetMxWcc, METH_O, (char *)"\n" + "GetMxWcc(PNEANet Graph) -> PNEANet\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetMxScc", (PyCFunction)_wrap_GetMxScc, METH_O, (char *)"\n" + "GetMxScc(PNEANet Graph) -> PNEANet\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetMxBiCon", _wrap_GetMxBiCon, METH_VARARGS, (char *)"\n" + "GetMxBiCon(PUNGraph const & Graph, bool const & RenumberNodes=False) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + " RenumberNodes: bool const &\n" + "\n" + "GetMxBiCon(PUNGraph const & Graph) -> PUNGraph\n" + "\n" + "Parameters:\n" + " Graph: PUNGraph const &\n" + "\n" + "GetMxBiCon(PNEANet Graph) -> PNEANet\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"CntInDegNodes", _wrap_CntInDegNodes, METH_VARARGS, (char *)"\n" + "CntInDegNodes(PNEANet Graph, int const & NodeInDeg) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NodeInDeg: int const &\n" + "\n" + ""}, + { (char *)"CntOutDegNodes", _wrap_CntOutDegNodes, METH_VARARGS, (char *)"\n" + "CntOutDegNodes(PNEANet Graph, int const & NodeOutDeg) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NodeOutDeg: int const &\n" + "\n" + ""}, + { (char *)"CntDegNodes", _wrap_CntDegNodes, METH_VARARGS, (char *)"\n" + "CntDegNodes(PNEANet Graph, int const & NodeDeg) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NodeDeg: int const &\n" + "\n" + ""}, + { (char *)"CntNonZNodes", (PyCFunction)_wrap_CntNonZNodes, METH_O, (char *)"\n" + "CntNonZNodes(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"CntEdgesToSet", _wrap_CntEdgesToSet, METH_VARARGS, (char *)"\n" + "CntEdgesToSet(PNEANet Graph, int const & NId, TIntSet const & NodeSet) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NId: int const &\n" + " NodeSet: TIntSet const &\n" + "\n" + ""}, + { (char *)"GetMxDegNId", (PyCFunction)_wrap_GetMxDegNId, METH_O, (char *)"\n" + "GetMxDegNId(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetMxInDegNId", (PyCFunction)_wrap_GetMxInDegNId, METH_O, (char *)"\n" + "GetMxInDegNId(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetMxOutDegNId", (PyCFunction)_wrap_GetMxOutDegNId, METH_O, (char *)"\n" + "GetMxOutDegNId(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetInDegCnt", _wrap_GetInDegCnt, METH_VARARGS, (char *)"\n" + "GetInDegCnt(PNEANet Graph, TIntPrV & DegToCntV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCntV: TIntPrV &\n" + "\n" + "GetInDegCnt(PNEANet Graph, TFltPrV & DegToCntV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCntV: TFltPrV &\n" + "\n" + ""}, + { (char *)"GetOutDegCnt", _wrap_GetOutDegCnt, METH_VARARGS, (char *)"\n" + "GetOutDegCnt(PNEANet Graph, TIntPrV & DegToCntV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCntV: TIntPrV &\n" + "\n" + "GetOutDegCnt(PNEANet Graph, TFltPrV & DegToCntV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCntV: TFltPrV &\n" + "\n" + ""}, + { (char *)"GetDegCnt", _wrap_GetDegCnt, METH_VARARGS, (char *)"\n" + "GetDegCnt(PNEANet Graph, TIntPrV & DegToCntV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCntV: TIntPrV &\n" + "\n" + "GetDegCnt(PNEANet Graph, TFltPrV & DegToCntV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCntV: TFltPrV &\n" + "\n" + ""}, + { (char *)"GetDegSeqV", _wrap_GetDegSeqV, METH_VARARGS, (char *)"\n" + "GetDegSeqV(PNEANet Graph, TIntV DegV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegV: TIntV &\n" + "\n" + "GetDegSeqV(PNEANet Graph, TIntV InDegV, TIntV OutDegV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " InDegV: TIntV &\n" + " OutDegV: TIntV &\n" + "\n" + ""}, + { (char *)"GetNodeInDegV", _wrap_GetNodeInDegV, METH_VARARGS, (char *)"\n" + "GetNodeInDegV(PNEANet Graph, TIntPrV & NIdInDegV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NIdInDegV: TIntPrV &\n" + "\n" + ""}, + { (char *)"GetNodeOutDegV", _wrap_GetNodeOutDegV, METH_VARARGS, (char *)"\n" + "GetNodeOutDegV(PNEANet Graph, TIntPrV & NIdOutDegV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NIdOutDegV: TIntPrV &\n" + "\n" + ""}, + { (char *)"CntUniqUndirEdges", (PyCFunction)_wrap_CntUniqUndirEdges, METH_O, (char *)"\n" + "CntUniqUndirEdges(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"CntUniqDirEdges", (PyCFunction)_wrap_CntUniqDirEdges, METH_O, (char *)"\n" + "CntUniqDirEdges(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"CntUniqBiDirEdges", (PyCFunction)_wrap_CntUniqBiDirEdges, METH_O, (char *)"\n" + "CntUniqBiDirEdges(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"CntSelfEdges", (PyCFunction)_wrap_CntSelfEdges, METH_O, (char *)"\n" + "CntSelfEdges(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetBfsTree", _wrap_GetBfsTree, METH_VARARGS, (char *)"\n" + "GetBfsTree(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn) -> PNGraph\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " StartNId: int const &\n" + " FollowOut: bool const &\n" + " FollowIn: bool const &\n" + "\n" + ""}, + { (char *)"GetSubTreeSz", _wrap_GetSubTreeSz, METH_VARARGS, (char *)"\n" + "GetSubTreeSz(PNEANet Graph, int const & StartNId, bool const & FollowOut, bool const & FollowIn, \n" + " int & TreeSz, int & TreeDepth) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " StartNId: int const &\n" + " FollowOut: bool const &\n" + " FollowIn: bool const &\n" + " TreeSz: int &\n" + " TreeDepth: int &\n" + "\n" + ""}, + { (char *)"GetNodesAtHop", _wrap_GetNodesAtHop, METH_VARARGS, (char *)"\n" + "GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV, bool const & IsDir=False) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " StartNId: int const &\n" + " Hop: int const &\n" + " NIdV: TIntV &\n" + " IsDir: bool const &\n" + "\n" + "GetNodesAtHop(PNEANet Graph, int const & StartNId, int const & Hop, TIntV NIdV) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " StartNId: int const &\n" + " Hop: int const &\n" + " NIdV: TIntV &\n" + "\n" + ""}, + { (char *)"GetNodesAtHops", _wrap_GetNodesAtHops, METH_VARARGS, (char *)"\n" + "GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV, bool const & IsDir=False) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " StartNId: int const &\n" + " HopCntV: TIntPrV &\n" + " IsDir: bool const &\n" + "\n" + "GetNodesAtHops(PNEANet Graph, int const & StartNId, TIntPrV & HopCntV) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " StartNId: int const &\n" + " HopCntV: TIntPrV &\n" + "\n" + ""}, + { (char *)"GetShortPath", _wrap_GetShortPath, METH_VARARGS, (char *)"\n" + "GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId, bool const & IsDir=False) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + " IsDir: bool const &\n" + "\n" + "GetShortPath(PNEANet Graph, int const & SrcNId, int const & DstNId) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SrcNId: int const &\n" + " DstNId: int const &\n" + "\n" + "GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False, int const & MaxDist=Mx) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SrcNId: int const &\n" + " NIdToDistH: TIntH &\n" + " IsDir: bool const &\n" + " MaxDist: int const &\n" + "\n" + "GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH, bool const & IsDir=False) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SrcNId: int const &\n" + " NIdToDistH: TIntH &\n" + " IsDir: bool const &\n" + "\n" + "GetShortPath(PNEANet Graph, int const & SrcNId, TIntH NIdToDistH) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SrcNId: int const &\n" + " NIdToDistH: TIntH &\n" + "\n" + ""}, + { (char *)"GetBfsFullDiam", _wrap_GetBfsFullDiam, METH_VARARGS, (char *)"\n" + "GetBfsFullDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NTestNodes: int const &\n" + " IsDir: bool const &\n" + "\n" + "GetBfsFullDiam(PNEANet Graph, int const & NTestNodes) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NTestNodes: int const &\n" + "\n" + ""}, + { (char *)"GetBfsEffDiam", _wrap_GetBfsEffDiam, METH_VARARGS, (char *)"\n" + "GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir=False) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NTestNodes: int const &\n" + " IsDir: bool const &\n" + "\n" + "GetBfsEffDiam(PNEANet Graph, int const & NTestNodes) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NTestNodes: int const &\n" + "\n" + "GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NTestNodes: int const &\n" + " IsDir: bool const &\n" + " EffDiam: double &\n" + " FullDiam: int &\n" + "\n" + "GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, bool const & IsDir, double & EffDiam, int & FullDiam, \n" + " double & AvgSPL) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NTestNodes: int const &\n" + " IsDir: bool const &\n" + " EffDiam: double &\n" + " FullDiam: int &\n" + " AvgSPL: double &\n" + "\n" + "GetBfsEffDiam(PNEANet Graph, int const & NTestNodes, TIntV SubGraphNIdV, bool const & IsDir, double & EffDiam, \n" + " int & FullDiam) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NTestNodes: int const &\n" + " SubGraphNIdV: TIntV const &\n" + " IsDir: bool const &\n" + " EffDiam: double &\n" + " FullDiam: int &\n" + "\n" + ""}, + { (char *)"DrawGViz", _wrap_DrawGViz, METH_VARARGS, (char *)"\n" + "DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False, \n" + " TIntStrH const & NIdColorH=TIntStrH())\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " Layout: TGVizLayout const &\n" + " PltFNm: TStr const &\n" + " Desc: TStr const &\n" + " NodeLabels: bool const &\n" + " NIdColorH: TIntStrH const &\n" + "\n" + "DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr(), bool const & NodeLabels=False)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " Layout: TGVizLayout const &\n" + " PltFNm: TStr const &\n" + " Desc: TStr const &\n" + " NodeLabels: bool const &\n" + "\n" + "DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc=TStr())\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " Layout: TGVizLayout const &\n" + " PltFNm: TStr const &\n" + " Desc: TStr const &\n" + "\n" + "DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " Layout: TGVizLayout const &\n" + " PltFNm: TStr const &\n" + "\n" + "DrawGViz(PNEANet Graph, TGVizLayout const & Layout, TStr PltFNm, TStr Desc, TIntStrH const & NodeLabelH)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " Layout: TGVizLayout const &\n" + " PltFNm: TStr const &\n" + " Desc: TStr const &\n" + " NodeLabelH: TIntStrH const &\n" + "\n" + ""}, + { (char *)"GetClustCf", _wrap_GetClustCf, METH_VARARGS, (char *)"\n" + "GetClustCf(PNEANet Graph, int SampleNodes=-1) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SampleNodes: int\n" + "\n" + "GetClustCf(PNEANet Graph) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + "GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int SampleNodes=-1) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCCfV: TFltPrV &\n" + " SampleNodes: int\n" + "\n" + "GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCCfV: TFltPrV &\n" + "\n" + "GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes=-1) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCCfV: TFltPrV &\n" + " ClosedTriads: int64 &\n" + " OpenTriads: int64 &\n" + " SampleNodes: int\n" + "\n" + "GetClustCf(PNEANet Graph, TFltPrV & DegToCCfV, int64 & ClosedTriads, int64 & OpenTriads) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DegToCCfV: TFltPrV &\n" + " ClosedTriads: int64 &\n" + " OpenTriads: int64 &\n" + "\n" + ""}, + { (char *)"GetNodeClustCf", _wrap_GetNodeClustCf, METH_VARARGS, (char *)"\n" + "GetNodeClustCf(PNEANet Graph, int const & NId) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NId: int const &\n" + "\n" + "GetNodeClustCf(PNEANet Graph, TIntFltH & NIdCCfH)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NIdCCfH: TIntFltH &\n" + "\n" + ""}, + { (char *)"GetTriads", _wrap_GetTriads, METH_VARARGS, (char *)"\n" + "GetTriads(PNEANet Graph, int SampleNodes=-1) -> int64\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SampleNodes: int\n" + "\n" + "GetTriads(PNEANet Graph) -> int64\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + "GetTriads(PNEANet Graph, int64 & ClosedTriads, int64 & OpenTriads, int SampleNodes) -> int64\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " ClosedTriads: int64 &\n" + " OpenTriads: int64 &\n" + " SampleNodes: int\n" + "\n" + "GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV, int SampleNodes=-1)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NIdCOTriadV: TIntTrV &\n" + " SampleNodes: int\n" + "\n" + "GetTriads(PNEANet Graph, TIntTrV & NIdCOTriadV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NIdCOTriadV: TIntTrV &\n" + "\n" + ""}, + { (char *)"GetTriadEdges", _wrap_GetTriadEdges, METH_VARARGS, (char *)"\n" + "GetTriadEdges(PNEANet Graph, int SampleEdges=-1) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SampleEdges: int\n" + "\n" + "GetTriadEdges(PNEANet Graph) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { (char *)"GetTriadParticip", _wrap_GetTriadParticip, METH_VARARGS, (char *)"\n" + "GetTriadParticip(PNEANet Graph, TIntPrV & TriadCntV)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " TriadCntV: TIntPrV &\n" + "\n" + ""}, + { (char *)"GetCmnNbrs", _wrap_GetCmnNbrs, METH_VARARGS, (char *)"\n" + "GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NId1: int const &\n" + " NId2: int const &\n" + "\n" + "GetCmnNbrs(PNEANet Graph, int const & NId1, int const & NId2, TIntV NbrV) -> int\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NId1: int const &\n" + " NId2: int const &\n" + " NbrV: TIntV &\n" + "\n" + ""}, + { (char *)"GetModularity", _wrap_GetModularity, METH_VARARGS, (char *)"\n" + "GetModularity(PNEANet G, TIntV NIdV, int GEdges=-1) -> double\n" + "\n" + "Parameters:\n" + " G: TPt< TNEANet > const &\n" + " NIdV: TIntV const &\n" + " GEdges: int\n" + "\n" + "GetModularity(PNEANet G, TIntV NIdV) -> double\n" + "\n" + "Parameters:\n" + " G: TPt< TNEANet > const &\n" + " NIdV: TIntV const &\n" + "\n" + "GetModularity(PNEANet G, TCnComV const & CmtyV, int GEdges=-1) -> double\n" + "\n" + "Parameters:\n" + " G: TPt< TNEANet > const &\n" + " CmtyV: TCnComV const &\n" + " GEdges: int\n" + "\n" + "GetModularity(PNEANet G, TCnComV const & CmtyV) -> double\n" + "\n" + "Parameters:\n" + " G: TPt< TNEANet > const &\n" + " CmtyV: TCnComV const &\n" + "\n" + ""}, + { (char *)"GetEdgesInOut", _wrap_GetEdgesInOut, METH_VARARGS, (char *)"\n" + "GetEdgesInOut(PNEANet Graph, TIntV NIdV, int & EdgesIn, int & EdgesOut)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NIdV: TIntV const &\n" + " EdgesIn: int &\n" + " EdgesOut: int &\n" + "\n" + ""}, + { (char *)"GetAnf", _wrap_GetAnf, METH_VARARGS, (char *)"\n" + "GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, \n" + " int const & NApprox=32)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SrcNId: int const &\n" + " DistNbrsV: TIntFltKdV &\n" + " MxDist: int const &\n" + " IsDir: bool const &\n" + " NApprox: int const &\n" + "\n" + "GetAnf(PNEANet Graph, int const & SrcNId, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " SrcNId: int const &\n" + " DistNbrsV: TIntFltKdV &\n" + " MxDist: int const &\n" + " IsDir: bool const &\n" + "\n" + "GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir, int const & NApprox=32)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DistNbrsV: TIntFltKdV &\n" + " MxDist: int const &\n" + " IsDir: bool const &\n" + " NApprox: int const &\n" + "\n" + "GetAnf(PNEANet Graph, TIntFltKdV & DistNbrsV, int const & MxDist, bool const & IsDir)\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " DistNbrsV: TIntFltKdV &\n" + " MxDist: int const &\n" + " IsDir: bool const &\n" + "\n" + ""}, + { (char *)"GetAnfEffDiam", _wrap_GetAnfEffDiam, METH_VARARGS, (char *)"\n" + "GetAnfEffDiam(PNEANet Graph, bool const & IsDir, double const & Percentile, int const & NApprox) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " IsDir: bool const &\n" + " Percentile: double const &\n" + " NApprox: int const &\n" + "\n" + "GetAnfEffDiam(PNEANet Graph, int const NRuns=1, int NApprox=-1) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NRuns: int const\n" + " NApprox: int\n" + "\n" + "GetAnfEffDiam(PNEANet Graph, int const NRuns=1) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + " NRuns: int const\n" + "\n" + "GetAnfEffDiam(PNEANet Graph) -> double\n" + "\n" + "Parameters:\n" + " Graph: TPt< TNEANet > const &\n" + "\n" + ""}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_TAscFltTo_p_TFlt(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TFlt *) ((TAscFlt *) x)); +} +static void *_p_TStdOutTo_p_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut *) ((TStdOut *) x)); +} +static void *_p_TFOutTo_p_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut *) ((TFOut *) x)); +} +static void *_p_TMOutTo_p_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut *) ((TMOut *) x)); +} +static void *_p_TMemOutTo_p_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut *) ((TMemOut *) x)); +} +static void *_p_TFInOutTo_p_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut *) (TSInOut *) ((TFInOut *) x)); +} +static void *_p_TSInOutTo_p_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut *) ((TSInOut *) x)); +} +static void *_p_f_r_TSOut__r_TStdOutTo_p_f_r_TSOut__r_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut &(*)(TSOut &)) ((TStdOut &(*)(TSOut &)) x)); +} +static void *_p_f_r_TSOut__r_TFOutTo_p_f_r_TSOut__r_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut &(*)(TSOut &)) ((TFOut &(*)(TSOut &)) x)); +} +static void *_p_f_r_TSOut__r_TMOutTo_p_f_r_TSOut__r_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut &(*)(TSOut &)) ((TMOut &(*)(TSOut &)) x)); +} +static void *_p_f_r_TSOut__r_TMemOutTo_p_f_r_TSOut__r_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut &(*)(TSOut &)) ((TMemOut &(*)(TSOut &)) x)); +} +static void *_p_f_r_TSOut__r_TFInOutTo_p_f_r_TSOut__r_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut &(*)(TSOut &)) (TSInOut *) ((TFInOut &(*)(TSOut &)) x)); +} +static void *_p_f_r_TSOut__r_TSInOutTo_p_f_r_TSOut__r_TSOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSOut &(*)(TSOut &)) ((TSInOut &(*)(TSOut &)) x)); +} +static void *_p_TStdOutTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSOut *) ((TStdOut *) x)); +} +static void *_p_TStdInTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *) ((TStdIn *) x)); +} +static void *_p_TFInOutTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *)(TSInOut *) ((TFInOut *) x)); +} +static void *_p_TMInTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *) ((TMIn *) x)); +} +static void *_p_TMOutTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSOut *) ((TMOut *) x)); +} +static void *_p_TStrInTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *) ((TStrIn *) x)); +} +static void *_p_TChAInTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *) ((TChAIn *) x)); +} +static void *_p_TSOutTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) ((TSOut *) x)); +} +static void *_p_TFOutTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSOut *) ((TFOut *) x)); +} +static void *_p_TSInOutTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *) ((TSInOut *) x)); +} +static void *_p_TMemInTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *) ((TMemIn *) x)); +} +static void *_p_TFInTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSIn *) ((TFIn *) x)); +} +static void *_p_TSInTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) ((TSIn *) x)); +} +static void *_p_TMemOutTo_p_TSBase(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSBase *) (TSOut *) ((TMemOut *) x)); +} +static void *_p_TFInOutTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) (TSInOut *) ((TFInOut *) x)); +} +static void *_p_TFInTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) ((TFIn *) x)); +} +static void *_p_TMInTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) ((TMIn *) x)); +} +static void *_p_TStdInTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) ((TStdIn *) x)); +} +static void *_p_TMemInTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) ((TMemIn *) x)); +} +static void *_p_TStrInTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) ((TStrIn *) x)); +} +static void *_p_TSInOutTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) ((TSInOut *) x)); +} +static void *_p_TChAInTo_p_TSIn(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSIn *) ((TChAIn *) x)); +} +static void *_p_TFInOutTo_p_TSInOut(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((TSInOut *) ((TFInOut *) x)); +} +static swig_type_info _swigt__p_FILE = {"_p_FILE", "TFileId|FILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PGStatVec = {"_p_PGStatVec", "PGStatVec *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PGraph = {"_p_PGraph", "PGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PNet = {"_p_PNet", "PNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PVecT_TAscFlt_t = {"_p_PVecT_TAscFlt_t", "TAscFltVP *|PVec< TAscFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PVecT_TFlt_t = {"_p_PVecT_TFlt_t", "TFltVP *|PVec< TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PVecT_TStr_t = {"_p_PVecT_TStr_t", "TStrVP *|PVec< TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TArtPointVisitor = {"_p_TArtPointVisitor", "TArtPointVisitor *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TAscFlt = {"_p_TAscFlt", "TAscFlt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TBPGraph = {"_p_TBPGraph", "TBPGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TBPGraph__TEdgeI = {"_p_TBPGraph__TEdgeI", "TBPGraph::TEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TBPGraph__TNode = {"_p_TBPGraph__TNode", "TBPGraph::TNode *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TBPGraph__TNodeI = {"_p_TBPGraph__TNodeI", "TBPGraph::TNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TBiConVisitor = {"_p_TBiConVisitor", "TBiConVisitor *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TBigStrPool = {"_p_TBigStrPool", "TBigStrPool *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TBool = {"_p_TBool", "TBool *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TCRef = {"_p_TCRef", "TCRef *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TCh = {"_p_TCh", "TCh *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TChA = {"_p_TChA", "TChA *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TChAIn = {"_p_TChAIn", "TChAIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TChRet = {"_p_TChRet", "TChRet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TCnCom = {"_p_TCnCom", "TCnCom *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TConv_Pt64Ints32 = {"_p_TConv_Pt64Ints32", "TConv_Pt64Ints32 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TCs = {"_p_TCs", "TCs *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TDbStr = {"_p_TDbStr", "TDbStr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFAccess = {"_p_TFAccess", "enum TFAccess *|TFAccess *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFIn = {"_p_TFIn", "TFIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFOut = {"_p_TFOut", "TFOut *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFfGGen = {"_p_TFfGGen", "TFfGGen *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFile = {"_p_TFile", "TFile *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFlt = {"_p_TFlt", "TFlt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFltRect = {"_p_TFltRect", "TFltRect *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFltV__TIter = {"_p_TFltV__TIter", "TFltV::TIter *|TFltVecIter *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TForestFire = {"_p_TForestFire", "TForestFire *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TGUtil = {"_p_TGUtil", "TGUtil *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TGVizLayout_ = {"_p_TGVizLayout_", "enum TGVizLayout_ *|TGVizLayout *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TGraphFlag = {"_p_TGraphFlag", "TGraphFlag *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THKeyDat = {"_p_THKeyDat", "THKeyDat *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashKeyDatIT_TInt_TInt_t = {"_p_THashKeyDatIT_TInt_TInt_t", "THash< TInt,TInt >::TIter *|THashKeyDatI< TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t = {"_p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t", "THashKeyDatI< TInt,TVec< TInt,int > > *|THash< TInt,TVec< TInt,int > >::TIter *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashKeyDatT_TInt_TInt_t = {"_p_THashKeyDatT_TInt_TInt_t", "THashKeyDatI< TInt,TInt >::THKeyDat *|THashKeyDat< TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TCh_TCh_TDefaultHashFuncT_TCh_t_t = {"_p_THashT_TCh_TCh_TDefaultHashFuncT_TCh_t_t", "THash< TCh,TCh,TDefaultHashFunc< TCh > > *|TChChH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TDbStr_TInt_TDefaultHashFuncT_TDbStr_t_t = {"_p_THashT_TDbStr_TInt_TDefaultHashFuncT_TDbStr_t_t", "THash< TDbStr,TInt,TDefaultHashFunc< TDbStr > > *|TDbStrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TDbStr_TStr_TDefaultHashFuncT_TDbStr_t_t = {"_p_THashT_TDbStr_TStr_TDefaultHashFuncT_TDbStr_t_t", "THash< TDbStr,TStr,TDefaultHashFunc< TDbStr > > *|TDbStrStrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TFlt_TFlt_TDefaultHashFuncT_TFlt_t_t = {"_p_THashT_TFlt_TFlt_TDefaultHashFuncT_TFlt_t_t", "THash< TFlt,TFlt,TDefaultHashFunc< TFlt > > *|TFltFltH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TBool_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TBool_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TBool,TDefaultHashFunc< TInt > > *|TIntBoolH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TFlt,TDefaultHashFunc< TInt > > *|TIntFltH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t_TDefaultHashFuncT_TInt_t_t", "THash< TInt,THash< TInt,TInt,TDefaultHashFunc< TInt > >,TDefaultHashFunc< TInt > > *|TIntIntHH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TInt,TDefaultHashFunc< TInt > > *|THash< TInt,TInt > *|TIntH *|TIntIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TPairT_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TPairT_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TPair< TFlt,TFlt >,TDefaultHashFunc< TInt > > *|TIntFltPrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TPair< TInt,TFlt >,TDefaultHashFunc< TInt > > *|TIntIntFltPrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TPair< TInt,TInt > > *|THash< TInt,TIntPr > *|THash< TInt,TPair< TInt,TInt >,TDefaultHashFunc< TInt > > *|TIntIntPrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TStr,TDefaultHashFunc< TInt > > *|TIntStrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TTripleT_TFlt_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TTripleT_TFlt_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t", "TIntFltTrH *|THash< TInt,TTriple< TFlt,TFlt,TFlt >,TDefaultHashFunc< TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TUInt64_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TUInt64_TDefaultHashFuncT_TInt_t_t", "TIntUInt64H *|THash< TInt,TUInt64,TDefaultHashFunc< TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TVecT_TFlt_int_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TVecT_TFlt_int_t_TDefaultHashFuncT_TInt_t_t", "TIntFltVH *|THash< TInt,TVec< TFlt,int >,TDefaultHashFunc< TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TVec< TInt,int > > *|THash< TInt,TVec< TInt,int >,TDefaultHashFunc< TInt > > *|TIntIntVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TInt_t_t", "THash< TInt,TVec< TPair< TInt,TInt >,int >,TDefaultHashFunc< TInt > > *|TIntIntPrVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TInt_TVecT_TStr_int_t_TDefaultHashFuncT_TInt_t_t = {"_p_THashT_TInt_TVecT_TStr_int_t_TDefaultHashFuncT_TInt_t_t", "TIntStrVH *|THash< TInt,TVec< TStr,int >,TDefaultHashFunc< TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t = {"_p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t", "THash< TPair< TInt,TInt >,TFlt,TDefaultHashFunc< TPair< TInt,TInt > > > *|TIntPrFltH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TInt_TInt_t_TInt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t = {"_p_THashT_TPairT_TInt_TInt_t_TInt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t", "THash< TPair< TInt,TInt >,TInt,TDefaultHashFunc< TPair< TInt,TInt > > > *|TIntPrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TInt_TInt_t_TStr_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t = {"_p_THashT_TPairT_TInt_TInt_t_TStr_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t", "THash< TPair< TInt,TInt >,TStr,TDefaultHashFunc< TPair< TInt,TInt > > > *|TIntPrStrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TInt_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t = {"_p_THashT_TPairT_TInt_TInt_t_TVecT_TInt_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t", "THash< TPair< TInt,TInt >,TVec< TInt,int >,TDefaultHashFunc< TPair< TInt,TInt > > > *|TIntPrIntVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t = {"_p_THashT_TPairT_TInt_TInt_t_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t", "THash< TPair< TInt,TInt >,TVec< TPair< TInt,TInt >,int >,TDefaultHashFunc< TPair< TInt,TInt > > > *|TIntPrIntPrVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t = {"_p_THashT_TPairT_TInt_TInt_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t", "TIntPrStrVH *|THash< TPair< TInt,TInt >,TVec< TStr,int >,TDefaultHashFunc< TPair< TInt,TInt > > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TInt_TStr_t_TInt_TDefaultHashFuncT_TPairT_TInt_TStr_t_t_t = {"_p_THashT_TPairT_TInt_TStr_t_TInt_TDefaultHashFuncT_TPairT_TInt_TStr_t_t_t", "THash< TPair< TInt,TStr >,TInt,TDefaultHashFunc< TPair< TInt,TStr > > > *|TIntStrPrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TStr_TInt_t_TInt_TDefaultHashFuncT_TPairT_TStr_TInt_t_t_t = {"_p_THashT_TPairT_TStr_TInt_t_TInt_TDefaultHashFuncT_TPairT_TStr_TInt_t_t_t", "THash< TPair< TStr,TInt >,TInt,TDefaultHashFunc< TPair< TStr,TInt > > > *|TStrIntPrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TStr_TStr_t_TBool_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t = {"_p_THashT_TPairT_TStr_TStr_t_TBool_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t", "TStrPrBoolH *|THash< TPair< TStr,TStr >,TBool,TDefaultHashFunc< TPair< TStr,TStr > > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TStr_TStr_t_TFlt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t = {"_p_THashT_TPairT_TStr_TStr_t_TFlt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t", "THash< TPair< TStr,TStr >,TFlt,TDefaultHashFunc< TPair< TStr,TStr > > > *|TStrPrFltH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TStr_TStr_t_TInt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t = {"_p_THashT_TPairT_TStr_TStr_t_TInt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t", "THash< TPair< TStr,TStr >,TInt,TDefaultHashFunc< TPair< TStr,TStr > > > *|TStrPrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TStr_TStr_t_TStr_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t = {"_p_THashT_TPairT_TStr_TStr_t_TStr_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t", "THash< TPair< TStr,TStr >,TStr,TDefaultHashFunc< TPair< TStr,TStr > > > *|TStrPrStrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TPairT_TStr_TStr_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t = {"_p_THashT_TPairT_TStr_TStr_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t", "TStrPrStrVH *|THash< TPair< TStr,TStr >,TVec< TStr,int >,TDefaultHashFunc< TPair< TStr,TStr > > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TBool_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TBool_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TBool,TDefaultHashFunc< TStr > > *|TStrBoolH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TFlt_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TFlt_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TFlt,TDefaultHashFunc< TStr > > *|TStrFltH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TInt_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TInt_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TInt,TDefaultHashFunc< TStr > > *|TStrIntH *|TStrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TPair< TInt,TFlt >,TDefaultHashFunc< TStr > > *|TStrIntFltPrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TPairT_TInt_TInt_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TPairT_TInt_TInt_t_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TPair< TInt,TInt >,TDefaultHashFunc< TStr > > *|TStrIntPrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TPairT_TStr_TStr_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TPairT_TStr_TStr_t_TDefaultHashFuncT_TStr_t_t", "TStrStrPrH *|THash< TStr,TPair< TStr,TStr >,TDefaultHashFunc< TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TStr_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TStr_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TStr,TDefaultHashFunc< TStr > > *|TStrStrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TUInt64_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TUInt64_TDefaultHashFuncT_TStr_t_t", "TStrUInt64H *|THash< TStr,TUInt64,TDefaultHashFunc< TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TFlt_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TFlt_int_t_TDefaultHashFuncT_TStr_t_t", "TStrFltVH *|THash< TStr,TVec< TFlt,int >,TDefaultHashFunc< TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TInt_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TInt_int_t_TDefaultHashFuncT_TStr_t_t", "TStrIntVH *|THash< TStr,TVec< TInt,int >,TDefaultHashFunc< TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TKeyDatT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TKeyDatT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TVec< TKeyDat< TStr,TInt >,int >,TDefaultHashFunc< TStr > > *|TStrStrIntKdVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TKeyDatT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TKeyDatT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TVec< TKeyDat< TStr,TStr >,int >,TDefaultHashFunc< TStr > > *|TStrStrKdVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TVec< TPair< TInt,TInt >,int >,TDefaultHashFunc< TStr > > *|TStrIntPrVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TPairT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TPairT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TVec< TPair< TStr,TInt >,int >,TDefaultHashFunc< TStr > > *|TStrStrIntPrVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TPairT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TPairT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t", "THash< TStr,TVec< TPair< TStr,TStr >,int >,TDefaultHashFunc< TStr > > *|TStrStrPrVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TStr_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TStr_int_t_TDefaultHashFuncT_TStr_t_t", "TStrStrVH *|THash< TStr,TVec< TStr,int >,TDefaultHashFunc< TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TStr_TVecT_TUInt64_int_t_TDefaultHashFuncT_TStr_t_t = {"_p_THashT_TStr_TVecT_TUInt64_int_t_TDefaultHashFuncT_TStr_t_t", "TStrUInt64VH *|THash< TStr,TVec< TUInt64,int >,TDefaultHashFunc< TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TTripleT_TCh_TCh_TCh_t_TInt_TDefaultHashFuncT_TTripleT_TCh_TCh_TCh_t_t_t = {"_p_THashT_TTripleT_TCh_TCh_TCh_t_TInt_TDefaultHashFuncT_TTripleT_TCh_TCh_TCh_t_t_t", "THash< TTriple< TCh,TCh,TCh >,TInt,TDefaultHashFunc< TTriple< TCh,TCh,TCh > > > *|TChTrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TTripleT_TInt_TInt_TInt_t_TFlt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t = {"_p_THashT_TTripleT_TInt_TInt_TInt_t_TFlt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t", "THash< TTriple< TInt,TInt,TInt >,TFlt,TDefaultHashFunc< TTriple< TInt,TInt,TInt > > > *|TIntTrFltH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TTripleT_TInt_TInt_TInt_t_TInt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t = {"_p_THashT_TTripleT_TInt_TInt_TInt_t_TInt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t", "THash< TTriple< TInt,TInt,TInt >,TInt,TDefaultHashFunc< TTriple< TInt,TInt,TInt > > > *|TIntTrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TTripleT_TStr_TStr_TStr_t_TInt_TDefaultHashFuncT_TTripleT_TStr_TStr_TStr_t_t_t = {"_p_THashT_TTripleT_TStr_TStr_TStr_t_TInt_TDefaultHashFuncT_TTripleT_TStr_TStr_TStr_t_t_t", "THash< TTriple< TStr,TStr,TStr >,TInt,TDefaultHashFunc< TTriple< TStr,TStr,TStr > > > *|TStrTrIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TUInt64_TInt_TDefaultHashFuncT_TUInt64_t_t = {"_p_THashT_TUInt64_TInt_TDefaultHashFuncT_TUInt64_t_t", "TUInt64H *|THash< TUInt64,TInt,TDefaultHashFunc< TUInt64 > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TUInt64_TVecT_TStr_int_t_TDefaultHashFuncT_TUInt64_t_t = {"_p_THashT_TUInt64_TVecT_TStr_int_t_TDefaultHashFuncT_TUInt64_t_t", "TUInt64StrVH *|THash< TUInt64,TVec< TStr,int >,TDefaultHashFunc< TUInt64 > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TUInt_TUInt_TDefaultHashFuncT_TUInt_t_t = {"_p_THashT_TUInt_TUInt_TDefaultHashFuncT_TUInt_t_t", "TUIntH *|THash< TUInt,TUInt,TDefaultHashFunc< TUInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TVecT_TInt_int_t_TInt_TDefaultHashFuncT_TVecT_TInt_int_t_t_t = {"_p_THashT_TVecT_TInt_int_t_TInt_TDefaultHashFuncT_TVecT_TInt_int_t_t_t", "THash< TVec< TInt,int >,TInt,TDefaultHashFunc< TVec< TInt,int > > > *|TIntVIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TVecT_TStr_int_t_TInt_TDefaultHashFuncT_TVecT_TStr_int_t_t_t = {"_p_THashT_TVecT_TStr_int_t_TInt_TDefaultHashFuncT_TVecT_TStr_int_t_t_t", "TStrVH *|THash< TVec< TStr,int >,TInt,TDefaultHashFunc< TVec< TStr,int > > > *|TStrVIntH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TVecT_TStr_int_t_TStr_TDefaultHashFuncT_TVecT_TStr_int_t_t_t = {"_p_THashT_TVecT_TStr_int_t_TStr_TDefaultHashFuncT_TVecT_TStr_int_t_t_t", "THash< TVec< TStr,int >,TStr,TDefaultHashFunc< TVec< TStr,int > > > *|TStrVStrH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TVecT_TStr_int_t_TVecT_TInt_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t = {"_p_THashT_TVecT_TStr_int_t_TVecT_TInt_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t", "THash< TVec< TStr,int >,TVec< TInt,int >,TDefaultHashFunc< TVec< TStr,int > > > *|TStrVIntVH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_THashT_TVecT_TStr_int_t_TVecT_TStr_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t = {"_p_THashT_TVecT_TStr_int_t_TVecT_TStr_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t", "TStrVStrVH *|THash< TVec< TStr,int >,TVec< TStr,int >,TDefaultHashFunc< TVec< TStr,int > > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TILx = {"_p_TILx", "TILx *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TInt = {"_p_TInt", "TVec< TInt,int >::TIter|TInt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TIntSet = {"_p_TIntSet", "TIntSet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TIntV__TIter = {"_p_TIntV__TIter", "TIntV::TIter *|TIntVecIter *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TIter = {"_p_TIter", "TIter *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TAscFlt_TInt_t = {"_p_TKeyDatT_TAscFlt_TInt_t", "TKeyDat< TAscFlt,TInt > *|TAscFltIntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TBool_t = {"_p_TKeyDatT_TFlt_TBool_t", "TKeyDat< TFlt,TBool > *|TFltBoolKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TFlt_t = {"_p_TKeyDatT_TFlt_TFlt_t", "TKeyDat< TFlt,TFlt > *|TFltKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TInt_t = {"_p_TKeyDatT_TFlt_TInt_t", "TKeyDat< TFlt,TInt > *|TFltIntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TPairT_TInt_TBool_t_t = {"_p_TKeyDatT_TFlt_TPairT_TInt_TBool_t_t", "TKeyDat< TFlt,TPair< TInt,TBool > > *|TFltIntBoolPrKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t = {"_p_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t", "TKeyDat< TFlt,TPair< TInt,TInt > > *|TFltIntPrKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TStr_t = {"_p_TKeyDatT_TFlt_TStr_t", "TKeyDat< TFlt,TStr > *|TFltStrKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TUInt64_t = {"_p_TKeyDatT_TFlt_TUInt64_t", "TKeyDat< TFlt,TUInt64 > *|TFltUInt64Kd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TFlt_TUInt_t = {"_p_TKeyDatT_TFlt_TUInt_t", "TKeyDat< TFlt,TUInt > *|TFltUIntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TInt_TFlt_t = {"_p_TKeyDatT_TInt_TFlt_t", "TKeyDat< TInt,TFlt > *|TIntFltKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TInt_TInt_t = {"_p_TKeyDatT_TInt_TInt_t", "TKeyDat< TInt,TInt > *|TIntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t = {"_p_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t", "TKeyDat< TInt,TPair< TFlt,TFlt > > *|TIntFltPrKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TInt_TSFlt_t = {"_p_TKeyDatT_TInt_TSFlt_t", "TKeyDat< TInt,TSFlt > *|TIntSFltKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TInt_TStr_t = {"_p_TKeyDatT_TInt_TStr_t", "TKeyDat< TInt,TStr > *|TIntStrKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TInt_TUInt64_t = {"_p_TKeyDatT_TInt_TUInt64_t", "TKeyDat< TInt,TUInt64 > *|TIntUInt64Kd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t = {"_p_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t", "TKeyDat< TPair< TInt,TInt >,TFlt > *|TIntPrFltKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TStr_TAscFlt_t = {"_p_TKeyDatT_TStr_TAscFlt_t", "TKeyDat< TStr,TAscFlt > *|TStrAscFltKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TStr_TBool_t = {"_p_TKeyDatT_TStr_TBool_t", "TKeyDat< TStr,TBool > *|TStrBoolKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TStr_TFlt_t = {"_p_TKeyDatT_TStr_TFlt_t", "TKeyDat< TStr,TFlt > *|TStrFltKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TStr_TInt_t = {"_p_TKeyDatT_TStr_TInt_t", "TKeyDat< TStr,TInt > *|TStrIntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TStr_TStr_t = {"_p_TKeyDatT_TStr_TStr_t", "TKeyDat< TStr,TStr > *|TStrKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TUInt64_TFlt_t = {"_p_TKeyDatT_TUInt64_TFlt_t", "TKeyDat< TUInt64,TFlt > *|TUInt64FltKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TUInt64_TInt_t = {"_p_TKeyDatT_TUInt64_TInt_t", "TKeyDat< TUInt64,TInt > *|TUInt64IntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TUInt64_TStr_t = {"_p_TKeyDatT_TUInt64_TStr_t", "TKeyDat< TUInt64,TStr > *|TUInt64StrKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TUInt_TInt_t = {"_p_TKeyDatT_TUInt_TInt_t", "TKeyDat< TUInt,TInt > *|TUIntIntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TKeyDatT_TUInt_TUInt_t = {"_p_TKeyDatT_TUInt_TUInt_t", "TKeyDat< TUInt,TUInt > *|TUIntKd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLFlt = {"_p_TLFlt", "TLFlt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLnRet = {"_p_TLnRet", "TLnRet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLoc = {"_p_TLoc", "enum TLoc *|TLoc *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLogOp = {"_p_TLogOp", "enum TLogOp *|TLogOp *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLstT_TFlt_t = {"_p_TLstT_TFlt_t", "TFltL *|TLst< TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLstT_TInt_t = {"_p_TLstT_TInt_t", "TIntL *|TLst< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLstT_TKeyDatT_TAscFlt_TInt_t_t = {"_p_TLstT_TKeyDatT_TAscFlt_TInt_t_t", "TAscFltIntKdL *|TLst< TKeyDat< TAscFlt,TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLstT_TKeyDatT_TFlt_TInt_t_t = {"_p_TLstT_TKeyDatT_TFlt_TInt_t_t", "TFltIntKdL *|TLst< TKeyDat< TFlt,TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLstT_TKeyDatT_TInt_TInt_t_t = {"_p_TLstT_TKeyDatT_TInt_TInt_t_t", "TIntKdL *|TLst< TKeyDat< TInt,TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TLstT_TStr_t = {"_p_TLstT_TStr_t", "TStrL *|TLst< TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TMIn = {"_p_TMIn", "TMIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TMOut = {"_p_TMOut", "TMOut *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TMem = {"_p_TMem", "TMem *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TMemIn = {"_p_TMemIn", "TMemIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TMemOut = {"_p_TMemOut", "TMemOut *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANet = {"_p_TNEANet", "TNEANet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANetAFltI = {"_p_TNEANetAFltI", "TNEANetAFltI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANetAIntI = {"_p_TNEANetAIntI", "TNEANetAIntI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANetAStrI = {"_p_TNEANetAStrI", "TNEANetAStrI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANetEdgeI = {"_p_TNEANetEdgeI", "TNEANetEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANetNodeI = {"_p_TNEANetNodeI", "TNEANetNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANet__TAFltI = {"_p_TNEANet__TAFltI", "TNEANet::TAFltI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANet__TAIntI = {"_p_TNEANet__TAIntI", "TNEANet::TAIntI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANet__TAStrI = {"_p_TNEANet__TAStrI", "TNEANet::TAStrI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANet__TEdgeI = {"_p_TNEANet__TEdgeI", "TNEANet::TEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANet__TNode = {"_p_TNEANet__TNode", "TNEANet::TNode *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEANet__TNodeI = {"_p_TNEANet__TNodeI", "TNEANet::TNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEGraph = {"_p_TNEGraph", "TNEGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEGraph__TEdgeI = {"_p_TNEGraph__TEdgeI", "TNEGraph::TEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEGraph__TNode = {"_p_TNEGraph__TNode", "TNEGraph::TNode *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNEGraph__TNodeI = {"_p_TNEGraph__TNodeI", "TNEGraph::TNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNGraph = {"_p_TNGraph", "TNGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNGraphEdgeI = {"_p_TNGraphEdgeI", "TNGraphEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNGraphMtx = {"_p_TNGraphMtx", "TNGraphMtx *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNGraphNodeI = {"_p_TNGraphNodeI", "TNGraphNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNGraph__TEdgeI = {"_p_TNGraph__TEdgeI", "TNGraph::TEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNGraph__TNode = {"_p_TNGraph__TNode", "TNGraph::TNode *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNGraph__TNodeI = {"_p_TNGraph__TNodeI", "TNGraph::TNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNet = {"_p_TNet", "TNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeEDatNetT_TInt_TFlt_t = {"_p_TNodeEDatNetT_TInt_TFlt_t", "TNodeEDatNet< TInt,TFlt > *|TIntFltNEDNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeEDatNetT_TInt_TInt_t = {"_p_TNodeEDatNetT_TInt_TInt_t", "TIntNEDNet *|TNodeEDatNet< TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeEDatNetT_TStr_TInt_t = {"_p_TNodeEDatNetT_TStr_TInt_t", "TStrIntNEDNet *|TNodeEDatNet< TStr,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeEdgeNetT_TFlt_TFlt_t = {"_p_TNodeEdgeNetT_TFlt_TFlt_t", "TNodeEdgeNet< TFlt,TFlt > *|TFltNENet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeEdgeNetT_TInt_TInt_t = {"_p_TNodeEdgeNetT_TInt_TInt_t", "TNodeEdgeNet< TInt,TInt > *|TIntNENet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeNetT_TFlt_t = {"_p_TNodeNetT_TFlt_t", "TNodeNet< TFlt > *|TFltNNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeNetT_TInt_t = {"_p_TNodeNetT_TInt_t", "TIntNNet *|TNodeNet< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeNetT_TStr_t = {"_p_TNodeNetT_TStr_t", "TNodeNet< TStr > *|TStrNNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TNodeTy = {"_p_TNodeTy", "TNodeTy *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TOLx = {"_p_TOLx", "TOLx *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TObj = {"_p_TObj", "TObj *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairHashImpl1 = {"_p_TPairHashImpl1", "TPairHashImpl1 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairHashImpl2 = {"_p_TPairHashImpl2", "TPairHashImpl *|TPairHashImpl2 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TAscFlt_TAscFlt_t = {"_p_TPairT_TAscFlt_TAscFlt_t", "TAscFltPr *|TPair< TAscFlt,TAscFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TAscFlt_TInt_t = {"_p_TPairT_TAscFlt_TInt_t", "TAscFltIntPr *|TPair< TAscFlt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TAscFlt_TStr_t = {"_p_TPairT_TAscFlt_TStr_t", "TAscFltStrPr *|TPair< TAscFlt,TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TBool_TCh_t = {"_p_TPairT_TBool_TCh_t", "TBoolChPr *|TPair< TBool,TCh > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TBool_TFlt_t = {"_p_TPairT_TBool_TFlt_t", "TBoolFltPr *|TPair< TBool,TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TFlt_TFlt_t = {"_p_TPairT_TFlt_TFlt_t", "TFltPr *|TPair< TFlt,TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TFlt_TInt_t = {"_p_TPairT_TFlt_TInt_t", "TFltIntPr *|TPair< TFlt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TFlt_TPairT_TStr_TStr_t_t = {"_p_TPairT_TFlt_TPairT_TStr_TStr_t_t", "TFltStrPrPr *|TPair< TFlt,TPair< TStr,TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TFlt_TStr_t = {"_p_TPairT_TFlt_TStr_t", "TFltStrPr *|TPair< TFlt,TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TFlt_TUInt64_t = {"_p_TPairT_TFlt_TUInt64_t", "TFltUInt64Pr *|TPair< TFlt,TUInt64 > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TBool_t = {"_p_TPairT_TInt_TBool_t", "TIntBoolPr *|TPair< TInt,TBool > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TCh_t = {"_p_TPairT_TInt_TCh_t", "TIntChPr *|TPair< TInt,TCh > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TFlt_t = {"_p_TPairT_TInt_TFlt_t", "TIntFltPr *|TPair< TInt,TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TInt_t = {"_p_TPairT_TInt_TInt_t", "TIntPr *|TPair< TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TPairT_TInt_TInt_t_t = {"_p_TPairT_TInt_TPairT_TInt_TInt_t_t", "TIntIntPrPr *|TPair< TInt,TPair< TInt,TInt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TPairT_TStr_TStr_t_t = {"_p_TPairT_TInt_TPairT_TStr_TStr_t_t", "TIntStrPrPr *|TPair< TInt,TPair< TStr,TStr > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TStr_t = {"_p_TPairT_TInt_TStr_t", "TIntStrPr *|TPair< TInt,TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TUInt64_t = {"_p_TPairT_TInt_TUInt64_t", "TIntUInt64Pr *|TPair< TInt,TUInt64 > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TVecT_TInt_int_t_t = {"_p_TPairT_TInt_TVecT_TInt_int_t_t", "TPair< TInt,TVec< TInt,int > > *|TIntIntVPr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TInt_TVecT_TStr_int_t_t = {"_p_TPairT_TInt_TVecT_TStr_int_t_t", "TPair< TInt,TVec< TStr,int > > *|TIntStrVPr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TPairT_TInt_TInt_t_TInt_t = {"_p_TPairT_TPairT_TInt_TInt_t_TInt_t", "TIntPrIntPr *|TPair< TPair< TInt,TInt >,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TStr_TFlt_t = {"_p_TPairT_TStr_TFlt_t", "TStrFltPr *|TPair< TStr,TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TStr_TInt_t = {"_p_TPairT_TStr_TInt_t", "TStrIntPr *|TPair< TStr,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TStr_TStr_t = {"_p_TPairT_TStr_TStr_t", "TStrPr *|TPair< TStr,TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TStr_TVecT_TStr_int_t_t = {"_p_TPairT_TStr_TVecT_TStr_int_t_t", "TPair< TStr,TVec< TStr,int > > *|TStrStrVPr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUCh_TInt_t = {"_p_TPairT_TUCh_TInt_t", "TUChIntPr *|TPair< TUCh,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUCh_TStr_t = {"_p_TPairT_TUCh_TStr_t", "TUChStrPr *|TPair< TUCh,TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUCh_TUInt64_t = {"_p_TPairT_TUCh_TUInt64_t", "TUChUInt64Pr *|TPair< TUCh,TUInt64 > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUInt64_TFlt_t = {"_p_TPairT_TUInt64_TFlt_t", "TUInt64FltPr *|TPair< TUInt64,TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUInt64_TInt_t = {"_p_TPairT_TUInt64_TInt_t", "TUInt64IntPr *|TPair< TUInt64,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUInt64_TStr_t = {"_p_TPairT_TUInt64_TStr_t", "TUInt64StrPr *|TPair< TUInt64,TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUInt64_TUInt64_t = {"_p_TPairT_TUInt64_TUInt64_t", "TUInt64Pr *|TPair< TUInt64,TUInt64 > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUInt_TInt_t = {"_p_TPairT_TUInt_TInt_t", "TUIntIntPr *|TPair< TUInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TUInt_TUInt_t = {"_p_TPairT_TUInt_TUInt_t", "TUIntUIntPr *|TPair< TUInt,TUInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPairT_TVecT_TStr_int_t_TInt_t = {"_p_TPairT_TVecT_TStr_int_t_TInt_t", "TStrVIntPr *|TPair< TVec< TStr,int >,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_PVecT_TAscFlt_t_t = {"_p_TPtT_PVecT_TAscFlt_t_t", "PAscFltV *|TPt< PVec< TAscFlt > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_PVecT_TFlt_t_t = {"_p_TPtT_PVecT_TFlt_t_t", "TPt< PVec< TFlt > > *|PFltV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_PVecT_TStr_t_t = {"_p_TPtT_PVecT_TStr_t_t", "TPt< PVec< TStr > > *|PStrV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TBPGraph_t = {"_p_TPtT_TBPGraph_t", "TPt< TBPGraph > *|PBPGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TBigStrPool_t = {"_p_TPtT_TBigStrPool_t", "PBigStrPool *|TPt< TBigStrPool > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TExcept_t = {"_p_TPtT_TExcept_t", "PExcept *|TPt< TExcept > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TFRnd_t = {"_p_TPtT_TFRnd_t", "PFRnd *|TPt< TFRnd > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TMem_t = {"_p_TPtT_TMem_t", "TPt< TMem > *|PMem *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNEANet_t = {"_p_TPtT_TNEANet_t", "TPt< TNEANet > *|PNEANet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNEGraph_t = {"_p_TPtT_TNEGraph_t", "TPt< TNEGraph > *|PNEGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNGraph_t = {"_p_TPtT_TNGraph_t", "TPt< TNGraph > *|PNGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeEDatNetT_TInt_TFlt_t_t = {"_p_TPtT_TNodeEDatNetT_TInt_TFlt_t_t", "TPt< TNodeEDatNet< TInt,TFlt > > *|PIntFltNEDNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeEDatNetT_TInt_TInt_t_t = {"_p_TPtT_TNodeEDatNetT_TInt_TInt_t_t", "TPt< TNodeEDatNet< TInt,TInt > > *|PIntNEDNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeEDatNetT_TStr_TInt_t_t = {"_p_TPtT_TNodeEDatNetT_TStr_TInt_t_t", "TPt< TNodeEDatNet< TStr,TInt > > *|PStrIntNEDNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeEdgeNetT_TFlt_TFlt_t_t = {"_p_TPtT_TNodeEdgeNetT_TFlt_TFlt_t_t", "TPt< TNodeEdgeNet< TFlt,TFlt > > *|PFltNENet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeEdgeNetT_TInt_TInt_t_t = {"_p_TPtT_TNodeEdgeNetT_TInt_TInt_t_t", "TPt< TNodeEdgeNet< TInt,TInt > > *|PIntNENet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeNetT_TFlt_t_t = {"_p_TPtT_TNodeNetT_TFlt_t_t", "TPt< TNodeNet< TFlt > > *|PFltNNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeNetT_TInt_t_t = {"_p_TPtT_TNodeNetT_TInt_t_t", "TPt< TNodeNet< TInt > > *|PIntNNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TNodeNetT_TStr_t_t = {"_p_TPtT_TNodeNetT_TStr_t_t", "TPt< TNodeNet< TStr > > *|PStrNNet *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TSInOut_t = {"_p_TPtT_TSInOut_t", "PSInOut *|TPt< TSInOut > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TSIn_t = {"_p_TPtT_TSIn_t", "TPt< TSIn > *|PSIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TSOut_t = {"_p_TPtT_TSOut_t", "PSOut *|TPt< TSOut > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TStrPool64_t = {"_p_TPtT_TStrPool64_t", "TPt< TStrPool64 > *|PStrPool64 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TStrPool_t = {"_p_TPtT_TStrPool_t", "PStrPool *|TPt< TStrPool > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TUNGraph_t = {"_p_TPtT_TUNGraph_t", "TPt< TUNGraph > *|PUNGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TVecPoolT_TInt_int_t_t = {"_p_TPtT_TVecPoolT_TInt_int_t_t", "TPt< TVecPool< TInt,int > > *|PIntVecPool *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TXmlDoc_t = {"_p_TPtT_TXmlDoc_t", "TPt< TXmlDoc > *|PXmlDoc *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TPtT_TXmlTok_t = {"_p_TPtT_TXmlTok_t", "TPt< TXmlTok > *|PXmlTok *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQQueueT_TFlt_t = {"_p_TQQueueT_TFlt_t", "TQQueue< TFlt > *|TFltQ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQQueueT_TInt_t = {"_p_TQQueueT_TInt_t", "TIntQ *|TQQueue< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQQueueT_TPairT_TInt_TInt_t_t = {"_p_TQQueueT_TPairT_TInt_TInt_t_t", "TQQueue< TPair< TInt,TInt > > *|TIntPrQ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQQueueT_TPairT_TInt_TStr_t_t = {"_p_TQQueueT_TPairT_TInt_TStr_t_t", "TQQueue< TPair< TInt,TStr > > *|TIntStrPrQ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQQueueT_TStr_t = {"_p_TQQueueT_TStr_t", "TQQueue< TStr > *|TStrQ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQQueueT_TVecT_TAscFlt_int_t_t = {"_p_TQQueueT_TVecT_TAscFlt_int_t_t", "TQQueue< TVec< TAscFlt,int > > *|TAscFltVQ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQQueueT_TVecT_TFlt_int_t_t = {"_p_TQQueueT_TVecT_TFlt_int_t_t", "TQQueue< TVec< TFlt,int > > *|TFltVQ *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQuadT_TFlt_TFlt_TFlt_TFlt_t = {"_p_TQuadT_TFlt_TFlt_TFlt_TFlt_t", "TFltQu *|TQuad< TFlt,TFlt,TFlt,TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQuadT_TFlt_TInt_TInt_TInt_t = {"_p_TQuadT_TFlt_TInt_TInt_TInt_t", "TFltIntIntIntQu *|TQuad< TFlt,TInt,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQuadT_TInt_TInt_TFlt_TFlt_t = {"_p_TQuadT_TInt_TInt_TFlt_TFlt_t", "TIntIntFltFltQu *|TQuad< TInt,TInt,TFlt,TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQuadT_TInt_TInt_TInt_TInt_t = {"_p_TQuadT_TInt_TInt_TInt_TInt_t", "TIntQu *|TQuad< TInt,TInt,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQuadT_TInt_TStr_TInt_TInt_t = {"_p_TQuadT_TInt_TStr_TInt_TInt_t", "TIntStrIntIntQu *|TQuad< TInt,TStr,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQuadT_TStr_TStr_TInt_TInt_t = {"_p_TQuadT_TStr_TStr_TInt_TInt_t", "TStrStrIntIntQu *|TQuad< TStr,TStr,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TQuadT_TStr_TStr_TStr_TStr_t = {"_p_TQuadT_TStr_TStr_TStr_TStr_t", "TStrQu *|TQuad< TStr,TStr,TStr,TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TRStr = {"_p_TRStr", "TRStr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TRelOp = {"_p_TRelOp", "enum TRelOp *|TRelOp *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TRnd = {"_p_TRnd", "TRnd *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSBase = {"_p_TSBase", "TSBase *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TFInOut = {"_p_TFInOut", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_TSFlt = {"_p_TSFlt", "TSFlt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSIn = {"_p_TSIn", "TSIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSInOut = {"_p_TSInOut", "TSInOut *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSInt = {"_p_TSInt", "TSInt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSOut = {"_p_TSOut", "TSOut *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSOutMnp = {"_p_TSOutMnp", "TSOutMnp *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSStackT_TInt_t = {"_p_TSStackT_TInt_t", "TIntS *|TSStack< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSStackT_TPairT_TBool_TCh_t_t = {"_p_TSStackT_TPairT_TBool_TCh_t_t", "TSStack< TPair< TBool,TCh > > *|TBoolChS *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSStackT_TPairT_TInt_TInt_t_t = {"_p_TSStackT_TPairT_TInt_TInt_t_t", "TSStack< TPair< TInt,TInt > > *|TSStack< TIntPr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSStr = {"_p_TSStr", "TSStr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSecTm = {"_p_TSecTm", "TSecTm *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TSizeTy = {"_p_TSizeTy", "TSizeTy *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStdIn = {"_p_TStdIn", "TStdIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStdOut = {"_p_TStdOut", "TStdOut *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStopReason = {"_p_TStopReason", "TStopReason *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStr = {"_p_TStr", "TVec< TStr,int >::TIter|TStr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrHashF_DJB = {"_p_TStrHashF_DJB", "TStrHashF_DJB *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrHashF_Md5 = {"_p_TStrHashF_Md5", "TStrHashF_Md5 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrHashF_OldGLib = {"_p_TStrHashF_OldGLib", "TStrHashF_OldGLib *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t = {"_p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t", "TStrIntSH *|TStrHash< TInt,TStrPool,TDefaultHashFunc< TStr > > *|TStrSH *|TStrHash< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrHashT_TVecT_TInt_int_t_TStrPool_TDefaultHashFuncT_TStr_t_t = {"_p_TStrHashT_TVecT_TInt_int_t_TStrPool_TDefaultHashFuncT_TStr_t_t", "TStrHash< TVec< TInt,int >,TStrPool,TDefaultHashFunc< TStr > > *|TStrToIntVSH *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrIn = {"_p_TStrIn", "TStrIn *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrIntPrH__TIter = {"_p_TStrIntPrH__TIter", "TStrIntPrH::TIter *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrPool = {"_p_TStrPool", "TStrPool *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrPool64 = {"_p_TStrPool64", "TStrPool64 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrUtil = {"_p_TStrUtil", "TStrUtil *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TStrV__TIter = {"_p_TStrV__TIter", "TStrV::TIter *|TStrVecIter *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTreeT_TFlt_t = {"_p_TTreeT_TFlt_t", "TTree< TFlt > *|TFltTree *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTreeT_TInt_t = {"_p_TTreeT_TInt_t", "TIntTree *|TTree< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTreeT_TPairT_TStr_TInt_t_t = {"_p_TTreeT_TPairT_TStr_TInt_t_t", "TTree< TPair< TStr,TInt > > *|TStrIntPrTree *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTreeT_TStr_t = {"_p_TTreeT_TStr_t", "TTree< TStr > *|TStrTree *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTreeT_TTripleT_TStr_TInt_TVecT_TStr_int_t_t_t = {"_p_TTreeT_TTripleT_TStr_TInt_TVecT_TStr_int_t_t_t", "TTree< TTriple< TStr,TInt,TVec< TStr,int > > > *|TStrIntStrVTrTree *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TChA_TChA_TChA_t = {"_p_TTripleT_TChA_TChA_TChA_t", "TTriple< TChA,TChA,TChA > *|TChATr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TCh_TCh_TCh_t = {"_p_TTripleT_TCh_TCh_TCh_t", "TChTr *|TTriple< TCh,TCh,TCh > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TCh_TInt_TInt_t = {"_p_TTripleT_TCh_TInt_TInt_t", "TChIntIntTr *|TTriple< TCh,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TFlt_TFlt_TFlt_t = {"_p_TTripleT_TFlt_TFlt_TFlt_t", "TTriple< TFlt,TFlt,TFlt > *|TFltTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TFlt_TFlt_TInt_t = {"_p_TTripleT_TFlt_TFlt_TInt_t", "TFltFltIntTr *|TTriple< TFlt,TFlt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TFlt_TFlt_TStr_t = {"_p_TTripleT_TFlt_TFlt_TStr_t", "TTriple< TFlt,TFlt,TStr > *|TFltFltStrTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TFlt_TInt_TInt_t = {"_p_TTripleT_TFlt_TInt_TInt_t", "TFltIntIntTr *|TTriple< TFlt,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TFlt_TFlt_t = {"_p_TTripleT_TInt_TFlt_TFlt_t", "TTriple< TInt,TFlt,TFlt > *|TIntFltFltTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TFlt_TInt_t = {"_p_TTripleT_TInt_TFlt_TInt_t", "TIntFltIntTr *|TTriple< TInt,TFlt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TInt_TFlt_t = {"_p_TTripleT_TInt_TInt_TFlt_t", "TTriple< TInt,TInt,TFlt > *|TIntIntFltTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TInt_TInt_t = {"_p_TTripleT_TInt_TInt_TInt_t", "TIntTr *|TTriple< TInt,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TInt_TStr_t = {"_p_TTripleT_TInt_TInt_TStr_t", "TTriple< TInt,TInt,TStr > *|TIntIntStrTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TInt_TVecT_TInt_int_t_t = {"_p_TTripleT_TInt_TInt_TVecT_TInt_int_t_t", "TTriple< TInt,TInt,TVec< TInt,int > > *|TIntIntIntVTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TStr_TInt_t = {"_p_TTripleT_TInt_TStr_TInt_t", "TIntStrIntTr *|TTriple< TInt,TStr,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TInt_TVecT_TInt_int_t_TInt_t = {"_p_TTripleT_TInt_TVecT_TInt_int_t_TInt_t", "TIntIntVIntTr *|TTriple< TInt,TVec< TInt,int >,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TStr_TFlt_TFlt_t = {"_p_TTripleT_TStr_TFlt_TFlt_t", "TTriple< TStr,TFlt,TFlt > *|TStrFltFltTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TStr_TInt_TInt_t = {"_p_TTripleT_TStr_TInt_TInt_t", "TStrIntIntTr *|TTriple< TStr,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TStr_TInt_TVecT_TStr_int_t_t = {"_p_TTripleT_TStr_TInt_TVecT_TStr_int_t_t", "TTriple< TStr,TInt,TVec< TStr,int > > *|TStrIntStrVTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TStr_TStr_TInt_t = {"_p_TTripleT_TStr_TStr_TInt_t", "TStrStrIntTr *|TTriple< TStr,TStr,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TStr_TStr_TStr_t = {"_p_TTripleT_TStr_TStr_TStr_t", "TTriple< TStr,TStr,TStr > *|TStrTr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TUCh_TInt_TInt_t = {"_p_TTripleT_TUCh_TInt_TInt_t", "TUChIntIntTr *|TTriple< TUCh,TInt,TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TTripleT_TUInt64_TUInt64_TUInt64_t = {"_p_TTripleT_TUInt64_TUInt64_TUInt64_t", "TUInt64Tr *|TTriple< TUInt64,TUInt64,TUInt64 > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUCh = {"_p_TUCh", "TUCh *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUInt = {"_p_TUInt", "TUInt *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUInt64 = {"_p_TUInt64", "TUInt64 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUNGraph = {"_p_TUNGraph", "TUNGraph *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUNGraphEdgeI = {"_p_TUNGraphEdgeI", "TUNGraphEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUNGraphMtx = {"_p_TUNGraphMtx", "TUNGraphMtx *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUNGraphNodeI = {"_p_TUNGraphNodeI", "TUNGraphNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUNGraph__TEdgeI = {"_p_TUNGraph__TEdgeI", "TUNGraph::TEdgeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUNGraph__TNode = {"_p_TUNGraph__TNode", "TUNGraph::TNode *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUNGraph__TNodeI = {"_p_TUNGraph__TNodeI", "TUNGraph::TNodeI *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TUndirFFire = {"_p_TUndirFFire", "TUndirFFire *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVVecT_TFlt_t = {"_p_TVVVecT_TFlt_t", "TFltVVV *|TVVVec< TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVVecT_TInt_t = {"_p_TVVVecT_TInt_t", "TIntVVV *|TVVVec< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVecT_TBool_t = {"_p_TVVecT_TBool_t", "TBoolVV *|TVVec< TBool > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVecT_TCh_t = {"_p_TVVecT_TCh_t", "TChVV *|TVVec< TCh > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVecT_TFlt_t = {"_p_TVVecT_TFlt_t", "TFltVV *|TVVec< TFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVecT_TInt_t = {"_p_TVVecT_TInt_t", "TIntVV *|TVVec< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVecT_TPairT_TInt_TInt_t_t = {"_p_TVVecT_TPairT_TInt_TInt_t_t", "TVVec< TPair< TInt,TInt > > *|TIntPrVV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVecT_TSFlt_t = {"_p_TVVecT_TSFlt_t", "TSFltVV *|TVVec< TSFlt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVVecT_TStr_t = {"_p_TVVecT_TStr_t", "TStrVV *|TVVec< TStr > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVal = {"_p_TVal", "TVal *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecPoolT_TInt_int_t = {"_p_TVecPoolT_TInt_int_t", "TIntVecPool *|TVecPool< TInt,int > *|TVecPool< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TAscFlt_int_t = {"_p_TVecT_TAscFlt_int_t", "TAscFltV *|TVec< TAscFlt,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TBool_int_t = {"_p_TVecT_TBool_int_t", "TBoolV *|TVec< TBool,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TChA_int_t = {"_p_TVecT_TChA_int_t", "TChAV *|TVec< TChA,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TCh_int_t = {"_p_TVecT_TCh_int_t", "TChV *|TVec< TCh,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TCnCom_int_t = {"_p_TVecT_TCnCom_int_t", "TVec< TCnCom > *|TCnComV *|TVec< TCnCom,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TFlt_int_t = {"_p_TVecT_TFlt_int_t", "TVec< TFlt,int > *|TFltV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TInt_int_t = {"_p_TVecT_TInt_int_t", "TVec< TVec< TInt,int >,int >::TIter|TVec< TInt,int > *|TIntV *|TVec< TInt > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TAscFlt_TInt_t_int_t = {"_p_TVecT_TKeyDatT_TAscFlt_TInt_t_int_t", "TVec< TKeyDat< TAscFlt,TInt >,int > *|TAscFltIntKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TFlt_TBool_t_int_t = {"_p_TVecT_TKeyDatT_TFlt_TBool_t_int_t", "TFltBoolKdV *|TVec< TKeyDat< TFlt,TBool >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t = {"_p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t", "TVec< TKeyDat< TFlt,TFlt >,int > *|TFltKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TFlt_TInt_t_int_t = {"_p_TVecT_TKeyDatT_TFlt_TInt_t_int_t", "TVec< TKeyDat< TFlt,TInt >,int > *|TFltIntKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t_int_t = {"_p_TVecT_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t_int_t", "TFltIntPrKdV *|TVec< TKeyDat< TFlt,TPair< TInt,TInt > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TFlt_TStr_t_int_t = {"_p_TVecT_TKeyDatT_TFlt_TStr_t_int_t", "TFltStrKdV *|TVec< TKeyDat< TFlt,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TFlt_TUInt64_t_int_t = {"_p_TVecT_TKeyDatT_TFlt_TUInt64_t_int_t", "TVec< TKeyDat< TFlt,TUInt64 >,int > *|TFltUInt64KdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TInt_TFlt_t_int_t = {"_p_TVecT_TKeyDatT_TInt_TFlt_t_int_t", "TVec< TKeyDat< TInt,TFlt >,int > *|TIntFltKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TInt_TInt_t_int_t = {"_p_TVecT_TKeyDatT_TInt_TInt_t_int_t", "TVec< TKeyDat< TInt,TInt > > *|TVec< TKeyDat< TInt,TInt >,int > *|TIntKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t_int_t = {"_p_TVecT_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t_int_t", "TIntFltPrKdV *|TVec< TKeyDat< TInt,TPair< TFlt,TFlt > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TInt_TStr_t_int_t = {"_p_TVecT_TKeyDatT_TInt_TStr_t_int_t", "TIntStrKdV *|TVec< TKeyDat< TInt,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TInt_TUInt64_t_int_t = {"_p_TVecT_TKeyDatT_TInt_TUInt64_t_int_t", "TVec< TKeyDat< TInt,TUInt64 >,int > *|TIntUInt64KdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t = {"_p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t", "TVec< TKeyDat< TInt,TVec< TInt,int > > > *|TVec< TKeyDat< TInt,TVec< TInt,int > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t_int_t = {"_p_TVecT_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t_int_t", "TVec< TKeyDat< TPair< TInt,TInt >,TFlt >,int > *|TIntPrFltKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TStr_TAscFlt_t_int_t = {"_p_TVecT_TKeyDatT_TStr_TAscFlt_t_int_t", "TVec< TKeyDat< TStr,TAscFlt >,int > *|TStrAscFltKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TStr_TFlt_t_int_t = {"_p_TVecT_TKeyDatT_TStr_TFlt_t_int_t", "TVec< TKeyDat< TStr,TFlt >,int > *|TStrFltKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TStr_TInt_t_int_t = {"_p_TVecT_TKeyDatT_TStr_TInt_t_int_t", "TVec< TKeyDat< TStr,TInt >,int > *|TStrIntKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TStr_TStr_t_int_t = {"_p_TVecT_TKeyDatT_TStr_TStr_t_int_t", "TStrKdV *|TVec< TKeyDat< TStr,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TUInt64_TFlt_t_int_t = {"_p_TVecT_TKeyDatT_TUInt64_TFlt_t_int_t", "TVec< TKeyDat< TUInt64,TFlt >,int > *|TUInt64FltKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TUInt64_TInt_t_int_t = {"_p_TVecT_TKeyDatT_TUInt64_TInt_t_int_t", "TVec< TKeyDat< TUInt64,TInt >,int > *|TUInt64IntKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TUInt64_TStr_t_int_t = {"_p_TVecT_TKeyDatT_TUInt64_TStr_t_int_t", "TUInt64StrKdV *|TVec< TKeyDat< TUInt64,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TUInt_TInt_t_int_t = {"_p_TVecT_TKeyDatT_TUInt_TInt_t_int_t", "TVec< TKeyDat< TUInt,TInt >,int > *|TUIntIntKdV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t = {"_p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t", "TVec< TKeyDat< TVec< TInt,int >,TInt > > *|TVec< TKeyDat< TVec< TInt,int >,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TAscFlt_TInt_t_int_t = {"_p_TVecT_TPairT_TAscFlt_TInt_t_int_t", "TAscFltIntPrV *|TVec< TPair< TAscFlt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TAscFlt_TStr_t_int_t = {"_p_TVecT_TPairT_TAscFlt_TStr_t_int_t", "TAscFltStrPrV *|TVec< TPair< TAscFlt,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TFlt_TFlt_t_int_t = {"_p_TVecT_TPairT_TFlt_TFlt_t_int_t", "TFltPrV *|TVec< TPair< TFlt,TFlt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TFlt_TInt_t_int_t = {"_p_TVecT_TPairT_TFlt_TInt_t_int_t", "TFltIntPrV *|TVec< TPair< TFlt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TFlt_TPairT_TStr_TStr_t_t_int_t = {"_p_TVecT_TPairT_TFlt_TPairT_TStr_TStr_t_t_int_t", "TFltStrPrPrV *|TVec< TPair< TFlt,TPair< TStr,TStr > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TFlt_TStr_t_int_t = {"_p_TVecT_TPairT_TFlt_TStr_t_int_t", "TFltStrPrV *|TVec< TPair< TFlt,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TFlt_TUInt64_t_int_t = {"_p_TVecT_TPairT_TFlt_TUInt64_t_int_t", "TFltUInt64PrV *|TVec< TPair< TFlt,TUInt64 >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TFlt_t_int_t = {"_p_TVecT_TPairT_TInt_TFlt_t_int_t", "TIntFltPrV *|TVec< TPair< TInt,TFlt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TInt_t_int_t = {"_p_TVecT_TPairT_TInt_TInt_t_int_t", "TVec< TPair< TInt,TInt > > *|TIntPrV *|TVec< TPair< TInt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TPairT_TInt_TInt_t_t_int_t = {"_p_TVecT_TPairT_TInt_TPairT_TInt_TInt_t_t_int_t", "TIntIntPrPrV *|TVec< TPair< TInt,TPair< TInt,TInt > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TPairT_TStr_TStr_t_t_int_t = {"_p_TVecT_TPairT_TInt_TPairT_TStr_TStr_t_t_int_t", "TIntStrPrPrV *|TVec< TPair< TInt,TPair< TStr,TStr > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TStr_t_int_t = {"_p_TVecT_TPairT_TInt_TStr_t_int_t", "TIntStrPrV *|TVec< TPair< TInt,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TUInt64_t_int_t = {"_p_TVecT_TPairT_TInt_TUInt64_t_int_t", "TIntUInt64PrV *|TVec< TPair< TInt,TUInt64 >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t = {"_p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t", "TVec< TPair< TInt,TVec< TInt,int > > > *|TVec< TPair< TInt,TVec< TInt,int > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TInt_TVecT_TStr_int_t_t_int_t = {"_p_TVecT_TPairT_TInt_TVecT_TStr_int_t_t_int_t", "TIntStrVPrV *|TVec< TPair< TInt,TVec< TStr,int > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TStr_TFlt_t_int_t = {"_p_TVecT_TPairT_TStr_TFlt_t_int_t", "TStrFltPrV *|TVec< TPair< TStr,TFlt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TStr_TInt_t_int_t = {"_p_TVecT_TPairT_TStr_TInt_t_int_t", "TStrIntPrV *|TVec< TPair< TStr,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TStr_TStr_t_int_t = {"_p_TVecT_TPairT_TStr_TStr_t_int_t", "TStrPrV *|TVec< TPair< TStr,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TStr_TVecT_TStr_int_t_t_int_t = {"_p_TVecT_TPairT_TStr_TVecT_TStr_int_t_t_int_t", "TStrStrVPrV *|TVec< TPair< TStr,TVec< TStr,int > >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TUCh_TInt_t_int_t = {"_p_TVecT_TPairT_TUCh_TInt_t_int_t", "TUChIntPrV *|TVec< TPair< TUCh,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TUCh_TUInt64_t_int_t = {"_p_TVecT_TPairT_TUCh_TUInt64_t_int_t", "TUChUInt64PrV *|TVec< TPair< TUCh,TUInt64 >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TUInt64_TFlt_t_int_t = {"_p_TVecT_TPairT_TUInt64_TFlt_t_int_t", "TUInt64FltPrV *|TVec< TPair< TUInt64,TFlt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TUInt64_TInt_t_int_t = {"_p_TVecT_TPairT_TUInt64_TInt_t_int_t", "TUInt64IntPrV *|TVec< TPair< TUInt64,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TUInt64_TStr_t_int_t = {"_p_TVecT_TPairT_TUInt64_TStr_t_int_t", "TUInt64StrPrV *|TVec< TPair< TUInt64,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t = {"_p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t", "TVec< TPair< TVec< TInt,int >,TInt > > *|TVec< TPair< TVec< TInt,int >,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPairT_TVecT_TStr_int_t_TInt_t_int_t = {"_p_TVecT_TPairT_TVecT_TStr_int_t_TInt_t_int_t", "TStrVIntPrV *|TVec< TPair< TVec< TStr,int >,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TPtT_TNGraph_t_int_t = {"_p_TVecT_TPtT_TNGraph_t_int_t", "TVec< TPt< TNGraph > > *|TVec< PNGraph > *|TVec< TPt< TNGraph >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TQQueueT_TInt_t_int_t = {"_p_TVecT_TQQueueT_TInt_t_int_t", "TIntQV *|TVec< TQQueue< TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TQuadT_TFlt_TInt_TInt_TInt_t_int_t = {"_p_TVecT_TQuadT_TFlt_TInt_TInt_TInt_t_int_t", "TFltIntIntIntQuV *|TVec< TQuad< TFlt,TInt,TInt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TQuadT_TInt_TInt_TInt_TInt_t_int_t = {"_p_TVecT_TQuadT_TInt_TInt_TInt_TInt_t_int_t", "TIntQuV *|TVec< TQuad< TInt,TInt,TInt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TQuadT_TInt_TStr_TInt_TInt_t_int_t = {"_p_TVecT_TQuadT_TInt_TStr_TInt_TInt_t_int_t", "TIntStrIntIntQuV *|TVec< TQuad< TInt,TStr,TInt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TQuadT_TStr_TStr_TStr_TStr_t_int_t = {"_p_TVecT_TQuadT_TStr_TStr_TStr_TStr_t_int_t", "TStrQuV *|TVec< TQuad< TStr,TStr,TStr,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TSFlt_int_t = {"_p_TVecT_TSFlt_int_t", "TSFltV *|TVec< TSFlt,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TStr_int_t = {"_p_TVecT_TStr_int_t", "TVec< TStr,int > *|TStrV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TFlt_TFlt_TFlt_t_int_t = {"_p_TVecT_TTripleT_TFlt_TFlt_TFlt_t_int_t", "TFltTrV *|TVec< TTriple< TFlt,TFlt,TFlt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TFlt_TFlt_TStr_t_int_t = {"_p_TVecT_TTripleT_TFlt_TFlt_TStr_t_int_t", "TFltFltStrTrV *|TVec< TTriple< TFlt,TFlt,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TFlt_TInt_TInt_t_int_t = {"_p_TVecT_TTripleT_TFlt_TInt_TInt_t_int_t", "TFltIntIntTrV *|TVec< TTriple< TFlt,TInt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TInt_TFlt_TInt_t_int_t = {"_p_TVecT_TTripleT_TInt_TFlt_TInt_t_int_t", "TIntFltIntTrV *|TVec< TTriple< TInt,TFlt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TInt_TInt_TFlt_t_int_t = {"_p_TVecT_TTripleT_TInt_TInt_TFlt_t_int_t", "TIntIntFltTrV *|TVec< TTriple< TInt,TInt,TFlt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t = {"_p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t", "TIntTrV *|TVec< TTriple< TInt,TInt,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TInt_TInt_TStr_t_int_t = {"_p_TVecT_TTripleT_TInt_TInt_TStr_t_int_t", "TIntIntStrTrV *|TVec< TTriple< TInt,TInt,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TInt_TInt_TVecT_TInt_int_t_t_int_t = {"_p_TVecT_TTripleT_TInt_TInt_TVecT_TInt_int_t_t_int_t", "TVec< TTriple< TInt,TInt,TVec< TInt,int > >,int > *|TIntIntIntVTrV *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TInt_TStr_TInt_t_int_t = {"_p_TVecT_TTripleT_TInt_TStr_TInt_t_int_t", "TIntStrIntTrV *|TVec< TTriple< TInt,TStr,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TInt_TVecT_TInt_int_t_TInt_t_int_t = {"_p_TVecT_TTripleT_TInt_TVecT_TInt_int_t_TInt_t_int_t", "TIntIntVIntTrV *|TVec< TTriple< TInt,TVec< TInt,int >,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TStr_TFlt_TFlt_t_int_t = {"_p_TVecT_TTripleT_TStr_TFlt_TFlt_t_int_t", "TStrFltFltTrV *|TVec< TTriple< TStr,TFlt,TFlt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TStr_TStr_TInt_t_int_t = {"_p_TVecT_TTripleT_TStr_TStr_TInt_t_int_t", "TStrStrIntTrV *|TVec< TTriple< TStr,TStr,TInt >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TTripleT_TStr_TStr_TStr_t_int_t = {"_p_TVecT_TTripleT_TStr_TStr_TStr_t_int_t", "TStrTrV *|TVec< TTriple< TStr,TStr,TStr >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TUCh_int_t = {"_p_TVecT_TUCh_int_t", "TUChV *|TVec< TUCh,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TUInt64_int_t = {"_p_TVecT_TUInt64_int_t", "TUInt64V *|TVec< TUInt64,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TUInt_int_t = {"_p_TVecT_TUInt_int_t", "TUIntV *|TVec< TUInt,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TVal_TSizeTy_t = {"_p_TVecT_TVal_TSizeTy_t", "TVec< TVal,TSizeTy > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TVecT_TFlt_int_t_int_t = {"_p_TVecT_TVecT_TFlt_int_t_int_t", "TVec< TVec< TFlt,int > > *|TVec< TFltV > *|TVec< TVec< TFlt,int >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_TVecT_TInt_int_t_int_t = {"_p_TVecT_TVecT_TInt_int_t_int_t", "TVec< TVec< TInt,int > > *|TIntIntVV *|TVec< TVec< TInt,int >,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVecT_char_p_int_t = {"_p_TVecT_char_p_int_t", "TVec< char * > *|TVec< char *,int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TVoid = {"_p_TVoid", "TVoid *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_TXmlLx = {"_p_TXmlLx", "TXmlLx *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *|int8 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_r_TSOut__r_TSOut = {"_p_f_r_TSOut__r_TSOut", "TSOut &(*)(TSOut &)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_r_TSOut__r_TStdOut = {"_p_f_r_TSOut__r_TStdOut", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_f_r_TSOut__r_TMemOut = {"_p_f_r_TSOut__r_TMemOut", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_f_r_TSOut__r_TFInOut = {"_p_f_r_TSOut__r_TFInOut", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_f_r_TSOut__r_TFOut = {"_p_f_r_TSOut__r_TFOut", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_f_r_TSOut__r_TMOut = {"_p_f_r_TSOut__r_TMOut", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_f_r_TSOut__r_TSInOut = {"_p_f_r_TSOut__r_TSInOut", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_float = {"_p_float", "float *|sdouble *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *|int32 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_long_double = {"_p_long_double", "long double *|ldouble *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64 *|long long *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ptrdiff_t = {"_p_ptrdiff_t", "ptrdiff_t *|ssize_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_short = {"_p_short", "int16 *|short *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_size_t = {"_p_size_t", "TSize *|size_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uchar *|unsigned char *|uint8 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32 *|unsigned int *|uint *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "ulong *|unsigned long *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64 *|unsigned long long *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16 *|unsigned short *|ushort *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_FILE, + &_swigt__p_PGStatVec, + &_swigt__p_PGraph, + &_swigt__p_PNet, + &_swigt__p_PVecT_TAscFlt_t, + &_swigt__p_PVecT_TFlt_t, + &_swigt__p_PVecT_TStr_t, + &_swigt__p_TArtPointVisitor, + &_swigt__p_TAscFlt, + &_swigt__p_TBPGraph, + &_swigt__p_TBPGraph__TEdgeI, + &_swigt__p_TBPGraph__TNode, + &_swigt__p_TBPGraph__TNodeI, + &_swigt__p_TBiConVisitor, + &_swigt__p_TBigStrPool, + &_swigt__p_TBool, + &_swigt__p_TCRef, + &_swigt__p_TCh, + &_swigt__p_TChA, + &_swigt__p_TChAIn, + &_swigt__p_TChRet, + &_swigt__p_TCnCom, + &_swigt__p_TConv_Pt64Ints32, + &_swigt__p_TCs, + &_swigt__p_TDbStr, + &_swigt__p_TFAccess, + &_swigt__p_TFIn, + &_swigt__p_TFInOut, + &_swigt__p_TFOut, + &_swigt__p_TFfGGen, + &_swigt__p_TFile, + &_swigt__p_TFlt, + &_swigt__p_TFltRect, + &_swigt__p_TFltV__TIter, + &_swigt__p_TForestFire, + &_swigt__p_TGUtil, + &_swigt__p_TGVizLayout_, + &_swigt__p_TGraphFlag, + &_swigt__p_THKeyDat, + &_swigt__p_THashKeyDatIT_TInt_TInt_t, + &_swigt__p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t, + &_swigt__p_THashKeyDatT_TInt_TInt_t, + &_swigt__p_THashT_TCh_TCh_TDefaultHashFuncT_TCh_t_t, + &_swigt__p_THashT_TDbStr_TInt_TDefaultHashFuncT_TDbStr_t_t, + &_swigt__p_THashT_TDbStr_TStr_TDefaultHashFuncT_TDbStr_t_t, + &_swigt__p_THashT_TFlt_TFlt_TDefaultHashFuncT_TFlt_t_t, + &_swigt__p_THashT_TInt_TBool_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TPairT_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TTripleT_TFlt_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TUInt64_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TVecT_TFlt_int_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TInt_TVecT_TStr_int_t_TDefaultHashFuncT_TInt_t_t, + &_swigt__p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + &_swigt__p_THashT_TPairT_TInt_TInt_t_TInt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + &_swigt__p_THashT_TPairT_TInt_TInt_t_TStr_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + &_swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TInt_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + &_swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + &_swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + &_swigt__p_THashT_TPairT_TInt_TStr_t_TInt_TDefaultHashFuncT_TPairT_TInt_TStr_t_t_t, + &_swigt__p_THashT_TPairT_TStr_TInt_t_TInt_TDefaultHashFuncT_TPairT_TStr_TInt_t_t_t, + &_swigt__p_THashT_TPairT_TStr_TStr_t_TBool_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + &_swigt__p_THashT_TPairT_TStr_TStr_t_TFlt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + &_swigt__p_THashT_TPairT_TStr_TStr_t_TInt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + &_swigt__p_THashT_TPairT_TStr_TStr_t_TStr_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + &_swigt__p_THashT_TPairT_TStr_TStr_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + &_swigt__p_THashT_TStr_TBool_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TFlt_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TInt_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TPairT_TInt_TInt_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TPairT_TStr_TStr_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TStr_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TUInt64_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TFlt_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TInt_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TKeyDatT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TKeyDatT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TPairT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TPairT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TStr_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TStr_TVecT_TUInt64_int_t_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_THashT_TTripleT_TCh_TCh_TCh_t_TInt_TDefaultHashFuncT_TTripleT_TCh_TCh_TCh_t_t_t, + &_swigt__p_THashT_TTripleT_TInt_TInt_TInt_t_TFlt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t, + &_swigt__p_THashT_TTripleT_TInt_TInt_TInt_t_TInt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t, + &_swigt__p_THashT_TTripleT_TStr_TStr_TStr_t_TInt_TDefaultHashFuncT_TTripleT_TStr_TStr_TStr_t_t_t, + &_swigt__p_THashT_TUInt64_TInt_TDefaultHashFuncT_TUInt64_t_t, + &_swigt__p_THashT_TUInt64_TVecT_TStr_int_t_TDefaultHashFuncT_TUInt64_t_t, + &_swigt__p_THashT_TUInt_TUInt_TDefaultHashFuncT_TUInt_t_t, + &_swigt__p_THashT_TVecT_TInt_int_t_TInt_TDefaultHashFuncT_TVecT_TInt_int_t_t_t, + &_swigt__p_THashT_TVecT_TStr_int_t_TInt_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + &_swigt__p_THashT_TVecT_TStr_int_t_TStr_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + &_swigt__p_THashT_TVecT_TStr_int_t_TVecT_TInt_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + &_swigt__p_THashT_TVecT_TStr_int_t_TVecT_TStr_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + &_swigt__p_TILx, + &_swigt__p_TInt, + &_swigt__p_TIntSet, + &_swigt__p_TIntV__TIter, + &_swigt__p_TIter, + &_swigt__p_TKeyDatT_TAscFlt_TInt_t, + &_swigt__p_TKeyDatT_TFlt_TBool_t, + &_swigt__p_TKeyDatT_TFlt_TFlt_t, + &_swigt__p_TKeyDatT_TFlt_TInt_t, + &_swigt__p_TKeyDatT_TFlt_TPairT_TInt_TBool_t_t, + &_swigt__p_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t, + &_swigt__p_TKeyDatT_TFlt_TStr_t, + &_swigt__p_TKeyDatT_TFlt_TUInt64_t, + &_swigt__p_TKeyDatT_TFlt_TUInt_t, + &_swigt__p_TKeyDatT_TInt_TFlt_t, + &_swigt__p_TKeyDatT_TInt_TInt_t, + &_swigt__p_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t, + &_swigt__p_TKeyDatT_TInt_TSFlt_t, + &_swigt__p_TKeyDatT_TInt_TStr_t, + &_swigt__p_TKeyDatT_TInt_TUInt64_t, + &_swigt__p_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t, + &_swigt__p_TKeyDatT_TStr_TAscFlt_t, + &_swigt__p_TKeyDatT_TStr_TBool_t, + &_swigt__p_TKeyDatT_TStr_TFlt_t, + &_swigt__p_TKeyDatT_TStr_TInt_t, + &_swigt__p_TKeyDatT_TStr_TStr_t, + &_swigt__p_TKeyDatT_TUInt64_TFlt_t, + &_swigt__p_TKeyDatT_TUInt64_TInt_t, + &_swigt__p_TKeyDatT_TUInt64_TStr_t, + &_swigt__p_TKeyDatT_TUInt_TInt_t, + &_swigt__p_TKeyDatT_TUInt_TUInt_t, + &_swigt__p_TLFlt, + &_swigt__p_TLnRet, + &_swigt__p_TLoc, + &_swigt__p_TLogOp, + &_swigt__p_TLstT_TFlt_t, + &_swigt__p_TLstT_TInt_t, + &_swigt__p_TLstT_TKeyDatT_TAscFlt_TInt_t_t, + &_swigt__p_TLstT_TKeyDatT_TFlt_TInt_t_t, + &_swigt__p_TLstT_TKeyDatT_TInt_TInt_t_t, + &_swigt__p_TLstT_TStr_t, + &_swigt__p_TMIn, + &_swigt__p_TMOut, + &_swigt__p_TMem, + &_swigt__p_TMemIn, + &_swigt__p_TMemOut, + &_swigt__p_TNEANet, + &_swigt__p_TNEANetAFltI, + &_swigt__p_TNEANetAIntI, + &_swigt__p_TNEANetAStrI, + &_swigt__p_TNEANetEdgeI, + &_swigt__p_TNEANetNodeI, + &_swigt__p_TNEANet__TAFltI, + &_swigt__p_TNEANet__TAIntI, + &_swigt__p_TNEANet__TAStrI, + &_swigt__p_TNEANet__TEdgeI, + &_swigt__p_TNEANet__TNode, + &_swigt__p_TNEANet__TNodeI, + &_swigt__p_TNEGraph, + &_swigt__p_TNEGraph__TEdgeI, + &_swigt__p_TNEGraph__TNode, + &_swigt__p_TNEGraph__TNodeI, + &_swigt__p_TNGraph, + &_swigt__p_TNGraphEdgeI, + &_swigt__p_TNGraphMtx, + &_swigt__p_TNGraphNodeI, + &_swigt__p_TNGraph__TEdgeI, + &_swigt__p_TNGraph__TNode, + &_swigt__p_TNGraph__TNodeI, + &_swigt__p_TNet, + &_swigt__p_TNodeEDatNetT_TInt_TFlt_t, + &_swigt__p_TNodeEDatNetT_TInt_TInt_t, + &_swigt__p_TNodeEDatNetT_TStr_TInt_t, + &_swigt__p_TNodeEdgeNetT_TFlt_TFlt_t, + &_swigt__p_TNodeEdgeNetT_TInt_TInt_t, + &_swigt__p_TNodeNetT_TFlt_t, + &_swigt__p_TNodeNetT_TInt_t, + &_swigt__p_TNodeNetT_TStr_t, + &_swigt__p_TNodeTy, + &_swigt__p_TOLx, + &_swigt__p_TObj, + &_swigt__p_TPairHashImpl1, + &_swigt__p_TPairHashImpl2, + &_swigt__p_TPairT_TAscFlt_TAscFlt_t, + &_swigt__p_TPairT_TAscFlt_TInt_t, + &_swigt__p_TPairT_TAscFlt_TStr_t, + &_swigt__p_TPairT_TBool_TCh_t, + &_swigt__p_TPairT_TBool_TFlt_t, + &_swigt__p_TPairT_TFlt_TFlt_t, + &_swigt__p_TPairT_TFlt_TInt_t, + &_swigt__p_TPairT_TFlt_TPairT_TStr_TStr_t_t, + &_swigt__p_TPairT_TFlt_TStr_t, + &_swigt__p_TPairT_TFlt_TUInt64_t, + &_swigt__p_TPairT_TInt_TBool_t, + &_swigt__p_TPairT_TInt_TCh_t, + &_swigt__p_TPairT_TInt_TFlt_t, + &_swigt__p_TPairT_TInt_TInt_t, + &_swigt__p_TPairT_TInt_TPairT_TInt_TInt_t_t, + &_swigt__p_TPairT_TInt_TPairT_TStr_TStr_t_t, + &_swigt__p_TPairT_TInt_TStr_t, + &_swigt__p_TPairT_TInt_TUInt64_t, + &_swigt__p_TPairT_TInt_TVecT_TInt_int_t_t, + &_swigt__p_TPairT_TInt_TVecT_TStr_int_t_t, + &_swigt__p_TPairT_TPairT_TInt_TInt_t_TInt_t, + &_swigt__p_TPairT_TStr_TFlt_t, + &_swigt__p_TPairT_TStr_TInt_t, + &_swigt__p_TPairT_TStr_TStr_t, + &_swigt__p_TPairT_TStr_TVecT_TStr_int_t_t, + &_swigt__p_TPairT_TUCh_TInt_t, + &_swigt__p_TPairT_TUCh_TStr_t, + &_swigt__p_TPairT_TUCh_TUInt64_t, + &_swigt__p_TPairT_TUInt64_TFlt_t, + &_swigt__p_TPairT_TUInt64_TInt_t, + &_swigt__p_TPairT_TUInt64_TStr_t, + &_swigt__p_TPairT_TUInt64_TUInt64_t, + &_swigt__p_TPairT_TUInt_TInt_t, + &_swigt__p_TPairT_TUInt_TUInt_t, + &_swigt__p_TPairT_TVecT_TStr_int_t_TInt_t, + &_swigt__p_TPtT_PVecT_TAscFlt_t_t, + &_swigt__p_TPtT_PVecT_TFlt_t_t, + &_swigt__p_TPtT_PVecT_TStr_t_t, + &_swigt__p_TPtT_TBPGraph_t, + &_swigt__p_TPtT_TBigStrPool_t, + &_swigt__p_TPtT_TExcept_t, + &_swigt__p_TPtT_TFRnd_t, + &_swigt__p_TPtT_TMem_t, + &_swigt__p_TPtT_TNEANet_t, + &_swigt__p_TPtT_TNEGraph_t, + &_swigt__p_TPtT_TNGraph_t, + &_swigt__p_TPtT_TNodeEDatNetT_TInt_TFlt_t_t, + &_swigt__p_TPtT_TNodeEDatNetT_TInt_TInt_t_t, + &_swigt__p_TPtT_TNodeEDatNetT_TStr_TInt_t_t, + &_swigt__p_TPtT_TNodeEdgeNetT_TFlt_TFlt_t_t, + &_swigt__p_TPtT_TNodeEdgeNetT_TInt_TInt_t_t, + &_swigt__p_TPtT_TNodeNetT_TFlt_t_t, + &_swigt__p_TPtT_TNodeNetT_TInt_t_t, + &_swigt__p_TPtT_TNodeNetT_TStr_t_t, + &_swigt__p_TPtT_TSInOut_t, + &_swigt__p_TPtT_TSIn_t, + &_swigt__p_TPtT_TSOut_t, + &_swigt__p_TPtT_TStrPool64_t, + &_swigt__p_TPtT_TStrPool_t, + &_swigt__p_TPtT_TUNGraph_t, + &_swigt__p_TPtT_TVecPoolT_TInt_int_t_t, + &_swigt__p_TPtT_TXmlDoc_t, + &_swigt__p_TPtT_TXmlTok_t, + &_swigt__p_TQQueueT_TFlt_t, + &_swigt__p_TQQueueT_TInt_t, + &_swigt__p_TQQueueT_TPairT_TInt_TInt_t_t, + &_swigt__p_TQQueueT_TPairT_TInt_TStr_t_t, + &_swigt__p_TQQueueT_TStr_t, + &_swigt__p_TQQueueT_TVecT_TAscFlt_int_t_t, + &_swigt__p_TQQueueT_TVecT_TFlt_int_t_t, + &_swigt__p_TQuadT_TFlt_TFlt_TFlt_TFlt_t, + &_swigt__p_TQuadT_TFlt_TInt_TInt_TInt_t, + &_swigt__p_TQuadT_TInt_TInt_TFlt_TFlt_t, + &_swigt__p_TQuadT_TInt_TInt_TInt_TInt_t, + &_swigt__p_TQuadT_TInt_TStr_TInt_TInt_t, + &_swigt__p_TQuadT_TStr_TStr_TInt_TInt_t, + &_swigt__p_TQuadT_TStr_TStr_TStr_TStr_t, + &_swigt__p_TRStr, + &_swigt__p_TRelOp, + &_swigt__p_TRnd, + &_swigt__p_TSBase, + &_swigt__p_TSFlt, + &_swigt__p_TSIn, + &_swigt__p_TSInOut, + &_swigt__p_TSInt, + &_swigt__p_TSOut, + &_swigt__p_TSOutMnp, + &_swigt__p_TSStackT_TInt_t, + &_swigt__p_TSStackT_TPairT_TBool_TCh_t_t, + &_swigt__p_TSStackT_TPairT_TInt_TInt_t_t, + &_swigt__p_TSStr, + &_swigt__p_TSecTm, + &_swigt__p_TSizeTy, + &_swigt__p_TStdIn, + &_swigt__p_TStdOut, + &_swigt__p_TStopReason, + &_swigt__p_TStr, + &_swigt__p_TStrHashF_DJB, + &_swigt__p_TStrHashF_Md5, + &_swigt__p_TStrHashF_OldGLib, + &_swigt__p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_TStrHashT_TVecT_TInt_int_t_TStrPool_TDefaultHashFuncT_TStr_t_t, + &_swigt__p_TStrIn, + &_swigt__p_TStrIntPrH__TIter, + &_swigt__p_TStrPool, + &_swigt__p_TStrPool64, + &_swigt__p_TStrUtil, + &_swigt__p_TStrV__TIter, + &_swigt__p_TTreeT_TFlt_t, + &_swigt__p_TTreeT_TInt_t, + &_swigt__p_TTreeT_TPairT_TStr_TInt_t_t, + &_swigt__p_TTreeT_TStr_t, + &_swigt__p_TTreeT_TTripleT_TStr_TInt_TVecT_TStr_int_t_t_t, + &_swigt__p_TTripleT_TChA_TChA_TChA_t, + &_swigt__p_TTripleT_TCh_TCh_TCh_t, + &_swigt__p_TTripleT_TCh_TInt_TInt_t, + &_swigt__p_TTripleT_TFlt_TFlt_TFlt_t, + &_swigt__p_TTripleT_TFlt_TFlt_TInt_t, + &_swigt__p_TTripleT_TFlt_TFlt_TStr_t, + &_swigt__p_TTripleT_TFlt_TInt_TInt_t, + &_swigt__p_TTripleT_TInt_TFlt_TFlt_t, + &_swigt__p_TTripleT_TInt_TFlt_TInt_t, + &_swigt__p_TTripleT_TInt_TInt_TFlt_t, + &_swigt__p_TTripleT_TInt_TInt_TInt_t, + &_swigt__p_TTripleT_TInt_TInt_TStr_t, + &_swigt__p_TTripleT_TInt_TInt_TVecT_TInt_int_t_t, + &_swigt__p_TTripleT_TInt_TStr_TInt_t, + &_swigt__p_TTripleT_TInt_TVecT_TInt_int_t_TInt_t, + &_swigt__p_TTripleT_TStr_TFlt_TFlt_t, + &_swigt__p_TTripleT_TStr_TInt_TInt_t, + &_swigt__p_TTripleT_TStr_TInt_TVecT_TStr_int_t_t, + &_swigt__p_TTripleT_TStr_TStr_TInt_t, + &_swigt__p_TTripleT_TStr_TStr_TStr_t, + &_swigt__p_TTripleT_TUCh_TInt_TInt_t, + &_swigt__p_TTripleT_TUInt64_TUInt64_TUInt64_t, + &_swigt__p_TUCh, + &_swigt__p_TUInt, + &_swigt__p_TUInt64, + &_swigt__p_TUNGraph, + &_swigt__p_TUNGraphEdgeI, + &_swigt__p_TUNGraphMtx, + &_swigt__p_TUNGraphNodeI, + &_swigt__p_TUNGraph__TEdgeI, + &_swigt__p_TUNGraph__TNode, + &_swigt__p_TUNGraph__TNodeI, + &_swigt__p_TUndirFFire, + &_swigt__p_TVVVecT_TFlt_t, + &_swigt__p_TVVVecT_TInt_t, + &_swigt__p_TVVecT_TBool_t, + &_swigt__p_TVVecT_TCh_t, + &_swigt__p_TVVecT_TFlt_t, + &_swigt__p_TVVecT_TInt_t, + &_swigt__p_TVVecT_TPairT_TInt_TInt_t_t, + &_swigt__p_TVVecT_TSFlt_t, + &_swigt__p_TVVecT_TStr_t, + &_swigt__p_TVal, + &_swigt__p_TVecPoolT_TInt_int_t, + &_swigt__p_TVecT_TAscFlt_int_t, + &_swigt__p_TVecT_TBool_int_t, + &_swigt__p_TVecT_TChA_int_t, + &_swigt__p_TVecT_TCh_int_t, + &_swigt__p_TVecT_TCnCom_int_t, + &_swigt__p_TVecT_TFlt_int_t, + &_swigt__p_TVecT_TInt_int_t, + &_swigt__p_TVecT_TKeyDatT_TAscFlt_TInt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TFlt_TBool_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TFlt_TInt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TFlt_TStr_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TFlt_TUInt64_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TInt_TInt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TInt_TStr_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TInt_TUInt64_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TStr_TAscFlt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TStr_TFlt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TStr_TInt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TStr_TStr_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TUInt64_TFlt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TUInt64_TInt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TUInt64_TStr_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TUInt_TInt_t_int_t, + &_swigt__p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TAscFlt_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TAscFlt_TStr_t_int_t, + &_swigt__p_TVecT_TPairT_TFlt_TFlt_t_int_t, + &_swigt__p_TVecT_TPairT_TFlt_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TFlt_TPairT_TStr_TStr_t_t_int_t, + &_swigt__p_TVecT_TPairT_TFlt_TStr_t_int_t, + &_swigt__p_TVecT_TPairT_TFlt_TUInt64_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TFlt_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TPairT_TInt_TInt_t_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TPairT_TStr_TStr_t_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TStr_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TUInt64_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t, + &_swigt__p_TVecT_TPairT_TInt_TVecT_TStr_int_t_t_int_t, + &_swigt__p_TVecT_TPairT_TStr_TFlt_t_int_t, + &_swigt__p_TVecT_TPairT_TStr_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TStr_TStr_t_int_t, + &_swigt__p_TVecT_TPairT_TStr_TVecT_TStr_int_t_t_int_t, + &_swigt__p_TVecT_TPairT_TUCh_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TUCh_TUInt64_t_int_t, + &_swigt__p_TVecT_TPairT_TUInt64_TFlt_t_int_t, + &_swigt__p_TVecT_TPairT_TUInt64_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TUInt64_TStr_t_int_t, + &_swigt__p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t, + &_swigt__p_TVecT_TPairT_TVecT_TStr_int_t_TInt_t_int_t, + &_swigt__p_TVecT_TPtT_TNGraph_t_int_t, + &_swigt__p_TVecT_TQQueueT_TInt_t_int_t, + &_swigt__p_TVecT_TQuadT_TFlt_TInt_TInt_TInt_t_int_t, + &_swigt__p_TVecT_TQuadT_TInt_TInt_TInt_TInt_t_int_t, + &_swigt__p_TVecT_TQuadT_TInt_TStr_TInt_TInt_t_int_t, + &_swigt__p_TVecT_TQuadT_TStr_TStr_TStr_TStr_t_int_t, + &_swigt__p_TVecT_TSFlt_int_t, + &_swigt__p_TVecT_TStr_int_t, + &_swigt__p_TVecT_TTripleT_TFlt_TFlt_TFlt_t_int_t, + &_swigt__p_TVecT_TTripleT_TFlt_TFlt_TStr_t_int_t, + &_swigt__p_TVecT_TTripleT_TFlt_TInt_TInt_t_int_t, + &_swigt__p_TVecT_TTripleT_TInt_TFlt_TInt_t_int_t, + &_swigt__p_TVecT_TTripleT_TInt_TInt_TFlt_t_int_t, + &_swigt__p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t, + &_swigt__p_TVecT_TTripleT_TInt_TInt_TStr_t_int_t, + &_swigt__p_TVecT_TTripleT_TInt_TInt_TVecT_TInt_int_t_t_int_t, + &_swigt__p_TVecT_TTripleT_TInt_TStr_TInt_t_int_t, + &_swigt__p_TVecT_TTripleT_TInt_TVecT_TInt_int_t_TInt_t_int_t, + &_swigt__p_TVecT_TTripleT_TStr_TFlt_TFlt_t_int_t, + &_swigt__p_TVecT_TTripleT_TStr_TStr_TInt_t_int_t, + &_swigt__p_TVecT_TTripleT_TStr_TStr_TStr_t_int_t, + &_swigt__p_TVecT_TUCh_int_t, + &_swigt__p_TVecT_TUInt64_int_t, + &_swigt__p_TVecT_TUInt_int_t, + &_swigt__p_TVecT_TVal_TSizeTy_t, + &_swigt__p_TVecT_TVecT_TFlt_int_t_int_t, + &_swigt__p_TVecT_TVecT_TInt_int_t_int_t, + &_swigt__p_TVecT_char_p_int_t, + &_swigt__p_TVoid, + &_swigt__p_TXmlLx, + &_swigt__p_bool, + &_swigt__p_char, + &_swigt__p_double, + &_swigt__p_f_r_TSOut__r_TFInOut, + &_swigt__p_f_r_TSOut__r_TFOut, + &_swigt__p_f_r_TSOut__r_TMOut, + &_swigt__p_f_r_TSOut__r_TMemOut, + &_swigt__p_f_r_TSOut__r_TSInOut, + &_swigt__p_f_r_TSOut__r_TSOut, + &_swigt__p_f_r_TSOut__r_TStdOut, + &_swigt__p_float, + &_swigt__p_int, + &_swigt__p_long_double, + &_swigt__p_long_long, + &_swigt__p_p_char, + &_swigt__p_ptrdiff_t, + &_swigt__p_short, + &_swigt__p_size_t, + &_swigt__p_unsigned_char, + &_swigt__p_unsigned_int, + &_swigt__p_unsigned_long, + &_swigt__p_unsigned_long_long, + &_swigt__p_unsigned_short, + &_swigt__p_void, +}; + +static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PGStatVec[] = { {&_swigt__p_PGStatVec, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PGraph[] = { {&_swigt__p_PGraph, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PNet[] = { {&_swigt__p_PNet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PVecT_TAscFlt_t[] = { {&_swigt__p_PVecT_TAscFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PVecT_TFlt_t[] = { {&_swigt__p_PVecT_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PVecT_TStr_t[] = { {&_swigt__p_PVecT_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TArtPointVisitor[] = { {&_swigt__p_TArtPointVisitor, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TAscFlt[] = { {&_swigt__p_TAscFlt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TBPGraph[] = { {&_swigt__p_TBPGraph, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TBPGraph__TEdgeI[] = { {&_swigt__p_TBPGraph__TEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TBPGraph__TNode[] = { {&_swigt__p_TBPGraph__TNode, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TBPGraph__TNodeI[] = { {&_swigt__p_TBPGraph__TNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TBiConVisitor[] = { {&_swigt__p_TBiConVisitor, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TBigStrPool[] = { {&_swigt__p_TBigStrPool, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TBool[] = { {&_swigt__p_TBool, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TCRef[] = { {&_swigt__p_TCRef, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TCh[] = { {&_swigt__p_TCh, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TChA[] = { {&_swigt__p_TChA, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TChAIn[] = { {&_swigt__p_TChAIn, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TChRet[] = { {&_swigt__p_TChRet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TCnCom[] = { {&_swigt__p_TCnCom, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TConv_Pt64Ints32[] = { {&_swigt__p_TConv_Pt64Ints32, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TCs[] = { {&_swigt__p_TCs, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TDbStr[] = { {&_swigt__p_TDbStr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFAccess[] = { {&_swigt__p_TFAccess, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFIn[] = { {&_swigt__p_TFIn, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFOut[] = { {&_swigt__p_TFOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFfGGen[] = { {&_swigt__p_TFfGGen, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFile[] = { {&_swigt__p_TFile, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFlt[] = { {&_swigt__p_TFlt, 0, 0, 0}, {&_swigt__p_TAscFlt, _p_TAscFltTo_p_TFlt, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFltRect[] = { {&_swigt__p_TFltRect, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFltV__TIter[] = { {&_swigt__p_TFltV__TIter, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TForestFire[] = { {&_swigt__p_TForestFire, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TGUtil[] = { {&_swigt__p_TGUtil, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TGVizLayout_[] = { {&_swigt__p_TGVizLayout_, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TGraphFlag[] = { {&_swigt__p_TGraphFlag, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THKeyDat[] = { {&_swigt__p_THKeyDat, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashKeyDatIT_TInt_TInt_t[] = { {&_swigt__p_THashKeyDatIT_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t[] = { {&_swigt__p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashKeyDatT_TInt_TInt_t[] = { {&_swigt__p_THashKeyDatT_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TCh_TCh_TDefaultHashFuncT_TCh_t_t[] = { {&_swigt__p_THashT_TCh_TCh_TDefaultHashFuncT_TCh_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TDbStr_TInt_TDefaultHashFuncT_TDbStr_t_t[] = { {&_swigt__p_THashT_TDbStr_TInt_TDefaultHashFuncT_TDbStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TDbStr_TStr_TDefaultHashFuncT_TDbStr_t_t[] = { {&_swigt__p_THashT_TDbStr_TStr_TDefaultHashFuncT_TDbStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TFlt_TFlt_TDefaultHashFuncT_TFlt_t_t[] = { {&_swigt__p_THashT_TFlt_TFlt_TDefaultHashFuncT_TFlt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TBool_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TBool_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TPairT_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TPairT_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TTripleT_TFlt_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TTripleT_TFlt_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TUInt64_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TUInt64_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TVecT_TFlt_int_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TVecT_TFlt_int_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TInt_TVecT_TStr_int_t_TDefaultHashFuncT_TInt_t_t[] = { {&_swigt__p_THashT_TInt_TVecT_TStr_int_t_TDefaultHashFuncT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TInt_TInt_t_TInt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TPairT_TInt_TInt_t_TInt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TInt_TInt_t_TStr_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TPairT_TInt_TInt_t_TStr_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TInt_TInt_t_TVecT_TInt_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TInt_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TInt_TInt_t_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TInt_TInt_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TPairT_TInt_TInt_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TInt_TStr_t_TInt_TDefaultHashFuncT_TPairT_TInt_TStr_t_t_t[] = { {&_swigt__p_THashT_TPairT_TInt_TStr_t_TInt_TDefaultHashFuncT_TPairT_TInt_TStr_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TStr_TInt_t_TInt_TDefaultHashFuncT_TPairT_TStr_TInt_t_t_t[] = { {&_swigt__p_THashT_TPairT_TStr_TInt_t_TInt_TDefaultHashFuncT_TPairT_TStr_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TStr_TStr_t_TBool_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t[] = { {&_swigt__p_THashT_TPairT_TStr_TStr_t_TBool_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TStr_TStr_t_TFlt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t[] = { {&_swigt__p_THashT_TPairT_TStr_TStr_t_TFlt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TStr_TStr_t_TInt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t[] = { {&_swigt__p_THashT_TPairT_TStr_TStr_t_TInt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TStr_TStr_t_TStr_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t[] = { {&_swigt__p_THashT_TPairT_TStr_TStr_t_TStr_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TPairT_TStr_TStr_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t[] = { {&_swigt__p_THashT_TPairT_TStr_TStr_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TBool_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TBool_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TFlt_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TFlt_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TInt_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TInt_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TPairT_TInt_TInt_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TPairT_TInt_TInt_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TPairT_TStr_TStr_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TPairT_TStr_TStr_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TStr_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TStr_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TUInt64_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TUInt64_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TFlt_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TFlt_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TInt_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TInt_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TKeyDatT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TKeyDatT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TKeyDatT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TKeyDatT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TPairT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TPairT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TPairT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TPairT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TStr_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TStr_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TStr_TVecT_TUInt64_int_t_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_THashT_TStr_TVecT_TUInt64_int_t_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TTripleT_TCh_TCh_TCh_t_TInt_TDefaultHashFuncT_TTripleT_TCh_TCh_TCh_t_t_t[] = { {&_swigt__p_THashT_TTripleT_TCh_TCh_TCh_t_TInt_TDefaultHashFuncT_TTripleT_TCh_TCh_TCh_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TTripleT_TInt_TInt_TInt_t_TFlt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TTripleT_TInt_TInt_TInt_t_TFlt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TTripleT_TInt_TInt_TInt_t_TInt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t[] = { {&_swigt__p_THashT_TTripleT_TInt_TInt_TInt_t_TInt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TTripleT_TStr_TStr_TStr_t_TInt_TDefaultHashFuncT_TTripleT_TStr_TStr_TStr_t_t_t[] = { {&_swigt__p_THashT_TTripleT_TStr_TStr_TStr_t_TInt_TDefaultHashFuncT_TTripleT_TStr_TStr_TStr_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TUInt64_TInt_TDefaultHashFuncT_TUInt64_t_t[] = { {&_swigt__p_THashT_TUInt64_TInt_TDefaultHashFuncT_TUInt64_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TUInt64_TVecT_TStr_int_t_TDefaultHashFuncT_TUInt64_t_t[] = { {&_swigt__p_THashT_TUInt64_TVecT_TStr_int_t_TDefaultHashFuncT_TUInt64_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TUInt_TUInt_TDefaultHashFuncT_TUInt_t_t[] = { {&_swigt__p_THashT_TUInt_TUInt_TDefaultHashFuncT_TUInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TVecT_TInt_int_t_TInt_TDefaultHashFuncT_TVecT_TInt_int_t_t_t[] = { {&_swigt__p_THashT_TVecT_TInt_int_t_TInt_TDefaultHashFuncT_TVecT_TInt_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TVecT_TStr_int_t_TInt_TDefaultHashFuncT_TVecT_TStr_int_t_t_t[] = { {&_swigt__p_THashT_TVecT_TStr_int_t_TInt_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TVecT_TStr_int_t_TStr_TDefaultHashFuncT_TVecT_TStr_int_t_t_t[] = { {&_swigt__p_THashT_TVecT_TStr_int_t_TStr_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TVecT_TStr_int_t_TVecT_TInt_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t[] = { {&_swigt__p_THashT_TVecT_TStr_int_t_TVecT_TInt_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_THashT_TVecT_TStr_int_t_TVecT_TStr_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t[] = { {&_swigt__p_THashT_TVecT_TStr_int_t_TVecT_TStr_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TILx[] = { {&_swigt__p_TILx, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TInt[] = { {&_swigt__p_TInt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TIntSet[] = { {&_swigt__p_TIntSet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TIntV__TIter[] = { {&_swigt__p_TIntV__TIter, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TIter[] = { {&_swigt__p_TIter, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TAscFlt_TInt_t[] = { {&_swigt__p_TKeyDatT_TAscFlt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TBool_t[] = { {&_swigt__p_TKeyDatT_TFlt_TBool_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TFlt_t[] = { {&_swigt__p_TKeyDatT_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TInt_t[] = { {&_swigt__p_TKeyDatT_TFlt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TPairT_TInt_TBool_t_t[] = { {&_swigt__p_TKeyDatT_TFlt_TPairT_TInt_TBool_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t[] = { {&_swigt__p_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TStr_t[] = { {&_swigt__p_TKeyDatT_TFlt_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TUInt64_t[] = { {&_swigt__p_TKeyDatT_TFlt_TUInt64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TFlt_TUInt_t[] = { {&_swigt__p_TKeyDatT_TFlt_TUInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TInt_TFlt_t[] = { {&_swigt__p_TKeyDatT_TInt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TInt_TInt_t[] = { {&_swigt__p_TKeyDatT_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t[] = { {&_swigt__p_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TInt_TSFlt_t[] = { {&_swigt__p_TKeyDatT_TInt_TSFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TInt_TStr_t[] = { {&_swigt__p_TKeyDatT_TInt_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TInt_TUInt64_t[] = { {&_swigt__p_TKeyDatT_TInt_TUInt64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t[] = { {&_swigt__p_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TStr_TAscFlt_t[] = { {&_swigt__p_TKeyDatT_TStr_TAscFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TStr_TBool_t[] = { {&_swigt__p_TKeyDatT_TStr_TBool_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TStr_TFlt_t[] = { {&_swigt__p_TKeyDatT_TStr_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TStr_TInt_t[] = { {&_swigt__p_TKeyDatT_TStr_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TStr_TStr_t[] = { {&_swigt__p_TKeyDatT_TStr_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TUInt64_TFlt_t[] = { {&_swigt__p_TKeyDatT_TUInt64_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TUInt64_TInt_t[] = { {&_swigt__p_TKeyDatT_TUInt64_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TUInt64_TStr_t[] = { {&_swigt__p_TKeyDatT_TUInt64_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TUInt_TInt_t[] = { {&_swigt__p_TKeyDatT_TUInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TKeyDatT_TUInt_TUInt_t[] = { {&_swigt__p_TKeyDatT_TUInt_TUInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLFlt[] = { {&_swigt__p_TLFlt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLnRet[] = { {&_swigt__p_TLnRet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLoc[] = { {&_swigt__p_TLoc, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLogOp[] = { {&_swigt__p_TLogOp, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLstT_TFlt_t[] = { {&_swigt__p_TLstT_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLstT_TInt_t[] = { {&_swigt__p_TLstT_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLstT_TKeyDatT_TAscFlt_TInt_t_t[] = { {&_swigt__p_TLstT_TKeyDatT_TAscFlt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLstT_TKeyDatT_TFlt_TInt_t_t[] = { {&_swigt__p_TLstT_TKeyDatT_TFlt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLstT_TKeyDatT_TInt_TInt_t_t[] = { {&_swigt__p_TLstT_TKeyDatT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TLstT_TStr_t[] = { {&_swigt__p_TLstT_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TMIn[] = { {&_swigt__p_TMIn, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TMOut[] = { {&_swigt__p_TMOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TMem[] = { {&_swigt__p_TMem, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TMemIn[] = { {&_swigt__p_TMemIn, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TMemOut[] = { {&_swigt__p_TMemOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANet[] = { {&_swigt__p_TNEANet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANetAFltI[] = { {&_swigt__p_TNEANetAFltI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANetAIntI[] = { {&_swigt__p_TNEANetAIntI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANetAStrI[] = { {&_swigt__p_TNEANetAStrI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANetEdgeI[] = { {&_swigt__p_TNEANetEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANetNodeI[] = { {&_swigt__p_TNEANetNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANet__TAFltI[] = { {&_swigt__p_TNEANet__TAFltI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANet__TAIntI[] = { {&_swigt__p_TNEANet__TAIntI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANet__TAStrI[] = { {&_swigt__p_TNEANet__TAStrI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANet__TEdgeI[] = { {&_swigt__p_TNEANet__TEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANet__TNode[] = { {&_swigt__p_TNEANet__TNode, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEANet__TNodeI[] = { {&_swigt__p_TNEANet__TNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEGraph[] = { {&_swigt__p_TNEGraph, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEGraph__TEdgeI[] = { {&_swigt__p_TNEGraph__TEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEGraph__TNode[] = { {&_swigt__p_TNEGraph__TNode, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNEGraph__TNodeI[] = { {&_swigt__p_TNEGraph__TNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNGraph[] = { {&_swigt__p_TNGraph, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNGraphEdgeI[] = { {&_swigt__p_TNGraphEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNGraphMtx[] = { {&_swigt__p_TNGraphMtx, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNGraphNodeI[] = { {&_swigt__p_TNGraphNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNGraph__TEdgeI[] = { {&_swigt__p_TNGraph__TEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNGraph__TNode[] = { {&_swigt__p_TNGraph__TNode, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNGraph__TNodeI[] = { {&_swigt__p_TNGraph__TNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNet[] = { {&_swigt__p_TNet, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeEDatNetT_TInt_TFlt_t[] = { {&_swigt__p_TNodeEDatNetT_TInt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeEDatNetT_TInt_TInt_t[] = { {&_swigt__p_TNodeEDatNetT_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeEDatNetT_TStr_TInt_t[] = { {&_swigt__p_TNodeEDatNetT_TStr_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeEdgeNetT_TFlt_TFlt_t[] = { {&_swigt__p_TNodeEdgeNetT_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeEdgeNetT_TInt_TInt_t[] = { {&_swigt__p_TNodeEdgeNetT_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeNetT_TFlt_t[] = { {&_swigt__p_TNodeNetT_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeNetT_TInt_t[] = { {&_swigt__p_TNodeNetT_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeNetT_TStr_t[] = { {&_swigt__p_TNodeNetT_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TNodeTy[] = { {&_swigt__p_TNodeTy, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TOLx[] = { {&_swigt__p_TOLx, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TObj[] = { {&_swigt__p_TObj, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairHashImpl1[] = { {&_swigt__p_TPairHashImpl1, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairHashImpl2[] = { {&_swigt__p_TPairHashImpl2, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TAscFlt_TAscFlt_t[] = { {&_swigt__p_TPairT_TAscFlt_TAscFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TAscFlt_TInt_t[] = { {&_swigt__p_TPairT_TAscFlt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TAscFlt_TStr_t[] = { {&_swigt__p_TPairT_TAscFlt_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TBool_TCh_t[] = { {&_swigt__p_TPairT_TBool_TCh_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TBool_TFlt_t[] = { {&_swigt__p_TPairT_TBool_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TFlt_TFlt_t[] = { {&_swigt__p_TPairT_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TFlt_TInt_t[] = { {&_swigt__p_TPairT_TFlt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TFlt_TPairT_TStr_TStr_t_t[] = { {&_swigt__p_TPairT_TFlt_TPairT_TStr_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TFlt_TStr_t[] = { {&_swigt__p_TPairT_TFlt_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TFlt_TUInt64_t[] = { {&_swigt__p_TPairT_TFlt_TUInt64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TBool_t[] = { {&_swigt__p_TPairT_TInt_TBool_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TCh_t[] = { {&_swigt__p_TPairT_TInt_TCh_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TFlt_t[] = { {&_swigt__p_TPairT_TInt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TInt_t[] = { {&_swigt__p_TPairT_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TPairT_TInt_TInt_t_t[] = { {&_swigt__p_TPairT_TInt_TPairT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TPairT_TStr_TStr_t_t[] = { {&_swigt__p_TPairT_TInt_TPairT_TStr_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TStr_t[] = { {&_swigt__p_TPairT_TInt_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TUInt64_t[] = { {&_swigt__p_TPairT_TInt_TUInt64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TVecT_TInt_int_t_t[] = { {&_swigt__p_TPairT_TInt_TVecT_TInt_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TInt_TVecT_TStr_int_t_t[] = { {&_swigt__p_TPairT_TInt_TVecT_TStr_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TPairT_TInt_TInt_t_TInt_t[] = { {&_swigt__p_TPairT_TPairT_TInt_TInt_t_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TStr_TFlt_t[] = { {&_swigt__p_TPairT_TStr_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TStr_TInt_t[] = { {&_swigt__p_TPairT_TStr_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TStr_TStr_t[] = { {&_swigt__p_TPairT_TStr_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TStr_TVecT_TStr_int_t_t[] = { {&_swigt__p_TPairT_TStr_TVecT_TStr_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUCh_TInt_t[] = { {&_swigt__p_TPairT_TUCh_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUCh_TStr_t[] = { {&_swigt__p_TPairT_TUCh_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUCh_TUInt64_t[] = { {&_swigt__p_TPairT_TUCh_TUInt64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUInt64_TFlt_t[] = { {&_swigt__p_TPairT_TUInt64_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUInt64_TInt_t[] = { {&_swigt__p_TPairT_TUInt64_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUInt64_TStr_t[] = { {&_swigt__p_TPairT_TUInt64_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUInt64_TUInt64_t[] = { {&_swigt__p_TPairT_TUInt64_TUInt64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUInt_TInt_t[] = { {&_swigt__p_TPairT_TUInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TUInt_TUInt_t[] = { {&_swigt__p_TPairT_TUInt_TUInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPairT_TVecT_TStr_int_t_TInt_t[] = { {&_swigt__p_TPairT_TVecT_TStr_int_t_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_PVecT_TAscFlt_t_t[] = { {&_swigt__p_TPtT_PVecT_TAscFlt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_PVecT_TFlt_t_t[] = { {&_swigt__p_TPtT_PVecT_TFlt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_PVecT_TStr_t_t[] = { {&_swigt__p_TPtT_PVecT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TBPGraph_t[] = { {&_swigt__p_TPtT_TBPGraph_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TBigStrPool_t[] = { {&_swigt__p_TPtT_TBigStrPool_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TExcept_t[] = { {&_swigt__p_TPtT_TExcept_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TFRnd_t[] = { {&_swigt__p_TPtT_TFRnd_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TMem_t[] = { {&_swigt__p_TPtT_TMem_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNEANet_t[] = { {&_swigt__p_TPtT_TNEANet_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNEGraph_t[] = { {&_swigt__p_TPtT_TNEGraph_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNGraph_t[] = { {&_swigt__p_TPtT_TNGraph_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeEDatNetT_TInt_TFlt_t_t[] = { {&_swigt__p_TPtT_TNodeEDatNetT_TInt_TFlt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeEDatNetT_TInt_TInt_t_t[] = { {&_swigt__p_TPtT_TNodeEDatNetT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeEDatNetT_TStr_TInt_t_t[] = { {&_swigt__p_TPtT_TNodeEDatNetT_TStr_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeEdgeNetT_TFlt_TFlt_t_t[] = { {&_swigt__p_TPtT_TNodeEdgeNetT_TFlt_TFlt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeEdgeNetT_TInt_TInt_t_t[] = { {&_swigt__p_TPtT_TNodeEdgeNetT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeNetT_TFlt_t_t[] = { {&_swigt__p_TPtT_TNodeNetT_TFlt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeNetT_TInt_t_t[] = { {&_swigt__p_TPtT_TNodeNetT_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TNodeNetT_TStr_t_t[] = { {&_swigt__p_TPtT_TNodeNetT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TSInOut_t[] = { {&_swigt__p_TPtT_TSInOut_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TSIn_t[] = { {&_swigt__p_TPtT_TSIn_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TSOut_t[] = { {&_swigt__p_TPtT_TSOut_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TStrPool64_t[] = { {&_swigt__p_TPtT_TStrPool64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TStrPool_t[] = { {&_swigt__p_TPtT_TStrPool_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TUNGraph_t[] = { {&_swigt__p_TPtT_TUNGraph_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TVecPoolT_TInt_int_t_t[] = { {&_swigt__p_TPtT_TVecPoolT_TInt_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TXmlDoc_t[] = { {&_swigt__p_TPtT_TXmlDoc_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TPtT_TXmlTok_t[] = { {&_swigt__p_TPtT_TXmlTok_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQQueueT_TFlt_t[] = { {&_swigt__p_TQQueueT_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQQueueT_TInt_t[] = { {&_swigt__p_TQQueueT_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQQueueT_TPairT_TInt_TInt_t_t[] = { {&_swigt__p_TQQueueT_TPairT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQQueueT_TPairT_TInt_TStr_t_t[] = { {&_swigt__p_TQQueueT_TPairT_TInt_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQQueueT_TStr_t[] = { {&_swigt__p_TQQueueT_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQQueueT_TVecT_TAscFlt_int_t_t[] = { {&_swigt__p_TQQueueT_TVecT_TAscFlt_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQQueueT_TVecT_TFlt_int_t_t[] = { {&_swigt__p_TQQueueT_TVecT_TFlt_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQuadT_TFlt_TFlt_TFlt_TFlt_t[] = { {&_swigt__p_TQuadT_TFlt_TFlt_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQuadT_TFlt_TInt_TInt_TInt_t[] = { {&_swigt__p_TQuadT_TFlt_TInt_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQuadT_TInt_TInt_TFlt_TFlt_t[] = { {&_swigt__p_TQuadT_TInt_TInt_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQuadT_TInt_TInt_TInt_TInt_t[] = { {&_swigt__p_TQuadT_TInt_TInt_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQuadT_TInt_TStr_TInt_TInt_t[] = { {&_swigt__p_TQuadT_TInt_TStr_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQuadT_TStr_TStr_TInt_TInt_t[] = { {&_swigt__p_TQuadT_TStr_TStr_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TQuadT_TStr_TStr_TStr_TStr_t[] = { {&_swigt__p_TQuadT_TStr_TStr_TStr_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TRStr[] = { {&_swigt__p_TRStr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TRelOp[] = { {&_swigt__p_TRelOp, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TRnd[] = { {&_swigt__p_TRnd, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TFInOut[] = {{&_swigt__p_TFInOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSBase[] = { {&_swigt__p_TStdOut, _p_TStdOutTo_p_TSBase, 0, 0}, {&_swigt__p_TStdIn, _p_TStdInTo_p_TSBase, 0, 0}, {&_swigt__p_TMOut, _p_TMOutTo_p_TSBase, 0, 0}, {&_swigt__p_TFIn, _p_TFInTo_p_TSBase, 0, 0}, {&_swigt__p_TSIn, _p_TSInTo_p_TSBase, 0, 0}, {&_swigt__p_TSOut, _p_TSOutTo_p_TSBase, 0, 0}, {&_swigt__p_TFInOut, _p_TFInOutTo_p_TSBase, 0, 0}, {&_swigt__p_TStrIn, _p_TStrInTo_p_TSBase, 0, 0}, {&_swigt__p_TSBase, 0, 0, 0}, {&_swigt__p_TChAIn, _p_TChAInTo_p_TSBase, 0, 0}, {&_swigt__p_TFOut, _p_TFOutTo_p_TSBase, 0, 0}, {&_swigt__p_TMemIn, _p_TMemInTo_p_TSBase, 0, 0}, {&_swigt__p_TMIn, _p_TMInTo_p_TSBase, 0, 0}, {&_swigt__p_TSInOut, _p_TSInOutTo_p_TSBase, 0, 0}, {&_swigt__p_TMemOut, _p_TMemOutTo_p_TSBase, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSFlt[] = { {&_swigt__p_TSFlt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSIn[] = { {&_swigt__p_TSIn, 0, 0, 0}, {&_swigt__p_TChAIn, _p_TChAInTo_p_TSIn, 0, 0}, {&_swigt__p_TFInOut, _p_TFInOutTo_p_TSIn, 0, 0}, {&_swigt__p_TFIn, _p_TFInTo_p_TSIn, 0, 0}, {&_swigt__p_TMIn, _p_TMInTo_p_TSIn, 0, 0}, {&_swigt__p_TStdIn, _p_TStdInTo_p_TSIn, 0, 0}, {&_swigt__p_TMemIn, _p_TMemInTo_p_TSIn, 0, 0}, {&_swigt__p_TStrIn, _p_TStrInTo_p_TSIn, 0, 0}, {&_swigt__p_TSInOut, _p_TSInOutTo_p_TSIn, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSInOut[] = { {&_swigt__p_TFInOut, _p_TFInOutTo_p_TSInOut, 0, 0}, {&_swigt__p_TSInOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSInt[] = { {&_swigt__p_TSInt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSOut[] = { {&_swigt__p_TStdOut, _p_TStdOutTo_p_TSOut, 0, 0}, {&_swigt__p_TMemOut, _p_TMemOutTo_p_TSOut, 0, 0}, {&_swigt__p_TFInOut, _p_TFInOutTo_p_TSOut, 0, 0}, {&_swigt__p_TSOut, 0, 0, 0}, {&_swigt__p_TFOut, _p_TFOutTo_p_TSOut, 0, 0}, {&_swigt__p_TMOut, _p_TMOutTo_p_TSOut, 0, 0}, {&_swigt__p_TSInOut, _p_TSInOutTo_p_TSOut, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSOutMnp[] = { {&_swigt__p_TSOutMnp, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSStackT_TInt_t[] = { {&_swigt__p_TSStackT_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSStackT_TPairT_TBool_TCh_t_t[] = { {&_swigt__p_TSStackT_TPairT_TBool_TCh_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSStackT_TPairT_TInt_TInt_t_t[] = { {&_swigt__p_TSStackT_TPairT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSStr[] = { {&_swigt__p_TSStr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSecTm[] = { {&_swigt__p_TSecTm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TSizeTy[] = { {&_swigt__p_TSizeTy, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStdIn[] = { {&_swigt__p_TStdIn, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStdOut[] = { {&_swigt__p_TStdOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStopReason[] = { {&_swigt__p_TStopReason, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStr[] = { {&_swigt__p_TStr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrHashF_DJB[] = { {&_swigt__p_TStrHashF_DJB, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrHashF_Md5[] = { {&_swigt__p_TStrHashF_Md5, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrHashF_OldGLib[] = { {&_swigt__p_TStrHashF_OldGLib, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrHashT_TVecT_TInt_int_t_TStrPool_TDefaultHashFuncT_TStr_t_t[] = { {&_swigt__p_TStrHashT_TVecT_TInt_int_t_TStrPool_TDefaultHashFuncT_TStr_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrIn[] = { {&_swigt__p_TStrIn, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrIntPrH__TIter[] = { {&_swigt__p_TStrIntPrH__TIter, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrPool[] = { {&_swigt__p_TStrPool, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrPool64[] = { {&_swigt__p_TStrPool64, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrUtil[] = { {&_swigt__p_TStrUtil, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TStrV__TIter[] = { {&_swigt__p_TStrV__TIter, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTreeT_TFlt_t[] = { {&_swigt__p_TTreeT_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTreeT_TInt_t[] = { {&_swigt__p_TTreeT_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTreeT_TPairT_TStr_TInt_t_t[] = { {&_swigt__p_TTreeT_TPairT_TStr_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTreeT_TStr_t[] = { {&_swigt__p_TTreeT_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTreeT_TTripleT_TStr_TInt_TVecT_TStr_int_t_t_t[] = { {&_swigt__p_TTreeT_TTripleT_TStr_TInt_TVecT_TStr_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TChA_TChA_TChA_t[] = { {&_swigt__p_TTripleT_TChA_TChA_TChA_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TCh_TCh_TCh_t[] = { {&_swigt__p_TTripleT_TCh_TCh_TCh_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TCh_TInt_TInt_t[] = { {&_swigt__p_TTripleT_TCh_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TFlt_TFlt_TFlt_t[] = { {&_swigt__p_TTripleT_TFlt_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TFlt_TFlt_TInt_t[] = { {&_swigt__p_TTripleT_TFlt_TFlt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TFlt_TFlt_TStr_t[] = { {&_swigt__p_TTripleT_TFlt_TFlt_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TFlt_TInt_TInt_t[] = { {&_swigt__p_TTripleT_TFlt_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TFlt_TFlt_t[] = { {&_swigt__p_TTripleT_TInt_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TFlt_TInt_t[] = { {&_swigt__p_TTripleT_TInt_TFlt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TInt_TFlt_t[] = { {&_swigt__p_TTripleT_TInt_TInt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TInt_TInt_t[] = { {&_swigt__p_TTripleT_TInt_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TInt_TStr_t[] = { {&_swigt__p_TTripleT_TInt_TInt_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TInt_TVecT_TInt_int_t_t[] = { {&_swigt__p_TTripleT_TInt_TInt_TVecT_TInt_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TStr_TInt_t[] = { {&_swigt__p_TTripleT_TInt_TStr_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TInt_TVecT_TInt_int_t_TInt_t[] = { {&_swigt__p_TTripleT_TInt_TVecT_TInt_int_t_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TStr_TFlt_TFlt_t[] = { {&_swigt__p_TTripleT_TStr_TFlt_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TStr_TInt_TInt_t[] = { {&_swigt__p_TTripleT_TStr_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TStr_TInt_TVecT_TStr_int_t_t[] = { {&_swigt__p_TTripleT_TStr_TInt_TVecT_TStr_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TStr_TStr_TInt_t[] = { {&_swigt__p_TTripleT_TStr_TStr_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TStr_TStr_TStr_t[] = { {&_swigt__p_TTripleT_TStr_TStr_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TUCh_TInt_TInt_t[] = { {&_swigt__p_TTripleT_TUCh_TInt_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TTripleT_TUInt64_TUInt64_TUInt64_t[] = { {&_swigt__p_TTripleT_TUInt64_TUInt64_TUInt64_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUCh[] = { {&_swigt__p_TUCh, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUInt[] = { {&_swigt__p_TUInt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUInt64[] = { {&_swigt__p_TUInt64, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUNGraph[] = { {&_swigt__p_TUNGraph, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUNGraphEdgeI[] = { {&_swigt__p_TUNGraphEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUNGraphMtx[] = { {&_swigt__p_TUNGraphMtx, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUNGraphNodeI[] = { {&_swigt__p_TUNGraphNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUNGraph__TEdgeI[] = { {&_swigt__p_TUNGraph__TEdgeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUNGraph__TNode[] = { {&_swigt__p_TUNGraph__TNode, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUNGraph__TNodeI[] = { {&_swigt__p_TUNGraph__TNodeI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TUndirFFire[] = { {&_swigt__p_TUndirFFire, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVVecT_TFlt_t[] = { {&_swigt__p_TVVVecT_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVVecT_TInt_t[] = { {&_swigt__p_TVVVecT_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVecT_TBool_t[] = { {&_swigt__p_TVVecT_TBool_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVecT_TCh_t[] = { {&_swigt__p_TVVecT_TCh_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVecT_TFlt_t[] = { {&_swigt__p_TVVecT_TFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVecT_TInt_t[] = { {&_swigt__p_TVVecT_TInt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVecT_TPairT_TInt_TInt_t_t[] = { {&_swigt__p_TVVecT_TPairT_TInt_TInt_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVecT_TSFlt_t[] = { {&_swigt__p_TVVecT_TSFlt_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVVecT_TStr_t[] = { {&_swigt__p_TVVecT_TStr_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVal[] = { {&_swigt__p_TVal, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecPoolT_TInt_int_t[] = { {&_swigt__p_TVecPoolT_TInt_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TAscFlt_int_t[] = { {&_swigt__p_TVecT_TAscFlt_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TBool_int_t[] = { {&_swigt__p_TVecT_TBool_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TChA_int_t[] = { {&_swigt__p_TVecT_TChA_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TCh_int_t[] = { {&_swigt__p_TVecT_TCh_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TCnCom_int_t[] = { {&_swigt__p_TVecT_TCnCom_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TFlt_int_t[] = { {&_swigt__p_TVecT_TFlt_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TInt_int_t[] = { {&_swigt__p_TVecT_TInt_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TAscFlt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TAscFlt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TFlt_TBool_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TFlt_TBool_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TFlt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TFlt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TFlt_TStr_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TFlt_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TFlt_TUInt64_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TFlt_TUInt64_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TInt_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TInt_TStr_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TInt_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TInt_TUInt64_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TInt_TUInt64_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TStr_TAscFlt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TStr_TAscFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TStr_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TStr_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TStr_TInt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TStr_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TStr_TStr_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TStr_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TUInt64_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TUInt64_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TUInt64_TInt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TUInt64_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TUInt64_TStr_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TUInt64_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TUInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TUInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t[] = { {&_swigt__p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TAscFlt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TAscFlt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TAscFlt_TStr_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TAscFlt_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TFlt_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TFlt_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TFlt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TFlt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TFlt_TPairT_TStr_TStr_t_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TFlt_TPairT_TStr_TStr_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TFlt_TStr_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TFlt_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TFlt_TUInt64_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TFlt_TUInt64_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TPairT_TInt_TInt_t_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TPairT_TInt_TInt_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TPairT_TStr_TStr_t_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TPairT_TStr_TStr_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TStr_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TUInt64_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TUInt64_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TInt_TVecT_TStr_int_t_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TInt_TVecT_TStr_int_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TStr_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TStr_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TStr_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TStr_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TStr_TStr_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TStr_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TStr_TVecT_TStr_int_t_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TStr_TVecT_TStr_int_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TUCh_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TUCh_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TUCh_TUInt64_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TUCh_TUInt64_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TUInt64_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TUInt64_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TUInt64_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TUInt64_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TUInt64_TStr_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TUInt64_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPairT_TVecT_TStr_int_t_TInt_t_int_t[] = { {&_swigt__p_TVecT_TPairT_TVecT_TStr_int_t_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TPtT_TNGraph_t_int_t[] = { {&_swigt__p_TVecT_TPtT_TNGraph_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TQQueueT_TInt_t_int_t[] = { {&_swigt__p_TVecT_TQQueueT_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TQuadT_TFlt_TInt_TInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TQuadT_TFlt_TInt_TInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TQuadT_TInt_TInt_TInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TQuadT_TInt_TInt_TInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TQuadT_TInt_TStr_TInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TQuadT_TInt_TStr_TInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TQuadT_TStr_TStr_TStr_TStr_t_int_t[] = { {&_swigt__p_TVecT_TQuadT_TStr_TStr_TStr_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TSFlt_int_t[] = { {&_swigt__p_TVecT_TSFlt_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TStr_int_t[] = { {&_swigt__p_TVecT_TStr_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TFlt_TFlt_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TFlt_TFlt_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TFlt_TFlt_TStr_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TFlt_TFlt_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TFlt_TInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TFlt_TInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TInt_TFlt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TInt_TFlt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TInt_TInt_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TInt_TInt_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TInt_TInt_TStr_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TInt_TInt_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TInt_TInt_TVecT_TInt_int_t_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TInt_TInt_TVecT_TInt_int_t_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TInt_TStr_TInt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TInt_TStr_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TInt_TVecT_TInt_int_t_TInt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TInt_TVecT_TInt_int_t_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TStr_TFlt_TFlt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TStr_TFlt_TFlt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TStr_TStr_TInt_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TStr_TStr_TInt_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TTripleT_TStr_TStr_TStr_t_int_t[] = { {&_swigt__p_TVecT_TTripleT_TStr_TStr_TStr_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TUCh_int_t[] = { {&_swigt__p_TVecT_TUCh_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TUInt64_int_t[] = { {&_swigt__p_TVecT_TUInt64_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TUInt_int_t[] = { {&_swigt__p_TVecT_TUInt_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TVal_TSizeTy_t[] = { {&_swigt__p_TVecT_TVal_TSizeTy_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TVecT_TFlt_int_t_int_t[] = { {&_swigt__p_TVecT_TVecT_TFlt_int_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_TVecT_TInt_int_t_int_t[] = { {&_swigt__p_TVecT_TVecT_TInt_int_t_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVecT_char_p_int_t[] = { {&_swigt__p_TVecT_char_p_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TVoid[] = { {&_swigt__p_TVoid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_TXmlLx[] = { {&_swigt__p_TXmlLx, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_r_TSOut__r_TStdOut[] = {{&_swigt__p_f_r_TSOut__r_TStdOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_r_TSOut__r_TMemOut[] = {{&_swigt__p_f_r_TSOut__r_TMemOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_r_TSOut__r_TFInOut[] = {{&_swigt__p_f_r_TSOut__r_TFInOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_r_TSOut__r_TFOut[] = {{&_swigt__p_f_r_TSOut__r_TFOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_r_TSOut__r_TMOut[] = {{&_swigt__p_f_r_TSOut__r_TMOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_r_TSOut__r_TSInOut[] = {{&_swigt__p_f_r_TSOut__r_TSInOut, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_r_TSOut__r_TSOut[] = { {&_swigt__p_f_r_TSOut__r_TStdOut, _p_f_r_TSOut__r_TStdOutTo_p_f_r_TSOut__r_TSOut, 0, 0}, {&_swigt__p_f_r_TSOut__r_TMemOut, _p_f_r_TSOut__r_TMemOutTo_p_f_r_TSOut__r_TSOut, 0, 0}, {&_swigt__p_f_r_TSOut__r_TFInOut, _p_f_r_TSOut__r_TFInOutTo_p_f_r_TSOut__r_TSOut, 0, 0}, {&_swigt__p_f_r_TSOut__r_TSOut, 0, 0, 0}, {&_swigt__p_f_r_TSOut__r_TFOut, _p_f_r_TSOut__r_TFOutTo_p_f_r_TSOut__r_TSOut, 0, 0}, {&_swigt__p_f_r_TSOut__r_TMOut, _p_f_r_TSOut__r_TMOutTo_p_f_r_TSOut__r_TSOut, 0, 0}, {&_swigt__p_f_r_TSOut__r_TSInOut, _p_f_r_TSOut__r_TSInOutTo_p_f_r_TSOut__r_TSOut, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_long_double[] = { {&_swigt__p_long_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ptrdiff_t[] = { {&_swigt__p_ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_FILE, + _swigc__p_PGStatVec, + _swigc__p_PGraph, + _swigc__p_PNet, + _swigc__p_PVecT_TAscFlt_t, + _swigc__p_PVecT_TFlt_t, + _swigc__p_PVecT_TStr_t, + _swigc__p_TArtPointVisitor, + _swigc__p_TAscFlt, + _swigc__p_TBPGraph, + _swigc__p_TBPGraph__TEdgeI, + _swigc__p_TBPGraph__TNode, + _swigc__p_TBPGraph__TNodeI, + _swigc__p_TBiConVisitor, + _swigc__p_TBigStrPool, + _swigc__p_TBool, + _swigc__p_TCRef, + _swigc__p_TCh, + _swigc__p_TChA, + _swigc__p_TChAIn, + _swigc__p_TChRet, + _swigc__p_TCnCom, + _swigc__p_TConv_Pt64Ints32, + _swigc__p_TCs, + _swigc__p_TDbStr, + _swigc__p_TFAccess, + _swigc__p_TFIn, + _swigc__p_TFInOut, + _swigc__p_TFOut, + _swigc__p_TFfGGen, + _swigc__p_TFile, + _swigc__p_TFlt, + _swigc__p_TFltRect, + _swigc__p_TFltV__TIter, + _swigc__p_TForestFire, + _swigc__p_TGUtil, + _swigc__p_TGVizLayout_, + _swigc__p_TGraphFlag, + _swigc__p_THKeyDat, + _swigc__p_THashKeyDatIT_TInt_TInt_t, + _swigc__p_THashKeyDatIT_TInt_TVecT_TInt_int_t_t, + _swigc__p_THashKeyDatT_TInt_TInt_t, + _swigc__p_THashT_TCh_TCh_TDefaultHashFuncT_TCh_t_t, + _swigc__p_THashT_TDbStr_TInt_TDefaultHashFuncT_TDbStr_t_t, + _swigc__p_THashT_TDbStr_TStr_TDefaultHashFuncT_TDbStr_t_t, + _swigc__p_THashT_TFlt_TFlt_TDefaultHashFuncT_TFlt_t_t, + _swigc__p_THashT_TInt_TBool_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TFlt_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TInt_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TPairT_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TPairT_TInt_TInt_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TStr_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TTripleT_TFlt_TFlt_TFlt_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TUInt64_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TVecT_TFlt_int_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TVecT_TInt_int_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TInt_TVecT_TStr_int_t_TDefaultHashFuncT_TInt_t_t, + _swigc__p_THashT_TPairT_TInt_TInt_t_TFlt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + _swigc__p_THashT_TPairT_TInt_TInt_t_TInt_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + _swigc__p_THashT_TPairT_TInt_TInt_t_TStr_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + _swigc__p_THashT_TPairT_TInt_TInt_t_TVecT_TInt_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + _swigc__p_THashT_TPairT_TInt_TInt_t_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + _swigc__p_THashT_TPairT_TInt_TInt_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TInt_TInt_t_t_t, + _swigc__p_THashT_TPairT_TInt_TStr_t_TInt_TDefaultHashFuncT_TPairT_TInt_TStr_t_t_t, + _swigc__p_THashT_TPairT_TStr_TInt_t_TInt_TDefaultHashFuncT_TPairT_TStr_TInt_t_t_t, + _swigc__p_THashT_TPairT_TStr_TStr_t_TBool_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + _swigc__p_THashT_TPairT_TStr_TStr_t_TFlt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + _swigc__p_THashT_TPairT_TStr_TStr_t_TInt_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + _swigc__p_THashT_TPairT_TStr_TStr_t_TStr_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + _swigc__p_THashT_TPairT_TStr_TStr_t_TVecT_TStr_int_t_TDefaultHashFuncT_TPairT_TStr_TStr_t_t_t, + _swigc__p_THashT_TStr_TBool_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TFlt_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TInt_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TPairT_TInt_TFlt_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TPairT_TInt_TInt_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TPairT_TStr_TStr_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TStr_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TUInt64_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TFlt_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TInt_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TKeyDatT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TKeyDatT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TPairT_TInt_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TPairT_TStr_TInt_t_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TPairT_TStr_TStr_t_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TStr_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TStr_TVecT_TUInt64_int_t_TDefaultHashFuncT_TStr_t_t, + _swigc__p_THashT_TTripleT_TCh_TCh_TCh_t_TInt_TDefaultHashFuncT_TTripleT_TCh_TCh_TCh_t_t_t, + _swigc__p_THashT_TTripleT_TInt_TInt_TInt_t_TFlt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t, + _swigc__p_THashT_TTripleT_TInt_TInt_TInt_t_TInt_TDefaultHashFuncT_TTripleT_TInt_TInt_TInt_t_t_t, + _swigc__p_THashT_TTripleT_TStr_TStr_TStr_t_TInt_TDefaultHashFuncT_TTripleT_TStr_TStr_TStr_t_t_t, + _swigc__p_THashT_TUInt64_TInt_TDefaultHashFuncT_TUInt64_t_t, + _swigc__p_THashT_TUInt64_TVecT_TStr_int_t_TDefaultHashFuncT_TUInt64_t_t, + _swigc__p_THashT_TUInt_TUInt_TDefaultHashFuncT_TUInt_t_t, + _swigc__p_THashT_TVecT_TInt_int_t_TInt_TDefaultHashFuncT_TVecT_TInt_int_t_t_t, + _swigc__p_THashT_TVecT_TStr_int_t_TInt_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + _swigc__p_THashT_TVecT_TStr_int_t_TStr_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + _swigc__p_THashT_TVecT_TStr_int_t_TVecT_TInt_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + _swigc__p_THashT_TVecT_TStr_int_t_TVecT_TStr_int_t_TDefaultHashFuncT_TVecT_TStr_int_t_t_t, + _swigc__p_TILx, + _swigc__p_TInt, + _swigc__p_TIntSet, + _swigc__p_TIntV__TIter, + _swigc__p_TIter, + _swigc__p_TKeyDatT_TAscFlt_TInt_t, + _swigc__p_TKeyDatT_TFlt_TBool_t, + _swigc__p_TKeyDatT_TFlt_TFlt_t, + _swigc__p_TKeyDatT_TFlt_TInt_t, + _swigc__p_TKeyDatT_TFlt_TPairT_TInt_TBool_t_t, + _swigc__p_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t, + _swigc__p_TKeyDatT_TFlt_TStr_t, + _swigc__p_TKeyDatT_TFlt_TUInt64_t, + _swigc__p_TKeyDatT_TFlt_TUInt_t, + _swigc__p_TKeyDatT_TInt_TFlt_t, + _swigc__p_TKeyDatT_TInt_TInt_t, + _swigc__p_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t, + _swigc__p_TKeyDatT_TInt_TSFlt_t, + _swigc__p_TKeyDatT_TInt_TStr_t, + _swigc__p_TKeyDatT_TInt_TUInt64_t, + _swigc__p_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t, + _swigc__p_TKeyDatT_TStr_TAscFlt_t, + _swigc__p_TKeyDatT_TStr_TBool_t, + _swigc__p_TKeyDatT_TStr_TFlt_t, + _swigc__p_TKeyDatT_TStr_TInt_t, + _swigc__p_TKeyDatT_TStr_TStr_t, + _swigc__p_TKeyDatT_TUInt64_TFlt_t, + _swigc__p_TKeyDatT_TUInt64_TInt_t, + _swigc__p_TKeyDatT_TUInt64_TStr_t, + _swigc__p_TKeyDatT_TUInt_TInt_t, + _swigc__p_TKeyDatT_TUInt_TUInt_t, + _swigc__p_TLFlt, + _swigc__p_TLnRet, + _swigc__p_TLoc, + _swigc__p_TLogOp, + _swigc__p_TLstT_TFlt_t, + _swigc__p_TLstT_TInt_t, + _swigc__p_TLstT_TKeyDatT_TAscFlt_TInt_t_t, + _swigc__p_TLstT_TKeyDatT_TFlt_TInt_t_t, + _swigc__p_TLstT_TKeyDatT_TInt_TInt_t_t, + _swigc__p_TLstT_TStr_t, + _swigc__p_TMIn, + _swigc__p_TMOut, + _swigc__p_TMem, + _swigc__p_TMemIn, + _swigc__p_TMemOut, + _swigc__p_TNEANet, + _swigc__p_TNEANetAFltI, + _swigc__p_TNEANetAIntI, + _swigc__p_TNEANetAStrI, + _swigc__p_TNEANetEdgeI, + _swigc__p_TNEANetNodeI, + _swigc__p_TNEANet__TAFltI, + _swigc__p_TNEANet__TAIntI, + _swigc__p_TNEANet__TAStrI, + _swigc__p_TNEANet__TEdgeI, + _swigc__p_TNEANet__TNode, + _swigc__p_TNEANet__TNodeI, + _swigc__p_TNEGraph, + _swigc__p_TNEGraph__TEdgeI, + _swigc__p_TNEGraph__TNode, + _swigc__p_TNEGraph__TNodeI, + _swigc__p_TNGraph, + _swigc__p_TNGraphEdgeI, + _swigc__p_TNGraphMtx, + _swigc__p_TNGraphNodeI, + _swigc__p_TNGraph__TEdgeI, + _swigc__p_TNGraph__TNode, + _swigc__p_TNGraph__TNodeI, + _swigc__p_TNet, + _swigc__p_TNodeEDatNetT_TInt_TFlt_t, + _swigc__p_TNodeEDatNetT_TInt_TInt_t, + _swigc__p_TNodeEDatNetT_TStr_TInt_t, + _swigc__p_TNodeEdgeNetT_TFlt_TFlt_t, + _swigc__p_TNodeEdgeNetT_TInt_TInt_t, + _swigc__p_TNodeNetT_TFlt_t, + _swigc__p_TNodeNetT_TInt_t, + _swigc__p_TNodeNetT_TStr_t, + _swigc__p_TNodeTy, + _swigc__p_TOLx, + _swigc__p_TObj, + _swigc__p_TPairHashImpl1, + _swigc__p_TPairHashImpl2, + _swigc__p_TPairT_TAscFlt_TAscFlt_t, + _swigc__p_TPairT_TAscFlt_TInt_t, + _swigc__p_TPairT_TAscFlt_TStr_t, + _swigc__p_TPairT_TBool_TCh_t, + _swigc__p_TPairT_TBool_TFlt_t, + _swigc__p_TPairT_TFlt_TFlt_t, + _swigc__p_TPairT_TFlt_TInt_t, + _swigc__p_TPairT_TFlt_TPairT_TStr_TStr_t_t, + _swigc__p_TPairT_TFlt_TStr_t, + _swigc__p_TPairT_TFlt_TUInt64_t, + _swigc__p_TPairT_TInt_TBool_t, + _swigc__p_TPairT_TInt_TCh_t, + _swigc__p_TPairT_TInt_TFlt_t, + _swigc__p_TPairT_TInt_TInt_t, + _swigc__p_TPairT_TInt_TPairT_TInt_TInt_t_t, + _swigc__p_TPairT_TInt_TPairT_TStr_TStr_t_t, + _swigc__p_TPairT_TInt_TStr_t, + _swigc__p_TPairT_TInt_TUInt64_t, + _swigc__p_TPairT_TInt_TVecT_TInt_int_t_t, + _swigc__p_TPairT_TInt_TVecT_TStr_int_t_t, + _swigc__p_TPairT_TPairT_TInt_TInt_t_TInt_t, + _swigc__p_TPairT_TStr_TFlt_t, + _swigc__p_TPairT_TStr_TInt_t, + _swigc__p_TPairT_TStr_TStr_t, + _swigc__p_TPairT_TStr_TVecT_TStr_int_t_t, + _swigc__p_TPairT_TUCh_TInt_t, + _swigc__p_TPairT_TUCh_TStr_t, + _swigc__p_TPairT_TUCh_TUInt64_t, + _swigc__p_TPairT_TUInt64_TFlt_t, + _swigc__p_TPairT_TUInt64_TInt_t, + _swigc__p_TPairT_TUInt64_TStr_t, + _swigc__p_TPairT_TUInt64_TUInt64_t, + _swigc__p_TPairT_TUInt_TInt_t, + _swigc__p_TPairT_TUInt_TUInt_t, + _swigc__p_TPairT_TVecT_TStr_int_t_TInt_t, + _swigc__p_TPtT_PVecT_TAscFlt_t_t, + _swigc__p_TPtT_PVecT_TFlt_t_t, + _swigc__p_TPtT_PVecT_TStr_t_t, + _swigc__p_TPtT_TBPGraph_t, + _swigc__p_TPtT_TBigStrPool_t, + _swigc__p_TPtT_TExcept_t, + _swigc__p_TPtT_TFRnd_t, + _swigc__p_TPtT_TMem_t, + _swigc__p_TPtT_TNEANet_t, + _swigc__p_TPtT_TNEGraph_t, + _swigc__p_TPtT_TNGraph_t, + _swigc__p_TPtT_TNodeEDatNetT_TInt_TFlt_t_t, + _swigc__p_TPtT_TNodeEDatNetT_TInt_TInt_t_t, + _swigc__p_TPtT_TNodeEDatNetT_TStr_TInt_t_t, + _swigc__p_TPtT_TNodeEdgeNetT_TFlt_TFlt_t_t, + _swigc__p_TPtT_TNodeEdgeNetT_TInt_TInt_t_t, + _swigc__p_TPtT_TNodeNetT_TFlt_t_t, + _swigc__p_TPtT_TNodeNetT_TInt_t_t, + _swigc__p_TPtT_TNodeNetT_TStr_t_t, + _swigc__p_TPtT_TSInOut_t, + _swigc__p_TPtT_TSIn_t, + _swigc__p_TPtT_TSOut_t, + _swigc__p_TPtT_TStrPool64_t, + _swigc__p_TPtT_TStrPool_t, + _swigc__p_TPtT_TUNGraph_t, + _swigc__p_TPtT_TVecPoolT_TInt_int_t_t, + _swigc__p_TPtT_TXmlDoc_t, + _swigc__p_TPtT_TXmlTok_t, + _swigc__p_TQQueueT_TFlt_t, + _swigc__p_TQQueueT_TInt_t, + _swigc__p_TQQueueT_TPairT_TInt_TInt_t_t, + _swigc__p_TQQueueT_TPairT_TInt_TStr_t_t, + _swigc__p_TQQueueT_TStr_t, + _swigc__p_TQQueueT_TVecT_TAscFlt_int_t_t, + _swigc__p_TQQueueT_TVecT_TFlt_int_t_t, + _swigc__p_TQuadT_TFlt_TFlt_TFlt_TFlt_t, + _swigc__p_TQuadT_TFlt_TInt_TInt_TInt_t, + _swigc__p_TQuadT_TInt_TInt_TFlt_TFlt_t, + _swigc__p_TQuadT_TInt_TInt_TInt_TInt_t, + _swigc__p_TQuadT_TInt_TStr_TInt_TInt_t, + _swigc__p_TQuadT_TStr_TStr_TInt_TInt_t, + _swigc__p_TQuadT_TStr_TStr_TStr_TStr_t, + _swigc__p_TRStr, + _swigc__p_TRelOp, + _swigc__p_TRnd, + _swigc__p_TSBase, + _swigc__p_TSFlt, + _swigc__p_TSIn, + _swigc__p_TSInOut, + _swigc__p_TSInt, + _swigc__p_TSOut, + _swigc__p_TSOutMnp, + _swigc__p_TSStackT_TInt_t, + _swigc__p_TSStackT_TPairT_TBool_TCh_t_t, + _swigc__p_TSStackT_TPairT_TInt_TInt_t_t, + _swigc__p_TSStr, + _swigc__p_TSecTm, + _swigc__p_TSizeTy, + _swigc__p_TStdIn, + _swigc__p_TStdOut, + _swigc__p_TStopReason, + _swigc__p_TStr, + _swigc__p_TStrHashF_DJB, + _swigc__p_TStrHashF_Md5, + _swigc__p_TStrHashF_OldGLib, + _swigc__p_TStrHashT_TInt_TStrPool_TDefaultHashFuncT_TStr_t_t, + _swigc__p_TStrHashT_TVecT_TInt_int_t_TStrPool_TDefaultHashFuncT_TStr_t_t, + _swigc__p_TStrIn, + _swigc__p_TStrIntPrH__TIter, + _swigc__p_TStrPool, + _swigc__p_TStrPool64, + _swigc__p_TStrUtil, + _swigc__p_TStrV__TIter, + _swigc__p_TTreeT_TFlt_t, + _swigc__p_TTreeT_TInt_t, + _swigc__p_TTreeT_TPairT_TStr_TInt_t_t, + _swigc__p_TTreeT_TStr_t, + _swigc__p_TTreeT_TTripleT_TStr_TInt_TVecT_TStr_int_t_t_t, + _swigc__p_TTripleT_TChA_TChA_TChA_t, + _swigc__p_TTripleT_TCh_TCh_TCh_t, + _swigc__p_TTripleT_TCh_TInt_TInt_t, + _swigc__p_TTripleT_TFlt_TFlt_TFlt_t, + _swigc__p_TTripleT_TFlt_TFlt_TInt_t, + _swigc__p_TTripleT_TFlt_TFlt_TStr_t, + _swigc__p_TTripleT_TFlt_TInt_TInt_t, + _swigc__p_TTripleT_TInt_TFlt_TFlt_t, + _swigc__p_TTripleT_TInt_TFlt_TInt_t, + _swigc__p_TTripleT_TInt_TInt_TFlt_t, + _swigc__p_TTripleT_TInt_TInt_TInt_t, + _swigc__p_TTripleT_TInt_TInt_TStr_t, + _swigc__p_TTripleT_TInt_TInt_TVecT_TInt_int_t_t, + _swigc__p_TTripleT_TInt_TStr_TInt_t, + _swigc__p_TTripleT_TInt_TVecT_TInt_int_t_TInt_t, + _swigc__p_TTripleT_TStr_TFlt_TFlt_t, + _swigc__p_TTripleT_TStr_TInt_TInt_t, + _swigc__p_TTripleT_TStr_TInt_TVecT_TStr_int_t_t, + _swigc__p_TTripleT_TStr_TStr_TInt_t, + _swigc__p_TTripleT_TStr_TStr_TStr_t, + _swigc__p_TTripleT_TUCh_TInt_TInt_t, + _swigc__p_TTripleT_TUInt64_TUInt64_TUInt64_t, + _swigc__p_TUCh, + _swigc__p_TUInt, + _swigc__p_TUInt64, + _swigc__p_TUNGraph, + _swigc__p_TUNGraphEdgeI, + _swigc__p_TUNGraphMtx, + _swigc__p_TUNGraphNodeI, + _swigc__p_TUNGraph__TEdgeI, + _swigc__p_TUNGraph__TNode, + _swigc__p_TUNGraph__TNodeI, + _swigc__p_TUndirFFire, + _swigc__p_TVVVecT_TFlt_t, + _swigc__p_TVVVecT_TInt_t, + _swigc__p_TVVecT_TBool_t, + _swigc__p_TVVecT_TCh_t, + _swigc__p_TVVecT_TFlt_t, + _swigc__p_TVVecT_TInt_t, + _swigc__p_TVVecT_TPairT_TInt_TInt_t_t, + _swigc__p_TVVecT_TSFlt_t, + _swigc__p_TVVecT_TStr_t, + _swigc__p_TVal, + _swigc__p_TVecPoolT_TInt_int_t, + _swigc__p_TVecT_TAscFlt_int_t, + _swigc__p_TVecT_TBool_int_t, + _swigc__p_TVecT_TChA_int_t, + _swigc__p_TVecT_TCh_int_t, + _swigc__p_TVecT_TCnCom_int_t, + _swigc__p_TVecT_TFlt_int_t, + _swigc__p_TVecT_TInt_int_t, + _swigc__p_TVecT_TKeyDatT_TAscFlt_TInt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TFlt_TBool_t_int_t, + _swigc__p_TVecT_TKeyDatT_TFlt_TFlt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TFlt_TInt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TFlt_TPairT_TInt_TInt_t_t_int_t, + _swigc__p_TVecT_TKeyDatT_TFlt_TStr_t_int_t, + _swigc__p_TVecT_TKeyDatT_TFlt_TUInt64_t_int_t, + _swigc__p_TVecT_TKeyDatT_TInt_TFlt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TInt_TInt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TInt_TPairT_TFlt_TFlt_t_t_int_t, + _swigc__p_TVecT_TKeyDatT_TInt_TStr_t_int_t, + _swigc__p_TVecT_TKeyDatT_TInt_TUInt64_t_int_t, + _swigc__p_TVecT_TKeyDatT_TInt_TVecT_TInt_int_t_t_int_t, + _swigc__p_TVecT_TKeyDatT_TPairT_TInt_TInt_t_TFlt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TStr_TAscFlt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TStr_TFlt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TStr_TInt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TStr_TStr_t_int_t, + _swigc__p_TVecT_TKeyDatT_TUInt64_TFlt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TUInt64_TInt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TUInt64_TStr_t_int_t, + _swigc__p_TVecT_TKeyDatT_TUInt_TInt_t_int_t, + _swigc__p_TVecT_TKeyDatT_TVecT_TInt_int_t_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TAscFlt_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TAscFlt_TStr_t_int_t, + _swigc__p_TVecT_TPairT_TFlt_TFlt_t_int_t, + _swigc__p_TVecT_TPairT_TFlt_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TFlt_TPairT_TStr_TStr_t_t_int_t, + _swigc__p_TVecT_TPairT_TFlt_TStr_t_int_t, + _swigc__p_TVecT_TPairT_TFlt_TUInt64_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TFlt_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TPairT_TInt_TInt_t_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TPairT_TStr_TStr_t_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TStr_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TUInt64_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TVecT_TInt_int_t_t_int_t, + _swigc__p_TVecT_TPairT_TInt_TVecT_TStr_int_t_t_int_t, + _swigc__p_TVecT_TPairT_TStr_TFlt_t_int_t, + _swigc__p_TVecT_TPairT_TStr_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TStr_TStr_t_int_t, + _swigc__p_TVecT_TPairT_TStr_TVecT_TStr_int_t_t_int_t, + _swigc__p_TVecT_TPairT_TUCh_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TUCh_TUInt64_t_int_t, + _swigc__p_TVecT_TPairT_TUInt64_TFlt_t_int_t, + _swigc__p_TVecT_TPairT_TUInt64_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TUInt64_TStr_t_int_t, + _swigc__p_TVecT_TPairT_TVecT_TInt_int_t_TInt_t_int_t, + _swigc__p_TVecT_TPairT_TVecT_TStr_int_t_TInt_t_int_t, + _swigc__p_TVecT_TPtT_TNGraph_t_int_t, + _swigc__p_TVecT_TQQueueT_TInt_t_int_t, + _swigc__p_TVecT_TQuadT_TFlt_TInt_TInt_TInt_t_int_t, + _swigc__p_TVecT_TQuadT_TInt_TInt_TInt_TInt_t_int_t, + _swigc__p_TVecT_TQuadT_TInt_TStr_TInt_TInt_t_int_t, + _swigc__p_TVecT_TQuadT_TStr_TStr_TStr_TStr_t_int_t, + _swigc__p_TVecT_TSFlt_int_t, + _swigc__p_TVecT_TStr_int_t, + _swigc__p_TVecT_TTripleT_TFlt_TFlt_TFlt_t_int_t, + _swigc__p_TVecT_TTripleT_TFlt_TFlt_TStr_t_int_t, + _swigc__p_TVecT_TTripleT_TFlt_TInt_TInt_t_int_t, + _swigc__p_TVecT_TTripleT_TInt_TFlt_TInt_t_int_t, + _swigc__p_TVecT_TTripleT_TInt_TInt_TFlt_t_int_t, + _swigc__p_TVecT_TTripleT_TInt_TInt_TInt_t_int_t, + _swigc__p_TVecT_TTripleT_TInt_TInt_TStr_t_int_t, + _swigc__p_TVecT_TTripleT_TInt_TInt_TVecT_TInt_int_t_t_int_t, + _swigc__p_TVecT_TTripleT_TInt_TStr_TInt_t_int_t, + _swigc__p_TVecT_TTripleT_TInt_TVecT_TInt_int_t_TInt_t_int_t, + _swigc__p_TVecT_TTripleT_TStr_TFlt_TFlt_t_int_t, + _swigc__p_TVecT_TTripleT_TStr_TStr_TInt_t_int_t, + _swigc__p_TVecT_TTripleT_TStr_TStr_TStr_t_int_t, + _swigc__p_TVecT_TUCh_int_t, + _swigc__p_TVecT_TUInt64_int_t, + _swigc__p_TVecT_TUInt_int_t, + _swigc__p_TVecT_TVal_TSizeTy_t, + _swigc__p_TVecT_TVecT_TFlt_int_t_int_t, + _swigc__p_TVecT_TVecT_TInt_int_t_int_t, + _swigc__p_TVecT_char_p_int_t, + _swigc__p_TVoid, + _swigc__p_TXmlLx, + _swigc__p_bool, + _swigc__p_char, + _swigc__p_double, + _swigc__p_f_r_TSOut__r_TFInOut, + _swigc__p_f_r_TSOut__r_TFOut, + _swigc__p_f_r_TSOut__r_TMOut, + _swigc__p_f_r_TSOut__r_TMemOut, + _swigc__p_f_r_TSOut__r_TSInOut, + _swigc__p_f_r_TSOut__r_TSOut, + _swigc__p_f_r_TSOut__r_TStdOut, + _swigc__p_float, + _swigc__p_int, + _swigc__p_long_double, + _swigc__p_long_long, + _swigc__p_p_char, + _swigc__p_ptrdiff_t, + _swigc__p_short, + _swigc__p_size_t, + _swigc__p_unsigned_char, + _swigc__p_unsigned_int, + _swigc__p_unsigned_long, + _swigc__p_unsigned_long_long, + _swigc__p_unsigned_short, + _swigc__p_void, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned staticly to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int found, init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + module_head = &swig_module; + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + found=0; + iter=module_head; + do { + if (iter==&swig_module) { + found=1; + break; + } + iter=iter->next; + } while (iter!= module_head); + + /* if the is found in the list, then all is done and we may leave */ + if (found) return; + /* otherwise we must add out module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpeters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %d\n", swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; + } + + SWIGINTERN int + swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { + char *tmp; + PyObject *str = swig_varlink_str(v); + fprintf(fp,"Swig global variables "); + fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(str); + return 0; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { + /* PyObject header changed in Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + (char *)"swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ + (printfunc) swig_varlink_print, /* tp_print */ + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#if PY_VERSION_HEX >= 0x02060000 + 0, /* tp_version */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; +#if PY_VERSION_HEX < 0x02020000 + varlink_type.ob_type = &PyType_Type; +#else + if (PyType_Ready(&varlink_type) < 0) + return NULL; +#endif + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + strncpy(gv->name,name,size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *_SWIG_globals = 0; + if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); + return _SWIG_globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (c && (c = strstr(c, "swig_ptr: "))) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + strncpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + strncpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md; +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { +# if PY_VERSION_HEX >= 0x03020000 + PyModuleDef_HEAD_INIT, +# else + { + PyObject_HEAD_INIT(NULL) + NULL, /* m_init */ + 0, /* m_index */ + NULL, /* m_copy */ + }, +# endif + (char *) SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + (PyCFunction) SwigPyObject_own, + (PyCFunction) SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyObject *metatype_args; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + + /* metatype is used to implement static member variables. */ + metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type); + assert(metatype_args); + metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL); + assert(metatype); + Py_DECREF(metatype_args); + metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro; + assert(PyType_Ready(metatype) >= 0); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule((char *) SWIG_name, SwigMethods); +#endif + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce(); + } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + SWIG_Python_SetConstant(d, "lUndef",SWIG_From_int(static_cast< int >(lUndef))); + SWIG_Python_SetConstant(d, "lUs",SWIG_From_int(static_cast< int >(lUs))); + SWIG_Python_SetConstant(d, "lSi",SWIG_From_int(static_cast< int >(lSi))); + SWIG_Python_SetConstant(d, "loUndef",SWIG_From_int(static_cast< int >(loUndef))); + SWIG_Python_SetConstant(d, "loNot",SWIG_From_int(static_cast< int >(loNot))); + SWIG_Python_SetConstant(d, "loAnd",SWIG_From_int(static_cast< int >(loAnd))); + SWIG_Python_SetConstant(d, "loOr",SWIG_From_int(static_cast< int >(loOr))); + SWIG_Python_SetConstant(d, "roUndef",SWIG_From_int(static_cast< int >(roUndef))); + SWIG_Python_SetConstant(d, "roLs",SWIG_From_int(static_cast< int >(roLs))); + SWIG_Python_SetConstant(d, "roLEq",SWIG_From_int(static_cast< int >(roLEq))); + SWIG_Python_SetConstant(d, "roEq",SWIG_From_int(static_cast< int >(roEq))); + SWIG_Python_SetConstant(d, "roNEq",SWIG_From_int(static_cast< int >(roNEq))); + SWIG_Python_SetConstant(d, "roGEq",SWIG_From_int(static_cast< int >(roGEq))); + SWIG_Python_SetConstant(d, "roGt",SWIG_From_int(static_cast< int >(roGt))); + SWIG_Python_SetConstant(d, "TFfGGen_srUndef",SWIG_From_int(static_cast< int >(TFfGGen::srUndef))); + SWIG_Python_SetConstant(d, "TFfGGen_srOk",SWIG_From_int(static_cast< int >(TFfGGen::srOk))); + SWIG_Python_SetConstant(d, "TFfGGen_srFlood",SWIG_From_int(static_cast< int >(TFfGGen::srFlood))); + SWIG_Python_SetConstant(d, "TFfGGen_srTimeLimit",SWIG_From_int(static_cast< int >(TFfGGen::srTimeLimit))); + PyDict_SetItemString(md,(char*)"cvar", SWIG_globals()); + SWIG_addvarlink(SWIG_globals(),(char*)"TFfGGen_TimeLimitSec",Swig_var_TFfGGen_TimeLimitSec_get, Swig_var_TFfGGen_TimeLimitSec_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TSIn_StdIn",Swig_var_TSIn_StdIn_get, Swig_var_TSIn_StdIn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TSOut_StdOut",Swig_var_TSOut_StdOut_get, Swig_var_TSOut_StdOut_set); + SWIG_Python_SetConstant(d, "faUndef",SWIG_From_int(static_cast< int >(faUndef))); + SWIG_Python_SetConstant(d, "faCreate",SWIG_From_int(static_cast< int >(faCreate))); + SWIG_Python_SetConstant(d, "faUpdate",SWIG_From_int(static_cast< int >(faUpdate))); + SWIG_Python_SetConstant(d, "faAppend",SWIG_From_int(static_cast< int >(faAppend))); + SWIG_Python_SetConstant(d, "faRdOnly",SWIG_From_int(static_cast< int >(faRdOnly))); + SWIG_Python_SetConstant(d, "faRestore",SWIG_From_int(static_cast< int >(faRestore))); + SWIG_addvarlink(SWIG_globals(),(char*)"TFile_TxtFExt",Swig_var_TFile_TxtFExt_get, Swig_var_TFile_TxtFExt_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFile_HtmlFExt",Swig_var_TFile_HtmlFExt_get, Swig_var_TFile_HtmlFExt_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFile_HtmFExt",Swig_var_TFile_HtmFExt_get, Swig_var_TFile_HtmFExt_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFile_GifFExt",Swig_var_TFile_GifFExt_get, Swig_var_TFile_GifFExt_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFile_JarFExt",Swig_var_TFile_JarFExt_get, Swig_var_TFile_JarFExt_set); + SWIG_Python_SetConstant(d, "TBPGraph_bgsUndef",SWIG_From_int(static_cast< int >(TBPGraph::bgsUndef))); + SWIG_Python_SetConstant(d, "TBPGraph_bgsLeft",SWIG_From_int(static_cast< int >(TBPGraph::bgsLeft))); + SWIG_Python_SetConstant(d, "TBPGraph_bgsRight",SWIG_From_int(static_cast< int >(TBPGraph::bgsRight))); + SWIG_Python_SetConstant(d, "TBPGraph_bgsBoth",SWIG_From_int(static_cast< int >(TBPGraph::bgsBoth))); + SWIG_Python_SetConstant(d, "gvlDot",SWIG_From_int(static_cast< int >(gvlDot))); + SWIG_Python_SetConstant(d, "gvlNeato",SWIG_From_int(static_cast< int >(gvlNeato))); + SWIG_Python_SetConstant(d, "gvlTwopi",SWIG_From_int(static_cast< int >(gvlTwopi))); + SWIG_Python_SetConstant(d, "gvlCirco",SWIG_From_int(static_cast< int >(gvlCirco))); + SWIG_addvarlink(SWIG_globals(),(char*)"TRnd_RndSeed",Swig_var_TRnd_RndSeed_get, Swig_var_TRnd_RndSeed_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_Mn",Swig_var_TBool_Mn_get, Swig_var_TBool_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_Mx",Swig_var_TBool_Mx_get, Swig_var_TBool_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_Vals",Swig_var_TBool_Vals_get, Swig_var_TBool_Vals_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_Rnd",Swig_var_TBool_Rnd_get, Swig_var_TBool_Rnd_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_FalseStr",Swig_var_TBool_FalseStr_get, Swig_var_TBool_FalseStr_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_TrueStr",Swig_var_TBool_TrueStr_get, Swig_var_TBool_TrueStr_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_NStr",Swig_var_TBool_NStr_get, Swig_var_TBool_NStr_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_YStr",Swig_var_TBool_YStr_get, Swig_var_TBool_YStr_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_NoStr",Swig_var_TBool_NoStr_get, Swig_var_TBool_NoStr_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TBool_YesStr",Swig_var_TBool_YesStr_get, Swig_var_TBool_YesStr_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_Mn",Swig_var_TCh_Mn_get, Swig_var_TCh_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_Mx",Swig_var_TCh_Mx_get, Swig_var_TCh_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_Vals",Swig_var_TCh_Vals_get, Swig_var_TCh_Vals_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_NullCh",Swig_var_TCh_NullCh_get, Swig_var_TCh_NullCh_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_TabCh",Swig_var_TCh_TabCh_get, Swig_var_TCh_TabCh_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_LfCh",Swig_var_TCh_LfCh_get, Swig_var_TCh_LfCh_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_CrCh",Swig_var_TCh_CrCh_get, Swig_var_TCh_CrCh_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_EofCh",Swig_var_TCh_EofCh_get, Swig_var_TCh_EofCh_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TCh_HashCh",Swig_var_TCh_HashCh_get, Swig_var_TCh_HashCh_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUCh_Mn",Swig_var_TUCh_Mn_get, Swig_var_TUCh_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUCh_Mx",Swig_var_TUCh_Mx_get, Swig_var_TUCh_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUCh_Vals",Swig_var_TUCh_Vals_get, Swig_var_TUCh_Vals_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TInt_Mn",Swig_var_TInt_Mn_get, Swig_var_TInt_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TInt_Mx",Swig_var_TInt_Mx_get, Swig_var_TInt_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TInt_Kilo",Swig_var_TInt_Kilo_get, Swig_var_TInt_Kilo_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TInt_Mega",Swig_var_TInt_Mega_get, Swig_var_TInt_Mega_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TInt_Giga",Swig_var_TInt_Giga_get, Swig_var_TInt_Giga_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TInt_Rnd",Swig_var_TInt_Rnd_get, Swig_var_TInt_Rnd_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUInt_Mn",Swig_var_TUInt_Mn_get, Swig_var_TUInt_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUInt_Mx",Swig_var_TUInt_Mx_get, Swig_var_TUInt_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUInt_Rnd",Swig_var_TUInt_Rnd_get, Swig_var_TUInt_Rnd_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUInt64_Mn",Swig_var_TUInt64_Mn_get, Swig_var_TUInt64_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TUInt64_Mx",Swig_var_TUInt64_Mx_get, Swig_var_TUInt64_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFlt_Mn",Swig_var_TFlt_Mn_get, Swig_var_TFlt_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFlt_Mx",Swig_var_TFlt_Mx_get, Swig_var_TFlt_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFlt_NInf",Swig_var_TFlt_NInf_get, Swig_var_TFlt_NInf_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFlt_PInf",Swig_var_TFlt_PInf_get, Swig_var_TFlt_PInf_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFlt_Eps",Swig_var_TFlt_Eps_get, Swig_var_TFlt_Eps_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFlt_EpsHalf",Swig_var_TFlt_EpsHalf_get, Swig_var_TFlt_EpsHalf_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TFlt_Rnd",Swig_var_TFlt_Rnd_get, Swig_var_TFlt_Rnd_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TSFlt_Mn",Swig_var_TSFlt_Mn_get, Swig_var_TSFlt_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TSFlt_Mx",Swig_var_TSFlt_Mx_get, Swig_var_TSFlt_Mx_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TLFlt_Mn",Swig_var_TLFlt_Mn_get, Swig_var_TLFlt_Mn_set); + SWIG_addvarlink(SWIG_globals(),(char*)"TLFlt_Mx",Swig_var_TLFlt_Mx_get, Swig_var_TLFlt_Mx_set); + SWIG_Python_SetConstant(d, "TIntIntVH_HashPrimes",SWIG_From_int(static_cast< int >(THash< TInt,TVec< TInt,int > >::HashPrimes))); + SWIG_Python_SetConstant(d, "TIntH_HashPrimes",SWIG_From_int(static_cast< int >(THash< TInt,TInt >::HashPrimes))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/snap-python/source/snapx/LICENSE_NETWORKX b/snap-python/source/snapx/LICENSE_NETWORKX new file mode 100644 index 0000000000000000000000000000000000000000..3400491dfe7eb4c85a9148a85ca36ff37af68d34 --- /dev/null +++ b/snap-python/source/snapx/LICENSE_NETWORKX @@ -0,0 +1,37 @@ +######################################################################## +# SnapX is designed based on NetworkX's interface, +# and its codebase contains the original code from NetworkX +######################################################################## + Copyright (C) 2004-2020, NetworkX Developers + Aric Hagberg + Dan Schult + Pieter Swart + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NetworkX Developers nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/snap-python/source/snapx/README.md b/snap-python/source/snapx/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2f283a15caff412b7e7f500fc6ead7239c1207ab --- /dev/null +++ b/snap-python/source/snapx/README.md @@ -0,0 +1,47 @@ +## SnapX: A new SNAP API with NetworkX-like interface +This directory contains an alternative interface to SNAP, whose goal is to offer a more Pythonic way to interact with C++ SNAP's graph data structures and algorithms. The new API provided here is aimed to be fully compatible with NetworkX, with the ultimate goal of behaving as its drop-in replacement. + +## Getting started +To install the interface for development, simply run `python3 setup.py develop` in your environment. By design, you can manipulate SnapX graphs as if you are working with NetworkX, as the following code snippet demonstrates: +```python3 +import snapx as sx + +g = sx.Graph() +g.add_nodes_from([0, 1, (2, {'weight': 0.4}), (3, {'name': 'foo'})]) +g.add_edges_from([(0, 1, {'bar': 'baz'}), (1, 3)]) + +g.nodes(data=True) # Show all nodes with their attributes +g.edges[(0, 1)] # Show attributes associated with edge (0, 1) + +g.adj[0][1]['data'] = 12 # Assign a new attribute to edge (0, 1) + +for n in g.nodes: + print(n, g.nodes[n]) # Iterate over nodes + +for e in g.edges: + print(e, g.edges[e]) # Iterate over edges +``` + +## Implementation overview + +### Data structures +- `Graph`: An undirected graph data structure emulated by SNAP's `TNEANet`, a multigraph with support for node and edge attributes. Please see the docstring for `Graph` class, available under `classes/graph.py` for more information on its design. + +### Views +The following view classes are currently available for use: +- `AtlasView` +- `AdjacencyView` +- `NodeView` +- `EdgeView` + +### Generators +Two simple graph generators from NetworkX are made available at the moment: `empty_graph` and `path_graph`. Support for more graph generators can be added with relative ease insofar as the generators interact only with the available APIs of the graph data structures. Adding generators defined in SNAP is another possibility for future implementations. + +### Algorithms (NOT working) +The subdirectory `algorithms` is where you can find SNAP's graph algorithms. Currently, only a tiny subset of algorithms are exposed from snap.py; they are NOT not working at the moment due to the use of TNEANet. This subdirectory is left here nonetheless in order to help illustrate the future direction should we choose to support graph algorithms. + +## Testing +The entire test suite can be invoked by calling `pytest`. Remaining faithful to NetworkX's original interface is an importal goal of this project, and thus we put our code through the same set of test cases as NetworkX to the extent possible. + +## License +This project depends heavily on NetworkX's various components such as code, docstrings and, most importantly, the API design. The original licence of NetworkX can be found in `LICENSE_NETWORKX`. diff --git a/snap-python/source/snapx/__init__.py b/snap-python/source/snapx/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/snapx/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/snapx/setup.py b/snap-python/source/snapx/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..4e9ba9b2a02682cf143a0a877aa079fcb90ec44b --- /dev/null +++ b/snap-python/source/snapx/setup.py @@ -0,0 +1,10 @@ +from setuptools import setup, find_packages + +if __name__ == "__main__": + setup( + name="snapx", + author="snap.stanford.edu", + version="0.0.1", + packages=find_packages(), + description="""SnapX: An experimental SNAP API with NetworkX-like interface""" + ) diff --git a/snap-python/source/snapx/snapx/__init__.py b/snap-python/source/snapx/snapx/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ca352f4bb48fc6b972b690b3e52ba72a97612585 --- /dev/null +++ b/snap-python/source/snapx/snapx/__init__.py @@ -0,0 +1,15 @@ +import snapx.classes +from snapx.classes import * + +import snapx.generators +from snapx.generators import * + +import snapx.algorithms +from snapx.algorithms import * + +import snapx.convert +from snapx.convert import * + +from snapx.exception import * + +from snapx.relabel import * diff --git a/snap-python/source/snapx/snapx/algorithms/__init__.py b/snap-python/source/snapx/snapx/algorithms/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..675e3781b1312ede8872e02713bda2439e898125 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/__init__.py @@ -0,0 +1,4 @@ +from snapx.algorithms.centrality import * +from snapx.algorithms.community import * +from snapx.algorithms.components import * +from snapx.algorithms.shortest_paths import * diff --git a/snap-python/source/snapx/snapx/algorithms/centrality/__init__.py b/snap-python/source/snapx/snapx/algorithms/centrality/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8d8b7a3cf97804dd6d98fc33348af4c4f65e459 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/centrality/__init__.py @@ -0,0 +1 @@ +from .snap_cent import * \ No newline at end of file diff --git a/snap-python/source/snapx/snapx/algorithms/centrality/snap_cent.py b/snap-python/source/snapx/snapx/algorithms/centrality/snap_cent.py new file mode 100644 index 0000000000000000000000000000000000000000..127e1867bff4bac3064ef79f41ee23beb6e1fc36 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/centrality/snap_cent.py @@ -0,0 +1,4 @@ +from snap import GetDegreeCentr + +def get_degree_centr(graph, nid): + return GetDegreeCentr(graph.snap_graph, nid) \ No newline at end of file diff --git a/snap-python/source/snapx/snapx/algorithms/community/__init__.py b/snap-python/source/snapx/snapx/algorithms/community/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6d8b9cece003341c8a1d0025b7678ab9614da0a7 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/community/__init__.py @@ -0,0 +1 @@ +from snapx.algorithms.community.snap_cmty import * \ No newline at end of file diff --git a/snap-python/source/snapx/snapx/algorithms/community/snap_cmty.py b/snap-python/source/snapx/snapx/algorithms/community/snap_cmty.py new file mode 100644 index 0000000000000000000000000000000000000000..cfa12b2f190928412ae22fea48a870f659cf7d0e --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/community/snap_cmty.py @@ -0,0 +1,13 @@ +from snap import TCnComV + +from snap import CommunityCNM, CommunityGirvanNewman + +def community_CNM(graph): + cmtyV = TCnComV() + modularity = CommunityCNM(graph.snap_graph, cmtyV) + return (modularity, cmtyV) + +def community_girvan_newman(graph): + cmtyV = TCnComV() + modularity = CommunityGirvanNewman(graph.snap_graph, cmtyV) + return (modularity, cmtyV) diff --git a/snap-python/source/snapx/snapx/algorithms/components/__init__.py b/snap-python/source/snapx/snapx/algorithms/components/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dfc3c948e0dff4ce15d45d21e656f6c59164ce55 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/components/__init__.py @@ -0,0 +1 @@ +from .components import * diff --git a/snap-python/source/snapx/snapx/algorithms/components/components.py b/snap-python/source/snapx/snapx/algorithms/components/components.py new file mode 100644 index 0000000000000000000000000000000000000000..5ba864aae4dcfca03fcb8456c488bb3b40d32f68 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/components/components.py @@ -0,0 +1,176 @@ +"""PORTED FROM NETWORKX +Connected components.""" +import snapx as sx +from snap import GetSccs, GetMxScc, TCnComV +from snapx.utils.decorators import not_implemented_for + +__all__ = [ + "connected_components", + "max_connected_component", +] + + +@not_implemented_for("directed") +def connected_components(G): + """Generate connected components. + + Parameters + ---------- + G : NetworkX graph + An undirected graph + + Returns + ------- + comp : generator of sets + A generator of sets of nodes, one for each component of G. + + Raises + ------ + NetworkXNotImplemented + If G is directed. + + Examples + -------- + Generate a sorted list of connected components, largest first. + + >>> G = nx.path_graph(4) + >>> nx.add_path(G, [10, 11, 12]) + >>> [len(c) for c in sorted(nx.connected_components(G), key=len, reverse=True)] + [4, 3] + + If you only want the largest connected component, it's more + efficient to use max instead of sort. + + >>> largest_cc = max(nx.connected_components(G), key=len) + + To create the induced subgraph of each component use: + + >>> S = [G.subgraph(c).copy() for c in nx.connected_components(G)] + + See Also + -------- + strongly_connected_components + weakly_connected_components + + Notes + ----- + For undirected graphs only. + + """ + Components = TCnComV() + Graphs = [] + GetSccs(G._graph, Components) + for CnCom in Components: + Graphs.append(sx.Graph(incoming_graph_data=CnCom)) + return Graphs + +@not_implemented_for("directed") +def max_connected_component(G): + return sx.Graph(incoming_graph_data=GetMxScc(G._graph)) + + + +# def number_connected_components(G): +# """Returns the number of connected components. + +# Parameters +# ---------- +# G : NetworkX graph +# An undirected graph. + +# Returns +# ------- +# n : integer +# Number of connected components + +# See Also +# -------- +# connected_components +# number_weakly_connected_components +# number_strongly_connected_components + +# Notes +# ----- +# For undirected graphs only. + +# """ +# return sum(1 for cc in connected_components(G)) + + +# @not_implemented_for("directed") +# def is_connected(G): +# """Returns True if the graph is connected, False otherwise. + +# Parameters +# ---------- +# G : NetworkX Graph +# An undirected graph. + +# Returns +# ------- +# connected : bool +# True if the graph is connected, false otherwise. + +# Raises +# ------ +# NetworkXNotImplemented +# If G is directed. + +# Examples +# -------- +# >>> G = nx.path_graph(4) +# >>> print(nx.is_connected(G)) +# True + +# See Also +# -------- +# is_strongly_connected +# is_weakly_connected +# is_semiconnected +# is_biconnected +# connected_components + +# Notes +# ----- +# For undirected graphs only. + +# """ +# if len(G) == 0: +# raise nx.NetworkXPointlessConcept( +# "Connectivity is undefined ", "for the null graph." +# ) +# return sum(1 for node in _plain_bfs(G, arbitrary_element(G))) == len(G) + + +# @not_implemented_for("directed") +# def node_connected_component(G, n): +# """Returns the set of nodes in the component of graph containing node n. + +# Parameters +# ---------- +# G : NetworkX Graph +# An undirected graph. + +# n : node label +# A node in G + +# Returns +# ------- +# comp : set +# A set of nodes in the component of G containing node n. + +# Raises +# ------ +# NetworkXNotImplemented +# If G is directed. + +# See Also +# -------- +# connected_components + +# Notes +# ----- +# For undirected graphs only. + +# """ +# return _plain_bfs(G, n) \ No newline at end of file diff --git a/snap-python/source/snapx/snapx/algorithms/dag.py b/snap-python/source/snapx/snapx/algorithms/dag.py new file mode 100644 index 0000000000000000000000000000000000000000..1cf7286f54e66ce073755794a7a374342e438e25 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/dag.py @@ -0,0 +1,914 @@ +"""Algorithms for directed acyclic graphs (DAGs). + +Note that most of these functions are only guaranteed to work for DAGs. +In general, these functions do not check for acyclic-ness, so it is up +to the user to check for that. +""" + +from collections import deque +from math import gcd +from functools import partial +from itertools import chain +from itertools import product +from itertools import starmap +import heapq + +import snapx as sx + +# from snapx.algorithms.traversal.breadth_first_search import descendants_at_distance +# from snapx.generators.trees import NIL +# from networkx.utils import arbitrary_element +# from networkx.utils import consume +# from networkx.utils import pairwise +# from networkx.utils import not_implemented_for + +# __all__ = [ +# "descendants", +# "ancestors", +# "topological_sort", +# "lexicographical_topological_sort", +# "all_topological_sorts", +# "is_directed_acyclic_graph", +# "is_aperiodic", +# "transitive_closure", +# "transitive_closure_dag", +# "transitive_reduction", +# "antichains", +# "dag_longest_path", +# "dag_longest_path_length", +# "dag_to_branching", +# ] + +__all__ = ["topological_sort"] + +# chaini = chain.from_iterable + + +# def descendants(G, source): +# """Returns all nodes reachable from `source` in `G`. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed acyclic graph (DAG) +# source : node in `G` + +# Returns +# ------- +# set() +# The descendants of `source` in `G` +# """ +# if not G.has_node(source): +# raise nx.NetworkXError(f"The node {source} is not in the graph.") +# des = {n for n, d in nx.shortest_path_length(G, source=source).items()} +# return des - {source} + + +# def ancestors(G, source): +# """Returns all nodes having a path to `source` in `G`. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed acyclic graph (DAG) +# source : node in `G` + +# Returns +# ------- +# set() +# The ancestors of source in G +# """ +# if not G.has_node(source): +# raise nx.NetworkXError(f"The node {source} is not in the graph.") +# anc = {n for n, d in nx.shortest_path_length(G, target=source).items()} +# return anc - {source} + + +# def has_cycle(G): +# """Decides whether the directed graph has a cycle.""" +# try: +# consume(topological_sort(G)) +# except nx.NetworkXUnfeasible: +# return True +# else: +# return False + + +# def is_directed_acyclic_graph(G): +# """Returns True if the graph `G` is a directed acyclic graph (DAG) or +# False if not. + +# Parameters +# ---------- +# G : NetworkX graph + +# Returns +# ------- +# bool +# True if `G` is a DAG, False otherwise +# """ +# return G.is_directed() and not has_cycle(G) + + +def topological_sort(G): + """PORTED FROM NETWORKX + Returns a generator of nodes in topologically sorted order. + + A topological sort is a nonunique permutation of the nodes such that an + edge from u to v implies that u appears before v in the topological sort + order. + + Parameters + ---------- + G : SnapX digraph + A directed acyclic graph (DAG) + + Returns + ------- + iterable + An iterable of node names in topological sorted order. + + Raises + ------ + SnapXError + Topological sort is defined for directed graphs only. If the graph `G` + is undirected, a :exc:`SnapXError` is raised. + + SnapXUnfeasible + If `G` is not a directed acyclic graph (DAG) no topological sort exists + and a :exc:`SnapXUnfeasible` exception is raised. This can also be + raised if `G` is changed while the returned iterator is being processed + + RuntimeError + If `G` is changed while the returned iterator is being processed. + + Examples + -------- + To get the reverse order of the topological sort: + + >>> DG = sx.DiGraph([(1, 2), (2, 3)]) + >>> list(reversed(list(sx.topological_sort(DG)))) + [3, 2, 1] + + --- DISREGARD BELOW --- + If your DiGraph naturally has the edges representing tasks/inputs + and nodes representing people/processes that initiate tasks, then + topological_sort is not quite what you need. You will have to change + the tasks to nodes with dependence reflected by edges. The result is + a kind of topological sort of the edges. This can be done + with :func:`networkx.line_graph` as follows: + + >>> list(nx.topological_sort(nx.line_graph(DG))) + [(1, 2), (2, 3)] + + Notes + ----- + This algorithm is based on a description and proof in + "Introduction to Algorithms: A Creative Approach" [1]_ . + + See also + -------- + is_directed_acyclic_graph, lexicographical_topological_sort + + References + ---------- + .. [1] Manber, U. (1989). + *Introduction to Algorithms - A Creative Approach.* Addison-Wesley. + """ + if not G.is_directed(): + raise sx.SnapXError("Topological sort not defined on undirected graphs.") + + indegree_map = {v: d for v, d in G.in_degree() if d > 0} + # These nodes have zero indegree and ready to be returned. + zero_indegree = [v for v, d in G.in_degree() if d == 0] + + while zero_indegree: + node = zero_indegree.pop() + if node not in G: + raise RuntimeError("Graph changed during iteration") + for _, child in G.edges(node): + try: + indegree_map[child] -= 1 + except KeyError as e: + raise RuntimeError("Graph changed during iteration") from e + if indegree_map[child] == 0: + zero_indegree.append(child) + del indegree_map[child] + + yield node + + if indegree_map: + raise sx.SnapXUnfeasible( + "Graph contains a cycle or graph changed " "during iteration" + ) + + +# def lexicographical_topological_sort(G, key=None): +# """Returns a generator of nodes in lexicographically topologically sorted +# order. + +# A topological sort is a nonunique permutation of the nodes such that an +# edge from u to v implies that u appears before v in the topological sort +# order. + +# Parameters +# ---------- +# G : NetworkX digraph +# A directed acyclic graph (DAG) + +# key : function, optional +# This function maps nodes to keys with which to resolve ambiguities in +# the sort order. Defaults to the identity function. + +# Returns +# ------- +# iterable +# An iterable of node names in lexicographical topological sort order. + +# Raises +# ------ +# NetworkXError +# Topological sort is defined for directed graphs only. If the graph `G` +# is undirected, a :exc:`NetworkXError` is raised. + +# NetworkXUnfeasible +# If `G` is not a directed acyclic graph (DAG) no topological sort exists +# and a :exc:`NetworkXUnfeasible` exception is raised. This can also be +# raised if `G` is changed while the returned iterator is being processed + +# RuntimeError +# If `G` is changed while the returned iterator is being processed. + +# Notes +# ----- +# This algorithm is based on a description and proof in +# "Introduction to Algorithms: A Creative Approach" [1]_ . + +# See also +# -------- +# topological_sort + +# References +# ---------- +# .. [1] Manber, U. (1989). +# *Introduction to Algorithms - A Creative Approach.* Addison-Wesley. +# """ +# if not G.is_directed(): +# msg = "Topological sort not defined on undirected graphs." +# raise nx.NetworkXError(msg) + +# if key is None: + +# def key(node): +# return node + +# nodeid_map = {n: i for i, n in enumerate(G)} + +# def create_tuple(node): +# return key(node), nodeid_map[node], node + +# indegree_map = {v: d for v, d in G.in_degree() if d > 0} +# # These nodes have zero indegree and ready to be returned. +# zero_indegree = [create_tuple(v) for v, d in G.in_degree() if d == 0] +# heapq.heapify(zero_indegree) + +# while zero_indegree: +# _, _, node = heapq.heappop(zero_indegree) + +# if node not in G: +# raise RuntimeError("Graph changed during iteration") +# for _, child in G.edges(node): +# try: +# indegree_map[child] -= 1 +# except KeyError as e: +# raise RuntimeError("Graph changed during iteration") from e +# if indegree_map[child] == 0: +# heapq.heappush(zero_indegree, create_tuple(child)) +# del indegree_map[child] + +# yield node + +# if indegree_map: +# msg = "Graph contains a cycle or graph changed during iteration" +# raise nx.NetworkXUnfeasible(msg) + + +# @not_implemented_for("undirected") +# def all_topological_sorts(G): +# """Returns a generator of _all_ topological sorts of the directed graph G. + +# A topological sort is a nonunique permutation of the nodes such that an +# edge from u to v implies that u appears before v in the topological sort +# order. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed graph + +# Returns +# ------- +# generator +# All topological sorts of the digraph G + +# Raises +# ------ +# NetworkXNotImplemented +# If `G` is not directed +# NetworkXUnfeasible +# If `G` is not acyclic + +# Examples +# -------- +# To enumerate all topological sorts of directed graph: + +# >>> DG = nx.DiGraph([(1, 2), (2, 3), (2, 4)]) +# >>> list(nx.all_topological_sorts(DG)) +# [[1, 2, 4, 3], [1, 2, 3, 4]] + +# Notes +# ----- +# Implements an iterative version of the algorithm given in [1]. + +# References +# ---------- +# .. [1] Knuth, Donald E., Szwarcfiter, Jayme L. (1974). +# "A Structured Program to Generate All Topological Sorting Arrangements" +# Information Processing Letters, Volume 2, Issue 6, 1974, Pages 153-157, +# ISSN 0020-0190, +# https://doi.org/10.1016/0020-0190(74)90001-5. +# Elsevier (North-Holland), Amsterdam +# """ +# if not G.is_directed(): +# raise nx.NetworkXError( +# "Topological sort not defined on undirected graphs.") + +# # the names of count and D are chosen to match the global variables in [1] +# # number of edges originating in a vertex v +# count = dict(G.in_degree()) +# # vertices with indegree 0 +# D = deque([v for v, d in G.in_degree() if d == 0]) +# # stack of first value chosen at a position k in the topological sort +# bases = [] +# current_sort = [] + +# # do-while construct +# while True: +# assert all([count[v] == 0 for v in D]) + +# if len(current_sort) == len(G): +# yield list(current_sort) + +# # clean-up stack +# while len(current_sort) > 0: +# assert len(bases) == len(current_sort) +# q = current_sort.pop() + +# # "restores" all edges (q, x) +# # NOTE: it is important to iterate over edges instead +# # of successors, so count is updated correctly in multigraphs +# for _, j in G.out_edges(q): +# count[j] += 1 +# assert count[j] >= 0 +# # remove entries from D +# while len(D) > 0 and count[D[-1]] > 0: +# D.pop() + +# # corresponds to a circular shift of the values in D +# # if the first value chosen (the base) is in the first +# # position of D again, we are done and need to consider the +# # previous condition +# D.appendleft(q) +# if D[-1] == bases[-1]: +# # all possible values have been chosen at current position +# # remove corresponding marker +# bases.pop() +# else: +# # there are still elements that have not been fixed +# # at the current position in the topological sort +# # stop removing elements, escape inner loop +# break + +# else: +# if len(D) == 0: +# raise nx.NetworkXUnfeasible("Graph contains a cycle.") + +# # choose next node +# q = D.pop() +# # "erase" all edges (q, x) +# # NOTE: it is important to iterate over edges instead +# # of successors, so count is updated correctly in multigraphs +# for _, j in G.out_edges(q): +# count[j] -= 1 +# assert count[j] >= 0 +# if count[j] == 0: +# D.append(j) +# current_sort.append(q) + +# # base for current position might _not_ be fixed yet +# if len(bases) < len(current_sort): +# bases.append(q) + +# if len(bases) == 0: +# break + + +# def is_aperiodic(G): +# """Returns True if `G` is aperiodic. + +# A directed graph is aperiodic if there is no integer k > 1 that +# divides the length of every cycle in the graph. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed graph + +# Returns +# ------- +# bool +# True if the graph is aperiodic False otherwise + +# Raises +# ------ +# NetworkXError +# If `G` is not directed + +# Notes +# ----- +# This uses the method outlined in [1]_, which runs in $O(m)$ time +# given $m$ edges in `G`. Note that a graph is not aperiodic if it is +# acyclic as every integer trivial divides length 0 cycles. + +# References +# ---------- +# .. [1] Jarvis, J. P.; Shier, D. R. (1996), +# "Graph-theoretic analysis of finite Markov chains," +# in Shier, D. R.; Wallenius, K. T., Applied Mathematical Modeling: +# A Multidisciplinary Approach, CRC Press. +# """ +# if not G.is_directed(): +# raise nx.NetworkXError( +# "is_aperiodic not defined for undirected graphs") + +# s = arbitrary_element(G) +# levels = {s: 0} +# this_level = [s] +# g = 0 +# lev = 1 +# while this_level: +# next_level = [] +# for u in this_level: +# for v in G[u]: +# if v in levels: # Non-Tree Edge +# g = gcd(g, levels[u] - levels[v] + 1) +# else: # Tree Edge +# next_level.append(v) +# levels[v] = lev +# this_level = next_level +# lev += 1 +# if len(levels) == len(G): # All nodes in tree +# return g == 1 +# else: +# return g == 1 and nx.is_aperiodic(G.subgraph(set(G) - set(levels))) + + +# @not_implemented_for("undirected") +# def transitive_closure(G, reflexive=False): +# """ Returns transitive closure of a directed graph + +# The transitive closure of G = (V,E) is a graph G+ = (V,E+) such that +# for all v, w in V there is an edge (v, w) in E+ if and only if there +# is a path from v to w in G. + +# Handling of paths from v to v has some flexibility within this definition. +# A reflexive transitive closure creates a self-loop for the path +# from v to v of length 0. The usual transitive closure creates a +# self-loop only if a cycle exists (a path from v to v with length > 0). +# We also allow an option for no self-loops. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed graph +# reflexive : Bool or None, optional (default: False) +# Determines when cycles create self-loops in the Transitive Closure. +# If True, trivial cycles (length 0) create self-loops. The result +# is a reflexive tranistive closure of G. +# If False (the default) non-trivial cycles create self-loops. +# If None, self-loops are not created. + +# Returns +# ------- +# NetworkX DiGraph +# The transitive closure of `G` + +# Raises +# ------ +# NetworkXNotImplemented +# If `G` is not directed + +# References +# ---------- +# .. [1] http://www.ics.uci.edu/~eppstein/PADS/PartialOrder.py + +# TODO this function applies to all directed graphs and is probably misplaced +# here in dag.py +# """ +# if reflexive is None: +# TC = G.copy() +# for v in G: +# edges = ((v, u) for u in nx.dfs_preorder_nodes(G, v) if v != u) +# TC.add_edges_from(edges) +# return TC +# if reflexive is True: +# TC = G.copy() +# for v in G: +# edges = ((v, u) for u in nx.dfs_preorder_nodes(G, v)) +# TC.add_edges_from(edges) +# return TC +# # reflexive is False +# TC = G.copy() +# for v in G: +# edges = ((v, w) for u, w in nx.edge_dfs(G, v)) +# TC.add_edges_from(edges) +# return TC + + +# @not_implemented_for("undirected") +# def transitive_closure_dag(G, topo_order=None): +# """ Returns the transitive closure of a directed acyclic graph. + +# This function is faster than the function `transitive_closure`, but fails +# if the graph has a cycle. + +# The transitive closure of G = (V,E) is a graph G+ = (V,E+) such that +# for all v, w in V there is an edge (v, w) in E+ if and only if there +# is a non-null path from v to w in G. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed acyclic graph (DAG) + +# topo_order: list or tuple, optional +# A topological order for G (if None, the function will compute one) + +# Returns +# ------- +# NetworkX DiGraph +# The transitive closure of `G` + +# Raises +# ------ +# NetworkXNotImplemented +# If `G` is not directed +# NetworkXUnfeasible +# If `G` has a cycle + +# Notes +# ----- +# This algorithm is probably simple enough to be well-known but I didn't find +# a mention in the literature. +# """ +# if topo_order is None: +# topo_order = list(topological_sort(G)) + +# TC = G.copy() + +# # idea: traverse vertices following a reverse topological order, connecting +# # each vertex to its descendants at distance 2 as we go +# for v in reversed(topo_order): +# TC.add_edges_from((v, u) for u in descendants_at_distance(TC, v, 2)) + +# return TC + + +# @not_implemented_for("undirected") +# def transitive_reduction(G): +# """ Returns transitive reduction of a directed graph + +# The transitive reduction of G = (V,E) is a graph G- = (V,E-) such that +# for all v,w in V there is an edge (v,w) in E- if and only if (v,w) is +# in E and there is no path from v to w in G with length greater than 1. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed acyclic graph (DAG) + +# Returns +# ------- +# NetworkX DiGraph +# The transitive reduction of `G` + +# Raises +# ------ +# NetworkXError +# If `G` is not a directed acyclic graph (DAG) transitive reduction is +# not uniquely defined and a :exc:`NetworkXError` exception is raised. + +# References +# ---------- +# https://en.wikipedia.org/wiki/Transitive_reduction + +# """ +# if not is_directed_acyclic_graph(G): +# msg = "Directed Acyclic Graph required for transitive_reduction" +# raise nx.NetworkXError(msg) +# TR = nx.DiGraph() +# TR.add_nodes_from(G.nodes()) +# descendants = {} +# # count before removing set stored in descendants +# check_count = dict(G.in_degree) +# for u in G: +# u_nbrs = set(G[u]) +# for v in G[u]: +# if v in u_nbrs: +# if v not in descendants: +# descendants[v] = {y for x, y in nx.dfs_edges(G, v)} +# u_nbrs -= descendants[v] +# check_count[v] -= 1 +# if check_count[v] == 0: +# del descendants[v] +# TR.add_edges_from((u, v) for v in u_nbrs) +# return TR + + +# @not_implemented_for("undirected") +# def antichains(G, topo_order=None): +# """Generates antichains from a directed acyclic graph (DAG). + +# An antichain is a subset of a partially ordered set such that any +# two elements in the subset are incomparable. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed acyclic graph (DAG) + +# topo_order: list or tuple, optional +# A topological order for G (if None, the function will compute one) + +# Returns +# ------- +# generator object + +# Raises +# ------ +# NetworkXNotImplemented +# If `G` is not directed + +# NetworkXUnfeasible +# If `G` contains a cycle + +# Notes +# ----- +# This function was originally developed by Peter Jipsen and Franco Saliola +# for the SAGE project. It's included in NetworkX with permission from the +# authors. Original SAGE code at: + +# https://github.com/sagemath/sage/blob/master/src/sage/combinat/posets/hasse_diagram.py + +# References +# ---------- +# .. [1] Free Lattices, by R. Freese, J. Jezek and J. B. Nation, +# AMS, Vol 42, 1995, p. 226. +# """ +# if topo_order is None: +# topo_order = list(nx.topological_sort(G)) + +# TC = nx.transitive_closure_dag(G, topo_order) +# antichains_stacks = [([], list(reversed(topo_order)))] + +# while antichains_stacks: +# (antichain, stack) = antichains_stacks.pop() +# # Invariant: +# # - the elements of antichain are independent +# # - the elements of stack are independent from those of antichain +# yield antichain +# while stack: +# x = stack.pop() +# new_antichain = antichain + [x] +# new_stack = [t for t in stack if not ( +# (t in TC[x]) or (x in TC[t]))] +# antichains_stacks.append((new_antichain, new_stack)) + + +# @not_implemented_for("undirected") +# def dag_longest_path(G, weight="weight", default_weight=1, topo_order=None): +# """Returns the longest path in a directed acyclic graph (DAG). + +# If `G` has edges with `weight` attribute the edge data are used as +# weight values. + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed acyclic graph (DAG) + +# weight : str, optional +# Edge data key to use for weight + +# default_weight : int, optional +# The weight of edges that do not have a weight attribute + +# topo_order: list or tuple, optional +# A topological order for G (if None, the function will compute one) + +# Returns +# ------- +# list +# Longest path + +# Raises +# ------ +# NetworkXNotImplemented +# If `G` is not directed + +# See also +# -------- +# dag_longest_path_length + +# """ +# if not G: +# return [] + +# if topo_order is None: +# topo_order = nx.topological_sort(G) + +# dist = {} # stores {v : (length, u)} +# for v in topo_order: +# us = [ +# (dist[u][0] + data.get(weight, default_weight), u) +# for u, data in G.pred[v].items() +# ] + +# # Use the best predecessor if there is one and its distance is +# # non-negative, otherwise terminate. +# maxu = max(us, key=lambda x: x[0]) if us else (0, v) +# dist[v] = maxu if maxu[0] >= 0 else (0, v) + +# u = None +# v = max(dist, key=lambda x: dist[x][0]) +# path = [] +# while u != v: +# path.append(v) +# u = v +# v = dist[v][1] + +# path.reverse() +# return path + + +# @not_implemented_for("undirected") +# def dag_longest_path_length(G, weight="weight", default_weight=1): +# """Returns the longest path length in a DAG + +# Parameters +# ---------- +# G : NetworkX DiGraph +# A directed acyclic graph (DAG) + +# weight : string, optional +# Edge data key to use for weight + +# default_weight : int, optional +# The weight of edges that do not have a weight attribute + +# Returns +# ------- +# int +# Longest path length + +# Raises +# ------ +# NetworkXNotImplemented +# If `G` is not directed + +# See also +# -------- +# dag_longest_path +# """ +# path = nx.dag_longest_path(G, weight, default_weight) +# path_length = 0 +# for (u, v) in pairwise(path): +# path_length += G[u][v].get(weight, default_weight) + +# return path_length + + +# def root_to_leaf_paths(G): +# """Yields root-to-leaf paths in a directed acyclic graph. + +# `G` must be a directed acyclic graph. If not, the behavior of this +# function is undefined. A "root" in this graph is a node of in-degree +# zero and a "leaf" a node of out-degree zero. + +# When invoked, this function iterates over each path from any root to +# any leaf. A path is a list of nodes. + +# """ +# roots = (v for v, d in G.in_degree() if d == 0) +# leaves = (v for v, d in G.out_degree() if d == 0) +# all_paths = partial(nx.all_simple_paths, G) +# # TODO In Python 3, this would be better as `yield from ...`. +# return chaini(starmap(all_paths, product(roots, leaves))) + + +# @not_implemented_for("multigraph") +# @not_implemented_for("undirected") +# def dag_to_branching(G): +# """Returns a branching representing all (overlapping) paths from +# root nodes to leaf nodes in the given directed acyclic graph. + +# As described in :mod:`networkx.algorithms.tree.recognition`, a +# *branching* is a directed forest in which each node has at most one +# parent. In other words, a branching is a disjoint union of +# *arborescences*. For this function, each node of in-degree zero in +# `G` becomes a root of one of the arborescences, and there will be +# one leaf node for each distinct path from that root to a leaf node +# in `G`. + +# Each node `v` in `G` with *k* parents becomes *k* distinct nodes in +# the returned branching, one for each parent, and the sub-DAG rooted +# at `v` is duplicated for each copy. The algorithm then recurses on +# the children of each copy of `v`. + +# Parameters +# ---------- +# G : NetworkX graph +# A directed acyclic graph. + +# Returns +# ------- +# DiGraph +# The branching in which there is a bijection between root-to-leaf +# paths in `G` (in which multiple paths may share the same leaf) +# and root-to-leaf paths in the branching (in which there is a +# unique path from a root to a leaf). + +# Each node has an attribute 'source' whose value is the original +# node to which this node corresponds. No other graph, node, or +# edge attributes are copied into this new graph. + +# Raises +# ------ +# NetworkXNotImplemented +# If `G` is not directed, or if `G` is a multigraph. + +# HasACycle +# If `G` is not acyclic. + +# Examples +# -------- +# To examine which nodes in the returned branching were produced by +# which original node in the directed acyclic graph, we can collect +# the mapping from source node to new nodes into a dictionary. For +# example, consider the directed diamond graph:: + +# >>> from collections import defaultdict +# >>> from operator import itemgetter +# >>> +# >>> G = nx.DiGraph(nx.utils.pairwise('abd')) +# >>> G.add_edges_from(nx.utils.pairwise('acd')) +# >>> B = nx.dag_to_branching(G) +# >>> +# >>> sources = defaultdict(set) +# >>> for v, source in B.nodes(data='source'): +# ... sources[source].add(v) +# >>> len(sources['a']) +# 1 +# >>> len(sources['d']) +# 2 + +# To copy node attributes from the original graph to the new graph, +# you can use a dictionary like the one constructed in the above +# example:: + +# >>> for source, nodes in sources.items(): +# ... for v in nodes: +# ... B.nodes[v].update(G.nodes[source]) + +# Notes +# ----- +# This function is not idempotent in the sense that the node labels in +# the returned branching may be uniquely generated each time the +# function is invoked. In fact, the node labels may not be integers; +# in order to relabel the nodes to be more readable, you can use the +# :func:`networkx.convert_node_labels_to_integers` function. + +# The current implementation of this function uses +# :func:`networkx.prefix_tree`, so it is subject to the limitations of +# that function. + +# """ +# if has_cycle(G): +# msg = "dag_to_branching is only defined for acyclic graphs" +# raise nx.HasACycle(msg) +# paths = root_to_leaf_paths(G) +# B, root = nx.prefix_tree(paths) +# # Remove the synthetic `root` and `NIL` nodes in the prefix tree. +# B.remove_node(root) +# B.remove_node(NIL) +# return B diff --git a/snap-python/source/snapx/snapx/algorithms/shortest_paths/__init__.py b/snap-python/source/snapx/snapx/algorithms/shortest_paths/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b2d02959ac26136a5b5ef98911ad974c5416e52 --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/shortest_paths/__init__.py @@ -0,0 +1,2 @@ +from snapx.algorithms.shortest_paths.weighted import * +from snapx.algorithms.shortest_paths.unweighted import * diff --git a/snap-python/source/snapx/snapx/algorithms/shortest_paths/unweighted.py b/snap-python/source/snapx/snapx/algorithms/shortest_paths/unweighted.py new file mode 100644 index 0000000000000000000000000000000000000000..ac3917592e45bcc7e5af865b003069653000476e --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/shortest_paths/unweighted.py @@ -0,0 +1,531 @@ +"""PORTED FROM NETWORKX +Shortest path algorithms for unweighted graphs. +""" +import snapx as sx + +__all__ = [ + "bidirectional_shortest_path", + "single_source_shortest_path", + "single_source_shortest_path_length", + # "single_target_shortest_path", + # "single_target_shortest_path_length", + # "all_pairs_shortest_path", + # "all_pairs_shortest_path_length", + # "predecessor", +] + + +def single_source_shortest_path_length(G, source, cutoff=None): + """Compute the shortest path lengths from source to all reachable nodes. + + Parameters + ---------- + G : NetworkX graph + + source : node + Starting node for path + + cutoff : integer, optional + Depth to stop the search. Only paths of length <= cutoff are returned. + + Returns + ------- + lengths : dict + Dict keyed by node to shortest path length to source. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length = nx.single_source_shortest_path_length(G, 0) + >>> length[4] + 4 + >>> for node in length: + ... print("{}: {}".format(node, length[node])) + 0: 0 + 1: 1 + 2: 2 + 3: 3 + 4: 4 + + See Also + -------- + shortest_path_length + """ + if source not in G: + raise sx.NodeNotFound("Source {} is not in G".format(source)) + if cutoff is None: + cutoff = float("inf") + nextlevel = {source: 1} + return dict(_single_shortest_path_length(G.adj, nextlevel, cutoff)) + + +def _single_shortest_path_length(adj, firstlevel, cutoff): + """Yields (node, level) in a breadth first search + + Shortest Path Length helper function + Parameters + ---------- + adj : dict + Adjacency dict or view + firstlevel : dict + starting nodes, e.g. {source: 1} or {target: 1} + cutoff : int or float + level at which we stop the process + """ + seen = {} # level (number of hops) when seen in BFS + level = 0 # the current level + nextlevel = set(firstlevel) # set of nodes to check at next level + n = len(adj) + while nextlevel and cutoff >= level: + thislevel = nextlevel # advance to next level + nextlevel = set() # and start a new set (fringe) + found = [] + for v in thislevel: + if v not in seen: + seen[v] = level # set the level of vertex v + found.append(v) + yield (v, level) + if len(seen) == n: + return + for v in found: + nextlevel.update(adj[v]) + level += 1 + del seen + + +def single_target_shortest_path_length(G, target, cutoff=None): + """Compute the shortest path lengths to target from all reachable nodes. + + Parameters + ---------- + G : NetworkX graph + + target : node + Target node for path + + cutoff : integer, optional + Depth to stop the search. Only paths of length <= cutoff are returned. + + Returns + ------- + lengths : iterator + (source, shortest path length) iterator + + Examples + -------- + >>> G = nx.path_graph(5, create_using=nx.DiGraph()) + >>> length = dict(nx.single_target_shortest_path_length(G, 4)) + >>> length[0] + 4 + >>> for node in range(5): + ... print("{}: {}".format(node, length[node])) + 0: 4 + 1: 3 + 2: 2 + 3: 1 + 4: 0 + + See Also + -------- + single_source_shortest_path_length, shortest_path_length + """ + if target not in G: + raise sx.NodeNotFound("Target {} is not in G".format(target)) + + if cutoff is None: + cutoff = float("inf") + # handle either directed or undirected + adj = G.pred if G.is_directed() else G.adj + nextlevel = {target: 1} + return _single_shortest_path_length(adj, nextlevel, cutoff) + + +def all_pairs_shortest_path_length(G, cutoff=None): + """Computes the shortest path lengths between all nodes in `G`. + + Parameters + ---------- + G : NetworkX graph + + cutoff : integer, optional + Depth at which to stop the search. Only paths of length at most + `cutoff` are returned. + + Returns + ------- + lengths : iterator + (source, dictionary) iterator with dictionary keyed by target and + shortest path length as the key value. + + Notes + ----- + The iterator returned only has reachable node pairs. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length = dict(nx.all_pairs_shortest_path_length(G)) + >>> for node in [0, 1, 2, 3, 4]: + ... print("1 - {}: {}".format(node, length[1][node]) + 1 - 0: 1 + 1 - 1: 0 + 1 - 2: 1 + 1 - 3: 2 + 1 - 4: 3 + >>> length[3][2] + 1 + >>> length[2][2] + 0 + + """ + length = single_source_shortest_path_length + # TODO This can be trivially parallelized. + for n in G: + yield (n, length(G, n, cutoff=cutoff)) + + +def bidirectional_shortest_path(G, source, target): + """Returns a list of nodes in a shortest path between source and target. + + Parameters + ---------- + G : NetworkX graph + + source : node label + starting node for path + + target : node label + ending node for path + + Returns + ------- + path: list + List of nodes in a path from source to target. + + Raises + ------ + NetworkXNoPath + If no path exists between source and target. + + See Also + -------- + shortest_path + + Notes + ----- + This algorithm is used by shortest_path(G, source, target). + """ + + if source not in G or target not in G: + msg = "Either source {} or target {} is not in G".format(source, target) + raise sx.NodeNotFound(msg) + + # call helper to do the real work + results = _bidirectional_pred_succ(G, source, target) + pred, succ, w = results + + # build path from pred+w+succ + path = [] + # from source to w + while w is not None: + path.append(w) + w = pred[w] + path.reverse() + # from w to target + w = succ[path[-1]] + while w is not None: + path.append(w) + w = succ[w] + + return path + + +def _bidirectional_pred_succ(G, source, target): + """Bidirectional shortest path helper. + + Returns (pred, succ, w) where + pred is a dictionary of predecessors from w to the source, and + succ is a dictionary of successors from w to the target. + """ + # does BFS from both source and target and meets in the middle + if target == source: + return ({target: None}, {source: None}, source) + + # handle either directed or undirected + if G.is_directed(): + Gpred = G.pred + Gsucc = G.succ + else: + Gpred = G.adj + Gsucc = G.adj + + # predecesssor and successors in search + pred = {source: None} + succ = {target: None} + + # initialize fringes, start with forward + forward_fringe = [source] + reverse_fringe = [target] + + while forward_fringe and reverse_fringe: + if len(forward_fringe) <= len(reverse_fringe): + this_level = forward_fringe + forward_fringe = [] + for v in this_level: + for w in Gsucc[v]: + if w not in pred: + forward_fringe.append(w) + pred[w] = v + if w in succ: # path found + return pred, succ, w + else: + this_level = reverse_fringe + reverse_fringe = [] + for v in this_level: + for w in Gpred[v]: + if w not in succ: + succ[w] = v + reverse_fringe.append(w) + if w in pred: # found path + return pred, succ, w + + raise sx.SnapXNoPath("No path between {} and {}.".format(source, target)) + + +def single_source_shortest_path(G, source, cutoff=None): + """Compute shortest path between source + and all other nodes reachable from source. + + Parameters + ---------- + G : NetworkX graph + + source : node label + Starting node for path + + cutoff : integer, optional + Depth to stop the search. Only paths of length <= cutoff are returned. + + Returns + ------- + lengths : dictionary + Dictionary, keyed by target, of shortest paths. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> path = nx.single_source_shortest_path(G, 0) + >>> path[4] + [0, 1, 2, 3, 4] + + Notes + ----- + The shortest path is not necessarily unique. So there can be multiple + paths between the source and each target node, all of which have the + same 'shortest' length. For each target node, this function returns + only one of those paths. + + See Also + -------- + shortest_path + """ + if source not in G: + raise sx.NodeNotFound("Source {} is not in G".format(source)) + + def join(p1, p2): + return p1 + p2 + + if cutoff is None: + cutoff = float("inf") + nextlevel = {source: 1} # list of nodes to check at next level + paths = {source: [source]} # paths dictionary (paths to key from source) + return dict(_single_shortest_path(G.adj, nextlevel, paths, cutoff, join)) + + +def _single_shortest_path(adj, firstlevel, paths, cutoff, join): + """Returns shortest paths + + Shortest Path helper function + Parameters + ---------- + adj : dict + Adjacency dict or view + firstlevel : dict + starting nodes, e.g. {source: 1} or {target: 1} + paths : dict + paths for starting nodes, e.g. {source: [source]} + cutoff : int or float + level at which we stop the process + join : function + function to construct a path from two partial paths. Requires two + list inputs `p1` and `p2`, and returns a list. Usually returns + `p1 + p2` (forward from source) or `p2 + p1` (backward from target) + """ + level = 0 # the current level + nextlevel = firstlevel + while nextlevel and cutoff > level: + thislevel = nextlevel + nextlevel = {} + for v in thislevel: + for w in adj[v]: + if w not in paths: + paths[w] = join(paths[v], [w]) + nextlevel[w] = 1 + level += 1 + return paths + + +def single_target_shortest_path(G, target, cutoff=None): + """Compute shortest path to target from all nodes that reach target. + + Parameters + ---------- + G : NetworkX graph + + target : node label + Target node for path + + cutoff : integer, optional + Depth to stop the search. Only paths of length <= cutoff are returned. + + Returns + ------- + lengths : dictionary + Dictionary, keyed by target, of shortest paths. + + Examples + -------- + >>> G = nx.path_graph(5, create_using=nx.DiGraph()) + >>> path = nx.single_target_shortest_path(G, 4) + >>> path[0] + [0, 1, 2, 3, 4] + + Notes + ----- + The shortest path is not necessarily unique. So there can be multiple + paths between the source and each target node, all of which have the + same 'shortest' length. For each target node, this function returns + only one of those paths. + + See Also + -------- + shortest_path, single_source_shortest_path + """ + if target not in G: + raise sx.NodeNotFound("Target {} is not in G".format(target)) + + def join(p1, p2): + return p2 + p1 + + # handle undirected graphs + adj = G.pred if G.is_directed() else G.adj + if cutoff is None: + cutoff = float("inf") + nextlevel = {target: 1} # list of nodes to check at next level + paths = {target: [target]} # paths dictionary (paths to key from source) + return dict(_single_shortest_path(adj, nextlevel, paths, cutoff, join)) + + +# def all_pairs_shortest_path(G, cutoff=None): +# """Compute shortest paths between all nodes. + +# Parameters +# ---------- +# G : NetworkX graph + +# cutoff : integer, optional +# Depth at which to stop the search. Only paths of length at most +# `cutoff` are returned. + +# Returns +# ------- +# lengths : dictionary +# Dictionary, keyed by source and target, of shortest paths. + +# Examples +# -------- +# >>> G = nx.path_graph(5) +# >>> path = dict(nx.all_pairs_shortest_path(G)) +# >>> print(path[0][4]) +# [0, 1, 2, 3, 4] + +# See Also +# -------- +# floyd_warshall() + +# """ +# # TODO This can be trivially parallelized. +# for n in G: +# yield (n, single_source_shortest_path(G, n, cutoff=cutoff)) + + +# def predecessor(G, source, target=None, cutoff=None, return_seen=None): +# """Returns dict of predecessors for the path from source to all nodes in G + + +# Parameters +# ---------- +# G : NetworkX graph + +# source : node label +# Starting node for path + +# target : node label, optional +# Ending node for path. If provided only predecessors between +# source and target are returned + +# cutoff : integer, optional +# Depth to stop the search. Only paths of length <= cutoff are returned. + + +# Returns +# ------- +# pred : dictionary +# Dictionary, keyed by node, of predecessors in the shortest path. + +# Examples +# -------- +# >>> G = nx.path_graph(4) +# >>> list(G) +# [0, 1, 2, 3] +# >>> nx.predecessor(G, 0) +# {0: [], 1: [0], 2: [1], 3: [2]} + +# """ +# if source not in G: +# raise sx.NodeNotFound("Source {} is not in G".format(source)) + + +# level = 0 # the current level +# nextlevel = [source] # list of nodes to check at next level +# seen = {source: level} # level (number of hops) when seen in BFS +# pred = {source: []} # predecessor dictionary +# while nextlevel: +# level = level + 1 +# thislevel = nextlevel +# nextlevel = [] +# for v in thislevel: +# for w in G[v]: +# if w not in seen: +# pred[w] = [v] +# seen[w] = level +# nextlevel.append(w) +# elif seen[w] == level: # add v to predecessor list if it +# pred[w].append(v) # is at the correct level +# if cutoff and cutoff <= level: +# break + +# if target is not None: +# if return_seen: +# if target not in pred: +# return ([], -1) # No predecessor +# return (pred[target], seen[target]) +# else: +# if target not in pred: +# return [] # No predecessor +# return pred[target] +# else: +# if return_seen: +# return (pred, seen) +# else: +# return pred diff --git a/snap-python/source/snapx/snapx/algorithms/shortest_paths/weighted.py b/snap-python/source/snapx/snapx/algorithms/shortest_paths/weighted.py new file mode 100644 index 0000000000000000000000000000000000000000..870644c65ec48c8409c1f5b74631b9305137d85b --- /dev/null +++ b/snap-python/source/snapx/snapx/algorithms/shortest_paths/weighted.py @@ -0,0 +1,2168 @@ +"""PORTED FROM NETWORKX +Shortest path algorithms for weighed graphs. +""" + +from collections import deque +from heapq import heappush, heappop +from itertools import count +import snapx as sx + +# from networkx.utils import generate_unique_node +# from networkx.algorithms.shortest_paths.generic import _build_paths_from_predecessors + + +__all__ = [ + "dijkstra_path", + "dijkstra_path_length", + "bidirectional_dijkstra", + "single_source_dijkstra", + "single_source_dijkstra_path", + "single_source_dijkstra_path_length", + "multi_source_dijkstra", + "multi_source_dijkstra_path", + "multi_source_dijkstra_path_length", + "all_pairs_dijkstra", + "all_pairs_dijkstra_path", + "all_pairs_dijkstra_path_length", + # "dijkstra_predecessor_and_distance", + # "bellman_ford_path", + # "bellman_ford_path_length", + # "single_source_bellman_ford", + # "single_source_bellman_ford_path", + # "single_source_bellman_ford_path_length", + # "all_pairs_bellman_ford_path", + # "all_pairs_bellman_ford_path_length", + # "bellman_ford_predecessor_and_distance", + # "negative_edge_cycle", + # "goldberg_radzik", + # "johnson", +] + + +def _weight_function(G, weight): + """Returns a function that returns the weight of an edge. + + The returned function is specifically suitable for input to + functions :func:`_dijkstra` and :func:`_bellman_ford_relaxation`. + + Parameters + ---------- + G : NetworkX graph. + + weight : string or function + If it is callable, `weight` itself is returned. If it is a string, + it is assumed to be the name of the edge attribute that represents + the weight of an edge. In that case, a function is returned that + gets the edge weight according to the specified edge attribute. + + Returns + ------- + function + This function returns a callable that accepts exactly three inputs: + a node, an node adjacent to the first one, and the edge attribute + dictionary for the eedge joining those nodes. That function returns + a number representing the weight of an edge. + + If `G` is a multigraph, and `weight` is not callable, the + minimum edge weight over all parallel edges is returned. If any edge + does not have an attribute with key `weight`, it is assumed to + have weight one. + + """ + if callable(weight): + return weight + # If the weight keyword argument is not callable, we assume it is a + # string representing the edge attribute containing the weight of + # the edge. + if G.is_multigraph(): + return lambda u, v, d: min(attr.get(weight, 1) for attr in d.values()) + return lambda u, v, data: data.get(weight, 1) + + +def dijkstra_path(G, source, target, weight="weight"): + """Returns the shortest weighted path from source to target in G. + + Uses Dijkstra's Method to compute the shortest weighted path + between two nodes in a graph. + + Parameters + ---------- + G : NetworkX graph + + source : node + Starting node + + target : node + Ending node + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + path : list + List of nodes in a shortest path. + + Raises + ------ + NodeNotFound + If `source` is not in `G`. + + NetworkXNoPath + If no path exists between source and target. + + Examples + -------- + >>> G=nx.path_graph(5) + >>> print(nx.dijkstra_path(G,0,4)) + [0, 1, 2, 3, 4] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + The weight function can be used to include node weights. + + >>> def func(u, v, d): + ... node_u_wt = G.nodes[u].get('node_weight', 1) + ... node_v_wt = G.nodes[v].get('node_weight', 1) + ... edge_wt = d.get('weight', 1) + ... return node_u_wt/2 + node_v_wt/2 + edge_wt + + In this example we take the average of start and end node + weights of an edge and add it to the weight of the edge. + + The function :func:`single_source_dijkstra` computes both + path and length-of-path if you need both, use that. + + See Also + -------- + bidirectional_dijkstra(), bellman_ford_path() + single_source_dijkstra() + """ + (length, path) = single_source_dijkstra(G, source, target=target, weight=weight) + return path + + +def dijkstra_path_length(G, source, target, weight="weight"): + """Returns the shortest weighted path length in G from source to target. + + Uses Dijkstra's Method to compute the shortest weighted path length + between two nodes in a graph. + + Parameters + ---------- + G : NetworkX graph + + source : node label + starting node for path + + target : node label + ending node for path + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + length : number + Shortest path length. + + Raises + ------ + NodeNotFound + If `source` is not in `G`. + + NetworkXNoPath + If no path exists between source and target. + + Examples + -------- + >>> G=nx.path_graph(5) + >>> print(nx.dijkstra_path_length(G,0,4)) + 4 + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + The function :func:`single_source_dijkstra` computes both + path and length-of-path if you need both, use that. + + See Also + -------- + bidirectional_dijkstra(), bellman_ford_path_length() + single_source_dijkstra() + + """ + if source == target: + return 0 + weight = _weight_function(G, weight) + length = _dijkstra(G, source, weight, target=target) + try: + return length[target] + except KeyError as e: + raise sx.SnapXNoPath("Node {} not reachable from {}".format(target, source)) from e + + +def single_source_dijkstra_path(G, source, cutoff=None, weight="weight"): + """Find shortest weighted paths in G from a source node. + + Compute shortest path between source and all other reachable + nodes for a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + source : node + Starting node for path. + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + paths : dictionary + Dictionary of shortest path lengths keyed by target. + + Raises + ------ + NodeNotFound + If `source` is not in `G`. + + Examples + -------- + >>> G=nx.path_graph(5) + >>> path=nx.single_source_dijkstra_path(G,0) + >>> path[4] + [0, 1, 2, 3, 4] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + See Also + -------- + single_source_dijkstra(), single_source_bellman_ford() + + """ + return multi_source_dijkstra_path(G, {source}, cutoff=cutoff, weight=weight) + + +def single_source_dijkstra_path_length(G, source, cutoff=None, weight="weight"): + """Find shortest weighted path lengths in G from a source node. + + Compute the shortest path length between source and all other + reachable nodes for a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + source : node label + Starting node for path + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + length : dict + Dict keyed by node to shortest path length from source. + + Raises + ------ + NodeNotFound + If `source` is not in `G`. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length = nx.single_source_dijkstra_path_length(G, 0) + >>> length[4] + 4 + >>> for node in [0, 1, 2, 3, 4]: + ... print("{}: {}".format(node, length[node])) + 0: 0 + 1: 1 + 2: 2 + 3: 3 + 4: 4 + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + See Also + -------- + single_source_dijkstra(), single_source_bellman_ford_path_length() + + """ + return multi_source_dijkstra_path_length(G, {source}, cutoff=cutoff, weight=weight) + + +def single_source_dijkstra(G, source, target=None, cutoff=None, weight="weight"): + """Find shortest weighted paths and lengths from a source node. + + Compute the shortest path length between source and all other + reachable nodes for a weighted graph. + + Uses Dijkstra's algorithm to compute shortest paths and lengths + between a source and all other reachable nodes in a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + source : node label + Starting node for path + + target : node label, optional + Ending node for path + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + distance, path : pair of dictionaries, or numeric and list. + If target is None, paths and lengths to all nodes are computed. + The return value is a tuple of two dictionaries keyed by target nodes. + The first dictionary stores distance to each target node. + The second stores the path to each target node. + If target is not None, returns a tuple (distance, path), where + distance is the distance from source to target and path is a list + representing the path from source to target. + + Raises + ------ + NodeNotFound + If `source` is not in `G`. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length, path = nx.single_source_dijkstra(G, 0) + >>> print(length[4]) + 4 + >>> for node in [0, 1, 2, 3, 4]: + ... print("{}: {}".format(node, length[node])) + 0: 0 + 1: 1 + 2: 2 + 3: 3 + 4: 4 + >>> path[4] + [0, 1, 2, 3, 4] + >>> length, path = nx.single_source_dijkstra(G, 0, 1) + >>> length + 1 + >>> path + [0, 1] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + Based on the Python cookbook recipe (119466) at + http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/119466 + + This algorithm is not guaranteed to work if edge weights + are negative or are floating point numbers + (overflows and roundoff errors can cause problems). + + See Also + -------- + single_source_dijkstra_path() + single_source_dijkstra_path_length() + single_source_bellman_ford() + """ + return multi_source_dijkstra( + G, {source}, cutoff=cutoff, target=target, weight=weight + ) + + +def multi_source_dijkstra_path(G, sources, cutoff=None, weight="weight"): + """Find shortest weighted paths in G from a given set of source + nodes. + + Compute shortest path between any of the source nodes and all other + reachable nodes for a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + sources : non-empty set of nodes + Starting nodes for paths. If this is just a set containing a + single node, then all paths computed by this function will start + from that node. If there are two or more nodes in the set, the + computed paths may begin from any one of the start nodes. + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + paths : dictionary + Dictionary of shortest paths keyed by target. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> path = nx.multi_source_dijkstra_path(G, {0, 4}) + >>> path[1] + [0, 1] + >>> path[3] + [4, 3] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + Raises + ------ + ValueError + If `sources` is empty. + NodeNotFound + If any of `sources` is not in `G`. + + See Also + -------- + multi_source_dijkstra(), multi_source_bellman_ford() + + """ + length, path = multi_source_dijkstra(G, sources, cutoff=cutoff, weight=weight) + return path + + +def multi_source_dijkstra_path_length(G, sources, cutoff=None, weight="weight"): + """Find shortest weighted path lengths in G from a given set of + source nodes. + + Compute the shortest path length between any of the source nodes and + all other reachable nodes for a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + sources : non-empty set of nodes + Starting nodes for paths. If this is just a set containing a + single node, then all paths computed by this function will start + from that node. If there are two or more nodes in the set, the + computed paths may begin from any one of the start nodes. + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + length : dict + Dict keyed by node to shortest path length to nearest source. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length = nx.multi_source_dijkstra_path_length(G, {0, 4}) + >>> for node in [0, 1, 2, 3, 4]: + ... print("{}: {}".format(node, length[node])) + 0: 0 + 1: 1 + 2: 2 + 3: 1 + 4: 0 + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + Raises + ------ + ValueError + If `sources` is empty. + NodeNotFound + If any of `sources` is not in `G`. + + See Also + -------- + multi_source_dijkstra() + + """ + if not sources: + raise ValueError("sources must not be empty") + weight = _weight_function(G, weight) + return _dijkstra_multisource(G, sources, weight, cutoff=cutoff) + + +def multi_source_dijkstra(G, sources, target=None, cutoff=None, weight="weight"): + """Find shortest weighted paths and lengths from a given set of + source nodes. + + Uses Dijkstra's algorithm to compute the shortest paths and lengths + between one of the source nodes and the given `target`, or all other + reachable nodes if not specified, for a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + sources : non-empty set of nodes + Starting nodes for paths. If this is just a set containing a + single node, then all paths computed by this function will start + from that node. If there are two or more nodes in the set, the + computed paths may begin from any one of the start nodes. + + target : node label, optional + Ending node for path + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + distance, path : pair of dictionaries, or numeric and list + If target is None, returns a tuple of two dictionaries keyed by node. + The first dictionary stores distance from one of the source nodes. + The second stores the path from one of the sources to that node. + If target is not None, returns a tuple of (distance, path) where + distance is the distance from source to target and path is a list + representing the path from source to target. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length, path = nx.multi_source_dijkstra(G, {0, 4}) + >>> for node in [0, 1, 2, 3, 4]: + ... print("{}: {}".format(node, length[node])) + 0: 0 + 1: 1 + 2: 2 + 3: 1 + 4: 0 + >>> path[1] + [0, 1] + >>> path[3] + [4, 3] + + >>> length, path = nx.multi_source_dijkstra(G, {0, 4}, 1) + >>> length + 1 + >>> path + [0, 1] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The weight function can be used to hide edges by returning None. + So ``weight = lambda u, v, d: 1 if d['color']=="red" else None`` + will find the shortest red path. + + Based on the Python cookbook recipe (119466) at + http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/119466 + + This algorithm is not guaranteed to work if edge weights + are negative or are floating point numbers + (overflows and roundoff errors can cause problems). + + Raises + ------ + ValueError + If `sources` is empty. + NodeNotFound + If any of `sources` is not in `G`. + + See Also + -------- + multi_source_dijkstra_path() + multi_source_dijkstra_path_length() + + """ + if not sources: + raise ValueError("sources must not be empty") + if target in sources: + return (0, [target]) + weight = _weight_function(G, weight) + paths = {source: [source] for source in sources} # dictionary of paths + dist = _dijkstra_multisource( + G, sources, weight, paths=paths, cutoff=cutoff, target=target + ) + if target is None: + return (dist, paths) + try: + return (dist[target], paths[target]) + except KeyError as e: + raise sx.NetworkXNoPath("No path to {}.".format(target)) from e + + +def _dijkstra(G, source, weight, pred=None, paths=None, cutoff=None, target=None): + """Uses Dijkstra's algorithm to find shortest weighted paths from a + single source. + + This is a convenience function for :func:`_dijkstra_multisource` + with all the arguments the same, except the keyword argument + `sources` set to ``[source]``. + + """ + return _dijkstra_multisource( + G, [source], weight, pred=pred, paths=paths, cutoff=cutoff, target=target + ) + + +def _dijkstra_multisource( + G, sources, weight, pred=None, paths=None, cutoff=None, target=None +): + """Uses Dijkstra's algorithm to find shortest weighted paths + + Parameters + ---------- + G : NetworkX graph + + sources : non-empty iterable of nodes + Starting nodes for paths. If this is just an iterable containing + a single node, then all paths computed by this function will + start from that node. If there are two or more nodes in this + iterable, the computed paths may begin from any one of the start + nodes. + + weight: function + Function with (u, v, data) input that returns that edges weight + + pred: dict of lists, optional(default=None) + dict to store a list of predecessors keyed by that node + If None, predecessors are not stored. + + paths: dict, optional (default=None) + dict to store the path list from source to each node, keyed by node. + If None, paths are not stored. + + target : node label, optional + Ending node for path. Search is halted when target is found. + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + Returns + ------- + distance : dictionary + A mapping from node to shortest distance to that node from one + of the source nodes. + + Raises + ------ + NodeNotFound + If any of `sources` is not in `G`. + + Notes + ----- + The optional predecessor and path dictionaries can be accessed by + the caller through the original pred and paths objects passed + as arguments. No need to explicitly return pred or paths. + + """ + G_succ = G._succ if G.is_directed() else G._adj + + push = heappush + pop = heappop + dist = {} # dictionary of final distances + seen = {} + # fringe is heapq with 3-tuples (distance,c,node) + # use the count c to avoid comparing nodes (may not be able to) + c = count() + fringe = [] + for source in sources: + if source not in G: + raise sx.NodeNotFound("Source {} not in G".format(source)) + seen[source] = 0 + push(fringe, (0, next(c), source)) + while fringe: + (d, _, v) = pop(fringe) + if v in dist: + continue # already searched this node. + dist[v] = d + if v == target: + break + for u, e in G_succ[v].items(): + cost = weight(v, u, e) + if cost is None: + continue + vu_dist = dist[v] + cost + if cutoff is not None: + if vu_dist > cutoff: + continue + if u in dist: + u_dist = dist[u] + if vu_dist < u_dist: + raise ValueError("Contradictory paths found:", "negative weights?") + elif pred is not None and vu_dist == u_dist: + pred[u].append(v) + elif u not in seen or vu_dist < seen[u]: + seen[u] = vu_dist + push(fringe, (vu_dist, next(c), u)) + if paths is not None: + paths[u] = paths[v] + [u] + if pred is not None: + pred[u] = [v] + elif vu_dist == seen[u]: + if pred is not None: + pred[u].append(v) + + # The optional predecessor and path dictionaries can be accessed + # by the caller via the pred and paths objects passed as arguments. + return dist + + +def dijkstra_predecessor_and_distance(G, source, cutoff=None, weight="weight"): + """Compute weighted shortest path length and predecessors. + + Uses Dijkstra's Method to obtain the shortest weighted paths + and return dictionaries of predecessors for each node and + distance for each node from the `source`. + + Parameters + ---------- + G : NetworkX graph + + source : node label + Starting node for path + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + pred, distance : dictionaries + Returns two dictionaries representing a list of predecessors + of a node and the distance to each node. + Warning: If target is specified, the dicts are incomplete as they + only contain information for the nodes along a path to target. + + Raises + ------ + NodeNotFound + If `source` is not in `G`. + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The list of predecessors contains more than one element only when + there are more than one shortest paths to the key node. + + Examples + -------- + >>> import networkx as nx + >>> G = nx.path_graph(5, create_using = nx.DiGraph()) + >>> pred, dist = nx.dijkstra_predecessor_and_distance(G, 0) + >>> sorted(pred.items()) + [(0, []), (1, [0]), (2, [1]), (3, [2]), (4, [3])] + >>> sorted(dist.items()) + [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] + + >>> pred, dist = nx.dijkstra_predecessor_and_distance(G, 0, 1) + >>> sorted(pred.items()) + [(0, []), (1, [0])] + >>> sorted(dist.items()) + [(0, 0), (1, 1)] + """ + + weight = _weight_function(G, weight) + pred = {source: []} # dictionary of predecessors + return (pred, _dijkstra(G, source, weight, pred=pred, cutoff=cutoff)) + + +def all_pairs_dijkstra(G, cutoff=None, weight="weight"): + """Find shortest weighted paths and lengths between all nodes. + + Parameters + ---------- + G : NetworkX graph + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edge[u][v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Yields + ------ + (node, (distance, path)) : (node obj, (dict, dict)) + Each source node has two associated dicts. The first holds distance + keyed by target and the second holds paths keyed by target. + (See single_source_dijkstra for the source/target node terminology.) + If desired you can apply `dict()` to this function to create a dict + keyed by source node to the two dicts. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> len_path = dict(nx.all_pairs_dijkstra(G)) + >>> print(len_path[3][0][1]) + 2 + >>> for node in [0, 1, 2, 3, 4]: + ... print("3 - {}: {}".format(node, len_path[3][0][node]) + 3 - 0: 3 + 3 - 1: 2 + 3 - 2: 1 + 3 - 3: 0 + 3 - 4: 1 + >>> len_path[3][1][1] + [3, 2, 1] + >>> for n, (dist, path) in nx.all_pairs_dijkstra(G): + ... print(path[1]) + [0, 1] + [1] + [2, 1] + [3, 2, 1] + [4, 3, 2, 1] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The yielded dicts only have keys for reachable nodes. + """ + for n in G: + dist, path = single_source_dijkstra(G, n, cutoff=cutoff, weight=weight) + yield (n, (dist, path)) + + +def all_pairs_dijkstra_path_length(G, cutoff=None, weight="weight"): + """Compute shortest path lengths between all nodes in a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + distance : iterator + (source, dictionary) iterator with dictionary keyed by target and + shortest path length as the key value. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length = dict(nx.all_pairs_dijkstra_path_length(G)) + >>> for node in [0, 1, 2, 3, 4]: + ... print("1 - {}: {}".format(node, length[1][node])) + 1 - 0: 1 + 1 - 1: 0 + 1 - 2: 1 + 1 - 3: 2 + 1 - 4: 3 + >>> length[3][2] + 1 + >>> length[2][2] + 0 + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + The dictionary returned only has keys for reachable node pairs. + """ + length = single_source_dijkstra_path_length + for n in G: + yield (n, length(G, n, cutoff=cutoff, weight=weight)) + + +def all_pairs_dijkstra_path(G, cutoff=None, weight="weight"): + """Compute shortest paths between all nodes in a weighted graph. + + Parameters + ---------- + G : NetworkX graph + + cutoff : integer or float, optional + Depth to stop the search. Only return paths with length <= cutoff. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + distance : dictionary + Dictionary, keyed by source and target, of shortest paths. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> path = dict(nx.all_pairs_dijkstra_path(G)) + >>> print(path[0][4]) + [0, 1, 2, 3, 4] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + See Also + -------- + floyd_warshall(), all_pairs_bellman_ford_path() + + """ + path = single_source_dijkstra_path + # TODO This can be trivially parallelized. + for n in G: + yield (n, path(G, n, cutoff=cutoff, weight=weight)) + + # def bellman_ford_predecessor_and_distance( + # G, source, target=None, weight="weight", heuristic=False + # ): + # """Compute shortest path lengths and predecessors on shortest paths + # in weighted graphs. + + # The algorithm has a running time of $O(mn)$ where $n$ is the number of + # nodes and $m$ is the number of edges. It is slower than Dijkstra but + # can handle negative edge weights. + + # Parameters + # ---------- + # G : NetworkX graph + # The algorithm works for all types of graphs, including directed + # graphs and multigraphs. + + # source: node label + # Starting node for path + + # weight : string or function + # If this is a string, then edge weights will be accessed via the + # edge attribute with this key (that is, the weight of the edge + # joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + # such edge attribute exists, the weight of the edge is assumed to + # be one. + + # If this is a function, the weight of an edge is the value + # returned by the function. The function must accept exactly three + # positional arguments: the two endpoints of an edge and the + # dictionary of edge attributes for that edge. The function must + # return a number. + + # heuristic : bool + # Determines whether to use a heuristic to early detect negative + # cycles at a hopefully negligible cost. + + # Returns + # ------- + # pred, dist : dictionaries + # Returns two dictionaries keyed by node to predecessor in the + # path and to the distance from the source respectively. + + # Raises + # ------ + # NodeNotFound + # If `source` is not in `G`. + + # NetworkXUnbounded + # If the (di)graph contains a negative cost (di)cycle, the + # algorithm raises an exception to indicate the presence of the + # negative cost (di)cycle. Note: any negative weight edge in an + # undirected graph is a negative cost cycle. + + # Examples + # -------- + # >>> import networkx as nx + # >>> G = nx.path_graph(5, create_using = nx.DiGraph()) + # >>> pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0) + # >>> sorted(pred.items()) + # [(0, []), (1, [0]), (2, [1]), (3, [2]), (4, [3])] + # >>> sorted(dist.items()) + # [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] + + # >>> pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0, 1) + # >>> sorted(pred.items()) + # [(0, []), (1, [0]), (2, [1]), (3, [2]), (4, [3])] + # >>> sorted(dist.items()) + # [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] + + # >>> G = nx.cycle_graph(5, create_using = nx.DiGraph()) + # >>> G[1][2]['weight'] = -7 + # >>> nx.bellman_ford_predecessor_and_distance(G, 0) + # Traceback (most recent call last): + # ... + # networkx.exception.NetworkXUnbounded: Negative cost cycle detected. + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # The dictionaries returned only have keys for nodes reachable from + # the source. + + # In the case where the (di)graph is not connected, if a component + # not containing the source contains a negative cost (di)cycle, it + # will not be detected. + + # In NetworkX v2.1 and prior, the source node had predecessor `[None]`. + # In NetworkX v2.2 this changed to the source node having predecessor `[]` + # """ + # if source not in G: + # raise nx.NodeNotFound("Node {} is not found in the graph".format(source)) + # weight = _weight_function(G, weight) + # if any(weight(u, v, d) < 0 for u, v, d in nx.selfloop_edges(G, data=True)): + # raise nx.NetworkXUnbounded("Negative cost cycle detected.") + + # dist = {source: 0} + # pred = {source: []} + + # if len(G) == 1: + # return pred, dist + + # weight = _weight_function(G, weight) + + # dist = _bellman_ford( + # G, [source], weight, pred=pred, dist=dist, target=target, heuristic=heuristic + # ) + # return (pred, dist) + + # def _bellman_ford( + # G, source, weight, pred=None, paths=None, dist=None, target=None, heuristic=True + # ): + # """Relaxation loop for Bellman–Ford algorithm. + + # This is an implementation of the SPFA variant. + # See https://en.wikipedia.org/wiki/Shortest_Path_Faster_Algorithm + + # Parameters + # ---------- + # G : NetworkX graph + + # source: list + # List of source nodes. The shortest path from any of the source + # nodes will be found if multiple sources are provided. + + # weight : function + # The weight of an edge is the value returned by the function. The + # function must accept exactly three positional arguments: the two + # endpoints of an edge and the dictionary of edge attributes for + # that edge. The function must return a number. + + # pred: dict of lists, optional (default=None) + # dict to store a list of predecessors keyed by that node + # If None, predecessors are not stored + + # paths: dict, optional (default=None) + # dict to store the path list from source to each node, keyed by node + # If None, paths are not stored + + # dist: dict, optional (default=None) + # dict to store distance from source to the keyed node + # If None, returned dist dict contents default to 0 for every node in the + # source list + + # target: node label, optional + # Ending node for path. Path lengths to other destinations may (and + # probably will) be incorrect. + + # heuristic : bool + # Determines whether to use a heuristic to early detect negative + # cycles at a hopefully negligible cost. + + # Returns + # ------- + # Returns a dict keyed by node to the distance from the source. + # Dicts for paths and pred are in the mutated input dicts by those names. + + # Raises + # ------ + # NodeNotFound + # If any of `source` is not in `G`. + + # NetworkXUnbounded + # If the (di)graph contains a negative cost (di)cycle, the + # algorithm raises an exception to indicate the presence of the + # negative cost (di)cycle. Note: any negative weight edge in an + # undirected graph is a negative cost cycle + # """ + # for s in source: + # if s not in G: + # raise nx.NodeNotFound("Source {s} not in G".format(s)) + + # if pred is None: + # pred = {v: [] for v in source} + + # if dist is None: + # dist = {v: 0 for v in source} + + # # Heuristic Storage setup. Note: use None because nodes cannot be None + # nonexistent_edge = (None, None) + # pred_edge = {v: None for v in source} + # recent_update = {v: nonexistent_edge for v in source} + + # G_succ = G.succ if G.is_directed() else G.adj + # inf = float("inf") + # n = len(G) + + # count = {} + # q = deque(source) + # in_q = set(source) + # while q: + # u = q.popleft() + # in_q.remove(u) + + # # Skip relaxations if any of the predecessors of u is in the queue. + # if all(pred_u not in in_q for pred_u in pred[u]): + # dist_u = dist[u] + # for v, e in G_succ[u].items(): + # dist_v = dist_u + weight(u, v, e) + + # if dist_v < dist.get(v, inf): + # # In this conditional branch we are updating the path with v. + # # If it happens that some earlier update also added node v + # # that implies the existence of a negative cycle since + # # after the update node v would lie on the update path twice. + # # The update path is stored up to one of the source nodes, + # # therefore u is always in the dict recent_update + # if heuristic: + # if v in recent_update[u]: + # raise nx.NetworkXUnbounded("Negative cost cycle detected.") + # # Transfer the recent update info from u to v if the + # # same source node is the head of the update path. + # # If the source node is responsible for the cost update, + # # then clear the history and use it instead. + # if v in pred_edge and pred_edge[v] == u: + # recent_update[v] = recent_update[u] + # else: + # recent_update[v] = (u, v) + + # if v not in in_q: + # q.append(v) + # in_q.add(v) + # count_v = count.get(v, 0) + 1 + # if count_v == n: + # raise nx.NetworkXUnbounded("Negative cost cycle detected.") + # count[v] = count_v + # dist[v] = dist_v + # pred[v] = [u] + # pred_edge[v] = u + + # elif dist.get(v) is not None and dist_v == dist.get(v): + # pred[v].append(u) + + # if paths is not None: + # sources = set(source) + # dsts = [target] if target is not None else pred + # for dst in dsts: + # gen = _build_paths_from_predecessors(sources, dst, pred) + # paths[dst] = next(gen) + + # return dist + + # def bellman_ford_path(G, source, target, weight="weight"): + # """Returns the shortest path from source to target in a weighted graph G. + + # Parameters + # ---------- + # G : NetworkX graph + + # source : node + # Starting node + + # target : node + # Ending node + + # weight: string, optional (default='weight') + # Edge data key corresponding to the edge weight + + # Returns + # ------- + # path : list + # List of nodes in a shortest path. + + # Raises + # ------ + # NodeNotFound + # If `source` is not in `G`. + + # NetworkXNoPath + # If no path exists between source and target. + + # Examples + # -------- + # >>> G=nx.path_graph(5) + # >>> print(nx.bellman_ford_path(G, 0, 4)) + # [0, 1, 2, 3, 4] + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # See Also + # -------- + # dijkstra_path(), bellman_ford_path_length() + # """ + # length, path = single_source_bellman_ford(G, source, target=target, weight=weight) + # return path + + # def bellman_ford_path_length(G, source, target, weight="weight"): + # """Returns the shortest path length from source to target + # in a weighted graph. + + # Parameters + # ---------- + # G : NetworkX graph + + # source : node label + # starting node for path + + # target : node label + # ending node for path + + # weight: string, optional (default='weight') + # Edge data key corresponding to the edge weight + + # Returns + # ------- + # length : number + # Shortest path length. + + # Raises + # ------ + # NodeNotFound + # If `source` is not in `G`. + + # NetworkXNoPath + # If no path exists between source and target. + + # Examples + # -------- + # >>> G=nx.path_graph(5) + # >>> print(nx.bellman_ford_path_length(G,0,4)) + # 4 + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # See Also + # -------- + # dijkstra_path_length(), bellman_ford_path() + # """ + # if source == target: + # return 0 + + # weight = _weight_function(G, weight) + + # length = _bellman_ford(G, [source], weight, target=target) + + # try: + # return length[target] + # except KeyError as e: + # raise nx.NetworkXNoPath("node {} not reachable from {}".format(target, source)) from e + + # def single_source_bellman_ford_path(G, source, weight="weight"): + # """Compute shortest path between source and all other reachable + # nodes for a weighted graph. + + # Parameters + # ---------- + # G : NetworkX graph + + # source : node + # Starting node for path. + + # weight: string, optional (default='weight') + # Edge data key corresponding to the edge weight + + # Returns + # ------- + # paths : dictionary + # Dictionary of shortest path lengths keyed by target. + + # Raises + # ------ + # NodeNotFound + # If `source` is not in `G`. + + # Examples + # -------- + # >>> G=nx.path_graph(5) + # >>> path=nx.single_source_bellman_ford_path(G,0) + # >>> path[4] + # [0, 1, 2, 3, 4] + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # See Also + # -------- + # single_source_dijkstra(), single_source_bellman_ford() + + # """ + # (length, path) = single_source_bellman_ford(G, source, weight=weight) + # return path + + # def single_source_bellman_ford_path_length(G, source, weight="weight"): + # """Compute the shortest path length between source and all other + # reachable nodes for a weighted graph. + + # Parameters + # ---------- + # G : NetworkX graph + + # source : node label + # Starting node for path + + # weight: string, optional (default='weight') + # Edge data key corresponding to the edge weight. + + # Returns + # ------- + # length : iterator + # (target, shortest path length) iterator + + # Raises + # ------ + # NodeNotFound + # If `source` is not in `G`. + + # Examples + # -------- + # >>> G = nx.path_graph(5) + # >>> length = dict(nx.single_source_bellman_ford_path_length(G, 0)) + # >>> length[4] + # 4 + # >>> for node in [0, 1, 2, 3, 4]: + # ... print("{}: {}".format(node, length[node])) + # 0: 0 + # 1: 1 + # 2: 2 + # 3: 3 + # 4: 4 + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # See Also + # -------- + # single_source_dijkstra(), single_source_bellman_ford() + + # """ + # weight = _weight_function(G, weight) + # return _bellman_ford(G, [source], weight) + + # def single_source_bellman_ford(G, source, target=None, weight="weight"): + # """Compute shortest paths and lengths in a weighted graph G. + + # Uses Bellman-Ford algorithm for shortest paths. + + # Parameters + # ---------- + # G : NetworkX graph + + # source : node label + # Starting node for path + + # target : node label, optional + # Ending node for path + + # Returns + # ------- + # distance, path : pair of dictionaries, or numeric and list + # If target is None, returns a tuple of two dictionaries keyed by node. + # The first dictionary stores distance from one of the source nodes. + # The second stores the path from one of the sources to that node. + # If target is not None, returns a tuple of (distance, path) where + # distance is the distance from source to target and path is a list + # representing the path from source to target. + + # Raises + # ------ + # NodeNotFound + # If `source` is not in `G`. + + # Examples + # -------- + # >>> G = nx.path_graph(5) + # >>> length, path = nx.single_source_bellman_ford(G, 0) + # >>> print(length[4]) + # 4 + # >>> for node in [0, 1, 2, 3, 4]: + # ... print("{node}: {length[node]}".format(node, length[node])) + # 0: 0 + # 1: 1 + # 2: 2 + # 3: 3 + # 4: 4 + # >>> path[4] + # [0, 1, 2, 3, 4] + # >>> length, path = nx.single_source_bellman_ford(G, 0, 1) + # >>> length + # 1 + # >>> path + # [0, 1] + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # See Also + # -------- + # single_source_dijkstra() + # single_source_bellman_ford_path() + # single_source_bellman_ford_path_length() + # """ + # if source == target: + # return (0, [source]) + + # weight = _weight_function(G, weight) + + # paths = {source: [source]} # dictionary of paths + # dist = _bellman_ford(G, [source], weight, paths=paths, target=target) + # if target is None: + # return (dist, paths) + # try: + # return (dist[target], paths[target]) + # except KeyError as e: + # msg = "Node {} not reachable from {}".format(target, source) + # raise nx.NetworkXNoPath(msg) from e + + # def all_pairs_bellman_ford_path_length(G, weight="weight"): + # """ Compute shortest path lengths between all nodes in a weighted graph. + + # Parameters + # ---------- + # G : NetworkX graph + + # weight: string, optional (default='weight') + # Edge data key corresponding to the edge weight + + # Returns + # ------- + # distance : iterator + # (source, dictionary) iterator with dictionary keyed by target and + # shortest path length as the key value. + + # Examples + # -------- + # >>> G = nx.path_graph(5) + # >>> length = dict(nx.all_pairs_bellman_ford_path_length(G)) + # >>> for node in [0, 1, 2, 3, 4]: + # ... print("1 - {node}: {length[1][node]}".format(node, length[1][node])) + # 1 - 0: 1 + # 1 - 1: 0 + # 1 - 2: 1 + # 1 - 3: 2 + # 1 - 4: 3 + # >>> length[3][2] + # 1 + # >>> length[2][2] + # 0 + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # The dictionary returned only has keys for reachable node pairs. + # """ + # length = single_source_bellman_ford_path_length + # for n in G: + # yield (n, dict(length(G, n, weight=weight))) + + # def all_pairs_bellman_ford_path(G, weight="weight"): + # """ Compute shortest paths between all nodes in a weighted graph. + + # Parameters + # ---------- + # G : NetworkX graph + + # weight: string, optional (default='weight') + # Edge data key corresponding to the edge weight + + # Returns + # ------- + # distance : dictionary + # Dictionary, keyed by source and target, of shortest paths. + + # Examples + # -------- + # >>> G = nx.path_graph(5) + # >>> path = dict(nx.all_pairs_bellman_ford_path(G)) + # >>> print(path[0][4]) + # [0, 1, 2, 3, 4] + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # See Also + # -------- + # floyd_warshall(), all_pairs_dijkstra_path() + + # """ + # path = single_source_bellman_ford_path + # # TODO This can be trivially parallelized. + # for n in G: + # yield (n, path(G, n, weight=weight)) + + # def goldberg_radzik(G, source, weight="weight"): + # """Compute shortest path lengths and predecessors on shortest paths + # in weighted graphs. + + # The algorithm has a running time of $O(mn)$ where $n$ is the number of + # nodes and $m$ is the number of edges. It is slower than Dijkstra but + # can handle negative edge weights. + + # Parameters + # ---------- + # G : NetworkX graph + # The algorithm works for all types of graphs, including directed + # graphs and multigraphs. + + # source: node label + # Starting node for path + + # weight : string or function + # If this is a string, then edge weights will be accessed via the + # edge attribute with this key (that is, the weight of the edge + # joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + # such edge attribute exists, the weight of the edge is assumed to + # be one. + + # If this is a function, the weight of an edge is the value + # returned by the function. The function must accept exactly three + # positional arguments: the two endpoints of an edge and the + # dictionary of edge attributes for that edge. The function must + # return a number. + + # Returns + # ------- + # pred, dist : dictionaries + # Returns two dictionaries keyed by node to predecessor in the + # path and to the distance from the source respectively. + + # Raises + # ------ + # NodeNotFound + # If `source` is not in `G`. + + # NetworkXUnbounded + # If the (di)graph contains a negative cost (di)cycle, the + # algorithm raises an exception to indicate the presence of the + # negative cost (di)cycle. Note: any negative weight edge in an + # undirected graph is a negative cost cycle. + + # Examples + # -------- + # >>> import networkx as nx + # >>> G = nx.path_graph(5, create_using = nx.DiGraph()) + # >>> pred, dist = nx.goldberg_radzik(G, 0) + # >>> sorted(pred.items()) + # [(0, None), (1, 0), (2, 1), (3, 2), (4, 3)] + # >>> sorted(dist.items()) + # [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)] + + # >>> G = nx.cycle_graph(5, create_using = nx.DiGraph()) + # >>> G[1][2]['weight'] = -7 + # >>> nx.goldberg_radzik(G, 0) + # Traceback (most recent call last): + # ... + # networkx.exception.NetworkXUnbounded: Negative cost cycle detected. + + # Notes + # ----- + # Edge weight attributes must be numerical. + # Distances are calculated as sums of weighted edges traversed. + + # The dictionaries returned only have keys for nodes reachable from + # the source. + + # In the case where the (di)graph is not connected, if a component + # not containing the source contains a negative cost (di)cycle, it + # will not be detected. + + # """ + # if source not in G: + # raise nx.NodeNotFound("Node {} is not found in the graph".format(source)) + # weight = _weight_function(G, weight) + # if any(weight(u, v, d) < 0 for u, v, d in nx.selfloop_edges(G, data=True)): + # raise nx.NetworkXUnbounded("Negative cost cycle detected.") + + # if len(G) == 1: + # return {source: None}, {source: 0} + + # if G.is_directed(): + # G_succ = G.succ + # else: + # G_succ = G.adj + + # inf = float("inf") + # d = {u: inf for u in G} + # d[source] = 0 + # pred = {source: None} + + def topo_sort(relabeled): + """Topologically sort nodes relabeled in the previous round and detect + negative cycles. + """ + # List of nodes to scan in this round. Denoted by A in Goldberg and + # Radzik's paper. + to_scan = [] + # In the DFS in the loop below, neg_count records for each node the + # number of edges of negative reduced costs on the path from a DFS root + # to the node in the DFS forest. The reduced cost of an edge (u, v) is + # defined as d[u] + weight[u][v] - d[v]. + # + # neg_count also doubles as the DFS visit marker array. + neg_count = {} + for u in relabeled: + # Skip visited nodes. + if u in neg_count: + continue + d_u = d[u] + # Skip nodes without out-edges of negative reduced costs. + if all(d_u + weight(u, v, e) >= d[v] for v, e in G_succ[u].items()): + continue + # Nonrecursive DFS that inserts nodes reachable from u via edges of + # nonpositive reduced costs into to_scan in (reverse) topological + # order. + stack = [(u, iter(G_succ[u].items()))] + in_stack = {u} + neg_count[u] = 0 + while stack: + u, it = stack[-1] + try: + v, e = next(it) + except StopIteration: + to_scan.append(u) + stack.pop() + in_stack.remove(u) + continue + t = d[u] + weight(u, v, e) + d_v = d[v] + if t <= d_v: + is_neg = t < d_v + d[v] = t + pred[v] = u + if v not in neg_count: + neg_count[v] = neg_count[u] + int(is_neg) + stack.append((v, iter(G_succ[v].items()))) + in_stack.add(v) + elif v in in_stack and neg_count[u] + int(is_neg) > neg_count[v]: + # (u, v) is a back edge, and the cycle formed by the + # path v to u and (u, v) contains at least one edge of + # negative reduced cost. The cycle must be of negative + # cost. + raise nx.NetworkXUnbounded("Negative cost cycle detected.") + to_scan.reverse() + return to_scan + + def relax(to_scan): + """Relax out-edges of relabeled nodes. + """ + relabeled = set() + # Scan nodes in to_scan in topological order and relax incident + # out-edges. Add the relabled nodes to labeled. + for u in to_scan: + d_u = d[u] + for v, e in G_succ[u].items(): + w_e = weight(u, v, e) + if d_u + w_e < d[v]: + d[v] = d_u + w_e + pred[v] = u + relabeled.add(v) + return relabeled + + # Set of nodes relabled in the last round of scan operations. Denoted by B + # in Goldberg and Radzik's paper. + relabeled = {source} + + while relabeled: + to_scan = topo_sort(relabeled) + relabeled = relax(to_scan) + + d = {u: d[u] for u in pred} + return pred, d + + +# def negative_edge_cycle(G, weight="weight", heuristic=True): +# """Returns True if there exists a negative edge cycle anywhere in G. + +# Parameters +# ---------- +# G : NetworkX graph + +# weight : string or function +# If this is a string, then edge weights will be accessed via the +# edge attribute with this key (that is, the weight of the edge +# joining `u` to `v` will be ``G.edges[u, v][weight]``). If no +# such edge attribute exists, the weight of the edge is assumed to +# be one. + +# If this is a function, the weight of an edge is the value +# returned by the function. The function must accept exactly three +# positional arguments: the two endpoints of an edge and the +# dictionary of edge attributes for that edge. The function must +# return a number. + +# heuristic : bool +# Determines whether to use a heuristic to early detect negative +# cycles at a negligible cost. In case of graphs with a negative cycle, +# the performance of detection increases by at least an order of magnitude. + +# Returns +# ------- +# negative_cycle : bool +# True if a negative edge cycle exists, otherwise False. + +# Examples +# -------- +# >>> import networkx as nx +# >>> G = nx.cycle_graph(5, create_using = nx.DiGraph()) +# >>> print(nx.negative_edge_cycle(G)) +# False +# >>> G[1][2]['weight'] = -7 +# >>> print(nx.negative_edge_cycle(G)) +# True + +# Notes +# ----- +# Edge weight attributes must be numerical. +# Distances are calculated as sums of weighted edges traversed. + +# This algorithm uses bellman_ford_predecessor_and_distance() but finds +# negative cycles on any component by first adding a new node connected to +# every node, and starting bellman_ford_predecessor_and_distance on that +# node. It then removes that extra node. +# """ +# newnode = generate_unique_node() +# G.add_edges_from([(newnode, n) for n in G]) + +# try: +# bellman_ford_predecessor_and_distance(G, newnode, weight, heuristic=heuristic) +# except nx.NetworkXUnbounded: +# return True +# finally: +# G.remove_node(newnode) +# return False + + +def bidirectional_dijkstra(G, source, target, weight="weight"): + r"""Dijkstra's algorithm for shortest paths using bidirectional search. + + Parameters + ---------- + G : NetworkX graph + + source : node + Starting node. + + target : node + Ending node. + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + length, path : number and list + length is the distance from source to target. + path is a list of nodes on a path from source to target. + + Raises + ------ + NodeNotFound + If either `source` or `target` is not in `G`. + + NetworkXNoPath + If no path exists between source and target. + + Examples + -------- + >>> G = nx.path_graph(5) + >>> length, path = nx.bidirectional_dijkstra(G, 0, 4) + >>> print(length) + 4 + >>> print(path) + [0, 1, 2, 3, 4] + + Notes + ----- + Edge weight attributes must be numerical. + Distances are calculated as sums of weighted edges traversed. + + In practice bidirectional Dijkstra is much more than twice as fast as + ordinary Dijkstra. + + Ordinary Dijkstra expands nodes in a sphere-like manner from the + source. The radius of this sphere will eventually be the length + of the shortest path. Bidirectional Dijkstra will expand nodes + from both the source and the target, making two spheres of half + this radius. Volume of the first sphere is `\pi*r*r` while the + others are `2*\pi*r/2*r/2`, making up half the volume. + + This algorithm is not guaranteed to work if edge weights + are negative or are floating point numbers + (overflows and roundoff errors can cause problems). + + See Also + -------- + shortest_path + shortest_path_length + """ + if source not in G or target not in G: + msg = "Either source {} or target {} is not in G".format(source, target) + raise nx.NodeNotFound(msg) + + if source == target: + return (0, [source]) + + weight = _weight_function(G, weight) + push = heappush + pop = heappop + # Init: [Forward, Backward] + dists = [{}, {}] # dictionary of final distances + paths = [{source: [source]}, {target: [target]}] # dictionary of paths + fringe = [[], []] # heap of (distance, node) for choosing node to expand + seen = [{source: 0}, {target: 0}] # dict of distances to seen nodes + c = count() + # initialize fringe heap + push(fringe[0], (0, next(c), source)) + push(fringe[1], (0, next(c), target)) + # neighs for extracting correct neighbor information + if G.is_directed(): + neighs = [G._succ, G._pred] + else: + neighs = [G._adj, G._adj] + # variables to hold shortest discovered path + # finaldist = 1e30000 + finalpath = [] + dir = 1 + while fringe[0] and fringe[1]: + # choose direction + # dir == 0 is forward direction and dir == 1 is back + dir = 1 - dir + # extract closest to expand + (dist, _, v) = pop(fringe[dir]) + if v in dists[dir]: + # Shortest path to v has already been found + continue + # update distance + dists[dir][v] = dist # equal to seen[dir][v] + if v in dists[1 - dir]: + # if we have scanned v in both directions we are done + # we have now discovered the shortest path + return (finaldist, finalpath) + + for w, d in neighs[dir][v].items(): + if dir == 0: # forward + vwLength = dists[dir][v] + weight(v, w, d) + else: # back, must remember to change v,w->w,v + vwLength = dists[dir][v] + weight(w, v, d) + if w in dists[dir]: + if vwLength < dists[dir][w]: + raise ValueError("Contradictory paths found: negative weights?") + elif w not in seen[dir] or vwLength < seen[dir][w]: + # relaxing + seen[dir][w] = vwLength + push(fringe[dir], (vwLength, next(c), w)) + paths[dir][w] = paths[dir][v] + [w] + if w in seen[0] and w in seen[1]: + # see if this path is better than than the already + # discovered shortest path + totaldist = seen[0][w] + seen[1][w] + if finalpath == [] or finaldist > totaldist: + finaldist = totaldist + revpath = paths[1][w][:] + revpath.reverse() + finalpath = paths[0][w] + revpath[1:] + raise nx.NetworkXNoPath("No path between {} and {}.".format(source, target)) + + +def johnson(G, weight="weight"): + r"""Uses Johnson's Algorithm to compute shortest paths. + + Johnson's Algorithm finds a shortest path between each pair of + nodes in a weighted graph even if negative weights are present. + + Parameters + ---------- + G : NetworkX graph + + weight : string or function + If this is a string, then edge weights will be accessed via the + edge attribute with this key (that is, the weight of the edge + joining `u` to `v` will be ``G.edges[u, v][weight]``). If no + such edge attribute exists, the weight of the edge is assumed to + be one. + + If this is a function, the weight of an edge is the value + returned by the function. The function must accept exactly three + positional arguments: the two endpoints of an edge and the + dictionary of edge attributes for that edge. The function must + return a number. + + Returns + ------- + distance : dictionary + Dictionary, keyed by source and target, of shortest paths. + + Raises + ------ + NetworkXError + If given graph is not weighted. + + Examples + -------- + >>> import networkx as nx + >>> graph = nx.DiGraph() + >>> graph.add_weighted_edges_from([('0', '3', 3), ('0', '1', -5), + ... ('0', '2', 2), ('1', '2', 4), ('2', '3', 1)]) + >>> paths = nx.johnson(graph, weight='weight') + >>> paths['0']['2'] + ['0', '1', '2'] + + Notes + ----- + Johnson's algorithm is suitable even for graphs with negative weights. It + works by using the Bellman–Ford algorithm to compute a transformation of + the input graph that removes all negative weights, allowing Dijkstra's + algorithm to be used on the transformed graph. + + The time complexity of this algorithm is $O(n^2 \log n + n m)$, + where $n$ is the number of nodes and $m$ the number of edges in the + graph. For dense graphs, this may be faster than the Floyd–Warshall + algorithm. + + See Also + -------- + floyd_warshall_predecessor_and_distance + floyd_warshall_numpy + all_pairs_shortest_path + all_pairs_shortest_path_length + all_pairs_dijkstra_path + bellman_ford_predecessor_and_distance + all_pairs_bellman_ford_path + all_pairs_bellman_ford_path_length + + """ + if not nx.is_weighted(G, weight=weight): + raise nx.NetworkXError("Graph is not weighted.") + + dist = {v: 0 for v in G} + pred = {v: [] for v in G} + weight = _weight_function(G, weight) + + # Calculate distance of shortest paths + dist_bellman = _bellman_ford(G, list(G), weight, pred=pred, dist=dist) + + # Update the weight function to take into account the Bellman--Ford + # relaxation distances. + def new_weight(u, v, d): + return weight(u, v, d) + dist_bellman[u] - dist_bellman[v] + + def dist_path(v): + paths = {v: [v]} + _dijkstra(G, v, new_weight, paths=paths) + return paths + + return {v: dist_path(v) for v in G} diff --git a/snap-python/source/snapx/snapx/classes/__init__.py b/snap-python/source/snapx/snapx/classes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..42aebf6c27b4daaa978f7d69d1e6101d3e413c8c --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/__init__.py @@ -0,0 +1,11 @@ +from .attrdict import AttributeDict + +from .graph import Graph + +from .function import * + +from .digraph import DiGraph + +from .filters import * + +from .graphviews import * diff --git a/snap-python/source/snapx/snapx/classes/_nodeiter.py b/snap-python/source/snapx/snapx/classes/_nodeiter.py new file mode 100644 index 0000000000000000000000000000000000000000..33da841a4899fe741b458ebd506cc58184a2cba9 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/_nodeiter.py @@ -0,0 +1,75 @@ +"""Defines private classes for vairous iterators +""" +from snap import TIntV, TFltV, TStrV +from collections.abc import Generator + +class _BaseIterator: + def __init__(self, it): + if not isinstance(it, Generator): + raise TypeError('Expected Generator, but got {}'.format(type(it).__name__)) + self._iter = it + + def __iter__(self): + return self + + def __next__(self): + try: + cur = next(self._iter).GetId() + return cur + except: + # TODO: We need to find a better way to handle the stopiter? + raise StopIteration + + +class _GraphNodeIterator(_BaseIterator): + '''Iterates over graph nodes''' + +class _GraphEdgeIterator(_BaseIterator): + '''Iterates over edges''' + +class _TNEANetEdgeIter: + def __init__(self, it, directed=False): + if not isinstance(it, Generator): + raise TypeError('Expected Generator, but got {}'.format(type(it).__name__)) + self._iter = it + self._directed = directed + + def __iter__(self): + return self + + def __next__(self): + try: + # HACK: Use the fact that we need only return (lo, hi) pair for + # undirected graph. (Need to check if the snap C++ layer indeed + # throws an exception when reaching the end of chain though, otherwise + # we risk infinite loop...) + while True: + cur = next(self._iter) + src = cur.GetSrcNId(); dst = cur.GetDstNId() + if self._directed or src <= dst: + return (src, dst) + + except: + # TODO: We need to find a better way to handle the stopiter? + raise StopIteration + +class _GraphNodeDataIterator: + def __init__(self, g): + self._graph = g + self._attr_fns = ((self._graph.snap_graph.IntAttrNameNI, self._graph.snap_graph.GetIntAttrDatN), + (self._graph.snap_graph.FltAttrNameNI, self._graph.snap_graph.GetFltAttrDatN), + (self._graph.snap_graph.StrAttrNameNI, self._graph.snap_graph.GetStrAttrDatN)) + + def __iter__(self): + for n in self._graph: + res = {} # TODO: Maybe there's a way to do this in-memory? + for (key_fn, val_fn) in self._attr_fns: + _attr_names = TStrV() + key_fn(n, _attr_names) + for _attr in _attr_names: + res[_attr] = val_fn(n, _attr) + + yield (n, res) + +class _GraphEdgeDataIterator: + pass \ No newline at end of file diff --git a/snap-python/source/snapx/snapx/classes/attrdict.py b/snap-python/source/snapx/snapx/classes/attrdict.py new file mode 100644 index 0000000000000000000000000000000000000000..93458dd09a3ea14d3db64d7bb953a4ba07fee9bd --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/attrdict.py @@ -0,0 +1,189 @@ +from collections.abc import MutableMapping + +from snap import TStrV +from snapx.exception import SnapXKeyError, SnapXTypeError + +class AttributeDict(MutableMapping): + """Wraps snap's attributes representations and presents them + like a Python built-in dict. + + For attribute types not supported by Snap, it emulates the behavior by + storing these in the extra attribute dictionaries. + + This layer should work for both node and edge attributes. + + DESIGN NOTE: + 1) What gets stored in SNAP's feature storage + For the time being, only int types are stored to SNAP's + feature store, and the rest will go straight to the extra attr dicts. + The following is an illustration of what gets stored where: + >>> g = sx.Graph() + >>> g.add_nodes([(0, {'foo': 'bar'}), (1, {'foo': 1})]) + >>> # Node 0's foo is in extra dict, Node 1's foo is in SNAP + + 2) Treatment of edge attributes for undirected graphs + Since we use TNEANet as the underlying graph data structure, we are + emulating the undirected graph's behavior by sorting the pair of nodes + of an edge in the ascending order, so that we consistently access the + same internal attribute storage. + For example, edge attribute queries for both (1, 4) and (4, 1) will + look at the internal storage for (1, 4) + """ + def __init__(self, graph, key): + self._graph = graph + if isinstance(key, int): + self._is_node = True + elif isinstance(key, tuple) and len(key) == 2 \ + and isinstance(key[0], int) and isinstance(key[1], int): + self._is_node = False + else: + raise SnapXTypeError("Argument 2 must be either node (int) or edge (2-tuple).") + + # Need to convert a (src, dst) pair to the EI in the case of edge. + try: + if self._is_node: + self._key = key + self._extra_attr = self._graph._node_extra_attr + else: + # IMPORTANT NOTE: src and dst gets reordered for UNDIRECTED graphs. + src, dst = key if graph.is_directed() else graph._order_edge(*key) + self._key = key if self._is_node else self._graph.snap_graph.GetEI(src, dst).GetId() + self._edge = (src, dst) + self._extra_attr = self._graph._edge_extra_attr + + except: + raise SnapXKeyError("Failed to get the edge ID for {}".format(str(key))) + + # TODO: Support floats and strs + # For iteration over Snap's attribute stores + self._snap_attr_names = self._graph.snap_graph.IntAttrNameNI if self._is_node else \ + self._graph.snap_graph.IntAttrNameEI + + # For setting values to Snap's attr stores + self._snap_attr_setter = self._graph.snap_graph.AddIntAttrDatN if self._is_node else \ + self._graph.snap_graph.AddIntAttrDatE + + # For getting values from Snap's attr stores + self._snap_attr_getter = self._graph.snap_graph.GetIntAttrDatN if self._is_node else \ + self._graph.snap_graph.GetIntAttrDatE + + # For deleting values from snap's attr stores + self._snap_attr_del = self._graph.snap_graph.DelAttrDatN if self._is_node else \ + self._graph.snap_graph.DelAttrDatE + + def __yield_snap_attrs(self): + _attr_names = TStrV() + self._snap_attr_names(self._key, _attr_names) + for _attr in _attr_names: + yield _attr + + def __iter__(self): + # First yield snap attributes + for _attr in self.__yield_snap_attrs(): + yield _attr + + # Now yield the rest + try: + extra_attr_dict = self._extra_attr[self._key] if self._is_node else \ + self._extra_attr[self._edge[0]][self._edge[1]] + for _attr in extra_attr_dict: + yield _attr + except KeyError: + pass + + def __contains__(self, key): + for _attr in self: + if _attr == key: + return True + + return False + + def __len__(self): + return sum(1 for _ in iter(self)) + + def __getitem__(self, attr): + try: + return self._snap_attr_getter(self._key, attr) + except RuntimeError: + extra_attr_getter = self._node_extra_attr_getter \ + if self._is_node else \ + self._edge_extra_attr_getter + return extra_attr_getter(self._key, attr) + + def _node_extra_attr_setter(self, key, val, attr): + """Sets the node attr to val. + Should be used only for attr types not directly supported by Snap.""" + if key not in self._graph: + raise KeyError + + if key not in self._graph._node_extra_attr: + self._graph._node_extra_attr[key] = {} + self._graph._node_extra_attr[key][attr] = val + + def _node_extra_attr_getter(self, key, attr): + """Gets the node attr val. + Should be used only for attr types not directly supported by Snap.""" + try: + return self._graph._node_extra_attr[key][attr] + except KeyError: + return None + + def _edge_extra_attr_setter(self, key, val, attr): + """Sets the edge attr to val. + Should be used only for attr types not directly supported by Snap.""" + u, v = self._edge + if u not in self._graph._edge_extra_attr: + self._graph._edge_extra_attr[u] = {} + if v not in self._graph._edge_extra_attr: + self._graph._edge_extra_attr[v] = {} + + if v not in self._graph._edge_extra_attr[u]: + datadict = {} + self._graph._edge_extra_attr[u][v] = datadict + if u != v: + self._graph._edge_extra_attr[v][u] = datadict + + self._graph._edge_extra_attr[u][v][attr] = val + + def _edge_extra_attr_getter(self, key, attr): + # TODO: Clean up design of setters & getters + u, v = self._edge + try: + return self._graph._edge_extra_attr[u][v][attr] + except KeyError: + return None + + def __setitem__(self, attr, val): + if not isinstance(attr, str): + raise SnapXTypeError("Argument 2 must be type str.") + + setter = self._node_extra_attr_setter \ + if self._is_node else \ + self._edge_extra_attr_setter + # Dispatch to corresponding setters if the type is supported by Snap. + # Currently only int is supported + if isinstance(val, int): + setter = self._snap_attr_setter + + setter(self._key, val, attr) + + def __delitem__(self, attr): + if attr not in self: + return + + if isinstance(self[attr], int): + self._snap_attr_del(self._key, attr) + else: + extra_attr_dict = self._extra_attr[self._key] if self._is_node else \ + self._extra_attr[self._edge[0]][self._edge[1]] + del extra_attr_dict[attr] + + def __str__(self): + strs = [] + for k in iter(self): + strs.append("'{}': {}".format(k, repr(self[k]))) + return "{" + ", ".join(strs) + "}" + + def __repr__(self): + return "{}({})".format(self.__class__.__name__, self.__str__()) + diff --git a/snap-python/source/snapx/snapx/classes/coreviews.py b/snap-python/source/snapx/snapx/classes/coreviews.py new file mode 100644 index 0000000000000000000000000000000000000000..3f720abb24e44ea5ba6361568d8548f8ccb0a6bb --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/coreviews.py @@ -0,0 +1,222 @@ +from collections.abc import Mapping + +from .attrdict import AttributeDict + + +class AtlasView(Mapping): + """This is a view into a dict-of-dict-like structure. + This view shows a certain node's neighbors and their edge attributes. + + Note that unlike NetworkX's AltasView, we need both the + underlying graph and the ID for the node of interest in + order to accomplish the same effect, hence the difference + in the API.""" + + __slots__ = ("_graph", "_node") + + def __getstate__(self): + raise NotImplementedError("TODO") + + def __setstate__(self, state): + raise NotImplementedError("TODO") + + def __init__(self, g, n): + """Initialize with the input node and graph""" + self._graph = g + self._node = n + + if not isinstance(n, int): + raise TypeError("Node ID must be int.") + if n not in g: + raise KeyError("Node must be present in graph.") + + def __len__(self): + return sum(1 for d in self) + + def __iter__(self): + ni = self._graph.snap_graph.GetNI(self._node) + for dst in ni.GetOutEdges(): + yield dst + + def __getitem__(self, key): + return AttributeDict(self._graph, (self._node, key)) + + def copy(self): + raise NotImplementedError("TODO") + + def __str__(self): + strs = [] + for k in iter(self): + strs.append(str(k) + ": " + str(self[k])) + return "{" + ", ".join(strs) + "}" + + def __repr__(self): + return '{}({})'.format(self.__class__.__name__, self.__str__()) + +class AdjacencyView(Mapping): + """This is a view into a dict-of-dict-of-dict-like data structure. + This view shows all nodes' neighbors and their edge attributes. + """ + + __slots__ = ("_graph",) + + def __init__(self, g): + self._graph = g + + def __getstate__(self): + raise NotImplementedError("TODO") + + def __setstate__(self, state): + raise NotImplementedError("TODO") + + def __getitem__(self, node): + return AtlasView(self._graph, node) + + def __len__(self): + return sum(1 for n in self) + + def __iter__(self): + for n in self._graph: + yield n + + def __str__(self): + strs = [] + for n in iter(self): + strs.append(str(n) + ": " + str(self[n])) + return "{" + ", ".join(strs) + "}" + + def __repr__(self): + return '{}({})'.format(self.__class__.__name__, self.__str__()) + + def copy(self): + raise NotImplementedError("TODO") + + +class FilterAtlas(Mapping): # nodedict, nbrdict, keydict + def __init__(self, d, NODE_OK): + self._atlas = d + self.NODE_OK = NODE_OK + + def __len__(self): + return sum(1 for n in self) + + def __iter__(self): + try: # check that NODE_OK has attr 'nodes' + node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas) + except AttributeError: + node_ok_shorter = False + if node_ok_shorter: + return (n for n in self.NODE_OK.nodes if n in self._atlas) + return (n for n in self._atlas if self.NODE_OK(n)) + + def __getitem__(self, key): + if key in self._atlas and self.NODE_OK(key): + return self._atlas[key] + raise KeyError("Key {} not found".format(key)) + + def copy(self): + try: # check that NODE_OK has attr 'nodes' + node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas) + except AttributeError: + node_ok_shorter = False + if node_ok_shorter: + return {u: self._atlas[u] for u in self.NODE_OK.nodes if u in self._atlas} + return {u: d for u, d in self._atlas.items() if self.NODE_OK(u)} + + def __str__(self): + return str({nbr: self[nbr] for nbr in self}) + + def __repr__(self): + return "{}({}, {})".format(self.__class__.__name__, self._atlas.__repr__(), self.NODE_OK._repr__()) + +class FilterAdjacency(Mapping): # edgedict + def __init__(self, d, NODE_OK, EDGE_OK): + self._atlas = d + self.NODE_OK = NODE_OK + self.EDGE_OK = EDGE_OK + + def __len__(self): + return sum(1 for n in self) + + def __iter__(self): + try: # check that NODE_OK has attr 'nodes' + node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas) + except AttributeError: + node_ok_shorter = False + if node_ok_shorter: + return (n for n in self.NODE_OK.nodes if n in self._atlas) + return (n for n in self._atlas if self.NODE_OK(n)) + + def __getitem__(self, node): + if node in self._atlas and self.NODE_OK(node): + + def new_node_ok(nbr): + return self.NODE_OK(nbr) and self.EDGE_OK(node, nbr) + + return FilterAtlas(self._atlas[node], new_node_ok) + raise KeyError("Key {} not found".format(key)) + + def copy(self): + try: # check that NODE_OK has attr 'nodes' + node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas) + except AttributeError: + node_ok_shorter = False + if node_ok_shorter: + return { + u: { + v: d + for v, d in self._atlas[u].items() + if self.NODE_OK(v) + if self.EDGE_OK(u, v) + } + for u in self.NODE_OK.nodes + if u in self._atlas + } + return { + u: {v: d for v, d in nbrs.items() if self.NODE_OK(v) if self.EDGE_OK(u, v)} + for u, nbrs in self._atlas.items() + if self.NODE_OK(u) + } + + def __str__(self): + return str({nbr: self[nbr] for nbr in self}) + + def __repr__(self): + return "{}({}, {}, {})".format(self.__class__.__name__, self._atlas.__repr__(), self.NODE_OK__repr__(), self.EDGE_OK.__repr__()) + + +class FilterMultiAdjacency(FilterAdjacency): # multiedgedict + def __getitem__(self, node): + if node in self._atlas and self.NODE_OK(node): + + def edge_ok(nbr, key): + return self.NODE_OK(nbr) and self.EDGE_OK(node, nbr, key) + + return FilterMultiInner(self._atlas[node], self.NODE_OK, edge_ok) + raise KeyError("Key {} not found".format(node)) + + def copy(self): + try: # check that NODE_OK has attr 'nodes' + node_ok_shorter = 2 * len(self.NODE_OK.nodes) < len(self._atlas) + except AttributeError: + node_ok_shorter = False + if node_ok_shorter: + my_nodes = self.NODE_OK.nodes + return { + u: { + v: {k: d for k, d in kd.items() if self.EDGE_OK(u, v, k)} + for v, kd in self._atlas[u].items() + if v in my_nodes + } + for u in my_nodes + if u in self._atlas + } + return { + u: { + v: {k: d for k, d in kd.items() if self.EDGE_OK(u, v, k)} + for v, kd in nbrs.items() + if self.NODE_OK(v) + } + for u, nbrs in self._atlas.items() + if self.NODE_OK(u) + } diff --git a/snap-python/source/snapx/snapx/classes/digraph.py b/snap-python/source/snapx/snapx/classes/digraph.py new file mode 100644 index 0000000000000000000000000000000000000000..15c78166f1fe939473bf0f5469d1fd3ffc80fc5a --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/digraph.py @@ -0,0 +1,1173 @@ +"""PORTED FROM NETWORKX +Base class for directed graphs.""" +from copy import deepcopy + +import snapx as sx +from snapx.classes.graph import Graph +from snapx.classes.coreviews import AdjacencyView +from snapx.classes.reportviews import ( + OutEdgeView, + # InEdgeView, + # DiDegreeView, + # InDegreeView, + # OutDegreeView, +) +from snapx.exception import SnapXError +import snapx.convert as convert + + +class DiGraph(Graph): + """PORTED FROM NETWORKX + Base class for undirected graphs, much like the "DiGraph" class in NetworkX. + + DESIGN NOTES: + 1) Use of TNEANet and its consequences: + This class is built on top of TNEANet, a multigraph implemented in C++ SNAP. + For that reason, some of the behaviors expected out of an undirected graph + are emulated in this layer. More specifically, we did the following: + - We keep a counter 'self._num_edges' to track how many edges exist in + the graph. + + We currently rely on TNEANet due to its rich support for node and edge + attributes. A future implementation may obviate the need for this emulation + by expanding the C++ SNAP's undirected graph to provide support for such + attributes. + + 2) How graph/node/edge attributes are stored + - Graph attributes: Stored in self.graph, a built-in dict. + - Node and edge attributes: + - An int typed attribute gets stored in the TNEANet's feature storage. + - All other types will go to the extra attribute builtin dicts + (self._node_extra_attr and self._edge_extra_attr). + AttributeDict handles manipulation of edge/node features. + + Docstrings are mostly copied over from NetworkX for reference, and thus may not + accurately reflect the exact features supported in SnapX. + + --- NETWORKX DiGraph Documentation --- + Base class for directed graphs. + + A DiGraph stores nodes and edges with optional data, or attributes. + + DiGraphs hold directed edges. Self loops are allowed but multiple + (parallel) edges are not. + + Nodes can be arbitrary (hashable) Python objects with optional + key/value attributes. By convention `None` is not used as a node. + + Edges are represented as links between nodes with optional + key/value attributes. + + Parameters + ---------- + incoming_graph_data : input graph (optional, default: None) + Data to initialize graph. If None (default) an empty + graph is created. The data can be any format that is supported + by the to_networkx_graph() function, currently including edge list, + dict of dicts, dict of lists, NetworkX graph, NumPy matrix + or 2d ndarray, SciPy sparse matrix, or PyGraphviz graph. + + attr : keyword arguments, optional (default= no attributes) + Attributes to add to graph as key=value pairs. + + See Also + -------- + Graph + MultiGraph + MultiDiGraph + OrderedDiGraph + + Examples + -------- + Create an empty graph structure (a "null graph") with no nodes and + no edges. + + >>> G = sx.DiGraph() + + G can be grown in several ways. + + **Nodes:** + + Add one node at a time: + + >>> G.add_node(1) + + Add the nodes from any container (a list, dict, set or + even the lines from a file or the nodes from another graph). + + >>> G.add_nodes_from([2, 3]) + >>> G.add_nodes_from(range(100, 110)) + >>> H = sx.path_graph(10) + >>> G.add_nodes_from(H) + + In addition to strings and integers any hashable Python object + (except None) can represent a node, e.g. a customized node object, + or even another Graph. + + >>> G.add_node(H) + + **Edges:** + + G can also be grown by adding edges. + + Add one edge, + + >>> G.add_edge(1, 2) + + a list of edges, + + >>> G.add_edges_from([(1, 2), (1, 3)]) + + or a collection of edges, + + >>> G.add_edges_from(H.edges) + + If some edges connect nodes not yet in the graph, the nodes + are added automatically. There are no errors when adding + nodes or edges that already exist. + + **Attributes:** + + Each graph, node, and edge can hold key/value attribute pairs + in an associated attribute dictionary (the keys must be hashable). + By default these are empty, but can be added or changed using + add_edge, add_node or direct manipulation of the attribute + dictionaries named graph, node and edge respectively. + + >>> G = sx.DiGraph(day="Friday") + >>> G.graph + {'day': 'Friday'} + + Add node attributes using add_node(), add_nodes_from() or G.nodes + + >>> G.add_node(1, time='5pm') + >>> G.add_nodes_from([3], time='2pm') + >>> G.nodes[1] + {'time': '5pm'} + >>> G.nodes[1]['room'] = 714 + >>> del G.nodes[1]['room'] # remove attribute + >>> list(G.nodes(data=True)) + [(1, {'time': '5pm'}), (3, {'time': '2pm'})] + + Add edge attributes using add_edge(), add_edges_from(), subscript + notation, or G.edges. + + >>> G.add_edge(1, 2, weight=4.7 ) + >>> G.add_edges_from([(3, 4), (4, 5)], color='red') + >>> G.add_edges_from([(1, 2, {'color':'blue'}), (2, 3, {'weight':8})]) + >>> G[1][2]['weight'] = 4.7 + >>> G.edges[1, 2]['weight'] = 4 + + Warning: we protect the graph data structure by making `G.edges[1, 2]` a + read-only dict-like structure. However, you can assign to attributes + in e.g. `G.edges[1, 2]`. Thus, use 2 sets of brackets to add/change + data attributes: `G.edges[1, 2]['weight'] = 4` + (For multigraphs: `MG.edges[u, v, key][name] = value`). + + **Shortcuts:** + + Many common graph features allow python syntax to speed reporting. + + >>> 1 in G # check if node in graph + True + >>> [n for n in G if n < 3] # iterate through nodes + [1, 2] + >>> len(G) # number of nodes in graph + 5 + + Often the best way to traverse all edges of a graph is via the neighbors. + The neighbors are reported as an adjacency-dict `G.adj` or `G.adjacency()` + + >>> for n, nbrsdict in G.adjacency(): + ... for nbr, eattr in nbrsdict.items(): + ... if 'weight' in eattr: + ... # Do something useful with the edges + ... pass + + But the edges reporting object is often more convenient: + + >>> for u, v, weight in G.edges(data='weight'): + ... if weight is not None: + ... # Do something useful with the edges + ... pass + + **Reporting:** + + Simple graph information is obtained using object-attributes and methods. + Reporting usually provides views instead of containers to reduce memory + usage. The views update as the graph is updated similarly to dict-views. + The objects `nodes, `edges` and `adj` provide access to data attributes + via lookup (e.g. `nodes[n], `edges[u, v]`, `adj[u][v]`) and iteration + (e.g. `nodes.items()`, `nodes.data('color')`, + `nodes.data('color', default='blue')` and similarly for `edges`) + Views exist for `nodes`, `edges`, `neighbors()`/`adj` and `degree`. + + For details on these and other miscellaneous methods, see below. + + **Subclasses (Advanced):** + + The Graph class uses a dict-of-dict-of-dict data structure. + The outer dict (node_dict) holds adjacency information keyed by node. + The next dict (adjlist_dict) represents the adjacency information and holds + edge data keyed by neighbor. The inner dict (edge_attr_dict) represents + the edge data and holds edge attribute values keyed by attribute names. + + Each of these three dicts can be replaced in a subclass by a user defined + dict-like object. In general, the dict-like features should be + maintained but extra features can be added. To replace one of the + dicts create a new graph class by changing the class(!) variable + holding the factory for that dict-like structure. The variable names are + node_dict_factory, node_attr_dict_factory, adjlist_inner_dict_factory, + adjlist_outer_dict_factory, edge_attr_dict_factory and graph_attr_dict_factory. + + node_dict_factory : function, (default: dict) + Factory function to be used to create the dict containing node + attributes, keyed by node id. + It should require no arguments and return a dict-like object + + node_attr_dict_factory: function, (default: dict) + Factory function to be used to create the node attribute + dict which holds attribute values keyed by attribute name. + It should require no arguments and return a dict-like object + + adjlist_outer_dict_factory : function, (default: dict) + Factory function to be used to create the outer-most dict + in the data structure that holds adjacency info keyed by node. + It should require no arguments and return a dict-like object. + + adjlist_inner_dict_factory : function, optional (default: dict) + Factory function to be used to create the adjacency list + dict which holds edge data keyed by neighbor. + It should require no arguments and return a dict-like object + + edge_attr_dict_factory : function, optional (default: dict) + Factory function to be used to create the edge attribute + dict which holds attribute values keyed by attribute name. + It should require no arguments and return a dict-like object. + + graph_attr_dict_factory : function, (default: dict) + Factory function to be used to create the graph attribute + dict which holds attribute values keyed by attribute name. + It should require no arguments and return a dict-like object. + + Typically, if your extension doesn't impact the data structure all + methods will inherited without issue except: `to_directed/to_undirected`. + By default these methods create a DiGraph/Graph class and you probably + want them to create your extension of a DiGraph/Graph. To facilitate + this we define two class variables that you can set in your subclass. + + to_directed_class : callable, (default: DiGraph or MultiDiGraph) + Class to create a new graph structure in the `to_directed` method. + If `None`, a NetworkX class (DiGraph or MultiDiGraph) is used. + + to_undirected_class : callable, (default: Graph or MultiGraph) + Class to create a new graph structure in the `to_undirected` method. + If `None`, a NetworkX class (Graph or MultiGraph) is used. + + Examples + -------- + + Create a low memory graph class that effectively disallows edge + attributes by using a single attribute dict for all edges. + This reduces the memory used, but you lose edge attributes. + + >>> class ThinGraph(nx.Graph): + ... all_edge_dict = {'weight': 1} + ... def single_edge_dict(self): + ... return self.all_edge_dict + ... edge_attr_dict_factory = single_edge_dict + >>> G = ThinGraph() + >>> G.add_edge(2, 1) + >>> G[2][1] + {'weight': 1} + >>> G.add_edge(2, 2) + >>> G[2][1] is G[2][2] + True + + + Please see :mod:`~networkx.classes.ordered` for more examples of + creating graph subclasses by overwriting the base class `dict` with + a dictionary-like object. + """ + + def __init__(self, incoming_graph_data=None, **attr): + """Initialize a graph with edges, name, or graph attributes. + + Parameters + ---------- + incoming_graph_data : input graph (optional, default: None) + Data to initialize graph. If None (default) an empty + graph is created. The data can be an edge list, or any + NetworkX graph object. If the corresponding optional Python + packages are installed the data can also be a NumPy matrix + or 2d ndarray, a SciPy sparse matrix, or a PyGraphviz graph. + + attr : keyword arguments, optional (default= no attributes) + Attributes to add to graph as key=value pairs. + + See Also + -------- + convert + + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G = nx.Graph(name='my graph') + >>> e = [(1, 2), (2, 3), (3, 4)] # list of edges + >>> G = nx.Graph(e) + + Arbitrary graph attribute pairs (key=value) may be assigned + + >>> G = nx.Graph(e, day="Friday") + >>> G.graph + {'day': 'Friday'} + + """ + self._graph = TNEANet.New() + + # Because we are emulating an directed graph using multigraph, + # we need a counter to keep track of edges + self._num_edges = 0 + # Supplementary dicts to keep data not supported by snap graph + self._node_extra_attr = {} + self._edge_extra_attr = {} + if incoming_graph_data is not None: + convert.to_snapx_graph(incoming_graph_data, create_using=self) + + # Graph attributes + self.graph = {} + self.graph.update(attr) + + @property + def adj(self): + """Graph adjacency object holding the neighbors of each node. + + This object is a read-only dict-like structure with node keys + and neighbor-dict values. The neighbor-dict is keyed by neighbor + to the edge-data-dict. So `G.adj[3][2]['color'] = 'blue'` sets + the color of the edge `(3, 2)` to `"blue"`. + + Iterating over G.adj behaves like a dict. Useful idioms include + `for nbr, datadict in G.adj[n].items():`. + + The neighbor information is also provided by subscripting the graph. + So `for nbr, foovalue in G[node].data('foo', default=1):` works. + + For directed graphs, `G.adj` holds outgoing (successor) info. + """ + return AdjacencyView(self) + + @property + def succ(self): + """PORTED FROM NETWORKX + Graph adjacency object holding the successors of each node. + + This object is a read-only dict-like structure with node keys + and neighbor-dict values. The neighbor-dict is keyed by neighbor + to the edge-data-dict. So `G.succ[3][2]['color'] = 'blue'` sets + the color of the edge `(3, 2)` to `"blue"`. + + Iterating over G.succ behaves like a dict. Useful idioms include + `for nbr, datadict in G.succ[n].items():`. A data-view not provided + by dicts also exists: `for nbr, foovalue in G.succ[node].data('foo'):` + and a default can be set via a `default` argument to the `data` method. + + The neighbor information is also provided by subscripting the graph. + So `for nbr, foovalue in G[node].data('foo', default=1):` works. + + For directed graphs, `G.adj` is identical to `G.succ`. + """ + return AdjacencyView(self) + + @property + def pred(self): + """PORTED FROM NETWORKX + Graph adjacency object holding the predecessors of each node. + + This object is a read-only dict-like structure with node keys + and neighbor-dict values. The neighbor-dict is keyed by neighbor + to the edge-data-dict. So `G.pred[2][3]['color'] = 'blue'` sets + the color of the edge `(3, 2)` to `"blue"`. + + Iterating over G.pred behaves like a dict. Useful idioms include + `for nbr, datadict in G.pred[n].items():`. A data-view not provided + by dicts also exists: `for nbr, foovalue in G.pred[node].data('foo'):` + A default can be set via a `default` argument to the `data` method. + """ + raise NotImplementedError("TODO") + + def add_node(self, node_for_adding, **attr): + """Add a single node `node_for_adding` and update node attributes. + + Parameters + ---------- + node_for_adding : node + A node can be any hashable Python object except None. + attr : keyword arguments, optional + Set or change node attributes using key=value. + + See Also + -------- + add_nodes_from + + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_node(1) + >>> G.add_node('Hello') + >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)]) + >>> G.add_node(K3) + >>> G.number_of_nodes() + 3 + + Use keywords set/change node attributes: + + >>> G.add_node(1, size=10) + >>> G.add_node(3, weight=0.4, UTM=('13S', 382871, 3972649)) + + Notes + ----- + A hashable object is one that can be used as a key in a Python + dictionary. This includes strings, numbers, tuples of strings + and numbers, etc. + + On many platforms hashable items also include mutables such as + NetworkX Graphs, though one should be careful that the hash + doesn't change on mutables. + """ + super.add_node(node_for_adding, **attr) + + def add_nodes_from(self, nodes_for_adding, **attr): + """Add multiple nodes. + + Parameters + ---------- + nodes_for_adding : iterable container + A container of nodes (list, dict, set, etc.). + OR + A container of (node, attribute dict) tuples. + Node attributes are updated using the attribute dict. + attr : keyword arguments, optional (default= no attributes) + Update attributes for all nodes in nodes. + Node attributes specified in nodes as a tuple take + precedence over attributes specified via keyword arguments. + + See Also + -------- + add_node + + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_nodes_from('Hello') + >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)]) + >>> G.add_nodes_from(K3) + >>> sorted(G.nodes(), key=str) + [0, 1, 2, 'H', 'e', 'l', 'o'] + + Use keywords to update specific node attributes for every node. + + >>> G.add_nodes_from([1, 2], size=10) + >>> G.add_nodes_from([3, 4], weight=0.4) + + Use (node, attrdict) tuples to update attributes for specific nodes. + + >>> G.add_nodes_from([(1, dict(size=11)), (2, {'color':'blue'})]) + >>> G.nodes[1]['size'] + 11 + >>> H = nx.Graph() + >>> H.add_nodes_from(G.nodes(data=True)) + >>> H.nodes[1]['size'] + 11 + + """ + super.add_nodes_from(nodes_for_adding, **attr) + + def remove_node(self, n): + """Remove node n. + + Removes the node n and all adjacent edges. + Attempting to remove a non-existent node will raise an exception. + + Parameters + ---------- + n : node + A node in the graph + + Raises + ------- + NetworkXError + If n is not in the graph. + + See Also + -------- + remove_nodes_from + + Examples + -------- + >>> G = nx.path_graph(3) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> list(G.edges) + [(0, 1), (1, 2)] + >>> G.remove_node(1) + >>> list(G.edges) + [] + + """ + super.remove_node(n) + + def remove_nodes_from(self, nodes): + """Remove multiple nodes. + + Parameters + ---------- + nodes : iterable container + A container of nodes (list, dict, set, etc.). If a node + in the container is not in the graph it is silently ignored. + + See Also + -------- + remove_node + + Examples + -------- + >>> G = nx.path_graph(3) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> e = list(G.nodes) + >>> e + [0, 1, 2] + >>> G.remove_nodes_from(e) + >>> list(G.nodes) + [] + + """ + super.remove_nodes_from(nodes) + + def add_edge(self, u_of_edge, v_of_edge, **attr): + """Add an edge between u and v. + + The nodes u and v will be automatically added if they are + not already in the graph. + + Edge attributes can be specified with keywords or by directly + accessing the edge's attribute dictionary. See examples below. + + Parameters + ---------- + u, v : nodes + Nodes can be, for example, strings or numbers. + Nodes must be hashable (and not None) Python objects. + attr : keyword arguments, optional + Edge data (or labels or objects) can be assigned using + keyword arguments. + + See Also + -------- + add_edges_from : add a collection of edges + + Notes + ----- + Adding an edge that already exists updates the edge data. + + Many NetworkX algorithms designed for weighted graphs use + an edge attribute (by default `weight`) to hold a numerical value. + + Examples + -------- + The following all add the edge e=(1, 2) to graph G: + + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> e = (1, 2) + >>> G.add_edge(1, 2) # explicit two-node form + >>> G.add_edge(*e) # single edge as tuple of two nodes + >>> G.add_edges_from( [(1, 2)] ) # add edges from iterable container + + Associate data to edges using keywords: + + >>> G.add_edge(1, 2, weight=3) + >>> G.add_edge(1, 3, weight=7, capacity=15, length=342.7) + + For non-string attribute keys, use subscript notation. + + >>> G.add_edge(1, 2) + >>> G[1][2].update({0: 5}) + >>> G.edges[1, 2].update({0: 5}) + """ + u = u_of_edge + v = v_of_edge + + if u not in self.nodes: + self.add_node(u) + if v not in self.nodes: + self.add_node(v) + + # Emulate (non-multi) graph by checking if the edge + # already exists. + if self.has_edge(u, v): + return + try: + self._graph.AddEdge(u, v) + self._num_edges += 1 + + # Finally update attrs + self.adj[u][v].update(attr) + + except TypeError: + raise SnapXTypeError("SNAP only supports int as edge keys.") + + def add_edges_from(self, ebunch_to_add, **attr): + """Add all the edges in ebunch_to_add. + + Parameters + ---------- + ebunch_to_add : container of edges + Each edge given in the container will be added to the + graph. The edges must be given as 2-tuples (u, v) or + 3-tuples (u, v, d) where d is a dictionary containing edge data. + attr : keyword arguments, optional + Edge data (or labels or objects) can be assigned using + keyword arguments. + + See Also + -------- + add_edge : add a single edge + add_weighted_edges_from : convenient way to add weighted edges + + Notes + ----- + Adding the same edge twice has no effect but any edge data + will be updated when each duplicate edge is added. + + Edge attributes specified in an ebunch take precedence over + attributes specified via keyword arguments. + + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_edges_from([(0, 1), (1, 2)]) # using a list of edge tuples + >>> e = zip(range(0, 3), range(1, 4)) + >>> G.add_edges_from(e) # Add the path graph 0-1-2-3 + + Associate data to edges + + >>> G.add_edges_from([(1, 2), (2, 3)], weight=3) + >>> G.add_edges_from([(3, 4), (1, 4)], label='WN2898') + """ + super.add_edges_from(ebunch_to_add, **attr) + + def remove_edge(self, u, v): + """Remove the edge between u and v. + + Parameters + ---------- + u, v : nodes + Remove the edge between nodes u and v. + + Raises + ------ + NetworkXError + If there is not an edge between u and v. + + See Also + -------- + remove_edges_from : remove a collection of edges + + Examples + -------- + >>> G = nx.Graph() # or DiGraph, etc + >>> nx.add_path(G, [0, 1, 2, 3]) + >>> G.remove_edge(0, 1) + >>> e = (1, 2) + >>> G.remove_edge(*e) # unpacks e from an edge tuple + >>> e = (2, 3, {'weight':7}) # an edge with attribute data + >>> G.remove_edge(*e[:2]) # select first part of edge tuple + """ + try: + del self._succ[u][v] + del self._pred[v][u] + except KeyError as e: + raise NetworkXError("The edge {u}-{v} not in graph.".format(u, v)) from e + + def remove_edges_from(self, ebunch): + """Remove all edges specified in ebunch. + + Parameters + ---------- + ebunch: list or container of edge tuples + Each edge given in the list or container will be removed + from the graph. The edges can be: + + - 2-tuples (u, v) edge between u and v. + - 3-tuples (u, v, k) where k is ignored. + + See Also + -------- + remove_edge : remove a single edge + + Notes + ----- + Will fail silently if an edge in ebunch is not in the graph. + + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> ebunch = [(1, 2), (2, 3)] + >>> G.remove_edges_from(ebunch) + """ + raise NotImplementedError("TODO") + + def has_successor(self, u, v): + """Returns True if node u has successor v. + + This is true if graph has the edge u->v. + """ + raise NotImplementedError("TODO") + # return u in self._succ and v in self._succ[u] + + def has_predecessor(self, u, v): + """Returns True if node u has predecessor v. + + This is true if graph has the edge u<-v. + """ + raise NotImplementedError("TODO") + # return u in self._pred and v in self._pred[u] + + def successors(self, n): + """Returns an iterator over successor nodes of n. + + A successor of n is a node m such that there exists a directed + edge from n to m. + + Parameters + ---------- + n : node + A node in the graph + + Raises + ------- + NetworkXError + If n is not in the graph. + + See Also + -------- + predecessors + + Notes + ----- + neighbors() and successors() are the same. + """ + # try: + # return iter(self._succ[n]) + # except KeyError as e: + # raise NetworkXError(f"The node {n} is not in the digraph.") from e + raise NotImplementedError("TODO") + + # digraph definitions + neighbors = successors + + def predecessors(self, n): + """Returns an iterator over predecessor nodes of n. + + A predecessor of n is a node m such that there exists a directed + edge from m to n. + + Parameters + ---------- + n : node + A node in the graph + + Raises + ------- + NetworkXError + If n is not in the graph. + + See Also + -------- + successors + """ + raise NotImplementedError("TODO") + # try: + # return iter(self._pred[n]) + # except KeyError as e: + # raise NetworkXError(f"The node {n} is not in the digraph.") from e + + @property + def edges(self): + """An OutEdgeView of the DiGraph as G.edges or G.edges(). + + edges(self, nbunch=None, data=False, default=None) + + The OutEdgeView provides set-like operations on the edge-tuples + as well as edge attribute lookup. When called, it also provides + an EdgeDataView object which allows control of access to edge + attributes (but does not provide set-like operations). + Hence, `G.edges[u, v]['color']` provides the value of the color + attribute for edge `(u, v)` while + `for (u, v, c) in G.edges.data('color', default='red'):` + iterates through all the edges yielding the color attribute + with default `'red'` if no color attribute exists. + + Parameters + ---------- + nbunch : single node, container, or all nodes (default= all nodes) + The view will only report edges incident to these nodes. + data : string or bool, optional (default=False) + The edge attribute returned in 3-tuple (u, v, ddict[data]). + If True, return edge attribute dict in 3-tuple (u, v, ddict). + If False, return 2-tuple (u, v). + default : value, optional (default=None) + Value used for edges that don't have the requested attribute. + Only relevant if data is not True or False. + + Returns + ------- + edges : OutEdgeView + A view of edge attributes, usually it iterates over (u, v) + or (u, v, d) tuples of edges, but can also be used for + attribute lookup as `edges[u, v]['foo']`. + + See Also + -------- + in_edges, out_edges + + Notes + ----- + Nodes in nbunch that are not in the graph will be (quietly) ignored. + For directed graphs this returns the out-edges. + + Examples + -------- + >>> G = nx.DiGraph() # or MultiDiGraph, etc + >>> nx.add_path(G, [0, 1, 2]) + >>> G.add_edge(2, 3, weight=5) + >>> [e for e in G.edges] + [(0, 1), (1, 2), (2, 3)] + >>> G.edges.data() # default data is {} (empty dict) + OutEdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]) + >>> G.edges.data('weight', default=1) + OutEdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)]) + >>> G.edges([0, 2]) # only edges incident to these nodes + OutEdgeDataView([(0, 1), (2, 3)]) + >>> G.edges(0) # only edges incident to a single node (use G.adj[0]?) + OutEdgeDataView([(0, 1)]) + + """ + return OutEdgeView(self) + + # alias out_edges to edges + out_edges = edges + + @property + def in_edges(self): + """An InEdgeView of the Graph as G.in_edges or G.in_edges(). + + in_edges(self, nbunch=None, data=False, default=None): + + Parameters + ---------- + nbunch : single node, container, or all nodes (default= all nodes) + The view will only report edges incident to these nodes. + data : string or bool, optional (default=False) + The edge attribute returned in 3-tuple (u, v, ddict[data]). + If True, return edge attribute dict in 3-tuple (u, v, ddict). + If False, return 2-tuple (u, v). + default : value, optional (default=None) + Value used for edges that don't have the requested attribute. + Only relevant if data is not True or False. + + Returns + ------- + in_edges : InEdgeView + A view of edge attributes, usually it iterates over (u, v) + or (u, v, d) tuples of edges, but can also be used for + attribute lookup as `edges[u, v]['foo']`. + + See Also + -------- + edges + """ + return InEdgeView(self) + + @property + def degree(self): + """A DegreeView for the Graph as G.degree or G.degree(). + + The node degree is the number of edges adjacent to the node. + The weighted node degree is the sum of the edge weights for + edges incident to that node. + + This object provides an iterator for (node, degree) as well as + lookup for the degree for a single node. + + Parameters + ---------- + nbunch : single node, container, or all nodes (default= all nodes) + The view will only report edges incident to these nodes. + + weight : string or None, optional (default=None) + The name of an edge attribute that holds the numerical value used + as a weight. If None, then each edge has weight 1. + The degree is the sum of the edge weights adjacent to the node. + + Returns + ------- + If a single node is requested + deg : int + Degree of the node + + OR if multiple nodes are requested + nd_iter : iterator + The iterator returns two-tuples of (node, degree). + + See Also + -------- + in_degree, out_degree + + Examples + -------- + >>> G = nx.DiGraph() # or MultiDiGraph + >>> nx.add_path(G, [0, 1, 2, 3]) + >>> G.degree(0) # node 0 with degree 1 + 1 + >>> list(G.degree([0, 1, 2])) + [(0, 1), (1, 2), (2, 2)] + + """ + return DiDegreeView(self) + + @property + def in_degree(self): + """An InDegreeView for (node, in_degree) or in_degree for single node. + + The node in_degree is the number of edges pointing to the node. + The weighted node degree is the sum of the edge weights for + edges incident to that node. + + This object provides an iteration over (node, in_degree) as well as + lookup for the degree for a single node. + + Parameters + ---------- + nbunch : single node, container, or all nodes (default= all nodes) + The view will only report edges incident to these nodes. + + weight : string or None, optional (default=None) + The name of an edge attribute that holds the numerical value used + as a weight. If None, then each edge has weight 1. + The degree is the sum of the edge weights adjacent to the node. + + Returns + ------- + If a single node is requested + deg : int + In-degree of the node + + OR if multiple nodes are requested + nd_iter : iterator + The iterator returns two-tuples of (node, in-degree). + + See Also + -------- + degree, out_degree + + Examples + -------- + >>> G = nx.DiGraph() + >>> nx.add_path(G, [0, 1, 2, 3]) + >>> G.in_degree(0) # node 0 with degree 0 + 0 + >>> list(G.in_degree([0, 1, 2])) + [(0, 0), (1, 1), (2, 1)] + + """ + return InDegreeView(self) + + @property + def out_degree(self): + """An OutDegreeView for (node, out_degree) + + The node out_degree is the number of edges pointing out of the node. + The weighted node degree is the sum of the edge weights for + edges incident to that node. + + This object provides an iterator over (node, out_degree) as well as + lookup for the degree for a single node. + + Parameters + ---------- + nbunch : single node, container, or all nodes (default= all nodes) + The view will only report edges incident to these nodes. + + weight : string or None, optional (default=None) + The name of an edge attribute that holds the numerical value used + as a weight. If None, then each edge has weight 1. + The degree is the sum of the edge weights adjacent to the node. + + Returns + ------- + If a single node is requested + deg : int + Out-degree of the node + + OR if multiple nodes are requested + nd_iter : iterator + The iterator returns two-tuples of (node, out-degree). + + See Also + -------- + degree, in_degree + + Examples + -------- + >>> G = nx.DiGraph() + >>> nx.add_path(G, [0, 1, 2, 3]) + >>> G.out_degree(0) # node 0 with degree 1 + 1 + >>> list(G.out_degree([0, 1, 2])) + [(0, 1), (1, 1), (2, 1)] + + """ + return OutDegreeView(self) + + def clear(self): + """Remove all nodes and edges from the graph. + + This also removes the name, and all graph, node, and edge attributes. + + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.clear() + >>> list(G.nodes) + [] + >>> list(G.edges) + [] + + """ + super.clear() + + def clear_edges(self): + """Remove all edges from the graph without altering nodes. + + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.clear_edges() + >>> list(G.nodes) + [0, 1, 2, 3] + >>> list(G.edges) + [] + + """ + for predecessor_dict in self._pred.values(): + predecessor_dict.clear() + for successor_dict in self._succ.values(): + successor_dict.clear() + + def is_multigraph(self): + """Returns True if graph is a multigraph, False otherwise.""" + return False + + def is_directed(self): + """Returns True if graph is directed, False otherwise.""" + return True + + def to_undirected(self, reciprocal=False, as_view=False): + """Returns an undirected representation of the digraph. + + Parameters + ---------- + reciprocal : bool (optional) + If True only keep edges that appear in both directions + in the original digraph. + as_view : bool (optional, default=False) + If True return an undirected view of the original directed graph. + + Returns + ------- + G : Graph + An undirected graph with the same name and nodes and + with edge (u, v, data) if either (u, v, data) or (v, u, data) + is in the digraph. If both edges exist in digraph and + their edge data is different, only one edge is created + with an arbitrary choice of which edge data to use. + You must check and correct for this manually if desired. + + See Also + -------- + Graph, copy, add_edge, add_edges_from + + Notes + ----- + If edges in both directions (u, v) and (v, u) exist in the + graph, attributes for the new undirected edge will be a combination of + the attributes of the directed edges. The edge data is updated + in the (arbitrary) order that the edges are encountered. For + more customized control of the edge attributes use add_edge(). + + This returns a "deepcopy" of the edge, node, and + graph attributes which attempts to completely copy + all of the data and references. + + This is in contrast to the similar G=DiGraph(D) which returns a + shallow copy of the data. + + See the Python copy module for more information on shallow + and deep copies, https://docs.python.org/3/library/copy.html. + + Warning: If you have subclassed DiGraph to use dict-like objects + in the data structure, those changes do not transfer to the + Graph created by this method. + + Examples + -------- + >>> G = nx.path_graph(2) # or MultiGraph, etc + >>> H = G.to_directed() + >>> list(H.edges) + [(0, 1), (1, 0)] + >>> G2 = H.to_undirected() + >>> list(G2.edges) + [(0, 1)] + """ + # graph_class = self.to_undirected_class() + # if as_view is True: + # return nx.graphviews.generic_graph_view(self, Graph) + # # deepcopy when not a view + # G = Graph() + # G.graph.update(deepcopy(self.graph)) + # G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items()) + # if reciprocal is True: + # G.add_edges_from( + # (u, v, deepcopy(d)) + # for u, nbrs in self._adj.items() + # for v, d in nbrs.items() + # if v in self._pred[u] + # ) + # else: + # G.add_edges_from( + # (u, v, deepcopy(d)) + # for u, nbrs in self._adj.items() + # for v, d in nbrs.items() + # ) + # return G + raise NotImplementedError("TODO") + + def reverse(self, copy=True): + """Returns the reverse of the graph. + + The reverse is a graph with the same nodes and edges + but with the directions of the edges reversed. + + Parameters + ---------- + copy : bool optional (default=True) + If True, return a new DiGraph holding the reversed edges. + If False, the reverse graph is created using a view of + the original graph. + """ + # if copy: + # H = self.__class__() + # H.graph.update(deepcopy(self.graph)) + # H.add_nodes_from((n, deepcopy(d)) for n, d in self.nodes.items()) + # H.add_edges_from((v, u, deepcopy(d)) for u, v, d in self.edges(data=True)) + # return H + # return nx.graphviews.reverse_view(self) + raise NotImplementedError("TODO") diff --git a/snap-python/source/snapx/snapx/classes/filters.py b/snap-python/source/snapx/snapx/classes/filters.py new file mode 100644 index 0000000000000000000000000000000000000000..784348a9dd9074954b01188e9adbf17ddead11db --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/filters.py @@ -0,0 +1,69 @@ +"""PORTED FROM NETWORKX +Filter factories to hide or show sets of nodes and edges. +These filters return the function used when creating `SubGraph`. +""" +__all__ = ['no_filter', 'hide_nodes', + 'hide_edges', 'hide_multiedges', + 'hide_diedges', 'hide_multidiedges', + 'show_nodes', + 'show_edges', 'show_multiedges', + 'show_diedges', 'show_multidiedges', + ] + + +def no_filter(*items): + return True + + +def hide_nodes(nodes): + nodes = set(nodes) + return lambda node: node not in nodes + + +def hide_diedges(edges): + edges = {(u, v) for u, v in edges} + return lambda u, v: (u, v) not in edges + + +def hide_edges(edges): + alledges = set(edges) | {(v, u) for (u, v) in edges} + return lambda u, v: (u, v) not in alledges + + +def hide_multidiedges(edges): + edges = {(u, v, k) for u, v, k in edges} + return lambda u, v, k: (u, v, k) not in edges + + +def hide_multiedges(edges): + alledges = set(edges) | {(v, u, k) for (u, v, k) in edges} + return lambda u, v, k: (u, v, k) not in alledges + + +# write show_nodes as a class to make SubGraph pickleable +class show_nodes: + def __init__(self, nodes): + self.nodes = set(nodes) + + def __call__(self, node): + return node in self.nodes + + +def show_diedges(edges): + edges = {(u, v) for u, v in edges} + return lambda u, v: (u, v) in edges + + +def show_edges(edges): + alledges = set(edges) | {(v, u) for (u, v) in edges} + return lambda u, v: (u, v) in alledges + + +def show_multidiedges(edges): + edges = {(u, v, k) for u, v, k in edges} + return lambda u, v, k: (u, v, k) in edges + + +def show_multiedges(edges): + alledges = set(edges) | {(v, u, k) for (u, v, k) in edges} + return lambda u, v, k: (u, v, k) in alledges diff --git a/snap-python/source/snapx/snapx/classes/function.py b/snap-python/source/snapx/snapx/classes/function.py new file mode 100644 index 0000000000000000000000000000000000000000..f98997e5bbe0b79653f5903d27de38bc1d906960 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/function.py @@ -0,0 +1,273 @@ +__all__ = ["set_node_attributes", "set_edge_attributes", "freeze"] + + +def set_node_attributes(G, values, name=None): + """PORTED FROM NETWORKX + Sets node attributes from a given value or dictionary of values. + .. Warning:: The call order of arguments `values` and `name` + switched between v1.x & v2.x. + Parameters + ---------- + G : NetworkX Graph + values : scalar value, dict-like + What the node attribute should be set to. If `values` is + not a dictionary, then it is treated as a single attribute value + that is then applied to every node in `G`. This means that if + you provide a mutable object, like a list, updates to that object + will be reflected in the node attribute for every node. + The attribute name will be `name`. + If `values` is a dict or a dict of dict, it should be keyed + by node to either an attribute value or a dict of attribute key/value + pairs used to update the node's attributes. + name : string (optional, default=None) + Name of the node attribute to set if values is a scalar. + Examples + -------- + After computing some property of the nodes of a graph, you may want + to assign a node attribute to store the value of that property for + each node:: + >>> G = nx.path_graph(3) + >>> bb = nx.betweenness_centrality(G) + >>> isinstance(bb, dict) + True + >>> nx.set_node_attributes(G, bb, 'betweenness') + >>> G.nodes[1]['betweenness'] + 1.0 + If you provide a list as the second argument, updates to the list + will be reflected in the node attribute for each node:: + >>> G = nx.path_graph(3) + >>> labels = [] + >>> nx.set_node_attributes(G, labels, 'labels') + >>> labels.append('foo') + >>> G.nodes[0]['labels'] + ['foo'] + >>> G.nodes[1]['labels'] + ['foo'] + >>> G.nodes[2]['labels'] + ['foo'] + If you provide a dictionary of dictionaries as the second argument, + the outer dictionary is assumed to be keyed by node to an inner + dictionary of node attributes for that node:: + >>> G = nx.path_graph(3) + >>> attrs = {0: {'attr1': 20, 'attr2': 'nothing'}, 1: {'attr2': 3}} + >>> nx.set_node_attributes(G, attrs) + >>> G.nodes[0]['attr1'] + 20 + >>> G.nodes[0]['attr2'] + 'nothing' + >>> G.nodes[1]['attr2'] + 3 + >>> G.nodes[2] + {} + """ + # Set node attributes based on type of `values` + if name is not None: # `values` must not be a dict of dict + try: # `values` is a dict + for n, v in values.items(): + try: + G.nodes[n][name] = values[n] + except KeyError: + pass + except AttributeError: # `values` is a constant + for n in G: + G.nodes[n][name] = values + else: # `values` must be dict of dict + for n, d in values.items(): + try: + G.nodes[n].update(d) + except KeyError: + pass + + +def set_edge_attributes(G, values, name=None): + """PORTED FROM NETWORKX + Sets edge attributes from a given value or dictionary of values. + .. Warning:: The call order of arguments `values` and `name` + switched between v1.x & v2.x. + Parameters + ---------- + G : NetworkX Graph + values : scalar value, dict-like + What the edge attribute should be set to. If `values` is + not a dictionary, then it is treated as a single attribute value + that is then applied to every edge in `G`. This means that if + you provide a mutable object, like a list, updates to that object + will be reflected in the edge attribute for each edge. The attribute + name will be `name`. + If `values` is a dict or a dict of dict, it should be keyed + by edge tuple to either an attribute value or a dict of attribute + key/value pairs used to update the edge's attributes. + For multigraphs, the edge tuples must be of the form ``(u, v, key)``, + where `u` and `v` are nodes and `key` is the edge key. + For non-multigraphs, the keys must be tuples of the form ``(u, v)``. + name : string (optional, default=None) + Name of the edge attribute to set if values is a scalar. + Examples + -------- + After computing some property of the edges of a graph, you may want + to assign a edge attribute to store the value of that property for + each edge:: + >>> G = nx.path_graph(3) + >>> bb = nx.edge_betweenness_centrality(G, normalized=False) + >>> nx.set_edge_attributes(G, bb, 'betweenness') + >>> G.edges[1, 2]['betweenness'] + 2.0 + If you provide a list as the second argument, updates to the list + will be reflected in the edge attribute for each edge:: + >>> labels = [] + >>> nx.set_edge_attributes(G, labels, 'labels') + >>> labels.append('foo') + >>> G.edges[0, 1]['labels'] + ['foo'] + >>> G.edges[1, 2]['labels'] + ['foo'] + If you provide a dictionary of dictionaries as the second argument, + the entire dictionary will be used to update edge attributes:: + >>> G = nx.path_graph(3) + >>> attrs = {(0, 1): {'attr1': 20, 'attr2': 'nothing'}, + ... (1, 2): {'attr2': 3}} + >>> nx.set_edge_attributes(G, attrs) + >>> G[0][1]['attr1'] + 20 + >>> G[0][1]['attr2'] + 'nothing' + >>> G[1][2]['attr2'] + 3 + """ + if name is not None: + # `values` does not contain attribute names + try: + # if `values` is a dict using `.items()` => {edge: value} + if G.is_multigraph(): + for (u, v, key), value in values.items(): + try: + G[u][v][key][name] = value + except KeyError: + pass + else: + for (u, v), value in values.items(): + try: + G[u][v][name] = value + except KeyError: + pass + except AttributeError: + # treat `values` as a constant + for u, v, data in G.edges(data=True): + data[name] = values + else: + # `values` consists of doct-of-dict {edge: {attr: value}} shape + if G.is_multigraph(): + for (u, v, key), d in values.items(): + try: + G[u][v][key].update(d) + except KeyError: + pass + else: + for (u, v), d in values.items(): + try: + G[u][v].update(d) + except KeyError: + pass + + +# def edge_subgraph(G, edges): +# """PORTED FROM NETWORKX +# Returns a view of the subgraph induced by the specified edges. +# The induced subgraph contains each edge in `edges` and each +# node incident to any of those edges. +# Parameters +# ---------- +# G : NetworkX Graph +# edges : iterable +# An iterable of edges. Edges not present in `G` are ignored. +# Returns +# ------- +# subgraph : SubGraph View +# A read-only edge-induced subgraph of `G`. +# Changes to `G` are reflected in the view. +# Notes +# ----- +# To create a mutable subgraph with its own copies of nodes +# edges and attributes use `subgraph.copy()` or `Graph(subgraph)` +# If you create a subgraph of a subgraph recursively you can end up +# with a chain of subgraphs that becomes very slow with about 15 +# nested subgraph views. Luckily the edge_subgraph filter nests +# nicely so you can use the original graph as G in this function +# to avoid chains. We do not rule out chains programmatically so +# that odd cases like an `edge_subgraph` of a `restricted_view` +# can be created. +# Examples +# -------- +# >>> import networkx as nx +# >>> G = nx.path_graph(5) +# >>> H = G.edge_subgraph([(0, 1), (3, 4)]) +# >>> list(H.nodes) +# [0, 1, 3, 4] +# >>> list(H.edges) +# [(0, 1), (3, 4)] +# """ +# sxf = sx.filters +# edges = set(edges) +# nodes = set() +# for e in edges: +# nodes.update(e[:2]) +# induced_nodes = sxf.show_nodes(nodes) +# if G.is_multigraph(): +# if G.is_directed(): +# induced_edges = sxf.show_multidiedges(edges) +# else: +# induced_edges = sxf.show_multiedges(edges) +# else: +# if G.is_directed(): +# induced_edges = sxf.show_diedges(edges) +# else: +# induced_edges = sxf.show_edges(edges) +# return sx.graphviews.subgraph_view(G, induced_nodes, induced_edges) + + +def frozen(*args, **kwargs): + """Dummy method for raising errors when trying to modify frozen graphs""" + raise sx.SnapXError("Frozen graph can't be modified") + + +def freeze(G): + """Modify graph to prevent further change by adding or removing + nodes or edges. + Node and edge data can still be modified. + Parameters + ---------- + G : graph + A NetworkX graph + Examples + -------- + >>> G = nx.path_graph(4) + >>> G = nx.freeze(G) + >>> try: + ... G.add_edge(4, 5) + ... except nx.NetworkXError as e: + ... print(str(e)) + Frozen graph can't be modified + Notes + ----- + To "unfreeze" a graph you must make a copy by creating a new graph object: + >>> graph = nx.path_graph(4) + >>> frozen_graph = nx.freeze(graph) + >>> unfrozen_graph = nx.Graph(frozen_graph) + >>> nx.is_frozen(unfrozen_graph) + False + See Also + -------- + is_frozen + """ + G.add_node = frozen + G.add_nodes_from = frozen + G.remove_node = frozen + G.remove_nodes_from = frozen + G.add_edge = frozen + G.add_edges_from = frozen + G.add_weighted_edges_from = frozen + G.remove_edge = frozen + G.remove_edges_from = frozen + G.clear = frozen + G.frozen = True + return G diff --git a/snap-python/source/snapx/snapx/classes/graph.py b/snap-python/source/snapx/snapx/classes/graph.py new file mode 100644 index 0000000000000000000000000000000000000000..c394bcc05c48ff8ae08510566ad44b341ceb1368 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/graph.py @@ -0,0 +1,1371 @@ +"""Undirected graphs. +""" + +import snapx as sx + +from snap import TNEANet, TNEANetNodeI, Nodes, Edges, TSIn + +from snapx.classes.reportviews import NodeView, EdgeView +from snapx.classes.coreviews import AdjacencyView +import snapx.convert as convert +from snapx.exception import SnapXTypeError, SnapXError +from ._nodeiter import _GraphNodeIterator, _GraphEdgeIterator, _TNEANetEdgeIter + + +class Graph: + """ + Base class for undirected graphs, much like the "Graph" class in NetworkX. + + DESIGN NOTES: + 1) Use of TNEANet and its consequences: + This class is built on top of TNEANet, a multigraph implemented in C++ SNAP. + For that reason, some of the behaviors expected out of an undirected graph + are emulated in this layer. More specifically, we did the following: + - When an edge (u, v) is added, both (u, v) and (v, u) get registered + to the underlying TNEANet. + - We keep a counter 'self._num_edges' to track how many edges exist in + the graph. + + We currently rely on TNEANet due to its rich support for node and edge + attributes. A future implementation may obviate the need for this emulation + by expanding the C++ SNAP's undirected graph to provide support for such + attributes. + + 2) How graph/node/edge attributes are stored + - Graph attributes: Stored in self.graph, a built-in dict. + - Node and edge attributes: + - An int typed attribute gets stored in the TNEANet's feature storage. + - All other types will go to the extra attribute builtin dicts + (self._node_extra_attr and self._edge_extra_attr). + AttributeDict handles manipulation of edge/node features. + + Docstrings are mostly copied over from NetworkX for reference, and thus may not + accurately reflect the exact features supported in SnapX. + """ + + def to_directed_class(self): + """PORTED FROM NETWORKX + Returns the class to use for empty directed copies. + + If you subclass the base classes, use this to designate + what directed class to use for `to_directed()` copies. + """ + return sx.DiGraph + + def to_undirected_class(self): + """PORTED FROM NETWORKX + Returns the class to use for empty undirected copies. + + If you subclass the base classes, use this to designate + what directed class to use for `to_directed()` copies. + """ + return Graph + + def __init__(self, incoming_graph_data=None, **attr): + """PORTED FROM NETWORKX + Initialize a graph with edges, name, or graph attributes. + Parameters + ---------- + incoming_graph_data : input graph (optional, default: None) + Data to initialize graph. If None (default) an empty + graph is created. The data can be an edge list, or any + NetworkX graph object. If the corresponding optional Python + packages are installed the data can also be a NumPy matrix + or 2d ndarray, a SciPy sparse matrix, or a PyGraphviz graph. + attr : keyword arguments, optional (default= no attributes) + Attributes to add to graph as key=value pairs. + See Also + -------- + convert + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G = nx.Graph(name='my graph') + >>> e = [(1, 2), (2, 3), (3, 4)] # list of edges + >>> G = nx.Graph(e) + Arbitrary graph attribute pairs (key=value) may be assigned + >>> G = nx.Graph(e, day="Friday") + >>> G.graph + {'day': 'Friday'} + """ + self._graph = TNEANet.New() + + # Because we are emulating an undirected graph using multigraph, + # we need a counter to keep track of edges + self._num_edges = 0 + # Supplementary dicts to keep data not supported by snap graph + self._node_extra_attr = {} + self._edge_extra_attr = {} + if incoming_graph_data is not None: + if type(incoming_graph_data) == type(TNEANet.New()): + self._graph = incoming_graph_data + self._num_edges = self._graph.GetEdges() + else: + convert.to_snapx_graph(incoming_graph_data, create_using=self) + + # Graph attributes + self.graph = {} + self.graph.update(attr) + + @property + def adj(self): + """PORTED FROM NETWORKX + Graph adjacency object holding the neighbors of each node. + This object is a read-only dict-like structure with node keys + and neighbor-dict values. The neighbor-dict is keyed by neighbor + to the edge-data-dict. So `G.adj[3][2]['color'] = 'blue'` sets + the color of the edge `(3, 2)` to `"blue"`. + Iterating over G.adj behaves like a dict. Useful idioms include + `for nbr, datadict in G.adj[n].items():`. + The neighbor information is also provided by subscripting the graph. + So `for nbr, foovalue in G[node].data('foo', default=1):` works. + For directed graphs, `G.adj` holds outgoing (successor) info. + """ + return AdjacencyView(self) + + @property + def name(self): + """PORTED FROM NETWORKX + String identifier of the graph. + This graph attribute appears in the attribute dict G.graph + keyed by the string `"name"`. as well as an attribute (technically + a property) `G.name`. This is entirely user controlled. + """ + return self.graph.get("name", "") + + @name.setter + def name(self, s): + self.graph["name"] = s + + def __str__(self): + """PORTED FROM NETWORKX + Returns the graph name. + Returns + ------- + name : string + The name of the graph. + Examples + -------- + >>> G = nx.Graph(name='foo') + >>> str(G) + 'foo' + """ + return self.name + + def __iter__(self): + """PORTED FROM NETWORKX + Iterate over the nodes. Use: 'for n in G'. + Returns + ------- + niter : iterator + An iterator over all nodes in the graph. + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> [n for n in G] + [0, 1, 2, 3] + >>> list(G) + [0, 1, 2, 3] + """ + return _GraphNodeIterator(self._graph.Nodes()) + + def __contains__(self, n): + """PORTED FROM NETWORKX + Returns True if n is a node, False otherwise. Use: 'n in G'. + + Examples + -------- + >>> G = sx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> 1 in G + True + """ + try: + return self._graph.IsNode(n) + except TypeError: + return False + + def __len__(self): + """PORTED FROM NETWORKX + Returns the number of nodes in the graph. Use: 'len(G)'. + + Returns + ------- + nnodes : int + The number of nodes in the graph. + + See Also + -------- + number_of_nodes, order which are identical + + Examples + -------- + >>> G = sx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> len(G) + 4 + + """ + return self._graph.GetNodes() + + def __getitem__(self, n): + """PORTED FROM NETWORKX + Returns a dict of neighbors of node n. Use: 'G[n]'. + Parameters + ---------- + n : node + A node in the graph. + Returns + ------- + adj_dict : dictionary + The adjacency dictionary for nodes connected to n. + Notes + ----- + G[n] is the same as G.adj[n] and similar to G.neighbors(n) + (which is an iterator over G.adj[n]) + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G[0] + AtlasView({1: {}}) + """ + return self.adj[n] + + def add_node(self, node_for_adding, **attr): + """PORTED FROM NETWORKX + Add a single node `node_for_adding` and update node attributes. + Parameters + ---------- + node_for_adding : node + A node can be any hashable Python object except None. + attr : keyword arguments, optional + Set or change node attributes using key=value. + See Also + -------- + add_nodes_from + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_node(1) + >>> G.add_node('Hello') + >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)]) + >>> G.add_node(K3) + >>> G.number_of_nodes() + 3 + Use keywords set/change node attributes: + >>> G.add_node(1, size=10) + >>> G.add_node(3, weight=0.4, UTM=('13S', 382871, 3972649)) + Notes + ----- + A hashable object is one that can be used as a key in a Python + dictionary. This includes strings, numbers, tuples of strings + and numbers, etc. + On many platforms hashable items also include mutables such as + NetworkX Graphs, though one should be careful that the hash + doesn't change on mutables. + """ + try: + if node_for_adding not in self: + self._graph.AddNode(node_for_adding) + self.nodes[node_for_adding].update(attr) + except TypeError: + raise SnapXTypeError("The node ID must be int.") + + def add_nodes_from(self, nodes_for_adding, **attr): + """PORTED FROM NETWORKX + Add multiple nodes. + Parameters + ---------- + nodes_for_adding : iterable container + A container of nodes (list, dict, set, etc.). + OR + A container of (node, attribute dict) tuples. + Node attributes are updated using the attribute dict. + attr : keyword arguments, optional (default= no attributes) + Update attributes for all nodes in nodes. + Node attributes specified in nodes as a tuple take + precedence over attributes specified via keyword arguments. + See Also + -------- + add_node + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_nodes_from('Hello') + >>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)]) + >>> G.add_nodes_from(K3) + >>> sorted(G.nodes(), key=str) + [0, 1, 2, 'H', 'e', 'l', 'o'] + Use keywords to update specific node attributes for every node. + >>> G.add_nodes_from([1, 2], size=10) + >>> G.add_nodes_from([3, 4], weight=0.4) + Use (node, attrdict) tuples to update attributes for specific nodes. + >>> G.add_nodes_from([(1, dict(size=11)), (2, {'color':'blue'})]) + >>> G.nodes[1]['size'] + 11 + >>> H = nx.Graph() + >>> H.add_nodes_from(G.nodes(data=True)) + >>> H.nodes[1]['size'] + 11 + """ + for n in nodes_for_adding: + try: + self.add_node(n) + self.nodes[n].update(attr) + except SnapXTypeError: + nn, ndict = n + if nn not in self.nodes: + self.add_node(nn) + self.nodes[nn].update(attr) + self.nodes[nn].update(ndict) + + def remove_node(self, n): + """PORTED FROM NETWORKX + Remove node n. + + Removes the node n and all adjacent edges. + Attempting to remove a non-existent node will raise an exception. + + Parameters + ---------- + n : node + A node in the graph + + Raises + ------- + NetworkXError + If n is not in the graph. + + See Also + -------- + remove_nodes_from + + Examples + -------- + >>> G = nx.path_graph(3) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> list(G.edges) + [(0, 1), (1, 2)] + >>> G.remove_node(1) + >>> list(G.edges) + [] + """ + try: + if n in self: + self._graph.DelNode(n) + except TypeError: + raise SnapXTypeError("The node ID must be int.") + + def remove_nodes_from(self, nodes): + """PORTED FROM NETWORKX + Remove multiple nodes. + + Parameters + ---------- + nodes : iterable container + A container of nodes (list, dict, set, etc.). If a node + in the container is not in the graph it is silently + ignored. + + See Also + -------- + remove_node + + Examples + -------- + >>> G = nx.path_graph(3) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> e = list(G.nodes) + >>> e + [0, 1, 2] + >>> G.remove_nodes_from(e) + >>> list(G.nodes) + [] + """ + for n in nodes: + try: + self.remove_node(n) + except SnapXTypeError: + pass + + @property + def nodes(self): + """PORTED FROM NETWORKX + A NodeView of the Graph as G.nodes or G.nodes(). + Can be used as `G.nodes` for data lookup and for set-like operations. + Can also be used as `G.nodes(data='color', default=None)` to return a + NodeDataView which reports specific node data but no set operations. + It presents a dict-like interface as well with `G.nodes.items()` + iterating over `(node, nodedata)` 2-tuples and `G.nodes[3]['foo']` + providing the value of the `foo` attribute for node `3`. In addition, + a view `G.nodes.data('foo')` provides a dict-like interface to the + `foo` attribute of each node. `G.nodes.data('foo', default=1)` + provides a default for nodes that do not have attribute `foo`. + Parameters + ---------- + data : string or bool, optional (default=False) + The node attribute returned in 2-tuple (n, ddict[data]). + If True, return entire node attribute dict as (n, ddict). + If False, return just the nodes n. + default : value, optional (default=None) + Value used for nodes that don't have the requested attribute. + Only relevant if data is not True or False. + Returns + ------- + NodeView + Allows set-like operations over the nodes as well as node + attribute dict lookup and calling to get a NodeDataView. + A NodeDataView iterates over `(n, data)` and has no set operations. + A NodeView iterates over `n` and includes set operations. + When called, if data is False, an iterator over nodes. + Otherwise an iterator of 2-tuples (node, attribute value) + where the attribute is specified in `data`. + If data is True then the attribute becomes the + entire data dictionary. + Notes + ----- + If your node data is not needed, it is simpler and equivalent + to use the expression ``for n in G``, or ``list(G)``. + Examples + -------- + There are two simple ways of getting a list of all nodes in the graph: + >>> G = nx.path_graph(3) + >>> list(G.nodes) + [0, 1, 2] + >>> list(G) + [0, 1, 2] + To get the node data along with the nodes: + >>> G.add_node(1, time='5pm') + >>> G.nodes[0]['foo'] = 'bar' + >>> list(G.nodes(data=True)) + [(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})] + >>> list(G.nodes.data()) + [(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})] + >>> list(G.nodes(data='foo')) + [(0, 'bar'), (1, None), (2, None)] + >>> list(G.nodes.data('foo')) + [(0, 'bar'), (1, None), (2, None)] + >>> list(G.nodes(data='time')) + [(0, None), (1, '5pm'), (2, None)] + >>> list(G.nodes.data('time')) + [(0, None), (1, '5pm'), (2, None)] + >>> list(G.nodes(data='time', default='Not Available')) + [(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')] + >>> list(G.nodes.data('time', default='Not Available')) + [(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')] + If some of your nodes have an attribute and the rest are assumed + to have a default attribute value you can create a dictionary + from node/attribute pairs using the `default` keyword argument + to guarantee the value is never None:: + >>> G = nx.Graph() + >>> G.add_node(0) + >>> G.add_node(1, weight=2) + >>> G.add_node(2, weight=3) + >>> dict(G.nodes(data='weight', default=1)) + {0: 1, 1: 2, 2: 3} + """ + nodes = NodeView(self) + # Lazy View creation: overload the (class) property on the instance + # Then future G.nodes use the existing View + # setattr doesn't work because attribute already exists + self.__dict__["nodes"] = nodes + return nodes + + def number_of_nodes(self): + """PORTED FROM NETWORKX + Returns the number of nodes in the graph. + Returns + ------- + nnodes : int + The number of nodes in the graph. + See Also + -------- + order, __len__ which are identical + Examples + -------- + >>> G = nx.path_graph(3) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.number_of_nodes() + 3 + """ + return self._graph.GetNodes() + + def order(self): + """PORTED FROM NETWORKX + Returns the number of nodes in the graph. + Returns + ------- + nnodes : int + The number of nodes in the graph. + See Also + -------- + number_of_nodes, __len__ which are identical + Examples + -------- + >>> G = nx.path_graph(3) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.order() + 3 + """ + return self._graph.GetNodes() + + def has_node(self, n): + """PORTED FROM NETWORKX + Returns True if the graph contains the node n. + Identical to `n in G` + Parameters + ---------- + n : node + Examples + -------- + >>> G = nx.path_graph(3) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.has_node(0) + True + It is more readable and simpler to use + >>> 0 in G + True + """ + try: + return n in self + except TypeError: + return False + + def add_edge(self, u_of_edge, v_of_edge, **attr): + """PORTED FROM NETWORKX: + Add an edge between u and v. + The nodes u and v will be automatically added if they are + not already in the graph. + Edge attributes can be specified with keywords or by directly + accessing the edge's attribute dictionary. See examples below. + Parameters + ---------- + u, v : nodes + Nodes can be, for example, strings or numbers. + Nodes must be hashable (and not None) Python objects. + attr : keyword arguments, optional + Edge data (or labels or objects) can be assigned using + keyword arguments. + See Also + -------- + add_edges_from : add a collection of edges + Notes + ----- + Adding an edge that already exists updates the edge data. + Many NetworkX algorithms designed for weighted graphs use + an edge attribute (by default `weight`) to hold a numerical value. + Examples + -------- + The following all add the edge e=(1, 2) to graph G: + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> e = (1, 2) + >>> G.add_edge(1, 2) # explicit two-node form + >>> G.add_edge(*e) # single edge as tuple of two nodes + >>> G.add_edges_from([(1, 2)]) # add edges from iterable container + Associate data to edges using keywords: + >>> G.add_edge(1, 2, weight=3) + >>> G.add_edge(1, 3, weight=7, capacity=15, length=342.7) + For non-string attribute keys, use subscript notation. + >>> G.add_edge(1, 2) + >>> G[1][2].update({0: 5}) + >>> G.edges[1, 2].update({0: 5}) + """ + u = u_of_edge + v = v_of_edge + + if u not in self.nodes: + self.add_node(u) + if v not in self.nodes: + self.add_node(v) + + # Emulate (non-multi) graph by checking if the edge + # already exists. + if self.has_edge(u, v): + return + try: + self._graph.AddEdge(u, v) + if u != v: + self._graph.AddEdge(v, u) + self._num_edges += 1 + + # Finally update attrs + self.adj[u][v].update(attr) + + except TypeError: + raise SnapXTypeError("SNAP only supports int as edge keys.") + + def add_edges_from(self, ebunch_to_add, **attr): + """PORTED FROM NETWORKX + Add all the edges in ebunch_to_add. + Parameters + ---------- + ebunch_to_add : container of edges + Each edge given in the container will be added to the + graph. The edges must be given as as 2-tuples (u, v) or + 3-tuples (u, v, d) where d is a dictionary containing edge data. + attr : keyword arguments, optional + Edge data (or labels or objects) can be assigned using + keyword arguments. + See Also + -------- + add_edge : add a single edge + add_weighted_edges_from : convenient way to add weighted edges + Notes + ----- + Adding the same edge twice has no effect but any edge data + will be updated when each duplicate edge is added. + Edge attributes specified in an ebunch take precedence over + attributes specified via keyword arguments. + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_edges_from([(0, 1), (1, 2)]) # using a list of edge tuples + >>> e = zip(range(0, 3), range(1, 4)) + >>> G.add_edges_from(e) # Add the path graph 0-1-2-3 + Associate data to edges + >>> G.add_edges_from([(1, 2), (2, 3)], weight=3) + >>> G.add_edges_from([(3, 4), (1, 4)], label='WN2898') + """ + for e in ebunch_to_add: + ne = len(e) + if ne == 3: + u, v, dd = e + elif ne == 2: + u, v = e + dd = {} + else: + raise SnapXError("The edge must be a 2-tuple or 3-tuple.") + try: + self.add_edge(u, v) + # FIXME: Faster way than simply walking over the dict? + self.edges[(u, v)].update(attr) + self.edges[(u, v)].update(dd) + + except (TypeError, RuntimeError) as e: + pass + + def add_weighted_edges_from(self, ebunch_to_add, weight="weight", **attr): + """PORTED FROM NETWORKX + Add weighted edges in `ebunch_to_add` with specified weight attr + Parameters + ---------- + ebunch_to_add : container of edges + Each edge given in the list or container will be added + to the graph. The edges must be given as 3-tuples (u, v, w) + where w is a number. + weight : string, optional (default= 'weight') + The attribute name for the edge weights to be added. + attr : keyword arguments, optional (default= no attributes) + Edge attributes to add/update for all edges. + See Also + -------- + add_edge : add a single edge + add_edges_from : add multiple edges + Notes + ----- + Adding the same edge twice for Graph/DiGraph simply updates + the edge data. For MultiGraph/MultiDiGraph, duplicate edges + are stored. + Examples + -------- + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_weighted_edges_from([(0, 1, 3.0), (1, 2, 7.5)]) + """ + self.add_edges_from(((u, v, {weight: d}) for u, v, d in ebunch_to_add), **attr) + + def remove_edge(self, u, v): + """PORTED FROM NETWORKX + Remove the edge between u and v. + + Parameters + ---------- + u, v : nodes + Remove the edge between nodes u and v. + + Raises + ------ + NetworkXError + If there is not an edge between u and v. + + See Also + -------- + remove_edges_from : remove a collection of edges + + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, etc + >>> G.remove_edge(0, 1) + >>> e = (1, 2) + >>> G.remove_edge(*e) # unpacks e from an edge tuple + >>> e = (2, 3, {"weight": 7}) # an edge with attribute data + >>> G.remove_edge(*e[:2]) # select first part of edge tuple + """ + if not self.has_edge(u, v): + return + + try: + self._graph.DelEdge(u, v) + if u != v: + self._graph.DelEdge(v, u) + self._num_edges -= 1 + except TypeError: + raise SnapXTypeError("SNAP only supports int as edge keys.") + + def remove_edges_from(self, ebunch): + """PORTED FROM NETWORKX + Remove all edges specified in ebunch. + + Parameters + ---------- + ebunch: list or container of edge tuples + Each edge given in the list or container will be removed + from the graph. The edges can be: + + - 2-tuples (u, v) edge between u and v. + - 3-tuples (u, v, k) where k is ignored. + + See Also + -------- + remove_edge : remove a single edge + + Notes + ----- + Will fail silently if an edge in ebunch is not in the graph. + + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> ebunch = [(1, 2), (2, 3)] + >>> G.remove_edges_from(ebunch) + """ + for e in ebunch_to_add: + ne = len(e) + if ne == 3: + u, v, _ = e + elif ne == 2: + u, v = e + else: + raise SnapXError("The edge must be a 2-tuple or 3-tuple.") + + try: + self.remove_edge(u, v) + except (TypeError, RuntimeError) as e: + pass + + def update(self, edges=None, nodes=None): + """PORTED FROM NETWORKX + Update the graph using nodes/edges/graphs as input. + Like dict.update, this method takes a graph as input, adding the + graph's nodes and edges to this graph. It can also take two inputs: + edges and nodes. Finally it can take either edges or nodes. + To specify only nodes the keyword `nodes` must be used. + The collections of edges and nodes are treated similarly to + the add_edges_from/add_nodes_from methods. When iterated, they + should yield 2-tuples (u, v) or 3-tuples (u, v, datadict). + Parameters + ---------- + edges : Graph object, collection of edges, or None + The first parameter can be a graph or some edges. If it has + attributes `nodes` and `edges`, then it is taken to be a + Graph-like object and those attributes are used as collections + of nodes and edges to be added to the graph. + If the first parameter does not have those attributes, it is + treated as a collection of edges and added to the graph. + If the first argument is None, no edges are added. + nodes : collection of nodes, or None + The second parameter is treated as a collection of nodes + to be added to the graph unless it is None. + If `edges is None` and `nodes is None` an exception is raised. + If the first parameter is a Graph, then `nodes` is ignored. + Examples + -------- + >>> G = nx.path_graph(5) + >>> G.update(nx.complete_graph(range(4,10))) + >>> from itertools import combinations + >>> edges = ((u, v, {'power': u * v}) + ... for u, v in combinations(range(10, 20), 2) + ... if u * v < 225) + >>> nodes = [1000] # for singleton, use a container + >>> G.update(edges, nodes) + Notes + ----- + It you want to update the graph using an adjacency structure + it is straightforward to obtain the edges/nodes from adjacency. + The following examples provide common cases, your adjacency may + be slightly different and require tweaks of these examples. + >>> # dict-of-set/list/tuple + >>> adj = {1: {2, 3}, 2: {1, 3}, 3: {1, 2}} + >>> e = [(u, v) for u, nbrs in adj.items() for v in nbrs] + >>> G.update(edges=e, nodes=adj) + >>> DG = nx.DiGraph() + >>> # dict-of-dict-of-attribute + >>> adj = {1: {2: 1.3, 3: 0.7}, 2: {1: 1.4}, 3: {1: 0.7}} + >>> e = [(u, v, {'weight': d}) for u, nbrs in adj.items() + ... for v, d in nbrs.items()] + >>> DG.update(edges=e, nodes=adj) + >>> # dict-of-dict-of-dict + >>> adj = {1: {2: {'weight': 1.3}, 3: {'color': 0.7, 'weight':1.2}}} + >>> e = [(u, v, {'weight': d}) for u, nbrs in adj.items() + ... for v, d in nbrs.items()] + >>> DG.update(edges=e, nodes=adj) + >>> # predecessor adjacency (dict-of-set) + >>> pred = {1: {2, 3}, 2: {3}, 3: {3}} + >>> e = [(v, u) for u, nbrs in pred.items() for v in nbrs] + >>> # MultiGraph dict-of-dict-of-dict-of-attribute + >>> MDG = nx.MultiDiGraph() + >>> adj = {1: {2: {0: {'weight': 1.3}, 1: {'weight': 1.2}}}, + ... 3: {2: {0: {'weight': 0.7}}}} + >>> e = [(u, v, ekey, d) for u, nbrs in adj.items() + ... for v, keydict in nbrs.items() + ... for ekey, d in keydict.items()] + >>> MDG.update(edges=e) + See Also + -------- + add_edges_from: add multiple edges to a graph + add_nodes_from: add multiple nodes to a graph + """ + if edges is not None: + if nodes is not None: + self.add_nodes_from(nodes) + self.add_edges_from(edges) + else: + # check if edges is a Graph object + try: + graph_nodes = edges.nodes + graph_edges = edges.edges + except AttributeError: + # edge not Graph-like + self.add_edges_from(edges) + else: # edges is Graph-like + self.add_nodes_from(graph_nodes.data()) + self.add_edges_from(graph_edges.data()) + self.graph.update(edges.graph) + elif nodes is not None: + self.add_nodes_from(nodes) + else: + raise sx.SnapXError("update needs nodes or edges input") + + def has_edge(self, u, v): + """PORTED FROM NETWORKX + Returns True if the edge (u, v) is in the graph. + This is the same as `v in G[u]` without KeyError exceptions. + Parameters + ---------- + u, v : nodes + Nodes can be, for example, strings or numbers. + Nodes must be hashable (and not None) Python objects. + Returns + ------- + edge_ind : bool + True if edge is in the graph, False otherwise. + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.has_edge(0, 1) # using two nodes + True + >>> e = (0, 1) + >>> G.has_edge(*e) # e is a 2-tuple (u, v) + True + >>> e = (0, 1, {'weight':7}) + >>> G.has_edge(*e[:2]) # e is a 3-tuple (u, v, data_dictionary) + True + The following syntax are equivalent: + >>> G.has_edge(0, 1) + True + >>> 1 in G[0] # though this gives KeyError if 0 not in G + True + """ + u, v = Graph._order_edge(u, v) + + # Avoid snap runtime error by first checking + # if the nodes exist + if u not in self or v not in self: + return False + try: + return self._graph.IsEdge(u, v) + except TypeError: + return False + + def neighbors(self, n): + """PORTED FROM NETWORKX + Returns an iterator over all neighbors of node n. + This is identical to `iter(G[n])` + Parameters + ---------- + n : node + A node in the graph + Returns + ------- + neighbors : iterator + An iterator over all neighbors of node n + Raises + ------ + NetworkXError + If the node n is not in the graph. + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> [n for n in G.neighbors(0)] + [1] + Notes + ----- + Alternate ways to access the neighbors are ``G.adj[n]`` or ``G[n]``: + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_edge('a', 'b', weight=7) + >>> G['a'] + AtlasView({'b': {'weight': 7}}) + >>> G = nx.path_graph(4) + >>> [n for n in G[0]] + [1] + """ + try: + return iter(self.adj[n]) + except KeyError: + raise SnapXError("The node {} is not in the graph.".format(n)) + + @property + def edges(self): + """PORTED FROM NETWORKX + An EdgeView of the Graph as G.edges or G.edges(). + edges(self, nbunch=None, data=False, default=None) + The EdgeView provides set-like operations on the edge-tuples + as well as edge attribute lookup. When called, it also provides + an EdgeDataView object which allows control of access to edge + attributes (but does not provide set-like operations). + Hence, `G.edges[u, v]['color']` provides the value of the color + attribute for edge `(u, v)` while + `for (u, v, c) in G.edges.data('color', default='red'):` + iterates through all the edges yielding the color attribute + with default `'red'` if no color attribute exists. + Parameters + ---------- + nbunch : single node, container, or all nodes (default= all nodes) + The view will only report edges incident to these nodes. + data : string or bool, optional (default=False) + The edge attribute returned in 3-tuple (u, v, ddict[data]). + If True, return edge attribute dict in 3-tuple (u, v, ddict). + If False, return 2-tuple (u, v). + default : value, optional (default=None) + Value used for edges that don't have the requested attribute. + Only relevant if data is not True or False. + Returns + ------- + edges : EdgeView + A view of edge attributes, usually it iterates over (u, v) + or (u, v, d) tuples of edges, but can also be used for + attribute lookup as `edges[u, v]['foo']`. + Notes + ----- + Nodes in nbunch that are not in the graph will be (quietly) ignored. + For directed graphs this returns the out-edges. + Examples + -------- + >>> G = nx.path_graph(3) # or MultiGraph, etc + >>> G.add_edge(2, 3, weight=5) + >>> [e for e in G.edges] + [(0, 1), (1, 2), (2, 3)] + >>> G.edges.data() # default data is {} (empty dict) + EdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]) + >>> G.edges.data('weight', default=1) + EdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)]) + >>> G.edges([0, 3]) # only edges incident to these nodes + EdgeDataView([(0, 1), (3, 2)]) + >>> G.edges(0) # only edges incident to a single node (use G.adj[0]?) + EdgeDataView([(0, 1)]) + """ + return EdgeView(self) + + def get_edge_data(self, u, v, default=None): + """PORTED FROM NETWORKX + Returns the attribute dictionary associated with edge (u, v). + This is identical to `G[u][v]` except the default is returned + instead of an exception if the edge doesn't exist. + Parameters + ---------- + u, v : nodes + default: any Python object (default=None) + Value to return if the edge (u, v) is not found. + Returns + ------- + edge_dict : dictionary + The edge attribute dictionary. + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G[0][1] + {} + Warning: Assigning to `G[u][v]` is not permitted. + But it is safe to assign attributes `G[u][v]['foo']` + >>> G[0][1]['weight'] = 7 + >>> G[0][1]['weight'] + 7 + >>> G[1][0]['weight'] + 7 + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.get_edge_data(0, 1) # default edge data is {} + {} + >>> e = (0, 1) + >>> G.get_edge_data(*e) # tuple form + {} + >>> G.get_edge_data('a', 'b', default=0) # edge not in graph, return 0 + 0 + """ + try: + return self.adj[u][v] + except KeyError: + return default + + def adjacency(self): + """PORTED FROM NETWORKX + Returns an iterator over (node, adjacency dict) tuples for all nodes. + For directed graphs, only outgoing neighbors/adjacencies are included. + Returns + ------- + adj_iter : iterator + An iterator over (node, adjacency dictionary) for all nodes in + the graph. + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> [(n, nbrdict) for n, nbrdict in G.adjacency()] + [(0, {1: {}}), (1, {0: {}, 2: {}}), (2, {1: {}, 3: {}}), (3, {2: {}})] + """ + return iter(self.adj.items()) + + @property + def degree(self): + raise NotImplementedError("TODO") + + def clear(self): + """PORTED_FROM_NETWORKX + Remove all nodes and edges from the graph. + This also removes the name, and all graph, node, and edge attributes. + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.clear() + >>> list(G.nodes) + [] + >>> list(G.edges) + [] + """ + self._graph.Clr() + self._num_edges = 0 + self._node_extra_attr.clear() + self._edge_extra_attr.clear() + self.graph.clear() + + def is_multigraph(self): + return False + + def is_directed(self): + return False + + def copy(self, as_view=False): + """PORTED FROM NETWORKX + Returns a copy of the graph. + The copy method by default returns an independent shallow copy + of the graph and attributes. That is, if an attribute is a + container, that container is shared by the original an the copy. + Use Python's `copy.deepcopy` for new containers. + If `as_view` is True then a view is returned instead of a copy. + Notes + ----- + All copies reproduce the graph structure, but data attributes + may be handled in different ways. There are four types of copies + of a graph that people might want. + Deepcopy -- A "deepcopy" copies the graph structure as well as + all data attributes and any objects they might contain. + The entire graph object is new so that changes in the copy + do not affect the original object. (see Python's copy.deepcopy) + Data Reference (Shallow) -- For a shallow copy the graph structure + is copied but the edge, node and graph attribute dicts are + references to those in the original graph. This saves + time and memory but could cause confusion if you change an attribute + in one graph and it changes the attribute in the other. + NetworkX does not provide this level of shallow copy. + Independent Shallow -- This copy creates new independent attribute + dicts and then does a shallow copy of the attributes. That is, any + attributes that are containers are shared between the new graph + and the original. This is exactly what `dict.copy()` provides. + You can obtain this style copy using: + >>> G = nx.path_graph(5) + >>> H = G.copy() + >>> H = G.copy(as_view=False) + >>> H = nx.Graph(G) + >>> H = G.__class__(G) + Fresh Data -- For fresh data, the graph structure is copied while + new empty data attribute dicts are created. The resulting graph + is independent of the original and it has no edge, node or graph + attributes. Fresh copies are not enabled. Instead use: + >>> H = G.__class__() + >>> H.add_nodes_from(G) + >>> H.add_edges_from(G.edges) + View -- Inspired by dict-views, graph-views act like read-only + versions of the original graph, providing a copy of the original + structure without requiring any memory for copying the information. + See the Python copy module for more information on shallow + and deep copies, https://docs.python.org/2/library/copy.html. + Parameters + ---------- + as_view : bool, optional (default=False) + If True, the returned graph-view provides a read-only view + of the original graph without actually copying any data. + Returns + ------- + G : Graph + A copy of the graph. + See Also + -------- + to_directed: return a directed copy of the graph. + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> H = G.copy() + """ + if as_view is True: + raise NotImplementedError("TODO") + # return nx.graphviews.generic_graph_view(self) + G = self.__class__() + G.graph.update(self.graph) + # Copy snap graph + G.add_nodes_from((n, d) for n, d in self.nodes(data=True)) + G.add_edges_from( + (u, v, datadict) + for u, nbrs in self.adj.items() + for v, datadict in nbrs.items() + ) + return G + + def to_directed(self, as_view=False): + raise NotImplementedError("TODO") + + def to_undirected(self, as_view=False): + raise NotImplementedError("TODO") + + def subgraph(self, nodes): + """PORTED FROM NETWORKX + Returns a SubGraph view of the subgraph induced on `nodes`. + The induced subgraph of the graph contains the nodes in `nodes` + and the edges between those nodes. + Parameters + ---------- + nodes : list, iterable + A container of nodes which will be iterated through once. + Returns + ------- + G : SubGraph View + A subgraph view of the graph. The graph structure cannot be + changed but node/edge attributes can and are shared with the + original graph. + Notes + ----- + The graph, edge and node attributes are shared with the original graph. + Changes to the graph structure is ruled out by the view, but changes + to attributes are reflected in the original graph. + To create a subgraph with its own copy of the edge/node attributes use: + G.subgraph(nodes).copy() + For an inplace reduction of a graph to a subgraph you can remove nodes: + G.remove_nodes_from([n for n in G if n not in set(nodes)]) + Subgraph views are sometimes NOT what you want. In most cases where + you want to do more than simply look at the induced edges, it makes + more sense to just create the subgraph as its own graph with code like: + :: + # Create a subgraph SG based on a (possibly multigraph) G + SG = G.__class__() + SG.add_nodes_from((n, G.nodes[n]) for n in largest_wcc) + if SG.is_multigraph(): + SG.add_edges_from((n, nbr, key, d) + for n, nbrs in G.adj.items() if n in largest_wcc + for nbr, keydict in nbrs.items() if nbr in largest_wcc + for key, d in keydict.items()) + else: + SG.add_edges_from((n, nbr, d) + for n, nbrs in G.adj.items() if n in largest_wcc + for nbr, d in nbrs.items() if nbr in largest_wcc) + SG.graph.update(G.graph) + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> H = G.subgraph([0, 1, 2]) + >>> list(H.edges) + [(0, 1), (1, 2)] + """ + induced_nodes = sx.filters.show_nodes(self.nbunch_iter(nodes)) + # if already a subgraph, don't make a chain + subgraph = sx.graphviews.subgraph_view + if hasattr(self, "_NODE_OK"): + return subgraph(self._graph, induced_nodes, self._EDGE_OK) + return subgraph(self, induced_nodes) + + # def edge_subgraph(self, edges): + # """Returns the subgraph induced by the specified edges. + # The induced subgraph contains each edge in `edges` and each + # node incident to any one of those edges. + # Parameters + # ---------- + # edges : iterable + # An iterable of edges in this graph. + # Returns + # ------- + # G : Graph + # An edge-induced subgraph of this graph with the same edge + # attributes. + # Notes + # ----- + # The graph, edge, and node attributes in the returned subgraph + # view are references to the corresponding attributes in the original + # graph. The view is read-only. + # To create a full graph version of the subgraph with its own copy + # of the edge or node attributes, use:: + # >>> G.edge_subgraph(edges).copy() # doctest: +SKIP + # Examples + # -------- + # >>> G = nx.path_graph(5) + # >>> H = G.edge_subgraph([(0, 1), (3, 4)]) + # >>> list(H.nodes) + # [0, 1, 3, 4] + # >>> list(H.edges) + # [(0, 1), (3, 4)] + # """ + # return nx.edge_subgraph(self, edges) + + def size(self, weight=None): + """PORTED FROM NETWORKX + Returns the number of edges or total of all edge weights. + Parameters + ---------- + weight : string or None, optional (default=None) + The edge attribute that holds the numerical value used + as a weight. If None, then each edge has weight 1. + Returns + ------- + size : numeric + The number of edges or + (if weight keyword is provided) the total weight sum. + If weight is None, returns an int. Otherwise a float + (or more general numeric if the weights are more general). + See Also + -------- + number_of_edges + Examples + -------- + >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.size() + 3 + >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc + >>> G.add_edge('a', 'b', weight=2) + >>> G.add_edge('b', 'c', weight=4) + >>> G.size() + 2 + >>> G.size(weight='weight') + 6.0 + """ + if weight is not None: + raise NotImplementedError("TODO") + return self._num_edges + + def number_of_edges(self, u=None, v=None): + """PORTED FROM NETWORKX + Returns the number of edges between two nodes. + Parameters + ---------- + u, v : nodes, optional (default=all edges) + If u and v are specified, return the number of edges between + u and v. Otherwise return the total number of all edges. + Returns + ------- + nedges : int + The number of edges in the graph. If nodes `u` and `v` are + specified return the number of edges between those nodes. If + the graph is directed, this only returns the number of edges + from `u` to `v`. + See Also + -------- + size + Examples + -------- + For undirected graphs, this method counts the total number of + edges in the graph: + >>> G = nx.path_graph(4) + >>> G.number_of_edges() + 3 + If you specify two nodes, this counts the total number of edges + joining the two nodes: + >>> G.number_of_edges(0, 1) + 1 + For directed graphs, this method can count the total number of + directed edges from `u` to `v`: + >>> G = nx.DiGraph() + >>> G.add_edge(0, 1) + >>> G.add_edge(1, 0) + >>> G.number_of_edges(0, 1) + 1 + """ + if u is None: + return self.size() + if self.has_edge(u, v): + return 1 + return 0 + + def nbunch_iter(self, nbunch=None): + """PORTED FROM NETWORKX + Returns an iterator over nodes contained in nbunch that are + also in the graph. + The nodes in nbunch are checked for membership in the graph + and if not are silently ignored. + Parameters + ---------- + nbunch : single node, container, or all nodes (default= all nodes) + The view will only report edges incident to these nodes. + Returns + ------- + niter : iterator + An iterator over nodes in nbunch that are also in the graph. + If nbunch is None, iterate over all nodes in the graph. + Raises + ------ + NetworkXError + If nbunch is not a node or or sequence of nodes. + If a node in nbunch is not hashable. + See Also + -------- + Graph.__iter__ + Notes + ----- + When nbunch is an iterator, the returned iterator yields values + directly from nbunch, becoming exhausted when nbunch is exhausted. + To test whether nbunch is a single node, one can use + "if nbunch in self:", even after processing with this routine. + If nbunch is not a node or a (possibly empty) sequence/iterator + or None, a :exc:`NetworkXError` is raised. Also, if any object in + nbunch is not hashable, a :exc:`NetworkXError` is raised. + """ + if nbunch is None: + bunch = iter(self) + elif nbunch in self: + bunch = iter([nbunch]) + else: + + def bunch_iter(nlist, adj): + try: + for n in nlist: + if n in adj: + yield n + except TypeError as e: + message = e.args[0] + # capture error for non-sequence/iterator nbunch. + if "iter" in message: + msg = "nbunch is not a node or a sequence of nodes." + raise SnapXError(msg) + else: + raise + + bunch = bunch_iter(nbunch, self.adj) + return bunch + + def _edge_iter(self): + """Returns a SNAP edge iterator.""" + return _TNEANetEdgeIter(self._graph.Edges(), directed=False) + + @property + def snap_graph(self): + """Returns the underlying SNAP graph.""" + return self._graph + + @staticmethod + def _order_edge(u, v): + return (u, v) if u <= v else (v, u) diff --git a/snap-python/source/snapx/snapx/classes/graphviews.py b/snap-python/source/snapx/snapx/classes/graphviews.py new file mode 100644 index 0000000000000000000000000000000000000000..84330adeac3a10ba17e8fc9c7deee271c89d58f7 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/graphviews.py @@ -0,0 +1,133 @@ +"""View of Graphs as SubGraph, Reverse, Directed, Undirected. +In some algorithms it is convenient to temporarily morph +a graph to exclude some nodes or edges. It should be better +to do that via a view than to remove and then re-add. +In other algorithms it is convenient to temporarily morph +a graph to reverse directed edges, or treat a directed graph +as undirected, etc. This module provides those graph views. +The resulting views are essentially read-only graphs that +report data from the orignal graph object. We provide an +attribute G._graph which points to the underlying graph object. +Note: Since graphviews look like graphs, one can end up with +view-of-view-of-view chains. Be careful with chains because +they become very slow with about 15 nested views. +For the common simple case of node induced subgraphs created +from the graph class, we short-cut the chain by returning a +subgraph of the original graph directly rather than a subgraph +of a subgraph. We are careful not to disrupt any edge filter in +the middle subgraph. In general, determining how to short-cut +the chain is tricky and much harder with restricted_views than +with induced subgraphs. +Often it is easiest to use .copy() to avoid chains. +""" +from snapx.classes.coreviews import ( + # UnionAdjacency, + # UnionMultiAdjacency, + FilterAtlas, + FilterAdjacency, + FilterMultiAdjacency, +) +from snapx.classes.filters import no_filter + +# from snapx.exception import SnapXError +# from snapx.utils import not_implemented_for + +import snapx as sx + +__all__ = ["subgraph_view"] + + +def subgraph_view(G, filter_node=no_filter, filter_edge=no_filter): + """ View of `G` applying a filter on nodes and edges. + `subgraph_view` provides a read-only view of the input graph that excludes + nodes and edges based on the outcome of two filter functions `filter_node` + and `filter_edge`. + The `filter_node` function takes one argument --- the node --- and returns + `True` if the node should be included in the subgraph, and `False` if it + should not be included. + The `filter_edge` function takes two (or three arguments if `G` is a + multi-graph) --- the nodes describing an edge, plus the edge-key if + parallel edges are possible --- and returns `True` if the edge should be + included in the subgraph, and `False` if it should not be included. + Both node and edge filter functions are called on graph elements as they + are queried, meaning there is no up-front cost to creating the view. + Parameters + ---------- + G : networkx.Graph + A directed/undirected graph/multigraph + filter_node : callable, optional + A function taking a node as input, which returns `True` if the node + should appear in the view. + filter_edge : callable, optional + A function taking as input the two nodes describing an edge (plus the + edge-key if `G` is a multi-graph), which returns `True` if the edge + should appear in the view. + Returns + ------- + graph : networkx.Graph + A read-only graph view of the input graph. + Examples + -------- + >>> import networkx as nx + >>> G = nx.path_graph(6) + Filter functions operate on the node, and return `True` if the node should + appear in the view: + >>> def filter_node(n1): + ... return n1 != 5 + ... + >>> view = nx.subgraph_view( + ... G, + ... filter_node=filter_node + ... ) + >>> view.nodes() + NodeView((0, 1, 2, 3, 4)) + We can use a closure pattern to filter graph elements based on additional + data --- for example, filtering on edge data attached to the graph: + >>> G[3][4]['cross_me'] = False + >>> def filter_edge(n1, n2): + ... return G[n1][n2].get('cross_me', True) + ... + >>> view = nx.subgraph_view( + ... G, + ... filter_edge=filter_edge + ... ) + >>> view.edges() + EdgeView([(0, 1), (1, 2), (2, 3), (4, 5)]) + >>> view = nx.subgraph_view( + ... G, + ... filter_node=filter_node, + ... filter_edge=filter_edge, + ... ) + >>> view.nodes() + NodeView((0, 1, 2, 3, 4)) + >>> view.edges() + EdgeView([(0, 1), (1, 2), (2, 3)]) + """ + newG = sx.freeze(G.__class__()) + newG._NODE_OK = filter_node + newG._EDGE_OK = filter_edge + + # create view by assigning attributes from G + newG._graph = G + newG.graph = G.graph + + newG._node_extra_attr = FilterAtlas(G._node_extra_attr, filter_node) + if G.is_multigraph(): + Adj = FilterMultiAdjacency + + def reverse_edge(u, v, k): + return filter_edge(v, u, k) + + else: + Adj = FilterAdjacency + + def reverse_edge(u, v): + return filter_edge(v, u) + + if G.is_directed(): + newG._succ = Adj(G._succ, filter_node, filter_edge) + newG._pred = Adj(G._pred, filter_node, reverse_edge) + newG._adj = newG._succ + else: + newG.nodes = Adj(G.nodes, filter_node, filter_edge) + return newG diff --git a/snap-python/source/snapx/snapx/classes/reportviews.py b/snap-python/source/snapx/snapx/classes/reportviews.py new file mode 100644 index 0000000000000000000000000000000000000000..ad5605875f3b38a7e03c024785f5d4fa0a532a51 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/reportviews.py @@ -0,0 +1,287 @@ +from .attrdict import AttributeDict +from collections.abc import Mapping, Set + +# NodeViews +class NodeView(Mapping, Set): + __slots__ = ("_graph",) + + def __getstate__(self): + raise NotImplementedError("TODO") + + def __setstate__(self, state): + raise NotImplementedError("TODO") + + def __init__(self, graph): + self._graph = graph + + # Mapping methods + def __len__(self): + return len(self._graph) + + def __iter__(self): + return iter(self._graph) + + def __getitem__(self, n): + if n not in self._graph: + raise KeyError(str(n)) + return AttributeDict(self._graph, n) + + # Set methods + def __contains__(self, n): + return n in self._graph + + @classmethod + def _from_iterable(cls, it): + return set(it) + + # DataView method + def __call__(self, data=False, default=None): + if data is False: + return self + return NodeDataView(self._graph, data, default) + + def data(self, data=True, default=None): + if data is False: + return self + return NodeDataView(self._graph, data, default) + + def __str__(self): + return str(list(self)) + + def __repr__(self): + return "{}({})".format(self.__class__.__name__, tuple(self)) + + +class NodeDataView(Set): + __slots__ = ("_graph", "_data", "_default") + + def __getstate__(self): + raise NotImplementedError("TODO") + + def __setstate__(self, state): + raise NotImplementedError("TODO") + + def __init__(self, graph, data=False, default=None): + self._graph = graph + self._data = data + self._default = default + + @classmethod + def _from_iterable(cls, it): + try: + return set(it) + except TypeError as err: + if "unhashable" in str(err): + msg = " : Could be b/c data=True or your values are unhashable" + raise TypeError(str(err) + msg) + raise + + def __len__(self): + return len(self._graph) + + def __iter__(self): + for n in self._graph: + if isinstance(self._data, bool): + if self._data: + yield (n, AttributeDict(self._graph, n)) + else: + yield n + else: + val = AttributeDict(self._graph, n)[self._data] + val = val if val else (self._default if self._default else None) + yield (n, val) + + def __contains__(self, n): + try: + node_in = n in self._graph + except TypeError: + n, d = n + return n in self._graph and self[n] == d + if node_in is True: + return node_in + try: + n, d = n + except (TypeError, ValueError): + return False + return n in self._graph and self[n] == d + + def __getitem__(self, n): + ddict = self._graph.nodes[n] + data = self._data + if data is False or data is True: + return ddict + return ddict[data] if data in ddict else self._default + + def __str__(self): + return str(list(self)) + + def __repr__(self): + name = self.__class__.__name__ + if self._data is False: + return "{}({})".format(name, tuple(self)) + if self._data is True: + return "{}({})".format(name, dict(self)) + return "{}({}, data={})".format(name, dict(self), self._data.__repr__()) + + +class OutEdgeDataView: + """EdgeDataView for outward edges of DiGraph; See EdgeDataView""" + + __slots__ = ( + "_viewer", + "_nbunch", + "_data", + "_default", + "_graph", + "_nodes_nbrs", + "_report", + ) + + def __getstate__(self): + raise NotImplementedError("TODO") + + def __setstate__(self, state): + raise NotImplementedError("TODO") + + def __init__(self, viewer, nbunch=None, data=False, default=None): + self._viewer = viewer + graph = self._graph = viewer._graph # FIXME: Better way to pass graph? + + if nbunch is None: + self._nodes_nbrs = graph.adj.items + else: + nbunch = list(graph.nbunch_iter(nbunch)) + self._nodes_nbrs = lambda: [(n, graph.adj[n]) for n in nbunch] + + self._nbunch = nbunch + self._data = data + self._default = default + + # Set _report based on data and default + if data is True: + self._report = lambda n, nbr, dd: (n, nbr, dd) + elif data is False: + self._report = lambda n, nbr, dd: (n, nbr) + else: # data is attribute name + self._report = ( + lambda n, nbr, dd: (n, nbr, dd[data]) + if data in dd + else (n, nbr, default) + ) + + def __len__(self): + # TODO: Support nbunch and returning # of their neighbors + return self._graph.number_of_edges() + + def __iter__(self): + return ( + self._report(n, nbr, dd) + for n, nbrs in self._nodes_nbrs() + for nbr, dd in nbrs.items() + ) + + def __contains__(self, e): + try: + u, v = e[:2] + ddict = AttributeDict(self._graph, (u, v)) + except KeyError: + return False + return e == self._report(u, v, ddict) + + def __str__(self): + return str(list(self)) + + def __repr__(self): + return "{}({})".format(self.__class__.__name__, list(self)) + + +class EdgeDataView(OutEdgeDataView): + __slots__ = () + + def __len__(self): + return sum(1 for e in self) + + def __iter__(self): + seen = {} + for n, nbrs in self._nodes_nbrs(): + for nbr, dd in nbrs.items(): + if nbr not in seen: + yield self._report(n, nbr, dd) + seen[n] = 1 + del seen + + +# EdgeViews have set operations and no data reported +class OutEdgeView(Set, Mapping): + """A EdgeView class for outward edges of a DiGraph""" + + __slots__ = ("_graph", "_nodes_nbrs") + + dataview = OutEdgeDataView + + def __getstate__(self): + raise NotImplementedError("TODO") + + def __setstate__(self, state): + raise NotImplementedError("TODO") + + @classmethod + def _from_iterable(cls, it): + return set(it) + + def __init__(self, G): + self._graph = G + self._nodes_nbrs = G.adj.items + + # Set methods + def __len__(self): + return sum(len(nbrs) for n, nbrs in self._nodes_nbrs()) + + def __iter__(self): + for n, nbrs in self._nodes_nbrs(): + for nbr in nbrs: + yield (n, nbr) + + def __contains__(self, e): + return self._graph.has_edge(*e) + + # Mapping Methods + def __getitem__(self, e): + return AttributeDict(self._graph, e) + + # EdgeDataView methods + def __call__(self, nbunch=None, data=False, default=None): + if nbunch is None and data is False: + return self + return self.dataview(self, nbunch, data, default) + + def data(self, data=True, default=None, nbunch=None): + if nbunch is None and data is False: + return self + return self.dataview(self, nbunch, data, default) + + # String Methods + def __str__(self): + return str(list(self)) + + def __repr__(self): + return "{}({})".format(self.__class__.__name__, list(self)) + + +class EdgeView(OutEdgeView): + __slots__ = () + dataview = EdgeDataView + + def __len__(self): + num_nbrs = (len(nbrs) + (n in nbrs) for n, nbrs in self._nodes_nbrs()) + return sum(num_nbrs) // 2 + + def __iter__(self): + seen = {} + for n, nbrs in self._nodes_nbrs(): + for nbr in list(nbrs): + if nbr not in seen: + yield (n, nbr) + seen[n] = 1 + del seen + diff --git a/snap-python/source/snapx/snapx/classes/tests/__init__.py b/snap-python/source/snapx/snapx/classes/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d3141799d5802b931e9b7aba9254aa41aa9be0b6 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/tests/__init__.py @@ -0,0 +1 @@ +import snap diff --git a/snap-python/source/snapx/snapx/classes/tests/test_attrdict.py b/snap-python/source/snapx/snapx/classes/tests/test_attrdict.py new file mode 100644 index 0000000000000000000000000000000000000000..584c8e6fed705338f8a2281f0c3f111896f33b73 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/tests/test_attrdict.py @@ -0,0 +1,98 @@ +import pytest + +import snapx as sx + +class TestAttributeDict: + def setup(self): + """By design, is impossible to decouple the graph from the AttributeDict, + so I am setting up a graph first in this series of tests. I certainly don't + enjoy passing around states, but I also don't have a better idea at the moment. + Maybe someone can refine the design and reduce the amount of inter- + dependence between Views, Graphs, and AttributeDict. """ + g = sx.Graph() + g.add_nodes_from([0, 1, 2]) + g.add_edges_from([(0, 1), (0, 2), (1, 2)]) + self.g = g + self.ndicts = {0: {"int": 1, "float": 1.234, "str": "This is a test string."}, + 1: {"float": 0.4, "foo": ["bar", "baz"]}, + 2: {"str": "string", "list": [1, 2], "dict": {"hello": "world"}}} + self.edicts = {(0, 1): {"int": 2, "dict": {"aa": "bbb"}}, + (0, 2): {"float": 0.23, "tuple": (1, 2, 4), "str": "abc", "int": 3}, + (1, 2): {"str": "bar", "list": [3, "aaa"]}} + # Implicitly calling __setitem__ + for n in self.ndicts.keys(): + self.g.nodes[n].update(self.ndicts[n]) + for e in self.edicts.keys(): + self.g.edges[e].update(self.edicts[e]) + + def test_init_fail(self): + """Checks if initialization successfully fails + for invalid inputs""" + g = sx.Graph() + # Invalid node ID (not integer) + with pytest.raises(sx.SnapXTypeError): + sx.AttributeDict(g, "hoge") + # Invalid format + with pytest.raises(sx.SnapXTypeError): + sx.AttributeDict(g, (1, 2, 3)) + # Invalid edge (not integer) + with pytest.raises(sx.SnapXTypeError): + sx.AttributeDict(g, (0, "hoge")) + with pytest.raises(sx.SnapXTypeError): + sx.AttributeDict(g, ("foo", 2)) + + g.add_nodes_from([0, 1]) + # Nonexistent edge + with pytest.raises(sx.SnapXKeyError): + sx.AttributeDict(g, (0, 1)) + + def test_contains(self): + # Implicitly tests __iter__ + for n in self.ndicts.keys(): + for gt in self.ndicts[n]: + assert gt in self.g.nodes[n] + + for e in self.edicts.keys(): + for gt in self.edicts[e]: + assert gt in self.g.edges[e] + + def test_len(self): + for n in self.ndicts.keys(): + assert len(self.g.nodes[n]) == len(self.ndicts[n]) + for e in self.edicts.keys(): + assert len(self.g.edges[e]) == len(self.edicts[e]) + + def test_setitem_overwrite(self): + self.g.nodes[0]["int"] = 34 + self.g.nodes[2]["str"] = "new string" + + assert self.g.nodes[0]["int"] == 34 + assert self.g.nodes[2]["str"] == "new string" + + def test_setitem_fail(self): + # Only str is allowed as attr name + with pytest.raises(sx.SnapXTypeError): + self.g.nodes[0][123] = 456 + + def test_items(self): + # This implicitly tests __getitem__ + for n in self.ndicts.keys(): + assert sorted(self.ndicts[n].items()) == sorted(self.g.nodes[n].items()) + for e in self.edicts.keys(): + assert sorted(self.edicts[e].items()) == sorted(self.g.edges[e].items()) + + def test_delitem(self): + # attribute type supported by snap + del self.g.nodes[0]["int"] + del self.ndicts[0]["int"] + for key in self.ndicts[0]: + assert self.g.nodes[0][key] == self.ndicts[0][key] + assert not "int" in self.g.nodes[0] + + # Not supported by snap + del self.g.edges[(0, 2)]["float"] + del self.edicts[(0, 2)]["float"] + for key in self.edicts[(0, 2)]: + assert self.g.edges[(0, 2)][key] == self.edicts[(0, 2)][key] + assert not "float" in self.g.edges[(0, 2)] + diff --git a/snap-python/source/snapx/snapx/classes/tests/test_coreviews.py b/snap-python/source/snapx/snapx/classes/tests/test_coreviews.py new file mode 100644 index 0000000000000000000000000000000000000000..9eb83b5a4558b535d1031cfcd34dde9f6d084577 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/tests/test_coreviews.py @@ -0,0 +1,133 @@ +import pytest +import pickle + +import snapx as sx + + +class TestAtlasView: + def setup(self): + g = sx.Graph() + g.add_nodes_from([0, 1, 2]) + # This is what we expect the AtlasView for node 0 to look like + self.atlas = {0: {'color': 'blue', 'weight': 1.2}, 1: {}, 2: {'color': 'green'}} + for key in self.atlas.keys(): + g.add_edge(0, key) + g.edges[(0, key)].update(self.atlas[key]) + self.g = g + self.av = sx.classes.coreviews.AtlasView(g, 0) + + # NOTE: Not supported + #def test_pickle(self): + # view = self.av + # pview = pickle.loads(pickle.dumps(view, -1)) + # assert view == pview + # assert view.__slots__ == pview.__slots__ + # pview = pickle.loads(pickle.dumps(view)) + # assert view == pview + # assert view.__slots__ == pview.__slots__ + + def test_len(self): + assert len(self.av) == len(self.atlas) + + def test_iter(self): + assert list(self.av) == list(self.atlas) + + def test_getitem(self): + for n in self.atlas: + for key in self.atlas[n]: + assert self.av[n][key] == self.atlas[n][key] + with pytest.raises(KeyError): + self.av[3] + + # NOTE: Not supported + #def test_copy(self): + # avcopy = self.av.copy() + # assert avcopy[0] == self.av[0] + # assert avcopy == self.av + # assert avcopy[0] is not self.av[0] + # assert avcopy is not self.av + # avcopy[5] = {} + # assert avcopy != self.av + + # avcopy[0]['ht'] = 4 + # assert avcopy[0] != self.av[0] + # self.av[0]['ht'] = 4 + # assert avcopy[0] == self.av[0] + # del self.av[0]['ht'] + + # assert not hasattr(self.av, '__setitem__') + + def test_items(self): + assert sorted(self.av.items()) == sorted(self.atlas.items()) + + def test_str(self): + out = str(self.atlas) + assert str(self.av) == out + + def test_repr(self): + out = "AtlasView(" + str(self.atlas) + ")" + assert repr(self.av) == out + +class TestAdjacencyView: + # node->nbr->data + def setup(self): + g = sx.Graph() + g.add_nodes_from([0, 1, 2, 3]) + dd03 = {'color': 'blue', 'weight': 1.2} + dd23 = {'color': 'green'} + # This is what we expect the AdjacencyView to look like: + self.adj = {0: {3: dd03}, 1: {}, 2: {3: dd23}, 3: {0: dd03, 2: dd23}} + for src in self.adj.keys(): + for dst in self.adj[src]: + g.add_edge(src, dst) + g.edges[(src, dst)].update(self.adj[src][dst]) + self.g = g + self.adjview = sx.classes.coreviews.AdjacencyView(g) + + # NOTE: Not supported + #def test_pickle(self): + # view = self.adjview + # pview = pickle.loads(pickle.dumps(view, -1)) + # assert view == pview + # assert view.__slots__ == pview.__slots__ + + def test_len(self): + assert len(self.adjview) == len(self.adj) + + def test_iter(self): + assert sorted(list(self.adjview)) == sorted(list(self.adj)) + + def test_getitem(self): + for src in self.adj: + for dst in self.adj[src]: + for key in self.adj[src][dst]: + assert self.adjview[src][dst][key] == self.adj[src][dst][key] + + with pytest.raises(KeyError): + self.adjview[4] + + # NOTE: Not supported + #def test_copy(self): + # avcopy = self.adjview.copy() + # assert avcopy[0] == self.adjview[0] + # assert avcopy[0] is not self.adjview[0] + + # avcopy[2][3]['ht'] = 4 + # assert avcopy[2] != self.adjview[2] + # self.adjview[2][3]['ht'] = 4 + # assert avcopy[2] == self.adjview[2] + # del self.adjview[2][3]['ht'] + + # assert not hasattr(self.adjview, '__setitem__') + + def test_items(self): + view_items = sorted((n, dict(d)) for n, d in self.adjview.items()) + assert view_items == sorted(self.adj.items()) + + def test_str(self): + out = str(dict(self.adj)) + assert str(self.adjview) == out + + def test_repr(self): + out = self.adjview.__class__.__name__ + "(" + str(self.adj) + ")" + assert repr(self.adjview) == out diff --git a/snap-python/source/snapx/snapx/classes/tests/test_graph.py b/snap-python/source/snapx/snapx/classes/tests/test_graph.py new file mode 100644 index 0000000000000000000000000000000000000000..a69e9e5577cbac21f5f3cbad6c09919317b520e5 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/tests/test_graph.py @@ -0,0 +1,776 @@ +""" Test suite for Graph. + +Test cases are copied from NetworkX. +""" + +import pickle +import gc + +import snapx as sx +from snapx.testing.utils import ( + assert_graphs_equal, + assert_edges_equal, + assert_nodes_equal +) + +import pytest + + +class BaseGraphTester: + """ Tests for data-structure independent graph class features.""" + + def test_contains(self): + G = self.K3 + assert(1 in G) + assert(4 not in G) + assert('b' not in G) + assert([] not in G) # no exception for nonhashable + assert({1: 1} not in G) # no exception for nonhashable + + def test_order(self): + G = self.K3 + assert len(G) == 3 + assert G.order() == 3 + assert G.number_of_nodes() == 3 + + def test_nodes(self): + G = self.K3 + assert sorted(G.nodes()) == self.k3nodes + assert sorted(G.nodes(data=True)) == [(0, {}), (1, {}), (2, {})] + + def test_has_node(self): + G = self.K3 + assert(G.has_node(1)) + assert(not G.has_node(4)) + assert(not G.has_node([])) # no exception for nonhashable + assert(not G.has_node({1: 1})) # no exception for nonhashable + + def test_has_edge(self): + G = self.K3 + assert G.has_edge(0, 1) + assert not G.has_edge(0, -1) + + def test_neighbors(self): + G = self.K3 + assert sorted(G.neighbors(0)) == [1, 2] + with pytest.raises(sx.SnapXError): + G.neighbors(-1) + + def test_memory_leak(self): + G = self.Graph() + + def count_objects_of_type(_type): + return sum(1 for obj in gc.get_objects() if isinstance(obj, _type)) + + gc.collect() + before = count_objects_of_type(self.Graph) + G.copy() + gc.collect() + after = count_objects_of_type(self.Graph) + assert before == after + + # test a subgraph of the base class + class MyGraph(self.Graph): + pass + + gc.collect() + G = MyGraph() + before = count_objects_of_type(MyGraph) + G.copy() + gc.collect() + after = count_objects_of_type(MyGraph) + assert before == after + + def test_edges(self): + G = self.K3 + assert_edges_equal(G.edges(), [(0, 1), (0, 2), (1, 2)]) + assert_edges_equal(G.edges(0), [(0, 1), (0, 2)]) + assert_edges_equal(G.edges([0, 1]), [(0, 1), (0, 2), (1, 2)]) + with pytest.raises(sx.SnapXError): + G.edges(-1) + + + #NOTE: Not supported + #def test_degree(self): + # G = self.K3 + # assert sorted(G.degree()) == [(0, 2), (1, 2), (2, 2)] + # assert dict(G.degree()) == {0: 2, 1: 2, 2: 2} + # assert G.degree(0) == 2 + # with pytest.raises(sx.SnapXError): + # G.degree(-1) # node not in graph + + + def test_size(self): + G = self.K3 + assert G.size() == 3 + assert G.number_of_edges() == 3 + + def test_nbunch_iter(self): + G = self.K3 + assert_nodes_equal(G.nbunch_iter(), self.k3nodes) # all nodes + assert_nodes_equal(G.nbunch_iter(0), [0]) # single node + assert_nodes_equal(G.nbunch_iter([0, 1]), [0, 1]) # sequence + # sequence with none in graph + assert_nodes_equal(G.nbunch_iter([-1]), []) + # node not in graph doesn't get caught upon creation of iterator + bunch = G.nbunch_iter(-1) + # but gets caught when iterator used + with pytest.raises(sx.SnapXError): + list(bunch) + + # string sequence should fail with TypeError + bunch = G.nbunch_iter("foo") + with pytest.raises(TypeError): + list(bunch) + + # unhashable doesn't get caught upon creation of iterator + bunch = G.nbunch_iter([0, 1, 2, {}]) + # but gets caught when iterator hits the unhashable + with pytest.raises(TypeError): + list(bunch) + + # TODO: Examine if we need this test... + #def test_nbunch_iter_node_format_raise(self): + # # Tests that a node that would have failed string formatting + # # doesn't cause an error when attempting to raise a + # # :exc:`sx.SnapXError`. + + # # For more information, see pull request #1813. + # G = self.Graph() + # nbunch = [('x', set())] + # with pytest.raises(sx.SnapXError): + # list(G.nbunch_iter(nbunch)) + + # TODO: Not supported + #def test_selfloop_degree(self): + # G = self.Graph() + # G.add_edge(1, 1) + # assert sorted(G.degree()) == [(1, 2)] + # assert dict(G.degree()) == {1: 2} + # assert G.degree(1) == 2 + # assert sorted(G.degree([1])) == [(1, 2)] + # assert G.degree(1, weight='weight') == 2 + + # TODO: Not supported + #def test_selfloops(self): + # G = self.K3.copy() + # G.add_edge(0, 0) + # assert_nodes_equal(sx.nodes_with_selfloops(G), [0]) + # assert_edges_equal(sx.selfloop_edges(G), [(0, 0)]) + # assert sx.number_of_selfloops(G) == 1 + # G.remove_edge(0, 0) + # G.add_edge(0, 0) + # G.remove_edges_from([(0, 0)]) + # G.add_edge(1, 1) + # G.remove_node(1) + # G.add_edge(0, 0) + # G.add_edge(1, 1) + # G.remove_nodes_from([0, 1]) + + +class BaseAttrGraphTester(BaseGraphTester): + """ Tests of graph class attribute features.""" + + # NOTE: Not supported + #def test_weighted_degree(self): + # G = self.Graph() + # G.add_edge(1, 2, weight=2, other=3) + # G.add_edge(2, 3, weight=3, other=4) + # assert (sorted(d for n, d in G.degree(weight='weight')) == + # [2, 3, 5]) + # assert dict(G.degree(weight='weight')) == {1: 2, 2: 5, 3: 3} + # assert G.degree(1, weight='weight') == 2 + # assert_nodes_equal((G.degree([1], weight='weight')), [(1, 2)]) + + # assert_nodes_equal((d for n, d in G.degree(weight='other')), [3, 7, 4]) + # assert dict(G.degree(weight='other')) == {1: 3, 2: 7, 3: 4} + # assert G.degree(1, weight='other') == 3 + # assert_edges_equal((G.degree([1], weight='other')), [(1, 3)]) + + def add_attributes(self, G): + G.graph['foo'] = [] + G.nodes[0]['foo'] = [] + ll = [] + G.edges[(1, 2)]["foo"] = ll + + def test_name(self): + G = self.Graph(name='') + assert G.name == "" + G = self.Graph(name='test') + assert G.__str__() == "test" + assert G.name == "test" + + # NOTE: Not supported + #def test_graph_chain(self): + # G = self.Graph([(0, 1), (1, 2)]) + # DG = G.to_directed(as_view=True) + # SDG = DG.subgraph([0, 1]) + # RSDG = SDG.reverse(copy=False) + # assert G is DG._graph + # assert DG is SDG._graph + # assert SDG is RSDG._graph + + def test_copy(self): + G = self.Graph() + G.add_node(0) + G.add_edge(1, 2) + self.add_attributes(G) + # copy edge datadict but any container attr are same + H = G.copy() + self.graphs_equal(H, G) + #self.different_attrdict(H, G) + self.shallow_copy_attrdict(H, G) + + # NOTE: Not supported (constructor using a graph) + #def test_class_copy(self): + # G = self.Graph() + # G.add_node(0) + # G.add_edge(1, 2) + # self.add_attributes(G) + # # copy edge datadict but any container attr are same + # H = G.__class__(G) + # self.graphs_equal(H, G) + # self.different_attrdict(H, G) + # self.shallow_copy_attrdict(H, G) + + def test_fresh_copy(self): + G = self.Graph() + G.add_node(0) + G.add_edge(1, 2) + self.add_attributes(G) + # copy graph structure but use fresh datadict + H = G.__class__() + H.add_nodes_from(G) + H.add_edges_from(G.edges()) + assert len(G.nodes[0]) == 1 + ddict = G.adj[1][2][0] if G.is_multigraph() else G.adj[1][2] + assert len(ddict) == 1 + assert len(H.nodes[0]) == 0 + ddict = H.adj[1][2][0] if H.is_multigraph() else H.adj[1][2] + assert len(ddict) == 0 + + def is_deepcopy(self, H, G): + self.graphs_equal(H, G) + self.different_attrdict(H, G) + self.deep_copy_attrdict(H, G) + + def deep_copy_attrdict(self, H, G): + self.deepcopy_graph_attr(H, G) + self.deepcopy_node_attr(H, G) + self.deepcopy_edge_attr(H, G) + + def deepcopy_graph_attr(self, H, G): + assert G.graph['foo'] == H.graph['foo'] + G.graph['foo'].append(1) + assert G.graph['foo'] != H.graph['foo'] + + def deepcopy_node_attr(self, H, G): + assert G.nodes[0]['foo'] == H.nodes[0]['foo'] + G.nodes[0]['foo'].append(1) + assert G.nodes[0]['foo'] != H.nodes[0]['foo'] + + def deepcopy_edge_attr(self, H, G): + assert G[1][2]['foo'] == H[1][2]['foo'] + G[1][2]['foo'].append(1) + assert G[1][2]['foo'] != H[1][2]['foo'] + + def is_shallow_copy(self, H, G): + self.graphs_equal(H, G) + self.shallow_copy_attrdict(H, G) + + def shallow_copy_attrdict(self, H, G): + self.shallow_copy_graph_attr(H, G) + self.shallow_copy_node_attr(H, G) + self.shallow_copy_edge_attr(H, G) + + def shallow_copy_graph_attr(self, H, G): + assert G.graph['foo'] == H.graph['foo'] + G.graph['foo'].append(1) + assert G.graph['foo'] == H.graph['foo'] + + def shallow_copy_node_attr(self, H, G): + assert G.nodes[0]['foo'] == H.nodes[0]['foo'] + G.nodes[0]['foo'].append(1) + assert G.nodes[0]['foo'] == H.nodes[0]['foo'] + + def shallow_copy_edge_attr(self, H, G): + assert G[1][2]['foo'] == H[1][2]['foo'] + G[1][2]['foo'].append(1) + assert G[1][2]['foo'] == H[1][2]['foo'] + + def same_attrdict(self, H, G): + old_foo = H[1][2]['foo'] + H.adj[1][2]['foo'] = 'baz' + assert G.edges == H.edges + H.adj[1][2]['foo'] = old_foo + assert G.edges == H.edges + + old_foo = H.nodes[0]['foo'] + H.nodes[0]['foo'] = 'baz' + assert G.nodes == H.nodes + H.nodes[0]['foo'] = old_foo + assert G.nodes == H.nodes + + def different_attrdict(self, H, G): + old_foo = H[1][2]['foo'] + H.adj[1][2]['foo'] = 'baz' + assert G.adj != H.adj + H.adj[1][2]['foo'] = old_foo + assert G.adj == H.adj + + old_foo = H.nodes[0]['foo'] + H.nodes[0]['foo'] = 'baz' + assert G.nodes != H.nodes + H.nodes[0]['foo'] = old_foo + assert G.nodes == H.nodes + + def graphs_equal(self, H, G): + assert G.adj == H.adj + assert G.nodes == H.nodes + assert G.graph == H.graph + assert G.name == H.name + ''' + if not G.is_directed() and not H.is_directed(): + assert H._adj[1][2] is H._adj[2][1] + assert G._adj[1][2] is G._adj[2][1] + else: # at least one is directed + if not G.is_directed(): + G._pred = G._adj + G._succ = G._adj + if not H.is_directed(): + H._pred = H._adj + H._succ = H._adj + assert G._pred == H._pred + assert G._succ == H._succ + assert H._succ[1][2] is H._pred[2][1] + assert G._succ[1][2] is G._pred[2][1]''' + + def test_graph_attr(self): + G = self.K3.copy() + G.graph['foo'] = 'bar' + assert G.graph['foo'] == 'bar' + del G.graph['foo'] + assert G.graph == {} + H = self.Graph(foo='bar') + assert H.graph['foo'] == 'bar' + + def test_node_attr(self): + G = self.K3.copy() + G.add_node(1, foo='bar') + assert_nodes_equal(G.nodes(), [0, 1, 2]) + assert_nodes_equal(G.nodes(data=True), + [(0, {}), (1, {'foo': 'bar'}), (2, {})]) + G.nodes[1]['foo'] = 'baz' + assert_nodes_equal(G.nodes(data=True), + [(0, {}), (1, {'foo': 'baz'}), (2, {})]) + assert_nodes_equal(G.nodes(data='foo'), + [(0, None), (1, 'baz'), (2, None)]) + assert_nodes_equal(G.nodes(data='foo', default='bar'), + [(0, 'bar'), (1, 'baz'), (2, 'bar')]) + + def test_node_attr2(self): + G = self.K3.copy() + a = {'foo': 'bar'} + G.add_node(3, **a) + assert_nodes_equal(G.nodes(), [0, 1, 2, 3]) + assert_nodes_equal(G.nodes(data=True), + [(0, {}), (1, {}), (2, {}), (3, {'foo': 'bar'})]) + + def test_edge_lookup(self): + G = self.Graph() + G.add_edge(1, 2, foo='bar') + assert_edges_equal(G.edges[1, 2], {'foo': 'bar'}) + + def test_edge_attr(self): + G = self.Graph() + G.add_edge(1, 2, foo='bar') + assert_edges_equal(G.edges(data=True), [(1, 2, {'foo': 'bar'})]) + assert_edges_equal(G.edges(data='foo'), [(1, 2, 'bar')]) + + def test_edge_attr2(self): + G = self.Graph() + G.add_edges_from([(1, 2), (3, 4)], foo='foo') + assert_edges_equal(G.edges(data=True), + [(1, 2, {'foo': 'foo'}), (3, 4, {'foo': 'foo'})]) + assert_edges_equal(G.edges(data='foo'), + [(1, 2, 'foo'), (3, 4, 'foo')]) + + def test_edge_attr3(self): + G = self.Graph() + G.add_edges_from([(1, 2, {'weight': 32}), + (3, 4, {'weight': 64})], foo='foo') + assert_edges_equal(G.edges(data=True), + [(1, 2, {'foo': 'foo', 'weight': 32}), + (3, 4, {'foo': 'foo', 'weight': 64})]) + + # NOTE: Edge removal not supported + # G.remove_edges_from([(1, 2), (3, 4)]) + # G.add_edge(1, 2, data=7, spam='bar', bar='foo') + # assert_edges_equal(G.edges(data=True), + # [(1, 2, {'data': 7, 'spam': 'bar', 'bar': 'foo'})]) + + def test_edge_attr4(self): + G = self.Graph() + G.add_edge(1, 2, data=7, spam='bar', bar='foo') + assert_edges_equal(G.edges(data=True), + [(1, 2, {'data': 7, 'spam': 'bar', 'bar': 'foo'})]) + G[1][2]['data'] = 10 # OK to set data like this + assert_edges_equal(G.edges(data=True), + [(1, 2, {'data': 10, 'spam': 'bar', 'bar': 'foo'})]) + + G.adj[1][2]['data'] = 20 + assert_edges_equal(G.edges(data=True), + [(1, 2, {'data': 20, 'spam': 'bar', 'bar': 'foo'})]) + G.edges[1, 2]['data'] = 21 # another spelling, "edge" + assert_edges_equal(G.edges(data=True), + [(1, 2, {'data': 21, 'spam': 'bar', 'bar': 'foo'})]) + G.adj[1][2]['listdata'] = [20, 200] + G.adj[1][2]['weight'] = 20 + dd = {'data': 21, 'spam': 'bar', 'bar': 'foo', + 'listdata': [20, 200], 'weight': 20} + assert_edges_equal(G.edges(data=True), [(1, 2, dd)]) + + # Note: Not supported + #def test_to_undirected(self): + # G = self.K3 + # self.add_attributes(G) + # H = sx.Graph(G) + # self.is_shallow_copy(H, G) + # self.different_attrdict(H, G) + # H = G.to_undirected() + # self.is_deepcopy(H, G) + + # NOTE: Not supported + #def test_to_directed(self): + # G = self.K3 + # self.add_attributes(G) + # H = sx.DiGraph(G) + # self.is_shallow_copy(H, G) + # self.different_attrdict(H, G) + # H = G.to_directed() + # self.is_deepcopy(H, G) + + # NOTE: Not supported + #def test_subgraph(self): + # G = self.K3 + # self.add_attributes(G) + # H = G.subgraph([0, 1, 2, 5]) + # self.graphs_equal(H, G) + # self.same_attrdict(H, G) + # self.shallow_copy_attrdict(H, G) + + # H = G.subgraph(0) + # assert H.adj == {0: {}} + # H = G.subgraph([]) + # assert H.adj == {} + # assert G.adj != {} + + + # NOTE: Not supported + #def test_selfloops_attr(self): + # G = self.K3.copy() + # G.add_edge(0, 0) + # G.add_edge(1, 1, weight=2) + # assert_edges_equal(sx.selfloop_edges(G, data=True), + # [(0, 0, {}), (1, 1, {'weight': 2})]) + # assert_edges_equal(sx.selfloop_edges(G, data='weight'), + # [(0, 0, None), (1, 1, 2)]) + + +class TestGraph(BaseAttrGraphTester): + """Tests specific to dict-of-dict-of-dict graph data structure""" + + def setup_method(self): + self.Graph = sx.Graph + # build dict-of-dict-of-dict K3 + self.k3edges = [(0, 1), (0, 2), (1, 2)] + self.k3nodes = [0, 1, 2] + self.K3 = self.Graph() + + self.K3.add_nodes_from(self.k3nodes) + self.K3.add_edges_from(self.k3edges) + assert(list(self.K3.nodes) == self.k3nodes) + assert(list(self.K3.edges) == self.k3edges) + assert(self.K3.number_of_edges() == len(self.k3edges)) + + # NOTE: Not supported + #def test_pickle(self): + # G = self.K3 + # pg = pickle.loads(pickle.dumps(G, -1)) + # self.graphs_equal(pg, G) + # pg = pickle.loads(pickle.dumps(G)) + # self.graphs_equal(pg, G) + + # NOTE: Not supported + #def test_data_input(self): + # G = self.Graph({1: [2], 2: [1]}, name="test") + # assert G.name == "test" + # assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})] + # G = self.Graph({1: [2], 2: [1]}, name="test") + # assert G.name == "test" + # assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})] + + def test_adjacency(self): + G = self.K3 + assert (dict(G.adjacency()) == + {0: {1: {}, 2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}) + + def test_getitem(self): + G = self.K3 + assert G[0] == {1: {}, 2: {}} + with pytest.raises(KeyError): + G.__getitem__(4) # Key should not be present + with pytest.raises(TypeError): + G.__getitem__(['A']) + + def test_add_node(self): + G = self.Graph() + G.add_node(0) + assert G.adj == {0: {}} + # test add attributes + G.add_node(1, c='red') + G.add_node(2, c='blue') + G.add_node(3, c='red') + assert G.nodes[1]['c'] == 'red' + assert G.nodes[2]['c'] == 'blue' + assert G.nodes[3]['c'] == 'red' + # test updating attributes + G.add_node(1, c='blue') + G.add_node(2, c='red') + G.add_node(3, c='blue') + assert G.nodes[1]['c'] == 'blue' + assert G.nodes[2]['c'] == 'red' + assert G.nodes[3]['c'] == 'blue' + + def test_add_nodes_from(self): + G = self.Graph() + G.add_nodes_from([0, 1, 2]) + assert G.adj == {0: {}, 1: {}, 2: {}} + # test add attributes + G.add_nodes_from([0, 1, 2], c='red') + assert G.nodes[0]['c'] == 'red' + assert G.nodes[2]['c'] == 'red' + # test that attribute dicts are not the same + assert(G.nodes[0] is not G.nodes[1]) + # test updating attributes + G.add_nodes_from([0, 1, 2], c='blue') + assert G.nodes[0]['c'] == 'blue' + assert G.nodes[2]['c'] == 'blue' + assert(G.nodes[0] is not G.nodes[1]) + # test tuple input + H = self.Graph() + H.add_nodes_from(G.nodes(data=True)) + assert H.nodes[0]['c'] == 'blue' + assert H.nodes[2]['c'] == 'blue' + assert(H.nodes[0] is not H.nodes[1]) + # specific overrides general + H.add_nodes_from([0, (1, {'c': 'green'}), (3, {'c': 'cyan'})], c='red') + assert H.nodes[0]['c'] == 'red' + assert H.nodes[1]['c'] == 'green' + assert H.nodes[2]['c'] == 'blue' + assert H.nodes[3]['c'] == 'cyan' + + # NOTE: Not supported + #def test_remove_node(self): + # G = self.K3.copy() + # G.remove_node(0) + # assert G.adj == {1: {2: {}}, 2: {1: {}}} + # with pytest.raises(sx.SnapXError): + # G.remove_node(-1) + + # # generator here to implement list,set,string... + #def test_remove_nodes_from(self): + # G = self.K3.copy() + # G.remove_nodes_from([0, 1]) + # assert G.adj == {2: {}} + # G.remove_nodes_from([-1]) # silent fail + + def test_add_edge(self): + G = self.Graph() + G.add_edge(0, 1) + assert G.adj == {0: {1: {}}, 1: {0: {}}} + G = self.Graph() + G.add_edge(*(0, 1)) + assert G.adj == {0: {1: {}}, 1: {0: {}}} + + def test_add_edges_from(self): + G = self.Graph() + G.add_edges_from([(0, 1), (0, 2, {'weight': 3})]) + assert G.adj == {0: {1: {}, 2: {'weight': 3}}, 1: {0: {}}, + 2: {0: {'weight': 3}}} + G = self.Graph() + G.add_edges_from([(0, 1), (0, 2, {'weight': 3}), + (1, 2, {'data': 4})], data=2) + assert G.adj == { + 0: {1: {'data': 2}, 2: {'weight': 3, 'data': 2}}, + 1: {0: {'data': 2}, 2: {'data': 4}}, + 2: {0: {'weight': 3, 'data': 2}, 1: {'data': 4}} + } + + with pytest.raises(sx.SnapXError): + G.add_edges_from([(0,)]) # too few in tuple + with pytest.raises(sx.SnapXError): + G.add_edges_from([(0, 1, 2, 3)]) # too many in tuple + with pytest.raises(TypeError): + G.add_edges_from([0]) # not a tuple + + # NOTE: Not supported + #def test_remove_edge(self): + # G = self.K3.copy() + # G.remove_edge(0, 1) + # assert G.adj == {0: {2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}} + # with pytest.raises(sx.SnapXError): + # G.remove_edge(-1, 0) + + #def test_remove_edges_from(self): + # G = self.K3.copy() + # G.remove_edges_from([(0, 1)]) + # assert G.adj == {0: {2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}} + # G.remove_edges_from([(0, 0)]) # silent fail + + def test_clear(self): + G = self.K3.copy() + G.clear() + assert G.adj == {} + + def test_edges_data(self): + G = self.K3 + all_edges = [(0, 1, {}), (0, 2, {}), (1, 2, {})] + assert_edges_equal(G.edges(data=True), all_edges) + assert_edges_equal(G.edges(0, data=True), [(0, 1, {}), (0, 2, {})]) + assert_edges_equal(G.edges([0, 1], data=True), all_edges) + with pytest.raises(sx.SnapXError): + G.edges(-1, True) + + def test_get_edge_data(self): + G = self.K3.copy() + assert G.get_edge_data(0, 1) == {} + assert G[0][1] == {} + assert G.get_edge_data(10, 20) is None + assert G.get_edge_data(-1, 0) is None + assert G.get_edge_data(-1, 0, default=1) == 1 + + def test_update(self): + # specify both edgees and nodes + G = self.K3.copy() + G.update(nodes=[3, (4, {'size': 2})], + edges=[(4, 5), (6, 7, {'weight': 2})]) + nlist = [(0, {}), (1, {}), (2, {}), (3, {}), + (4, {'size': 2}), (5, {}), (6, {}), (7, {})] + assert sorted(G.nodes.data()) == nlist + if G.is_directed(): + elist = [(0, 1, {}), (0, 2, {}), (1, 0, {}), (1, 2, {}), + (2, 0, {}), (2, 1, {}), + (4, 5, {}), (6, 7, {'weight': 2})] + else: + elist = [(0, 1, {}), (0, 2, {}), (1, 2, {}), + (4, 5, {}), (6, 7, {'weight': 2})] + assert sorted(G.edges.data()) == elist + assert G.graph == {} + + # no keywords -- order is edges, nodes + G = self.K3.copy() + G.update([(4, 5), (6, 7, {'weight': 2})], [3, (4, {'size': 2})]) + assert sorted(G.nodes.data()) == nlist + assert sorted(G.edges.data()) == elist + assert G.graph == {} + + # update using only a graph + G = self.Graph() + G.graph['foo'] = 'bar' + G.add_node(2, data=4) + G.add_edge(0, 1, weight=0.5) + GG = G.copy() + H = self.Graph() + GG.update(H) + assert_graphs_equal(G, GG) + H.update(G) + assert_graphs_equal(H, G) + + # update nodes only + H = self.Graph() + H.update(nodes=[3, 4]) + assert H.nodes ^ {3, 4} == set() + assert H.size() == 0 + + # update edges only + H = self.Graph() + H.update(edges=[(3, 4)]) + assert sorted(H.edges.data()) == [(3, 4, {})] + assert H.size() == 1 + + # No inputs -> exception + with pytest.raises(sx.SnapXError): + sx.Graph().update() + +# NOTE: Not supported +#class TestEdgeSubgraph: +# """Unit tests for the :meth:`Graph.edge_subgraph` method.""" +# +# def setup_method(self): +# # Create a path graph on five nodes. +# G = sx.path_graph(5) +# # Add some node, edge, and graph attributes. +# for i in range(5): +# G.nodes[i]['name'] = 'node{}'.format(i) +# G.edges[0, 1]['name'] = 'edge01' +# G.edges[3, 4]['name'] = 'edge34' +# G.graph['name'] = 'graph' +# # Get the subgraph induced by the first and last edges. +# self.G = G +# self.H = G.edge_subgraph([(0, 1), (3, 4)]) +# +# def test_correct_nodes(self): +# """Tests that the subgraph has the correct nodes.""" +# assert [0, 1, 3, 4] == sorted(self.H.nodes()) +# +# def test_correct_edges(self): +# """Tests that the subgraph has the correct edges.""" +# assert ([(0, 1, 'edge01'), (3, 4, 'edge34')] == +# sorted(self.H.edges(data='name'))) +# +# def test_add_node(self): +# """Tests that adding a node to the original graph does not +# affect the nodes of the subgraph. +# """ +# self.G.add_node(5) +# assert [0, 1, 3, 4] == sorted(self.H.nodes()) +# +# def test_remove_node(self): +# """Tests that removing a node in the original graph does +# affect the nodes of the subgraph. +# """ +# self.G.remove_node(0) +# assert [1, 3, 4] == sorted(self.H.nodes()) +# +# def test_node_attr_dict(self): +# """Tests that the node attribute dictionary of the two graphs is +# the same object. +# """ +# for v in self.H: +# assert self.G.nodes[v] == self.H.nodes[v] +# # Making a change to G should make a change in H and vice versa. +# self.G.nodes[0]['name'] = 'foo' +# assert self.G.nodes[0] == self.H.nodes[0] +# self.H.nodes[1]['name'] = 'bar' +# assert self.G.nodes[1] == self.H.nodes[1] +# +# def test_edge_attr_dict(self): +# """Tests that the edge attribute dictionary of the two graphs is +# the same object. +# """ +# for u, v in self.H.edges(): +# assert self.G.edges[u, v] == self.H.edges[u, v] +# # Making a change to G should make a change in H and vice versa. +# self.G.edges[0, 1]['name'] = 'foo' +# assert (self.G.edges[0, 1]['name'] == +# self.H.edges[0, 1]['name']) +# self.H.edges[3, 4]['name'] = 'bar' +# assert (self.G.edges[3, 4]['name'] == +# self.H.edges[3, 4]['name']) +# +# def test_graph_attr_dict(self): +# """Tests that the graph attribute dictionary of the two graphs +# is the same object. +# """ +# assert self.G.graph is self.H.graph diff --git a/snap-python/source/snapx/snapx/classes/tests/test_reportviews.py b/snap-python/source/snapx/snapx/classes/tests/test_reportviews.py new file mode 100644 index 0000000000000000000000000000000000000000..dc652c2457a2f6cbe33e8db2b37f4a483b654982 --- /dev/null +++ b/snap-python/source/snapx/snapx/classes/tests/test_reportviews.py @@ -0,0 +1,493 @@ +import pytest + +import snapx as sx +from snapx.classes.reportviews import NodeDataView +from snapx import AttributeDict + +# Nodes +class TestNodeView: + @classmethod + def setup_class(cls): + cls.G = sx.path_graph(9) + cls.nv = cls.G.nodes # NodeView(G) + + # NOTE: Not supported + # def test_pickle(self): + # import pickle + + # nv = self.nv + # pnv = pickle.loads(pickle.dumps(nv, -1)) + # assert nv == pnv + # assert nv.__slots__ == pnv.__slots__ + + def test_str(self): + assert str(self.nv) == "[0, 1, 2, 3, 4, 5, 6, 7, 8]" + + def test_repr(self): + assert repr(self.nv) == "NodeView((0, 1, 2, 3, 4, 5, 6, 7, 8))" + + def test_contains(self): + G = self.G.copy() + nv = G.nodes + assert 7 in nv + assert 9 not in nv + # NOTE: Node removal not supported. + # G.remove_node(7) + # G.add_node(9) + # assert 7 not in nv + # assert 9 in nv + + def test_getitem(self): + G = self.G.copy() + nv = G.nodes + G.nodes[3]["foo"] = "bar" + assert nv[7] == {} + assert nv[3] == {"foo": "bar"} + + def test_iter(self): + nv = self.nv + for i, n in enumerate(nv): + assert i == n + inv = iter(nv) + assert next(inv) == 0 + assert iter(nv) != nv + assert iter(inv) == inv + inv2 = iter(nv) + next(inv2) + assert list(inv) == list(inv2) + # odd case where NodeView calls NodeDataView with data=False + nnv = nv(data=False) + for i, n in enumerate(nnv): + assert i == n + + def test_call(self): + nodes = self.nv + assert nodes is nodes() + assert nodes is not nodes(data=True) + assert nodes is not nodes(data="weight") + +class TestNodeDataView: + @classmethod + def setup_class(cls): + cls.G = sx.path_graph(9) + cls.nv = NodeDataView(cls.G) + cls.ndv = cls.G.nodes.data(True) + cls.nwv = cls.G.nodes.data("foo") + + def test_viewtype(self): + nv = self.G.nodes + ndvfalse = nv.data(False) + assert nv is ndvfalse + assert nv is not self.ndv + + # NOTE: Not supported + #def test_pickle(self): + # import pickle + + # nv = self.nv + # pnv = pickle.loads(pickle.dumps(nv, -1)) + # assert nv == pnv + # assert nv.__slots__ == pnv.__slots__ + + def test_str(self): + msg = str([(n, AttributeDict(self.G, n)) for n in range(9)]) + assert str(self.ndv) == msg + + def test_repr(self): + expected = "NodeDataView((0, 1, 2, 3, 4, 5, 6, 7, 8))" + assert repr(self.nv) == expected + expected_data = ["{}: {}".format(n, repr(AttributeDict(self.G, n))) for n in range(9)] + expected = "NodeDataView({" + ", ".join(expected_data) + "})" + assert repr(self.ndv) == expected + expected = ( + "NodeDataView({0: None, 1: None, 2: None, 3: None, 4: None, " + + "5: None, 6: None, 7: None, 8: None}, data='foo')" + ) + assert repr(self.nwv) == expected + + def test_contains(self): + G = self.G.copy() + nv = G.nodes.data() + nwv = G.nodes.data("foo") + G.nodes[3]["foo"] = "bar" + assert (7, {}) in nv + assert (3, {"foo": "bar"}) in nv + assert (3, "bar") in nwv + assert (7, None) in nwv + # default + nwv_def = G.nodes(data="foo", default="biz") + assert (7, "biz") in nwv_def + assert (3, "bar") in nwv_def + + def test_getitem(self): + G = self.G.copy() + nv = G.nodes + G.nodes[3]["foo"] = "bar" + assert nv[3] == {"foo": "bar"} + # default + nwv_def = G.nodes(data="foo", default="biz") + assert nwv_def[7], "biz" + assert nwv_def[3] == "bar" + + def test_iter(self): + G = self.G.copy() + nv = G.nodes.data() + ndv = G.nodes.data(True) + nwv = G.nodes.data("foo") + for i, (n, d) in enumerate(nv): + assert i == n + assert d == {} + inv = iter(nv) + assert next(inv) == (0, {}) + G.nodes[3]["foo"] = "bar" + # default + for n, d in nv: + if n == 3: + assert d == {"foo": "bar"} + else: + assert d == {} + # data=True + for n, d in ndv: + if n == 3: + assert d == {"foo": "bar"} + else: + assert d == {} + # data='foo' + for n, d in nwv: + if n == 3: + assert d == "bar" + else: + assert d is None + # data='foo', default=1 + for n, d in G.nodes.data("foo", default=1): + if n == 3: + assert d == "bar" + else: + assert d == 1 + +def test_nodedataview_unhashable(): + G = sx.path_graph(9) + G.nodes[3]["foo"] = "bar" + nvs = [G.nodes.data()] + nvs.append(G.nodes.data(True)) + H = G.copy() + H.nodes[4]["foo"] = {1, 2, 3} + nvs.append(H.nodes.data(True)) + # raise unhashable + for nv in nvs: + pytest.raises(TypeError, set, nv) + pytest.raises(TypeError, eval, "nv | nv", locals()) + # no raise... hashable + Gn = G.nodes.data(False) + set(Gn) + Gn | Gn + Gn = G.nodes.data("foo") + set(Gn) + Gn | Gn + + +class TestNodeViewSetOps: + @classmethod + def setup_class(cls): + cls.G = sx.path_graph(9) + cls.G.nodes[3]["foo"] = "bar" + cls.nv = cls.G.nodes + + def n_its(self, nodes): + return {node for node in nodes} + + def test_len(self): + G = self.G.copy() + nv = G.nodes + assert len(nv) == 9 + # NOTE: Remove node not supported + # G.remove_node(7) + # assert len(nv) == 8 + G.add_node(9) + assert len(nv) == 10 + + def test_and(self): + # print("G & H nodes:", gnv & hnv) + nv = self.nv + some_nodes = self.n_its(range(5, 12)) + assert nv & some_nodes == self.n_its(range(5, 9)) + assert some_nodes & nv == self.n_its(range(5, 9)) + + def test_or(self): + # print("G | H nodes:", gnv | hnv) + nv = self.nv + some_nodes = self.n_its(range(5, 12)) + assert nv | some_nodes == self.n_its(range(12)) + assert some_nodes | nv == self.n_its(range(12)) + + def test_xor(self): + # print("G ^ H nodes:", gnv ^ hnv) + nv = self.nv + some_nodes = self.n_its(range(5, 12)) + nodes = {0, 1, 2, 3, 4, 9, 10, 11} + assert nv ^ some_nodes == self.n_its(nodes) + assert some_nodes ^ nv == self.n_its(nodes) + + def test_sub(self): + # print("G - H nodes:", gnv - hnv) + nv = self.nv + some_nodes = self.n_its(range(5, 12)) + assert nv - some_nodes == self.n_its(range(5)) + assert some_nodes - nv == self.n_its(range(9, 12)) + + +class TestNodeDataViewSetOps(TestNodeViewSetOps): + @classmethod + def setup_class(cls): + cls.G = sx.path_graph(9) + cls.G.nodes[3]["foo"] = "bar" + cls.nv = cls.G.nodes.data("foo") + + def n_its(self, nodes): + return {(node, "bar" if node == 3 else None) for node in nodes} + + +class TestNodeDataViewDefaultSetOps(TestNodeDataViewSetOps): + @classmethod + def setup_class(cls): + cls.G = sx.path_graph(9) + cls.G.nodes[3]["foo"] = "bar" + cls.nv = cls.G.nodes.data("foo", default=1) + + def n_its(self, nodes): + return {(node, "bar" if node == 3 else 1) for node in nodes} + +# Edges Data View +class TestEdgeDataView: + @classmethod + def setup_class(cls): + cls.G = sx.path_graph(9) + cls.eview = sx.reportviews.EdgeView + + # NOTE: Not supported + # def test_pickle(self): + # import pickle + + # ev = self.eview(self.G)(data=True) + # pev = pickle.loads(pickle.dumps(ev, -1)) + # assert list(ev) == list(pev) + # assert ev.__slots__ == pev.__slots__ + + def modify_edge(self, G, e, **kwds): + G.edges[e].update(kwds) + + def test_str(self): + ev = self.eview(self.G)(data=True) + rep = str([(n, n + 1, AttributeDict(self.G, (n, n+1))) for n in range(8)]) + assert str(ev) == rep + + def test_repr(self): + ev = self.eview(self.G)(data=True) + ad = "AttributeDict({})" + rep = ( + "EdgeDataView([(0, 1, {}), (1, 2, {}), ".format(ad, ad) + + "(2, 3, {}), (3, 4, {}), ".format(ad, ad) + + "(4, 5, {}), (5, 6, {}), ".format(ad, ad) + + "(6, 7, {}), (7, 8, {})])".format(ad, ad) + ) + assert repr(ev) == rep + + def test_iterdata(self): + G = self.G.copy() + evr = self.eview(G) + ev = evr(data=True) + ev_def = evr(data="foo", default=1) + + for u, v, d in ev: + pass + assert d == {} + + for u, v, wt in ev_def: + pass + assert wt == 1 + + self.modify_edge(G, (2, 3), foo="bar") + for e in ev: + assert len(e) == 3 + if set(e[:2]) == {2, 3}: + assert e[2] == {"foo": "bar"} + checked = True + else: + assert e[2] == {} + assert checked + + for e in ev_def: + assert len(e) == 3 + if set(e[:2]) == {2, 3}: + assert e[2] == "bar" + checked_wt = True + else: + assert e[2] == 1 + assert checked_wt + + def test_iter(self): + evr = self.eview(self.G) + ev = evr() + for u, v in ev: + pass + iev = iter(ev) + assert next(iev) == (0, 1) + assert iter(ev) != ev + assert iter(iev) == iev + + def test_contains(self): + evr = self.eview(self.G) + ev = evr() + if self.G.is_directed(): + assert (1, 2) in ev and (2, 1) not in ev + else: + assert (1, 2) in ev and (2, 1) in ev + assert not (1, 4) in ev + assert not (1, 90) in ev + assert not (90, 1) in ev + + def test_len(self): + evr = self.eview(self.G) + ev = evr(data="foo") + assert len(ev) == 8 + assert len(evr(1)) == 2 + assert len(evr([1, 2, 3])) == 4 + + assert len(self.G.edges(1)) == 2 + assert len(self.G.edges()) == 8 + assert len(self.G.edges) == 8 + + H = self.G.copy() + H.add_edge(1, 1) + assert len(H.edges(1)) == 3 + assert len(H.edges()) == 9 + assert len(H.edges) == 9 + +# Edge Views +class TestEdgeView: + @classmethod + def setup_class(cls): + cls.G = sx.path_graph(9) + cls.eview = sx.reportviews.EdgeView + + # NOTE: Not supported + # def test_pickle(self): + # import pickle + + # ev = self.eview(self.G) + # pev = pickle.loads(pickle.dumps(ev, -1)) + # assert ev == pev + # assert ev.__slots__ == pev.__slots__ + + def modify_edge(self, G, e, **kwds): + G._adj[e[0]][e[1]].update(kwds) + + def test_str(self): + ev = self.eview(self.G) + rep = str([(n, n + 1) for n in range(8)]) + assert str(ev) == rep + + def test_repr(self): + ev = self.eview(self.G) + rep = ( + "EdgeView([(0, 1), (1, 2), (2, 3), (3, 4), " + + "(4, 5), (5, 6), (6, 7), (7, 8)])" + ) + assert repr(ev) == rep + + def test_call(self): + ev = self.eview(self.G) + assert id(ev) == id(ev()) + assert id(ev) == id(ev(data=False)) + assert id(ev) != id(ev(data=True)) + assert id(ev) != id(ev(nbunch=1)) + + def test_data(self): + ev = self.eview(self.G) + assert id(ev) != id(ev.data()) + assert id(ev) == id(ev.data(data=False)) + assert id(ev) != id(ev.data(data=True)) + assert id(ev) != id(ev.data(nbunch=1)) + + def test_iter(self): + ev = self.eview(self.G) + for u, v in ev: + pass + iev = iter(ev) + assert next(iev) == (0, 1) + assert iter(ev) != ev + assert iter(iev) == iev + + def test_contains(self): + ev = self.eview(self.G) + edv = ev() + if self.G.is_directed(): + assert (1, 2) in ev and (2, 1) not in ev + assert (1, 2) in edv and (2, 1) not in edv + else: + assert (1, 2) in ev and (2, 1) in ev + assert (1, 2) in edv and (2, 1) in edv + assert not (1, 4) in ev + assert not (1, 4) in edv + # edge not in graph + assert not (1, 90) in ev + assert not (90, 1) in ev + assert not (1, 90) in edv + assert not (90, 1) in edv + + def test_len(self): + ev = self.eview(self.G) + num_ed = 9 if self.G.is_multigraph() else 8 + assert len(ev) == num_ed + + H = self.G.copy() + H.add_edge(1, 1) + assert len(H.edges(1)) == 3 + H.is_multigraph() - H.is_directed() + assert len(H.edges()) == num_ed + 1 + assert len(H.edges) == num_ed + 1 + + def test_and(self): + # print("G & H edges:", gnv & hnv) + ev = self.eview(self.G) + some_edges = {(0, 1), (1, 0), (0, 2)} + if self.G.is_directed(): + assert some_edges & ev, {(0, 1)} + assert ev & some_edges, {(0, 1)} + else: + assert ev & some_edges == {(0, 1), (1, 0)} + assert some_edges & ev == {(0, 1), (1, 0)} + return + + def test_or(self): + # print("G | H edges:", gnv | hnv) + ev = self.eview(self.G) + some_edges = {(0, 1), (1, 0), (0, 2)} + result1 = {(n, n + 1) for n in range(8)} + result1.update(some_edges) + result2 = {(n + 1, n) for n in range(8)} + result2.update(some_edges) + assert (ev | some_edges) in (result1, result2) + assert (some_edges | ev) in (result1, result2) + + def test_xor(self): + # print("G ^ H edges:", gnv ^ hnv) + ev = self.eview(self.G) + some_edges = {(0, 1), (1, 0), (0, 2)} + if self.G.is_directed(): + result = {(n, n + 1) for n in range(1, 8)} + result.update({(1, 0), (0, 2)}) + assert ev ^ some_edges == result + else: + result = {(n, n + 1) for n in range(1, 8)} + result.update({(0, 2)}) + assert ev ^ some_edges == result + return + + def test_sub(self): + # print("G - H edges:", gnv - hnv) + ev = self.eview(self.G) + some_edges = {(0, 1), (1, 0), (0, 2)} + result = {(n, n + 1) for n in range(8)} + result.remove((0, 1)) + assert ev - some_edges, result + diff --git a/snap-python/source/snapx/snapx/convert.py b/snap-python/source/snapx/snapx/convert.py new file mode 100644 index 0000000000000000000000000000000000000000..364b092314e64cf803a580c60ae1d61698f0b601 --- /dev/null +++ b/snap-python/source/snapx/snapx/convert.py @@ -0,0 +1,216 @@ +import warnings +import snapx as sx + +def to_snapx_graph(data, create_using=None, multigraph_input=False): + """PORTED FROM NETWORKX + Make a SnapX graph from a known data structure. + The preferred way to call this is automatically + from the class constructor + >>> d = {0: {1: {'weight':1}}} # dict-of-dicts single edge (0,1) + >>> G = nx.Graph(d) + instead of the equivalent + >>> G = nx.from_dict_of_dicts(d) + Parameters + ---------- + data : object to be converted + Current known types are: + any NetworkX graph + dict-of-dicts + dict-of-lists + container (ie set, list, tuple, iterator) of edges + Pandas DataFrame (row per edge) + numpy matrix + numpy ndarray + scipy sparse matrix + pygraphviz agraph + create_using : NetworkX graph constructor, optional (default=nx.Graph) + Graph type to create. If graph instance, then cleared before populated. + multigraph_input : bool (default False) + If True and data is a dict_of_dicts, + try to create a multigraph assuming dict_of_dict_of_lists. + If data and create_using are both multigraphs then create + a multigraph from a multigraph. + """ + # SX graph + if hasattr(data, "adj"): + try: + result = from_dict_of_dicts( + data.adj, + create_using=create_using, + multigraph_input=data.is_multigraph(), + ) + if hasattr(data, "graph"): # data.graph should be dict-like + result.graph.update(data.graph) + if hasattr(data, "nodes"): # data.nodes should be dict-like + # result.add_node_from(data.nodes.items()) possible but + # for custom node_attr_dict_factory which may be hashable + # will be unexpected behavior + for n, dd in data.nodes.items(): + result._node[n].update(dd) + return result + except: + raise sx.SnapXError("Input is not a correct SnapX graph.") + + # pygraphviz agraph + if hasattr(data, "is_strict"): + raise NotImplementedError("TODO") + #try: + # return nx.nx_agraph.from_agraph(data, create_using=create_using) + #except: + # raise nx.NetworkXError("Input is not a correct pygraphviz graph.") + + # dict of dicts/lists + if isinstance(data, dict): + raise NotImplementedError("TODO") + #try: + # return from_dict_of_dicts( + # data, create_using=create_using, multigraph_input=multigraph_input + # ) + #except: + # try: + # return from_dict_of_lists(data, create_using=create_using) + # except: + # raise TypeError("Input is not known type.") + + # list or generator of edges + + if isinstance(data, (list, tuple, set)) or any( + hasattr(data, attr) for attr in ["_adjdict", "next", "__next__"] + ): + raise NotImplementedError("TODO") + #try: + # return from_edgelist(data, create_using=create_using) + #except: + # raise nx.NetworkXError("Input is not a valid edge list") + + # Pandas DataFrame + try: + import pandas as pd + + if isinstance(data, pd.DataFrame): + raise NotImplementedError("TODO") + #if data.shape[0] == data.shape[1]: + # try: + # return nx.from_pandas_adjacency(data, create_using=create_using) + # except: + # msg = "Input is not a correct Pandas DataFrame adjacency matrix." + # raise nx.NetworkXError(msg) + #else: + # try: + # return nx.from_pandas_edgelist( + # data, edge_attr=True, create_using=create_using + # ) + # except: + # msg = "Input is not a correct Pandas DataFrame edge-list." + # raise nx.NetworkXError(msg) + except ImportError: + msg = "pandas not found, skipping conversion test." + warnings.warn(msg, ImportWarning) + + # numpy matrix or ndarray + try: + import numpy + + if isinstance(data, (numpy.matrix, numpy.ndarray)): + raise NotImplementedError("TODO") + #try: + # return nx.from_numpy_matrix(data, create_using=create_using) + #except: + # raise nx.NetworkXError("Input is not a correct numpy matrix or array.") + except ImportError: + warnings.warn("numpy not found, skipping conversion test.", ImportWarning) + + # scipy sparse matrix - any format + try: + import scipy + + if hasattr(data, "format"): + raise NotImplementedError("TODO") + #try: + # return nx.from_scipy_sparse_matrix(data, create_using=create_using) + #except: + # raise nx.NetworkXError( + # "Input is not a correct scipy sparse matrix type." + # ) + except ImportError: + warnings.warn("scipy not found, skipping conversion test.", ImportWarning) + + raise sx.SnapXError("Input is not a known data type for conversion.") + +def from_dict_of_dicts(d, create_using=None, multigraph_input=False): + """PORTED FROM NETWORKX + Returns a graph from a dictionary of dictionaries. + Parameters + ---------- + d : dictionary of dictionaries + A dictionary of dictionaries adjacency representation. + create_using : NetworkX graph constructor, optional (default=nx.Graph) + Graph type to create. If graph instance, then cleared before populated. + multigraph_input : bool (default False) + When True, the values of the inner dict are assumed + to be containers of edge data for multiple edges. + Otherwise this routine assumes the edge data are singletons. + Examples + -------- + >>> dod = {0: {1: {'weight': 1}}} # single edge (0,1) + >>> G = nx.from_dict_of_dicts(dod) + or + >>> G = nx.Graph(dod) # use Graph constructor + """ + G = sx.empty_graph(0, create_using) + G.add_nodes_from(d) + # is dict a MultiGraph or MultiDiGraph? + if multigraph_input: + # make a copy of the list of edge data (but not the edge data) + if G.is_directed(): + if G.is_multigraph(): + G.add_edges_from( + (u, v, key, data) + for u, nbrs in d.items() + for v, datadict in nbrs.items() + for key, data in datadict.items() + ) + else: + G.add_edges_from( + (u, v, data) + for u, nbrs in d.items() + for v, datadict in nbrs.items() + for key, data in datadict.items() + ) + else: # Undirected + if G.is_multigraph(): + seen = set() # don't add both directions of undirected graph + for u, nbrs in d.items(): + for v, datadict in nbrs.items(): + if (u, v) not in seen: + G.add_edges_from( + (u, v, key, data) for key, data in datadict.items() + ) + seen.add((v, u)) + else: + seen = set() # don't add both directions of undirected graph + for u, nbrs in d.items(): + for v, datadict in nbrs.items(): + if (u, v) not in seen: + G.add_edges_from( + (u, v, data) for key, data in datadict.items() + ) + seen.add((v, u)) + + else: # not a multigraph to multigraph transfer + if G.is_multigraph() and not G.is_directed(): + # d can have both representations u-v, v-u in dict. Only add one. + # We don't need this check for digraphs since we add both directions, + # or for Graph() since it is done implicitly (parallel edges not allowed) + seen = set() + for u, nbrs in d.items(): + for v, data in nbrs.items(): + if (u, v) not in seen: + G.add_edge(u, v, key=0) + G[u][v][0].update(data) + seen.add((v, u)) + else: + G.add_edges_from( + ((u, v, data) for u, nbrs in d.items() for v, data in nbrs.items()) + ) + return G diff --git a/snap-python/source/snapx/snapx/exception.py b/snap-python/source/snapx/snapx/exception.py new file mode 100644 index 0000000000000000000000000000000000000000..44d9ce50733afad2409ed3327205c5b2c7c65888 --- /dev/null +++ b/snap-python/source/snapx/snapx/exception.py @@ -0,0 +1,46 @@ +"""PORTED FROM NETWORKX""" + +__all__ = [ + "SnapXException", + "SnapXError", + "SnapXAlgorithmError", + "SnapXUnfeasible", + "SnapXNoPath", + "NodeNotFound", + "SnapXTypeError", + "SnapXKeyError", +] + + +class SnapXException(Exception): + """Base class for exceptions in SnapX.""" + + +class SnapXError(SnapXException): + """Exception for a serious error in SnapX""" + + +class SnapXAlgorithmError(SnapXException): + """Exception for unexpected termination of algorithms.""" + + +class SnapXUnfeasible(SnapXAlgorithmError): + """Exception raised by algorithms trying to solve a problem + instance that has no feasible solution.""" + + +class SnapXNoPath(SnapXUnfeasible): + """Exception for algorithms that should return a path when running + on graphs where such a path does not exist.""" + + +class NodeNotFound(SnapXException): + """Exception raised if requested node is not present in the graph""" + + +class SnapXTypeError(TypeError): + """Exception for SNAP specific type errors""" + + +class SnapXKeyError(KeyError): + """Exception for SNAP specific key errors""" diff --git a/snap-python/source/snapx/snapx/generators/__init__.py b/snap-python/source/snapx/snapx/generators/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8e6ba0945c9ebd62a1e49cd396dd864dd72bc77f --- /dev/null +++ b/snap-python/source/snapx/snapx/generators/__init__.py @@ -0,0 +1,2 @@ +from snapx.generators.classic import * +from snapx.generators.ego import * diff --git a/snap-python/source/snapx/snapx/generators/classic.py b/snap-python/source/snapx/snapx/generators/classic.py new file mode 100644 index 0000000000000000000000000000000000000000..b40caa58f7027dd022937a8452d8450429971b65 --- /dev/null +++ b/snap-python/source/snapx/snapx/generators/classic.py @@ -0,0 +1,105 @@ +"""Classic graph generators from NetworkX.""" + +import snapx as sx + +from snapx.utils import nodes_or_number +from snapx.utils import pairwise + +@nodes_or_number(0) +def empty_graph(n=0, create_using=None, default=sx.Graph): + """PORTED FROM NETWORKX + Returns the empty graph with n nodes and zero edges. + Parameters + ---------- + n : int or iterable container of nodes (default = 0) + If n is an integer, nodes are from `range(n)`. + If n is a container of nodes, those nodes appear in the graph. + create_using : Graph Instance, Constructor or None + Indicator of type of graph to return. + If a Graph-type instance, then clear and use it. + If None, use the `default` constructor. + If a constructor, call it to create an empty graph. + default : Graph constructor (optional, default = nx.Graph) + The constructor to use if create_using is None. + If None, then nx.Graph is used. + This is used when passing an unknown `create_using` value + through your home-grown function to `empty_graph` and + you want a default constructor other than nx.Graph. + Examples + -------- + >>> G = nx.empty_graph(10) + >>> G.number_of_nodes() + 10 + >>> G.number_of_edges() + 0 + >>> G = nx.empty_graph("ABC") + >>> G.number_of_nodes() + 3 + >>> sorted(G) + ['A', 'B', 'C'] + Notes + ----- + The variable create_using should be a Graph Constructor or a + "graph"-like object. Constructors, e.g. `nx.Graph` or `nx.MultiGraph` + will be used to create the returned graph. "graph"-like objects + will be cleared (nodes and edges will be removed) and refitted as + an empty "graph" with nodes specified in n. This capability + is useful for specifying the class-nature of the resulting empty + "graph" (i.e. Graph, DiGraph, MyWeirdGraphClass, etc.). + The variable create_using has three main uses: + Firstly, the variable create_using can be used to create an + empty digraph, multigraph, etc. For example, + >>> n = 10 + >>> G = nx.empty_graph(n, create_using=nx.DiGraph) + will create an empty digraph on n nodes. + Secondly, one can pass an existing graph (digraph, multigraph, + etc.) via create_using. For example, if G is an existing graph + (resp. digraph, multigraph, etc.), then empty_graph(n, create_using=G) + will empty G (i.e. delete all nodes and edges using G.clear()) + and then add n nodes and zero edges, and return the modified graph. + Thirdly, when constructing your home-grown graph creation function + you can use empty_graph to construct the graph by passing a user + defined create_using to empty_graph. In this case, if you want the + default constructor to be other than nx.Graph, specify `default`. + >>> def mygraph(n, create_using=None): + ... G = nx.empty_graph(n, create_using, nx.MultiGraph) + ... G.add_edges_from([(0, 1), (0, 1)]) + ... return G + >>> G = mygraph(3) + >>> G.is_multigraph() + True + >>> G = mygraph(3, nx.Graph) + >>> G.is_multigraph() + False + See also create_empty_copy(G). + """ + if create_using is None: + G = default() + elif hasattr(create_using, 'adj'): + # create_using is a SnapX style Graph + create_using.clear() + G = create_using + else: + # try create_using as constructor + G = create_using() + + n_name, nodes = n + G.add_nodes_from(nodes) + return G + +@nodes_or_number(0) +def path_graph(n, create_using=None): + """PORTED FROM NETWORKX + Returns the Path graph `P_n` of linearly connected nodes. + Parameters + ---------- + n : int or iterable + If an integer, node labels are 0 to n with center 0. + If an iterable of nodes, the center is the first. + create_using : NetworkX graph constructor, optional (default=nx.Graph) + Graph type to create. If graph instance, then cleared before populated. + """ + n_name, nodes = n + G = empty_graph(nodes, create_using) + G.add_edges_from(pairwise(nodes)) + return G diff --git a/snap-python/source/snapx/snapx/generators/ego.py b/snap-python/source/snapx/snapx/generators/ego.py new file mode 100644 index 0000000000000000000000000000000000000000..b6ece647ff22f0788a873a633f3a32375027c668 --- /dev/null +++ b/snap-python/source/snapx/snapx/generators/ego.py @@ -0,0 +1,69 @@ +""" +Ego graph. +""" +__all__ = ["ego_graph"] + +import snapx as sx +import snap + + +def ego_graph(G, n, radius=1, sample=-1.0, traversal='in', copy_attr=True): + """PORTED FROM NETWORKX + Returns induced subgraph of neighbors centered at node n within + a given radius. + + Parameters + ---------- + G : graph + A NetworkX Graph or DiGraph + + n : node + A single node + + radius : number, optional + Include all neighbors of distance<=radius from n. + + center : bool, optional - NOT ADDED + If False, do not include center node in graph + + undirected : bool, optional - NOT ADDED + If True use both in- and out-neighbors of directed graphs. + + distance : key, optional - NOT ADDED + Use specified edge data key as distance. For example, setting + distance='weight' will use the edge weight to measure the + distance from the node n. + + sample : int/float, optional + Number of nodes to sample as neighbors. Either positive int or float + between 0.0 and 1.0. + + traversal : str, optional, either 'in', 'out', 'all' + Get in, out or both ego neighborhoods + + copy_attr : bool, optional + Copy node and edge attributes to ego graph + """ + if traversal == 'in': + if copy_attr: + if sample != -1.0: + if type(sample) is int: + if 0 > sample: + raise RuntimeError + else: + snapGraph = snap.GetInEgonetSubAttr(G._graph, n, radius, sample, -1.0) + return sx.Graph(incoming_graph_data=snapGraph) + else: + if not 0.0 <= sample <= 1.0: + raise RuntimeError + else: + snapGraph = snap.GetInEgonetSubAttr(G._graph, n, radius, 0, sample) + return sx.Graph(incoming_graph_data=snapGraph) + else: + snapGraph = snap.GetInEgonetAttr(G._graph, n, radius) + return sx.Graph(incoming_graph_data=snapGraph) + else: + raise NotImplementedError + else: + raise NotImplementedError + diff --git a/snap-python/source/snapx/snapx/relabel.py b/snap-python/source/snapx/snapx/relabel.py new file mode 100644 index 0000000000000000000000000000000000000000..e7ff890b0fd58979731e982e6f6395bcf3d32cd3 --- /dev/null +++ b/snap-python/source/snapx/snapx/relabel.py @@ -0,0 +1,232 @@ +import snapx as sx +import snap + +__all__ = ["convert_node_labels_to_integers", "relabel_nodes"] + + +def relabel_nodes(G, mapping, copy=True): + """PORTED FROM NETWORKX + Relabel the nodes of the graph G. + + Parameters + ---------- + G : graph + A SnapX graph + + mapping : dictionary + A dictionary with the old labels as keys and new labels as values. + A partial mapping is allowed. + + copy : bool (optional, default=True) + If True return a copy, or if False relabel the nodes in place. + + Examples + -------- + To create a new graph with nodes relabeled according to a given + dictionary: + + >>> G = sx.path_graph(3) + >>> sorted(G) + [0, 1, 2] + >>> mapping = {0: 'a', 1: 'b', 2: 'c'} + >>> H = sx.relabel_nodes(G, mapping) + >>> sorted(H) + ['a', 'b', 'c'] + + Nodes can be relabeled with any hashable object, including numbers + and strings: + + >>> import string + >>> G = sx.path_graph(26) # nodes are integers 0 through 25 + >>> sorted(G)[:3] + [0, 1, 2] + >>> mapping = dict(zip(G, string.ascii_lowercase)) + >>> G = sx.relabel_nodes(G, mapping) # nodes are characters a through z + >>> sorted(G)[:3] + ['a', 'b', 'c'] + >>> mapping = dict(zip(G, range(1, 27))) + >>> G = sx.relabel_nodes(G, mapping) # nodes are integers 1 through 26 + >>> sorted(G)[:3] + [1, 2, 3] + + To perform a partial in-place relabeling, provide a dictionary + mapping only a subset of the nodes, and set the `copy` keyword + argument to False: + + >>> G = sx.path_graph(3) # nodes 0-1-2 + >>> mapping = {0: 'a', 1: 'b'} # 0->'a' and 1->'b' + >>> G = sx.relabel_nodes(G, mapping, copy=False) + >>> sorted(G, key=str) + [2, 'a', 'b'] + + A mapping can also be given as a function: + + >>> G = sx.path_graph(3) + >>> H = sx.relabel_nodes(G, lambda x: x ** 2) + >>> list(H) + [0, 1, 4] + + Notes + ----- + Only the nodes specified in the mapping will be relabeled. + + The keyword setting copy=False modifies the graph in place. + Relabel_nodes avoids naming collisions by building a + directed graph from ``mapping`` which specifies the order of + relabelings. Naming collisions, such as a->b, b->c, are ordered + such that "b" gets renamed to "c" before "a" gets renamed "b". + In cases of circular mappings (e.g. a->b, b->a), modifying the + graph is not possible in-place and an exception is raised. + In that case, use copy=True. + + See Also + -------- + convert_node_labels_to_integers + """ + # you can pass a function f(old_label)->new_label + # but we'll just make a dictionary here regardless + if not hasattr(mapping, "__getitem__"): + m = {n: mapping(n) for n in G} + else: + m = mapping + if copy: + return _relabel_copy(G, m) + else: + return _relabel_inplace(G, m) + + +def _relabel_inplace(G, mapping): + old_labels = set(mapping.keys()) + new_labels = set(mapping.values()) + if len(old_labels & new_labels) > 0: + # labels sets overlap + # can we topological sort and still do the relabeling? + D = sx.DiGraph(list(mapping.items())) + D.remove_edges_from(sx.selfloop_edges(D)) + try: + nodes = reversed(list(sx.topological_sort(D))) + except sx.NetworkXUnfeasible as e: + raise sx.NetworkXUnfeasible( + "The node label sets are overlapping and no ordering can " + "resolve the mapping. Use copy=True." + ) from e + else: + # non-overlapping label sets + nodes = old_labels + + multigraph = G.is_multigraph() + directed = G.is_directed() + + for old in nodes: + try: + new = mapping[old] + except KeyError: + continue + if new == old: + continue + try: + G.add_node(new, **G.nodes[old]) + except KeyError as e: + raise KeyError("Node {} is not in the graph".format(old)) from e + if multigraph: + new_edges = [ + (new, new if old == target else target, key, data) + for (_, target, key, data) in G.edges(old, data=True, keys=True) + ] + if directed: + new_edges += [ + (new if old == source else source, new, key, data) + for (source, _, key, data) in G.in_edges(old, data=True, keys=True) + ] + else: + new_edges = [ + (new, new if old == target else target, data) + for (_, target, data) in G.edges(old, data=True) + ] + if directed: + new_edges += [ + (new if old == source else source, new, data) + for (source, _, data) in G.in_edges(old, data=True) + ] + G.remove_node(old) + G.add_edges_from(new_edges) + return G + + +def _relabel_copy(G, mapping): + H = G.__class__() + H.add_nodes_from((mapping.get(n, n), d) for n, d in G.nodes(data=True)) + if G.is_multigraph(): + H.add_edges_from( + (mapping.get(n1, n1), mapping.get(n2, n2), k, d.copy()) + for (n1, n2, k, d) in G.edges(keys=True, data=True) + ) + else: + H.add_edges_from( + (mapping.get(n1, n1), mapping.get(n2, n2), d) + for (n1, n2, d) in G.edges(data=True) + ) + H.graph.update(G.graph) + return H + + +def convert_node_labels_to_integers( + G, first_label=0, ordering="default", label_attribute=None +): + """PORTED FROM NETWORKX + Returns a copy of the graph G with the nodes relabeled using + consecutive integers. + + Parameters + ---------- + G : graph + A SnapX graph + + first_label : int, optional (default=0) + An integer specifying the starting offset in numbering nodes. + The new integer labels are numbered first_label, ..., n-1+first_label. + + ordering : string + "default" : inherit node ordering from G.nodes() + "sorted" : inherit node ordering from sorted(G.nodes()) + "increasing degree" : nodes are sorted by increasing degree + "decreasing degree" : nodes are sorted by decreasing degree + + label_attribute : string, optional (default=None) + Name of node attribute to store old label. If None no attribute + is created. + + Notes + ----- + Node and edge attribute data are copied to the new (relabeled) graph. + + There is no guarantee that the relabeling of nodes to integers will + give the same two integers for two (even identical graphs). + Use the `ordering` argument to try to preserve the order. + + See Also + -------- + relabel_nodes + """ + N = G.number_of_nodes() + first_label + if ordering == "default": + mapping = dict(zip(G.nodes(), range(first_label, N))) + elif ordering == "sorted": + nlist = sorted(G.nodes()) + mapping = dict(zip(nlist, range(first_label, N))) + elif ordering == "increasing degree": + dv_pairs = [(d, n) for (n, d) in G.degree()] + dv_pairs.sort() # in-place sort from lowest to highest degree + mapping = dict(zip([n for d, n in dv_pairs], range(first_label, N))) + elif ordering == "decreasing degree": + dv_pairs = [(d, n) for (n, d) in G.degree()] + dv_pairs.sort() # in-place sort from lowest to highest degree + dv_pairs.reverse() + mapping = dict(zip([n for d, n in dv_pairs], range(first_label, N))) + else: + raise nx.NetworkXError("Unknown node ordering: {}".format(ordering)) + H = relabel_nodes(G, mapping) + # create node attribute with the old label + if label_attribute is not None: + nx.set_node_attributes(H, {v: k for k, v in mapping.items()}, label_attribute) + return H diff --git a/snap-python/source/snapx/snapx/testing/__init__.py b/snap-python/source/snapx/snapx/testing/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a72373469241472134137fd78df416f97ad51914 --- /dev/null +++ b/snap-python/source/snapx/snapx/testing/__init__.py @@ -0,0 +1,2 @@ +from snapx.testing.utils import * + diff --git a/snap-python/source/snapx/snapx/testing/utils.py b/snap-python/source/snapx/snapx/testing/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..cf64c177bed05bd1a480c9a179158811423dd8ae --- /dev/null +++ b/snap-python/source/snapx/snapx/testing/utils.py @@ -0,0 +1,62 @@ +"""PORTED FROM NETWORKX""" + +__all__ = ['assert_nodes_equal', 'assert_edges_equal', 'assert_graphs_equal', + 'almost_equal'] + + +def almost_equal(x, y, places=7): + return round(abs(x - y), places) == 0 + + +def assert_nodes_equal(nodes1, nodes2): + # Assumes iterables of nodes, or (node,datadict) tuples + nlist1 = list(nodes1) + nlist2 = list(nodes2) + try: + d1 = dict(nlist1) + d2 = dict(nlist2) + except (ValueError, TypeError): + d1 = dict.fromkeys(nlist1) + d2 = dict.fromkeys(nlist2) + assert d1 == d2 + + +def assert_edges_equal(edges1, edges2): + # Assumes iterables with u,v nodes as + # edge tuples (u,v), or + # edge tuples with data dicts (u,v,d), or + # edge tuples with keys and data dicts (u,v,k, d) + from collections import defaultdict + d1 = defaultdict(dict) + d2 = defaultdict(dict) + c1 = 0 + for c1, e in enumerate(edges1): + u, v = e[0], e[1] + data = [e[2:]] + if v in d1[u]: + data = d1[u][v] + data + d1[u][v] = data + d1[v][u] = data + c2 = 0 + for c2, e in enumerate(edges2): + u, v = e[0], e[1] + data = [e[2:]] + if v in d2[u]: + data = d2[u][v] + data + d2[u][v] = data + d2[v][u] = data + assert c1 == c2 + # can check one direction because lengths are the same. + for n, nbrdict in d1.items(): + for nbr, datalist in nbrdict.items(): + assert n in d2 + assert nbr in d2[n] + d2datalist = d2[n][nbr] + for data in datalist: + assert datalist.count(data) == d2datalist.count(data) + + +def assert_graphs_equal(graph1, graph2): + assert graph1.adj == graph2.adj + assert graph1.nodes == graph2.nodes + assert graph1.graph == graph2.graph diff --git a/snap-python/source/snapx/snapx/utils/__init__.py b/snap-python/source/snapx/snapx/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e83c838d4ead350ebfa5d58f858cfcf11a03a30a --- /dev/null +++ b/snap-python/source/snapx/snapx/utils/__init__.py @@ -0,0 +1,2 @@ +from snapx.utils.misc import * +from snapx.utils.decorators import * diff --git a/snap-python/source/snapx/snapx/utils/decorator.py b/snap-python/source/snapx/snapx/utils/decorator.py new file mode 100644 index 0000000000000000000000000000000000000000..b1f8b567e95bd84e49bd6d257f0fe3dc34677394 --- /dev/null +++ b/snap-python/source/snapx/snapx/utils/decorator.py @@ -0,0 +1,454 @@ +# ######################### LICENSE ############################ # + +# Copyright (c) 2005-2018, Michele Simionato +# All rights reserved. + +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: + +# Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# Redistributions in bytecode form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. + +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +# DAMAGE. + +""" +Decorator module, see http://pypi.python.org/pypi/decorator +for the documentation. +""" +from __future__ import print_function + +import re +import sys +import inspect +import operator +import itertools +import collections + +__version__ = '4.4.2' + +if sys.version_info >= (3,): + from inspect import getfullargspec + + def get_init(cls): + return cls.__init__ +else: + FullArgSpec = collections.namedtuple( + 'FullArgSpec', 'args varargs varkw defaults ' + 'kwonlyargs kwonlydefaults annotations') + + def getfullargspec(f): + "A quick and dirty replacement for getfullargspec for Python 2.X" + return FullArgSpec._make(inspect.getargspec(f) + ([], None, {})) + + def get_init(cls): + return cls.__init__.__func__ + +try: + iscoroutinefunction = inspect.iscoroutinefunction +except AttributeError: + # let's assume there are no coroutine functions in old Python + def iscoroutinefunction(f): + return False +try: + from inspect import isgeneratorfunction +except ImportError: + # assume no generator function in old Python versions + def isgeneratorfunction(caller): + return False + + +DEF = re.compile(r'\s*def\s*([_\w][_\w\d]*)\s*\(') + + +# basic functionality +class FunctionMaker(object): + """ + An object with the ability to create functions with a given signature. + It has attributes name, doc, module, signature, defaults, dict and + methods update and make. + """ + + # Atomic get-and-increment provided by the GIL + _compile_count = itertools.count() + + # make pylint happy + args = varargs = varkw = defaults = kwonlyargs = kwonlydefaults = () + + def __init__(self, func=None, name=None, signature=None, + defaults=None, doc=None, module=None, funcdict=None): + self.shortsignature = signature + if func: + # func can be a class or a callable, but not an instance method + self.name = func.__name__ + if self.name == '': # small hack for lambda functions + self.name = '_lambda_' + self.doc = func.__doc__ + self.module = func.__module__ + if inspect.isfunction(func): + argspec = getfullargspec(func) + self.annotations = getattr(func, '__annotations__', {}) + for a in ('args', 'varargs', 'varkw', 'defaults', 'kwonlyargs', + 'kwonlydefaults'): + setattr(self, a, getattr(argspec, a)) + for i, arg in enumerate(self.args): + setattr(self, 'arg%d' % i, arg) + allargs = list(self.args) + allshortargs = list(self.args) + if self.varargs: + allargs.append('*' + self.varargs) + allshortargs.append('*' + self.varargs) + elif self.kwonlyargs: + allargs.append('*') # single star syntax + for a in self.kwonlyargs: + allargs.append('%s=None' % a) + allshortargs.append('%s=%s' % (a, a)) + if self.varkw: + allargs.append('**' + self.varkw) + allshortargs.append('**' + self.varkw) + self.signature = ', '.join(allargs) + self.shortsignature = ', '.join(allshortargs) + self.dict = func.__dict__.copy() + # func=None happens when decorating a caller + if name: + self.name = name + if signature is not None: + self.signature = signature + if defaults: + self.defaults = defaults + if doc: + self.doc = doc + if module: + self.module = module + if funcdict: + self.dict = funcdict + # check existence required attributes + assert hasattr(self, 'name') + if not hasattr(self, 'signature'): + raise TypeError('You are decorating a non function: %s' % func) + + def update(self, func, **kw): + "Update the signature of func with the data in self" + func.__name__ = self.name + func.__doc__ = getattr(self, 'doc', None) + func.__dict__ = getattr(self, 'dict', {}) + func.__defaults__ = self.defaults + func.__kwdefaults__ = self.kwonlydefaults or None + func.__annotations__ = getattr(self, 'annotations', None) + try: + frame = sys._getframe(3) + except AttributeError: # for IronPython and similar implementations + callermodule = '?' + else: + callermodule = frame.f_globals.get('__name__', '?') + func.__module__ = getattr(self, 'module', callermodule) + func.__dict__.update(kw) + + def make(self, src_templ, evaldict=None, addsource=False, **attrs): + "Make a new function from a given template and update the signature" + src = src_templ % vars(self) # expand name and signature + evaldict = evaldict or {} + mo = DEF.search(src) + if mo is None: + raise SyntaxError('not a valid function template\n%s' % src) + name = mo.group(1) # extract the function name + names = set([name] + [arg.strip(' *') for arg in + self.shortsignature.split(',')]) + for n in names: + if n in ('_func_', '_call_'): + raise NameError('%s is overridden in\n%s' % (n, src)) + + if not src.endswith('\n'): # add a newline for old Pythons + src += '\n' + + # Ensure each generated function has a unique filename for profilers + # (such as cProfile) that depend on the tuple of (, + # , ) being unique. + filename = '' % next(self._compile_count) + try: + code = compile(src, filename, 'single') + exec(code, evaldict) + except Exception: + print('Error in generated code:', file=sys.stderr) + print(src, file=sys.stderr) + raise + func = evaldict[name] + if addsource: + attrs['__source__'] = src + self.update(func, **attrs) + return func + + @classmethod + def create(cls, obj, body, evaldict, defaults=None, + doc=None, module=None, addsource=True, **attrs): + """ + Create a function from the strings name, signature and body. + evaldict is the evaluation dictionary. If addsource is true an + attribute __source__ is added to the result. The attributes attrs + are added, if any. + """ + if isinstance(obj, str): # "name(signature)" + name, rest = obj.strip().split('(', 1) + signature = rest[:-1] # strip a right parens + func = None + else: # a function + name = None + signature = None + func = obj + self = cls(func, name, signature, defaults, doc, module) + ibody = '\n'.join(' ' + line for line in body.splitlines()) + caller = evaldict.get('_call_') # when called from `decorate` + if caller and iscoroutinefunction(caller): + body = ('async def %(name)s(%(signature)s):\n' + ibody).replace( + 'return', 'return await') + else: + body = 'def %(name)s(%(signature)s):\n' + ibody + return self.make(body, evaldict, addsource, **attrs) + + +def decorate(func, caller, extras=()): + """ + decorate(func, caller) decorates a function using a caller. + If the caller is a generator function, the resulting function + will be a generator function. + """ + evaldict = dict(_call_=caller, _func_=func) + es = '' + for i, extra in enumerate(extras): + ex = '_e%d_' % i + evaldict[ex] = extra + es += ex + ', ' + + if '3.5' <= sys.version < '3.6': + # with Python 3.5 isgeneratorfunction returns True for all coroutines + # however we know that it is NOT possible to have a generator + # coroutine in python 3.5: PEP525 was not there yet + generatorcaller = isgeneratorfunction( + caller) and not iscoroutinefunction(caller) + else: + generatorcaller = isgeneratorfunction(caller) + if generatorcaller: + fun = FunctionMaker.create( + func, "for res in _call_(_func_, %s%%(shortsignature)s):\n" + " yield res" % es, evaldict, __wrapped__=func) + else: + fun = FunctionMaker.create( + func, "return _call_(_func_, %s%%(shortsignature)s)" % es, + evaldict, __wrapped__=func) + if hasattr(func, '__qualname__'): + fun.__qualname__ = func.__qualname__ + return fun + + +def decorator(caller, _func=None): + """decorator(caller) converts a caller function into a decorator""" + if _func is not None: # return a decorated function + # this is obsolete behavior; you should use decorate instead + return decorate(_func, caller) + # else return a decorator function + defaultargs, defaults = '', () + if inspect.isclass(caller): + name = caller.__name__.lower() + doc = 'decorator(%s) converts functions/generators into ' \ + 'factories of %s objects' % (caller.__name__, caller.__name__) + elif inspect.isfunction(caller): + if caller.__name__ == '': + name = '_lambda_' + else: + name = caller.__name__ + doc = caller.__doc__ + nargs = caller.__code__.co_argcount + ndefs = len(caller.__defaults__ or ()) + defaultargs = ', '.join(caller.__code__.co_varnames[nargs-ndefs:nargs]) + if defaultargs: + defaultargs += ',' + defaults = caller.__defaults__ + else: # assume caller is an object with a __call__ method + name = caller.__class__.__name__.lower() + doc = caller.__call__.__doc__ + evaldict = dict(_call=caller, _decorate_=decorate) + dec = FunctionMaker.create( + '%s(func, %s)' % (name, defaultargs), + 'if func is None: return lambda func: _decorate_(func, _call, (%s))\n' + 'return _decorate_(func, _call, (%s))' % (defaultargs, defaultargs), + evaldict, doc=doc, module=caller.__module__, __wrapped__=caller) + if defaults: + dec.__defaults__ = (None,) + defaults + return dec + + +# ####################### contextmanager ####################### # + +try: # Python >= 3.2 + from contextlib import _GeneratorContextManager +except ImportError: # Python >= 2.5 + from contextlib import GeneratorContextManager as _GeneratorContextManager + + +class ContextManager(_GeneratorContextManager): + def __call__(self, func): + """Context manager decorator""" + return FunctionMaker.create( + func, "with _self_: return _func_(%(shortsignature)s)", + dict(_self_=self, _func_=func), __wrapped__=func) + + +init = getfullargspec(_GeneratorContextManager.__init__) +n_args = len(init.args) +if n_args == 2 and not init.varargs: # (self, genobj) Python 2.7 + def __init__(self, g, *a, **k): + return _GeneratorContextManager.__init__(self, g(*a, **k)) + ContextManager.__init__ = __init__ +elif n_args == 2 and init.varargs: # (self, gen, *a, **k) Python 3.4 + pass +elif n_args == 4: # (self, gen, args, kwds) Python 3.5 + def __init__(self, g, *a, **k): + return _GeneratorContextManager.__init__(self, g, a, k) + ContextManager.__init__ = __init__ + +_contextmanager = decorator(ContextManager) + + +def contextmanager(func): + # Enable Pylint config: contextmanager-decorators=decorator.contextmanager + return _contextmanager(func) + + +# ############################ dispatch_on ############################ # + +def append(a, vancestors): + """ + Append ``a`` to the list of the virtual ancestors, unless it is already + included. + """ + add = True + for j, va in enumerate(vancestors): + if issubclass(va, a): + add = False + break + if issubclass(a, va): + vancestors[j] = a + add = False + if add: + vancestors.append(a) + + +# inspired from simplegeneric by P.J. Eby and functools.singledispatch +def dispatch_on(*dispatch_args): + """ + Factory of decorators turning a function into a generic function + dispatching on the given arguments. + """ + assert dispatch_args, 'No dispatch args passed' + dispatch_str = '(%s,)' % ', '.join(dispatch_args) + + def check(arguments, wrong=operator.ne, msg=''): + """Make sure one passes the expected number of arguments""" + if wrong(len(arguments), len(dispatch_args)): + raise TypeError('Expected %d arguments, got %d%s' % + (len(dispatch_args), len(arguments), msg)) + + def gen_func_dec(func): + """Decorator turning a function into a generic function""" + + # first check the dispatch arguments + argset = set(getfullargspec(func).args) + if not set(dispatch_args) <= argset: + raise NameError('Unknown dispatch arguments %s' % dispatch_str) + + typemap = {} + + def vancestors(*types): + """ + Get a list of sets of virtual ancestors for the given types + """ + check(types) + ras = [[] for _ in range(len(dispatch_args))] + for types_ in typemap: + for t, type_, ra in zip(types, types_, ras): + if issubclass(t, type_) and type_ not in t.mro(): + append(type_, ra) + return [set(ra) for ra in ras] + + def ancestors(*types): + """ + Get a list of virtual MROs, one for each type + """ + check(types) + lists = [] + for t, vas in zip(types, vancestors(*types)): + n_vas = len(vas) + if n_vas > 1: + raise RuntimeError( + 'Ambiguous dispatch for %s: %s' % (t, vas)) + elif n_vas == 1: + va, = vas + mro = type('t', (t, va), {}).mro()[1:] + else: + mro = t.mro() + lists.append(mro[:-1]) # discard t and object + return lists + + def register(*types): + """ + Decorator to register an implementation for the given types + """ + check(types) + + def dec(f): + check(getfullargspec(f).args, operator.lt, ' in ' + f.__name__) + typemap[types] = f + return f + return dec + + def dispatch_info(*types): + """ + An utility to introspect the dispatch algorithm + """ + check(types) + lst = [] + for anc in itertools.product(*ancestors(*types)): + lst.append(tuple(a.__name__ for a in anc)) + return lst + + def _dispatch(dispatch_args, *args, **kw): + types = tuple(type(arg) for arg in dispatch_args) + try: # fast path + f = typemap[types] + except KeyError: + pass + else: + return f(*args, **kw) + combinations = itertools.product(*ancestors(*types)) + next(combinations) # the first one has been already tried + for types_ in combinations: + f = typemap.get(types_) + if f is not None: + return f(*args, **kw) + + # else call the default implementation + return func(*args, **kw) + + return FunctionMaker.create( + func, 'return _f_(%s, %%(shortsignature)s)' % dispatch_str, + dict(_f_=_dispatch), register=register, default=func, + typemap=typemap, vancestors=vancestors, ancestors=ancestors, + dispatch_info=dispatch_info, __wrapped__=func) + + gen_func_dec.__name__ = 'dispatch_on' + dispatch_str + return gen_func_dec diff --git a/snap-python/source/snapx/snapx/utils/decorators.py b/snap-python/source/snapx/snapx/utils/decorators.py new file mode 100644 index 0000000000000000000000000000000000000000..a6aa23255c96624c96235022dd3afd5c0a71f5ce --- /dev/null +++ b/snap-python/source/snapx/snapx/utils/decorators.py @@ -0,0 +1,115 @@ +from .decorator import decorator +import snapx as sx + +def nodes_or_number(which_args): + """PORTED FROM NETWORKX + Decorator to allow number of nodes or container of nodes. + Parameters + ---------- + which_args : int or sequence of ints + Location of the node arguments in args. Even if the argument is a + named positional argument (with a default value), you must specify its + index as a positional argument. + If more than one node argument is allowed, can be a list of locations. + Returns + ------- + _nodes_or_numbers : function + Function which replaces int args with ranges. + Examples + -------- + Decorate functions like this:: + @nodes_or_number(0) + def empty_graph(nodes): + pass + @nodes_or_number([0,1]) + def grid_2d_graph(m1, m2, periodic=False): + pass + @nodes_or_number(1) + def full_rary_tree(r, n) + # r is a number. n can be a number of a list of nodes + pass + """ + @decorator + def _nodes_or_number(func_to_be_decorated, *args, **kw): + # form tuple of arg positions to be converted. + try: + iter_wa = iter(which_args) + except TypeError: + iter_wa = (which_args,) + # change each argument in turn + new_args = list(args) + for i in iter_wa: + n = args[i] + try: + nodes = list(range(n)) + except TypeError: + nodes = tuple(n) + else: + if n < 0: + msg = "Negative number of nodes not valid: {}".format(n) + raise sx.SnapXError(msg) + new_args[i] = (n, nodes) + return func_to_be_decorated(*new_args, **kw) + return _nodes_or_number + +def not_implemented_for(*graph_types): + """PORTED FROM NETWORKX + Decorator to mark algorithms as not implemented + + Parameters + ---------- + graph_types : container of strings + Entries must be one of 'directed','undirected', 'multigraph', 'graph'. + + Returns + ------- + _require : function + The decorated function. + + Raises + ------ + NetworkXNotImplemented + If any of the packages cannot be imported + + Notes + ----- + Multiple types are joined logically with "and". + For "or" use multiple @not_implemented_for() lines. + + Examples + -------- + Decorate functions like this:: + + @not_implemnted_for('directed') + def sp_function(G): + pass + + @not_implemnted_for('directed','multigraph') + def sp_np_function(G): + pass + """ + + @decorator + def _not_implemented_for(not_implement_for_func, *args, **kwargs): + graph = args[0] + terms = { + "directed": graph.is_directed(), + "undirected": not graph.is_directed(), + "multigraph": graph.is_multigraph(), + "graph": not graph.is_multigraph(), + } + match = True + try: + for t in graph_types: + match = match and terms[t] + except KeyError as e: + raise KeyError( + "use one or more of " "directed, undirected, multigraph, graph" + ) from e + if match: + msg = "not implemented for {} type".format(' '.join(graph_types)) + raise sx.SnapXNotImplemented(msg) + else: + return not_implement_for_func(*args, **kwargs) + + return _not_implemented_for diff --git a/snap-python/source/snapx/snapx/utils/misc.py b/snap-python/source/snapx/snapx/utils/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..4e2de3b5efee9b1be513ad937ccf8a3e92397362 --- /dev/null +++ b/snap-python/source/snapx/snapx/utils/misc.py @@ -0,0 +1,22 @@ +"""PORTED FROM NETWORKX + +Miscellaneous Helpers for NetworkX. +These are not imported into the base networkx namespace but +can be accessed, for example, as +>>> import networkx +>>> networkx.utils.is_list_of_ints([1, 2, 3]) +True +>>> networkx.utils.is_list_of_ints([1, 2, "spam"]) +False +""" + +from itertools import tee + +# Recipe from the itertools documentation. +def pairwise(iterable, cyclic=False): + "s -> (s0, s1), (s1, s2), (s2, s3), ..." + a, b = tee(iterable) + first = next(b, None) + if cyclic is True: + return zip(a, chain(b, (first,))) + return zip(a, b) diff --git a/snap-python/source/swig/MANIFEST.in b/snap-python/source/swig/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..75d5bd611e2d395b022e8f179d8727cb4549d5c1 --- /dev/null +++ b/snap-python/source/swig/MANIFEST.in @@ -0,0 +1,3 @@ +include snap.py +include _snap.so +include snap diff --git a/snap-python/source/swig/MANIFEST.in.nx b/snap-python/source/swig/MANIFEST.in.nx new file mode 100644 index 0000000000000000000000000000000000000000..9b252bfe72215d0d27146675b1a488b1d9cabba2 --- /dev/null +++ b/snap-python/source/swig/MANIFEST.in.nx @@ -0,0 +1,2 @@ +include _snap.so + diff --git a/snap-python/source/swig/MANIFEST.mac b/snap-python/source/swig/MANIFEST.mac new file mode 100644 index 0000000000000000000000000000000000000000..ceebbab302af6ec08c1071f3a815d7619d8d14f5 --- /dev/null +++ b/snap-python/source/swig/MANIFEST.mac @@ -0,0 +1,5 @@ +setup.py +snap.py +_snap.so +update_dynlib.sh +install_name_tool diff --git a/snap-python/source/swig/MANIFEST.mac3 b/snap-python/source/swig/MANIFEST.mac3 new file mode 100644 index 0000000000000000000000000000000000000000..320bdaf5fb227fa3c1314b3ceb7103f9baf5a9bd --- /dev/null +++ b/snap-python/source/swig/MANIFEST.mac3 @@ -0,0 +1,5 @@ +setup.py +snap.py +_snap3.so +update_dynlib.sh +install_name_tool diff --git a/snap-python/source/swig/MANIFEST.nx b/snap-python/source/swig/MANIFEST.nx new file mode 100644 index 0000000000000000000000000000000000000000..9b8a374b985f552765f7eeca501d83a1a29e01fb --- /dev/null +++ b/snap-python/source/swig/MANIFEST.nx @@ -0,0 +1,3 @@ +setup.py +snap.py +_snap.so diff --git a/snap-python/source/swig/MANIFEST.nx3 b/snap-python/source/swig/MANIFEST.nx3 new file mode 100644 index 0000000000000000000000000000000000000000..4254d89397ac56658b4c1ac3f8b9c7ed44ec58eb --- /dev/null +++ b/snap-python/source/swig/MANIFEST.nx3 @@ -0,0 +1,3 @@ +setup.py +snap.py +_snap3.so diff --git a/snap-python/source/swig/MANIFEST.win b/snap-python/source/swig/MANIFEST.win new file mode 100644 index 0000000000000000000000000000000000000000..1ead8a4d4d924b85d5845cb14d935c6b7ed80658 --- /dev/null +++ b/snap-python/source/swig/MANIFEST.win @@ -0,0 +1,3 @@ +setup.py +snap.py +_snap.pyd diff --git a/snap-python/source/swig/Makefile b/snap-python/source/swig/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..2ab401c4ee5c4d2884d26daa74184eb9c5b9c43e --- /dev/null +++ b/snap-python/source/swig/Makefile @@ -0,0 +1,213 @@ +# +# Makefile for SWIG processing of SNAP Python +# Use this Makefile to compile SNAP Python from scratch +# +# Build instructions for py2 on macOS and Linux: +# make all2 # apply SWIG and compile the code +# make srcdist # build source distribution +# make whldist # build wheel distribution +# make pip-test # upload to private test pip +# make pip-public # upload to public release pip +# Build instructions for py3 on macOS and Linux: +# make all3 # apply SWIG and compile the code +# make srcdist3 # build source distribution for py3 +# make whldist3 # build wheel distribution for py3 +# make pip3-test # upload to private test pip +# make pip3-public # upload to public release pip +# +# NOTE: python2 build on macOS +# - use system python on macOS to compile +# - use system/brew python on macOS to build the source distribution +# - use brew python on macOS to build the wheel distribution +# - TODO: test cross system/brew install +# NOTE: python3 build on macOS +# - use brew python for all the steps +# - the final packages requires brew +# +# Build instructions for py2 on Windows: +# - run swig in Cygwin to generate snap_wrap.cxx and snap.py +# make swig-win +# - build Snappy solution in Visual Studio to generate _snap.pyd +# - open snappy-VS19 +# - add VC++ include path for snap-core, glib-core, snap-adv +# - create drive shares S: and P:, use Command Prompt: +# subst S: +# example path: C:\cygwin\home\\git\snap-dev-64 +# subst P: +# example path: C:\cygwin\home\\git\snap-python-64 +# - build +# - use Configuration +# Release, x64 +# - run setup.py in Cygwin to generate the package, +# EXECUTE LOCALLY DIRECTLY IN CYGWIN ON THE HOST, NOT OVER SSH +# make srcdist-win # build Windows source distribution +# make whldist-win # build Windows wheel distribution +# make pip-test # upload to private test pip +# # EXECUTE MANUALLY FROM COMMAND PROMPT +# make pip-public # upload to public release pip +# # EXECUTE MANUALLY FROM COMMAND PROMPT +# Build instructions for py3 on Windows: +# - run swig in Cygwin to generate snap_wrap.cxx and snap.py +# make swig3-win +# - build Snappy solution in Visual Studio to generate _snap.pyd +# - open snappy3-VS19 +# - add VC++ include path for snap-core, glib-core, snap-adv +# - create drive shares S: and P:, use Command Prompt: +# subst S: +# example path: C:\cygwin\home\\git\snap-dev-64 +# subst P: +# example path: C:\cygwin\home\\git\snap-python-64 +# - build +# - use Configuration +# Release, x64 +# - run setup.py in Cygwin to generate the package, +# EXECUTE LOCALLY DIRECTLY IN CYGWIN ON THE HOST, NOT OVER SSH +# make srcdist3-win # build Windows source distribution +# make whldist3-win # build Windows wheel distribution +# make pip3-test # upload to private test pip +# # EXECUTE MANUALLY FROM COMMAND PROMPT +# make pip3-public # upload to public release pip +# # EXECUTE MANUALLY FROM COMMAND PROMPT + +# set the path to your SNAP directory here +SNAPROOT ?= ../../snap +SNAPDIR = $(SNAPROOT)/$(SNAP) +GLIBDIR = $(SNAPROOT)/$(GLIB) +SNAPADVDIR = $(SNAPROOT)/$(SNAPADV) +SNAPEXPDIR = $(SNAPROOT)/$(SNAPEXP) + +# include compilation parameters +include $(SNAPROOT)/Makefile.config +include ../Makefile.config + +all: all3 + +all2: snap.py _snap.so + +all3: snap3.py _snap3.so + +snap.py: snap_wrap.cxx + +snap3.py: snap_wrap3.cxx + +_snap.so: snap_wrap.o Snap.o cliques.o agm.o agmfast.o agmfit.o biasedrandomwalk.o word2vec.o n2v.o + $(CC) $(LDFLAGS) $(LIBS) snap_wrap.o Snap.o cliques.o agm.o agmfast.o agmfit.o biasedrandomwalk.o word2vec.o n2v.o -o _snap.so + +_snap3.so: snap_wrap3.o Snap.o cliques.o agm.o agmfast.o agmfit.o biasedrandomwalk.o word2vec.o n2v.o + $(CC) $(LDFLAGS3) $(LIBS) snap_wrap3.o Snap.o -o cliques.o agm.o agmfast.o agmfit.o biasedrandomwalk.o word2vec.o n2v.o -o _snap.so + ln -f _snap.so _snap3.so + +snap_wrap.cxx: snap.i snap_types.i tvec.i pneanet.i tmodenet.i tcrossnet.i pungraph.i pngraph.i pgraph.i pngraphmp.i pneanetmp.i pylayer.i\ + snapswig.h snap_types.h printgraph.h goodgraph.cpp + swig $(SWIGFLAGS) -python -c++ -w302,312,317,325,362,383,384,389,401,503,508,509 -O -I$(SNAPDIR) -I$(GLIBDIR) snap.i + +snap_wrap3.cxx: snap.i snap_types.i tvec.i pneanet.i tmodenet.i tcrossnet.i pungraph.i pngraph.i pgraph.i pngraphmp.i pneanetmp.i pylayer.i\ + snapswig.h snap_types.h printgraph.h goodgraph.cpp + swig $(SWIGFLAGS3) -python -c++ -w302,312,317,325,362,383,384,389,401,503,508,509 -O -I$(SNAPDIR) -I$(GLIBDIR) snap.i + ln -f snap_wrap.cxx snap_wrap3.cxx + +snap_wrap.o: snap_wrap.cxx + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(GLIBDIR) $(IFLAGS) -c snap_wrap.cxx + +snap_wrap3.o: snap_wrap3.cxx + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(GLIBDIR) $(IFLAGS3) -c snap_wrap3.cxx -o snap_wrap.o + ln -f snap_wrap.o snap_wrap3.o + +Snap.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(GLIBDIR) -c $(SNAPDIR)/Snap.cpp + +cliques.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(SNAPADVDIR) -I$(GLIBDIR) -c $(SNAPADVDIR)/cliques.cpp + +agm.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(SNAPADVDIR) -I$(GLIBDIR) -c $(SNAPADVDIR)/agm.cpp + +agmfast.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(SNAPADVDIR) -I$(GLIBDIR) -c $(SNAPADVDIR)/agmfast.cpp + +agmfit.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(SNAPADVDIR) -I$(GLIBDIR) -c $(SNAPADVDIR)/agmfit.cpp + +biasedrandomwalk.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(SNAPADVDIR) -I$(GLIBDIR) -c $(SNAPADVDIR)/biasedrandomwalk.cpp + +word2vec.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(SNAPADVDIR) -I$(GLIBDIR) -c $(SNAPADVDIR)/word2vec.cpp + +n2v.o: + $(CC) $(CXXFLAGS) -I$(SNAPDIR) -I$(SNAPADVDIR) -I$(GLIBDIR) -c $(SNAPADVDIR)/n2v.cpp + +install: setup.py snap.py _snap.so + sudo $(PYTHON) setup.py install + +srcdist: $(SETUP) snap.py _snap.so + cp $(MANIFEST) MANIFEST + cp $(MANIFEST_IN) MANIFEST.in + $(PYTHON) $(SETUP) sdist + +whldist: $(SETUP) snap.py _snap.so + $(PYTHON) $(SETUP) bdist_wheel +ifeq ($(UNAME), Linux) + # change name '-linux_' to '-linuxmany1_' as required by pip + mv dist/*-linux_* `ls dist/*-linux_* | sed -e "s/-linux_/-manylinux1_/g"` +endif + +srcdist3: $(SETUP) snap3.py _snap3.so snap.py + cp $(MANIFEST) MANIFEST + cp $(MANIFEST_IN) MANIFEST.in + $(PYTHON3) $(SETUP) sdist + +whldist3: $(SETUP) snap3.py _snap3.so snap.py + $(PYTHON3) $(SETUP) bdist_wheel +ifeq ($(UNAME), Linux) + # change name '-linux_' to '-linuxmany1_' as required by pip + mv dist/*-linux_* `ls dist/*-linux_* | sed -e "s/-linux_/-manylinux1_/g"` +endif + +swig-win: snap_wrap.cxx + +swig3-win: snap_wrap3.cxx + +install-win: setup.py snap.py _snap.pyd + $(PYTHON) setup.py install + +srcdist-win: setup.py snap.py _snap.pyd + cp $(MANIFEST) MANIFEST + cp $(MANIFEST_IN) MANIFEST.in + $(PYTHON) setup.py sdist --formats=zip + chmod 0644 dist/*.zip + +whldist-win: setup.py snap.py _snap.pyd + $(PYTHON) setup.py bdist_wheel + +srcdist3-win: setup.py snap.py _snap.pyd + cp $(MANIFEST) MANIFEST + cp $(MANIFEST_IN) MANIFEST.in + $(PYTHON3) setup.py sdist --formats=zip + chmod 0644 dist/*.zip + +whldist3-win: setup.py snap.py _snap.pyd + $(PYTHON3) setup.py bdist_wheel + +clean: + rm -f *.o *_wrap*.cxx _*.so *.pyc snap*.py _snap*.* + +clean-obj: + rm -f snap_*.o _snap.so + +pip-test: dist/* + @echo TESTING uploading test file ${WHLFILE} + $(PYTHON) -m twine upload --repository-url https://test.pypi.org/legacy/ ${WHLFILE} + +pip3-test: dist/* + @echo TESTING uploading test file ${WHLFILE} + $(PYTHON3) -m twine upload --repository-url https://test.pypi.org/legacy/ ${WHLFILE} + +pip-public: dist/* + @echo PUBLIC RELEASE uploading file ${WHLFILE} + $(PYTHON) -m twine upload ${WHLFILE} + +pip3-public: dist/* + @echo PUBLIC RELEASE uploading file ${WHLFILE} + $(PYTHON3) -m twine upload ${WHLFILE} + diff --git a/snap-python/source/swig/README.txt b/snap-python/source/swig/README.txt new file mode 100644 index 0000000000000000000000000000000000000000..d3523bde9d7cfc305ec0cee8ab2ca5f8dd1cfada --- /dev/null +++ b/snap-python/source/swig/README.txt @@ -0,0 +1,85 @@ +======================================================================== + Snap.py - SNAP for Python + http://snap.stanford.edu +======================================================================== + +About Snap.py + +Snap.py is a Python interface for SNAP (Stanford Network Analysis Platform). +SNAP is a general purpose, high performance system for analysis and +manipulation of large networks. SNAP is written in C++ and optimized +for maximum performance and compact graph representation. It easily scales +to massive networks with hundreds of millions of nodes, and billions of edges. +Snap.py provides performance benefits of SNAP, combined with flexibility +of Python. Most of the SNAP functionality is available via Snap.py in Python. + +======================================================================== + +Prerequisites + +Packages for Mac OS X, Linux (as CentOS) and Windows 64-bit are available +at http://snap.stanford.edu. Download the package for your operating system. + +Snap.py requires that 64-bit Python 2.7.x is installed on your machine. +Supported versions of Python are: system version, Anaconda and Homebrew +on Mac OS X, system version on Linux, and packages from python.org on +Windows 64-bit. Make sure that you are using 64-bit Python 2.7.x packages. + +On Windows, Snap.py requires a 64-bit operating system version. Visual +C++ Redistributable for Visual Studio 2012 must be installed on the system. + +To install Snap.py, download and unpack the package for your platform +and run setup.py. + +Snap.py is largely self-contained and requires external packages only for +drawing and visualization. The following packages need to be installed +on the system to support drawing and visualization in Snap.py: + - Gnuplot for plotting structural properties of networks, and + - Graphviz for drawing and visualizing small graphs. + +Set the system PATH variable, so that Gnuplot and Graphviz are available, +or put the executables in the working directory. + +======================================================================== + +Installation + +Installation of Snap.py on Mac OS X + +On Mac OS X (supported releases are 10.7.5 or later), use the following +commands: + tar zxvf snap-*-macosx10.7.5-x64-py2.7.tar.gz + cd snap-*-macosx10.7.5-x64-py2.7 + sudo python setup.py install +If you use Anaconda and Homebrew Python, then 'sudo' in the last command +line is not required. + +Installation of Snap.py on Linux + +On Linux, use the following commands: + tar zxvf snap-*-centos6.2-x64-py2.6.tar.gz + cd snap-*-centos6.2-x64-py2.6 + sudo python setup.py install + +Installation of Snap.py on Windows 64-bit + +On Windows, verify that your operating system is 64-bit and that Visual +C++ Redistributable for Visual Studio 2012 is installed, then unzip the +Snap.py package and install it with the following command in the +Command Prompt: + cd snap-1.0-2.2-Win-x64-py2.7 + python setup.py install + +Local Install of Snap.py + +If you want to use Snap.py in a local directory without installing it +system-wide, then download the corresponding Snap.py package for your +system, unpack, and copy files snap.py and _snap.so (or _snap.pyd) to +your working directory. + +======================================================================== + +Documentation and Support + +Additional information is available at http://snap.stanford.edu. + diff --git a/snap-python/source/swig/Version b/snap-python/source/swig/Version new file mode 100644 index 0000000000000000000000000000000000000000..324dbc683e4125ad7e0166c51ab7e49f36fcb024 --- /dev/null +++ b/snap-python/source/swig/Version @@ -0,0 +1 @@ +Snap-6.0-20201224-153030 diff --git a/snap-python/source/swig/__init__.py b/snap-python/source/swig/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/swig/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/swig/gen/NOTES.TXT b/snap-python/source/swig/gen/NOTES.TXT new file mode 100644 index 0000000000000000000000000000000000000000..7a9af71a6c9d729e1218781bd2e5ff14f83b8d00 --- /dev/null +++ b/snap-python/source/swig/gen/NOTES.TXT @@ -0,0 +1,111 @@ +# +# generate the Python dispatch table +# + +# add new functions to types.txt + +# generate flist.txt +cat types.txt | grep -v "^#" | cut -f 2 > flist.txt + +# generate a dispatch table for each type +awk -f f.awk -v g=PUNGraph flist.txt > dispatch-pungraph.txt +awk -f f.awk -v g=PNGraph flist.txt > dispatch-pngraph.txt +awk -f f.awk -v g=PNEANet flist.txt > dispatch-pneanet.txt +awk -f f.awk -v g=PNGraphMP flist.txt > dispatch-pngraphmp.txt + +# combine the dispatch tables +cat dispatch-pungraph.txt dispatch-pngraph.txt dispatch-pneanet.txt dispatch-pngraphmp.txt > dispatch.txt + +# generate the Python code +python gendispatch.py types.txt dispatch.txt > out-20130807.txt + +# include output out-20130807.txt in ../pgraph.i +# include custom dispatch table disp-custom.py in ../pgraph.i +# also add new template calls to pungraph.i, pngraph.i, pneanet.i, ... + +# +# generate the SWIG type templates for TVec, THash, ... +# + +# get typedefs from SNAP code +grep "^typedef" /home/rok/git/snap/glib-core/ds.h | grep -v "*" >typedef-ds.txt +grep "^typedef" /home/rok/git/snap/glib-core/hash.h | grep -v "*" >typedef-hash.txt +grep "^typedef" /home/rok/git/snap/glib-core/dt.h | grep -v "*" >typedef-dt.txt +grep "^typedef" /home/rok/git/snap/glib-core/tm.h | grep -v "*" >typedef-tm.txt + +# generate SWIG template code +python gentypes.py typedef-ds.txt | grep template > swig-ds.txt +python gentypes.py typedef-hash.txt | grep template > swig-hash.txt +python gentypes.py typedef-dt.txt | grep template > swig-dt.txt +python gentypes.py typedef-tm.txt | grep template > swig-tm.txt + +# need to be placed in comments due to SWIG compilation errors + +// ignore tm.h typedefs at this point, not high priority + +// double definition +//%template(TStrVIntH) THash; + +// class TTm has no member named Load +//%template(TTmStrPr) TPair; +//%template(TStrTmPr) TPair; + +// is private +//%template(TStrSH) TStrHash; +//%template(TStrIntSH) TStrHash; +//%template(TStrToIntVSH) TStrHash; + +// no member named Load +//%template(TBoolChPr) TPair; +//%template(TUChIntPr) TPair; +//%template(TUChUInt64Pr) TPair; +//%template(TUChStrPr) TPair; +//%template(TIntChPr) TPair; + +// no match for operator< +//%template(TIntQV) TVec >; + +// N cannot be used as a function +//%template(TIntL) TLst; +//%template(TIntKdL) TLst; +//%template(TFltL) TLst; +//%template(TFltIntKdL) TLst; +//%template(TAscFltIntKdL) TLst; +//%template(TStrL) TLst; + +// no matching function for call to TCh::GetStr() const +//%template(TChChH) THash; + +// no member named GetStr +//%template(TChTrIntH) THash; + +// no match for operator= +//%template(TIntIntFltPrH) THash; + +// no member named GetMemUsed +//%template(TDbStrIntH) THash; +//%template(TDbStrStrH) THash; + +# +# add new methods to vector types +# + +# list of vector types is in vectors.txt + +# generate the vector dispatch table +awk -f v.awk vectors.txt > vec-20130820.txt + +# include vec-20130820.txt in tvec.i + +# +# add new methods to hash types +# + +# list of hash types is in hashes.txt + +# generate the vector dispatch table +awk -f h.awk hashes.txt > hash-20130820.txt + +# include hash-20130820.txt in thash.i + + diff --git a/snap-python/source/swig/gen/__init__.py b/snap-python/source/swig/gen/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/swig/gen/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/swig/gen/disp-custom.py b/snap-python/source/swig/gen/disp-custom.py new file mode 100644 index 0000000000000000000000000000000000000000..22741392b18c94ef616b9df18698a83f7f346dc4 --- /dev/null +++ b/snap-python/source/swig/gen/disp-custom.py @@ -0,0 +1,141 @@ +def ConvertGraph(toutspec, tinspec, *args): + if toutspec == PUNGraph: + if type(tinspec) == PUNGraph: + return ConvertGraph_PUNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PUNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PUNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PUNGraph_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNGraph: + if type(tinspec) == PUNGraph: + return ConvertGraph_PNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PNGraph_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNEANet: + if type(tinspec) == PUNGraph: + return ConvertGraph_PNEANet_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PNEANet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PNEANet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PNEANet_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNGraphMP: + if type(tinspec) == PUNGraph: + return ConvertGraph_PNGraphMP_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PNGraphMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PNGraphMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PNGraphMP_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + raise TypeError('First argument has invalid type') +def ConvertSubGraph(toutspec, tinspec, *args): + if toutspec == PUNGraph: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PUNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PUNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PUNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PUNGraph_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNGraph: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PNGraph_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNEANet: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PNEANet_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PNEANet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PNEANet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PNEANet_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNGraphMP: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PNGraphMP_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PNGraphMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PNGraphMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PNGraphMP_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + raise TypeError('First argument has invalid type') +def ConvertESubGraph(toutspec, tinspec, *args): + if toutspec == PUNGraph: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PUNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PUNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PUNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PUNGraph_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNGraph: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PNGraph_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNEANet: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PNEANet_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PNEANet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PNEANet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PNEANet_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + if toutspec == PNGraphMP: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PNGraphMP_PUNGraph(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PNGraphMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PNGraphMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PNGraphMP_PNGraphMP(tinspec, *args) + raise TypeError('Second argument has invalid type') + raise TypeError('First argument has invalid type') +def ToNetwork(tspec, *args): + if tspec == PNEANet : + return ToNetwork_PNEANet(*args) + raise TypeError('First argument has invalid type') +def ToGraph(tspec, *args): + if tspec == PUNGraph: + return ToGraph_PUNGraph(*args) + if tspec == PNGraph: + return ToGraph_PNGraph(*args) + if tspec == PUndirNet: + return ToGraph_PUndirNet(*args) + if tspec == PDirNet: + return ToGraph_PDirNet(*args) + raise TypeError('First argument has invalid type') + diff --git a/snap-python/source/swig/gen/dispatch-pneanet.txt b/snap-python/source/swig/gen/dispatch-pneanet.txt new file mode 100644 index 0000000000000000000000000000000000000000..5ea0adfff521e67ea1c44e80122f4517340c4b8c --- /dev/null +++ b/snap-python/source/swig/gen/dispatch-pneanet.txt @@ -0,0 +1,119 @@ +PNEANet LoadEdgeList +PNEANet LoadEdgeListStr +PNEANet LoadConnList +PNEANet LoadConnListStr +PNEANet LoadPajek +PNEANet SaveEdgeList +PNEANet SavePajek +PNEANet SaveMatlabSparseMtx +PNEANet SaveGViz +PNEANet PrintGraphStatTable +PNEANet MxSccSz +PNEANet MxWccSz +PNEANet GetNodeWcc +PNEANet IsConnected +PNEANet IsWeaklyConn +PNEANet GetWccSzCnt +PNEANet GetWccs +PNEANet GetSccSzCnt +PNEANet GetSccs +PNEANet GetMxWccSz +PNEANet GetMxSccSz +PNEANet GetMxWcc +PNEANet GetMxScc +PNEANet GetMxBiCon +PNEANet CntInDegNodes +PNEANet CntOutDegNodes +PNEANet CntDegNodes +PNEANet CntNonZNodes +PNEANet CntEdgesToSet +PNEANet GetMxDegNId +PNEANet GetMxInDegNId +PNEANet GetMxOutDegNId +PNEANet GetInDegCnt +PNEANet GetOutDegCnt +PNEANet GetDegCnt +PNEANet GetDegSeqV +PNEANet GetNodeInDegV +PNEANet GetNodeOutDegV +PNEANet CntUniqUndirEdges +PNEANet CntUniqDirEdges +PNEANet CntUniqBiDirEdges +PNEANet CntSelfEdges +PNEANet GetUnDir +PNEANet MakeUnDir +PNEANet AddSelfEdges +PNEANet DelSelfEdges +PNEANet DelNodes +PNEANet DelZeroDegNodes +PNEANet DelDegKNodes +PNEANet IsTree +PNEANet GetTreeRootNId +PNEANet GetTreeSig +PNEANet GetBfsTree +PNEANet GetSubTreeSz +PNEANet GetNodesAtHop +PNEANet GetNodesAtHops +PNEANet GetShortPath +PNEANet GetBfsFullDiam +PNEANet GetBfsEffDiam +PNEANet GetBfsEffDiamAll +PNEANet DrawGViz +PNEANet GenGrid +PNEANet GenStar +PNEANet GenCircle +PNEANet GenFull +PNEANet GenTree +PNEANet GenBaraHierar +PNEANet GenRndGnm +PNEANet GetClustCf +PNEANet GetClustCfAll +PNEANet GetNodeClustCf +PNEANet GetTriads +PNEANet GetTriadsAll +PNEANet GetTriadEdges +PNEANet GetNodeTriads +PNEANet GetNodeTriadsAll +PNEANet GetTriadParticip +PNEANet GetCmnNbrs +PNEANet GetLen2Paths +PNEANet GetModularity +PNEANet GetEdgesInOut +PNEANet GetAnf +PNEANet GetAnfEffDiam +PNEANet TestAnf +PNEANet PercentDegree +PNEANet NodesGTEDegree +PNEANet MxDegree +PNEANet PercentMxWcc +PNEANet PercentMxScc +PNEANet GetKCore +PNEANet GetKCoreNodes +PNEANet GetKCoreEdges +PNEANet PrintInfo +PNEANet GetNodeEcc +PNEANet GetPageRank +PNEANet GetHits +PNEANet PlotInDegDistr +PNEANet PlotOutDegDistr +PNEANet PlotWccDistr +PNEANet PlotSccDistr +PNEANet PlotClustCf +PNEANet PlotHops +PNEANet PlotShortPathDistr +PNEANet PlotKCoreNodes +PNEANet PlotKCoreEdges +PNEANet GetSubGraph +PNEANet GetSubGraphRenumber +PNEANet GetESubGraph +PNEANet GetRndSubGraph +PNEANet GetRndESubGraph +PNEANet GetTriangleCnt +PNEANet GetBetweennessCentr +PNEANet GetClosenessCentr +PNEANet GetFarnessCentr +PNEANet GetEgonetHop +PNEANet GetInEgonetHop +PNEANet GetOutEgonetHop +PNEANet GetInEgonetSub +PNEANet GetGraphUnion diff --git a/snap-python/source/swig/gen/dispatch-pngraph.txt b/snap-python/source/swig/gen/dispatch-pngraph.txt new file mode 100644 index 0000000000000000000000000000000000000000..75cef88c5bef1be60a9134645c23228e1dfea23d --- /dev/null +++ b/snap-python/source/swig/gen/dispatch-pngraph.txt @@ -0,0 +1,119 @@ +PNGraph LoadEdgeList +PNGraph LoadEdgeListStr +PNGraph LoadConnList +PNGraph LoadConnListStr +PNGraph LoadPajek +PNGraph SaveEdgeList +PNGraph SavePajek +PNGraph SaveMatlabSparseMtx +PNGraph SaveGViz +PNGraph PrintGraphStatTable +PNGraph MxSccSz +PNGraph MxWccSz +PNGraph GetNodeWcc +PNGraph IsConnected +PNGraph IsWeaklyConn +PNGraph GetWccSzCnt +PNGraph GetWccs +PNGraph GetSccSzCnt +PNGraph GetSccs +PNGraph GetMxWccSz +PNGraph GetMxSccSz +PNGraph GetMxWcc +PNGraph GetMxScc +PNGraph GetMxBiCon +PNGraph CntInDegNodes +PNGraph CntOutDegNodes +PNGraph CntDegNodes +PNGraph CntNonZNodes +PNGraph CntEdgesToSet +PNGraph GetMxDegNId +PNGraph GetMxInDegNId +PNGraph GetMxOutDegNId +PNGraph GetInDegCnt +PNGraph GetOutDegCnt +PNGraph GetDegCnt +PNGraph GetDegSeqV +PNGraph GetNodeInDegV +PNGraph GetNodeOutDegV +PNGraph CntUniqUndirEdges +PNGraph CntUniqDirEdges +PNGraph CntUniqBiDirEdges +PNGraph CntSelfEdges +PNGraph GetUnDir +PNGraph MakeUnDir +PNGraph AddSelfEdges +PNGraph DelSelfEdges +PNGraph DelNodes +PNGraph DelZeroDegNodes +PNGraph DelDegKNodes +PNGraph IsTree +PNGraph GetTreeRootNId +PNGraph GetTreeSig +PNGraph GetBfsTree +PNGraph GetSubTreeSz +PNGraph GetNodesAtHop +PNGraph GetNodesAtHops +PNGraph GetShortPath +PNGraph GetBfsFullDiam +PNGraph GetBfsEffDiam +PNGraph GetBfsEffDiamAll +PNGraph DrawGViz +PNGraph GenGrid +PNGraph GenStar +PNGraph GenCircle +PNGraph GenFull +PNGraph GenTree +PNGraph GenBaraHierar +PNGraph GenRndGnm +PNGraph GetClustCf +PNGraph GetClustCfAll +PNGraph GetNodeClustCf +PNGraph GetTriads +PNGraph GetTriadsAll +PNGraph GetTriadEdges +PNGraph GetNodeTriads +PNGraph GetNodeTriadsAll +PNGraph GetTriadParticip +PNGraph GetCmnNbrs +PNGraph GetLen2Paths +PNGraph GetModularity +PNGraph GetEdgesInOut +PNGraph GetAnf +PNGraph GetAnfEffDiam +PNGraph TestAnf +PNGraph PercentDegree +PNGraph NodesGTEDegree +PNGraph MxDegree +PNGraph PercentMxWcc +PNGraph PercentMxScc +PNGraph GetKCore +PNGraph GetKCoreNodes +PNGraph GetKCoreEdges +PNGraph PrintInfo +PNGraph GetNodeEcc +PNGraph GetPageRank +PNGraph GetHits +PNGraph PlotInDegDistr +PNGraph PlotOutDegDistr +PNGraph PlotWccDistr +PNGraph PlotSccDistr +PNGraph PlotClustCf +PNGraph PlotHops +PNGraph PlotShortPathDistr +PNGraph PlotKCoreNodes +PNGraph PlotKCoreEdges +PNGraph GetSubGraph +PNGraph GetSubGraphRenumber +PNGraph GetESubGraph +PNGraph GetRndSubGraph +PNGraph GetRndESubGraph +PNGraph GetTriangleCnt +PNGraph GetBetweennessCentr +PNGraph GetClosenessCentr +PNGraph GetFarnessCentr +PNGraph GetEgonetHop +PNGraph GetInEgonetHop +PNGraph GetOutEgonetHop +PNGraph GetInEgonetSub +PNGraph GetGraphUnion diff --git a/snap-python/source/swig/gen/dispatch-pngraphmp.txt b/snap-python/source/swig/gen/dispatch-pngraphmp.txt new file mode 100644 index 0000000000000000000000000000000000000000..7f5a051811f4d565af8731a21165611700f09140 --- /dev/null +++ b/snap-python/source/swig/gen/dispatch-pngraphmp.txt @@ -0,0 +1,113 @@ +PNGraphMP LoadEdgeList +PNGraphMP LoadEdgeListStr +PNGraphMP LoadConnList +PNGraphMP LoadConnListStr +PNGraphMP LoadPajek +PNGraphMP SaveEdgeList +PNGraphMP SavePajek +PNGraphMP SaveMatlabSparseMtx +PNGraphMP SaveGViz +PNGraphMP PrintGraphStatTable +PNGraphMP MxSccSz +PNGraphMP MxWccSz +PNGraphMP GetNodeWcc +PNGraphMP IsConnected +PNGraphMP IsWeaklyConn +PNGraphMP GetWccSzCnt +PNGraphMP GetWccs +PNGraphMP GetSccSzCnt +PNGraphMP GetSccs +PNGraphMP GetMxWccSz +PNGraphMP GetMxSccSz +PNGraphMP GetMxWcc +PNGraphMP GetMxScc +PNGraphMP GetMxBiCon +PNGraphMP CntInDegNodes +PNGraphMP CntOutDegNodes +PNGraphMP CntDegNodes +PNGraphMP CntNonZNodes +PNGraphMP CntEdgesToSet +PNGraphMP GetMxDegNId +PNGraphMP GetMxInDegNId +PNGraphMP GetMxOutDegNId +PNGraphMP GetInDegCnt +PNGraphMP GetOutDegCnt +PNGraphMP GetDegCnt +PNGraphMP GetDegSeqV +PNGraphMP GetNodeInDegV +PNGraphMP GetNodeOutDegV +PNGraphMP CntUniqUndirEdges +PNGraphMP CntUniqDirEdges +PNGraphMP CntUniqBiDirEdges +PNGraphMP CntSelfEdges +PNGraphMP GetUnDir +PNGraphMP MakeUnDir +PNGraphMP AddSelfEdges +PNGraphMP DelSelfEdges +PNGraphMP DelNodes +PNGraphMP DelZeroDegNodes +PNGraphMP DelDegKNodes +PNGraphMP IsTree +PNGraphMP GetTreeRootNId +PNGraphMP GetTreeSig +PNGraphMP GetBfsTree +PNGraphMP GetSubTreeSz +PNGraphMP GetNodesAtHop +PNGraphMP GetNodesAtHops +PNGraphMP GetShortPath +PNGraphMP GetBfsFullDiam +PNGraphMP GetBfsEffDiam +PNGraphMP DrawGViz +PNGraphMP GenGrid +PNGraphMP GenStar +PNGraphMP GenCircle +PNGraphMP GenFull +PNGraphMP GenTree +PNGraphMP GenBaraHierar +PNGraphMP GenRndGnm +PNGraphMP GetClustCf +PNGraphMP GetNodeClustCf +PNGraphMP GetTriads +PNGraphMP GetTriadEdges +PNGraphMP GetNodeTriads +PNGraphMP GetTriadParticip +PNGraphMP GetCmnNbrs +PNGraphMP GetLen2Paths +PNGraphMP GetModularity +PNGraphMP GetEdgesInOut +PNGraphMP GetAnf +PNGraphMP GetAnfEffDiam +PNGraphMP TestAnf +PNGraphMP PercentDegree +PNGraphMP NodesGTEDegree +PNGraphMP MxDegree +PNGraphMP PercentMxWcc +PNGraphMP PercentMxScc +PNGraphMP GetKCore +PNGraphMP GetKCoreNodes +PNGraphMP GetKCoreEdges +PNGraphMP PrintInfo +PNGraphMP GetNodeEcc +PNGraphMP GetPageRank +PNGraphMP GetPageRank_v1 +PNGraphMP GetPageRankMP +PNGraphMP GetHits +PNGraphMP GetHitsMP +PNGraphMP PlotInDegDistr +PNGraphMP PlotOutDegDistr +PNGraphMP PlotWccDistr +PNGraphMP PlotSccDistr +PNGraphMP PlotClustCf +PNGraphMP PlotHops +PNGraphMP PlotShortPathDistr +PNGraphMP PlotKCoreNodes +PNGraphMP PlotKCoreEdges +PNGraphMP GetSubGraph +PNGraphMP GetESubGraph +PNGraphMP GetRndSubGraph +PNGraphMP GetRndESubGraph +PNGraphMP GetTriangleCnt +PNGraphMP GetBetweennessCentr +PNGraphMP GetClosenessCentr +PNGraphMP GetFarnessCentr + diff --git a/snap-python/source/swig/gen/dispatch-pungraph.txt b/snap-python/source/swig/gen/dispatch-pungraph.txt new file mode 100644 index 0000000000000000000000000000000000000000..8ef83b77960421e01a02251a27d7937438329520 --- /dev/null +++ b/snap-python/source/swig/gen/dispatch-pungraph.txt @@ -0,0 +1,119 @@ +PUNGraph LoadEdgeList +PUNGraph LoadEdgeListStr +PUNGraph LoadConnList +PUNGraph LoadConnListStr +PUNGraph LoadPajek +PUNGraph SaveEdgeList +PUNGraph SavePajek +PUNGraph SaveMatlabSparseMtx +PUNGraph SaveGViz +PUNGraph PrintGraphStatTable +PUNGraph MxSccSz +PUNGraph MxWccSz +PUNGraph GetNodeWcc +PUNGraph IsConnected +PUNGraph IsWeaklyConn +PUNGraph GetWccSzCnt +PUNGraph GetWccs +PUNGraph GetSccSzCnt +PUNGraph GetSccs +PUNGraph GetMxWccSz +PUNGraph GetMxSccSz +PUNGraph GetMxWcc +PUNGraph GetMxScc +PUNGraph GetMxBiCon +PUNGraph CntInDegNodes +PUNGraph CntOutDegNodes +PUNGraph CntDegNodes +PUNGraph CntNonZNodes +PUNGraph CntEdgesToSet +PUNGraph GetMxDegNId +PUNGraph GetMxInDegNId +PUNGraph GetMxOutDegNId +PUNGraph GetInDegCnt +PUNGraph GetOutDegCnt +PUNGraph GetDegCnt +PUNGraph GetDegSeqV +PUNGraph GetNodeInDegV +PUNGraph GetNodeOutDegV +PUNGraph CntUniqUndirEdges +PUNGraph CntUniqDirEdges +PUNGraph CntUniqBiDirEdges +PUNGraph CntSelfEdges +PUNGraph GetUnDir +PUNGraph MakeUnDir +PUNGraph AddSelfEdges +PUNGraph DelSelfEdges +PUNGraph DelNodes +PUNGraph DelZeroDegNodes +PUNGraph DelDegKNodes +PUNGraph IsTree +PUNGraph GetTreeRootNId +PUNGraph GetTreeSig +PUNGraph GetBfsTree +PUNGraph GetSubTreeSz +PUNGraph GetNodesAtHop +PUNGraph GetNodesAtHops +PUNGraph GetShortPath +PUNGraph GetBfsFullDiam +PUNGraph GetBfsEffDiam +PUNGraph GetBfsEffDiamAll +PUNGraph DrawGViz +PUNGraph GenGrid +PUNGraph GenStar +PUNGraph GenCircle +PUNGraph GenFull +PUNGraph GenTree +PUNGraph GenBaraHierar +PUNGraph GenRndGnm +PUNGraph GetClustCf +PUNGraph GetClustCfAll +PUNGraph GetNodeClustCf +PUNGraph GetTriads +PUNGraph GetTriadsAll +PUNGraph GetTriadEdges +PUNGraph GetNodeTriads +PUNGraph GetNodeTriadsAll +PUNGraph GetTriadParticip +PUNGraph GetCmnNbrs +PUNGraph GetLen2Paths +PUNGraph GetModularity +PUNGraph GetEdgesInOut +PUNGraph GetAnf +PUNGraph GetAnfEffDiam +PUNGraph TestAnf +PUNGraph PercentDegree +PUNGraph NodesGTEDegree +PUNGraph MxDegree +PUNGraph PercentMxWcc +PUNGraph PercentMxScc +PUNGraph GetKCore +PUNGraph GetKCoreNodes +PUNGraph GetKCoreEdges +PUNGraph PrintInfo +PUNGraph GetNodeEcc +PUNGraph GetPageRank +PUNGraph GetHits +PUNGraph PlotInDegDistr +PUNGraph PlotOutDegDistr +PUNGraph PlotWccDistr +PUNGraph PlotSccDistr +PUNGraph PlotClustCf +PUNGraph PlotHops +PUNGraph PlotShortPathDistr +PUNGraph PlotKCoreNodes +PUNGraph PlotKCoreEdges +PUNGraph GetSubGraph +PUNGraph GetSubGraphRenumber +PUNGraph GetESubGraph +PUNGraph GetRndSubGraph +PUNGraph GetRndESubGraph +PUNGraph GetTriangleCnt +PUNGraph GetBetweennessCentr +PUNGraph GetClosenessCentr +PUNGraph GetFarnessCentr +PUNGraph GetEgonetHop +PUNGraph GetInEgonetHop +PUNGraph GetOutEgonetHop +PUNGraph GetInEgonetSub +PUNGraph GetGraphUnion diff --git a/snap-python/source/swig/gen/dispatch.txt b/snap-python/source/swig/gen/dispatch.txt new file mode 100644 index 0000000000000000000000000000000000000000..9d9f58ad68ad8396c726b1a8285def3421f9144d --- /dev/null +++ b/snap-python/source/swig/gen/dispatch.txt @@ -0,0 +1,470 @@ +PUNGraph LoadEdgeList +PUNGraph LoadEdgeListStr +PUNGraph LoadConnList +PUNGraph LoadConnListStr +PUNGraph LoadPajek +PUNGraph SaveEdgeList +PUNGraph SavePajek +PUNGraph SaveMatlabSparseMtx +PUNGraph SaveGViz +PUNGraph PrintGraphStatTable +PUNGraph MxSccSz +PUNGraph MxWccSz +PUNGraph GetNodeWcc +PUNGraph IsConnected +PUNGraph IsWeaklyConn +PUNGraph GetWccSzCnt +PUNGraph GetWccs +PUNGraph GetSccSzCnt +PUNGraph GetSccs +PUNGraph GetMxWccSz +PUNGraph GetMxSccSz +PUNGraph GetMxWcc +PUNGraph GetMxScc +PUNGraph GetMxBiCon +PUNGraph CntInDegNodes +PUNGraph CntOutDegNodes +PUNGraph CntDegNodes +PUNGraph CntNonZNodes +PUNGraph CntEdgesToSet +PUNGraph GetMxDegNId +PUNGraph GetMxInDegNId +PUNGraph GetMxOutDegNId +PUNGraph GetInDegCnt +PUNGraph GetOutDegCnt +PUNGraph GetDegCnt +PUNGraph GetDegSeqV +PUNGraph GetNodeInDegV +PUNGraph GetNodeOutDegV +PUNGraph CntUniqUndirEdges +PUNGraph CntUniqDirEdges +PUNGraph CntUniqBiDirEdges +PUNGraph CntSelfEdges +PUNGraph GetUnDir +PUNGraph MakeUnDir +PUNGraph AddSelfEdges +PUNGraph DelSelfEdges +PUNGraph DelNodes +PUNGraph DelZeroDegNodes +PUNGraph DelDegKNodes +PUNGraph IsTree +PUNGraph GetTreeRootNId +PUNGraph GetTreeSig +PUNGraph GetBfsTree +PUNGraph GetSubTreeSz +PUNGraph GetNodesAtHop +PUNGraph GetNodesAtHops +PUNGraph GetShortPath +PUNGraph GetBfsFullDiam +PUNGraph GetBfsEffDiam +PUNGraph GetBfsEffDiamAll +PUNGraph DrawGViz +PUNGraph GenGrid +PUNGraph GenStar +PUNGraph GenCircle +PUNGraph GenFull +PUNGraph GenTree +PUNGraph GenBaraHierar +PUNGraph GenRndGnm +PUNGraph GetClustCf +PUNGraph GetClustCfAll +PUNGraph GetNodeClustCf +PUNGraph GetTriads +PUNGraph GetTriadsAll +PUNGraph GetTriadEdges +PUNGraph GetNodeTriads +PUNGraph GetNodeTriadsAll +PUNGraph GetTriadParticip +PUNGraph GetCmnNbrs +PUNGraph GetLen2Paths +PUNGraph GetModularity +PUNGraph GetEdgesInOut +PUNGraph GetAnf +PUNGraph GetAnfEffDiam +PUNGraph TestAnf +PUNGraph PercentDegree +PUNGraph NodesGTEDegree +PUNGraph MxDegree +PUNGraph PercentMxWcc +PUNGraph PercentMxScc +PUNGraph GetKCore +PUNGraph GetKCoreNodes +PUNGraph GetKCoreEdges +PUNGraph PrintInfo +PUNGraph GetNodeEcc +PUNGraph GetPageRank +PUNGraph GetHits +PUNGraph PlotInDegDistr +PUNGraph PlotOutDegDistr +PUNGraph PlotWccDistr +PUNGraph PlotSccDistr +PUNGraph PlotClustCf +PUNGraph PlotHops +PUNGraph PlotShortPathDistr +PUNGraph PlotKCoreNodes +PUNGraph PlotKCoreEdges +PUNGraph GetSubGraph +PUNGraph GetSubGraphRenumber +PUNGraph GetESubGraph +PUNGraph GetRndSubGraph +PUNGraph GetRndESubGraph +PUNGraph GetTriangleCnt +PUNGraph GetBetweennessCentr +PUNGraph GetClosenessCentr +PUNGraph GetFarnessCentr +PUNGraph GetEgonetHop +PUNGraph GetInEgonetHop +PUNGraph GetOutEgonetHop +PUNGraph GetInEgonetSub +PUNGraph GetGraphUnion +PNGraph LoadEdgeList +PNGraph LoadEdgeListStr +PNGraph LoadConnList +PNGraph LoadConnListStr +PNGraph LoadPajek +PNGraph SaveEdgeList +PNGraph SavePajek +PNGraph SaveMatlabSparseMtx +PNGraph SaveGViz +PNGraph PrintGraphStatTable +PNGraph MxSccSz +PNGraph MxWccSz +PNGraph GetNodeWcc +PNGraph IsConnected +PNGraph IsWeaklyConn +PNGraph GetWccSzCnt +PNGraph GetWccs +PNGraph GetSccSzCnt +PNGraph GetSccs +PNGraph GetMxWccSz +PNGraph GetMxSccSz +PNGraph GetMxWcc +PNGraph GetMxScc +PNGraph GetMxBiCon +PNGraph CntInDegNodes +PNGraph CntOutDegNodes +PNGraph CntDegNodes +PNGraph CntNonZNodes +PNGraph CntEdgesToSet +PNGraph GetMxDegNId +PNGraph GetMxInDegNId +PNGraph GetMxOutDegNId +PNGraph GetInDegCnt +PNGraph GetOutDegCnt +PNGraph GetDegCnt +PNGraph GetDegSeqV +PNGraph GetNodeInDegV +PNGraph GetNodeOutDegV +PNGraph CntUniqUndirEdges +PNGraph CntUniqDirEdges +PNGraph CntUniqBiDirEdges +PNGraph CntSelfEdges +PNGraph GetUnDir +PNGraph MakeUnDir +PNGraph AddSelfEdges +PNGraph DelSelfEdges +PNGraph DelNodes +PNGraph DelZeroDegNodes +PNGraph DelDegKNodes +PNGraph IsTree +PNGraph GetTreeRootNId +PNGraph GetTreeSig +PNGraph GetBfsTree +PNGraph GetSubTreeSz +PNGraph GetNodesAtHop +PNGraph GetNodesAtHops +PNGraph GetShortPath +PNGraph GetBfsFullDiam +PNGraph GetBfsEffDiam +PNGraph GetBfsEffDiamAll +PNGraph DrawGViz +PNGraph GenGrid +PNGraph GenStar +PNGraph GenCircle +PNGraph GenFull +PNGraph GenTree +PNGraph GenBaraHierar +PNGraph GenRndGnm +PNGraph GetClustCf +PNGraph GetClustCfAll +PNGraph GetNodeClustCf +PNGraph GetTriads +PNGraph GetTriadsAll +PNGraph GetTriadEdges +PNGraph GetNodeTriads +PNGraph GetNodeTriadsAll +PNGraph GetTriadParticip +PNGraph GetCmnNbrs +PNGraph GetLen2Paths +PNGraph GetModularity +PNGraph GetEdgesInOut +PNGraph GetAnf +PNGraph GetAnfEffDiam +PNGraph TestAnf +PNGraph PercentDegree +PNGraph NodesGTEDegree +PNGraph MxDegree +PNGraph PercentMxWcc +PNGraph PercentMxScc +PNGraph GetKCore +PNGraph GetKCoreNodes +PNGraph GetKCoreEdges +PNGraph PrintInfo +PNGraph GetNodeEcc +PNGraph GetPageRank +PNGraph GetHits +PNGraph PlotInDegDistr +PNGraph PlotOutDegDistr +PNGraph PlotWccDistr +PNGraph PlotSccDistr +PNGraph PlotClustCf +PNGraph PlotHops +PNGraph PlotShortPathDistr +PNGraph PlotKCoreNodes +PNGraph PlotKCoreEdges +PNGraph GetSubGraph +PNGraph GetSubGraphRenumber +PNGraph GetESubGraph +PNGraph GetRndSubGraph +PNGraph GetRndESubGraph +PNGraph GetTriangleCnt +PNGraph GetBetweennessCentr +PNGraph GetClosenessCentr +PNGraph GetFarnessCentr +PNGraph GetEgonetHop +PNGraph GetInEgonetHop +PNGraph GetOutEgonetHop +PNGraph GetInEgonetSub +PNGraph GetGraphUnion +PNEANet LoadEdgeList +PNEANet LoadEdgeListStr +PNEANet LoadConnList +PNEANet LoadConnListStr +PNEANet LoadPajek +PNEANet SaveEdgeList +PNEANet SavePajek +PNEANet SaveMatlabSparseMtx +PNEANet SaveGViz +PNEANet PrintGraphStatTable +PNEANet MxSccSz +PNEANet MxWccSz +PNEANet GetNodeWcc +PNEANet IsConnected +PNEANet IsWeaklyConn +PNEANet GetWccSzCnt +PNEANet GetWccs +PNEANet GetSccSzCnt +PNEANet GetSccs +PNEANet GetMxWccSz +PNEANet GetMxSccSz +PNEANet GetMxWcc +PNEANet GetMxScc +PNEANet GetMxBiCon +PNEANet CntInDegNodes +PNEANet CntOutDegNodes +PNEANet CntDegNodes +PNEANet CntNonZNodes +PNEANet CntEdgesToSet +PNEANet GetMxDegNId +PNEANet GetMxInDegNId +PNEANet GetMxOutDegNId +PNEANet GetInDegCnt +PNEANet GetOutDegCnt +PNEANet GetDegCnt +PNEANet GetDegSeqV +PNEANet GetNodeInDegV +PNEANet GetNodeOutDegV +PNEANet CntUniqUndirEdges +PNEANet CntUniqDirEdges +PNEANet CntUniqBiDirEdges +PNEANet CntSelfEdges +PNEANet GetUnDir +PNEANet MakeUnDir +PNEANet AddSelfEdges +PNEANet DelSelfEdges +PNEANet DelNodes +PNEANet DelZeroDegNodes +PNEANet DelDegKNodes +PNEANet IsTree +PNEANet GetTreeRootNId +PNEANet GetTreeSig +PNEANet GetBfsTree +PNEANet GetSubTreeSz +PNEANet GetNodesAtHop +PNEANet GetNodesAtHops +PNEANet GetShortPath +PNEANet GetBfsFullDiam +PNEANet GetBfsEffDiam +PNEANet GetBfsEffDiamAll +PNEANet DrawGViz +PNEANet GenGrid +PNEANet GenStar +PNEANet GenCircle +PNEANet GenFull +PNEANet GenTree +PNEANet GenBaraHierar +PNEANet GenRndGnm +PNEANet GetClustCf +PNEANet GetClustCfAll +PNEANet GetNodeClustCf +PNEANet GetTriads +PNEANet GetTriadsAll +PNEANet GetTriadEdges +PNEANet GetNodeTriads +PNEANet GetNodeTriadsAll +PNEANet GetTriadParticip +PNEANet GetCmnNbrs +PNEANet GetLen2Paths +PNEANet GetModularity +PNEANet GetEdgesInOut +PNEANet GetAnf +PNEANet GetAnfEffDiam +PNEANet TestAnf +PNEANet PercentDegree +PNEANet NodesGTEDegree +PNEANet MxDegree +PNEANet PercentMxWcc +PNEANet PercentMxScc +PNEANet GetKCore +PNEANet GetKCoreNodes +PNEANet GetKCoreEdges +PNEANet PrintInfo +PNEANet GetNodeEcc +PNEANet GetPageRank +PNEANet GetHits +PNEANet PlotInDegDistr +PNEANet PlotOutDegDistr +PNEANet PlotWccDistr +PNEANet PlotSccDistr +PNEANet PlotClustCf +PNEANet PlotHops +PNEANet PlotShortPathDistr +PNEANet PlotKCoreNodes +PNEANet PlotKCoreEdges +PNEANet GetSubGraph +PNEANet GetSubGraphRenumber +PNEANet GetESubGraph +PNEANet GetRndSubGraph +PNEANet GetRndESubGraph +PNEANet GetTriangleCnt +PNEANet GetBetweennessCentr +PNEANet GetClosenessCentr +PNEANet GetFarnessCentr +PNEANet GetEgonetHop +PNEANet GetInEgonetHop +PNEANet GetOutEgonetHop +PNEANet GetInEgonetSub +PNEANet GetGraphUnion +PNGraphMP LoadEdgeList +PNGraphMP LoadEdgeListStr +PNGraphMP LoadConnList +PNGraphMP LoadConnListStr +PNGraphMP LoadPajek +PNGraphMP SaveEdgeList +PNGraphMP SavePajek +PNGraphMP SaveMatlabSparseMtx +PNGraphMP SaveGViz +PNGraphMP PrintGraphStatTable +PNGraphMP MxSccSz +PNGraphMP MxWccSz +PNGraphMP GetNodeWcc +PNGraphMP IsConnected +PNGraphMP IsWeaklyConn +PNGraphMP GetWccSzCnt +PNGraphMP GetWccs +PNGraphMP GetSccSzCnt +PNGraphMP GetSccs +PNGraphMP GetMxWccSz +PNGraphMP GetMxSccSz +PNGraphMP GetMxWcc +PNGraphMP GetMxScc +PNGraphMP GetMxBiCon +PNGraphMP CntInDegNodes +PNGraphMP CntOutDegNodes +PNGraphMP CntDegNodes +PNGraphMP CntNonZNodes +PNGraphMP CntEdgesToSet +PNGraphMP GetMxDegNId +PNGraphMP GetMxInDegNId +PNGraphMP GetMxOutDegNId +PNGraphMP GetInDegCnt +PNGraphMP GetOutDegCnt +PNGraphMP GetDegCnt +PNGraphMP GetDegSeqV +PNGraphMP GetNodeInDegV +PNGraphMP GetNodeOutDegV +PNGraphMP CntUniqUndirEdges +PNGraphMP CntUniqDirEdges +PNGraphMP CntUniqBiDirEdges +PNGraphMP CntSelfEdges +PNGraphMP GetUnDir +PNGraphMP MakeUnDir +PNGraphMP AddSelfEdges +PNGraphMP DelSelfEdges +PNGraphMP DelNodes +PNGraphMP DelZeroDegNodes +PNGraphMP DelDegKNodes +PNGraphMP IsTree +PNGraphMP GetTreeRootNId +PNGraphMP GetTreeSig +PNGraphMP GetBfsTree +PNGraphMP GetSubTreeSz +PNGraphMP GetNodesAtHop +PNGraphMP GetNodesAtHops +PNGraphMP GetShortPath +PNGraphMP GetBfsFullDiam +PNGraphMP GetBfsEffDiam +PNGraphMP DrawGViz +PNGraphMP GenGrid +PNGraphMP GenStar +PNGraphMP GenCircle +PNGraphMP GenFull +PNGraphMP GenTree +PNGraphMP GenBaraHierar +PNGraphMP GenRndGnm +PNGraphMP GetClustCf +PNGraphMP GetNodeClustCf +PNGraphMP GetTriads +PNGraphMP GetTriadEdges +PNGraphMP GetNodeTriads +PNGraphMP GetTriadParticip +PNGraphMP GetCmnNbrs +PNGraphMP GetLen2Paths +PNGraphMP GetModularity +PNGraphMP GetEdgesInOut +PNGraphMP GetAnf +PNGraphMP GetAnfEffDiam +PNGraphMP TestAnf +PNGraphMP PercentDegree +PNGraphMP NodesGTEDegree +PNGraphMP MxDegree +PNGraphMP PercentMxWcc +PNGraphMP PercentMxScc +PNGraphMP GetKCore +PNGraphMP GetKCoreNodes +PNGraphMP GetKCoreEdges +PNGraphMP PrintInfo +PNGraphMP GetNodeEcc +PNGraphMP GetPageRank +PNGraphMP GetPageRank_v1 +PNGraphMP GetPageRankMP +PNGraphMP GetHits +PNGraphMP GetHitsMP +PNGraphMP PlotInDegDistr +PNGraphMP PlotOutDegDistr +PNGraphMP PlotWccDistr +PNGraphMP PlotSccDistr +PNGraphMP PlotClustCf +PNGraphMP PlotHops +PNGraphMP PlotShortPathDistr +PNGraphMP PlotKCoreNodes +PNGraphMP PlotKCoreEdges +PNGraphMP GetSubGraph +PNGraphMP GetESubGraph +PNGraphMP GetRndSubGraph +PNGraphMP GetRndESubGraph +PNGraphMP GetTriangleCnt +PNGraphMP GetBetweennessCentr +PNGraphMP GetClosenessCentr +PNGraphMP GetFarnessCentr + diff --git a/snap-python/source/swig/gen/f.awk b/snap-python/source/swig/gen/f.awk new file mode 100644 index 0000000000000000000000000000000000000000..15df9cef127fb8ffa55f1f0c4403f44bfb2f7f03 --- /dev/null +++ b/snap-python/source/swig/gen/f.awk @@ -0,0 +1,3 @@ + { + printf "%s\t%s\n", g, $1; + } diff --git a/snap-python/source/swig/gen/genClassFn/README.txt b/snap-python/source/swig/gen/genClassFn/README.txt new file mode 100644 index 0000000000000000000000000000000000000000..704ba30c3b543d538820962145aa7dbbc207cd77 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/README.txt @@ -0,0 +1,25 @@ +To generating class function extensions for graphs in Python, the following script was run: +python genPyClassFn.py classFn.txt > out.txt + +The input file classFn.txt contains the names of the class functions. +The output "out.txt" was appended to pylayer.i as a %pythoncode% code block. + +Custom edits were made for the following class functions: + + def ConvertGraph_classFn(self, *args, **kwargs): + return ConvertGraph(args[0], self, *(args[1:]), **kwargs) + PUNGraph.ConvertGraph = ConvertGraph_classFn + PNGraph.ConvertGraph = ConvertGraph_classFn + PNEANet.ConvertGraph = ConvertGraph_classFn + + def ConvertSubGraph_classFn(self, *args, **kwargs): + return ConvertSubGraph(args[0], self, *args[1:], **kwargs) + PUNGraph.ConvertSubGraph = ConvertSubGraph_classFn + PNGraph.ConvertSubGraph = ConvertSubGraph_classFn + PNEANet.ConvertSubGraph = ConvertSubGraph_classFn + + def ConvertESubGraph_classFn(self, *args, **kwargs): + return ConvertESubGraph(args[0], self, *args[1:], **kwargs) + PUNGraph.ConvertESubGraph = ConvertESubGraph_classFn + PNGraph.ConvertESubGraph = ConvertESubGraph_classFn + PNEANet.ConvertESubGraph = ConvertESubGraph_classFn \ No newline at end of file diff --git a/snap-python/source/swig/gen/genClassFn/__init__.py b/snap-python/source/swig/gen/genClassFn/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/swig/gen/genClassFn/archive/README.txt b/snap-python/source/swig/gen/genClassFn/archive/README.txt new file mode 100644 index 0000000000000000000000000000000000000000..e0214a704f102bdc85c3136b9b0dc4906e3add33 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/archive/README.txt @@ -0,0 +1,9 @@ +This folder contains scripts for extending class functions in C++ using swig. +Currently class functions are being added in the Python interface instead, as described in the folder above. + +The class function extensions for C++ were generated as follows: +genClassFnDef.sh < classFn.txt > classFnDef.txt +python genClassFnExt.py > classFnExt.txt + +classFn.txt is the input file containing the names of the class functions, one per row. +classFnExt.txt is the output file that contains the extension templates for the classes: TNGraph, TUNGraph, and TNEANet. The %extend blocks for the graph classes should be placed in their respective swig .i files (pngraph.i, pungraph.i, and pneanet.i in this case) diff --git a/snap-python/source/swig/gen/genClassFn/archive/__init__.py b/snap-python/source/swig/gen/genClassFn/archive/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..40a96afc6ff09d58a702b76e3f7dd412fe975e26 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/archive/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/snap-python/source/swig/gen/genClassFn/archive/classFn.txt b/snap-python/source/swig/gen/genClassFn/archive/classFn.txt new file mode 100644 index 0000000000000000000000000000000000000000..992eb3660df735b4f80a906d8b0a5e44bcaf5b82 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/archive/classFn.txt @@ -0,0 +1,20 @@ +CntDegNodes +CntInDegNodes +CntOutDegNodes +CntNonZNodes +GetDegCnt +GetInDegCnt +GetOutDegCnt +GetMxDegNId +GetMxInDegNId +GetMxOutDegNId +GetNodeInDegV +GetNodeOutDegV +GetDegSeqV +CntSelfEdges +CntUniqBiDirEdges +CntUniqDirEdges +CntUniqUndirEdges +CntEdgesToSet +IsTree +PrintInfo diff --git a/snap-python/source/swig/gen/genClassFn/archive/classFnDef.txt b/snap-python/source/swig/gen/genClassFn/archive/classFnDef.txt new file mode 100644 index 0000000000000000000000000000000000000000..f95475faee5ca45e524ed414fae11fd26cb9419c --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/archive/classFnDef.txt @@ -0,0 +1,25 @@ +CntDegNodes template int CntDegNodes(const PGraph& Graph, const int& NodeDeg); +CntInDegNodes template int CntInDegNodes(const PGraph& Graph, const int& NodeInDeg); +CntOutDegNodes template int CntOutDegNodes(const PGraph& Graph, const int& NodeOutDeg); +CntNonZNodes template int CntNonZNodes(const PGraph& Graph); +GetDegCnt template void GetDegCnt(const PGraph& Graph, TIntPrV& DegToCntV); +GetDegCnt template void GetDegCnt(const PGraph& Graph, TFltPrV& DegToCntV); +GetInDegCnt template void GetInDegCnt(const PGraph& Graph, TIntPrV& DegToCntV); +GetInDegCnt template void GetInDegCnt(const PGraph& Graph, TFltPrV& DegToCntV); +GetOutDegCnt template void GetOutDegCnt(const PGraph& Graph, TIntPrV& DegToCntV); +GetOutDegCnt template void GetOutDegCnt(const PGraph& Graph, TFltPrV& DegToCntV); +GetMxDegNId template int GetMxDegNId(const PGraph& Graph); +GetMxInDegNId template int GetMxInDegNId(const PGraph& Graph); +GetMxOutDegNId template int GetMxOutDegNId(const PGraph& Graph); +GetNodeInDegV template void GetNodeInDegV(const PGraph& Graph, TIntPrV& NIdInDegV); +GetNodeOutDegV template void GetNodeOutDegV(const PGraph& Graph, TIntPrV& NIdOutDegV); +GetDegSeqV template void GetDegSeqV(const PGraph& Graph, TIntV& DegV); +GetDegSeqV template void GetDegSeqV(const PGraph& Graph, TIntV& InDegV, TIntV& OutDegV); +CntSelfEdges template int CntSelfEdges(const PGraph& Graph); +CntUniqBiDirEdges template int CntUniqBiDirEdges(const PGraph& Graph); +CntUniqDirEdges template int CntUniqDirEdges(const PGraph& Graph); +CntUniqUndirEdges template int CntUniqUndirEdges(const PGraph& Graph); +CntEdgesToSet template int CntEdgesToSet(const PGraph& Graph, const int& NId, const TIntSet& NodeSet); +IsTree template bool IsTree(const PGraph& Graph, int& RootNIdX); +IsTree template int GetTreeRootNId(const PGraph& Graph) { int RootNId; bool Tree; Tree = IsTree(Graph, RootNId); Assert(Tree); return RootNId; } +PrintInfo template void PrintInfo(const PGraph& Graph, const TStr& Desc="", const TStr& OutFNm="", const bool& Fast=true); diff --git a/snap-python/source/swig/gen/genClassFn/archive/classFnExt.txt b/snap-python/source/swig/gen/genClassFn/archive/classFnExt.txt new file mode 100644 index 0000000000000000000000000000000000000000..19bcb4502812e775e6e2f652c858ea32067454e1 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/archive/classFnExt.txt @@ -0,0 +1,225 @@ +%extend TUNGraph{ + int CntDegNodes(const int& NodeDeg){ + return TSnap::CntDegNodes(PUNGraph($self), NodeDeg); + } + int CntInDegNodes(const int& NodeInDeg){ + return TSnap::CntInDegNodes(PUNGraph($self), NodeInDeg); + } + int CntOutDegNodes(const int& NodeOutDeg){ + return TSnap::CntOutDegNodes(PUNGraph($self), NodeOutDeg); + } + int CntNonZNodes(){ + return TSnap::CntNonZNodes(PUNGraph($self)); + } + void GetDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetDegCnt(PUNGraph($self), DegToCntV); + } + void GetDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetDegCnt(PUNGraph($self), DegToCntV); + } + void GetInDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetInDegCnt(PUNGraph($self), DegToCntV); + } + void GetInDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetInDegCnt(PUNGraph($self), DegToCntV); + } + void GetOutDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetOutDegCnt(PUNGraph($self), DegToCntV); + } + void GetOutDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetOutDegCnt(PUNGraph($self), DegToCntV); + } + int GetMxDegNId(){ + return TSnap::GetMxDegNId(PUNGraph($self)); + } + int GetMxInDegNId(){ + return TSnap::GetMxInDegNId(PUNGraph($self)); + } + int GetMxOutDegNId(){ + return TSnap::GetMxOutDegNId(PUNGraph($self)); + } + void GetNodeInDegV(TIntPrV& NIdInDegV){ + return TSnap::GetNodeInDegV(PUNGraph($self), NIdInDegV); + } + void GetNodeOutDegV(TIntPrV& NIdOutDegV){ + return TSnap::GetNodeOutDegV(PUNGraph($self), NIdOutDegV); + } + void GetDegSeqV(TIntV& DegV){ + return TSnap::GetDegSeqV(PUNGraph($self), DegV); + } + void GetDegSeqV(TIntV& InDegV, TIntV& OutDegV){ + return TSnap::GetDegSeqV(PUNGraph($self), InDegV, OutDegV); + } + int CntSelfEdges(){ + return TSnap::CntSelfEdges(PUNGraph($self)); + } + int CntUniqBiDirEdges(){ + return TSnap::CntUniqBiDirEdges(PUNGraph($self)); + } + int CntUniqDirEdges(){ + return TSnap::CntUniqDirEdges(PUNGraph($self)); + } + int CntUniqUndirEdges(){ + return TSnap::CntUniqUndirEdges(PUNGraph($self)); + } + int CntEdgesToSet(const int& NId, const TIntSet& NodeSet){ + return TSnap::CntEdgesToSet(PUNGraph($self), NId, NodeSet); + } + bool IsTree(int& RootNIdX){ + return TSnap::IsTree(PUNGraph($self), RootNIdX); + } + void PrintInfo(const TStr& Desc="", const TStr& OutFNm="", const bool& Fast=true){ + return TSnap::PrintInfo(PUNGraph($self), Desc, OutFNm, Fast); + } +}; + +%extend TNGraph{ + int CntDegNodes(const int& NodeDeg){ + return TSnap::CntDegNodes(PNGraph($self), NodeDeg); + } + int CntInDegNodes(const int& NodeInDeg){ + return TSnap::CntInDegNodes(PNGraph($self), NodeInDeg); + } + int CntOutDegNodes(const int& NodeOutDeg){ + return TSnap::CntOutDegNodes(PNGraph($self), NodeOutDeg); + } + int CntNonZNodes(){ + return TSnap::CntNonZNodes(PNGraph($self)); + } + void GetDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetDegCnt(PNGraph($self), DegToCntV); + } + void GetDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetDegCnt(PNGraph($self), DegToCntV); + } + void GetInDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetInDegCnt(PNGraph($self), DegToCntV); + } + void GetInDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetInDegCnt(PNGraph($self), DegToCntV); + } + void GetOutDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetOutDegCnt(PNGraph($self), DegToCntV); + } + void GetOutDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetOutDegCnt(PNGraph($self), DegToCntV); + } + int GetMxDegNId(){ + return TSnap::GetMxDegNId(PNGraph($self)); + } + int GetMxInDegNId(){ + return TSnap::GetMxInDegNId(PNGraph($self)); + } + int GetMxOutDegNId(){ + return TSnap::GetMxOutDegNId(PNGraph($self)); + } + void GetNodeInDegV(TIntPrV& NIdInDegV){ + return TSnap::GetNodeInDegV(PNGraph($self), NIdInDegV); + } + void GetNodeOutDegV(TIntPrV& NIdOutDegV){ + return TSnap::GetNodeOutDegV(PNGraph($self), NIdOutDegV); + } + void GetDegSeqV(TIntV& DegV){ + return TSnap::GetDegSeqV(PNGraph($self), DegV); + } + void GetDegSeqV(TIntV& InDegV, TIntV& OutDegV){ + return TSnap::GetDegSeqV(PNGraph($self), InDegV, OutDegV); + } + int CntSelfEdges(){ + return TSnap::CntSelfEdges(PNGraph($self)); + } + int CntUniqBiDirEdges(){ + return TSnap::CntUniqBiDirEdges(PNGraph($self)); + } + int CntUniqDirEdges(){ + return TSnap::CntUniqDirEdges(PNGraph($self)); + } + int CntUniqUndirEdges(){ + return TSnap::CntUniqUndirEdges(PNGraph($self)); + } + int CntEdgesToSet(const int& NId, const TIntSet& NodeSet){ + return TSnap::CntEdgesToSet(PNGraph($self), NId, NodeSet); + } + bool IsTree(int& RootNIdX){ + return TSnap::IsTree(PNGraph($self), RootNIdX); + } + void PrintInfo(const TStr& Desc="", const TStr& OutFNm="", const bool& Fast=true){ + return TSnap::PrintInfo(PNGraph($self), Desc, OutFNm, Fast); + } +}; + +%extend TNEANet{ + int CntDegNodes(const int& NodeDeg){ + return TSnap::CntDegNodes(PNEANet($self), NodeDeg); + } + int CntInDegNodes(const int& NodeInDeg){ + return TSnap::CntInDegNodes(PNEANet($self), NodeInDeg); + } + int CntOutDegNodes(const int& NodeOutDeg){ + return TSnap::CntOutDegNodes(PNEANet($self), NodeOutDeg); + } + int CntNonZNodes(){ + return TSnap::CntNonZNodes(PNEANet($self)); + } + void GetDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetDegCnt(PNEANet($self), DegToCntV); + } + void GetDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetDegCnt(PNEANet($self), DegToCntV); + } + void GetInDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetInDegCnt(PNEANet($self), DegToCntV); + } + void GetInDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetInDegCnt(PNEANet($self), DegToCntV); + } + void GetOutDegCnt(TIntPrV& DegToCntV){ + return TSnap::GetOutDegCnt(PNEANet($self), DegToCntV); + } + void GetOutDegCnt(TFltPrV& DegToCntV){ + return TSnap::GetOutDegCnt(PNEANet($self), DegToCntV); + } + int GetMxDegNId(){ + return TSnap::GetMxDegNId(PNEANet($self)); + } + int GetMxInDegNId(){ + return TSnap::GetMxInDegNId(PNEANet($self)); + } + int GetMxOutDegNId(){ + return TSnap::GetMxOutDegNId(PNEANet($self)); + } + void GetNodeInDegV(TIntPrV& NIdInDegV){ + return TSnap::GetNodeInDegV(PNEANet($self), NIdInDegV); + } + void GetNodeOutDegV(TIntPrV& NIdOutDegV){ + return TSnap::GetNodeOutDegV(PNEANet($self), NIdOutDegV); + } + void GetDegSeqV(TIntV& DegV){ + return TSnap::GetDegSeqV(PNEANet($self), DegV); + } + void GetDegSeqV(TIntV& InDegV, TIntV& OutDegV){ + return TSnap::GetDegSeqV(PNEANet($self), InDegV, OutDegV); + } + int CntSelfEdges(){ + return TSnap::CntSelfEdges(PNEANet($self)); + } + int CntUniqBiDirEdges(){ + return TSnap::CntUniqBiDirEdges(PNEANet($self)); + } + int CntUniqDirEdges(){ + return TSnap::CntUniqDirEdges(PNEANet($self)); + } + int CntUniqUndirEdges(){ + return TSnap::CntUniqUndirEdges(PNEANet($self)); + } + int CntEdgesToSet(const int& NId, const TIntSet& NodeSet){ + return TSnap::CntEdgesToSet(PNEANet($self), NId, NodeSet); + } + bool IsTree(int& RootNIdX){ + return TSnap::IsTree(PNEANet($self), RootNIdX); + } + void PrintInfo(const TStr& Desc="", const TStr& OutFNm="", const bool& Fast=true){ + return TSnap::PrintInfo(PNEANet($self), Desc, OutFNm, Fast); + } +}; + diff --git a/snap-python/source/swig/gen/genClassFn/archive/genClassFnDef.sh b/snap-python/source/swig/gen/genClassFn/archive/genClassFnDef.sh new file mode 100644 index 0000000000000000000000000000000000000000..f46afc87432b4e23d27f21920618095c10782c9c --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/archive/genClassFnDef.sh @@ -0,0 +1,14 @@ +#!/bin/bash + +# Input: a list of function names, one on every line +# Output: the corresponding function headers defined in snap-core or snap-adv folders + +# Note: +# this script only works if the function headers are defined on one single line +# cound update this script if needed to catch cases where function headers are defined +# over multiple lines + +while read func; do + grep -h "template.*$func[ \t\n]*(" /home/albert/SNAP/snap/snap-core -r | sed "s/^/$func /" + grep -h "template.*$func[ \t\n]*(" /home/albert/SNAP/snap/snap-adv -r | sed "s/^/$func /" +done diff --git a/snap-python/source/swig/gen/genClassFn/archive/genClassFnExt.py b/snap-python/source/swig/gen/genClassFn/archive/genClassFnExt.py new file mode 100644 index 0000000000000000000000000000000000000000..ea76be93e4187d5e83ee06bb6e50fca18f7e3414 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/archive/genClassFnExt.py @@ -0,0 +1,82 @@ +# +# generate class function extensions for swig +# + +graphTypes = ['TUNGraph', 'TNGraph', 'TNEANet'] + +def removeFirstParam(funcDecl): + startParamIdx = funcDecl.find('(') + endParamIdx = funcDecl.find(')') + commaIdx = funcDecl.find(',') + if commaIdx != -1: + # If function has two or more parameters + newFuncDecl = funcDecl[:(startParamIdx + 1)] + funcDecl[commaIdx+1:].lstrip() + else: + # If function has only one parameter + newFuncDecl = funcDecl[:(startParamIdx + 1)] + funcDecl[endParamIdx:] + return newFuncDecl + +def stripTypes(decl): + returnStr = "" + currentArg = "" + for char in decl: + if char in (" ", "\t"): + currentArg = "" + elif char in (",",")"): + equalsIdx = currentArg.find("=") + if equalsIdx != -1: + currentArg = currentArg[:equalsIdx] + returnStr += currentArg + returnStr += (char + " ") + else: + currentArg += char + return returnStr.strip() + +def genFuncCall(funcDecl, funcName, graphType): + startParamIdx = funcDecl.find('(') + endParamIdx = funcDecl.find(')') + commaIdx = funcDecl.find(',') + + funcCall = funcName + if commaIdx != -1: + # If function has two or more parameters + funcCall += "(P" + graphType[1:] + "($self), " + stripTypes(funcDecl[commaIdx + 1:]) + else: + # If function has only one parameter + funcCall += "(P" + graphType[1:] + "($self))" + return funcCall + +def getFuncName(funcDecl): + startParamIdx = funcDecl.find('(') + s = funcDecl[:startParamIdx].strip() + last_space = max(s.rfind(' '), s.rfind('\t')) + name = s[last_space + 1:] + while not name[0].isalpha(): + name = name[1:] + return name + +for graphType in graphTypes: + print("%extend " + graphType + "{") + + with open('classFnDef.txt', 'r') as f: + for line in f: + funcName = line[:line.find(' ')] + funcHeader = line[(line.find(' ') + 1):].strip() + + startParamIdx = funcHeader.find('(') + endParamIdx = funcHeader.find(')') + startTemplateIdx = funcHeader.find('<') + endTemplateIdx = funcHeader.find('>') + + funcDecl = funcHeader[(endTemplateIdx + 1):(endParamIdx + 1)].strip() + name = getFuncName(funcDecl) + newFuncDecl = removeFirstParam(funcDecl).strip() + funcCall = genFuncCall(funcDecl, funcName, graphType).strip() + + if name == funcName: + print (" " + newFuncDecl + "{") + print (" " + "return TSnap::" + funcCall + ";") + print (" }") + + print ("};") + print() diff --git a/snap-python/source/swig/gen/genClassFn/classFn.txt b/snap-python/source/swig/gen/genClassFn/classFn.txt new file mode 100644 index 0000000000000000000000000000000000000000..391fb1e8ce7481d6d5d74fa73958333b18d66299 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/classFn.txt @@ -0,0 +1,130 @@ +CntDegNodes +CntInDegNodes +CntOutDegNodes +CntNonZNodes +GetDegCnt +GetInDegCnt +GetOutDegCnt +GetMxDegNId +GetMxInDegNId +GetMxOutDegNId +GetNodeInDegV +GetNodeOutDegV +GetDegSeqV +CntSelfEdges +CntUniqBiDirEdges +CntUniqDirEdges +CntUniqUndirEdges +CntEdgesToSet +AddSelfEdges +DelDegKNodes +DelNodes +DelSelfEdges +DelZeroDegNodes +GetUnDir +MakeUnDir +ConvertGraph +ConvertSubGraph +ConvertESubGraph +GetSubGraph +GetSubGraphRenumber +GetSubTreeSz +GetESubGraph +GetRndSubGraph +GetRndESubGraph +IsTree +PrintInfo +DrawGViz +DrawGVizColor +PlotSccDistr +PlotWccDistr +PlotClustCf +PlotInDegDistr +PlotOutDegDistr +PlotHops +PlotShortPathDistr +PlotEigValDistr +PlotEigValRank +PlotSngValDistr +PlotSngValRank +PlotSngVec +PlotInvParticipRat +PlotKCoreEdges +PlotKCoreNodes +GetSccs +GetSccSzCnt +GetWccs +GetWccSzCnt +GetMxBiCon +GetMxScc +GetMxSccSz +GetMxWcc +GetMxWccSz +IsConnected +IsWeaklyConn +GetNodeWcc +Get1CnCom +Get1CnComSzCnt +GetBiCon +GetBiConSzCnt +GetArtPoints +GetEdgeBridges +GetBfsFullDiam +GetBfsEffDiam +GetBfsEffDiamAll +GetNodesAtHop +GetNodesAtHops +GetShortPath +GetBfsTree +GetTreeRootNId +GetTreeSig +GetDegreeCentr +GetBetweennessCentr +GetClosenessCentr +GetFarnessCentr +GetPageRank +GetHits +GetNodeEcc +GetEigenVectorCentr +CommunityCNM +CommunityGirvanNewman +GetEdgesInOut +GetModularity +GetClustCf +GetClustCfAll +GetTriads +GetTriadsByNode +GetTriadsAll +GetCmnNbrs +GetNodeClustCf +GetNodeClustCfAll +GetNodeTriads +GetNodeTriadsSet +GetNodeTriadsAll +GetLen2Paths +GetTriadEdges +GetTriadParticip +GetKCore +GetKCoreNodes +GetKCoreEdges +GetAnf +GetAnfNode +GetAnfGraph +GetAnfEffDiam +GetEigVals +GetEigVec +GetEigVecs +GetLeadEigVec +GetSngVals +GetSngVec +GetSngVecs +GetLeadSngVec +GetInvParticipRat +GetShortPathAll +GenRewire +SaveEdgeList +SaveMatlabSparseMtx +SavePajek +SaveGViz +SaveGVizColor +DrawGViz \ No newline at end of file diff --git a/snap-python/source/swig/gen/genClassFn/genPyClassFn.py b/snap-python/source/swig/gen/genClassFn/genPyClassFn.py new file mode 100644 index 0000000000000000000000000000000000000000..c2567222982aa480e075fcd0b5a38ce84c9820b9 --- /dev/null +++ b/snap-python/source/swig/gen/genClassFn/genPyClassFn.py @@ -0,0 +1,14 @@ +# This script generates wrappers to enable Python class functions +# Command line input: file name containing the list of class functions to be added, one per line + +import sys + +graphTypes = ['PUNGraph', 'PNGraph', 'PNEANet'] +with open(sys.argv[1], 'r') as f: + for line in f: + funcName = line.strip() + print ("def " + funcName + "_classFn" + "(self, *args, **kwargs):") + print ("\t" + "return " + funcName + "(self, *args, **kwargs)") + for graphType in graphTypes: + print (graphType + "." + funcName + " = " + funcName + "_classFn") + print() diff --git a/snap-python/source/swig/gen/gendispatch.py b/snap-python/source/swig/gen/gendispatch.py new file mode 100644 index 0000000000000000000000000000000000000000..200cbfc9eb10ebea8d86f4834c94e5142dbfc58f --- /dev/null +++ b/snap-python/source/swig/gen/gendispatch.py @@ -0,0 +1,77 @@ +# +# generate dispatch tables for instantiated polymorphic SNAP templates +# input file format: +# + +import os +import sys + +f_header = "def %s(tspec, *args):" +f_consbody = " if tspec == %-8s: return %s_%s(*args)" +f_funcbody = " if type(tspec) == %-8s: return %s_%s(tspec, *args)" +f_end = " raise TypeError('First argument has invalid type')" + +def gendispatch(item, df): + flist = df[item]["cpp"] + + print f_header % (item) + for ftype in flist: + if df[item].has_key("type") and df[item]["type"] == "__cons__": + print f_consbody % (ftype, item, ftype) + else: + print f_funcbody % (ftype, item, ftype) + print f_end + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + df = {} + + ftname = sys.argv[1] + f = open(ftname, "r") + for nline in f: + line = nline.split("\n")[0] + w = line.split("\t") + + # skip empty lines, comments, malformed lines + if len(w) < 2 or len(w[0]) <= 0 or w[0] == "#": + continue + + ftype = w[0] + fname = w[1] + + if not df.has_key(fname): + df[fname] = {} + df[fname]["cpp"] = [] + df[fname]["type"] = ftype + + f.close() + + fdname = sys.argv[2] + f = open(fdname, "r") + for nline in f: + line = nline.split("\n")[0] + w = line.split("\t") + + # skip empty lines, comments, malformed lines + if len(w) < 2 or len(w[0]) <= 0 or w[0] == "#": + continue + + cpptype = w[0] + fname = w[1] + + if not df.has_key(fname): + df[fname] = {} + df[fname]["cpp"] = [] + + df[fname]["cpp"].append(cpptype) + + f.close() + + for item in df: + #print item, df[item] + gendispatch(item,df) + diff --git a/snap-python/source/swig/gen/gentypes.py b/snap-python/source/swig/gen/gentypes.py new file mode 100644 index 0000000000000000000000000000000000000000..e8a0e6ae63c7efcc06e004f7d6847e42ae71617e --- /dev/null +++ b/snap-python/source/swig/gen/gentypes.py @@ -0,0 +1,37 @@ +# +# generate tempaltes for SNAP typedefs +# input file format: ; +# + +import os +import sys + +if __name__ == '__main__': + + if len(sys.argv) < 2: + print "Usage: " + sys.argv[0] + " " + sys.exit(1) + + fname = sys.argv[1] + f = open(fname, "r") + for nline in f: + line = nline.split("\n")[0].strip() + print line + + # remove typedef + line1 = line.split(" ", 1)[1] + print line1 + # remove ';' + line2 = line1.replace(";","") + print line2 + # get definition, name + w = line2.rsplit(" ",1) + if len(w) < 2: + print "*** Error: incorrect line format: ", line + sys.exit(1) + tdef = w[0] + tname = w[1] + print "%%template(%s) %s;" % (tname, tdef) + + f.close() + diff --git a/snap-python/source/swig/gen/h.awk b/snap-python/source/swig/gen/h.awk new file mode 100644 index 0000000000000000000000000000000000000000..95cef096e9aac9a49bfb37f823481a5475649926 --- /dev/null +++ b/snap-python/source/swig/gen/h.awk @@ -0,0 +1,16 @@ + { + printf "%s.__getitem__ = getitem_hash\n", $1; + printf "%s.__setitem__ = setitem_has\n", $1; + printf "%s.__delitem__ = delitem_hash\n", $1; + printf "%s.__len__ = len_hash\n", $1; + printf "%s.__iter__ = iterhash\n", $1; + printf "%s.clear = clear_hash\n", $1; + printf "%s.copy = copy_hash\n", $1; + printf "%s.get = get_hash\n", $1; + printf "%s.items = items_hash\n", $1; + printf "%s.keys = keys_hash\n", $1; + printf "%s.pop = pop_hash\n", $1; + printf "%s.setdefault = setdefault_hash\n", $1; + printf "%s.update = update_hash\n", $1; + printf "%s.values = values_hash\n", $1; + } diff --git a/snap-python/source/swig/gen/hashes.txt b/snap-python/source/swig/gen/hashes.txt new file mode 100644 index 0000000000000000000000000000000000000000..72cb258c4e5fb0f4f3883f6f52b4113df3bf8d72 --- /dev/null +++ b/snap-python/source/swig/gen/hashes.txt @@ -0,0 +1,57 @@ +TIntH +TUInt64H +TIntBoolH +TIntIntH +TIntUInt64H +TIntIntVH +TIntIntHH +TIntFltH +TIntFltPrH +TIntFltTrH +TIntFltVH +TIntStrH +TIntStrVH +TIntIntPrH +TIntIntPrVH +TUInt64StrVH +TIntPrIntH +TIntPrIntVH +TIntPrIntPrVH +TIntTrIntH +TIntVIntH +TUIntH +TIntPrFltH +TIntTrFltH +TIntPrStrH +TIntPrStrVH +TIntStrPrIntH +TFltFltH +TStrH +TStrBoolH +TStrIntH +TStrIntPrH +TStrIntVH +TStrUInt64H +TStrUInt64VH +TStrIntPrVH +TStrFltH +TStrFltVH +TStrStrH +TStrStrPrH +TStrStrVH +TStrStrPrVH +TStrStrKdVH +TStrIntFltPrH +TStrStrIntPrVH +TStrStrIntKdVH +TStrPrBoolH +TStrPrIntH +TStrPrFltH +TStrPrStrH +TStrPrStrVH +TStrTrIntH +TStrIntPrIntH +TStrVH +TStrVIntVH +TStrVStrH +TStrVStrVH diff --git a/snap-python/source/swig/gen/types.txt b/snap-python/source/swig/gen/types.txt new file mode 100644 index 0000000000000000000000000000000000000000..db15aae568c7e10a5e17799a0c04217e00d39d83 --- /dev/null +++ b/snap-python/source/swig/gen/types.txt @@ -0,0 +1,127 @@ +# __cons__ constructors, +# the first parameter is a result type +# __func__ functions +# the first parameter is an object +# __conv__ conversions +# the first parameter is a result type, +# the second parameter is an input object +__cons__ LoadEdgeList +__cons__ LoadEdgeListStr +__cons__ LoadConnList +__cons__ LoadConnListStr +__cons__ LoadPajek +__func__ SaveEdgeList +__func__ SavePajek +__func__ SaveMatlabSparseMtx +__func__ SaveGViz +__func__ PrintGraphStatTable +__func__ MxSccSz +__func__ MxWccSz +__func__ GetNodeWcc +__func__ IsConnected +__func__ IsWeaklyConn +__func__ GetWccSzCnt +__func__ GetWccs +__func__ GetSccSzCnt +__func__ GetSccs +__func__ GetMxWccSz +__func__ GetMxSccSz +__func__ GetMxWcc +__func__ GetMxScc +__func__ GetMxBiCon +__func__ CntInDegNodes +__func__ CntOutDegNodes +__func__ CntDegNodes +__func__ CntNonZNodes +__func__ CntEdgesToSet +__func__ GetMxDegNId +__func__ GetMxInDegNId +__func__ GetMxOutDegNId +__func__ GetInDegCnt +__func__ GetOutDegCnt +__func__ GetDegCnt +__func__ GetDegSeqV +__func__ GetNodeInDegV +__func__ GetNodeOutDegV +__func__ CntUniqUndirEdges +__func__ CntUniqDirEdges +__func__ CntUniqBiDirEdges +__func__ CntSelfEdges +__func__ GetUnDir +__func__ MakeUnDir +__func__ AddSelfEdges +__func__ DelSelfEdges +__func__ DelNodes +__func__ DelZeroDegNodes +__func__ DelDegKNodes +__func__ IsTree +__func__ GetTreeRootNId +__func__ GetTreeSig +__func__ GetBfsTree +__func__ GetSubTreeSz +__func__ GetNodesAtHop +__func__ GetNodesAtHops +__func__ GetShortPath +__func__ GetBfsFullDiam +__func__ GetBfsEffDiam +__func__ GetBfsEffDiamAll +__func__ DrawGViz +__cons__ GenGrid +__cons__ GenStar +__cons__ GenCircle +__cons__ GenFull +__cons__ GenTree +__cons__ GenBaraHierar +__cons__ GenRndGnm +__func__ GetClustCf +__func__ GetClustCfAll +__func__ GetNodeClustCf +__func__ GetTriads +__func__ GetTriadsAll +__func__ GetTriadEdges +__func__ GetNodeTriads +__func__ GetNodeTriadsAll +__func__ GetTriadParticip +__func__ GetCmnNbrs +__func__ GetLen2Paths +__func__ GetModularity +__func__ GetEdgesInOut +__func__ GetAnf +__func__ GetAnfEffDiam +__func__ TestAnf +__func__ PercentDegree +__func__ NodesGTEDegree +__func__ MxDegree +__func__ PercentMxWcc +__func__ PercentMxScc +__func__ GetKCore +__func__ GetKCoreNodes +__func__ GetKCoreEdges +__func__ PrintInfo +__func__ GetNodeEcc +__func__ GetPageRank +__func__ GetHits +__func__ PlotInDegDistr +__func__ PlotOutDegDistr +__func__ PlotWccDistr +__func__ PlotSccDistr +__func__ PlotClustCf +__func__ PlotHops +__func__ PlotShortPathDistr +__func__ PlotKCoreNodes +__func__ PlotKCoreEdges +__func__ GetSubGraph +__func__ GetSubGraphRenumber +__func__ GetESubGraph +__func__ GetRndSubGraph +__func__ GetRndESubGraph +__func__ GetTriangleCnt +__func__ GetBetweennessCentr +__func__ GetClosenessCentr +__func__ GetFarnessCentr +__func__ GetEgonetHop +__func__ GetInEgonetHop +__func__ GetOutEgonetHop +__func__ GetInEgonetSub +__func__ GetGraphUnion +__func__ GetGraphIntersection diff --git a/snap-python/source/swig/gen/v.awk b/snap-python/source/swig/gen/v.awk new file mode 100644 index 0000000000000000000000000000000000000000..3ad5f97e1cc0de9900e313d6ada007840314151b --- /dev/null +++ b/snap-python/source/swig/gen/v.awk @@ -0,0 +1,18 @@ + { + printf "%s.__getitem__ = getitem\n", $1; + printf "%s.__setitem__ = setitem\n", $1; + printf "%s.__delitem__ = delitem\n", $1; + printf "%s.__len__ = len_vec\n", $1; + printf "%s.__iter__ = itervec\n", $1; + printf "%s.append = append_vec\n", $1; + printf "%s.clear = clear_vec\n", $1; + printf "%s.copy = copy_vec\n", $1; + printf "%s.count = count_vec\n", $1; + printf "%s.extend = extend_vec\n", $1; + printf "%s.index = index_vec\n", $1; + printf "%s.insert = insert_vec\n", $1; + printf "%s.pop = pop_vec\n", $1; + printf "%s.remove = remove_vec\n", $1; + printf "%s.reverse = reverse_vec\n", $1; + printf "%s.sort = sort_vec\n", $1; + } diff --git a/snap-python/source/swig/gen/vectors.txt b/snap-python/source/swig/gen/vectors.txt new file mode 100644 index 0000000000000000000000000000000000000000..9c72a10ae5b95735fdd6eccaf8552787b5274e0b --- /dev/null +++ b/snap-python/source/swig/gen/vectors.txt @@ -0,0 +1,91 @@ +TBoolV +TChV +TUChV +TUIntV +TIntV +TUInt64V +TFltV +TSFltV +TAscFltV +TStrV +TChAV +TIntPrV +TIntTrV +TIntQuV +TFltPrV +TFltTrV +TIntKdV +TUChIntPrV +TUChUInt64PrV +TIntUInt64PrV +TIntUInt64KdV +TIntFltPrV +TIntFltPrKdV +TFltIntPrV +TFltUInt64PrV +TFltStrPrV +TAscFltStrPrV +TIntStrPrV +TIntIntStrTrV +TIntIntFltTrV +TIntFltIntTrV +TIntStrIntTrV +TUIntIntKdV +TIntFltKdV +TIntPrFltKdV +TIntStrKdV +TIntStrPrPrV +TIntStrVPrV +TIntIntVIntTrV +TIntIntIntVTrV +TUInt64IntPrV +TUInt64FltPrV +TUInt64StrPrV +TUInt64IntKdV +TUInt64FltKdV +TUInt64StrKdV +TFltBoolKdV +TFltIntKdV +TFltUInt64KdV +TFltIntPrKdV +TFltKdV +TFltStrKdV +TFltStrPrPrV +TFltIntIntTrV +TFltFltStrTrV +TAscFltIntPrV +TAscFltIntKdV +TStrPrV +TStrIntPrV +TStrFltPrV +TStrIntKdV +TStrFltKdV +TStrAscFltKdV +TStrTrV +TStrQuV +TStrFltFltTrV +TStrStrIntTrV +TStrKdV +TStrStrVPrV +TStrVIntPrV +TFltIntIntIntQuV +TIntStrIntIntQuV +TIntIntPrPrV +PFltV +PAscFltV +PStrV +TBoolVV +TChVV +TIntVV +TSFltVV +TFltVV +TStrVV +TIntPrVV +TIntVVV +TIntIntVV +TFltVVV +TFltVFltV +PNEANetV +Schema +TCnCom +TCnComV diff --git a/snap-python/source/swig/goodgraph.cpp b/snap-python/source/swig/goodgraph.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1e5c0a43cc8e1a3dc19c70c7cbb23fd422e5696b --- /dev/null +++ b/snap-python/source/swig/goodgraph.cpp @@ -0,0 +1,74 @@ +#include "Snap.h" + +// TODO: move declarations to goodgraph.h +// RS 2013/08/19, this code should go to snap-core + +using namespace TSnap; + +typedef TVec TIntV; +typedef TVec TIntIntVV; + +TUNGraph TPrGraph(PUNGraph G) { + return *G; +}; + +//int accept_array(int array[]) { +// +// for (int i=0; i < 10; i++) +// printf("array[%d] = %d\n", i, array[i]); +// +// return 0; +//} + +template +double PercentDegree(const PGraph& Graph, const int Threshold=0) { + + int Cnt = 0; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) + { + if (NI.GetDeg() >= Threshold) Cnt++; + } + + return (double)Cnt / (double) Graph->GetNodes(); +} + +template +int NodesGTEDegree(const PGraph& Graph, const int Threshold=0) { + + int Cnt = 0; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); + NI++) + { + if (NI.GetDeg() >= Threshold) Cnt++; + } + + return Cnt; +} + +template +int MxDegree(const PGraph& Graph) { + + int MaxDeg = 0; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { + if (NI.GetDeg() > MaxDeg) { + MaxDeg = NI.GetDeg(); + } + } + + return MaxDeg; +} + +template +double PercentMxWcc(const PGraph& Graph) { + + return GetMxWccSz(Graph); +} + +template +double PercentMxScc(const PGraph& Graph) { + + PGraph MxSccSz = GetMxScc(Graph); + + return (double) MxSccSz->GetNodes() / (double) Graph->GetNodes(); +} + diff --git a/snap-python/source/swig/install_name_tool b/snap-python/source/swig/install_name_tool new file mode 100644 index 0000000000000000000000000000000000000000..a0fe97f2828a1064ace0e4c65b36a1274e89c24b Binary files /dev/null and b/snap-python/source/swig/install_name_tool differ diff --git a/snap-python/source/swig/linkpred_swig.h b/snap-python/source/swig/linkpred_swig.h new file mode 100644 index 0000000000000000000000000000000000000000..5c00d9ea6b51cce561a5010495f343164e334492 --- /dev/null +++ b/snap-python/source/swig/linkpred_swig.h @@ -0,0 +1,30 @@ + +// random walk with restars to node JumpNId +template +void GetRndWalkRestart(const PGraph& Graph, const double& JumpProb, const int& JumpNId, THash& RwrNIdH) { + const double DefVal = 1.0/Graph->GetNodes(); + RwrNIdH.Clr(false); + TIntH NIdOutDegH; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { + RwrNIdH.AddDat(NI.GetId(), DefVal); + NIdOutDegH.AddDat(NI.GetId(), NI.GetOutDeg()); + } + THash RwrNIdH2(Graph->GetNodes()); + for (int iter = 0; iter < 10; iter++) { + double Sum = 0; + for (typename PGraph::TObj::TNodeI NI = Graph->BegNI(); NI < Graph->EndNI(); NI++) { + double Val = 0; + for (int i = 0; i < NI.GetInDeg(); i++) { + const int InId = NI.GetInNId(i); + Val += (1.0-JumpProb) * 1.0/(NIdOutDegH.GetDat(InId)) * RwrNIdH.GetDat(InId); + } + if (NI.GetId() == JumpNId) { Val+= JumpProb; } + RwrNIdH.AddDat(NI.GetId(), Val); + Sum += Val; + } + for (int i = 0; i < RwrNIdH.Len(); i++) { + RwrNIdH[i] /= Sum; + } + } +} + diff --git a/snap-python/source/swig/numpy.i b/snap-python/source/swig/numpy.i new file mode 100644 index 0000000000000000000000000000000000000000..f2714cc34613afbddd2ecbd5c5f1e911cd8df52e --- /dev/null +++ b/snap-python/source/swig/numpy.i @@ -0,0 +1,3085 @@ +/* -*- C -*- (not really, but good for syntax highlighting) */ +#ifdef SWIGPYTHON + +%{ +#ifndef SWIG_FILE_WITH_INIT +#define NO_IMPORT_ARRAY +#endif +#include "stdio.h" +#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION +#include +%} + +/**********************************************************************/ + +%fragment("NumPy_Backward_Compatibility", "header") +{ +%#if NPY_API_VERSION < 0x00000007 +%#define NPY_ARRAY_DEFAULT NPY_DEFAULT +%#define NPY_ARRAY_FARRAY NPY_FARRAY +%#define NPY_FORTRANORDER NPY_FORTRAN +%#endif +} + +/**********************************************************************/ + +/* The following code originally appeared in + * enthought/kiva/agg/src/numeric.i written by Eric Jones. It was + * translated from C++ to C by John Hunter. Bill Spotz has modified + * it to fix some minor bugs, upgrade from Numeric to numpy (all + * versions), add some comments and functionality, and convert from + * direct code insertion to SWIG fragments. + */ + +%fragment("NumPy_Macros", "header") +{ +/* Macros to extract array attributes. + */ +%#if NPY_API_VERSION < 0x00000007 +%#define is_array(a) ((a) && PyArray_Check((PyArrayObject*)a)) +%#define array_type(a) (int)(PyArray_TYPE((PyArrayObject*)a)) +%#define array_numdims(a) (((PyArrayObject*)a)->nd) +%#define array_dimensions(a) (((PyArrayObject*)a)->dimensions) +%#define array_size(a,i) (((PyArrayObject*)a)->dimensions[i]) +%#define array_strides(a) (((PyArrayObject*)a)->strides) +%#define array_stride(a,i) (((PyArrayObject*)a)->strides[i]) +%#define array_data(a) (((PyArrayObject*)a)->data) +%#define array_descr(a) (((PyArrayObject*)a)->descr) +%#define array_flags(a) (((PyArrayObject*)a)->flags) +%#define array_enableflags(a,f) (((PyArrayObject*)a)->flags) = f +%#else +%#define is_array(a) ((a) && PyArray_Check(a)) +%#define array_type(a) PyArray_TYPE((PyArrayObject*)a) +%#define array_numdims(a) PyArray_NDIM((PyArrayObject*)a) +%#define array_dimensions(a) PyArray_DIMS((PyArrayObject*)a) +%#define array_strides(a) PyArray_STRIDES((PyArrayObject*)a) +%#define array_stride(a,i) PyArray_STRIDE((PyArrayObject*)a,i) +%#define array_size(a,i) PyArray_DIM((PyArrayObject*)a,i) +%#define array_data(a) PyArray_DATA((PyArrayObject*)a) +%#define array_descr(a) PyArray_DESCR((PyArrayObject*)a) +%#define array_flags(a) PyArray_FLAGS((PyArrayObject*)a) +%#define array_enableflags(a,f) PyArray_ENABLEFLAGS((PyArrayObject*)a,f) +%#endif +%#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS((PyArrayObject*)a)) +%#define array_is_native(a) (PyArray_ISNOTSWAPPED((PyArrayObject*)a)) +%#define array_is_fortran(a) (PyArray_ISFORTRAN((PyArrayObject*)a)) +} + +/**********************************************************************/ + +%fragment("NumPy_Utilities", + "header") +{ + /* Given a PyObject, return a string describing its type. + */ + const char* pytype_string(PyObject* py_obj) + { + if (py_obj == NULL ) return "C NULL value"; + if (py_obj == Py_None ) return "Python None" ; + if (PyCallable_Check(py_obj)) return "callable" ; + if (PyString_Check( py_obj)) return "string" ; + if (PyInt_Check( py_obj)) return "int" ; + if (PyFloat_Check( py_obj)) return "float" ; + if (PyDict_Check( py_obj)) return "dict" ; + if (PyList_Check( py_obj)) return "list" ; + if (PyTuple_Check( py_obj)) return "tuple" ; +%#if PY_MAJOR_VERSION < 3 + if (PyFile_Check( py_obj)) return "file" ; + if (PyModule_Check( py_obj)) return "module" ; + if (PyInstance_Check(py_obj)) return "instance" ; +%#endif + + return "unkown type"; + } + + /* Given a NumPy typecode, return a string describing the type. + */ + const char* typecode_string(int typecode) + { + static const char* type_names[25] = {"bool", + "byte", + "unsigned byte", + "short", + "unsigned short", + "int", + "unsigned int", + "long", + "unsigned long", + "long long", + "unsigned long long", + "float", + "double", + "long double", + "complex float", + "complex double", + "complex long double", + "object", + "string", + "unicode", + "void", + "ntypes", + "notype", + "char", + "unknown"}; + return typecode < 24 ? type_names[typecode] : type_names[24]; + } + + /* Make sure input has correct numpy type. This now just calls + PyArray_EquivTypenums(). + */ + int type_match(int actual_type, + int desired_type) + { + return PyArray_EquivTypenums(actual_type, desired_type); + } + +%#ifdef SWIGPY_USE_CAPSULE + void free_cap(PyObject * cap) + { + void* array = (void*) PyCapsule_GetPointer(cap,SWIGPY_CAPSULE_NAME); + if (array != NULL) free(array); + } +%#endif + + +} + +/**********************************************************************/ + +%fragment("NumPy_Object_to_Array", + "header", + fragment="NumPy_Backward_Compatibility", + fragment="NumPy_Macros", + fragment="NumPy_Utilities") +{ + /* Given a PyObject pointer, cast it to a PyArrayObject pointer if + * legal. If not, set the python error string appropriately and + * return NULL. + */ + PyArrayObject* obj_to_array_no_conversion(PyObject* input, + int typecode) + { + PyArrayObject* ary = NULL; + if (is_array(input) && (typecode == NPY_NOTYPE || + PyArray_EquivTypenums(array_type(input), typecode))) + { + ary = (PyArrayObject*) input; + } + else if is_array(input) + { + const char* desired_type = typecode_string(typecode); + const char* actual_type = typecode_string(array_type(input)); + PyErr_Format(PyExc_TypeError, + "Array of type '%s' required. Array of type '%s' given", + desired_type, actual_type); + ary = NULL; + } + else + { + const char* desired_type = typecode_string(typecode); + const char* actual_type = pytype_string(input); + PyErr_Format(PyExc_TypeError, + "Array of type '%s' required. A '%s' was given", + desired_type, + actual_type); + ary = NULL; + } + return ary; + } + + /* Convert the given PyObject to a NumPy array with the given + * typecode. On success, return a valid PyArrayObject* with the + * correct type. On failure, the python error string will be set and + * the routine returns NULL. + */ + PyArrayObject* obj_to_array_allow_conversion(PyObject* input, + int typecode, + int* is_new_object) + { + PyArrayObject* ary = NULL; + PyObject* py_obj; + if (is_array(input) && (typecode == NPY_NOTYPE || + PyArray_EquivTypenums(array_type(input),typecode))) + { + ary = (PyArrayObject*) input; + *is_new_object = 0; + } + else + { + py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_ARRAY_DEFAULT); + /* If NULL, PyArray_FromObject will have set python error value.*/ + ary = (PyArrayObject*) py_obj; + *is_new_object = 1; + } + return ary; + } + + /* Given a PyArrayObject, check to see if it is contiguous. If so, + * return the input pointer and flag it as not a new object. If it is + * not contiguous, create a new PyArrayObject using the original data, + * flag it as a new object and return the pointer. + */ + PyArrayObject* make_contiguous(PyArrayObject* ary, + int* is_new_object, + int min_dims, + int max_dims) + { + PyArrayObject* result; + if (array_is_contiguous(ary)) + { + result = ary; + *is_new_object = 0; + } + else + { + result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary, + array_type(ary), + min_dims, + max_dims); + *is_new_object = 1; + } + return result; + } + + /* Given a PyArrayObject, check to see if it is Fortran-contiguous. + * If so, return the input pointer, but do not flag it as not a new + * object. If it is not Fortran-contiguous, create a new + * PyArrayObject using the original data, flag it as a new object + * and return the pointer. + */ + PyArrayObject* make_fortran(PyArrayObject* ary, + int* is_new_object) + { + PyArrayObject* result; + if (array_is_fortran(ary)) + { + result = ary; + *is_new_object = 0; + } + else + { + Py_INCREF(array_descr(ary)); + result = (PyArrayObject*) PyArray_FromArray(ary, + array_descr(ary), + NPY_FORTRANORDER); + *is_new_object = 1; + } + return result; + } + + /* Convert a given PyObject to a contiguous PyArrayObject of the + * specified type. If the input object is not a contiguous + * PyArrayObject, a new one will be created and the new object flag + * will be set. + */ + PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input, + int typecode, + int* is_new_object) + { + int is_new1 = 0; + int is_new2 = 0; + PyArrayObject* ary2; + PyArrayObject* ary1 = obj_to_array_allow_conversion(input, + typecode, + &is_new1); + if (ary1) + { + ary2 = make_contiguous(ary1, &is_new2, 0, 0); + if ( is_new1 && is_new2) + { + Py_DECREF(ary1); + } + ary1 = ary2; + } + *is_new_object = is_new1 || is_new2; + return ary1; + } + + /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the + * specified type. If the input object is not a Fortran-ordered + * PyArrayObject, a new one will be created and the new object flag + * will be set. + */ + PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input, + int typecode, + int* is_new_object) + { + int is_new1 = 0; + int is_new2 = 0; + PyArrayObject* ary2; + PyArrayObject* ary1 = obj_to_array_allow_conversion(input, + typecode, + &is_new1); + if (ary1) + { + ary2 = make_fortran(ary1, &is_new2); + if (is_new1 && is_new2) + { + Py_DECREF(ary1); + } + ary1 = ary2; + } + *is_new_object = is_new1 || is_new2; + return ary1; + } +} /* end fragment */ + +/**********************************************************************/ + +%fragment("NumPy_Array_Requirements", + "header", + fragment="NumPy_Backward_Compatibility", + fragment="NumPy_Macros") +{ + /* Test whether a python object is contiguous. If array is + * contiguous, return 1. Otherwise, set the python error string and + * return 0. + */ + int require_contiguous(PyArrayObject* ary) + { + int contiguous = 1; + if (!array_is_contiguous(ary)) + { + PyErr_SetString(PyExc_TypeError, + "Array must be contiguous. A non-contiguous array was given"); + contiguous = 0; + } + return contiguous; + } + + /* Require that a numpy array is not byte-swapped. If the array is + * not byte-swapped, return 1. Otherwise, set the python error string + * and return 0. + */ + int require_native(PyArrayObject* ary) + { + int native = 1; + if (!array_is_native(ary)) + { + PyErr_SetString(PyExc_TypeError, + "Array must have native byteorder. " + "A byte-swapped array was given"); + native = 0; + } + return native; + } + + /* Require the given PyArrayObject to have a specified number of + * dimensions. If the array has the specified number of dimensions, + * return 1. Otherwise, set the python error string and return 0. + */ + int require_dimensions(PyArrayObject* ary, + int exact_dimensions) + { + int success = 1; + if (array_numdims(ary) != exact_dimensions) + { + PyErr_Format(PyExc_TypeError, + "Array must have %d dimensions. Given array has %d dimensions", + exact_dimensions, + array_numdims(ary)); + success = 0; + } + return success; + } + + /* Require the given PyArrayObject to have one of a list of specified + * number of dimensions. If the array has one of the specified number + * of dimensions, return 1. Otherwise, set the python error string + * and return 0. + */ + int require_dimensions_n(PyArrayObject* ary, + int* exact_dimensions, + int n) + { + int success = 0; + int i; + char dims_str[255] = ""; + char s[255]; + for (i = 0; i < n && !success; i++) + { + if (array_numdims(ary) == exact_dimensions[i]) + { + success = 1; + } + } + if (!success) + { + for (i = 0; i < n-1; i++) + { + sprintf(s, "%d, ", exact_dimensions[i]); + strcat(dims_str,s); + } + sprintf(s, " or %d", exact_dimensions[n-1]); + strcat(dims_str,s); + PyErr_Format(PyExc_TypeError, + "Array must have %s dimensions. Given array has %d dimensions", + dims_str, + array_numdims(ary)); + } + return success; + } + + /* Require the given PyArrayObject to have a specified shape. If the + * array has the specified shape, return 1. Otherwise, set the python + * error string and return 0. + */ + int require_size(PyArrayObject* ary, + npy_intp* size, + int n) + { + int i; + int success = 1; + int len; + char desired_dims[255] = "["; + char s[255]; + char actual_dims[255] = "["; + for(i=0; i < n;i++) + { + if (size[i] != -1 && size[i] != array_size(ary,i)) + { + success = 0; + } + } + if (!success) + { + for (i = 0; i < n; i++) + { + if (size[i] == -1) + { + sprintf(s, "*,"); + } + else + { + sprintf(s, "%ld,", (long int)size[i]); + } + strcat(desired_dims,s); + } + len = strlen(desired_dims); + desired_dims[len-1] = ']'; + for (i = 0; i < n; i++) + { + sprintf(s, "%ld,", (long int)array_size(ary,i)); + strcat(actual_dims,s); + } + len = strlen(actual_dims); + actual_dims[len-1] = ']'; + PyErr_Format(PyExc_TypeError, + "Array must have shape of %s. Given array has shape of %s", + desired_dims, + actual_dims); + } + return success; + } + + /* Require the given PyArrayObject to to be Fortran ordered. If the + * the PyArrayObject is already Fortran ordered, do nothing. Else, + * set the Fortran ordering flag and recompute the strides. + */ + int require_fortran(PyArrayObject* ary) + { + int success = 1; + int nd = array_numdims(ary); + int i; + npy_intp * strides = array_strides(ary); + if (array_is_fortran(ary)) return success; + /* Set the Fortran ordered flag */ + array_enableflags(ary,NPY_ARRAY_FARRAY); + /* Recompute the strides */ + strides[0] = strides[nd-1]; + for (i=1; i < nd; ++i) + strides[i] = strides[i-1] * array_size(ary,i-1); + return success; + } +} + +/* Combine all NumPy fragments into one for convenience */ +%fragment("NumPy_Fragments", + "header", + fragment="NumPy_Backward_Compatibility", + fragment="NumPy_Macros", + fragment="NumPy_Utilities", + fragment="NumPy_Object_to_Array", + fragment="NumPy_Array_Requirements") +{ +} + +/* End John Hunter translation (with modifications by Bill Spotz) + */ + +/* %numpy_typemaps() macro + * + * This macro defines a family of 74 typemaps that allow C arguments + * of the form + * + * 1. (DATA_TYPE IN_ARRAY1[ANY]) + * 2. (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) + * 3. (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) + * + * 4. (DATA_TYPE IN_ARRAY2[ANY][ANY]) + * 5. (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + * 6. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) + * 7. (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + * 8. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) + * + * 9. (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) + * 10. (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + * 11. (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + * 12. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) + * 13. (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + * 14. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) + * + * 15. (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) + * 16. (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + * 17. (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + * 18. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, , DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) + * 19. (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + * 20. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) + * + * 21. (DATA_TYPE INPLACE_ARRAY1[ANY]) + * 22. (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) + * 23. (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) + * + * 24. (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) + * 25. (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + * 26. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) + * 27. (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + * 28. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) + * + * 29. (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) + * 30. (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + * 31. (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + * 32. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) + * 33. (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + * 34. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) + * + * 35. (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) + * 36. (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + * 37. (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + * 38. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) + * 39. (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + * 40. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) + * + * 41. (DATA_TYPE ARGOUT_ARRAY1[ANY]) + * 42. (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) + * 43. (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) + * + * 44. (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) + * + * 45. (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) + * + * 46. (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) + * + * 47. (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) + * 48. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) + * + * 49. (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + * 50. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) + * 51. (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + * 52. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) + * + * 53. (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) + * 54. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) + * 55. (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) + * 56. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) + * + * 57. (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) + * 58. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4) + * 59. (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) + * 60. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4) + * + * 61. (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) + * 62. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) + * + * 63. (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + * 64. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) + * 65. (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + * 66. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) + * + * 67. (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) + * 68. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3) + * 69. (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) + * 70. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3) + * + * 71. (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) + * 72. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) + * 73. (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) + * 74. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) + * + * where "DATA_TYPE" is any type supported by the NumPy module, and + * "DIM_TYPE" is any int-like type suitable for specifying dimensions. + * The difference between "ARRAY" typemaps and "FARRAY" typemaps is + * that the "FARRAY" typemaps expect Fortran ordering of + * multidimensional arrays. In python, the dimensions will not need + * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1" + * typemaps). The IN_ARRAYs can be a numpy array or any sequence that + * can be converted to a numpy array of the specified type. The + * INPLACE_ARRAYs must be numpy arrays of the appropriate type. The + * ARGOUT_ARRAYs will be returned as new numpy arrays of the + * appropriate type. + * + * These typemaps can be applied to existing functions using the + * %apply directive. For example: + * + * %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)}; + * double prod(double* series, int length); + * + * %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2) + * {(int rows, int cols, double* matrix )}; + * void floor(int rows, int cols, double* matrix, double f); + * + * %apply (double IN_ARRAY3[ANY][ANY][ANY]) + * {(double tensor[2][2][2] )}; + * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) + * {(double low[2][2][2] )}; + * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) + * {(double upp[2][2][2] )}; + * void luSplit(double tensor[2][2][2], + * double low[2][2][2], + * double upp[2][2][2] ); + * + * or directly with + * + * double prod(double* IN_ARRAY1, int DIM1); + * + * void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f); + * + * void luSplit(double IN_ARRAY3[ANY][ANY][ANY], + * double ARGOUT_ARRAY3[ANY][ANY][ANY], + * double ARGOUT_ARRAY3[ANY][ANY][ANY]); + */ + +%define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE) + +/************************/ +/* Input Array Typemaps */ +/************************/ + +/* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE IN_ARRAY1[ANY]) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE IN_ARRAY1[ANY]) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[1] = { $1_dim0 }; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 1) || + !require_size(array, size, 1)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(freearg) + (DATA_TYPE IN_ARRAY1[ANY]) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[1] = { -1 }; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 1) || + !require_size(array, size, 1)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); +} +%typemap(freearg) + (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[1] = {-1}; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 1) || + !require_size(array, size, 1)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DATA_TYPE*) array_data(array); +} +%typemap(freearg) + (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE IN_ARRAY2[ANY][ANY]) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE IN_ARRAY2[ANY][ANY]) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[2] = { $1_dim0, $1_dim1 }; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 2) || + !require_size(array, size, 2)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(freearg) + (DATA_TYPE IN_ARRAY2[ANY][ANY]) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[2] = { -1, -1 }; + array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 2) || + !require_size(array, size, 2)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); +} +%typemap(freearg) + (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[2] = { -1, -1 }; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 2) || + !require_size(array, size, 2)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DATA_TYPE*) array_data(array); +} +%typemap(freearg) + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[2] = { -1, -1 }; + array = obj_to_array_fortran_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 2) || + !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); +} +%typemap(freearg) + (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[2] = { -1, -1 }; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 2) || + !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DATA_TYPE*) array_data(array); +} +%typemap(freearg) + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 3) || + !require_size(array, size, 3)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(freearg) + (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[3] = { -1, -1, -1 }; + array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 3) || + !require_size(array, size, 3)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); +} +%typemap(freearg) + (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + /* for now, only concerned with lists */ + $1 = PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL) +{ + npy_intp size[2] = { -1, -1 }; + PyArrayObject* temp_array; + Py_ssize_t i; + int is_new_object; + + /* length of the list */ + $2 = PyList_Size($input); + + /* the arrays */ + array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); + object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); + is_new_object_array = (int *)calloc($2,sizeof(int)); + + if (array == NULL || object_array == NULL || is_new_object_array == NULL) + { + SWIG_fail; + } + + for (i=0; i<$2; i++) + { + temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object); + + /* the new array must be stored so that it can be destroyed in freearg */ + object_array[i] = temp_array; + is_new_object_array[i] = is_new_object; + + if (!temp_array || !require_dimensions(temp_array, 2)) SWIG_fail; + + /* store the size of the first array in the list, then use that for comparison. */ + if (i == 0) + { + size[0] = array_size(temp_array,0); + size[1] = array_size(temp_array,1); + } + + if (!require_size(temp_array, size, 2)) SWIG_fail; + + array[i] = (DATA_TYPE*) array_data(temp_array); + } + + $1 = (DATA_TYPE**) array; + $3 = (DIM_TYPE) size[0]; + $4 = (DIM_TYPE) size[1]; +} +%typemap(freearg) + (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + Py_ssize_t i; + + if (array$argnum!=NULL) free(array$argnum); + + /*freeing the individual arrays if needed */ + if (object_array$argnum!=NULL) + { + if (is_new_object_array$argnum!=NULL) + { + for (i=0; i<$2; i++) + { + if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i]) + { Py_DECREF(object_array$argnum[i]); } + } + free(is_new_object_array$argnum); + } + free(object_array$argnum); + } +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, + * DATA_TYPE* IN_ARRAY3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[3] = { -1, -1, -1 }; + array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 3) || + !require_size(array, size, 3)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DATA_TYPE*) array_data(array); +} +%typemap(freearg) + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[3] = { -1, -1, -1 }; + array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 3) || + !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); +} +%typemap(freearg) + (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, + * DATA_TYPE* IN_FARRAY3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[3] = { -1, -1, -1 }; + array = obj_to_array_contiguous_allow_conversion($input, + DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 3) || + !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DATA_TYPE*) array_data(array); +} +%typemap(freearg) + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3}; + array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 4) || + !require_size(array, size, 4)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(freearg) + (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3, DIM_TYPE DIM4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[4] = { -1, -1, -1, -1 }; + array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 4) || + !require_size(array, size, 4)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); + $5 = (DIM_TYPE) array_size(array,3); +} +%typemap(freearg) + (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3, DIM_TYPE DIM4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + /* for now, only concerned with lists */ + $1 = PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL) +{ + npy_intp size[3] = { -1, -1, -1 }; + PyArrayObject* temp_array; + Py_ssize_t i; + int is_new_object; + + /* length of the list */ + $2 = PyList_Size($input); + + /* the arrays */ + array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); + object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); + is_new_object_array = (int *)calloc($2,sizeof(int)); + + if (array == NULL || object_array == NULL || is_new_object_array == NULL) + { + SWIG_fail; + } + + for (i=0; i<$2; i++) + { + temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object); + + /* the new array must be stored so that it can be destroyed in freearg */ + object_array[i] = temp_array; + is_new_object_array[i] = is_new_object; + + if (!temp_array || !require_dimensions(temp_array, 3)) SWIG_fail; + + /* store the size of the first array in the list, then use that for comparison. */ + if (i == 0) + { + size[0] = array_size(temp_array,0); + size[1] = array_size(temp_array,1); + size[2] = array_size(temp_array,2); + } + + if (!require_size(temp_array, size, 3)) SWIG_fail; + + array[i] = (DATA_TYPE*) array_data(temp_array); + } + + $1 = (DATA_TYPE**) array; + $3 = (DIM_TYPE) size[0]; + $4 = (DIM_TYPE) size[1]; + $5 = (DIM_TYPE) size[2]; +} +%typemap(freearg) + (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + Py_ssize_t i; + + if (array$argnum!=NULL) free(array$argnum); + + /*freeing the individual arrays if needed */ + if (object_array$argnum!=NULL) + { + if (is_new_object_array$argnum!=NULL) + { + for (i=0; i<$2; i++) + { + if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i]) + { Py_DECREF(object_array$argnum[i]); } + } + free(is_new_object_array$argnum); + } + free(object_array$argnum); + } +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, + * DATA_TYPE* IN_ARRAY4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[4] = { -1, -1, -1 , -1}; + array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 4) || + !require_size(array, size, 4)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DIM_TYPE) array_size(array,3); + $5 = (DATA_TYPE*) array_data(array); +} +%typemap(freearg) + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3, DIM_TYPE DIM4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[4] = { -1, -1, -1, -1 }; + array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 4) || + !require_size(array, size, 4) | !require_fortran(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); + $5 = (DIM_TYPE) array_size(array,3); +} +%typemap(freearg) + (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, + * DATA_TYPE* IN_FARRAY4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) +{ + $1 = is_array($input) || PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) + (PyArrayObject* array=NULL, int is_new_object=0) +{ + npy_intp size[4] = { -1, -1, -1 , -1 }; + array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, + &is_new_object); + if (!array || !require_dimensions(array, 4) || + !require_size(array, size, 4) || !require_fortran(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DIM_TYPE) array_size(array,3); + $5 = (DATA_TYPE*) array_data(array); +} +%typemap(freearg) + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) +{ + if (is_new_object$argnum && array$argnum) + { Py_DECREF(array$argnum); } +} + +/***************************/ +/* In-Place Array Typemaps */ +/***************************/ + +/* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE INPLACE_ARRAY1[ANY]) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE INPLACE_ARRAY1[ANY]) + (PyArrayObject* array=NULL) +{ + npy_intp size[1] = { $1_dim0 }; + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) || + !require_contiguous(array) || !require_native(array)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} + +/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) + (PyArrayObject* array=NULL, int i=1) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,1) || !require_contiguous(array) + || !require_native(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = 1; + for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i); +} + +/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) + (PyArrayObject* array=NULL, int i=0) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,1) || !require_contiguous(array) + || !require_native(array)) SWIG_fail; + $1 = 1; + for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i); + $2 = (DATA_TYPE*) array_data(array); +} + +/* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) + (PyArrayObject* array=NULL) +{ + npy_intp size[2] = { $1_dim0, $1_dim1 }; + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) || + !require_contiguous(array) || !require_native(array)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} + +/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,2) || !require_contiguous(array) + || !require_native(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,2) || !require_contiguous(array) || + !require_native(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DATA_TYPE*) array_data(array); +} + +/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,2) || !require_contiguous(array) + || !require_native(array) || !require_fortran(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,2) || !require_contiguous(array) || + !require_native(array) || !require_fortran(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DATA_TYPE*) array_data(array); +} + +/* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) + (PyArrayObject* array=NULL) +{ + npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) || + !require_contiguous(array) || !require_native(array)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} + +/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,3) || !require_contiguous(array) || + !require_native(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); +} + +/* Typemap suite for (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + $1 = PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL) +{ + npy_intp size[2] = { -1, -1 }; + PyArrayObject* temp_array; + Py_ssize_t i; + + /* length of the list */ + $2 = PyList_Size($input); + + /* the arrays */ + array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); + object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); + + if (array == NULL || object_array == NULL) + { + SWIG_fail; + } + + for (i=0; i<$2; i++) + { + temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE); + + /* the new array must be stored so that it can be destroyed in freearg */ + object_array[i] = temp_array; + + if ( !temp_array || !require_dimensions(temp_array, 2) || + !require_contiguous(temp_array) || + !require_native(temp_array) || + !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE) + ) SWIG_fail; + + /* store the size of the first array in the list, then use that for comparison. */ + if (i == 0) + { + size[0] = array_size(temp_array,0); + size[1] = array_size(temp_array,1); + } + + if (!require_size(temp_array, size, 2)) SWIG_fail; + + array[i] = (DATA_TYPE*) array_data(temp_array); + } + + $1 = (DATA_TYPE**) array; + $3 = (DIM_TYPE) size[0]; + $4 = (DIM_TYPE) size[1]; +} +%typemap(freearg) + (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + if (array$argnum!=NULL) free(array$argnum); + if (object_array$argnum!=NULL) free(object_array$argnum); +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, + * DATA_TYPE* INPLACE_ARRAY3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,3) || !require_contiguous(array) + || !require_native(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DATA_TYPE*) array_data(array); +} + +/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,3) || !require_contiguous(array) || + !require_native(array) || !require_fortran(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, + * DATA_TYPE* INPLACE_FARRAY3) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,3) || !require_contiguous(array) + || !require_native(array) || !require_fortran(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DATA_TYPE*) array_data(array); +} + +/* Typemap suite for (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) + (PyArrayObject* array=NULL) +{ + npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3 }; + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,4) || !require_size(array, size, 4) || + !require_contiguous(array) || !require_native(array)) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} + +/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3, DIM_TYPE DIM4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,4) || !require_contiguous(array) || + !require_native(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); + $5 = (DIM_TYPE) array_size(array,3); +} + +/* Typemap suite for (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3, DIM_TYPE DIM4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + $1 = PySequence_Check($input); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL) +{ + npy_intp size[3] = { -1, -1, -1 }; + PyArrayObject* temp_array; + Py_ssize_t i; + + /* length of the list */ + $2 = PyList_Size($input); + + /* the arrays */ + array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); + object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); + + if (array == NULL || object_array == NULL) + { + SWIG_fail; + } + + for (i=0; i<$2; i++) + { + temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE); + + /* the new array must be stored so that it can be destroyed in freearg */ + object_array[i] = temp_array; + + if ( !temp_array || !require_dimensions(temp_array, 3) || + !require_contiguous(temp_array) || + !require_native(temp_array) || + !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE) + ) SWIG_fail; + + /* store the size of the first array in the list, then use that for comparison. */ + if (i == 0) + { + size[0] = array_size(temp_array,0); + size[1] = array_size(temp_array,1); + size[2] = array_size(temp_array,2); + } + + if (!require_size(temp_array, size, 3)) SWIG_fail; + + array[i] = (DATA_TYPE*) array_data(temp_array); + } + + $1 = (DATA_TYPE**) array; + $3 = (DIM_TYPE) size[0]; + $4 = (DIM_TYPE) size[1]; + $5 = (DIM_TYPE) size[2]; +} +%typemap(freearg) + (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + if (array$argnum!=NULL) free(array$argnum); + if (object_array$argnum!=NULL) free(object_array$argnum); +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, + * DATA_TYPE* INPLACE_ARRAY4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,4) || !require_contiguous(array) + || !require_native(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DIM_TYPE) array_size(array,3); + $5 = (DATA_TYPE*) array_data(array); +} + +/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, + * DIM_TYPE DIM3, DIM_TYPE DIM4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,4) || !require_contiguous(array) || + !require_native(array) || !require_fortran(array)) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); + $2 = (DIM_TYPE) array_size(array,0); + $3 = (DIM_TYPE) array_size(array,1); + $4 = (DIM_TYPE) array_size(array,2); + $5 = (DIM_TYPE) array_size(array,3); +} + +/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, + * DATA_TYPE* INPLACE_FARRAY4) + */ +%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, + fragment="NumPy_Macros") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) +{ + $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), + DATA_TYPECODE); +} +%typemap(in, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) + (PyArrayObject* array=NULL) +{ + array = obj_to_array_no_conversion($input, DATA_TYPECODE); + if (!array || !require_dimensions(array,4) || !require_contiguous(array) + || !require_native(array) || !require_fortran(array)) SWIG_fail; + $1 = (DIM_TYPE) array_size(array,0); + $2 = (DIM_TYPE) array_size(array,1); + $3 = (DIM_TYPE) array_size(array,2); + $4 = (DIM_TYPE) array_size(array,3); + $5 = (DATA_TYPE*) array_data(array); +} + +/*************************/ +/* Argout Array Typemaps */ +/*************************/ + +/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY]) + */ +%typemap(in,numinputs=0, + fragment="NumPy_Backward_Compatibility,NumPy_Macros") + (DATA_TYPE ARGOUT_ARRAY1[ANY]) + (PyObject* array = NULL) +{ + npy_intp dims[1] = { $1_dim0 }; + array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); + if (!array) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(argout) + (DATA_TYPE ARGOUT_ARRAY1[ANY]) +{ + $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); +} + +/* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) + */ +%typemap(in,numinputs=1, + fragment="NumPy_Fragments") + (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) + (PyObject* array = NULL) +{ + npy_intp dims[1]; + if (!PyInt_Check($input)) + { + const char* typestring = pytype_string($input); + PyErr_Format(PyExc_TypeError, + "Int dimension expected. '%s' given.", + typestring); + SWIG_fail; + } + $2 = (DIM_TYPE) PyInt_AsLong($input); + dims[0] = (npy_intp) $2; + array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); + if (!array) SWIG_fail; + $1 = (DATA_TYPE*) array_data(array); +} +%typemap(argout) + (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) +{ + $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); +} + +/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) + */ +%typemap(in,numinputs=1, + fragment="NumPy_Fragments") + (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) + (PyObject* array = NULL) +{ + npy_intp dims[1]; + if (!PyInt_Check($input)) + { + const char* typestring = pytype_string($input); + PyErr_Format(PyExc_TypeError, + "Int dimension expected. '%s' given.", + typestring); + SWIG_fail; + } + $1 = (DIM_TYPE) PyInt_AsLong($input); + dims[0] = (npy_intp) $1; + array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); + if (!array) SWIG_fail; + $2 = (DATA_TYPE*) array_data(array); +} +%typemap(argout) + (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) +{ + $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); +} + +/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) + */ +%typemap(in,numinputs=0, + fragment="NumPy_Backward_Compatibility,NumPy_Macros") + (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) + (PyObject* array = NULL) +{ + npy_intp dims[2] = { $1_dim0, $1_dim1 }; + array = PyArray_SimpleNew(2, dims, DATA_TYPECODE); + if (!array) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(argout) + (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) +{ + $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); +} + +/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) + */ +%typemap(in,numinputs=0, + fragment="NumPy_Backward_Compatibility,NumPy_Macros") + (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) + (PyObject* array = NULL) +{ + npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 }; + array = PyArray_SimpleNew(3, dims, DATA_TYPECODE); + if (!array) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(argout) + (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) +{ + $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); +} + +/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) + */ +%typemap(in,numinputs=0, + fragment="NumPy_Backward_Compatibility,NumPy_Macros") + (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) + (PyObject* array = NULL) +{ + npy_intp dims[4] = { $1_dim0, $1_dim1, $1_dim2, $1_dim3 }; + array = PyArray_SimpleNew(4, dims, DATA_TYPECODE); + if (!array) SWIG_fail; + $1 = ($1_ltype) array_data(array); +} +%typemap(argout) + (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) +{ + $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); +} + +/*****************************/ +/* Argoutview Array Typemaps */ +/*****************************/ + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim_temp) +{ + $1 = &data_temp; + $2 = &dim_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) +{ + npy_intp dims[1] = { *$2 }; + PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEW_ARRAY1) + (DIM_TYPE dim_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim_temp; + $2 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) +{ + npy_intp dims[1] = { *$1 }; + PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) +{ + npy_intp dims[2] = { *$2, *$3 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_ARRAY2) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) +{ + npy_intp dims[2] = { *$1, *$2 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) +{ + npy_intp dims[2] = { *$2, *$3 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || !require_fortran(array)) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_FARRAY2) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) +{ + npy_intp dims[2] = { *$1, *$2 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || !require_fortran(array)) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) +{ + npy_intp dims[3] = { *$2, *$3, *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, + DATA_TYPE** ARGOUTVIEW_ARRAY3) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) +{ + npy_intp dims[3] = { *$1, *$2, *$3 }; + PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) +{ + npy_intp dims[3] = { *$2, *$3, *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, + DATA_TYPE** ARGOUTVIEW_FARRAY3) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEW_FARRAY3) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) +{ + npy_intp dims[3] = { *$1, *$2, *$3 }; + PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3, DIM_TYPE* DIM4) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; + $5 = &dim4_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) +{ + npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, + DATA_TYPE** ARGOUTVIEW_ARRAY4) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEW_ARRAY4) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &dim4_temp; + $5 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4) +{ + npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3, DIM_TYPE* DIM4) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; + $5 = &dim4_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) +{ + npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, + DATA_TYPE** ARGOUTVIEW_FARRAY4) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEW_FARRAY4) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &dim4_temp; + $5 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4) +{ + npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + $result = SWIG_Python_AppendOutput($result,obj); +} + +/*************************************/ +/* Managed Argoutview Array Typemaps */ +/*************************************/ + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim_temp) +{ + $1 = &data_temp; + $2 = &dim_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) +{ + npy_intp dims[1] = { *$2 }; + PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEWM_ARRAY1) + (DIM_TYPE dim_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim_temp; + $2 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) +{ + npy_intp dims[1] = { *$1 }; + PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) +{ + npy_intp dims[2] = { *$2, *$3 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEWM_ARRAY2) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) +{ + npy_intp dims[2] = { *$1, *$2 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) +{ + npy_intp dims[2] = { *$2, *$3 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || !require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEWM_FARRAY2) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) +{ + npy_intp dims[2] = { *$1, *$2 }; + PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || !require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) +{ + npy_intp dims[3] = { *$2, *$3, *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, + DATA_TYPE** ARGOUTVIEWM_ARRAY3) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEWM_ARRAY3) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3) +{ + npy_intp dims[3] = { *$1, *$2, *$3 }; + PyObject* obj= PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) +{ + npy_intp dims[3] = { *$2, *$3, *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, + DATA_TYPE** ARGOUTVIEWM_FARRAY3) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEWM_FARRAY3) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3) +{ + npy_intp dims[3] = { *$1, *$2, *$3 }; + PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3, DIM_TYPE* DIM4) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; + $5 = &dim4_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) +{ + npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, + DATA_TYPE** ARGOUTVIEWM_ARRAY4) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_ARRAY4) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &dim4_temp; + $5 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) +{ + npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3, DIM_TYPE* DIM4) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; + $5 = &dim4_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) +{ + npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, + DATA_TYPE** ARGOUTVIEWM_FARRAY4) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_FARRAY4) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &dim4_temp; + $5 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) +{ + npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3, DIM_TYPE* DIM4) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; + $5 = &dim4_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) +{ + npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, + DATA_TYPE** ARGOUTVIEWM_ARRAY4) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_ARRAY4) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &dim4_temp; + $5 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) +{ + npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, + DIM_TYPE* DIM3, DIM_TYPE* DIM4) + */ +%typemap(in,numinputs=0) + (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) + (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) +{ + $1 = &data_temp; + $2 = &dim1_temp; + $3 = &dim2_temp; + $4 = &dim3_temp; + $5 = &dim4_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) +{ + npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, + DATA_TYPE** ARGOUTVIEWM_FARRAY4) + */ +%typemap(in,numinputs=0) + (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_FARRAY4) + (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) +{ + $1 = &dim1_temp; + $2 = &dim2_temp; + $3 = &dim3_temp; + $4 = &dim4_temp; + $5 = &data_temp; +} +%typemap(argout, + fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") + (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) +{ + npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; + PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); + PyArrayObject* array = (PyArrayObject*) obj; + + if (!array || require_fortran(array)) SWIG_fail; + +%#ifdef SWIGPY_USE_CAPSULE + PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); +%#else + PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); +%#endif + +%#if NPY_API_VERSION < 0x00000007 + PyArray_BASE(array) = cap; +%#else + PyArray_SetBaseObject(array,cap); +%#endif + + $result = SWIG_Python_AppendOutput($result,obj); +} + +%enddef /* %numpy_typemaps() macro */ +/* *************************************************************** */ + +/* Concrete instances of the %numpy_typemaps() macro: Each invocation + * below applies all of the typemaps above to the specified data type. + */ +%numpy_typemaps(signed char , NPY_BYTE , int) +%numpy_typemaps(unsigned char , NPY_UBYTE , int) +%numpy_typemaps(short , NPY_SHORT , int) +%numpy_typemaps(unsigned short , NPY_USHORT , int) +%numpy_typemaps(int , NPY_INT , int) +%numpy_typemaps(unsigned int , NPY_UINT , int) +%numpy_typemaps(long , NPY_LONG , int) +%numpy_typemaps(unsigned long , NPY_ULONG , int) +%numpy_typemaps(long long , NPY_LONGLONG , int) +%numpy_typemaps(unsigned long long, NPY_ULONGLONG, int) +%numpy_typemaps(float , NPY_FLOAT , int) +%numpy_typemaps(double , NPY_DOUBLE , int) + +/* *************************************************************** + * The follow macro expansion does not work, because C++ bool is 4 + * bytes and NPY_BOOL is 1 byte + * + * %numpy_typemaps(bool, NPY_BOOL, int) + */ + +/* *************************************************************** + * On my Mac, I get the following warning for this macro expansion: + * 'swig/python detected a memory leak of type 'long double *', no destructor found.' + * + * %numpy_typemaps(long double, NPY_LONGDOUBLE, int) + */ + +/* *************************************************************** + * Swig complains about a syntax error for the following macro + * expansions: + * + * %numpy_typemaps(complex float, NPY_CFLOAT , int) + * + * %numpy_typemaps(complex double, NPY_CDOUBLE, int) + * + * %numpy_typemaps(complex long double, NPY_CLONGDOUBLE, int) + */ + +#endif /* SWIGPYTHON */ diff --git a/snap-python/source/swig/numpy_swig.i b/snap-python/source/swig/numpy_swig.i new file mode 100644 index 0000000000000000000000000000000000000000..fd1b1a3914b8be878e5c1815c695f70e169dddd2 --- /dev/null +++ b/snap-python/source/swig/numpy_swig.i @@ -0,0 +1,16 @@ +%{ + #define SWIG_FILE_WITH_INIT + #include "numpy.h" +%} + +%include "numpy.i" + +%init %{ + import_array(); +%} + +%apply (int* ARGOUT_ARRAY1, int DIM1) {(int* IntNumpyVecOut, int n)} +%apply (float* ARGOUT_ARRAY1, int DIM1) {(float* FltNumpyVecOut, int n)} +%apply (int* IN_ARRAY1, int DIM1) {(int* IntNumpyVecIn, int n)} +%apply (float* IN_ARRAY1, int DIM1) {(float* FltNumpyVecIn, int n)} +%include "numpy.h" diff --git a/snap-python/source/swig/pdirnet.i b/snap-python/source/swig/pdirnet.i new file mode 100644 index 0000000000000000000000000000000000000000..c1e7e48b1a38719cab4dbf254c31d8a7cd6e94a1 --- /dev/null +++ b/snap-python/source/swig/pdirnet.i @@ -0,0 +1,211 @@ +// pdirnet.i +// Templates for SNAP TDirNet, PDirNet + +%extend TDirNet { + TDirNetNodeI BegNI() { + return TDirNetNodeI($self->BegNI()); + } + TDirNetNodeI EndNI() { + return TDirNetNodeI($self->EndNI()); + } + TDirNetNodeI GetNI(const int &NId) { + return TDirNetNodeI($self->GetNI(NId)); + } + TDirNetEdgeI BegEI() { + return TDirNetEdgeI($self->BegEI()); + } + TDirNetEdgeI EndEI() { + return TDirNetEdgeI($self->EndEI()); + } +}; + +%pythoncode %{ +# redefine TDirNetEdgeI.GetId to return a pair of nodes rather than -1 +def GetId(self): + return (self.GetSrcNId(), self.GetDstNId()) + +TDirNetEdgeI.GetId = GetId +%} + + +// Basic Undirected Graphs + +%template(PrintGraphStatTable_PDirNet) PrintGraphStatTable; + +//%template(MxSccSz_PDirNet) TSnap::GetMxScc; +//%template(MxWccSz_PDirNet) TSnap::GetMxWccSz; +// End Basic Directed Graphs + +// Basic PDirNets +%template(PDirNet) TPt< TDirNet >; + +// gbase.h - PDirNet +%template(PrintInfo_PDirNet) TSnap::PrintInfo; + +// cncom.h - PDirNet +%template(GetNodeWcc_PDirNet) TSnap::GetNodeWcc; +%template(IsConnected_PDirNet) TSnap::IsConnected; +%template(IsWeaklyConn_PDirNet) TSnap::IsWeaklyConn; +%template(GetWccSzCnt_PDirNet) TSnap::GetWccSzCnt; +%template(GetWccs_PDirNet) TSnap::GetWccs; +%template(GetSccSzCnt_PDirNet) TSnap::GetSccSzCnt; +%template(GetSccs_PDirNet) TSnap::GetSccs; +%template(GetMxWccSz_PDirNet) TSnap::GetMxWccSz; +%template(GetMxSccSz_PDirNet) TSnap::GetMxSccSz; + +%template(GetMxWcc_PDirNet) TSnap::GetMxWcc; +%template(GetMxScc_PDirNet) TSnap::GetMxScc; +%template(GetMxBiCon_PDirNet) TSnap::GetMxBiCon; + +// centr.h - PDirNet +%template(GetNodeEcc_PDirNet) TSnap::GetNodeEcc; +%template(GetPageRank_PDirNet) TSnap::GetPageRank; +%template(GetPageRank_v1_PDirNet) TSnap::GetPageRank_v1; +%template(GetHits_PDirNet) TSnap::GetHits; +#ifdef _OPENMP +%template(GetPageRankMP_PDirNet) TSnap::GetPageRankMP; +%template(GetHitsMP_PDirNet) TSnap::GetHitsMP; +#endif + + +// alg.h - PDirNet +%template(CntInDegNodes_PDirNet) TSnap::CntInDegNodes; +%template(CntOutDegNodes_PDirNet) TSnap::CntOutDegNodes; +%template(CntDegNodes_PDirNet) TSnap::CntDegNodes; +%template(CntNonZNodes_PDirNet) TSnap::CntNonZNodes; +%template(CntEdgesToSet_PDirNet) TSnap::CntEdgesToSet; + +%template(GetMxDegNId_PDirNet) TSnap::GetMxDegNId; +%template(GetMxInDegNId_PDirNet) TSnap::GetMxInDegNId; +%template(GetMxOutDegNId_PDirNet) TSnap::GetMxOutDegNId; + +%template(GetInDegCnt_PDirNet) TSnap::GetInDegCnt; +%template(GetOutDegCnt_PDirNet) TSnap::GetOutDegCnt; +%template(GetDegCnt_PDirNet) TSnap::GetDegCnt; +%template(GetDegSeqV_PDirNet) TSnap::GetDegSeqV; + +%template(GetNodeInDegV_PDirNet) TSnap::GetNodeInDegV; +%template(GetNodeOutDegV_PDirNet) TSnap::GetNodeOutDegV; + +%template(CntUniqUndirEdges_PDirNet) TSnap::CntUniqUndirEdges; +%template(CntUniqDirEdges_PDirNet) TSnap::CntUniqDirEdges; +%template(CntUniqBiDirEdges_PDirNet) TSnap::CntUniqBiDirEdges; +%template(CntSelfEdges_PDirNet) TSnap::CntSelfEdges; + +%template(GetUnDir_PDirNet) TSnap::GetUnDir; +%template(MakeUnDir_PDirNet) TSnap::MakeUnDir; +%template(AddSelfEdges_PDirNet) TSnap::AddSelfEdges; +%template(DelSelfEdges_PDirNet) TSnap::DelSelfEdges; +%template(DelNodes_PDirNet) TSnap::DelNodes; +%template(DelZeroDegNodes_PDirNet) TSnap::DelZeroDegNodes; +%template(DelDegKNodes_PDirNet) TSnap::DelDegKNodes; +%template(IsTree_PDirNet) TSnap::IsTree; +%template(GetTreeRootNId_PDirNet) TSnap::GetTreeRootNId; +%template(GetTreeSig_PDirNet) TSnap::GetTreeSig; + + +// bfsdfs.h - PDirNet +%template(GetBfsTree_PDirNet) TSnap::GetBfsTree; +%template(GetSubTreeSz_PDirNet) TSnap::GetSubTreeSz; +%template(GetNodesAtHop_PDirNet) TSnap::GetNodesAtHop; +%template(GetNodesAtHops_PDirNet) TSnap::GetNodesAtHops; +// Shortest paths +%template(GetShortPath_PDirNet) TSnap::GetShortPath; +// Diameter +%template(GetBfsFullDiam_PDirNet) TSnap::GetBfsFullDiam; +%template(GetBfsEffDiam_PDirNet) TSnap::GetBfsEffDiam; +%template(GetBfsEffDiamAll_PDirNet) TSnap::GetBfsEffDiamAll; + + +// drawgviz.h +%template(DrawGViz_PDirNet) TSnap::DrawGViz; + + +// ggen.h +%template(GenGrid_PDirNet) TSnap::GenGrid; +%template(GenStar_PDirNet) TSnap::GenStar; +%template(GenCircle_PDirNet) TSnap::GenCircle; +%template(GenFull_PDirNet) TSnap::GenFull; +%template(GenTree_PDirNet) TSnap::GenTree; +%template(GenBaraHierar_PDirNet) TSnap::GenBaraHierar; +%template(GenRndGnm_PDirNet) TSnap::GenRndGnm; + + +// gio.h +%template(LoadEdgeList_PDirNet) TSnap::LoadEdgeList; +%template(LoadEdgeListStr_PDirNet) TSnap::LoadEdgeListStr; +%template(LoadConnList_PDirNet) TSnap::LoadConnList; +%template(LoadConnListStr_PDirNet) TSnap::LoadConnListStr; +%template(LoadPajek_PDirNet) TSnap::LoadPajek; +%template(SaveEdgeList_PDirNet) TSnap::SaveEdgeList; +%template(SavePajek_PDirNet) TSnap::SavePajek; +%template(SaveMatlabSparseMtx_PDirNet) TSnap::SaveMatlabSparseMtx; +%template(SaveGViz_PDirNet) TSnap::SaveGViz; + + +// kcore.h +%template(GetKCore_PDirNet) TSnap::GetKCore; +%template(GetKCoreEdges_PDirNet) TSnap::GetKCoreEdges; +%template(GetKCoreNodes_PDirNet) TSnap::GetKCoreNodes; + + +// subgraph.h +%template(ConvertGraph_PDirNet_PUNGraph) TSnap::ConvertGraph ; +%template(ConvertGraph_PDirNet_PDirNet) TSnap::ConvertGraph ; +%template(ConvertGraph_PDirNet_PNEANet) TSnap::ConvertGraph ; +%template(ConvertSubGraph_PDirNet_PUNGraph) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PDirNet_PDirNet) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PDirNet_PNEANet) TSnap::ConvertSubGraph ; +%template(ConvertESubGraph_PDirNet_PNEANet) TSnap::ConvertESubGraph ; +%template(GetSubGraph_PDirNet) TSnap::GetSubGraph; +%template(GetRndSubGraph_PDirNet) TSnap::GetRndSubGraph; +%template(GetRndESubGraph_PDirNet) TSnap::GetRndESubGraph; + + +// triad.h - PDirNet +%template(GetClustCf_PDirNet) TSnap::GetClustCf; +%template(GetClustCfAll_PDirNet) TSnap::GetClustCfAll; +%template(GetNodeClustCf_PDirNet) TSnap::GetNodeClustCf; +%template(GetTriads_PDirNet) TSnap::GetTriads; +%template(GetTriadsAll_PDirNet) TSnap::GetTriadsAll; +%template(GetTriadEdges_PDirNet) TSnap::GetTriadEdges; +%template(GetNodeTriads_PDirNet) TSnap::GetNodeTriads; +%template(GetNodeTriadsAll_PDirNet) TSnap::GetNodeTriadsAll; +%template(GetTriadParticip_PDirNet) TSnap::GetTriadParticip; +%template(GetTriangleCnt_PDirNet) TSnap::GetTriangleCnt; + +%template(GetCmnNbrs_PDirNet) TSnap::GetCmnNbrs; +%template(GetLen2Paths_PDirNet) TSnap::GetLen2Paths; + + +// cmty.h - PDirNet +%template(GetModularity_PDirNet) TSnap::GetModularity; +%template(GetEdgesInOut_PDirNet) TSnap::GetEdgesInOut; + + +// anf.h - PDirNet +%template(GetAnf_PDirNet) TSnap::GetAnf; +%template(GetAnfEffDiam_PDirNet) TSnap::GetAnfEffDiam; +%template(TestAnf_PDirNet) TSnap::TestAnf; + +// statplot.h - PDirNet +%template(PlotKCoreEdges_PDirNet) TSnap::PlotKCoreEdges; +%template(PlotKCoreNodes_PDirNet) TSnap::PlotKCoreNodes; +%template(PlotShortPathDistr_PDirNet) TSnap::PlotShortPathDistr; +%template(PlotHops_PDirNet) TSnap::PlotHops; +%template(PlotClustCf_PDirNet) TSnap::PlotClustCf; +%template(PlotSccDistr_PDirNet) TSnap::PlotSccDistr; +%template(PlotWccDistr_PDirNet) TSnap::PlotWccDistr; +%template(PlotOutDegDistr_PDirNet) TSnap::PlotOutDegDistr; +%template(PlotInDegDistr_PDirNet) TSnap::PlotInDegDistr; + + +// goodgraph.cpp - PDirNet +%template(PercentDegree_PDirNet) PercentDegree; +%template(NodesGTEDegree_PDirNet) NodesGTEDegree; +%template(MxDegree_PDirNet) MxDegree; +%template(PercentMxWcc_PDirNet) PercentMxWcc; +%template(PercentMxScc_PDirNet) PercentMxScc; + +// conv.h - PDirNet +%template(ToGraph_PDirNet) TSnap::ToGraph; diff --git a/snap-python/source/swig/pgraph.i b/snap-python/source/swig/pgraph.i new file mode 100644 index 0000000000000000000000000000000000000000..86c0b6c2a9428925ac82f5221b7253048b5c094c --- /dev/null +++ b/snap-python/source/swig/pgraph.i @@ -0,0 +1,1563 @@ +// pgraph.i +// Templates for SNAP, common functions to graph, net types + +%pythoncode %{ + +# +# dispatch table for instantiated polymorphic SNAP templates +# BELOW INCLUDE out-*.txt +# + +def LoadPajek(tspec, *args): + if tspec == PUNGraph: return LoadPajek_PUNGraph(*args) + if tspec == PUndirNet: return LoadPajek_PUndirNet(*args) + if tspec == PDirNet: return LoadPajek_PDirNet(*args) + if tspec == PNGraph : return LoadPajek_PNGraph(*args) + if tspec == PNEANet : return LoadPajek_PNEANet(*args) + if tspec == PNGraphMP: return LoadPajek_PNGraphMP(*args) + if tspec == PNEANetMP: return LoadPajek_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def SaveGViz(tspec, *args): + if type(tspec) == PUNGraph: return SaveGViz_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return SaveGViz_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return SaveGViz_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return SaveGViz_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return SaveGViz_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return SaveGViz_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return SaveGViz_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def TestAnf(tspec, *args): + if type(tspec) == PUNGraph: return TestAnf_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return TestAnf_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return TestAnf_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return TestAnf_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return TestAnf_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return TestAnf_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return TestAnf_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodeWcc(tspec, *args): + if type(tspec) == PUNGraph: return GetNodeWcc_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodeWcc_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodeWcc_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodeWcc_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodeWcc_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodeWcc_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodeWcc_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def DelNodes(tspec, *args): + if type(tspec) == PUNGraph: return DelNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return DelNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return DelNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return DelNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return DelNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return DelNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return DelNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntEdgesToSet(tspec, *args): + if type(tspec) == PUNGraph: return CntEdgesToSet_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntEdgesToSet_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntEdgesToSet_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntEdgesToSet_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntEdgesToSet_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntEdgesToSet_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntEdgesToSet_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetGraphUnion(tspec, *args): + if type(tspec) == PUNGraph: return GetGraphUnion_PUNGraph(tspec, *args) + if type(tspec) == PNGraph : return GetGraphUnion_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetGraphUnion_PNEANet(tspec, *args) + raise TypeError('First argument has invalid type') +def GetGraphIntersection(tspec, *args): + if type(tspec) == PUNGraph: return GetGraphIntersection_PUNGraph(tspec, *args) + if type(tspec) == PNGraph : return GetGraphIntersection_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetGraphIntersection_PNEANet(tspec, *args) + raise TypeError('First argument has invalid type') +def GetModularity(tspec, *args): + if type(tspec) == PUNGraph: return GetModularity_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetModularity_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetModularity_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetModularity_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetModularity_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetModularity_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetModularity_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetBfsEffDiam(tspec, *args): + if type(tspec) == PUNGraph: return GetBfsEffDiam_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetBfsEffDiam_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetBfsEffDiam_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetBfsEffDiam_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetBfsEffDiam_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetBfsEffDiam_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetBfsEffDiam_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetBfsEffDiamAll(tspec, *args): + if type(tspec) == PUNGraph: return GetBfsEffDiamAll_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetBfsEffDiamAll_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetBfsEffDiamAll_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetBfsEffDiamAll_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetBfsEffDiamAll_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetBfsEffDiamAll_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetBfsEffDiamAll_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PercentMxWcc(tspec, *args): + if type(tspec) == PUNGraph: return PercentMxWcc_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PercentMxWcc_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PercentMxWcc_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PercentMxWcc_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PercentMxWcc_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PercentMxWcc_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PercentMxWcc_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetSubGraph(tspec, *args): + if type(tspec) == PUNGraph: return GetSubGraph_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetSubGraph_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetSubGraph_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetSubGraph_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetSubGraph_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetSubGraph_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetSubGraph_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetSubGraphRenumber(tspec, *args): + if type(tspec) == PUNGraph: return GetSubGraphRenumber_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetSubGraphRenumber_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetSubGraphRenumber_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetSubGraphRenumber_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetSubGraphRenumber_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetSubGraphRenumber_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetSubGraphRenumber_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetBfsTree(tspec, *args): + if type(tspec) == PUNGraph: return GetBfsTree_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetBfsTree_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetBfsTree_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetBfsTree_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetBfsTree_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetBfsTree_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetBfsTree_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PrintGraphStatTable(tspec, *args): + if type(tspec) == PUNGraph: return PrintGraphStatTable_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PrintGraphStatTable_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PrintGraphStatTable_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PrintGraphStatTable_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PrintGraphStatTable_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PrintGraphStatTable_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PrintGraphStatTable_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetDegSeqV(tspec, *args): + if type(tspec) == PUNGraph: return GetDegSeqV_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetDegSeqV_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetDegSeqV_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetDegSeqV_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetDegSeqV_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetDegSeqV_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetDegSeqV_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GenGrid(tspec, *args): + if tspec == PUNGraph: return GenGrid_PUNGraph(*args) + if tspec == PUndirNet: return GenGrid_PUndirNet(*args) + if tspec == PDirNet: return GenGrid_PDirNet(*args) + if tspec == PNGraph : return GenGrid_PNGraph(*args) + if tspec == PNEANet : return GenGrid_PNEANet(*args) + if tspec == PNGraphMP: return GenGrid_PNGraphMP(*args) + if tspec == PNEANetMP : return GenGrid_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def LoadEdgeList(tspec, *args): + if tspec == PUNGraph: return LoadEdgeList_PUNGraph(*args) + if tspec == PUndirNet: return LoadEdgeList_PUndirNet(*args) + if tspec == PDirNet: return LoadEdgeList_PDirNet(*args) + if tspec == PNGraph : return LoadEdgeList_PNGraph(*args) + if tspec == PNEANet : return LoadEdgeList_PNEANet(*args) + if tspec == PNGraphMP: return LoadEdgeList_PNGraphMP(*args) + if tspec == PNEANetMP : return LoadEdgeList_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def GetUnDir(tspec, *args): + if type(tspec) == PUNGraph: return GetUnDir_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetUnDir_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetUnDir_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetUnDir_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetUnDir_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetUnDir_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetUnDir_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def DrawGViz(tspec, *args): + if type(tspec) == PUNGraph: return DrawGViz_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return DrawGViz_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return DrawGViz_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return DrawGViz_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return DrawGViz_PNEANet(tspec, *args) + if type(tspec) == PNEANetMP : return DrawGViz_PNEANetMP(tspec, *args) + if type(tspec) == PNGraphMP: return DrawGViz_PNGraphMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotKCoreNodes(tspec, *args): + if type(tspec) == PUNGraph: return PlotKCoreNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotKCoreNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotKCoreNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotKCoreNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotKCoreNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotKCoreNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotKCoreNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotOutDegDistr(tspec, *args): + if type(tspec) == PUNGraph: return PlotOutDegDistr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotOutDegDistr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotOutDegDistr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotOutDegDistr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotOutDegDistr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotOutDegDistr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotOutDegDistr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntUniqBiDirEdges(tspec, *args): + if type(tspec) == PUNGraph: return CntUniqBiDirEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntUniqBiDirEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntUniqBiDirEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntUniqBiDirEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntUniqBiDirEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntUniqBiDirEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntUniqBiDirEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetKCoreEdges(tspec, *args): + if type(tspec) == PUNGraph: return GetKCoreEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetKCoreEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetKCoreEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetKCoreEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetKCoreEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetKCoreEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetKCoreEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetMxDegNId(tspec, *args): + if type(tspec) == PUNGraph: return GetMxDegNId_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxDegNId_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxDegNId_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxDegNId_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxDegNId_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxDegNId_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxDegNId_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetBfsFullDiam(tspec, *args): + if type(tspec) == PUNGraph: return GetBfsFullDiam_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetBfsFullDiam_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetBfsFullDiam_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetBfsFullDiam_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetBfsFullDiam_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetBfsFullDiam_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetBfsFullDiam_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def LoadConnList(tspec, *args): + if tspec == PUNGraph: return LoadConnList_PUNGraph(*args) + if tspec == PUndirNet: return LoadConnList_PUndirNet(*args) + if tspec == PDirNet: return LoadConnList_PDirNet(*args) + if tspec == PNGraph : return LoadConnList_PNGraph(*args) + if tspec == PNEANet : return LoadConnList_PNEANet(*args) + if tspec == PNGraphMP: return LoadConnList_PNGraphMP(*args) + if tspec == PNEANetMP : return LoadConnList_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def GetHitsMP(tspec, *args): + if type(tspec) == PUNGraph: return GetHitsMP_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetHitsMP_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetHitsMP_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetHitsMP_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetHitsMP_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetHitsMP_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetHitsMP_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetPageRank(tspec, *args): + if type(tspec) == PUNGraph: return GetPageRank_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetPageRank_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetPageRank_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetPageRank_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetPageRank_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetPageRank_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetPageRank_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetPageRank_v1(tspec, *args): + if type(tspec) == PUNGraph: return GetPageRank_v1_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetPageRank_v1_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetPageRank_v1_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetPageRank_v1_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetPageRank_v1_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetPageRank_v1_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetPageRank_v1_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntInDegNodes(tspec, *args): + if type(tspec) == PUNGraph: return CntInDegNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntInDegNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntInDegNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntInDegNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntInDegNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntInDegNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntInDegNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetMxScc(tspec, *args): + if type(tspec) == PUNGraph: return GetMxScc_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxScc_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxScc_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxScc_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxScc_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxScc_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxScc_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def AddSelfEdges(tspec, *args): + if type(tspec) == PUNGraph: return AddSelfEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return AddSelfEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return AddSelfEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return AddSelfEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return AddSelfEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return AddSelfEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return AddSelfEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def DelDegKNodes(tspec, *args): + if type(tspec) == PUNGraph: return DelDegKNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return DelDegKNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return DelDegKNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return DelDegKNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return DelDegKNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return DelDegKNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return DelDegKNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotSccDistr(tspec, *args): + if type(tspec) == PUNGraph: return PlotSccDistr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotSccDistr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotSccDistr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotSccDistr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotSccDistr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotSccDistr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotSccDistr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def IsWeaklyConn(tspec, *args): + if type(tspec) == PUNGraph: return IsWeaklyConn_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return IsWeaklyConn_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return IsWeaklyConn_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return IsWeaklyConn_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return IsWeaklyConn_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return IsWeaklyConn_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return IsWeaklyConn_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetMxInDegNId(tspec, *args): + if type(tspec) == PUNGraph: return GetMxInDegNId_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxInDegNId_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxInDegNId_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxInDegNId_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxInDegNId_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxInDegNId_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxInDegNId_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetSccSzCnt(tspec, *args): + if type(tspec) == PUNGraph: return GetSccSzCnt_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetSccSzCnt_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetSccSzCnt_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetSccSzCnt_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetSccSzCnt_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetSccSzCnt_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetSccSzCnt_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetClosenessCentr(tspec, *args): + if type(tspec) == PUNGraph: return GetClosenessCentr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetClosenessCentr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetClosenessCentr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetClosenessCentr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetClosenessCentr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetClosenessCentr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetClosenessCentr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def MxWccSz(tspec, *args): + if type(tspec) == PUNGraph: return MxWccSz_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return MxWccSz_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return MxWccSz_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return MxWccSz_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return MxWccSz_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return MxWccSz_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return MxWccSz_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetCmnNbrs(tspec, *args): + if type(tspec) == PUNGraph: return GetCmnNbrs_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetCmnNbrs_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetCmnNbrs_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetCmnNbrs_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetCmnNbrs_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetCmnNbrs_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetCmnNbrs_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetTriadEdges(tspec, *args): + if type(tspec) == PUNGraph: return GetTriadEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetTriadEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetTriadEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetTriadEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetTriadEdges_PNEANet(tspec, *args) + if type(tspec) == PNEANetMP : return GetTriadEdges_PNEANetMP(tspec, *args) + if type(tspec) == PNGraphMP: return GetTriadEdges_PNGraphMP(tspec, *args) + raise TypeError('First argument has invalid type') +def LoadConnListStr(tspec, *args): + if tspec == PUNGraph: return LoadConnListStr_PUNGraph(*args) + if tspec == PUndirNet: return LoadConnListStr_PUndirNet(*args) + if tspec == PDirNet: return LoadConnListStr_PDirNet(*args) + if tspec == PNGraph : return LoadConnListStr_PNGraph(*args) + if tspec == PNEANet : return LoadConnListStr_PNEANet(*args) + if tspec == PNGraphMP: return LoadConnListStr_PNGraphMP(*args) + if tspec == PNEANetMP : return LoadConnListStr_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def GetMxWccSz(tspec, *args): + if type(tspec) == PUNGraph: return GetMxWccSz_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxWccSz_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxWccSz_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxWccSz_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxWccSz_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxWccSz_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxWccSz_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetMxOutDegNId(tspec, *args): + if type(tspec) == PUNGraph: return GetMxOutDegNId_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxOutDegNId_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxOutDegNId_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxOutDegNId_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxOutDegNId_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxOutDegNId_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxOutDegNId_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetLen2Paths(tspec, *args): + if type(tspec) == PUNGraph: return GetLen2Paths_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetLen2Paths_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetLen2Paths_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetLen2Paths_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetLen2Paths_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetLen2Paths_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetLen2Paths_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetPageRankMP(tspec, *args): + if type(tspec) == PUNGraph: return GetPageRankMP_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetPageRankMP_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetPageRankMP_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetPageRankMP_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetPageRankMP_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetPageRankMP_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetPageRankMP_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PrintInfo(tspec, *args): + if type(tspec) == PUNGraph: return PrintInfo_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PrintInfo_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PrintInfo_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PrintInfo_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PrintInfo_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PrintInfo_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PrintInfo_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetWccs(tspec, *args): + if type(tspec) == PUNGraph: return GetWccs_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetWccs_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetWccs_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetWccs_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetWccs_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetWccs_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetWccs_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetMxWcc(tspec, *args): + if type(tspec) == PUNGraph: return GetMxWcc_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxWcc_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxWcc_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxWcc_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxWcc_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxWcc_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxWcc_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetMxSccSz(tspec, *args): + if type(tspec) == PUNGraph: return GetMxSccSz_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxSccSz_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxSccSz_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxSccSz_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxSccSz_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxSccSz_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxSccSz_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntSelfEdges(tspec, *args): + if type(tspec) == PUNGraph: return CntSelfEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntSelfEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntSelfEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntSelfEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntSelfEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntSelfEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntSelfEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def NodesGTEDegree(tspec, *args): + if type(tspec) == PUNGraph: return NodesGTEDegree_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return NodesGTEDegree_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return NodesGTEDegree_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return NodesGTEDegree_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return NodesGTEDegree_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return NodesGTEDegree_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return NodesGTEDegree_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotShortPathDistr(tspec, *args): + if type(tspec) == PUNGraph: return PlotShortPathDistr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotShortPathDistr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotShortPathDistr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotShortPathDistr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotShortPathDistr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotShortPathDistr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotShortPathDistr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodesAtHop(tspec, *args): + if type(tspec) == PUNGraph: return GetNodesAtHop_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodesAtHop_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodesAtHop_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodesAtHop_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodesAtHop_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodesAtHop_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodesAtHop_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotInDegDistr(tspec, *args): + if type(tspec) == PUNGraph: return PlotInDegDistr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotInDegDistr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotInDegDistr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotInDegDistr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotInDegDistr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotInDegDistr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotInDegDistr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetHits(tspec, *args): + if type(tspec) == PUNGraph: return GetHits_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetHits_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetHits_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetHits_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetHits_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetHits_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetHits_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetMxBiCon(tspec, *args): + if type(tspec) == PUNGraph: return GetMxBiCon_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetMxBiCon_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetMxBiCon_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetMxBiCon_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetMxBiCon_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetMxBiCon_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetMxBiCon_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def DelZeroDegNodes(tspec, *args): + if type(tspec) == PUNGraph: return DelZeroDegNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return DelZeroDegNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return DelZeroDegNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return DelZeroDegNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return DelZeroDegNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return DelZeroDegNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return DelZeroDegNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetRndESubGraph(tspec, *args): + if type(tspec) == PUNGraph: return GetRndESubGraph_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetRndESubGraph_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetRndESubGraph_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetRndESubGraph_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetRndESubGraph_PNEANet(tspec, *args) + if type(tspec) == PNEANetMP : return GetRndESubGraph_PNEANetMP(tspec, *args) + if type(tspec) == PNGraphMP: return GetRndESubGraph_PNGraphMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetSccs(tspec, *args): + if type(tspec) == PUNGraph: return GetSccs_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetSccs_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetSccs_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetSccs_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetSccs_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetSccs_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetSccs_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PercentDegree(tspec, *args): + if type(tspec) == PUNGraph: return PercentDegree_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PercentDegree_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PercentDegree_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PercentDegree_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PercentDegree_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PercentDegree_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PercentDegree_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetSubTreeSz(tspec, *args): + if type(tspec) == PUNGraph: return GetSubTreeSz_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetSubTreeSz_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetSubTreeSz_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetSubTreeSz_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetSubTreeSz_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetSubTreeSz_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetSubTreeSz_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GenFull(tspec, *args): + if tspec == PUNGraph: return GenFull_PUNGraph(*args) + if tspec == PUndirNet: return GenFull_PUndirNet(*args) + if tspec == PDirNet: return GenFull_PDirNet(*args) + if tspec == PNGraph : return GenFull_PNGraph(*args) + if tspec == PNEANet : return GenFull_PNEANet(*args) + if tspec == PNGraphMP: return GenFull_PNGraphMP(*args) + if tspec == PNEANetMP : return GenFull_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def IsConnected(tspec, *args): + if type(tspec) == PUNGraph: return IsConnected_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return IsConnected_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return IsConnected_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return IsConnected_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return IsConnected_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return IsConnected_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return IsConnected_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodeClustCf(tspec, *args): + if type(tspec) == PUNGraph: return GetNodeClustCf_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodeClustCf_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodeClustCf_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodeClustCf_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodeClustCf_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodeClustCf_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodeClustCf_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def MxDegree(tspec, *args): + if type(tspec) == PUNGraph: return MxDegree_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return MxDegree_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return MxDegree_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return MxDegree_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return MxDegree_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return MxDegree_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return MxDegree_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def SavePajek(tspec, *args): + if type(tspec) == PUNGraph: return SavePajek_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return SavePajek_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return SavePajek_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return SavePajek_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return SavePajek_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return SavePajek_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return SavePajek_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetTreeRootNId(tspec, *args): + if type(tspec) == PUNGraph: return GetTreeRootNId_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetTreeRootNId_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetTreeRootNId_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetTreeRootNId_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetTreeRootNId_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetTreeRootNId_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetTreeRootNId_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotHops(tspec, *args): + if type(tspec) == PUNGraph: return PlotHops_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotHops_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotHops_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotHops_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotHops_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotHops_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotHops_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def DelSelfEdges(tspec, *args): + if type(tspec) == PUNGraph: return DelSelfEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return DelSelfEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return DelSelfEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return DelSelfEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return DelSelfEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return DelSelfEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return DelSelfEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetClustCf(tspec, *args): + if type(tspec) == PUNGraph: return GetClustCf_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetClustCf_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetClustCf_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetClustCf_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetClustCf_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetClustCf_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetClustCf_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetClustCfAll(tspec, *args): + if type(tspec) == PUNGraph: return GetClustCfAll_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetClustCfAll_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetClustCfAll_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetClustCfAll_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetClustCfAll_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetClustCfAll_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetClustCfAll_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodesAtHops(tspec, *args): + if type(tspec) == PUNGraph: return GetNodesAtHops_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodesAtHops_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodesAtHops_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodesAtHops_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodesAtHops_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodesAtHops_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodesAtHops_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodeOutDegV(tspec, *args): + if type(tspec) == PUNGraph: return GetNodeOutDegV_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodeOutDegV_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodeOutDegV_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodeOutDegV_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodeOutDegV_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodeOutDegV_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodeOutDegV_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetAnf(tspec, *args): + if type(tspec) == PUNGraph: return GetAnf_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetAnf_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetAnf_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetAnf_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetAnf_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetAnf_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetAnf_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotClustCf(tspec, *args): + if type(tspec) == PUNGraph: return PlotClustCf_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotClustCf_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotClustCf_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotClustCf_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotClustCf_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotClustCf_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotClustCf_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GenCircle(tspec, *args): + if tspec == PUNGraph: return GenCircle_PUNGraph(*args) + if tspec == PUndirNet: return GenCircle_PUndirNet(*args) + if tspec == PDirNet: return GenCircle_PDirNet(*args) + if tspec == PNGraph : return GenCircle_PNGraph(*args) + if tspec == PNEANet : return GenCircle_PNEANet(*args) + if tspec == PNGraphMP: return GenCircle_PNGraphMP(*args) + if tspec == PNEANetMP : return GenCircle_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def MakeUnDir(tspec, *args): + if type(tspec) == PUNGraph: return MakeUnDir_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return MakeUnDir_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return MakeUnDir_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return MakeUnDir_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return MakeUnDir_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return MakeUnDir_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return MakeUnDir_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetESubGraph(tspec, *args): + if type(tspec) == PUNGraph: return GetESubGraph_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetESubGraph_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetESubGraph_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetESubGraph_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetESubGraph_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetESubGraph_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetESubGraph_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetBetweennessCentr(tspec, *args): + if type(tspec) == PUNGraph: return GetBetweennessCentr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetBetweennessCentr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetBetweennessCentr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetBetweennessCentr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetBetweennessCentr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetBetweennessCentr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetBetweennessCentr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetTriadParticip(tspec, *args): + if type(tspec) == PUNGraph: return GetTriadParticip_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetTriadParticip_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetTriadParticip_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetTriadParticip_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetTriadParticip_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetTriadParticip_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetTriadParticip_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PercentMxScc(tspec, *args): + if type(tspec) == PUNGraph: return PercentMxScc_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PercentMxScc_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PercentMxScc_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PercentMxScc_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PercentMxScc_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PercentMxScc_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PercentMxScc_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetWccSzCnt(tspec, *args): + if type(tspec) == PUNGraph: return GetWccSzCnt_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetWccSzCnt_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetWccSzCnt_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetWccSzCnt_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetWccSzCnt_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetWccSzCnt_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetWccSzCnt_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntDegNodes(tspec, *args): + if type(tspec) == PUNGraph: return CntDegNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntDegNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntDegNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntDegNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntDegNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntDegNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntDegNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def IsTree(tspec, *args): + if type(tspec) == PUNGraph: return IsTree_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return IsTree_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return IsTree_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return IsTree_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return IsTree_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return IsTree_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return IsTree_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GenRndGnm(tspec, *args): + if tspec == PUNGraph: return GenRndGnm_PUNGraph(*args) + if tspec == PUndirNet: return GenRndGnm_PUndirNet(*args) + if tspec == PDirNet: return GenRndGnm_PDirNet(*args) + if tspec == PNGraph : return GenRndGnm_PNGraph(*args) + if tspec == PNEANet : return GenRndGnm_PNEANet(*args) + if tspec == PNGraphMP: return GenRndGnm_PNGraphMP(*args) + if tspec == PNEANetMP : return GenRndGnm_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def GetDegCnt(tspec, *args): + if type(tspec) == PUNGraph: return GetDegCnt_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetDegCnt_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetDegCnt_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetDegCnt_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetDegCnt_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetDegCnt_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetDegCnt_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetFarnessCentr(tspec, *args): + if type(tspec) == PUNGraph: return GetFarnessCentr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetFarnessCentr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetFarnessCentr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetFarnessCentr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetFarnessCentr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetFarnessCentr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetFarnessCentr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def SaveMatlabSparseMtx(tspec, *args): + if type(tspec) == PUNGraph: return SaveMatlabSparseMtx_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return SaveMatlabSparseMtx_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return SaveMatlabSparseMtx_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return SaveMatlabSparseMtx_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return SaveMatlabSparseMtx_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return SaveMatlabSparseMtx_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return SaveMatlabSparseMtx_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def MxSccSz(tspec, *args): + if type(tspec) == PUNGraph: return MxSccSz_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return MxSccSz_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return MxSccSz_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return MxSccSz_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return MxSccSz_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return MxSccSz_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return MxSccSz_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetAnfEffDiam(tspec, *args): + if type(tspec) == PUNGraph: return GetAnfEffDiam_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetAnfEffDiam_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetAnfEffDiam_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetAnfEffDiam_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetAnfEffDiam_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetAnfEffDiam_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetAnfEffDiam_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetTreeSig(tspec, *args): + if type(tspec) == PUNGraph: return GetTreeSig_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetTreeSig_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetTreeSig_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetTreeSig_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetTreeSig_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetTreeSig_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetTreeSig_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntOutDegNodes(tspec, *args): + if type(tspec) == PUNGraph: return CntOutDegNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntOutDegNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntOutDegNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntOutDegNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntOutDegNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntOutDegNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntOutDegNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetTriangleCnt(tspec, *args): + if type(tspec) == PUNGraph: return GetTriangleCnt_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetTriangleCnt_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetTriangleCnt_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetTriangleCnt_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetTriangleCnt_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetTriangleCnt_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetTriangleCnt_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetOutDegCnt(tspec, *args): + if type(tspec) == PUNGraph: return GetOutDegCnt_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetOutDegCnt_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetOutDegCnt_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetOutDegCnt_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetOutDegCnt_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetOutDegCnt_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetOutDegCnt_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GenBaraHierar(tspec, *args): + if tspec == PUNGraph: return GenBaraHierar_PUNGraph(*args) + if tspec == PUndirNet: return GenBaraHierar_PUndirNet(*args) + if tspec == PDirNet: return GenBaraHierar_PDirNet(*args) + if tspec == PNGraph : return GenBaraHierar_PNGraph(*args) + if tspec == PNEANet : return GenBaraHierar_PNEANet(*args) + if tspec == PNGraphMP: return GenBaraHierar_PNGraphMP(*args) + if tspec == PNEANetMP : return GenBaraHierar_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def GenTree(tspec, *args): + if tspec == PUNGraph: return GenTree_PUNGraph(*args) + if tspec == PUndirNet: return GenTree_PUndirNet(*args) + if tspec == PDirNet: return GenTree_PDirNet(*args) + if tspec == PNGraph : return GenTree_PNGraph(*args) + if tspec == PNEANet : return GenTree_PNEANet(*args) + if tspec == PNGraphMP: return GenTree_PNGraphMP(*args) + if tspec == PNEANetMP : return GenTree_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def GetShortPath(tspec, *args): + if type(tspec) == PUNGraph: return GetShortPath_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetShortPath_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetShortPath_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetShortPath_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetShortPath_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetShortPath_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetShortPath_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetKCoreNodes(tspec, *args): + if type(tspec) == PUNGraph: return GetKCoreNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetKCoreNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetKCoreNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetKCoreNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetKCoreNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetKCoreNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetKCoreNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetInDegCnt(tspec, *args): + if type(tspec) == PUNGraph: return GetInDegCnt_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetInDegCnt_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetInDegCnt_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetInDegCnt_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetInDegCnt_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetInDegCnt_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetInDegCnt_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntUniqDirEdges(tspec, *args): + if type(tspec) == PUNGraph: return CntUniqDirEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntUniqDirEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntUniqDirEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntUniqDirEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntUniqDirEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntUniqDirEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntUniqDirEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodeInDegV(tspec, *args): + if type(tspec) == PUNGraph: return GetNodeInDegV_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodeInDegV_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodeInDegV_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodeInDegV_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodeInDegV_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodeInDegV_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodeInDegV_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetRndSubGraph(tspec, *args): + if type(tspec) == PUNGraph: return GetRndSubGraph_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetRndSubGraph_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetRndSubGraph_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetRndSubGraph_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetRndSubGraph_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetRndSubGraph_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetRndSubGraph_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def PlotWccDistr(tspec, *args): + if type(tspec) == PUNGraph: return PlotWccDistr_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotWccDistr_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotWccDistr_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotWccDistr_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotWccDistr_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotWccDistr_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotWccDistr_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetEdgesInOut(tspec, *args): + if type(tspec) == PUNGraph: return GetEdgesInOut_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetEdgesInOut_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetEdgesInOut_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetEdgesInOut_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetEdgesInOut_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetEdgesInOut_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetEdgesInOut_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetKCore(tspec, *args): + if type(tspec) == PUNGraph: return GetKCore_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetKCore_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetKCore_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetKCore_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetKCore_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetKCore_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetKCore_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def CntNonZNodes(tspec, *args): + if type(tspec) == PUNGraph: return CntNonZNodes_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntNonZNodes_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntNonZNodes_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntNonZNodes_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntNonZNodes_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntNonZNodes_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntNonZNodes_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GenStar(tspec, *args): + if tspec == PUNGraph: return GenStar_PUNGraph(*args) + if tspec == PUndirNet: return GenStar_PUndirNet(*args) + if tspec == PDirNet: return GenStar_PDirNet(*args) + if tspec == PNGraph : return GenStar_PNGraph(*args) + if tspec == PNEANet : return GenStar_PNEANet(*args) + if tspec == PNGraphMP: return GenStar_PNGraphMP(*args) + if tspec == PNEANetMP : return GenStar_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def PlotKCoreEdges(tspec, *args): + if type(tspec) == PUNGraph: return PlotKCoreEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return PlotKCoreEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return PlotKCoreEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return PlotKCoreEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return PlotKCoreEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return PlotKCoreEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return PlotKCoreEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def SaveEdgeList(tspec, *args): + if type(tspec) == PUNGraph: return SaveEdgeList_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return SaveEdgeList_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return SaveEdgeList_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return SaveEdgeList_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return SaveEdgeList_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return SaveEdgeList_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return SaveEdgeList_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodeTriads(tspec, *args): + if type(tspec) == PUNGraph: return GetNodeTriads_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodeTriads_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodeTriads_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodeTriads_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodeTriads_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodeTriads_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodeTriads_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodeTriadsAll(tspec, *args): + if type(tspec) == PUNGraph: return GetNodeTriadsAll_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodeTriadsAll_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodeTriadsAll_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodeTriadsAll_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodeTriadsAll_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodeTriadsAll_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodeTriadsAll_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetNodeEcc(tspec, *args): + if type(tspec) == PUNGraph: return GetNodeEcc_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetNodeEcc_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetNodeEcc_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetNodeEcc_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetNodeEcc_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetNodeEcc_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetNodeEcc_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def LoadEdgeListStr(tspec, *args): + if tspec == PUNGraph: return LoadEdgeListStr_PUNGraph(*args) + if tspec == PUndirNet: return LoadEdgeListStr_PUndirNet(*args) + if tspec == PDirNet: return LoadEdgeListStr_PDirNet(*args) + if tspec == PNGraph : return LoadEdgeListStr_PNGraph(*args) + if tspec == PNEANet : return LoadEdgeListStr_PNEANet(*args) + if tspec == PNGraphMP: return LoadEdgeListStr_PNGraphMP(*args) + if tspec == PNEANetMP : return LoadEdgeListStr_PNEANetMP(*args) + raise TypeError('First argument has invalid type') +def CntUniqUndirEdges(tspec, *args): + if type(tspec) == PUNGraph: return CntUniqUndirEdges_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return CntUniqUndirEdges_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return CntUniqUndirEdges_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return CntUniqUndirEdges_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return CntUniqUndirEdges_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return CntUniqUndirEdges_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return CntUniqUndirEdges_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetTriads(tspec, *args): + if type(tspec) == PUNGraph: return GetTriads_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetTriads_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetTriads_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetTriads_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetTriads_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetTriads_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetTriads_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetTriadsAll(tspec, *args): + if type(tspec) == PUNGraph: return GetTriadsAll_PUNGraph(tspec, *args) + if type(tspec) == PUndirNet: return GetTriadsAll_PUndirNet(tspec, *args) + if type(tspec) == PDirNet: return GetTriadsAll_PDirNet(tspec, *args) + if type(tspec) == PNGraph : return GetTriadsAll_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetTriadsAll_PNEANet(tspec, *args) + if type(tspec) == PNGraphMP: return GetTriadsAll_PNGraphMP(tspec, *args) + if type(tspec) == PNEANetMP : return GetTriadsAll_PNEANetMP(tspec, *args) + raise TypeError('First argument has invalid type') +def GetEgonetHop(tspec, *args): + if type(tspec) == PUNGraph: return GetEgonetHop_PUNGraph(tspec, *args) + if type(tspec) == PNGraph : return GetEgonetHop_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetEgonetHop_PNEANet(tspec, *args) + raise TypeError('First argument has invalid type') +def GetInEgonetHop(tspec, *args): + if type(tspec) == PUNGraph: return GetInEgonetHop_PUNGraph(tspec, *args) + if type(tspec) == PNGraph : return GetInEgonetHop_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetInEgonetHop_PNEANet(tspec, *args) + raise TypeError('First argument has invalid type') +def GetOutEgonetHop(tspec, *args): + if type(tspec) == PUNGraph: return GetOutEgonetHop_PUNGraph(tspec, *args) + if type(tspec) == PNGraph : return GetOutEgonetHop_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetOutEgonetHop_PNEANet(tspec, *args) + raise TypeError('First argument has invalid type') +def GetInEgonetSub(tspec, *args): + if type(tspec) == PUNGraph: return GetInEgonetSub_PUNGraph(tspec, *args) + if type(tspec) == PNGraph : return GetInEgonetSub_PNGraph(tspec, *args) + if type(tspec) == PNEANet : return GetInEgonetSub_PNEANet(tspec, *args) + raise TypeError('First argument has invalid type') + +# +# BELOW INCLUDE disp-custom.py +# +def ConvertGraph(toutspec, tinspec, *args): + if toutspec == PUNGraph: + if type(tinspec) == PUNGraph: + return ConvertGraph_PUNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertGraph_PUNGraph_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertGraph_PUNGraph_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PUNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PUNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PUNGraph_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertGraph_PUNGraph_PNEANetMP(tinspec, *args) + if toutspec == PUndirNet: + if type(tinspec) == PUNGraph: + return ConvertGraph_PUndirNet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertGraph_PUndirNet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertGraph_PUndirNet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PUndirNet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PUndirNet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PUndirNet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertGraph_PUndirNet_PNEANetMP(tinspec, *args) + if toutspec == PDirNet: + if type(tinspec) == PUNGraph: + return ConvertGraph_PDirNet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertGraph_PDirNet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertGraph_PDirNet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PDirNet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PDirNet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PDirNet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertGraph_PDirNet_PNEANetMP(tinspec, *args) + if toutspec == PNGraph: + if type(tinspec) == PUNGraph: + return ConvertGraph_PNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertGraph_PNGraph_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertGraph_PNGraph_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PNGraph_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertGraph_PNGraph_PNEANetMP(tinspec, *args) + if toutspec == PNEANet: + if type(tinspec) == PUNGraph: + return ConvertGraph_PNEANet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertGraph_PNEANet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertGraph_PNEANet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PNEANet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PNEANet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PNEANet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertGraph_PNEANet_PNEANetMP(tinspec, *args) + if toutspec == PNGraphMP: + if type(tinspec) == PUNGraph: + return ConvertGraph_PNGraphMP_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertGraph_PNGraphMP_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertGraph_PNGraphMP_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PNGraphMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PNGraphMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PNGraphMP_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertGraph_PNGraphMP_PNEANetMP(tinspec, *args) + if toutspec == PNEANetMP: + if type(tinspec) == PUNGraph: + return ConvertGraph_PNEANetMP_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertGraph_PNEANetMP_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertGraph_PNEANetMP_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertGraph_PNEANetMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertGraph_PNEANetMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertGraph_PNEANetMP_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertGraph_PNEANetMP_PNEANetMP(tinspec, *args) + raise TypeError('First argument has invalid type') +def ConvertSubGraph(toutspec, tinspec, *args): + if toutspec == PUNGraph: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PUNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertSubGraph_PUNGraph_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertSubGraph_PUNGraph_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PUNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PUNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PUNGraph_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertSubGraph_PUNGraph_PNEANetMP(tinspec, *args) + if toutspec == PUndirNet: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PUndirNet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertSubGraph_PUndirNet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertSubGraph_PUndirNet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PUndirNet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PUndirNet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PUndirNet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertSubGraph_PUndirNet_PNEANetMP(tinspec, *args) + if toutspec == PDirNet: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PDirNet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertSubGraph_PDirNet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertSubGraph_PDirNet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PDirNet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PDirNet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PDirNet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertSubGraph_PDirNet_PNEANetMP(tinspec, *args) + if toutspec == PNGraph: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertSubGraph_PNGraph_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertSubGraph_PNGraph_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PNGraph_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertSubGraph_PNGraph_PNEANetMP(tinspec, *args) + if toutspec == PNEANet: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PNEANet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertSubGraph_PNEANet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertSubGraph_PNEANet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PNEANet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PNEANet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PNEANet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertSubGraph_PNEANet_PNEANetMP(tinspec, *args) + if toutspec == PNGraphMP: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PNGraphMP_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertSubGraph_PNGraphMP_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertSubGraph_PNGraphMP_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PNGraphMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PNGraphMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PNGraphMP_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertSubGraph_PNGraphMP_PNEANetMP(tinspec, *args) + if toutspec == PNEANetMP: + if type(tinspec) == PUNGraph: + return ConvertSubGraph_PNEANetMP_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertSubGraph_PNEANetMP_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertSubGraph_PNEANetMP_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertSubGraph_PNEANetMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertSubGraph_PNEANetMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertSubGraph_PNEANetMP_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertSubGraph_PNEANetMP_PNEANetMP(tinspec, *args) + raise TypeError('First argument has invalid type') +def ConvertESubGraph(toutspec, tinspec, *args): + if toutspec == PUNGraph: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PUNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertESubGraph_PUNGraph_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertESubGraph_PUNGraph_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PUNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PUNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PUNGraph_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertESubGraph_PUNGraph_PNEANetMP(tinspec, *args) + if toutspec == PUndirNet: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PUndirNet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertESubGraph_PUndirNet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertESubGraph_PUndirNet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PUndirNet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PUndirNet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PUndirNet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertESubGraph_PUndirNet_PNEANetMP(tinspec, *args) + if toutspec == PDirNet: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PDirNet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertESubGraph_PDirNet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertESubGraph_PDirNet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PDirNet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PDirNet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PDirNet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertESubGraph_PDirNet_PNEANetMP(tinspec, *args) + if toutspec == PNGraph: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PNGraph_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertESubGraph_PNGraph_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertESubGraph_PNGraph_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PNGraph_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PNGraph_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PNGraph_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertESubGraph_PNGraph_PNEANetMP(tinspec, *args) + if toutspec == PNEANet: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PNEANet_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertESubGraph_PNEANet_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertESubGraph_PNEANet_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PNEANet_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PNEANet_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PNEANet_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertESubGraph_PNEANet_PNEANetMP(tinspec, *args) + if toutspec == PNGraphMP: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PNGraphMP_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertESubGraph_PNGraphMP_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertESubGraph_PNGraphMP_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PNGraphMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PNGraphMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PNGraphMP_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertESubGraph_PNGraphMP_PNEANetMP(tinspec, *args) + if toutspec == PNEANetMP: + if type(tinspec) == PUNGraph: + return ConvertESubGraph_PNEANetMP_PUNGraph(tinspec, *args) + if type(tinspec) == PUndirNet: + return ConvertESubGraph_PNEANetMP_PUndirNet(tinspec, *args) + if type(tinspec) == PDirNet: + return ConvertESubGraph_PNEANetMP_PDirNet(tinspec, *args) + if type(tinspec) == PNGraph: + return ConvertESubGraph_PNEANetMP_PNGraph(tinspec, *args) + if type(tinspec) == PNEANet: + return ConvertESubGraph_PNEANetMP_PNEANet(tinspec, *args) + if type(tinspec) == PNGraphMP: + return ConvertESubGraph_PNEANetMP_PNGraphMP(tinspec, *args) + if type(tinspec) == PNEANetMP: + return ConvertESubGraph_PNEANetMP_PNEANetMP(tinspec, *args) + raise TypeError('First argument has invalid type') +def ToNetwork(tspec, *args): + if tspec == PNEANet : return ToNetwork_PNEANet(*args) + raise TypeError('First argument has invalid type') +def ToGraph(tspec, *args): + if tspec == PUNGraph: return ToGraph_PUNGraph(*args) + if tspec == PUndirNet: return ToGraph_PUndirNet(*args) + if tspec == PDirNet: return ToGraph_PDirNet(*args) + if tspec == PNGraph : return ToGraph_PNGraph(*args) + raise TypeError('First argument has invalid type') + +# +# generators for nodes and edges +# + +# iterate through all the nodes +def Nodes(self): + NI = self.BegNI() + while NI < self.EndNI(): + yield NI + NI.Next() + +# iterate through all the edges +def Edges(self): + EI = self.BegEI() + while EI < self.EndEI(): + yield EI + EI.Next() + +# iterate through out edges of a node +def GetOutEdges(self): + for e in range(0, self.GetOutDeg()): + yield self.GetOutNId(e) + +# iterate through in edges of a node +def GetInEdges(self): + for e in range(0, self.GetInDeg()): + yield self.GetInNId(e) + +# +# generators for nodes and edges +# + +# iterate through all the nodes +def MMNodes(self): + NI = self.BegMMNI() + while NI < self.EndMMNI(): + yield NI + NI.Next() + +# +# redefine some methods to use T... class not P... class +# + +def Clr(self): + self().Clr() + +def Empty(self): + return self().Empty() + +def Save(self,*args): + self().Save(*args) + +# +# define generator and redirection methods +# + +PNEANet.Nodes = Nodes +PNEANet.Edges = Edges +PNEANet.Clr = Clr +PNEANet.Empty = Empty +PNEANet.Save = Save + +TModeNet.Nodes = MMNodes +TModeNet.Edges = Edges + +PMMNet.Save = Save + +PUNGraph.Nodes = Nodes +PUNGraph.Edges = Edges +PUNGraph.Clr = Clr +PUNGraph.Empty = Empty +PUNGraph.Save = Save + + +PUndirNet.Nodes = Nodes +PUndirNet.Edges = Edges +PUndirNet.Clr = Clr +PUndirNet.Empty = Empty +PUndirNet.Save = Save + +PDirNet.Nodes = Nodes +PDirNet.Edges = Edges +PDirNet.Clr = Clr +PDirNet.Empty = Empty +PDirNet.Save = Save + +PNGraph.Nodes = Nodes +PNGraph.Edges = Edges +PNGraph.Clr = Clr +PNGraph.Empty = Empty +PNGraph.Save = Save + +TNGraphNodeI.GetOutEdges = GetOutEdges +TNGraphNodeI.GetInEdges = GetInEdges + +TUNGraphNodeI.GetOutEdges = GetOutEdges +TUNGraphNodeI.GetInEdges = GetInEdges + +TDirNetNodeI.GetOutEdges = GetOutEdges +TDirNetNodeI.GetInEdges = GetInEdges + +TUndirNetNodeI.GetOutEdges = GetOutEdges +TUndirNetNodeI.GetInEdges = GetInEdges + +TNEANetNodeI.GetOutEdges = GetOutEdges +TNEANetNodeI.GetInEdges = GetInEdges + +TModeNetNodeI.GetOutEdges = GetOutEdges +TModeNetNodeI.GetInEdges = GetInEdges + +%} + +#ifdef GCC_ATOMIC +%pythoncode %{ + +PNGraphMP.Nodes = Nodes +PNGraphMP.Edges = Edges +PNGraphMP.Clr = Clr +PNGraphMP.Empty = Empty +PNGraphMP.Save = Save + +PNEANetMP.Nodes = Nodes +PNEANetMP.Edges = Edges +PNEANetMP.Clr = Clr +PNEANetMP.Empty = Empty +PNEANetMP.Save = Save + +TNGraphMPNodeI.GetOutEdges = GetOutEdges +TNGraphMPNodeI.GetInEdges = GetInEdges + +TNEANetMPNodeI.GetOutEdges = GetOutEdges +TNEANetMPNodeI.GetInEdges = GetInEdges + +%} +#endif // GCC_ATOMIC diff --git a/snap-python/source/swig/pmmnet.i b/snap-python/source/swig/pmmnet.i new file mode 100644 index 0000000000000000000000000000000000000000..11b2734b50cb0dab5d0d05de08342870557db575 --- /dev/null +++ b/snap-python/source/swig/pmmnet.i @@ -0,0 +1,32 @@ +// pmmnet.i +// Templates for SNAP TMMNet +// + +%extend TMMNet { + TMMNetModeNetI BegModeNetI() { + return TMMNetModeNetI($self->BegModeNetI()); + } + TMMNetModeNetI EndModeNetI() { + return TMMNetModeNetI($self->EndModeNetI()); + } + TMMNetModeNetI GetModeNetI(const int &NId) { + return TMMNetModeNetI($self->GetModeNetI(NId)); + } + + + TMMNetCrossNetI BegCrossNetI() { + return TMMNetCrossNetI ($self->BegCrossNetI()); + } + TMMNetCrossNetI EndCrossNetI() { + return TMMNetCrossNetI ($self->EndCrossNetI()); + } + TMMNetCrossNetI GetCrossNetI(const int &CId) { + return TMMNetCrossNetI ($self->GetCrossNetI(CId)); + } + +}; + + + +// Basic TMMNets +%template(PMMNet) TPt< TMMNet >; diff --git a/snap-python/source/swig/pneanet.i b/snap-python/source/swig/pneanet.i new file mode 100644 index 0000000000000000000000000000000000000000..7a1caf7d58cf0295ce6e37726b66488dab8709f4 --- /dev/null +++ b/snap-python/source/swig/pneanet.i @@ -0,0 +1,366 @@ +// pneanet.i +// Templates for SNAP TNEANet, PNEANet +// + +/* + Instantiates templates from SNAP for inclusion in RINGO. + Note in Vim, this replaces SNAP Template headers: + + :%s#^template.* \S* \([^(]*\).*#%template(\1) TSnap::\1;#gc + :%s#^///.*\n:##g +*/ + +%extend TNEANet { + // node iterator + TNEANetNodeI BegNI() { + return TNEANetNodeI($self->BegNI()); + } + TNEANetNodeI EndNI() { + return TNEANetNodeI($self->EndNI()); + } + TNEANetNodeI GetNI(const int &NId) { + return TNEANetNodeI($self->GetNI(NId)); + } + + // add node attribute value + int AddIntAttrDatN(const TNEANetNodeI& NI, const TInt& Value, const TStr& Attr) { + return $self->AddIntAttrDatN(NI.GetNI(), Value, Attr); + } + int AddFltAttrDatN(const TNEANetNodeI& NI, const TFlt& Value, const TStr& Attr) { + return $self->AddFltAttrDatN(NI.GetNI(), Value, Attr); + } + int AddStrAttrDatN(const TNEANetNodeI& NI, const TStr& Value, const TStr& Attr) { + return $self->AddStrAttrDatN(NI.GetNI(), Value, Attr); + } + + // get node attribute value + TInt GetIntAttrDatN(const TNEANetNodeI& NI, const TStr& Attr) { + return $self->GetIntAttrDatN(NI.GetNI(), Attr); + } + TFlt GetFltAttrDatN(const TNEANetNodeI& NI, const TStr& Attr) { + return $self->GetFltAttrDatN(NI.GetNI(), Attr); + } + TStr GetStrAttrDatN(const TNEANetNodeI& NI, const TStr& Attr) { + return $self->GetStrAttrDatN(NI.GetNI(), Attr); + } + + // get node attribute value by index + TInt GetIntAttrIndDatN(const TNEANetNodeI& NI, const int& index) { + return $self->GetIntAttrIndDatN(NI.GetNI(), index); + } + TFlt GetFltAttrIndDatN(const TNEANetNodeI& NI, const int& index) { + return $self->GetFltAttrIndDatN(NI.GetNI(), index); + } + TStr GetStrAttrIndDatN(const TNEANetNodeI& NI, const int& index) { + return $self->GetStrAttrIndDatN(NI.GetNI(), index); + } + + // delete node attribute value + int DelAttrDatN(const TNEANetNodeI& NI, const TStr& Attr) { + return $self->DelAttrDatN(NI.GetNI(), Attr); + } + + // edge iterator + TNEANetEdgeI BegEI() { + return TNEANetEdgeI($self->BegEI()); + } + TNEANetEdgeI EndEI() { + return TNEANetEdgeI($self->EndEI()); + } + TNEANetEdgeI GetEI(const int &EId) { + return TNEANetEdgeI($self->GetEI(EId)); + } + TNEANetEdgeI GetEI(const int &SrcNId, const int &DstNId) { + return TNEANetEdgeI($self->GetEI(SrcNId, DstNId)); + } + + // add edge attributes value + int AddIntAttrDatE(const TNEANetEdgeI& EI, const TInt& Value, const TStr& Attr) { + return $self->AddIntAttrDatE(EI.GetEI(), Value, Attr); + } + int AddFltAttrDatE(const TNEANetEdgeI& EI, const TFlt& Value, const TStr& Attr) { + return $self->AddFltAttrDatE(EI.GetEI(), Value, Attr); + } + int AddStrAttrDatE(const TNEANetEdgeI& EI, const TStr& Value, const TStr& Attr) { + return $self->AddStrAttrDatE(EI.GetEI(), Value, Attr); + } + + // get edge attribute value + TInt GetIntAttrDatE(const TNEANetEdgeI& EI, const TStr& Attr) { + return $self->GetIntAttrDatE(EI.GetEI(), Attr); + } + TFlt GetFltAttrDatE(const TNEANetEdgeI& EI, const TStr& Attr) { + return $self->GetFltAttrDatE(EI.GetEI(), Attr); + } + TStr GetStrAttrDatE(const TNEANetEdgeI& EI, const TStr& Attr) { + return $self->GetStrAttrDatE(EI.GetEI(), Attr); + } + + // get edge attribute value by index + TInt GetIntAttrIndDatE(const TNEANetEdgeI& EI, const int& index) { + return $self->GetIntAttrIndDatE(EI.GetEI(), index); + } + TFlt GetFltAttrIndDatE(const TNEANetEdgeI& EI, const int& index) { + return $self->GetFltAttrIndDatE(EI.GetEI(), index); + } + TStr GetStrAttrIndDatE(const TNEANetEdgeI& EI, const int& index) { + return $self->GetStrAttrIndDatE(EI.GetEI(), index); + } + + // delete edge attribute value + int DelAttrDatE(const TNEANetEdgeI& EI, const TStr& Attr) { + return $self->DelAttrDatE(EI.GetEI(), Attr); + } + + TNEANetAIntI BegNAIntI(const TStr& Attr) { + return TNEANetAIntI($self->BegNAIntI(Attr)); + } + TNEANetAIntI EndNAIntI(const TStr& Attr) { + return TNEANetAIntI($self->EndNAIntI(Attr)); + } + + TNEANetAStrI BegNAStrI(const TStr& Attr) { + return TNEANetAStrI($self->BegNAStrI(Attr)); + } + TNEANetAStrI EndNAStrI(const TStr& Attr) { + return TNEANetAStrI($self->EndNAStrI(Attr)); + } + + TNEANetAFltI BegNAFltI(const TStr& Attr) { + return TNEANetAFltI($self->BegNAFltI(Attr)); + } + TNEANetAFltI EndNAFltI(const TStr& Attr) { + return TNEANetAFltI($self->EndNAFltI(Attr)); + } + + TNEANetAIntI BegEAIntI(const TStr& Attr) { + return TNEANetAIntI($self->BegEAIntI(Attr)); + } + TNEANetAIntI EndEAIntI(const TStr& Attr) { + return TNEANetAIntI($self->EndEAIntI(Attr)); + } + + TNEANetAStrI BegEAStrI(const TStr& Attr) { + return TNEANetAStrI($self->BegEAStrI(Attr)); + } + TNEANetAStrI EndEAStrI(const TStr& Attr) { + return TNEANetAStrI($self->EndEAStrI(Attr)); + } + + TNEANetAFltI BegEAFltI(const TStr& Attr) { + return TNEANetAFltI($self->BegEAFltI(Attr)); + } + TNEANetAFltI EndEAFltI(const TStr& Attr) { + return TNEANetAFltI($self->EndEAFltI(Attr)); + } + +}; + + +// Convert a directed graph to a multi-edge attribute graph +//%template(ConvertGraphToPNEANet) ConvertGraph; + +// Use PNEANet as default function name. + +%template(PrintGraphStatTable_PNEANet) PrintGraphStatTable; + +//%template(MxSccSz_PNEANet) TSnap::GetMxScc; +//%template(MxWccSz_PNEANet) TSnap::GetMxWccSz; +// End Basic Directed Graphs + + +// Basic PNEANets +%template(PNEANet) TPt< TNEANet >; + + +// gbase.h - PNEANet +%template(PrintInfo_PNEANet) TSnap::PrintInfo; + +// cncom.h - PNEANet +%template(GetNodeWcc_PNEANet) TSnap::GetNodeWcc; +%template(IsConnected_PNEANet) TSnap::IsConnected; +%template(IsWeaklyConn_PNEANet) TSnap::IsWeaklyConn; +%template(GetWccSzCnt_PNEANet) TSnap::GetWccSzCnt; +%template(GetWccs_PNEANet) TSnap::GetWccs; +%template(GetSccSzCnt_PNEANet) TSnap::GetSccSzCnt; +%template(GetSccs_PNEANet) TSnap::GetSccs; +%template(GetMxWccSz_PNEANet) TSnap::GetMxWccSz; +%template(GetMxSccSz_PNEANet) TSnap::GetMxSccSz; + +%template(GetMxWcc_PNEANet) TSnap::GetMxWcc; +%template(GetMxScc_PNEANet) TSnap::GetMxScc; +%template(GetMxBiCon_PNEANet) TSnap::GetMxBiCon; + +// centr.h - PNEANet +%template(GetNodeEcc_PNEANet) TSnap::GetNodeEcc; +%template(GetPageRank_PNEANet) TSnap::GetPageRank; +%template(GetPageRank_v1_PNEANet) TSnap::GetPageRank_v1; +%template(GetHits_PNEANet) TSnap::GetHits; +%template(GetBetweennessCentr_PNEANet) TSnap::GetBetweennessCentr; +%template(GetClosenessCentr_PNEANet) TSnap::GetClosenessCentr; +%template(GetFarnessCentr_PNEANet) TSnap::GetFarnessCentr; +#ifdef _OPENMP +%template(GetPageRankMP_PNEANet) TSnap::GetPageRankMP; +%template(GetHitsMP_PNEANet) TSnap::GetHitsMP; +#endif + + +// alg.h - PNEANet +%template(CntInDegNodes_PNEANet) TSnap::CntInDegNodes; +%template(CntOutDegNodes_PNEANet) TSnap::CntOutDegNodes; +%template(CntDegNodes_PNEANet) TSnap::CntDegNodes; +%template(CntNonZNodes_PNEANet) TSnap::CntNonZNodes; +%template(CntEdgesToSet_PNEANet) TSnap::CntEdgesToSet; + +%template(GetMxDegNId_PNEANet) TSnap::GetMxDegNId; +%template(GetMxInDegNId_PNEANet) TSnap::GetMxInDegNId; +%template(GetMxOutDegNId_PNEANet) TSnap::GetMxOutDegNId; + +%template(GetInDegCnt_PNEANet) TSnap::GetInDegCnt; +%template(GetOutDegCnt_PNEANet) TSnap::GetOutDegCnt; +%template(GetDegCnt_PNEANet) TSnap::GetDegCnt; +%template(GetDegSeqV_PNEANet) TSnap::GetDegSeqV; + +%template(GetNodeInDegV_PNEANet) TSnap::GetNodeInDegV; +%template(GetNodeOutDegV_PNEANet) TSnap::GetNodeOutDegV; + +%template(CntUniqUndirEdges_PNEANet) TSnap::CntUniqUndirEdges; +%template(CntUniqDirEdges_PNEANet) TSnap::CntUniqDirEdges; +%template(CntUniqBiDirEdges_PNEANet) TSnap::CntUniqBiDirEdges; +%template(CntSelfEdges_PNEANet) TSnap::CntSelfEdges; + +%template(GetUnDir_PNEANet) TSnap::GetUnDir; +%template(MakeUnDir_PNEANet) TSnap::MakeUnDir; +%template(AddSelfEdges_PNEANet) TSnap::AddSelfEdges; +%template(DelSelfEdges_PNEANet) TSnap::DelSelfEdges; +%template(DelNodes_PNEANet) TSnap::DelNodes; +%template(DelZeroDegNodes_PNEANet) TSnap::DelZeroDegNodes; +%template(DelDegKNodes_PNEANet) TSnap::DelDegKNodes; +%template(IsTree_PNEANet) TSnap::IsTree; +%template(GetTreeRootNId_PNEANet) TSnap::GetTreeRootNId; +%template(GetTreeSig_PNEANet) TSnap::GetTreeSig; + + +// bfsdfs.h - PNEANet +%template(GetBfsTree_PNEANet) TSnap::GetBfsTree; +%template(GetSubTreeSz_PNEANet) TSnap::GetSubTreeSz; +%template(GetNodesAtHop_PNEANet) TSnap::GetNodesAtHop; +%template(GetNodesAtHops_PNEANet) TSnap::GetNodesAtHops; +// Shortest paths +%template(GetShortPath_PNEANet) TSnap::GetShortPath; +// Diameter +%template(GetBfsFullDiam_PNEANet) TSnap::GetBfsFullDiam; +%template(GetBfsEffDiam_PNEANet) TSnap::GetBfsEffDiam; +%template(GetBfsEffDiamAll_PNEANet) TSnap::GetBfsEffDiamAll; + + +// drawgviz.h +%template(DrawGViz_PNEANet) TSnap::DrawGViz; + + +// ggen.h +%template(GenGrid_PNEANet) TSnap::GenGrid; +%template(GenStar_PNEANet) TSnap::GenStar; +%template(GenCircle_PNEANet) TSnap::GenCircle; +%template(GenFull_PNEANet) TSnap::GenFull; +%template(GenTree_PNEANet) TSnap::GenTree; +%template(GenBaraHierar_PNEANet) TSnap::GenBaraHierar; +%template(GenRndGnm_PNEANet) TSnap::GenRndGnm; + + +// gio.h +%template(LoadEdgeList_PNEANet) TSnap::LoadEdgeList; +%template(LoadEdgeListStr_PNEANet) TSnap::LoadEdgeListStr; +%template(LoadConnList_PNEANet) TSnap::LoadConnList; +%template(LoadConnListStr_PNEANet) TSnap::LoadConnListStr; +%template(LoadPajek_PNEANet) TSnap::LoadPajek; +%template(SaveEdgeList_PNEANet) TSnap::SaveEdgeList; +%template(SavePajek_PNEANet) TSnap::SavePajek; +%template(SaveMatlabSparseMtx_PNEANet) TSnap::SaveMatlabSparseMtx; +%template(SaveGViz_PNEANet) TSnap::SaveGViz; + + +// kcore.h +%template(GetKCore_PNEANet) TSnap::GetKCore; +%template(GetKCoreEdges_PNEANet) TSnap::GetKCoreEdges; +%template(GetKCoreNodes_PNEANet) TSnap::GetKCoreNodes; + + +// subgraph.h +%template(ConvertGraph_PNEANet_PNEANet) TSnap::ConvertGraph ; +%template(ConvertGraph_PNEANet_PNGraph) TSnap::ConvertGraph ; +%template(ConvertGraph_PNEANet_PUNGraph) TSnap::ConvertGraph ; +%template(ConvertSubGraph_PNEANet_PNEANet) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PNEANet_PNGraph) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PNEANet_PUNGraph) TSnap::ConvertSubGraph ; +%template(ConvertESubGraph_PNEANet_PNEANet) TSnap::ConvertESubGraph ; +%template(GetSubGraph_PNEANet) TSnap::GetSubGraph; +%template(GetESubGraph_PNEANet) TSnap::GetESubGraph; +%template(GetRndSubGraph_PNEANet) TSnap::GetRndSubGraph; +%template(GetRndESubGraph_PNEANet) TSnap::GetRndESubGraph; +%template(GetEgonetHop_PNEANet) TSnap::GetEgonetHop; +%template(GetInEgonetHop_PNEANet) TSnap::GetInEgonetHop; +%template(GetOutEgonetHop_PNEANet) TSnap::GetOutEgonetHop; +%template(GetInEgonetSub_PNEANet) TSnap::GetInEgonetSub; +%template(GetGraphUnion_PNEANet) TSnap::GetGraphUnion; +%template(GetGraphIntersection_PNEANet) TSnap::GetGraphIntersection; + + +// triad.h - PNEANet +%template(GetClustCf_PNEANet) TSnap::GetClustCf; +%template(GetClustCfAll_PNEANet) TSnap::GetClustCfAll; +%template(GetNodeClustCf_PNEANet) TSnap::GetNodeClustCf; +%template(GetTriads_PNEANet) TSnap::GetTriads; +%template(GetTriadsAll_PNEANet) TSnap::GetTriadsAll; +%template(GetTriadEdges_PNEANet) TSnap::GetTriadEdges; +%template(GetNodeTriads_PNEANet) TSnap::GetNodeTriads; +%template(GetNodeTriadsAll_PNEANet) TSnap::GetNodeTriadsAll; +%template(GetTriadParticip_PNEANet) TSnap::GetTriadParticip; +%template(GetTriangleCnt_PNEANet) TSnap::GetTriangleCnt; + +%template(GetCmnNbrs_PNEANet) TSnap::GetCmnNbrs; +%template(GetLen2Paths_PNEANet) TSnap::GetLen2Paths; + + +// cmty.h - PNEANet +%template(GetModularity_PNEANet) TSnap::GetModularity; +%template(GetEdgesInOut_PNEANet) TSnap::GetEdgesInOut; + + +// anf.h - PNEANet +%template(GetAnf_PNEANet) TSnap::GetAnf; +%template(GetAnfEffDiam_PNEANet) TSnap::GetAnfEffDiam; +%template(TestAnf_PNEANet) TSnap::TestAnf; + + +// statplot.h - PNEANet +%template(PlotKCoreEdges_PNEANet) TSnap::PlotKCoreEdges; +%template(PlotKCoreNodes_PNEANet) TSnap::PlotKCoreNodes; +%template(PlotShortPathDistr_PNEANet) TSnap::PlotShortPathDistr; +%template(PlotHops_PNEANet) TSnap::PlotHops; +%template(PlotClustCf_PNEANet) TSnap::PlotClustCf; +%template(PlotSccDistr_PNEANet) TSnap::PlotSccDistr; +%template(PlotWccDistr_PNEANet) TSnap::PlotWccDistr; +%template(PlotOutDegDistr_PNEANet) TSnap::PlotOutDegDistr; +%template(PlotInDegDistr_PNEANet) TSnap::PlotInDegDistr; + + +// goodgraph.cpp - PNEANet +%template(PercentDegree_PNEANet) PercentDegree; +%template(NodesGTEDegree_PNEANet) NodesGTEDegree; +%template(MxDegree_PNEANet) MxDegree; +%template(PercentMxWcc_PNEANet) PercentMxWcc; +%template(PercentMxScc_PNEANet) PercentMxScc; + +// conv.h - PNEANet +%template(ToNetwork_PNEANet) TSnap::ToNetwork; + +//%rename(ToNetwork_PNEANet) TSnap::ToNetwork(PTable, const TStr &, const TStr &, TStrV &, TAttrAggr); +//TSnap::ToNetwork(PTable, const TStr &, const TStr &, TStrV &, TAttrAggr); +//%rename(ToNetwork_PNEANet) TSnap::ToNetwork(PTable, const TStr &, const TStr &, TAttrAggr); +//TSnap::ToNetwork(PTable, const TStr &, const TStr &, TAttrAggr); +//%rename(ToNetwork_PNEANet) TSnap::ToNetwork(PTable, const TStr &, const TStr &, TVec &, TAttrAggr); +//TSnap::ToNetwork(PTable, const TStr &, const TStr &, TVec &, TAttrAggr); +//%rename(ToNetwork_PNEANet) TSnap::ToNetwork(PTable, const TStr &, const TStr &, TVec &, PTable, const TStr &, TVec &, TAttrAggr); +//TSnap::ToNetwork(PTable, const TStr &, const TStr &, TVec &, PTable, const TStr &, TVec &, TAttrAggr); + diff --git a/snap-python/source/swig/pneanetmp.i b/snap-python/source/swig/pneanetmp.i new file mode 100644 index 0000000000000000000000000000000000000000..724d797f424637cc32c6d343d43d412e61878bb0 --- /dev/null +++ b/snap-python/source/swig/pneanetmp.i @@ -0,0 +1,59 @@ +// pneanetmp.i +// Templates for SNAP TNEANetMP, PNEANetMP + +%extend TNEANetMP { + TNEANetMPNodeI BegNI() { + return TNEANetMPNodeI($self->BegNI()); + } + TNEANetMPNodeI EndNI() { + return TNEANetMPNodeI($self->EndNI()); + } + TNEANetMPNodeI GetNI(const int &NId) { + return TNEANetMPNodeI($self->GetNI(NId)); + } + TNEANetMPEdgeI BegEI() { + return TNEANetMPEdgeI($self->BegEI()); + } + TNEANetMPEdgeI EndEI() { + return TNEANetMPEdgeI($self->EndEI()); + } +}; + +%pythoncode %{ +# redefine TNEANetMPEdgeI.GetId to return a pair of nodes rather than -1 +def GetId(self): + return (self.GetSrcNId(), self.GetDstNId()) + +TNEANetMPEdgeI.GetId = GetId +%} + +#ifdef _OPENMP +%pythoncode %{ +def ToNetworkMP(tspec, *args): + if tspec == PNEANetMP : return ToNetworkMP_PNEANetMP(*args) + return None + +def ToNetworkMP2(tspec, *args): + if tspec == PNEANetMP : return ToNetworkMP2_PNEANetMP(*args) + return None +%} +#endif + + + +// Basic Undirected Graphs + +%template(PrintGraphStatTable_PNEANetMP) PrintGraphStatTable; + +//%template(MxSccSz_PNEANetMP) TSnap::GetMxScc; +//%template(MxWccSz_PNEANetMP) TSnap::GetMxWccSz; +// End Basic Directed Graphs + +// Basic PNEANetMPs +%template(PNEANetMP) TPt< TNEANetMP >; +// conv.h - PNGraph +#ifdef _OPENMP +%template(ToNetworkMP_PNEANetMP) TSnap::ToNetworkMP; +%template(ToNetworkMP2_PNEANetMP) TSnap::ToNetworkMP2; +#endif + diff --git a/snap-python/source/swig/pngraph.i b/snap-python/source/swig/pngraph.i new file mode 100644 index 0000000000000000000000000000000000000000..53d43826e54ad163e23c5e90798cbb28d326a86a --- /dev/null +++ b/snap-python/source/swig/pngraph.i @@ -0,0 +1,225 @@ +// pngraph.i +// Templates for SNAP TNGraph, PNGraph + +%extend TNGraph { + TNGraphNodeI BegNI() { + return TNGraphNodeI($self->BegNI()); + } + TNGraphNodeI EndNI() { + return TNGraphNodeI($self->EndNI()); + } + TNGraphNodeI GetNI(const int &NId) { + return TNGraphNodeI($self->GetNI(NId)); + } + TNGraphEdgeI BegEI() { + return TNGraphEdgeI($self->BegEI()); + } + TNGraphEdgeI EndEI() { + return TNGraphEdgeI($self->EndEI()); + } + TNGraphEdgeI GetEI(const int &SrcNId, const int &DstNId) { + return TNGraphEdgeI($self->GetEI(SrcNId, DstNId)); + } +}; + + +%pythoncode %{ +# redefine TNGraphEdgeI.GetId to return a pair of nodes rather than -1 +def GetId(self): + return (self.GetSrcNId(), self.GetDstNId()) + +TNGraphEdgeI.GetId = GetId +%} + + +// Basic Undirected Graphs + +%template(PrintGraphStatTable_PNGraph) PrintGraphStatTable; + +//%template(MxSccSz_PNGraph) TSnap::GetMxScc; +//%template(MxWccSz_PNGraph) TSnap::GetMxWccSz; +// End Basic Directed Graphs + +// Basic PNGraphs +%template(PNGraph) TPt< TNGraph >; + +// gbase.h - PNGraph +%template(PrintInfo_PNGraph) TSnap::PrintInfo; + +// cncom.h - PNGraph +%template(GetNodeWcc_PNGraph) TSnap::GetNodeWcc; +%template(IsConnected_PNGraph) TSnap::IsConnected; +%template(IsWeaklyConn_PNGraph) TSnap::IsWeaklyConn; +%template(GetWccSzCnt_PNGraph) TSnap::GetWccSzCnt; +%template(GetWccs_PNGraph) TSnap::GetWccs; +%template(GetSccSzCnt_PNGraph) TSnap::GetSccSzCnt; +%template(GetSccs_PNGraph) TSnap::GetSccs; +%template(GetMxWccSz_PNGraph) TSnap::GetMxWccSz; +%template(GetMxSccSz_PNGraph) TSnap::GetMxSccSz; + +%template(GetMxWcc_PNGraph) TSnap::GetMxWcc; +%template(GetMxScc_PNGraph) TSnap::GetMxScc; +%template(GetMxBiCon_PNGraph) TSnap::GetMxBiCon; + +// centr.h - PNGraph +%template(GetNodeEcc_PNGraph) TSnap::GetNodeEcc; +%template(GetPageRank_PNGraph) TSnap::GetPageRank; +%template(GetPageRank_v1_PNGraph) TSnap::GetPageRank_v1; +%template(GetHits_PNGraph) TSnap::GetHits; +%template(GetBetweennessCentr_PNGraph) TSnap::GetBetweennessCentr; +%template(GetClosenessCentr_PNGraph) TSnap::GetClosenessCentr; +%template(GetFarnessCentr_PNGraph) TSnap::GetFarnessCentr; +#ifdef _OPENMP +%template(GetPageRankMP_PNGraph) TSnap::GetPageRankMP; +%template(GetHitsMP_PNGraph) TSnap::GetHitsMP; +#endif + + +// alg.h - PNGraph +%template(CntInDegNodes_PNGraph) TSnap::CntInDegNodes; +%template(CntOutDegNodes_PNGraph) TSnap::CntOutDegNodes; +%template(CntDegNodes_PNGraph) TSnap::CntDegNodes; +%template(CntNonZNodes_PNGraph) TSnap::CntNonZNodes; +%template(CntEdgesToSet_PNGraph) TSnap::CntEdgesToSet; + +%template(GetMxDegNId_PNGraph) TSnap::GetMxDegNId; +%template(GetMxInDegNId_PNGraph) TSnap::GetMxInDegNId; +%template(GetMxOutDegNId_PNGraph) TSnap::GetMxOutDegNId; + +%template(GetInDegCnt_PNGraph) TSnap::GetInDegCnt; +%template(GetOutDegCnt_PNGraph) TSnap::GetOutDegCnt; +%template(GetDegCnt_PNGraph) TSnap::GetDegCnt; +%template(GetDegSeqV_PNGraph) TSnap::GetDegSeqV; + +%template(GetNodeInDegV_PNGraph) TSnap::GetNodeInDegV; +%template(GetNodeOutDegV_PNGraph) TSnap::GetNodeOutDegV; + +%template(CntUniqUndirEdges_PNGraph) TSnap::CntUniqUndirEdges; +%template(CntUniqDirEdges_PNGraph) TSnap::CntUniqDirEdges; +%template(CntUniqBiDirEdges_PNGraph) TSnap::CntUniqBiDirEdges; +%template(CntSelfEdges_PNGraph) TSnap::CntSelfEdges; + +%template(GetUnDir_PNGraph) TSnap::GetUnDir; +%template(MakeUnDir_PNGraph) TSnap::MakeUnDir; +%template(AddSelfEdges_PNGraph) TSnap::AddSelfEdges; +%template(DelSelfEdges_PNGraph) TSnap::DelSelfEdges; +%template(DelNodes_PNGraph) TSnap::DelNodes; +%template(DelZeroDegNodes_PNGraph) TSnap::DelZeroDegNodes; +%template(DelDegKNodes_PNGraph) TSnap::DelDegKNodes; +%template(IsTree_PNGraph) TSnap::IsTree; +%template(GetTreeRootNId_PNGraph) TSnap::GetTreeRootNId; +%template(GetTreeSig_PNGraph) TSnap::GetTreeSig; + + +// bfsdfs.h - PNGraph +%template(GetBfsTree_PNGraph) TSnap::GetBfsTree; +%template(GetSubTreeSz_PNGraph) TSnap::GetSubTreeSz; +%template(GetNodesAtHop_PNGraph) TSnap::GetNodesAtHop; +%template(GetNodesAtHops_PNGraph) TSnap::GetNodesAtHops; +// Shortest paths +%template(GetShortPath_PNGraph) TSnap::GetShortPath; +// Diameter +%template(GetBfsFullDiam_PNGraph) TSnap::GetBfsFullDiam; +%template(GetBfsEffDiam_PNGraph) TSnap::GetBfsEffDiam; +%template(GetBfsEffDiamAll_PNGraph) TSnap::GetBfsEffDiamAll; + + +// drawgviz.h +%template(DrawGViz_PNGraph) TSnap::DrawGViz; + + +// ggen.h +%template(GenGrid_PNGraph) TSnap::GenGrid; +%template(GenStar_PNGraph) TSnap::GenStar; +%template(GenCircle_PNGraph) TSnap::GenCircle; +%template(GenFull_PNGraph) TSnap::GenFull; +%template(GenTree_PNGraph) TSnap::GenTree; +%template(GenBaraHierar_PNGraph) TSnap::GenBaraHierar; +%template(GenRndGnm_PNGraph) TSnap::GenRndGnm; + + +// gio.h +%template(LoadEdgeList_PNGraph) TSnap::LoadEdgeList; +%template(LoadEdgeListStr_PNGraph) TSnap::LoadEdgeListStr; +%template(LoadConnList_PNGraph) TSnap::LoadConnList; +%template(LoadConnListStr_PNGraph) TSnap::LoadConnListStr; +%template(LoadPajek_PNGraph) TSnap::LoadPajek; +%template(SaveEdgeList_PNGraph) TSnap::SaveEdgeList; +%template(SavePajek_PNGraph) TSnap::SavePajek; +%template(SaveMatlabSparseMtx_PNGraph) TSnap::SaveMatlabSparseMtx; +%template(SaveGViz_PNGraph) TSnap::SaveGViz; + + +// kcore.h +%template(GetKCore_PNGraph) TSnap::GetKCore; +%template(GetKCoreEdges_PNGraph) TSnap::GetKCoreEdges; +%template(GetKCoreNodes_PNGraph) TSnap::GetKCoreNodes; + + +// subgraph.h +%template(ConvertGraph_PNGraph_PUNGraph) TSnap::ConvertGraph ; +%template(ConvertGraph_PNGraph_PNGraph) TSnap::ConvertGraph ; +%template(ConvertGraph_PNGraph_PNEANet) TSnap::ConvertGraph ; +%template(ConvertSubGraph_PNGraph_PUNGraph) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PNGraph_PNGraph) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PNGraph_PNEANet) TSnap::ConvertSubGraph ; +%template(ConvertESubGraph_PNGraph_PNEANet) TSnap::ConvertESubGraph ; +%template(GetSubGraph_PNGraph) TSnap::GetSubGraph; +%template(GetSubGraphRenumber_PNGraph) TSnap::GetSubGraphRenumber; +%template(GetRndSubGraph_PNGraph) TSnap::GetRndSubGraph; +%template(GetRndESubGraph_PNGraph) TSnap::GetRndESubGraph; +%template(GetEgonetHop_PNGraph) TSnap::GetEgonetHop; +%template(GetInEgonetHop_PNGraph) TSnap::GetInEgonetHop; +%template(GetOutEgonetHop_PNGraph) TSnap::GetOutEgonetHop; +%template(GetInEgonetSub_PNGraph) TSnap::GetInEgonetSub; +%template(GetGraphUnion_PNGraph) TSnap::GetGraphUnion; +%template(GetGraphIntersection_PNGraph) TSnap::GetGraphIntersection; + + +// triad.h - PNGraph +%template(GetClustCf_PNGraph) TSnap::GetClustCf; +%template(GetClustCfAll_PNGraph) TSnap::GetClustCfAll; +%template(GetNodeClustCf_PNGraph) TSnap::GetNodeClustCf; +%template(GetTriads_PNGraph) TSnap::GetTriads; +%template(GetTriadsAll_PNGraph) TSnap::GetTriadsAll; +%template(GetTriadEdges_PNGraph) TSnap::GetTriadEdges; +%template(GetNodeTriads_PNGraph) TSnap::GetNodeTriads; +%template(GetNodeTriadsAll_PNGraph) TSnap::GetNodeTriadsAll; +%template(GetTriadParticip_PNGraph) TSnap::GetTriadParticip; +%template(GetTriangleCnt_PNGraph) TSnap::GetTriangleCnt; + +%template(GetCmnNbrs_PNGraph) TSnap::GetCmnNbrs; +%template(GetLen2Paths_PNGraph) TSnap::GetLen2Paths; + + +// cmty.h - PNGraph +%template(GetModularity_PNGraph) TSnap::GetModularity; +%template(GetEdgesInOut_PNGraph) TSnap::GetEdgesInOut; + + +// anf.h - PNGraph +%template(GetAnf_PNGraph) TSnap::GetAnf; +%template(GetAnfEffDiam_PNGraph) TSnap::GetAnfEffDiam; +%template(TestAnf_PNGraph) TSnap::TestAnf; + +// statplot.h - PNGraph +%template(PlotKCoreEdges_PNGraph) TSnap::PlotKCoreEdges; +%template(PlotKCoreNodes_PNGraph) TSnap::PlotKCoreNodes; +%template(PlotShortPathDistr_PNGraph) TSnap::PlotShortPathDistr; +%template(PlotHops_PNGraph) TSnap::PlotHops; +%template(PlotClustCf_PNGraph) TSnap::PlotClustCf; +%template(PlotSccDistr_PNGraph) TSnap::PlotSccDistr; +%template(PlotWccDistr_PNGraph) TSnap::PlotWccDistr; +%template(PlotOutDegDistr_PNGraph) TSnap::PlotOutDegDistr; +%template(PlotInDegDistr_PNGraph) TSnap::PlotInDegDistr; + + +// goodgraph.cpp - PNGraph +%template(PercentDegree_PNGraph) PercentDegree; +%template(NodesGTEDegree_PNGraph) NodesGTEDegree; +%template(MxDegree_PNGraph) MxDegree; +%template(PercentMxWcc_PNGraph) PercentMxWcc; +%template(PercentMxScc_PNGraph) PercentMxScc; + +// conv.h - PNGraph +%template(ToGraph_PNGraph) TSnap::ToGraph; diff --git a/snap-python/source/swig/pngraphmp.i b/snap-python/source/swig/pngraphmp.i new file mode 100644 index 0000000000000000000000000000000000000000..0a81c247a923dc7e7c8902ef542e42f031ed2d1b --- /dev/null +++ b/snap-python/source/swig/pngraphmp.i @@ -0,0 +1,60 @@ +// pngraphmp.i +// Templates for SNAP TNGraphMP, PNGraphMP + +%extend TNGraphMP { + TNGraphMPNodeI BegNI() { + return TNGraphMPNodeI($self->BegNI()); + } + TNGraphMPNodeI EndNI() { + return TNGraphMPNodeI($self->EndNI()); + } + TNGraphMPNodeI GetNI(const int &NId) { + return TNGraphMPNodeI($self->GetNI(NId)); + } + TNGraphMPEdgeI BegEI() { + return TNGraphMPEdgeI($self->BegEI()); + } + TNGraphMPEdgeI EndEI() { + return TNGraphMPEdgeI($self->EndEI()); + } +}; + +%pythoncode %{ +# redefine TNGraphMPEdgeI.GetId to return a pair of nodes rather than -1 +def GetId(self): + return (self.GetSrcNId(), self.GetDstNId()) + +TNGraphMPEdgeI.GetId = GetId +%} + +#ifdef _OPENMP +%pythoncode %{ +def ToGraphMP3(tspec, *args): + if tspec == PNGraphMP : return ToGraphMP3_PNGraphMP(*args) + return None + +def ToGraphMP(tspec, *args): + if tspec == PNGraphMP : return ToGraphMP_PNGraphMP(*args) + return None +%} +#endif + + + +// Basic Undirected Graphs + +%template(PrintGraphStatTable_PNGraphMP) PrintGraphStatTable; + +//%template(MxSccSz_PNGraphMP) TSnap::GetMxScc; +//%template(MxWccSz_PNGraphMP) TSnap::GetMxWccSz; +// End Basic Directed Graphs + +// Basic PNGraphMPs +%template(PNGraphMP) TPt< TNGraphMP >; + +// conv.h - PNGraph +#ifdef _OPENMP +%template(ToGraphMP_PNGraphMP) TSnap::ToGraphMP; +%template(ToGraphMP3_PNGraphMP) TSnap::ToGraphMP3; +#endif + diff --git a/snap-python/source/swig/printgraph.h b/snap-python/source/swig/printgraph.h new file mode 100644 index 0000000000000000000000000000000000000000..1f24daa60d20ea19926070f81827c834bf4b1240 --- /dev/null +++ b/snap-python/source/swig/printgraph.h @@ -0,0 +1,51 @@ + +template +void PrintGraphStatTable(const PGraph& G, TStr OutFNm, TStr Desc="") { + TFltPrV DegCCfV; + int64 ClosedTriads, OpenTriads; + int FullDiam; + double EffDiam; + TSnap::PrintInfo(G, OutFNm); + TExeTm ExeTm; printf("C"); + const double CCF = TSnap::GetClustCf(G, DegCCfV, ClosedTriads, OpenTriads); + printf("[%s]D", ExeTm.GetStr()); + TSnap::GetBfsEffDiam(G, 1000, false, EffDiam, FullDiam); + printf("[%s]CC", ExeTm.GetStr()); + PGraph WCC = TSnap::GetMxWcc(G); + PGraph SCC = TSnap::GetMxScc(G); + printf("[%s]\n", ExeTm.GetStr()); + FILE* F = stdout; + if (! OutFNm.Empty()) { + F = fopen(TStr::Fmt("%s.html", OutFNm.CStr()).CStr(), "wt"); } + fprintf(F, "\n"); + fprintf(F, "\n"); + fprintf(F, " \n"); + fprintf(F, " \n", G->GetNodes()); + fprintf(F, " \n", G->GetEdges()); + fprintf(F, " \n", WCC->GetNodes(), WCC->GetNodes()/double(G->GetNodes())); + fprintf(F, " \n", WCC->GetEdges(), WCC->GetEdges()/double(G->GetEdges())); + fprintf(F, " \n", SCC->GetNodes(), SCC->GetNodes()/double(G->GetNodes())); + fprintf(F, " \n", SCC->GetEdges(), SCC->GetEdges()/double(G->GetEdges())); + fprintf(F, " \n", CCF); + fprintf(F, " \n", TUInt64(ClosedTriads).GetStr().CStr()); + fprintf(F, " \n", ClosedTriads/double(ClosedTriads+OpenTriads)); + fprintf(F, " \n", FullDiam); + fprintf(F, " \n", EffDiam); + fprintf(F, "
Dataset statistics
Nodes %d
Edges %d
Nodes in largest WCC %d (%.3f)
Edges in largest WCC %d (%.3f)
Nodes in largest SCC %d (%.3f)
Edges in largest SCC %d (%.3f)
Average clustering coefficient %.4f
Number of triangles %s
Fraction of closed triangles %.4g
Diameter (longest shortest path) %d
90-percentile effective diameter %.2g
\n"); + fprintf(F, "
\n"); + if (! OutFNm.Empty()) { + fprintf(F, "\n\n"); + fprintf(F, "\n"); + fprintf(F, " \n"); + fprintf(F, " \n"); + fprintf(F, "\n"); + fprintf(F, "\n"); + fprintf(F, " \n", OutFNm.CStr(), OutFNm.CStr()); + fprintf(F, " \n", Desc.CStr()); + fprintf(F, "\n"); + fprintf(F, "
FileDescription
%s.txt.gz%s
\n"); + fclose(F); + TSnap::SaveEdgeList(G, OutFNm+".txt", Desc); + } +} + diff --git a/snap-python/source/swig/ptable.i b/snap-python/source/swig/ptable.i new file mode 100644 index 0000000000000000000000000000000000000000..6bcf82ead2b6a5f36276fa5b70f95fb77847dc08 --- /dev/null +++ b/snap-python/source/swig/ptable.i @@ -0,0 +1,24 @@ +// ptable.i +// Templates for SNAP, common functions to TTable + +// Basic PTable +%template(PTable) TPt< TTable >; + +%pythoncode %{ + + +# +# redefine some methods to use T... class not P... class +# + +def Save(self,*args): + self().Save(*args) + +# +# define generator and redirection methods +# + +PTable.Save = Save + +%} + diff --git a/snap-python/source/swig/pundirnet.i b/snap-python/source/swig/pundirnet.i new file mode 100644 index 0000000000000000000000000000000000000000..2fba6cb92fc508f439cb5ab604f20899f7830333 --- /dev/null +++ b/snap-python/source/swig/pundirnet.i @@ -0,0 +1,212 @@ +// pundirnet.i +// Templates for SNAP TUndirNet, PUndirNet + +%extend TUndirNet { + TUndirNetNodeI BegNI() { + return TUndirNetNodeI($self->BegNI()); + } + TUndirNetNodeI EndNI() { + return TUndirNetNodeI($self->EndNI()); + } + TUndirNetNodeI GetNI(const int &NId) { + return TUndirNetNodeI($self->GetNI(NId)); + } + TUndirNetEdgeI BegEI() { + return TUndirNetEdgeI($self->BegEI()); + } + TUndirNetEdgeI EndEI() { + return TUndirNetEdgeI($self->EndEI()); + } +}; + +%pythoncode %{ +# redefine TUndirNetEdgeI.GetId to return a pair of nodes rather than -1 +def GetId(self): + return (self.GetSrcNId(), self.GetDstNId()) + +TUndirNetEdgeI.GetId = GetId +%} + +// Basic Undirected Graphs + +%template(PrintGraphStatTable_PUndirNet) PrintGraphStatTable; + +//%template(MxSccSz_PUndirNet) TSnap::GetMxScc; +//%template(MxWccSz_PUndirNet) TSnap::GetMxWccSz; +// End Basic Directed Graphs + +// Basic PUndirNets +%template(PUndirNet) TPt< TUndirNet >; + +// gbase.h - PUndirNet +%template(PrintInfo_PUndirNet) TSnap::PrintInfo; + +// cncom.h - PUndirNet +%template(GetNodeWcc_PUndirNet) TSnap::GetNodeWcc; +%template(IsConnected_PUndirNet) TSnap::IsConnected; +%template(IsWeaklyConn_PUndirNet) TSnap::IsWeaklyConn; +%template(GetWccSzCnt_PUndirNet) TSnap::GetWccSzCnt; +%template(GetWccs_PUndirNet) TSnap::GetWccs; +%template(GetSccSzCnt_PUndirNet) TSnap::GetSccSzCnt; +%template(GetSccs_PUndirNet) TSnap::GetSccs; +%template(GetMxWccSz_PUndirNet) TSnap::GetMxWccSz; +%template(GetMxSccSz_PUndirNet) TSnap::GetMxSccSz; + +%template(GetMxWcc_PUndirNet) TSnap::GetMxWcc; +%template(GetMxScc_PUndirNet) TSnap::GetMxScc; +%template(GetMxBiCon_PUndirNet) TSnap::GetMxBiCon; + +// centr.h - PUndirNet +%template(GetNodeEcc_PUndirNet) TSnap::GetNodeEcc; +%template(GetPageRank_PUndirNet) TSnap::GetPageRank; +%template(GetPageRank_v1_PUndirNet) TSnap::GetPageRank_v1; +%template(GetHits_PUndirNet) TSnap::GetHits; +#ifdef _OPENMP +%template(GetPageRankMP_PUndirNet) TSnap::GetPageRankMP; +%template(GetHitsMP_PUndirNet) TSnap::GetHitsMP; +#endif + +// alg.h - PUndirNet +%template(CntInDegNodes_PUndirNet) TSnap::CntInDegNodes; +%template(CntOutDegNodes_PUndirNet) TSnap::CntOutDegNodes; +%template(CntDegNodes_PUndirNet) TSnap::CntDegNodes; +%template(CntNonZNodes_PUndirNet) TSnap::CntNonZNodes; +%template(CntEdgesToSet_PUndirNet) TSnap::CntEdgesToSet; + +%template(GetMxDegNId_PUndirNet) TSnap::GetMxDegNId; +%template(GetMxInDegNId_PUndirNet) TSnap::GetMxInDegNId; +%template(GetMxOutDegNId_PUndirNet) TSnap::GetMxOutDegNId; + +%template(GetInDegCnt_PUndirNet) TSnap::GetInDegCnt; +%template(GetOutDegCnt_PUndirNet) TSnap::GetOutDegCnt; +%template(GetDegCnt_PUndirNet) TSnap::GetDegCnt; +%template(GetDegSeqV_PUndirNet) TSnap::GetDegSeqV; + +%template(GetNodeInDegV_PUndirNet) TSnap::GetNodeInDegV; +%template(GetNodeOutDegV_PUndirNet) TSnap::GetNodeOutDegV; + +%template(CntUniqUndirEdges_PUndirNet) TSnap::CntUniqUndirEdges; +%template(CntUniqDirEdges_PUndirNet) TSnap::CntUniqDirEdges; +%template(CntUniqBiDirEdges_PUndirNet) TSnap::CntUniqBiDirEdges; +%template(CntSelfEdges_PUndirNet) TSnap::CntSelfEdges; + +%template(GetUnDir_PUndirNet) TSnap::GetUnDir; +%template(MakeUnDir_PUndirNet) TSnap::MakeUnDir; +%template(AddSelfEdges_PUndirNet) TSnap::AddSelfEdges; +%template(DelSelfEdges_PUndirNet) TSnap::DelSelfEdges; +%template(DelNodes_PUndirNet) TSnap::DelNodes; +%template(DelZeroDegNodes_PUndirNet) TSnap::DelZeroDegNodes; +%template(DelDegKNodes_PUndirNet) TSnap::DelDegKNodes; +%template(IsTree_PUndirNet) TSnap::IsTree; +%template(GetTreeRootNId_PUndirNet) TSnap::GetTreeRootNId; +%template(GetTreeSig_PUndirNet) TSnap::GetTreeSig; + + +// bfsdfs.h - PUndirNet +%template(GetBfsTree_PUndirNet) TSnap::GetBfsTree; +%template(GetSubTreeSz_PUndirNet) TSnap::GetSubTreeSz; +%template(GetNodesAtHop_PUndirNet) TSnap::GetNodesAtHop; +%template(GetNodesAtHops_PUndirNet) TSnap::GetNodesAtHops; +// Shortest paths +%template(GetShortPath_PUndirNet) TSnap::GetShortPath; +// Diameter +%template(GetBfsFullDiam_PUndirNet) TSnap::GetBfsFullDiam; +%template(GetBfsEffDiam_PUndirNet) TSnap::GetBfsEffDiam; +%template(GetBfsEffDiamAll_PUndirNet) TSnap::GetBfsEffDiamAll; + + +// drawgviz.h +%template(DrawGViz_PUndirNet) TSnap::DrawGViz; + + +// ggen.h +%template(GenGrid_PUndirNet) TSnap::GenGrid; +%template(GenStar_PUndirNet) TSnap::GenStar; +%template(GenCircle_PUndirNet) TSnap::GenCircle; +%template(GenFull_PUndirNet) TSnap::GenFull; +%template(GenTree_PUndirNet) TSnap::GenTree; +%template(GenBaraHierar_PUndirNet) TSnap::GenBaraHierar; +%template(GenRndGnm_PUndirNet) TSnap::GenRndGnm; + + +// gio.h +%template(LoadEdgeList_PUndirNet) TSnap::LoadEdgeList; +%template(LoadEdgeListStr_PUndirNet) TSnap::LoadEdgeListStr; +%template(LoadConnList_PUndirNet) TSnap::LoadConnList; +%template(LoadConnListStr_PUndirNet) TSnap::LoadConnListStr; +%template(LoadPajek_PUndirNet) TSnap::LoadPajek; +%template(SaveEdgeList_PUndirNet) TSnap::SaveEdgeList; +%template(SavePajek_PUndirNet) TSnap::SavePajek; +%template(SaveMatlabSparseMtx_PUndirNet) TSnap::SaveMatlabSparseMtx; +%template(SaveGViz_PUndirNet) TSnap::SaveGViz; + + +// kcore.h +%template(GetKCore_PUndirNet) TSnap::GetKCore; +%template(GetKCoreEdges_PUndirNet) TSnap::GetKCoreEdges; +%template(GetKCoreNodes_PUndirNet) TSnap::GetKCoreNodes; + + + +// subgraph.h +%template(ConvertGraph_PUndirNet_PUndirNet) TSnap::ConvertGraph ; +%template(ConvertGraph_PUndirNet_PNGraph) TSnap::ConvertGraph ; +%template(ConvertGraph_PUndirNet_PNEANet) TSnap::ConvertGraph ; +%template(ConvertSubGraph_PUndirNet_PUndirNet) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PUndirNet_PNGraph) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PUndirNet_PNEANet) TSnap::ConvertSubGraph ; +%template(ConvertESubGraph_PUndirNet_PNEANet) TSnap::ConvertESubGraph ; +%template(GetSubGraph_PUndirNet) TSnap::GetSubGraph; +%template(GetRndSubGraph_PUndirNet) TSnap::GetRndSubGraph; +%template(GetRndESubGraph_PUndirNet) TSnap::GetRndESubGraph; + + +// triad.h - PUndirNet +%template(GetClustCf_PUndirNet) TSnap::GetClustCf; +%template(GetClustCfAll_PUndirNet) TSnap::GetClustCfAll; +%template(GetNodeClustCf_PUndirNet) TSnap::GetNodeClustCf; +%template(GetTriads_PUndirNet) TSnap::GetTriads; +%template(GetTriadsAll_PUndirNet) TSnap::GetTriadsAll; +%template(GetTriadEdges_PUndirNet) TSnap::GetTriadEdges; +%template(GetNodeTriads_PUndirNet) TSnap::GetNodeTriads; +%template(GetNodeTriadsAll_PUndirNet) TSnap::GetNodeTriadsAll; +%template(GetTriadParticip_PUndirNet) TSnap::GetTriadParticip; +%template(GetTriangleCnt_PUndirNet) TSnap::GetTriangleCnt; + +%template(GetCmnNbrs_PUndirNet) TSnap::GetCmnNbrs; +%template(GetLen2Paths_PUndirNet) TSnap::GetLen2Paths; + + +// cmty.h - PUndirNet +%template(GetModularity_PUndirNet) TSnap::GetModularity; +%template(GetEdgesInOut_PUndirNet) TSnap::GetEdgesInOut; + + +// anf.h - PUndirNet +%template(GetAnf_PUndirNet) TSnap::GetAnf; +%template(GetAnfEffDiam_PUndirNet) TSnap::GetAnfEffDiam; +%template(TestAnf_PUndirNet) TSnap::TestAnf; + + +// statplot.h - PUndirNet +%template(PlotKCoreEdges_PUndirNet) TSnap::PlotKCoreEdges; +%template(PlotKCoreNodes_PUndirNet) TSnap::PlotKCoreNodes; +%template(PlotShortPathDistr_PUndirNet) TSnap::PlotShortPathDistr; +%template(PlotHops_PUndirNet) TSnap::PlotHops; +%template(PlotClustCf_PUndirNet) TSnap::PlotClustCf; +%template(PlotSccDistr_PUndirNet) TSnap::PlotSccDistr; +%template(PlotWccDistr_PUndirNet) TSnap::PlotWccDistr; +%template(PlotOutDegDistr_PUndirNet) TSnap::PlotOutDegDistr; +%template(PlotInDegDistr_PUndirNet) TSnap::PlotInDegDistr; + + +// goodgraph.cpp - PUndirNet +%template(PercentDegree_PUndirNet) PercentDegree; +%template(NodesGTEDegree_PUndirNet) NodesGTEDegree; +%template(MxDegree_PUndirNet) MxDegree; +%template(PercentMxWcc_PUndirNet) PercentMxWcc; +%template(PercentMxScc_PUndirNet) PercentMxScc; + +// conv.h - PUndirNet +%template(ToGraph_PUndirNet) TSnap::ToGraph; + diff --git a/snap-python/source/swig/pungraph.i b/snap-python/source/swig/pungraph.i new file mode 100644 index 0000000000000000000000000000000000000000..90a2c5355690ffc535e3a8ef4c219a29b709d3c5 --- /dev/null +++ b/snap-python/source/swig/pungraph.i @@ -0,0 +1,225 @@ +// pungraph.i +// Templates for SNAP TUNGraph, PUNGraph + +%extend TUNGraph { + TUNGraphNodeI BegNI() { + return TUNGraphNodeI($self->BegNI()); + } + TUNGraphNodeI EndNI() { + return TUNGraphNodeI($self->EndNI()); + } + TUNGraphNodeI GetNI(const int &NId) { + return TUNGraphNodeI($self->GetNI(NId)); + } + TUNGraphEdgeI BegEI() { + return TUNGraphEdgeI($self->BegEI()); + } + TUNGraphEdgeI EndEI() { + return TUNGraphEdgeI($self->EndEI()); + } + TUNGraphEdgeI GetEI(const int &SrcNId, const int &DstNId) { + return TUNGraphEdgeI($self->GetEI(SrcNId, DstNId)); + } +}; + + +%pythoncode %{ +# redefine TUNGraphEdgeI.GetId to return a pair of nodes rather than -1 +def GetId(self): + return (self.GetSrcNId(), self.GetDstNId()) + +TUNGraphEdgeI.GetId = GetId +%} + + +// Basic Undirected Graphs + +%template(PrintGraphStatTable_PUNGraph) PrintGraphStatTable; + +//%template(MxSccSz_PUNGraph) TSnap::GetMxScc; +//%template(MxWccSz_PUNGraph) TSnap::GetMxWccSz; +// End Basic Directed Graphs + +// Basic PUNGraphs +%template(PUNGraph) TPt< TUNGraph >; + +// gbase.h - PUNGraph +%template(PrintInfo_PUNGraph) TSnap::PrintInfo; + +// cncom.h - PUNGraph +%template(GetNodeWcc_PUNGraph) TSnap::GetNodeWcc; +%template(IsConnected_PUNGraph) TSnap::IsConnected; +%template(IsWeaklyConn_PUNGraph) TSnap::IsWeaklyConn; +%template(GetWccSzCnt_PUNGraph) TSnap::GetWccSzCnt; +%template(GetWccs_PUNGraph) TSnap::GetWccs; +%template(GetSccSzCnt_PUNGraph) TSnap::GetSccSzCnt; +%template(GetSccs_PUNGraph) TSnap::GetSccs; +%template(GetMxWccSz_PUNGraph) TSnap::GetMxWccSz; +%template(GetMxSccSz_PUNGraph) TSnap::GetMxSccSz; + +%template(GetMxWcc_PUNGraph) TSnap::GetMxWcc; +%template(GetMxScc_PUNGraph) TSnap::GetMxScc; +%template(GetMxBiCon_PUNGraph) TSnap::GetMxBiCon; + +// centr.h - PUNGraph +%template(GetNodeEcc_PUNGraph) TSnap::GetNodeEcc; +%template(GetPageRank_PUNGraph) TSnap::GetPageRank; +%template(GetPageRank_v1_PUNGraph) TSnap::GetPageRank_v1; +%template(GetHits_PUNGraph) TSnap::GetHits; +%template(GetBetweennessCentr_PUNGraph) TSnap::GetBetweennessCentr; +%template(GetClosenessCentr_PUNGraph) TSnap::GetClosenessCentr; +%template(GetFarnessCentr_PUNGraph) TSnap::GetFarnessCentr; +#ifdef _OPENMP +%template(GetPageRankMP_PUNGraph) TSnap::GetPageRankMP; +%template(GetHitsMP_PUNGraph) TSnap::GetHitsMP; +#endif + +// alg.h - PUNGraph +%template(CntInDegNodes_PUNGraph) TSnap::CntInDegNodes; +%template(CntOutDegNodes_PUNGraph) TSnap::CntOutDegNodes; +%template(CntDegNodes_PUNGraph) TSnap::CntDegNodes; +%template(CntNonZNodes_PUNGraph) TSnap::CntNonZNodes; +%template(CntEdgesToSet_PUNGraph) TSnap::CntEdgesToSet; + +%template(GetMxDegNId_PUNGraph) TSnap::GetMxDegNId; +%template(GetMxInDegNId_PUNGraph) TSnap::GetMxInDegNId; +%template(GetMxOutDegNId_PUNGraph) TSnap::GetMxOutDegNId; + +%template(GetInDegCnt_PUNGraph) TSnap::GetInDegCnt; +%template(GetOutDegCnt_PUNGraph) TSnap::GetOutDegCnt; +%template(GetDegCnt_PUNGraph) TSnap::GetDegCnt; +%template(GetDegSeqV_PUNGraph) TSnap::GetDegSeqV; + +%template(GetNodeInDegV_PUNGraph) TSnap::GetNodeInDegV; +%template(GetNodeOutDegV_PUNGraph) TSnap::GetNodeOutDegV; + +%template(CntUniqUndirEdges_PUNGraph) TSnap::CntUniqUndirEdges; +%template(CntUniqDirEdges_PUNGraph) TSnap::CntUniqDirEdges; +%template(CntUniqBiDirEdges_PUNGraph) TSnap::CntUniqBiDirEdges; +%template(CntSelfEdges_PUNGraph) TSnap::CntSelfEdges; + +%template(GetUnDir_PUNGraph) TSnap::GetUnDir; +%template(MakeUnDir_PUNGraph) TSnap::MakeUnDir; +%template(AddSelfEdges_PUNGraph) TSnap::AddSelfEdges; +%template(DelSelfEdges_PUNGraph) TSnap::DelSelfEdges; +%template(DelNodes_PUNGraph) TSnap::DelNodes; +%template(DelZeroDegNodes_PUNGraph) TSnap::DelZeroDegNodes; +%template(DelDegKNodes_PUNGraph) TSnap::DelDegKNodes; +%template(IsTree_PUNGraph) TSnap::IsTree; +%template(GetTreeRootNId_PUNGraph) TSnap::GetTreeRootNId; +%template(GetTreeSig_PUNGraph) TSnap::GetTreeSig; + + +// bfsdfs.h - PUNGraph +%template(GetBfsTree_PUNGraph) TSnap::GetBfsTree; +%template(GetSubTreeSz_PUNGraph) TSnap::GetSubTreeSz; +%template(GetNodesAtHop_PUNGraph) TSnap::GetNodesAtHop; +%template(GetNodesAtHops_PUNGraph) TSnap::GetNodesAtHops; +// Shortest paths +%template(GetShortPath_PUNGraph) TSnap::GetShortPath; +// Diameter +%template(GetBfsFullDiam_PUNGraph) TSnap::GetBfsFullDiam; +%template(GetBfsEffDiam_PUNGraph) TSnap::GetBfsEffDiam; +%template(GetBfsEffDiamAll_PUNGraph) TSnap::GetBfsEffDiamAll; + + +// drawgviz.h +%template(DrawGViz_PUNGraph) TSnap::DrawGViz; + + +// ggen.h +%template(GenGrid_PUNGraph) TSnap::GenGrid; +%template(GenStar_PUNGraph) TSnap::GenStar; +%template(GenCircle_PUNGraph) TSnap::GenCircle; +%template(GenFull_PUNGraph) TSnap::GenFull; +%template(GenTree_PUNGraph) TSnap::GenTree; +%template(GenBaraHierar_PUNGraph) TSnap::GenBaraHierar; +%template(GenRndGnm_PUNGraph) TSnap::GenRndGnm; + + +// gio.h +%template(LoadEdgeList_PUNGraph) TSnap::LoadEdgeList; +%template(LoadEdgeListStr_PUNGraph) TSnap::LoadEdgeListStr; +%template(LoadConnList_PUNGraph) TSnap::LoadConnList; +%template(LoadConnListStr_PUNGraph) TSnap::LoadConnListStr; +%template(LoadPajek_PUNGraph) TSnap::LoadPajek; +%template(SaveEdgeList_PUNGraph) TSnap::SaveEdgeList; +%template(SavePajek_PUNGraph) TSnap::SavePajek; +%template(SaveMatlabSparseMtx_PUNGraph) TSnap::SaveMatlabSparseMtx; +%template(SaveGViz_PUNGraph) TSnap::SaveGViz; + + +// kcore.h +%template(GetKCore_PUNGraph) TSnap::GetKCore; +%template(GetKCoreEdges_PUNGraph) TSnap::GetKCoreEdges; +%template(GetKCoreNodes_PUNGraph) TSnap::GetKCoreNodes; + + +// subgraph.h +%template(ConvertGraph_PUNGraph_PUNGraph) TSnap::ConvertGraph ; +%template(ConvertGraph_PUNGraph_PNGraph) TSnap::ConvertGraph ; +%template(ConvertGraph_PUNGraph_PNEANet) TSnap::ConvertGraph ; +%template(ConvertSubGraph_PUNGraph_PUNGraph) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PUNGraph_PNGraph) TSnap::ConvertSubGraph ; +%template(ConvertSubGraph_PUNGraph_PNEANet) TSnap::ConvertSubGraph ; +%template(ConvertESubGraph_PUNGraph_PNEANet) TSnap::ConvertESubGraph ; +%template(GetSubGraph_PUNGraph) TSnap::GetSubGraph; +%template(GetSubGraphRenumber_PUNGraph) TSnap::GetSubGraphRenumber; +%template(GetRndSubGraph_PUNGraph) TSnap::GetRndSubGraph; +%template(GetRndESubGraph_PUNGraph) TSnap::GetRndESubGraph; +%template(GetEgonetHop_PUNGraph) TSnap::GetEgonetHop; +%template(GetInEgonetHop_PUNGraph) TSnap::GetInEgonetHop; +%template(GetOutEgonetHop_PUNGraph) TSnap::GetOutEgonetHop; +%template(GetInEgonetSub_PUNGraph) TSnap::GetInEgonetSub; +%template(GetGraphUnion_PUNGraph) TSnap::GetGraphUnion; +%template(GetGraphIntersection_PUNGraph) TSnap::GetGraphIntersection; + + +// triad.h - PUNGraph +%template(GetClustCf_PUNGraph) TSnap::GetClustCf; +%template(GetClustCfAll_PUNGraph) TSnap::GetClustCfAll; +%template(GetNodeClustCf_PUNGraph) TSnap::GetNodeClustCf; +%template(GetTriads_PUNGraph) TSnap::GetTriads; +%template(GetTriadsAll_PUNGraph) TSnap::GetTriadsAll; +%template(GetTriadEdges_PUNGraph) TSnap::GetTriadEdges; +%template(GetNodeTriads_PUNGraph) TSnap::GetNodeTriads; +%template(GetNodeTriadsAll_PUNGraph) TSnap::GetNodeTriadsAll; +%template(GetTriadParticip_PUNGraph) TSnap::GetTriadParticip; +%template(GetTriangleCnt_PUNGraph) TSnap::GetTriangleCnt; + +%template(GetCmnNbrs_PUNGraph) TSnap::GetCmnNbrs; +%template(GetLen2Paths_PUNGraph) TSnap::GetLen2Paths; + + +// cmty.h - PUNGraph +%template(GetModularity_PUNGraph) TSnap::GetModularity; +%template(GetEdgesInOut_PUNGraph) TSnap::GetEdgesInOut; + + +// anf.h - PUNGraph +%template(GetAnf_PUNGraph) TSnap::GetAnf; +%template(GetAnfEffDiam_PUNGraph) TSnap::GetAnfEffDiam; +%template(TestAnf_PUNGraph) TSnap::TestAnf; + + +// statplot.h - PUNGraph +%template(PlotKCoreEdges_PUNGraph) TSnap::PlotKCoreEdges; +%template(PlotKCoreNodes_PUNGraph) TSnap::PlotKCoreNodes; +%template(PlotShortPathDistr_PUNGraph) TSnap::PlotShortPathDistr; +%template(PlotHops_PUNGraph) TSnap::PlotHops; +%template(PlotClustCf_PUNGraph) TSnap::PlotClustCf; +%template(PlotSccDistr_PUNGraph) TSnap::PlotSccDistr; +%template(PlotWccDistr_PUNGraph) TSnap::PlotWccDistr; +%template(PlotOutDegDistr_PUNGraph) TSnap::PlotOutDegDistr; +%template(PlotInDegDistr_PUNGraph) TSnap::PlotInDegDistr; + + +// goodgraph.cpp - PUNGraph +%template(PercentDegree_PUNGraph) PercentDegree; +%template(NodesGTEDegree_PUNGraph) NodesGTEDegree; +%template(MxDegree_PUNGraph) MxDegree; +%template(PercentMxWcc_PUNGraph) PercentMxWcc; +%template(PercentMxScc_PUNGraph) PercentMxScc; + +// conv.h - PUNGraph +%template(ToGraph_PUNGraph) TSnap::ToGraph; diff --git a/snap-python/source/swig/pylayer.i b/snap-python/source/swig/pylayer.i new file mode 100644 index 0000000000000000000000000000000000000000..0a24fcd083101792f07df22a1def5ed586824837 --- /dev/null +++ b/snap-python/source/swig/pylayer.i @@ -0,0 +1,1375 @@ +// +// This file implements an additional layer over SWIG generated code in order +// to provide improved Python functionality. It includes the following +// enhancements, which are implemented where possible: +// +// - standalone functions are available as class methods +// - built-in Python classes (lists, dictionaries) are accepted as +// parameters in addition to SNAP C++ based classes +// - function results are available as return values rather than as +// reference parameters +// - support for optional parameters has been enhanced +// + +%pythoncode %{ + +# This function adds compatility to additional datatypes +# Works for Python types: list, set, and dict (with their corresponding SNAP types) +def ConvertToSnapType(args, pos, SnapType, PyType): + if len(args) > pos: + arg = args[pos] + if type(arg) == PyType: + convertedArgs = list(args) + convertedArg = SnapType() + + try: + if PyType == list: + for item in arg: + convertedArg.Add(item) + elif PyType == set: + for item in arg: + convertedArg.AddKey(item) + elif PyType == dict: + for key in arg: + convertedArg[key] = arg[key] + except TypeError: + # Raise TypeError instead of the general SystemError + raise + + convertedArgs[pos] = convertedArg + + return tuple(convertedArgs) + + return args + +# This function converts TNGraph/TUNGraph/TNEANet to PNGraph/PUNGraph/PNEANet +def ConvertGraphArg(GraphType): + if GraphType == TNGraph: + GraphType = PNGraph + elif GraphType == TUNGraph: + GraphType = PUNGraph + elif GraphType == TNEANet: + GraphType = PNEANet + return GraphType + +# This function moves the argument at pos to be returned instead +def MoveArgToReturn (tspec, args, func, pos, argType): + if len(args) > pos and type(args[pos]) == argType: + #For backward compatility + return func(tspec, *args) + else: + returnArg = argType() + newArgs = list(args) + newArgs.insert(pos, returnArg) + oldReturn = func(tspec, *newArgs) + if oldReturn == None: + return returnArg + else: + return (oldReturn, returnArg) + +_GenFull = GenFull +def GenFull(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _GenFull(GraphType, *args) + +_GenCircle = GenCircle +def GenCircle(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _GenCircle(GraphType, *args) + +_GenGrid = GenGrid +def GenGrid(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _GenGrid(GraphType, *args) + +_GenStar = GenStar +def GenStar(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _GenStar(GraphType, *args) + +_GenTree = GenTree +def GenTree(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _GenTree(GraphType, *args) + +_GenRndGnm = GenRndGnm +def GenRndGnm(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _GenRndGnm(GraphType, *args) + +_GenBaraHierar = GenBaraHierar +def GenBaraHierar(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _GenBaraHierar(GraphType, *args) + +_LoadEdgeList = LoadEdgeList +def LoadEdgeList(GraphType, InFNm, SrcColId = 0, DstColId = 1, Separator = " "): + GraphType = ConvertGraphArg(GraphType) + if Separator == " ": + return _LoadEdgeList(GraphType, InFNm, SrcColId, DstColId) + else: + return _LoadEdgeList(GraphType, InFNm, SrcColId, DstColId, Separator) + +_LoadEdgeListStr = LoadEdgeListStr +def LoadEdgeListStr(GraphType, InFNm, SrcColId = 0, DstColId = 1, Mapping = None): + GraphType = ConvertGraphArg(GraphType) + # we need exception handling, since some snap.py types cannot be + # compared to None or booleans + try: + if Mapping == None or Mapping == False: + return _LoadEdgeListStr(GraphType, InFNm, SrcColId, DstColId) + + if Mapping == True: + StrToNIdH = TStrIntSH() + graph = _LoadEdgeListStr(GraphType, InFNm, SrcColId, DstColId, StrToNIdH) + return (graph, StrToNIdH) + except: + pass + + return _LoadEdgeListStr(GraphType, InFNm, SrcColId, DstColId, Mapping) + +_LoadConnList = LoadConnList +def LoadConnList(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _LoadConnList(GraphType, *args) + +_LoadConnListStr = LoadConnListStr +def LoadConnListStr(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return MoveArgToReturn(GraphType, args, _LoadConnListStr, 1, TStrIntSH) + +_LoadPajek = LoadPajek +def LoadPajek(GraphType, *args): + GraphType = ConvertGraphArg(GraphType) + return _LoadPajek(GraphType, *args) + +_SaveGViz = SaveGViz +def SaveGViz(Graph, *args): + args = ConvertToSnapType(args, -1, TIntStrH, dict) + return _SaveGViz(Graph, *args) + +def SaveGVizColor(Graph, OutFNm, Desc, NodeLabels, NIdColorH): + return SaveGViz(Graph, OutFNm, Desc, NodeLabels, NIdColorH) + +_SavePajek = SavePajek +def SavePajek(Graph, OutFNm, NIdColorH = None, NIdLabelH = None, EIdColorH = None): + # we need exception handling, since some snap.py types cannot be + # compared to None or booleans + try: + if NIdColorH is None: + NIdColorH = TIntStrH() + if NIdLabelH is None: + NIdLabelH = TIntStrH() + if EIdColorH is None: + EIdColorH = TIntStrH() + except: + pass + args = (OutFNm, NIdColorH, NIdLabelH, EIdColorH) + args = ConvertToSnapType(args, 1, TIntStrH, dict) + args = ConvertToSnapType(args, 2, TIntStrH, dict) + args = ConvertToSnapType(args, 3, TIntStrH, dict) + return _SavePajek(Graph, *args) + +_GetDegCnt = GetDegCnt +def GetDegCnt(Graph, *args): + return MoveArgToReturn(Graph, args, _GetDegCnt, 0, TIntPrV) + +_GetInDegCnt = GetInDegCnt +def GetInDegCnt(Graph, *args): + return MoveArgToReturn(Graph, args, _GetInDegCnt, 0, TIntPrV) + +_GetOutDegCnt = GetOutDegCnt +def GetOutDegCnt(Graph, *args): + return MoveArgToReturn(Graph, args, _GetOutDegCnt, 0, TIntPrV) + +_GetNodeInDegV = GetNodeInDegV +def GetNodeInDegV(Graph, *args): + return MoveArgToReturn(Graph, args, _GetNodeInDegV, 0, TIntPrV) + +_GetNodeOutDegV = GetNodeOutDegV +def GetNodeOutDegV(Graph, *args): + return MoveArgToReturn(Graph, args, _GetNodeOutDegV, 0, TIntPrV) + +_GetDegSeqV = GetDegSeqV +def GetDegSeqV(Graph, *args, **kwargs): + if len(args) > 0 and type(args[0]) == TIntV: + #Backward compatibility + return _GetDegSeqV(Graph, *args) + else: + if (len(args) + len(kwargs) == 0) or (len(args) == 1 and args[0] == False) or (len(kwargs) == 1 and kwargs['Dir'] == False): + # case Dir = False + DegV = TIntV() + _GetDegSeqV(Graph, DegV) + return DegV + else: + # case Dir = True + InDegV = TIntV() + OutDegV = TIntV() + _GetDegSeqV(Graph, InDegV, OutDegV) + return (InDegV, OutDegV) + +_CntEdgesToSet = CntEdgesToSet +def CntEdgesToSet(Graph, *args): + args = ConvertToSnapType(args, 1, TIntSet, set) + return _CntEdgesToSet(Graph, *args) + +_DelNodes = DelNodes +def DelNodes(Graph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _DelNodes(Graph, *args) + +_ConvertSubGraph = ConvertSubGraph +def ConvertSubGraph(GraphType, InGraph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _ConvertSubGraph(GraphType, InGraph, *args) + +_ConvertESubGraph = ConvertESubGraph +def ConvertESubGraph(GraphType, InGraph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _ConvertESubGraph(GraphType, InGraph, *args) + +_GetSubGraph = GetSubGraph +def GetSubGraph(Graph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _GetSubGraph(Graph, *args) + +_GetSubGraphRenumber = GetSubGraphRenumber +def GetSubGraphRenumber(Graph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _GetSubGraphRenumber(Graph, *args) + +_GetESubGraph = GetESubGraph +def GetESubGraph(Graph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _GetESubGraph(Graph, *args) + +_DrawGViz = DrawGViz +def DrawGViz(Graph, *args): + args = ConvertToSnapType(args, -1, TIntStrH, dict) + return _DrawGViz(Graph, *args) + +def DrawGVizColor(Graph, Layout, PltFNm, Desc, NodeLabels, NIdColorH): + return DrawGViz(Graph, Layout, PltFNm, Desc, NodeLabels, NIdColorH) + +_GetSccs = GetSccs +def GetSccs(Graph, *args): + return MoveArgToReturn(Graph, args, _GetSccs, 0, TCnComV) + +_GetSccSzCnt = GetSccSzCnt +def GetSccSzCnt(Graph, *args): + return MoveArgToReturn(Graph, args, _GetSccSzCnt, 0, TIntPrV) + +_GetWccs = GetWccs +def GetWccs(Graph, *args): + return MoveArgToReturn(Graph, args, _GetWccs, 0, TCnComV) + +_GetWccSzCnt = GetWccSzCnt +def GetWccSzCnt(Graph, *args): + return MoveArgToReturn(Graph, args, _GetWccSzCnt, 0, TIntPrV) + +_GetNodeWcc = GetNodeWcc +def GetNodeWcc(Graph, *args): + return MoveArgToReturn(Graph, args, _GetNodeWcc, 1, TIntV) + +_Get1CnCom = Get1CnCom +def Get1CnCom(Graph, *args): + return MoveArgToReturn(Graph, args, _Get1CnCom, 0, TCnComV) + +_Get1CnComSzCnt = Get1CnComSzCnt +def Get1CnComSzCnt(Graph, *args): + return MoveArgToReturn(Graph, args, _Get1CnComSzCnt, 0, TIntPrV) + +_GetBiCon = GetBiCon +def GetBiCon(Graph, *args): + return MoveArgToReturn(Graph, args, _GetBiCon, 0, TCnComV) + +_GetBiConSzCnt = GetBiConSzCnt +def GetBiConSzCnt(Graph, *args): + return MoveArgToReturn(Graph, args, _GetBiConSzCnt, 0, TIntPrV) + +_GetArtPoints = GetArtPoints +def GetArtPoints(Graph, *args): + return MoveArgToReturn(Graph, args, _GetArtPoints, 0, TIntV) + +_GetEdgeBridges = GetEdgeBridges +def GetEdgeBridges(Graph, *args): + return MoveArgToReturn(Graph, args, _GetEdgeBridges, 0, TIntPrV) + +_GetNodesAtHop = GetNodesAtHop +def GetNodesAtHop(Graph, *args): + return MoveArgToReturn(Graph, args, _GetNodesAtHop, 2, TIntV) + +_GetNodesAtHops = GetNodesAtHops +def GetNodesAtHops(Graph, *args): + return MoveArgToReturn(Graph, args, _GetNodesAtHops, 1, TIntPrV) + +def GetShortPathAll(Graph, SrcNId, IsDir = False, MaxDist=TInt.Mx): + NIdToDistH = TIntH() + oldReturn = GetShortPath(Graph, SrcNId, NIdToDistH, IsDir, MaxDist) + return oldReturn, NIdToDistH + +_GetTreeSig = GetTreeSig +def GetTreeSig(Graph, RootNId, Sig, NodeMap = False): + if NodeMap: + map = TIntPrV() + sig = TIntV() + _GetTreeSig(Graph, RootNId, sig, map) + return (sig, map) + else: + sig = TIntV() + _GetTreeSig(Graph, RootNId, sig) + return sig + +_GetBetweennessCentr = GetBetweennessCentr +def GetBetweennessCentr(Graph, *args): + if len(args)>=1 and type(args[0]) == TIntFltH and type(args[1]) == TIntPrFltH: + #Backward compatibility + return _GetBetweennessCentr(Graph, *args) + else: + NIdBtwH = TIntFltH() + EdgeBtwH = TIntPrFltH() + _GetBetweennessCentr (Graph, NIdBtwH, EdgeBtwH, *args) + return (NIdBtwH, EdgeBtwH) + +_GetPageRank = GetPageRank +def GetPageRank(Graph, *args): + return MoveArgToReturn(Graph, args, _GetPageRank, 0, TIntFltH) + +_GetHits = GetHits +def GetHits(Graph, *args, **kwargs): + if len(args) >= 2 and (type(args[0]) == TIntFltH) and (type(args[1]) == TIntFltH): + #Backward compatibility + return _GetHits(Graph, *args) + else: + if len(args) == 1: + MaxIter = args[0] + elif "MaxIter" in kwargs: + MaxIter = kwargs["MaxIter"] + else: + #Default value for MaxIter is 20 + MaxIter = 20 + NIdHubH = TIntFltH() + NIdAuthH = TIntFltH() + _GetHits(Graph, NIdHubH, NIdAuthH, MaxIter) + return (NIdHubH, NIdAuthH) + +_GetEigenVectorCentr = GetEigenVectorCentr +def GetEigenVectorCentr(Graph, *args): + return MoveArgToReturn(Graph, args, _GetEigenVectorCentr, 0, TIntFltH) + +_CommunityCNM = CommunityCNM +def CommunityCNM(Graph, *args): + return MoveArgToReturn(Graph, args, _CommunityCNM, 0, TCnComV) + +_CommunityGirvanNewman = CommunityGirvanNewman +def CommunityGirvanNewman(Graph, *args): + return MoveArgToReturn(Graph, args, _CommunityGirvanNewman, 0, TCnComV) + +_GetEdgesInOut = GetEdgesInOut +def GetEdgesInOut(Graph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _GetEdgesInOut(Graph, *args) + +_GetModularity = GetModularity +def GetModularity(Graph, *args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _GetModularity(Graph, *args) + +_GetClustCf = GetClustCf +def GetClustCf(Graph, *args, **kwargs): + if len(args) == 2 and (type(args[0]) == TFltPrV): + #Backward compatibility + return _GetClustCf(Graph, *args) + if len(args) == 1 and (type(args[0]) == int or type(args[0]) == TFltPrV): + #Backward compatibility + return _GetClustCf(Graph, *args) + + #Default argument values + CCfByDeg = False + SampleNodes = -1 + + #Populate argument values + if 'CCfByDeg' in kwargs: + CCfByDeg = kwargs['CCfByDeg'] + if 'SampleNodes' in kwargs: + SampleNodes = kwargs['SampleNodes'] + if len(args) == 1: + CCfByDeg = args[0] + if len(args) == 2: + CCfByDeg = args[0] + SampleNodes = args[1] + + if CCfByDeg: + DegToCCfV = TFltPrV() + PrevReturn = _GetClustCf(Graph, DegToCCfV, SampleNodes) + return (PrevReturn, DegToCCfV) + else: + return _GetClustCf(Graph, SampleNodes) + +def GetTriadsByNode(Graph, SampleNodes=-1): + NIdCOTriadV = TIntTrV() + GetTriads(Graph, NIdCOTriadV, SampleNodes) + return NIdCOTriadV + +_GetClustCfAll = GetClustCfAll +def GetClustCfAll(Graph, *args): + return MoveArgToReturn(Graph, args, _GetClustCfAll, 0, TFltPrV) + +_GetCmnNbrs = GetCmnNbrs +def GetCmnNbrs(Graph, NId1, NId2, NbrList = False): + # we need exception handling, since some snap.py types cannot be + # compared to None or booleans + try: + if NbrList == None or NbrList == False: + return _GetCmnNbrs(Graph, NId1, NId2) + elif NbrList == True: + NbrV = TIntV() + PrevReturn = _GetCmnNbrs(Graph, NId1, NId2, NbrV) + return (PrevReturn, NbrV) + except: + pass + + return _GetCmnNbrs(Graph, NId1, NId2, NbrList) + +def GetNodeClustCfAll(Graph): + NIdCCfH = TIntFltH() + GetNodeClustCf(Graph, NIdCCfH) + return NIdCCfH + +_GetNodeTriads = GetNodeTriads +def GetNodeTriads(Graph, *args): + if len(args) == 2: + args = ConvertToSnapType(args, 1, TIntSet, set) + return _GetNodeTriads(Graph, *args) + +def GetNodeTriadsSet(Graph, NId, GroupSet): + return GetNodeTriads(Graph, NId, GroupSet) + +_GetTriadParticip = GetTriadParticip +def GetTriadParticip(Graph, *args): + return MoveArgToReturn(Graph, args, _GetTriadParticip, 0, TIntPrV) + +_GetKCoreNodes = GetKCoreNodes +def GetKCoreNodes(Graph, *args): + return MoveArgToReturn(Graph, args, _GetKCoreNodes, 0, TIntPrV) + +_GetKCoreEdges = GetKCoreEdges +def GetKCoreEdges(Graph, *args): + return MoveArgToReturn(Graph, args, _GetKCoreEdges, 0, TIntPrV) + +_GetEigVals = GetEigVals +def GetEigVals(Graph, *args): + return MoveArgToReturn(Graph, args, _GetEigVals, 1, TFltV) + +_GetSngVals = GetSngVals +def GetSngVals(Graph, *args): + return MoveArgToReturn(Graph, args, _GetSngVals, 1, TFltV) + +_GetInvParticipRat = GetInvParticipRat +def GetInvParticipRat(Graph, *args): + return MoveArgToReturn(Graph, args, _GetInvParticipRat, 2, TFltPrV) + +def GetAnfNode(Graph, SrcNId, MxDist, IsDir, NApprox=32): + DistNbrsV = TIntFltKdV() + GetAnf(Graph, SrcNId, DistNbrsV, MxDist, IsDir, NApprox) + return DistNbrsV + +def GetAnfGraph(Graph, MxDist, IsDir, NApprox=32): + DistNbrsV = TIntFltKdV() + GetAnf(Graph, DistNbrsV, MxDist, IsDir, NApprox) + return DistNbrsV + +def GetLeadEigVec(Graph): + EigVec = TFltV() + GetEigVec(Graph, EigVec) + return EigVec + +def GetEigVecs(Graph, EigVecs): + EigVal = TFltV() + EigVecV = TFltVFltV() + GetEigVec(Graph, EigVecs, EigVal, EigVecV) + return (EigVal, EigVecV) + +def GetLeadSngVec(Graph): + LeftSV = TFltV() + RightSV = TFltV() + GetSngVec(Graph, LeftSV, RightSV) + return (LeftSV, RightSV) + +def GetSngVecs(Graph, SngVecs): + SngValV = TFltV() + LeftSV = TFltVFltV() + RightSV = TFltVFltV() + GetSngVec(Graph, SngVecs, SngValV, LeftSV, RightSV) + return (SngValV, LeftSV, RightSV) + + +_GenConfModel = GenConfModel +def GenConfModel(*args): + args = ConvertToSnapType(args, 0, TIntV, list) + return _GenConfModel(*args) + +_GetBfsEffDiam = GetBfsEffDiam +def GetBfsEffDiam(Graph, *args): + args = ConvertToSnapType(args, 1, TIntV, list) + return _GetBfsEffDiam(Graph, *args) + +_GetLen2Paths = GetLen2Paths +def GetLen2Paths(Graph, *args): + if type(args[-1]) != bool: + #Backward compatibility + return _GetLen2Paths(Graph, *args) + elif args[-1]: + NbrV = TIntV() + paths = _GetLen2Paths(Graph, *(list(args[:-1]) + [NbrV])) + return paths, NbrV + else: + return _GetLen2Paths(Graph, *args[:-1]) + + return MoveArgToReturn(Graph, args, _GetLen2Paths, 2, TIntV) + +%} + +// Add class functions + +%pythoncode %{ +# Add class functions + +def CntDegNodes_classFn(self, *args, **kwargs): + return CntDegNodes(self, *args, **kwargs) +PUNGraph.CntDegNodes = CntDegNodes_classFn +PNGraph.CntDegNodes = CntDegNodes_classFn +PNEANet.CntDegNodes = CntDegNodes_classFn + +def CntInDegNodes_classFn(self, *args, **kwargs): + return CntInDegNodes(self, *args, **kwargs) +PUNGraph.CntInDegNodes = CntInDegNodes_classFn +PNGraph.CntInDegNodes = CntInDegNodes_classFn +PNEANet.CntInDegNodes = CntInDegNodes_classFn + +def CntOutDegNodes_classFn(self, *args, **kwargs): + return CntOutDegNodes(self, *args, **kwargs) +PUNGraph.CntOutDegNodes = CntOutDegNodes_classFn +PNGraph.CntOutDegNodes = CntOutDegNodes_classFn +PNEANet.CntOutDegNodes = CntOutDegNodes_classFn + +def CntNonZNodes_classFn(self, *args, **kwargs): + return CntNonZNodes(self, *args, **kwargs) +PUNGraph.CntNonZNodes = CntNonZNodes_classFn +PNGraph.CntNonZNodes = CntNonZNodes_classFn +PNEANet.CntNonZNodes = CntNonZNodes_classFn + +def GetDegCnt_classFn(self, *args, **kwargs): + return GetDegCnt(self, *args, **kwargs) +PUNGraph.GetDegCnt = GetDegCnt_classFn +PNGraph.GetDegCnt = GetDegCnt_classFn +PNEANet.GetDegCnt = GetDegCnt_classFn + +def GetInDegCnt_classFn(self, *args, **kwargs): + return GetInDegCnt(self, *args, **kwargs) +PUNGraph.GetInDegCnt = GetInDegCnt_classFn +PNGraph.GetInDegCnt = GetInDegCnt_classFn +PNEANet.GetInDegCnt = GetInDegCnt_classFn + +def GetOutDegCnt_classFn(self, *args, **kwargs): + return GetOutDegCnt(self, *args, **kwargs) +PUNGraph.GetOutDegCnt = GetOutDegCnt_classFn +PNGraph.GetOutDegCnt = GetOutDegCnt_classFn +PNEANet.GetOutDegCnt = GetOutDegCnt_classFn + +def GetMxDegNId_classFn(self, *args, **kwargs): + return GetMxDegNId(self, *args, **kwargs) +PUNGraph.GetMxDegNId = GetMxDegNId_classFn +PNGraph.GetMxDegNId = GetMxDegNId_classFn +PNEANet.GetMxDegNId = GetMxDegNId_classFn + +def GetMxInDegNId_classFn(self, *args, **kwargs): + return GetMxInDegNId(self, *args, **kwargs) +PUNGraph.GetMxInDegNId = GetMxInDegNId_classFn +PNGraph.GetMxInDegNId = GetMxInDegNId_classFn +PNEANet.GetMxInDegNId = GetMxInDegNId_classFn + +def GetMxOutDegNId_classFn(self, *args, **kwargs): + return GetMxOutDegNId(self, *args, **kwargs) +PUNGraph.GetMxOutDegNId = GetMxOutDegNId_classFn +PNGraph.GetMxOutDegNId = GetMxOutDegNId_classFn +PNEANet.GetMxOutDegNId = GetMxOutDegNId_classFn + +def GetNodeInDegV_classFn(self, *args, **kwargs): + return GetNodeInDegV(self, *args, **kwargs) +PUNGraph.GetNodeInDegV = GetNodeInDegV_classFn +PNGraph.GetNodeInDegV = GetNodeInDegV_classFn +PNEANet.GetNodeInDegV = GetNodeInDegV_classFn + +def GetNodeOutDegV_classFn(self, *args, **kwargs): + return GetNodeOutDegV(self, *args, **kwargs) +PUNGraph.GetNodeOutDegV = GetNodeOutDegV_classFn +PNGraph.GetNodeOutDegV = GetNodeOutDegV_classFn +PNEANet.GetNodeOutDegV = GetNodeOutDegV_classFn + +def GetDegSeqV_classFn(self, *args, **kwargs): + return GetDegSeqV(self, *args, **kwargs) +PUNGraph.GetDegSeqV = GetDegSeqV_classFn +PNGraph.GetDegSeqV = GetDegSeqV_classFn +PNEANet.GetDegSeqV = GetDegSeqV_classFn + +def CntSelfEdges_classFn(self, *args, **kwargs): + return CntSelfEdges(self, *args, **kwargs) +PUNGraph.CntSelfEdges = CntSelfEdges_classFn +PNGraph.CntSelfEdges = CntSelfEdges_classFn +PNEANet.CntSelfEdges = CntSelfEdges_classFn + +def CntUniqBiDirEdges_classFn(self, *args, **kwargs): + return CntUniqBiDirEdges(self, *args, **kwargs) +PUNGraph.CntUniqBiDirEdges = CntUniqBiDirEdges_classFn +PNGraph.CntUniqBiDirEdges = CntUniqBiDirEdges_classFn +PNEANet.CntUniqBiDirEdges = CntUniqBiDirEdges_classFn + +def CntUniqDirEdges_classFn(self, *args, **kwargs): + return CntUniqDirEdges(self, *args, **kwargs) +PUNGraph.CntUniqDirEdges = CntUniqDirEdges_classFn +PNGraph.CntUniqDirEdges = CntUniqDirEdges_classFn +PNEANet.CntUniqDirEdges = CntUniqDirEdges_classFn + +def CntUniqUndirEdges_classFn(self, *args, **kwargs): + return CntUniqUndirEdges(self, *args, **kwargs) +PUNGraph.CntUniqUndirEdges = CntUniqUndirEdges_classFn +PNGraph.CntUniqUndirEdges = CntUniqUndirEdges_classFn +PNEANet.CntUniqUndirEdges = CntUniqUndirEdges_classFn + +def CntEdgesToSet_classFn(self, *args, **kwargs): + return CntEdgesToSet(self, *args, **kwargs) +PUNGraph.CntEdgesToSet = CntEdgesToSet_classFn +PNGraph.CntEdgesToSet = CntEdgesToSet_classFn +PNEANet.CntEdgesToSet = CntEdgesToSet_classFn + +def AddSelfEdges_classFn(self, *args, **kwargs): + return AddSelfEdges(self, *args, **kwargs) +PUNGraph.AddSelfEdges = AddSelfEdges_classFn +PNGraph.AddSelfEdges = AddSelfEdges_classFn +PNEANet.AddSelfEdges = AddSelfEdges_classFn + +def DelDegKNodes_classFn(self, *args, **kwargs): + return DelDegKNodes(self, *args, **kwargs) +PUNGraph.DelDegKNodes = DelDegKNodes_classFn +PNGraph.DelDegKNodes = DelDegKNodes_classFn +PNEANet.DelDegKNodes = DelDegKNodes_classFn + +def DelNodes_classFn(self, *args, **kwargs): + return DelNodes(self, *args, **kwargs) +PUNGraph.DelNodes = DelNodes_classFn +PNGraph.DelNodes = DelNodes_classFn +PNEANet.DelNodes = DelNodes_classFn + +def DelSelfEdges_classFn(self, *args, **kwargs): + return DelSelfEdges(self, *args, **kwargs) +PUNGraph.DelSelfEdges = DelSelfEdges_classFn +PNGraph.DelSelfEdges = DelSelfEdges_classFn +PNEANet.DelSelfEdges = DelSelfEdges_classFn + +def DelZeroDegNodes_classFn(self, *args, **kwargs): + return DelZeroDegNodes(self, *args, **kwargs) +PUNGraph.DelZeroDegNodes = DelZeroDegNodes_classFn +PNGraph.DelZeroDegNodes = DelZeroDegNodes_classFn +PNEANet.DelZeroDegNodes = DelZeroDegNodes_classFn + +def GetUnDir_classFn(self, *args, **kwargs): + return GetUnDir(self, *args, **kwargs) +PUNGraph.GetUnDir = GetUnDir_classFn +PNGraph.GetUnDir = GetUnDir_classFn +PNEANet.GetUnDir = GetUnDir_classFn + +def MakeUnDir_classFn(self, *args, **kwargs): + return MakeUnDir(self, *args, **kwargs) +PUNGraph.MakeUnDir = MakeUnDir_classFn +PNGraph.MakeUnDir = MakeUnDir_classFn +PNEANet.MakeUnDir = MakeUnDir_classFn + +def ConvertGraph_classFn(self, GraphType, *args, **kwargs): + GraphType = ConvertGraphArg(GraphType) + return ConvertGraph(GraphType, self, *args, **kwargs) +PUNGraph.ConvertGraph = ConvertGraph_classFn +PNGraph.ConvertGraph = ConvertGraph_classFn +PNEANet.ConvertGraph = ConvertGraph_classFn + +def ConvertSubGraph_classFn(self, GraphType, *args, **kwargs): + GraphType = ConvertGraphArg(GraphType) + return ConvertSubGraph(GraphType, self, *args, **kwargs) +PUNGraph.ConvertSubGraph = ConvertSubGraph_classFn +PNGraph.ConvertSubGraph = ConvertSubGraph_classFn +PNEANet.ConvertSubGraph = ConvertSubGraph_classFn + +def ConvertESubGraph_classFn(self, GraphType, *args, **kwargs): + GraphType = ConvertGraphArg(GraphType) + return ConvertESubGraph(GraphType, self, *args, **kwargs) +PUNGraph.ConvertESubGraph = ConvertESubGraph_classFn +PNGraph.ConvertESubGraph = ConvertESubGraph_classFn +PNEANet.ConvertESubGraph = ConvertESubGraph_classFn + +def GetSubGraph_classFn(self, *args, **kwargs): + return GetSubGraph(self, *args, **kwargs) +PUNGraph.GetSubGraph = GetSubGraph_classFn +PNGraph.GetSubGraph = GetSubGraph_classFn +PNEANet.GetSubGraph = GetSubGraph_classFn + +def GetSubGraphRenumber_classFn(self, *args, **kwargs): + return GetSubGraphRenumber(self, *args, **kwargs) +PUNGraph.GetSubGraphRenumber = GetSubGraphRenumber_classFn +PNGraph.GetSubGraphRenumber = GetSubGraphRenumber_classFn +PNEANet.GetSubGraphRenumber = GetSubGraphRenumber_classFn + +def GetSubTreeSz_classFn(self, *args, **kwargs): + return GetSubTreeSz(self, *args, **kwargs) +PUNGraph.GetSubTreeSz = GetSubTreeSz_classFn +PNGraph.GetSubTreeSz = GetSubTreeSz_classFn +PNEANet.GetSubTreeSz = GetSubTreeSz_classFn + +def GetESubGraph_classFn(self, *args, **kwargs): + return GetESubGraph(self, *args, **kwargs) +PUNGraph.GetESubGraph = GetESubGraph_classFn +PNGraph.GetESubGraph = GetESubGraph_classFn +PNEANet.GetESubGraph = GetESubGraph_classFn + +def GetRndSubGraph_classFn(self, *args, **kwargs): + return GetRndSubGraph(self, *args, **kwargs) +PUNGraph.GetRndSubGraph = GetRndSubGraph_classFn +PNGraph.GetRndSubGraph = GetRndSubGraph_classFn +PNEANet.GetRndSubGraph = GetRndSubGraph_classFn + +def GetRndESubGraph_classFn(self, *args, **kwargs): + return GetRndESubGraph(self, *args, **kwargs) +PUNGraph.GetRndESubGraph = GetRndESubGraph_classFn +PNGraph.GetRndESubGraph = GetRndESubGraph_classFn +PNEANet.GetRndESubGraph = GetRndESubGraph_classFn + +def GetEgonet_classFn(self, *args, **kwargs): + return GetEgonet(self, *args, **kwargs) +PUNGraph.GetEgonet = GetEgonet_classFn +PNGraph.GetEgonet = GetEgonet_classFn + +def GetEgonetHop_classFn(self, *args, **kwargs): + return GetEgonetHop(self, *args, **kwargs) +PUNGraph.GetEgonetHop = GetEgonetHop_classFn +PNGraph.GetEgonetHop = GetEgonetHop_classFn +PNEANet.GetEgonetHop = GetEgonetHop_classFn + +def GetInEgonetHop_classFn(self, *args, **kwargs): + return GetInEgonetHop(self, *args, **kwargs) +PUNGraph.GetInEgonetHop = GetInEgonetHop_classFn +PNGraph.GetInEgonetHop = GetInEgonetHop_classFn +PNEANet.GetInEgonetHop = GetInEgonetHop_classFn + +def GetOutEgonetHop_classFn(self, *args, **kwargs): + return GetOutEgonetHop(self, *args, **kwargs) +PUNGraph.GetOutEgonetHop = GetOutEgonetHop_classFn +PNGraph.GetOutEgonetHop = GetOutEgonetHop_classFn +PNEANet.GetOutEgonetHop = GetOutEgonetHop_classFn + +def GetInEgonetSub_classFn(self, *args, **kwargs): + return GetInEgonetSub(self, *args, **kwargs) +PUNGraph.GetInEgonetSub = GetInEgonetSub_classFn +PNGraph.GetInEgonetSub = GetInEgonetSub_classFn +PNEANet.GetInEgonetSub = GetInEgonetSub_classFn + +def GetGraphUnion_classFn(self, *args, **kwargs): + return GetGraphUnion(self, *args, **kwargs) +PUNGraph.GetGraphUnion = GetGraphUnion_classFn +PNGraph.GetGraphUnion = GetGraphUnion_classFn +PNEANet.GetGraphUnion = GetGraphUnion_classFn + +def GetGraphUnionAttr_classFn(self, *args, **kwargs): + return GetGraphUnionAttr(self, *args, **kwargs) +PNEANet.GetGraphUnionAttr = GetGraphUnionAttr_classFn + +def GetGraphIntersection_classFn(self, *args, **kwargs): + return GetGraphIntersection(self, *args, **kwargs) +PUNGraph.GetGraphIntersection = GetGraphIntersection_classFn +PNGraph.GetGraphIntersection = GetGraphIntersection_classFn +PNEANet.GetGraphIntersection = GetGraphIntersection_classFn + +def GetGraphIntersectionAttr_classFn(self, *args, **kwargs): + return GetGraphIntersectionAttr(self, *args, **kwargs) +PNEANet.GetGraphIntersectionAttr = GetGraphIntersectionAttr_classFn + +def IsTree_classFn(self, *args, **kwargs): + return IsTree(self, *args, **kwargs) +PUNGraph.IsTree = IsTree_classFn +PNGraph.IsTree = IsTree_classFn +PNEANet.IsTree = IsTree_classFn + +def PrintInfo_classFn(self, *args, **kwargs): + return PrintInfo(self, *args, **kwargs) +PUNGraph.PrintInfo = PrintInfo_classFn +PNGraph.PrintInfo = PrintInfo_classFn +PNEANet.PrintInfo = PrintInfo_classFn + +def PlotSccDistr_classFn(self, *args, **kwargs): + return PlotSccDistr(self, *args, **kwargs) +PUNGraph.PlotSccDistr = PlotSccDistr_classFn +PNGraph.PlotSccDistr = PlotSccDistr_classFn +PNEANet.PlotSccDistr = PlotSccDistr_classFn + +def PlotWccDistr_classFn(self, *args, **kwargs): + return PlotWccDistr(self, *args, **kwargs) +PUNGraph.PlotWccDistr = PlotWccDistr_classFn +PNGraph.PlotWccDistr = PlotWccDistr_classFn +PNEANet.PlotWccDistr = PlotWccDistr_classFn + +def PlotClustCf_classFn(self, *args, **kwargs): + return PlotClustCf(self, *args, **kwargs) +PUNGraph.PlotClustCf = PlotClustCf_classFn +PNGraph.PlotClustCf = PlotClustCf_classFn +PNEANet.PlotClustCf = PlotClustCf_classFn + +def PlotInDegDistr_classFn(self, *args, **kwargs): + return PlotInDegDistr(self, *args, **kwargs) +PUNGraph.PlotInDegDistr = PlotInDegDistr_classFn +PNGraph.PlotInDegDistr = PlotInDegDistr_classFn +PNEANet.PlotInDegDistr = PlotInDegDistr_classFn + +def PlotOutDegDistr_classFn(self, *args, **kwargs): + return PlotOutDegDistr(self, *args, **kwargs) +PUNGraph.PlotOutDegDistr = PlotOutDegDistr_classFn +PNGraph.PlotOutDegDistr = PlotOutDegDistr_classFn +PNEANet.PlotOutDegDistr = PlotOutDegDistr_classFn + +def PlotHops_classFn(self, *args, **kwargs): + return PlotHops(self, *args, **kwargs) +PUNGraph.PlotHops = PlotHops_classFn +PNGraph.PlotHops = PlotHops_classFn +PNEANet.PlotHops = PlotHops_classFn + +def PlotShortPathDistr_classFn(self, *args, **kwargs): + return PlotShortPathDistr(self, *args, **kwargs) +PUNGraph.PlotShortPathDistr = PlotShortPathDistr_classFn +PNGraph.PlotShortPathDistr = PlotShortPathDistr_classFn +PNEANet.PlotShortPathDistr = PlotShortPathDistr_classFn + +def PlotEigValDistr_classFn(self, *args, **kwargs): + return PlotEigValDistr(self, *args, **kwargs) +PUNGraph.PlotEigValDistr = PlotEigValDistr_classFn +PNGraph.PlotEigValDistr = PlotEigValDistr_classFn +PNEANet.PlotEigValDistr = PlotEigValDistr_classFn + +def PlotEigValRank_classFn(self, *args, **kwargs): + return PlotEigValRank(self, *args, **kwargs) +PUNGraph.PlotEigValRank = PlotEigValRank_classFn +PNGraph.PlotEigValRank = PlotEigValRank_classFn +PNEANet.PlotEigValRank = PlotEigValRank_classFn + +def PlotSngValDistr_classFn(self, *args, **kwargs): + return PlotSngValDistr(self, *args, **kwargs) +PUNGraph.PlotSngValDistr = PlotSngValDistr_classFn +PNGraph.PlotSngValDistr = PlotSngValDistr_classFn +PNEANet.PlotSngValDistr = PlotSngValDistr_classFn + +def PlotSngValRank_classFn(self, *args, **kwargs): + return PlotSngValRank(self, *args, **kwargs) +PUNGraph.PlotSngValRank = PlotSngValRank_classFn +PNGraph.PlotSngValRank = PlotSngValRank_classFn +PNEANet.PlotSngValRank = PlotSngValRank_classFn + +def PlotSngVec_classFn(self, *args, **kwargs): + return PlotSngVec(self, *args, **kwargs) +PUNGraph.PlotSngVec = PlotSngVec_classFn +PNGraph.PlotSngVec = PlotSngVec_classFn +PNEANet.PlotSngVec = PlotSngVec_classFn + +def PlotInvParticipRat_classFn(self, *args, **kwargs): + return PlotInvParticipRat(self, *args, **kwargs) +PUNGraph.PlotInvParticipRat = PlotInvParticipRat_classFn +PNGraph.PlotInvParticipRat = PlotInvParticipRat_classFn +PNEANet.PlotInvParticipRat = PlotInvParticipRat_classFn + +def PlotKCoreEdges_classFn(self, *args, **kwargs): + return PlotKCoreEdges(self, *args, **kwargs) +PUNGraph.PlotKCoreEdges = PlotKCoreEdges_classFn +PNGraph.PlotKCoreEdges = PlotKCoreEdges_classFn +PNEANet.PlotKCoreEdges = PlotKCoreEdges_classFn + +def PlotKCoreNodes_classFn(self, *args, **kwargs): + return PlotKCoreNodes(self, *args, **kwargs) +PUNGraph.PlotKCoreNodes = PlotKCoreNodes_classFn +PNGraph.PlotKCoreNodes = PlotKCoreNodes_classFn +PNEANet.PlotKCoreNodes = PlotKCoreNodes_classFn + +def GetSccs_classFn(self, *args, **kwargs): + return GetSccs(self, *args, **kwargs) +PUNGraph.GetSccs = GetSccs_classFn +PNGraph.GetSccs = GetSccs_classFn +PNEANet.GetSccs = GetSccs_classFn + +def GetSccSzCnt_classFn(self, *args, **kwargs): + return GetSccSzCnt(self, *args, **kwargs) +PUNGraph.GetSccSzCnt = GetSccSzCnt_classFn +PNGraph.GetSccSzCnt = GetSccSzCnt_classFn +PNEANet.GetSccSzCnt = GetSccSzCnt_classFn + +def GetWccs_classFn(self, *args, **kwargs): + return GetWccs(self, *args, **kwargs) +PUNGraph.GetWccs = GetWccs_classFn +PNGraph.GetWccs = GetWccs_classFn +PNEANet.GetWccs = GetWccs_classFn + +def GetWccSzCnt_classFn(self, *args, **kwargs): + return GetWccSzCnt(self, *args, **kwargs) +PUNGraph.GetWccSzCnt = GetWccSzCnt_classFn +PNGraph.GetWccSzCnt = GetWccSzCnt_classFn +PNEANet.GetWccSzCnt = GetWccSzCnt_classFn + +def GetMxBiCon_classFn(self, *args, **kwargs): + return GetMxBiCon(self, *args, **kwargs) +PUNGraph.GetMxBiCon = GetMxBiCon_classFn +PNGraph.GetMxBiCon = GetMxBiCon_classFn +PNEANet.GetMxBiCon = GetMxBiCon_classFn + +def GetMxScc_classFn(self, *args, **kwargs): + return GetMxScc(self, *args, **kwargs) +PUNGraph.GetMxScc = GetMxScc_classFn +PNGraph.GetMxScc = GetMxScc_classFn +PNEANet.GetMxScc = GetMxScc_classFn + +def GetMxSccSz_classFn(self, *args, **kwargs): + return GetMxSccSz(self, *args, **kwargs) +PUNGraph.GetMxSccSz = GetMxSccSz_classFn +PNGraph.GetMxSccSz = GetMxSccSz_classFn +PNEANet.GetMxSccSz = GetMxSccSz_classFn + +def GetMxWcc_classFn(self, *args, **kwargs): + return GetMxWcc(self, *args, **kwargs) +PUNGraph.GetMxWcc = GetMxWcc_classFn +PNGraph.GetMxWcc = GetMxWcc_classFn +PNEANet.GetMxWcc = GetMxWcc_classFn + +def GetMxWccSz_classFn(self, *args, **kwargs): + return GetMxWccSz(self, *args, **kwargs) +PUNGraph.GetMxWccSz = GetMxWccSz_classFn +PNGraph.GetMxWccSz = GetMxWccSz_classFn +PNEANet.GetMxWccSz = GetMxWccSz_classFn + +def IsConnected_classFn(self, *args, **kwargs): + return IsConnected(self, *args, **kwargs) +PUNGraph.IsConnected = IsConnected_classFn +PNGraph.IsConnected = IsConnected_classFn +PNEANet.IsConnected = IsConnected_classFn + +def IsWeaklyConn_classFn(self, *args, **kwargs): + return IsWeaklyConn(self, *args, **kwargs) +PUNGraph.IsWeaklyConn = IsWeaklyConn_classFn +PNGraph.IsWeaklyConn = IsWeaklyConn_classFn +PNEANet.IsWeaklyConn = IsWeaklyConn_classFn + +def GetNodeWcc_classFn(self, *args, **kwargs): + return GetNodeWcc(self, *args, **kwargs) +PUNGraph.GetNodeWcc = GetNodeWcc_classFn +PNGraph.GetNodeWcc = GetNodeWcc_classFn +PNEANet.GetNodeWcc = GetNodeWcc_classFn + +def Get1CnCom_classFn(self, *args, **kwargs): + return Get1CnCom(self, *args, **kwargs) +PUNGraph.Get1CnCom = Get1CnCom_classFn +PNGraph.Get1CnCom = Get1CnCom_classFn +PNEANet.Get1CnCom = Get1CnCom_classFn + +def Get1CnComSzCnt_classFn(self, *args, **kwargs): + return Get1CnComSzCnt(self, *args, **kwargs) +PUNGraph.Get1CnComSzCnt = Get1CnComSzCnt_classFn +PNGraph.Get1CnComSzCnt = Get1CnComSzCnt_classFn +PNEANet.Get1CnComSzCnt = Get1CnComSzCnt_classFn + +def GetBiCon_classFn(self, *args, **kwargs): + return GetBiCon(self, *args, **kwargs) +PUNGraph.GetBiCon = GetBiCon_classFn +PNGraph.GetBiCon = GetBiCon_classFn +PNEANet.GetBiCon = GetBiCon_classFn + +def GetBiConSzCnt_classFn(self, *args, **kwargs): + return GetBiConSzCnt(self, *args, **kwargs) +PUNGraph.GetBiConSzCnt = GetBiConSzCnt_classFn +PNGraph.GetBiConSzCnt = GetBiConSzCnt_classFn +PNEANet.GetBiConSzCnt = GetBiConSzCnt_classFn + +def GetArtPoints_classFn(self, *args, **kwargs): + return GetArtPoints(self, *args, **kwargs) +PUNGraph.GetArtPoints = GetArtPoints_classFn +PNGraph.GetArtPoints = GetArtPoints_classFn +PNEANet.GetArtPoints = GetArtPoints_classFn + +def GetEdgeBridges_classFn(self, *args, **kwargs): + return GetEdgeBridges(self, *args, **kwargs) +PUNGraph.GetEdgeBridges = GetEdgeBridges_classFn +PNGraph.GetEdgeBridges = GetEdgeBridges_classFn +PNEANet.GetEdgeBridges = GetEdgeBridges_classFn + +def GetBfsFullDiam_classFn(self, *args, **kwargs): + return GetBfsFullDiam(self, *args, **kwargs) +PUNGraph.GetBfsFullDiam = GetBfsFullDiam_classFn +PNGraph.GetBfsFullDiam = GetBfsFullDiam_classFn +PNEANet.GetBfsFullDiam = GetBfsFullDiam_classFn + +def GetBfsEffDiam_classFn(self, *args, **kwargs): + return GetBfsEffDiam(self, *args, **kwargs) +PUNGraph.GetBfsEffDiam = GetBfsEffDiam_classFn +PNGraph.GetBfsEffDiam = GetBfsEffDiam_classFn +PNEANet.GetBfsEffDiam = GetBfsEffDiam_classFn + +def GetBfsEffDiamAll_classFn(self, *args, **kwargs): + return GetBfsEffDiamAll(self, *args, **kwargs) +PUNGraph.GetBfsEffDiamAll = GetBfsEffDiamAll_classFn +PNGraph.GetBfsEffDiamAll = GetBfsEffDiamAll_classFn +PNEANet.GetBfsEffDiamAll = GetBfsEffDiamAll_classFn + +def GetNodesAtHop_classFn(self, *args, **kwargs): + return GetNodesAtHop(self, *args, **kwargs) +PUNGraph.GetNodesAtHop = GetNodesAtHop_classFn +PNGraph.GetNodesAtHop = GetNodesAtHop_classFn +PNEANet.GetNodesAtHop = GetNodesAtHop_classFn + +def GetNodesAtHops_classFn(self, *args, **kwargs): + return GetNodesAtHops(self, *args, **kwargs) +PUNGraph.GetNodesAtHops = GetNodesAtHops_classFn +PNGraph.GetNodesAtHops = GetNodesAtHops_classFn +PNEANet.GetNodesAtHops = GetNodesAtHops_classFn + +def GetShortPath_classFn(self, *args, **kwargs): + return GetShortPath(self, *args, **kwargs) +PUNGraph.GetShortPath = GetShortPath_classFn +PNGraph.GetShortPath = GetShortPath_classFn +PNEANet.GetShortPath = GetShortPath_classFn + +def GetBfsTree_classFn(self, *args, **kwargs): + return GetBfsTree(self, *args, **kwargs) +PUNGraph.GetBfsTree = GetBfsTree_classFn +PNGraph.GetBfsTree = GetBfsTree_classFn +PNEANet.GetBfsTree = GetBfsTree_classFn + +def GetTreeRootNId_classFn(self, *args, **kwargs): + return GetTreeRootNId(self, *args, **kwargs) +PUNGraph.GetTreeRootNId = GetTreeRootNId_classFn +PNGraph.GetTreeRootNId = GetTreeRootNId_classFn +PNEANet.GetTreeRootNId = GetTreeRootNId_classFn + +def GetTreeSig_classFn(self, *args, **kwargs): + return GetTreeSig(self, *args, **kwargs) +PUNGraph.GetTreeSig = GetTreeSig_classFn +PNGraph.GetTreeSig = GetTreeSig_classFn +PNEANet.GetTreeSig = GetTreeSig_classFn + +def GetDegreeCentr_classFn(self, *args, **kwargs): + return GetDegreeCentr(self, *args, **kwargs) +PUNGraph.GetDegreeCentr = GetDegreeCentr_classFn +PNGraph.GetDegreeCentr = GetDegreeCentr_classFn +PNEANet.GetDegreeCentr = GetDegreeCentr_classFn + +def GetBetweennessCentr_classFn(self, *args, **kwargs): + return GetBetweennessCentr(self, *args, **kwargs) +PUNGraph.GetBetweennessCentr = GetBetweennessCentr_classFn +PNGraph.GetBetweennessCentr = GetBetweennessCentr_classFn +PNEANet.GetBetweennessCentr = GetBetweennessCentr_classFn + +def GetClosenessCentr_classFn(self, *args, **kwargs): + return GetClosenessCentr(self, *args, **kwargs) +PUNGraph.GetClosenessCentr = GetClosenessCentr_classFn +PNGraph.GetClosenessCentr = GetClosenessCentr_classFn +PNEANet.GetClosenessCentr = GetClosenessCentr_classFn + +def GetFarnessCentr_classFn(self, *args, **kwargs): + return GetFarnessCentr(self, *args, **kwargs) +PUNGraph.GetFarnessCentr = GetFarnessCentr_classFn +PNGraph.GetFarnessCentr = GetFarnessCentr_classFn +PNEANet.GetFarnessCentr = GetFarnessCentr_classFn + +def GetPageRank_classFn(self, *args, **kwargs): + return GetPageRank(self, *args, **kwargs) +PUNGraph.GetPageRank = GetPageRank_classFn +PNGraph.GetPageRank = GetPageRank_classFn +PNEANet.GetPageRank = GetPageRank_classFn + +def GetHits_classFn(self, *args, **kwargs): + return GetHits(self, *args, **kwargs) +PUNGraph.GetHits = GetHits_classFn +PNGraph.GetHits = GetHits_classFn +PNEANet.GetHits = GetHits_classFn + +def GetNodeEcc_classFn(self, *args, **kwargs): + return GetNodeEcc(self, *args, **kwargs) +PUNGraph.GetNodeEcc = GetNodeEcc_classFn +PNGraph.GetNodeEcc = GetNodeEcc_classFn +PNEANet.GetNodeEcc = GetNodeEcc_classFn + +def GetEigenVectorCentr_classFn(self, *args, **kwargs): + return GetEigenVectorCentr(self, *args, **kwargs) +PUNGraph.GetEigenVectorCentr = GetEigenVectorCentr_classFn +PNGraph.GetEigenVectorCentr = GetEigenVectorCentr_classFn +PNEANet.GetEigenVectorCentr = GetEigenVectorCentr_classFn + +def CommunityCNM_classFn(self, *args, **kwargs): + return CommunityCNM(self, *args, **kwargs) +PUNGraph.CommunityCNM = CommunityCNM_classFn +PNGraph.CommunityCNM = CommunityCNM_classFn +PNEANet.CommunityCNM = CommunityCNM_classFn + +def CommunityGirvanNewman_classFn(self, *args, **kwargs): + return CommunityGirvanNewman(self, *args, **kwargs) +PUNGraph.CommunityGirvanNewman = CommunityGirvanNewman_classFn +PNGraph.CommunityGirvanNewman = CommunityGirvanNewman_classFn +PNEANet.CommunityGirvanNewman = CommunityGirvanNewman_classFn + +def GetEdgesInOut_classFn(self, *args, **kwargs): + return GetEdgesInOut(self, *args, **kwargs) +PUNGraph.GetEdgesInOut = GetEdgesInOut_classFn +PNGraph.GetEdgesInOut = GetEdgesInOut_classFn +PNEANet.GetEdgesInOut = GetEdgesInOut_classFn + +def GetModularity_classFn(self, *args, **kwargs): + return GetModularity(self, *args, **kwargs) +PUNGraph.GetModularity = GetModularity_classFn +PNGraph.GetModularity = GetModularity_classFn +PNEANet.GetModularity = GetModularity_classFn + +def GetClustCf_classFn(self, *args, **kwargs): + return GetClustCf(self, *args, **kwargs) +PUNGraph.GetClustCf = GetClustCf_classFn +PNGraph.GetClustCf = GetClustCf_classFn +PNEANet.GetClustCf = GetClustCf_classFn + +def GetClustCfAll_classFn(self, *args, **kwargs): + return GetClustCfAll(self, *args, **kwargs) +PUNGraph.GetClustCfAll = GetClustCfAll_classFn +PNGraph.GetClustCfAll = GetClustCfAll_classFn +PNEANet.GetClustCfAll = GetClustCfAll_classFn + +def GetTriads_classFn(self, *args, **kwargs): + return GetTriads(self, *args, **kwargs) +PUNGraph.GetTriads = GetTriads_classFn +PNGraph.GetTriads = GetTriads_classFn +PNEANet.GetTriads = GetTriads_classFn + +def GetTriadsByNode_classFn(self, *args, **kwargs): + return GetTriadsByNode(self, *args, **kwargs) +PUNGraph.GetTriadsByNode = GetTriadsByNode_classFn +PNGraph.GetTriadsByNode = GetTriadsByNode_classFn +PNEANet.GetTriadsByNode = GetTriadsByNode_classFn + +def GetTriadsAll_classFn(self, *args, **kwargs): + return GetTriadsAll(self, *args, **kwargs) +PUNGraph.GetTriadsAll = GetTriadsAll_classFn +PNGraph.GetTriadsAll = GetTriadsAll_classFn +PNEANet.GetTriadsAll = GetTriadsAll_classFn + +def GetCmnNbrs_classFn(self, *args, **kwargs): + return GetCmnNbrs(self, *args, **kwargs) +PUNGraph.GetCmnNbrs = GetCmnNbrs_classFn +PNGraph.GetCmnNbrs = GetCmnNbrs_classFn +PNEANet.GetCmnNbrs = GetCmnNbrs_classFn + +def GetNodeClustCf_classFn(self, *args, **kwargs): + return GetNodeClustCf(self, *args, **kwargs) +PUNGraph.GetNodeClustCf = GetNodeClustCf_classFn +PNGraph.GetNodeClustCf = GetNodeClustCf_classFn +PNEANet.GetNodeClustCf = GetNodeClustCf_classFn + +def GetNodeClustCfAll_classFn(self, *args, **kwargs): + return GetNodeClustCfAll(self, *args, **kwargs) +PUNGraph.GetNodeClustCfAll = GetNodeClustCfAll_classFn +PNGraph.GetNodeClustCfAll = GetNodeClustCfAll_classFn +PNEANet.GetNodeClustCfAll = GetNodeClustCfAll_classFn + +def GetNodeTriads_classFn(self, *args, **kwargs): + return GetNodeTriads(self, *args, **kwargs) +PUNGraph.GetNodeTriads = GetNodeTriads_classFn +PNGraph.GetNodeTriads = GetNodeTriads_classFn +PNEANet.GetNodeTriads = GetNodeTriads_classFn + +def GetNodeTriadsSet_classFn(self, *args, **kwargs): + return GetNodeTriadsSet(self, *args, **kwargs) +PUNGraph.GetNodeTriadsSet = GetNodeTriadsSet_classFn +PNGraph.GetNodeTriadsSet = GetNodeTriadsSet_classFn +PNEANet.GetNodeTriadsSet = GetNodeTriadsSet_classFn + +def GetNodeTriadsAll_classFn(self, *args, **kwargs): + return GetNodeTriadsAll(self, *args, **kwargs) +PUNGraph.GetNodeTriadsAll = GetNodeTriadsAll_classFn +PNGraph.GetNodeTriadsAll = GetNodeTriadsAll_classFn +PNEANet.GetNodeTriadsAll = GetNodeTriadsAll_classFn + +def GetLen2Paths_classFn(self, *args, **kwargs): + return GetLen2Paths(self, *args, **kwargs) +PUNGraph.GetLen2Paths = GetLen2Paths_classFn +PNGraph.GetLen2Paths = GetLen2Paths_classFn +PNEANet.GetLen2Paths = GetLen2Paths_classFn + +def GetTriadEdges_classFn(self, *args, **kwargs): + return GetTriadEdges(self, *args, **kwargs) +PUNGraph.GetTriadEdges = GetTriadEdges_classFn +PNGraph.GetTriadEdges = GetTriadEdges_classFn +PNEANet.GetTriadEdges = GetTriadEdges_classFn + +def GetTriadParticip_classFn(self, *args, **kwargs): + return GetTriadParticip(self, *args, **kwargs) +PUNGraph.GetTriadParticip = GetTriadParticip_classFn +PNGraph.GetTriadParticip = GetTriadParticip_classFn +PNEANet.GetTriadParticip = GetTriadParticip_classFn + +def GetKCore_classFn(self, *args, **kwargs): + return GetKCore(self, *args, **kwargs) +PUNGraph.GetKCore = GetKCore_classFn +PNGraph.GetKCore = GetKCore_classFn +PNEANet.GetKCore = GetKCore_classFn + +def GetKCoreNodes_classFn(self, *args, **kwargs): + return GetKCoreNodes(self, *args, **kwargs) +PUNGraph.GetKCoreNodes = GetKCoreNodes_classFn +PNGraph.GetKCoreNodes = GetKCoreNodes_classFn +PNEANet.GetKCoreNodes = GetKCoreNodes_classFn + +def GetKCoreEdges_classFn(self, *args, **kwargs): + return GetKCoreEdges(self, *args, **kwargs) +PUNGraph.GetKCoreEdges = GetKCoreEdges_classFn +PNGraph.GetKCoreEdges = GetKCoreEdges_classFn +PNEANet.GetKCoreEdges = GetKCoreEdges_classFn + +def GetAnf_classFn(self, *args, **kwargs): + return GetAnf(self, *args, **kwargs) +PUNGraph.GetAnf = GetAnf_classFn +PNGraph.GetAnf = GetAnf_classFn +PNEANet.GetAnf = GetAnf_classFn + +def GetAnfNode_classFn(self, *args, **kwargs): + return GetAnfNode(self, *args, **kwargs) +PUNGraph.GetAnfNode = GetAnfNode_classFn +PNGraph.GetAnfNode = GetAnfNode_classFn +PNEANet.GetAnfNode = GetAnfNode_classFn + +def GetAnfGraph_classFn(self, *args, **kwargs): + return GetAnfGraph(self, *args, **kwargs) +PUNGraph.GetAnfGraph = GetAnfGraph_classFn +PNGraph.GetAnfGraph = GetAnfGraph_classFn +PNEANet.GetAnfGraph = GetAnfGraph_classFn + +def GetAnfEffDiam_classFn(self, *args, **kwargs): + return GetAnfEffDiam(self, *args, **kwargs) +PUNGraph.GetAnfEffDiam = GetAnfEffDiam_classFn +PNGraph.GetAnfEffDiam = GetAnfEffDiam_classFn +PNEANet.GetAnfEffDiam = GetAnfEffDiam_classFn + +def GetEigVals_classFn(self, *args, **kwargs): + return GetEigVals(self, *args, **kwargs) +PUNGraph.GetEigVals = GetEigVals_classFn +PNGraph.GetEigVals = GetEigVals_classFn +PNEANet.GetEigVals = GetEigVals_classFn + +def GetEigVec_classFn(self, *args, **kwargs): + return GetEigVec(self, *args, **kwargs) +PUNGraph.GetEigVec = GetEigVec_classFn +PNGraph.GetEigVec = GetEigVec_classFn +PNEANet.GetEigVec = GetEigVec_classFn + +def GetEigVecs_classFn(self, *args, **kwargs): + return GetEigVecs(self, *args, **kwargs) +PUNGraph.GetEigVecs = GetEigVecs_classFn +PNGraph.GetEigVecs = GetEigVecs_classFn +PNEANet.GetEigVecs = GetEigVecs_classFn + +def GetLeadEigVec_classFn(self, *args, **kwargs): + return GetLeadEigVec(self, *args, **kwargs) +PUNGraph.GetLeadEigVec = GetLeadEigVec_classFn +PNGraph.GetLeadEigVec = GetLeadEigVec_classFn +PNEANet.GetLeadEigVec = GetLeadEigVec_classFn + +def GetSngVals_classFn(self, *args, **kwargs): + return GetSngVals(self, *args, **kwargs) +PUNGraph.GetSngVals = GetSngVals_classFn +PNGraph.GetSngVals = GetSngVals_classFn +PNEANet.GetSngVals = GetSngVals_classFn + +def GetSngVec_classFn(self, *args, **kwargs): + return GetSngVec(self, *args, **kwargs) +PUNGraph.GetSngVec = GetSngVec_classFn +PNGraph.GetSngVec = GetSngVec_classFn +PNEANet.GetSngVec = GetSngVec_classFn + +def GetSngVecs_classFn(self, *args, **kwargs): + return GetSngVecs(self, *args, **kwargs) +PUNGraph.GetSngVecs = GetSngVecs_classFn +PNGraph.GetSngVecs = GetSngVecs_classFn +PNEANet.GetSngVecs = GetSngVecs_classFn + +def GetLeadSngVec_classFn(self, *args, **kwargs): + return GetLeadSngVec(self, *args, **kwargs) +PUNGraph.GetLeadSngVec = GetLeadSngVec_classFn +PNGraph.GetLeadSngVec = GetLeadSngVec_classFn +PNEANet.GetLeadSngVec = GetLeadSngVec_classFn + +def GetInvParticipRat_classFn(self, *args, **kwargs): + return GetInvParticipRat(self, *args, **kwargs) +PUNGraph.GetInvParticipRat = GetInvParticipRat_classFn +PNGraph.GetInvParticipRat = GetInvParticipRat_classFn +PNEANet.GetInvParticipRat = GetInvParticipRat_classFn + +def GetShortPathAll_classFn(self, *args, **kwargs): + return GetShortPathAll(self, *args, **kwargs) +PUNGraph.GetShortPathAll = GetShortPathAll_classFn +PNGraph.GetShortPathAll = GetShortPathAll_classFn +PNEANet.GetShortPathAll = GetShortPathAll_classFn + +def GenRewire_classFn(self, *args, **kwargs): + return GenRewire(self, *args, **kwargs) +PUNGraph.GenRewire = GenRewire_classFn +PNGraph.GenRewire = GenRewire_classFn +PNEANet.GenRewire = GenRewire_classFn + +def SaveEdgeList_classFn(self, *args, **kwargs): + return SaveEdgeList(self, *args, **kwargs) +PUNGraph.SaveEdgeList = SaveEdgeList_classFn +PNGraph.SaveEdgeList = SaveEdgeList_classFn +PNEANet.SaveEdgeList = SaveEdgeList_classFn + +def SaveMatlabSparseMtx_classFn(self, *args, **kwargs): + return SaveMatlabSparseMtx(self, *args, **kwargs) +PUNGraph.SaveMatlabSparseMtx = SaveMatlabSparseMtx_classFn +PNGraph.SaveMatlabSparseMtx = SaveMatlabSparseMtx_classFn +PNEANet.SaveMatlabSparseMtx = SaveMatlabSparseMtx_classFn + +def SavePajek_classFn(self, *args, **kwargs): + return SavePajek(self, *args, **kwargs) +PUNGraph.SavePajek = SavePajek_classFn +PNGraph.SavePajek = SavePajek_classFn +PNEANet.SavePajek = SavePajek_classFn + +def SaveGViz_classFn(self, *args, **kwargs): + return SaveGViz(self, *args, **kwargs) +PUNGraph.SaveGViz = SaveGViz_classFn +PNGraph.SaveGViz = SaveGViz_classFn +PNEANet.SaveGViz = SaveGViz_classFn + +def SaveGVizColor_classFn(self, *args, **kwargs): + return SaveGVizColor(self, *args, **kwargs) +PUNGraph.SaveGVizColor = SaveGVizColor_classFn +PNGraph.SaveGVizColor = SaveGVizColor_classFn +PNEANet.SaveGVizColor = SaveGVizColor_classFn + +def DrawGViz_classFn(self, *args, **kwargs): + return DrawGViz(self, *args, **kwargs) +PUNGraph.DrawGViz = DrawGViz_classFn +PNGraph.DrawGViz = DrawGViz_classFn +PNEANet.DrawGViz = DrawGViz_classFn + +def DrawGVizColor_classFn(self, *args, **kwargs): + return DrawGVizColor(self, *args, **kwargs) +PUNGraph.DrawGVizColor = DrawGVizColor_classFn +PNGraph.DrawGVizColor = DrawGVizColor_classFn +PNEANet.DrawGVizColor = DrawGVizColor_classFn + +def ToGraph_classFN(self, GraphType, *args, **kwargs): + GraphType = ConvertGraphArg(GraphType) + return ToGraph(GraphType, self, *args, **kwargs) +PTable.ToGraph = ToGraph_classFN + +def ToNetwork_classFN(self, GraphType, *args, **kwargs): + GraphType = ConvertGraphArg(GraphType) + return ToNetwork(GraphType, self, *args, **kwargs) +PTable.ToNetwork = ToNetwork_classFN + +%} + diff --git a/snap-python/source/swig/setup.py b/snap-python/source/swig/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..d96c15a4d78260d461fde8fba4315293d20db477 --- /dev/null +++ b/snap-python/source/swig/setup.py @@ -0,0 +1,71 @@ +""" +setup.py file for SNAP (Stanford Network Analysis Platform) Python +""" +import os +import platform +import shutil + +from setuptools import Extension, setup +from setuptools.command.build_ext import build_ext + +import distutils.dir_util + +SNAPPY_VERSION = '6.0.0' + +class SwigExtension(Extension): + def __init__(self, name, sourcedir=''): + Extension.__init__(self, name, sources=[]) + self.sourcedir = os.path.abspath(sourcedir) + +class PkgBuild(build_ext): + def run(self): + for ext in self.extensions: + self.build_extension(ext) + + def build_extension(self, ext): + extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name))) + + if not os.path.exists(extdir): + os.makedirs(extdir) + + snap_obj = '_snap.so' + if platform.uname()[0].find('Windows') == 0: + snap_obj = '_snap.pyd' + + # SWIG generated SNAP .py + shutil.copy('snap.py', extdir) + # compiled SNAP object library + shutil.copy(snap_obj, extdir) + + # __init__ to import snapx as a module + shutil.copy('snap/__init__.py', extdir) + # snapx implementation + distutils.dir_util.copy_tree( + '../snapx/snapx', os.path.join(extdir, 'snapx')) + +with open('../README.md') as f: + LONG_DESCRIPTION = f.read() + +setup( + name='snap-stanford', + version=SNAPPY_VERSION, + author="snap.stanford.edu", + description="SNAP (Stanford Network Analysis Platform) Python", + long_description=LONG_DESCRIPTION, + long_description_content_type="text/markdown", + url="http://snap.stanford.edu", + license="3-clause BSD, http://snap.stanford.edu/snap/license.html", + classifiers=[ + "Programming Language :: Python :: 2", + "Programming Language :: Python :: 3", + "License :: OSI Approved :: BSD License", + "Operating System :: MacOS", + "Operating System :: Microsoft :: Windows", + "Operating System :: POSIX :: Linux", + "Topic :: Scientific/Engineering" + ], + zip_safe=False, + cmdclass=dict(build_ext=PkgBuild), + ext_modules=[SwigExtension('snap.')], +) + diff --git a/snap-python/source/swig/snap.i b/snap-python/source/swig/snap.i new file mode 100644 index 0000000000000000000000000000000000000000..bd3ed39e0e89c1e39a1b102997cf17c5b2e6880e --- /dev/null +++ b/snap-python/source/swig/snap.i @@ -0,0 +1,689 @@ +// snap.i + +// PNEANet, PUNGraph, PNGraph are supported, +// along with standard SNAP functions. + +// set to 1 for release to include all the functions (long compile) +// set to 0 for development to include limited functions (shorter compile) +#define SNAP_ALL 0 + +%pythoncode %{ +Version = "6.0.1" +%} + +%module snap + +%{ + +#include "Snap.h" +//#include "cliques.h" +//#include "agm.h" +//#include "agmfast.h" +//#include "agmfit.h" +//#include "n2v.h" + +/* #include "Engine.h" */ +#include "snapswig.h" + +#include "printgraph.h" +#include "snap_types.h" +#include "goodgraph.cpp" +#include "linkpred_swig.h" + +%} + +%feature("autodoc", "3"); + +%ignore TOnExeStop; +%ignore TPt::TPt; +%ignore TPt::LoadXml; +%ignore TPt::SaveXml; +%ignore TPt::operator==; +%ignore TPt::operator!=; +%ignore TPt::operator<; +%ignore TPt::GetPrimHashCd; +%ignore TPt::GetSecHashCd; +%ignore TPt::Clone; + +%ignore TChA::LoadXml; +%ignore TMem::LoadXml; + +%ignore TInt::GetStr; +%ignore TPair::GetStr; + +%ignore TFInOut; +%ignore TFRnd; +%ignore TFile::Copy; +%ignore TFile::GetLastAccessTm; +%ignore TFile::GetLastWriteTm; +%ignore TFile::GetCreateTm; +%ignore TFile::GetSize; + +%ignore TBPGraph::HasFlag(const TGraphFlag& Flag) const; +%ignore TNEGraph::GetSmallGraph(); +%ignore TNEANet::GetSmallGraph(); +%ignore TBPGraph::GetEI(int const&) const; + +%ignore TNGraph::GetEI(int const&) const; +%ignore TUNGraph::GetEI(int const&) const; +%ignore TNEANet::GetEI(int const&) const; +%ignore TDirNet::GetEI(int const&) const; +%ignore TUndirNet::GetEI(int const&) const; + +%ignore TVec, int>::Add; +%ignore TVec, int>::AddMerged; + +%ignore TVec::Add; +%ignore TVec::AddMerged; + + +%ignore THash< TInt, TVec< TInt, int > >::AddDat; +%ignore THash< TInt, TVec< TInt, int > >::HashPrimeT; +%ignore THash< TInt, TVec< TInt, int > >::AddDatId; + +%ignore THash< TInt, TInt, TDefaultHashFunc >::HashPrimeT; +%ignore THash< TInt, TInt, TDefaultHashFunc >::AddDatId; +%ignore THash< TInt, TInt>::HashPrimeT; + +%ignore LoadXml; +%ignore SaveXml; + +%ignore TTm; +%ignore HashPrimeT; + +%ignore TPair< TStr,TAttrType >::Load; +%ignore TPair< TStr,TAttrType >::Save; +%ignore TPair< TStr,TAttrType >::GetMemUsed; +%ignore TPair< TStr,TAttrType >::GetPrimHashCd; +%ignore TPair< TStr,TAttrType >::GetSecHashCd; +%ignore TPair< TStr,TAttrType >::TPair(TSIn &); + +//%ignore TVec< TPair< TStr, TAttrType_ >, int >::Load; +//%ignore TVec< TPair< TStr, TAttrType >, int >::Load; +%ignore TVec< TPair< TStr,TAttrType > >::Load; +%ignore TVec< TPair< TStr,TAttrType > >::Save; +%ignore TVec< TPair< TStr,TAttrType > >::GetPrimHashCd; +%ignore TVec< TPair< TStr,TAttrType > >::GetSecHashCd; +//%ignore TVec< TPair< TStr,TAttrType > >::TVec(TSIn *); +%ignore TVec< TPair< TStr,TAttrType > >::TVec(TSIn &); +//%ignore Schema::Load; + +%ignore TVec::Intrs; +%ignore TVec::IntrsLen; +%ignore TVec::AddSorted; +%ignore TVec::AddBackSorted; +%ignore TVec::AddMerged; +%ignore TVec::AddVMerged; +%ignore TVec::AddUnique; +%ignore TVec::SearchBack; +%ignore TVec::SearchBin; +%ignore TVec::SearchBinLeft; +%ignore TVec::SearchForw; +%ignore TVec::SearchVForw; +%ignore TVec::Merge; +%ignore TVec::Count; +%ignore TVec::Diff; +%ignore TVec::Union; +%ignore TVec::PrevPerm; +%ignore TVec::NextPerm; +%ignore TVec::DelAll; +%ignore TVec::DelIfIn; +%ignore TVec::GetPivotValN; +%ignore TVec::BSort; +%ignore TVec::ISort; +%ignore TVec::QSort; +%ignore TVec::Sort; +%ignore TVec::IsSorted; +%ignore TVec::IsIn; +%ignore TVec::IsInBin; +%ignore TVec::Partition; +%ignore TVec::operator<; +%ignore TVec::operator==; +%ignore TVec::operator!=; +%ignore TVec::GetPrimHashCd; +%ignore TVec::GetSecHashCd; +%ignore TVec::GetDat; +%ignore TVec::UnionLen; +%ignore TVec::GetAddDat; +%ignore TVec::GetMxValN; +%ignore TVec::CopyUniqueFrom; +// TODO: maybe the line below could work +//%rename("regex:/TVec::(?!(GetVal|operator\[\]|Len))/$ignore/") ""; + +// ignore all THash::AddDatId, MarkDelKey, MarkDelKeyId +%ignore THash::AddDatId; +%ignore THash::MarkDelKey; +%ignore THash::MarkDelKeyId; + +// ignore overloaded methods for TTable row iterators +%ignore TRowIterator::GetIntAttr(TInt) const; +%ignore TRowIterator::GetFltAttr(TInt) const; +%ignore TRowIterator::GetStrAttr(TInt) const; +%ignore TRowIteratorWithRemove::GetNextIntAttr(TInt) const; +%ignore TRowIteratorWithRemove::GetNextFltAttr(TInt) const; +%ignore TRowIteratorWithRemove::GetNextStrAttr(TInt) const; + +// Python-C++ conversion typemaps + +%include "snap_types.i" + +%include exception.i + +%exception { + try { + $action + } catch (PExcept Except) { + SWIG_exception(SWIG_UnknownError,Except->GetMsgStr().CStr()); + } +} + +#define GLib_UNIX +// glib-core +%include "bd.h" +%include "ds.h" +%include "dt.h" +%include "fl.h" +//%include "tm.h" +%include "ut.h" + +// SNAP Library +// snap-core +%include "gbase.h" +%include "util.h" + +// representations +%include "hash.h" +%include "hashmp.h" +%include "shash.h" +%include "graph.h" +%include "graphmp.h" +%include "network.h" +%include "mmnet.h" +%include "networkmp.h" +%include "table.h" +%include "attr.h" + +// algorithms +%include "alg.h" +%include "anf.h" +%include "bfsdfs.h" +%include "centr.h" +%include "cmty.h" +%include "cncom.h" +%include "ff.h" +%include "gsvd.h" +%include "gio.h" +%include "gviz.h" +%include "kcore.h" +%include "ggen.h" +%include "subgraph.h" +%include "util.h" +%include "triad.h" +%include "statplot.h" +//%include "cliques.h" +//%include "agm.h" +//%include "agmfast.h" +//%include "agmfit.h" +//%include "n2v.h" + +//%template(Schema) TVec< TPair< TStr, TAttrType> >; +//%template(Schema) TVec< TPair< TStr, TAttrType_> >; + +// SNAP type definitions + +//%template(Schema) TVec >; + +// ds.h + +%template(TIntPr) TPair; +%template(TFltPr) TPair; +%template(TStrIntPr) TPair; +%template(TIntTr) TTriple; +%template(TIntFltKd) TKeyDat; +%template(TIntStrPr) TPair; + +%template(TIntV) TVec; +%template(TFltV) TVec; +%template(TStrV) TVec; +%template(TIntPrV) TVec; +%template(TFltPrV) TVec; +%template(TStrIntPrV) TVec; +%template(TIntTrV) TVec; +%template(TIntFltKdV) TVec; +%template(TIntIntVV) TVec< TVec< TInt, int >, int >; +%template(TFltVFltV) TVec; +%template(PNEANetV) TVec; + +#if SNAP_ALL +//%template(TBoolChPr) TPair; +%template(TBoolFltPr) TPair; +//%template(TUChIntPr) TPair; +//%template(TUChUInt64Pr) TPair; +//%template(TUChStrPr) TPair; +%template(TIntBoolPr) TPair; +//%template(TIntChPr) TPair; +%template(TIntUInt64Pr) TPair; +%template(TIntIntPrPr) TPair; +%template(TIntIntVPr) TPair >; +%template(TIntFltPr) TPair; +%template(TIntStrVPr) TPair; +%template(TIntPrIntPr) TPair; +%template(TUIntUIntPr) TPair; +%template(TUIntIntPr) TPair; +%template(TUInt64IntPr) TPair; +%template(TUInt64Pr) TPair; +%template(TUInt64FltPr) TPair; +%template(TUInt64StrPr) TPair; +%template(TFltIntPr) TPair; +%template(TFltUInt64Pr) TPair; +%template(TFltStrPr) TPair; +%template(TAscFltIntPr) TPair; +%template(TAscFltPr) TPair; +%template(TFltStrPr) TPair; +%template(TAscFltStrPr) TPair; +%template(TStrIntPr) TPair; +%template(TStrFltPr) TPair; +%template(TStrPr) TPair; +%template(TStrStrVPr) TPair; +%template(TStrVIntPr) TPair; +%template(TIntIntPrPr) TPair; +%template(TIntStrPrPr) TPair; +%template(TFltStrPrPr) TPair; +%template(TChTr) TTriple; +%template(TChIntIntTr) TTriple; +%template(TUChIntIntTr) TTriple; +%template(TUInt64Tr) TTriple; +%template(TIntStrIntTr) TTriple; +%template(TIntIntStrTr) TTriple; +%template(TIntIntFltTr) TTriple; +%template(TIntFltIntTr) TTriple; +%template(TIntFltFltTr) TTriple; +%template(TIntIntVIntTr) TTriple, TInt>; +%template(TIntIntIntVTr) TTriple >; +%template(TFltTr) TTriple; +%template(TFltIntIntTr) TTriple; +%template(TFltFltIntTr) TTriple; +%template(TFltFltStrTr) TTriple; +%template(TChATr) TTriple; +%template(TStrTr) TTriple; +%template(TStrIntIntTr) TTriple; +%template(TStrFltFltTr) TTriple; +%template(TStrStrIntTr) TTriple; +%template(TStrIntStrVTr) TTriple; +%template(TStrStrIntIntQu) TQuad; +%template(TStrQu) TQuad; +%template(TIntQu) TQuad; +%template(TFltQu) TQuad; +%template(TFltIntIntIntQu) TQuad; +%template(TIntStrIntIntQu) TQuad; +%template(TIntIntFltFltQu) TQuad; +%template(TIntKd) TKeyDat; +%template(TIntUInt64Kd) TKeyDat; +%template(TIntPrFltKd) TKeyDat; +%template(TIntFltPrKd) TKeyDat; +%template(TIntSFltKd) TKeyDat; +%template(TIntStrKd) TKeyDat; +%template(TUIntIntKd) TKeyDat; +%template(TUIntKd) TKeyDat; +%template(TUInt64IntKd) TKeyDat; +%template(TUInt64FltKd) TKeyDat; +%template(TUInt64StrKd) TKeyDat; +%template(TFltBoolKd) TKeyDat; +%template(TFltIntKd) TKeyDat; +%template(TFltUInt64Kd) TKeyDat; +%template(TFltIntPrKd) TKeyDat; +%template(TFltUIntKd) TKeyDat; +%template(TFltKd) TKeyDat; +%template(TFltStrKd) TKeyDat; +%template(TFltBoolKd) TKeyDat; +%template(TFltIntBoolPrKd) TKeyDat; +%template(TAscFltIntKd) TKeyDat; +%template(TStrBoolKd) TKeyDat; +%template(TStrIntKd) TKeyDat; +%template(TStrFltKd) TKeyDat; +%template(TStrAscFltKd) TKeyDat; +%template(TStrKd) TKeyDat; +%template(TBoolV) TVec; +%template(TChV) TVec; +%template(TUChV) TVec; +%template(TUIntV) TVec; +%template(TUInt64V) TVec; +%template(TSFltV) TVec; +%template(TAscFltV) TVec; +%template(TStrV) TVec; +%template(TChAV) TVec; +%template(TIntQuV) TVec; +%template(TFltTrV) TVec; +%template(TIntKdV) TVec; +%template(TUChIntPrV) TVec; +%template(TUChUInt64PrV) TVec; +%template(TIntUInt64PrV) TVec; +%template(TIntUInt64KdV) TVec; +%template(TIntFltPrV) TVec; +%template(TIntFltPrKdV) TVec; +%template(TFltIntPrV) TVec; +%template(TFltUInt64PrV) TVec; +%template(TFltStrPrV) TVec; +%template(TAscFltStrPrV) TVec; +%template(TIntStrPrV) TVec; +%template(TIntIntStrTrV) TVec; +%template(TIntIntFltTrV) TVec; +%template(TIntFltIntTrV) TVec; +%template(TIntStrIntTrV) TVec; +%template(TIntStrStrTrV) TVec; +%template(TIntKdV) TVec; +%template(TUIntIntKdV) TVec; +%template(TIntPrFltKdV) TVec; +%template(TIntStrKdV) TVec; +%template(TIntStrPrPrV) TVec; +%template(TIntStrVPrV) TVec; +%template(TIntIntVIntTrV) TVec; +%template(TIntIntIntVTrV) TVec; +%template(TUInt64IntPrV) TVec; +%template(TUInt64FltPrV) TVec; +%template(TUInt64StrPrV) TVec; +%template(TUInt64IntKdV) TVec; +%template(TUInt64FltKdV) TVec; +%template(TUInt64StrKdV) TVec; +%template(TFltBoolKdV) TVec; +%template(TFltIntKdV) TVec; +%template(TFltUInt64KdV) TVec; +%template(TFltIntPrKdV) TVec; +%template(TFltKdV) TVec; +%template(TFltStrKdV) TVec; +%template(TFltStrPrPrV) TVec; +%template(TFltIntIntTrV) TVec; +%template(TFltFltStrTrV) TVec; +%template(TAscFltIntPrV) TVec; +%template(TAscFltIntKdV) TVec; +%template(TStrPrV) TVec; +%template(TStrIntPrV) TVec; +%template(TStrFltPrV) TVec; +%template(TStrIntKdV) TVec; +%template(TStrFltKdV) TVec; +%template(TStrAscFltKdV) TVec; +%template(TStrTrV) TVec; +%template(TStrQuV) TVec; +%template(TStrFltFltTrV) TVec; +%template(TStrStrIntTrV) TVec; +%template(TStrKdV) TVec; +%template(TStrStrVPrV) TVec; +%template(TStrVIntPrV) TVec; +%template(TFltIntIntIntQuV) TVec; +%template(TIntStrIntIntQuV) TVec; +%template(TIntIntPrPrV) TVec; +%template(TIntVecPool) TVecPool; +%template(PIntVecPool) TPt; +%template(TFltVP) PVec; +%template(PFltV) TPt; +%template(TAscFltVP) PVec; +%template(PAscFltV) TPt; +%template(TStrVP) PVec; +%template(PStrV) TPt; +%template(TBoolVV) TVVec; +%template(TChVV) TVVec; +%template(TIntVV) TVVec; +%template(TSFltVV) TVVec; +%template(TFltVV) TVVec; +%template(TStrVV) TVVec; +%template(TIntPrVV) TVVec; +%template(TIntVVV) TVVVec; +%template(TFltVVV) TVVVec; +%template(TIntTree) TTree; +%template(TFltTree) TTree; +%template(TStrTree) TTree; +%template(TStrIntPrTree) TTree; +%template(TStrIntStrVTrTree) TTree; +%template(TIntS) TSStack; +%template(TBoolChS) TSStack; +%template(TIntQ) TQQueue; +%template(TFltQ) TQQueue; +%template(TStrQ) TQQueue; +%template(TIntPrQ) TQQueue; +%template(TIntStrPrQ) TQQueue; +%template(TFltVQ) TQQueue; +%template(TAscFltVQ) TQQueue; +//%template(TIntQV) TVec >; +//%template(TIntL) TLst; +//%template(TIntKdL) TLst; +//%template(TFltL) TLst; +//%template(TFltIntKdL) TLst; +//%template(TAscFltIntKdL) TLst; +//%template(TStrL) TLst; +#endif + +// hash.h + +// define hash types +%template(TIntH) THash; +%template(TIntIntH) THash; +%template(TIntFltH) THash; +%template(TIntStrH) THash; +%template(TIntPrFltH) THash; +%template(TStrIntH) THash; +%template(TStrIntSH) TStrHash >; + +// define keydat types +%template(TIntHI) THashKeyDatI ; +%template(TIntIntHI) THashKeyDatI ; +%template(TIntFltHI) THashKeyDatI ; +%template(TIntStrHI) THashKeyDatI ; +%template(TIntPrFltHI) THashKeyDatI ; +%template(TStrIntHI) THashKeyDatI ; +%template(TIntFltVH) THash; + +#if SNAP_ALL +// define hash types +//%template(TChChH) THash; +//%template(TChTrIntH) THash; +%template(TUInt64H) THash; +%template(TIntBoolH) THash; +%template(TIntUInt64H) THash; +//%template(TIntIntFltPrH) THash; +%template(TIntIntVH) THash; +%template(TIntIntHH) THash; +%template(TIntFltPrH) THash; +%template(TIntFltTrH) THash; +%template(TIntStrVH) THash; +%template(TIntIntPrH) THash; +%template(TIntIntPrVH) THash; +%template(TIntStrPrVH) THash; +%template(TUInt64StrVH) THash; +%template(TIntPrIntH) THash; +%template(TIntPrIntVH) THash; +%template(TIntPrIntPrVH) THash; +%template(TIntTrIntH) THash; +%template(TIntVIntH) THash; +%template(TUIntH) THash; +%template(TIntPrIntH) THash; +%template(TIntPrIntVH) THash; +%template(TIntTrFltH) THash; +%template(TIntPrStrH) THash; +%template(TIntPrStrVH) THash; +%template(TIntStrPrIntH) THash; +%template(TFltFltH) THash; +%template(TStrH) THash; +%template(TStrBoolH) THash; +%template(TStrIntH) THash; +%template(TStrIntPrH) THash; +%template(TStrIntVH) THash; +%template(TStrUInt64H) THash; +%template(TStrUInt64VH) THash; +%template(TStrIntPrVH) THash; +%template(TStrFltH) THash; +%template(TStrFltVH) THash; +%template(TStrStrH) THash; +%template(TStrStrPrH) THash; +%template(TStrStrVH) THash; +%template(TStrStrPrVH) THash; +%template(TStrStrKdVH) THash; +%template(TStrIntFltPrH) THash; +%template(TStrStrIntPrVH) THash; +%template(TStrStrIntKdVH) THash; +//%template(TDbStrIntH) THash; +//%template(TDbStrStrH) THash; +%template(TStrPrBoolH) THash; +%template(TStrPrIntH) THash; +%template(TStrPrFltH) THash; +%template(TStrPrStrH) THash; +%template(TStrPrStrVH) THash; +%template(TStrTrIntH) THash; +%template(TStrIntPrIntH) THash; +%template(TStrVH) THash; +//%template(TStrVIntH) THash; +%template(TStrVIntVH) THash; +%template(TStrVStrH) THash; +%template(TStrVStrVH) THash; +//%template(TStrSH) TStrHash; +//%template(TStrIntSH) TStrHash; +//%template(TStrToIntVSH) TStrHash; + +// define keydat types +//%template(TChChHI) THashKeyDatI ; +//%template(TChTrIntHI) THashKeyDatI ; +%template(TUInt64HI) THashKeyDatI ; +%template(TIntBoolHI) THashKeyDatI ; +%template(TIntHI) THashKeyDatI ; +%template(TIntUInt64HI) THashKeyDatI ; +//%template(TIntIntFltPrHI) THashKeyDatI ; +%template(TIntIntVHI) THashKeyDatI ; +%template(TIntIntHHI) THashKeyDatI ; +%template(TIntFltPrHI) THashKeyDatI ; +%template(TIntFltTrHI) THashKeyDatI ; +%template(TIntFltVHI) THashKeyDatI ; +%template(TIntStrVHI) THashKeyDatI ; +%template(TIntIntPrHI) THashKeyDatI ; +%template(TIntIntPrVHI) THashKeyDatI ; +%template(TIntStrPrVHI) THashKeyDatI ; +%template(TUInt64StrVHI) THashKeyDatI ; +%template(TIntPrIntHI) THashKeyDatI ; +%template(TIntPrIntVHI) THashKeyDatI ; +%template(TIntPrIntPrVHI) THashKeyDatI ; +%template(TIntTrIntHI) THashKeyDatI ; +%template(TIntVIntHI) THashKeyDatI ; +%template(TUIntHI) THashKeyDatI ; +%template(TIntPrIntHI) THashKeyDatI ; +%template(TIntPrIntVHI) THashKeyDatI ; +%template(TIntTrFltHI) THashKeyDatI ; +%template(TIntPrStrHI) THashKeyDatI ; +%template(TIntPrStrVHI) THashKeyDatI ; +%template(TIntStrPrIntHI) THashKeyDatI ; +%template(TFltFltHI) THashKeyDatI ; +%template(TStrHI) THashKeyDatI ; +%template(TStrBoolHI) THashKeyDatI ; +%template(TStrIntHI) THashKeyDatI ; +%template(TStrIntPrHI) THashKeyDatI ; +%template(TStrIntVHI) THashKeyDatI ; +%template(TStrUInt64HI) THashKeyDatI ; +%template(TStrUInt64VHI) THashKeyDatI ; +%template(TStrIntPrVHI) THashKeyDatI ; +%template(TStrFltHI) THashKeyDatI ; +%template(TStrFltVHI) THashKeyDatI ; +%template(TStrStrHI) THashKeyDatI ; +%template(TStrStrPrHI) THashKeyDatI ; +%template(TStrStrVHI) THashKeyDatI ; +%template(TStrStrPrVHI) THashKeyDatI ; +%template(TStrStrKdVHI) THashKeyDatI ; +%template(TStrIntFltPrHI) THashKeyDatI ; +%template(TStrStrIntPrVHI) THashKeyDatI ; +%template(TStrStrIntKdVHI) THashKeyDatI ; +//%template(TDbStrIntHI) THashKeyDatI ; +//%template(TDbStrStrHI) THashKeyDatI ; +%template(TStrPrBoolHI) THashKeyDatI ; +%template(TStrPrIntHI) THashKeyDatI ; +%template(TStrPrFltHI) THashKeyDatI ; +%template(TStrPrStrHI) THashKeyDatI ; +%template(TStrPrStrVHI) THashKeyDatI ; +%template(TStrTrIntHI) THashKeyDatI ; +%template(TStrIntPrIntHI) THashKeyDatI ; +%template(TStrVHI) THashKeyDatI ; +//%template(TStrVIntHI) THashKeyDatI ; +%template(TStrVIntVHI) THashKeyDatI ; +%template(TStrVStrHI) THashKeyDatI ; +%template(TStrVStrVHI) THashKeyDatI ; +//%template(TStrSHI) TStrHashKeyDatI ; +//%template(TStrIntSHI) TStrHashKeyDatI ; +#endif + +// dt.h + +%template(TStrV) TVec; + +// cncom.h + +%template(TCnComV) TVec; + +// tm.h + +//%template(TSecTmV) TVec; +//%template(TSecTmStrKd) TKeyDat; +//%template(TSecTmStrKdV) TVec; +//%template(TTmV) TVec; +////%template(TTmStrPr) TPair; +////%template(TStrTmPr) TPair; +//%template(TTmStrPrV) TVec; +//%template(TStrTmPrV) TVec; + +// table.h + +//%template(Schema) TVec >; +//typedef TStrIntPrV Schema; + +%template(TStrTAttrPr) TPair< TStr, TAttrType>; +%template(Schema) TVec< TPair< TStr, TAttrType> >; + +%template(TIntSet) THashSet; +%template(TIntHSI) THashSetKeyI ; + +//---------- + +// SWIG conversion C++ code + +%include "snapswig.h" +%include "goodgraph.cpp" +%include "printgraph.h" +%include "linkpred_swig.h" +%include "conv.h" + +%template(GetRndWalkRestart_PUNGraph) GetRndWalkRestart; +%template(GetRndWalkRestart_PNGraph) GetRndWalkRestart; +%template(GetRndWalkRestart_PNEANet) GetRndWalkRestart; + +/* Include other SWIG interface types here. */ + +/* Vector and hash interface */ +%include "tvec.i" +%include "thash.i" +%include "thashset.i" + +/* Graph and network interface */ +%include "pneanet.i" +%include "tmodenet.i" +%include "tcrossnet.i" +%include "pmmnet.i" +%include "pngraph.i" +%include "pungraph.i" +%include "pdirnet.i" +%include "pundirnet.i" + +#ifdef GCC_ATOMIC +%include "pngraphmp.i" +%include "pneanetmp.i" +#endif + +%include "pgraph.i" +#ifndef NONUMPY +%include "numpy_swig.i" +#endif + +/* table interface */ +%include "ptable.i" + +/* enhanced Python functionality */ +%include "pylayer.i" + +%template(PTable) TPt< TTable >; + +// note for operator renaming +// %rename(Add) Vector3::operator +; + diff --git a/snap-python/source/swig/snap/__init__.py b/snap-python/source/swig/snap/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4fcc2ccc85d0f2cac1443e61bccc0c567fc8cefa --- /dev/null +++ b/snap-python/source/swig/snap/__init__.py @@ -0,0 +1,24 @@ +import sys + +if sys.version_info[0] < 3: + # Python2.x + from snap import * +else: + # Python3.x + import importlib + import os + + import snap + + snappath = os.path.dirname(snap.__file__) + + # get the 'snap' module location as the first place to load from + sys.path.insert(0,snappath) + + # reload 'snap' to keep 'snap' object paths, not 'snap.snap' + importlib.reload(snap) + sys.path.pop(0) + + # set path for 'import snapx', add 'snap' path to the end + sys.path.append(snappath) + diff --git a/snap-python/source/swig/snap_types.h b/snap-python/source/swig/snap_types.h new file mode 100644 index 0000000000000000000000000000000000000000..d35c5ae62c5dd688300b2233a18963ea91b67888 --- /dev/null +++ b/snap-python/source/swig/snap_types.h @@ -0,0 +1,46 @@ +#include "Snap.h" + +void print_array(int *x, int length) { + for (int i = 0; i < length; i++) + printf("x[%d] = %d\n", i, x[i]); +} + +TFltV PyTFltV(double x[10]) { + + TFltV V; + for (int i = 0; i < 10; i++) { + V.Add(x[i]); + } + + return V; +} + +TIntV PyToTIntV (int *array, int length) { + + TIntV V; + for (int i = 0; i < length; i++) { + //printf("Adding array[%d] = %d\n", i, array[i]); + V.Add(array[i]); + } + + return V; +} + +int count(char *str, int len, char c) { + int sum = 0; + for (int i = 0; i < len; i++) { + if (str[i] == c) + sum++; + } + return sum; +} + +//void TIntVToPy (TIntV originalList, TIntV snapList, int& len) { +void TIntVToPy (TIntV originalList, TIntV *OutValue) { + + printf("BEFORE: Original TIntV list size to %d\n", originalList.Len()); + *OutValue = originalList; + printf("BEFORE: New TIntV list size = %d\n", OutValue->Len()); + +} + diff --git a/snap-python/source/swig/snap_types.i b/snap-python/source/swig/snap_types.i new file mode 100644 index 0000000000000000000000000000000000000000..4e1cd0fc3bcfa15a79e63ecfaccfa42ac6d7f9ca --- /dev/null +++ b/snap-python/source/swig/snap_types.i @@ -0,0 +1,369 @@ +// snap_types.i +// +// Provides type interface between Snap.py Python and SNAP C++ +// + +%include typemaps.i +%apply int &OUTPUT { int& RootNIdX}; +%apply int &OUTPUT { int& TreeSzX}; +%apply int &OUTPUT { int& TreeDepthX}; +%apply double &OUTPUT { double& EffDiamX}; +%apply double &OUTPUT { double& AvgSPLX}; +%apply int &OUTPUT { int& FullDiamX}; +%apply int &OUTPUT { int& EdgesInX}; +%apply int &OUTPUT { int& EdgesOutX}; +%apply int64 &OUTPUT { int64& ClosedTriadsX}; +%apply int64 &OUTPUT { int64& OpenTriadsX}; +%apply int &OUTPUT { int& ClosedNTriadsX}; +%apply int &OUTPUT { int& OpenNTriadsX}; +%apply int &OUTPUT { int& InGroupEdgesX}; +%apply int &OUTPUT { int& InOutGroupEdgesX}; +%apply int &OUTPUT { int& OutGroupEdgesX}; +%apply int &OUTPUT { int& ArndEdgesX}; +%apply int &OUTPUT { int& InEgoEdgesX}; +%apply int &OUTPUT { int& OutEgoEdgesX}; + +// +// TInt +// + +%typemap(in) TInt& { +//%typemap(in) TInt & NId { + //TInt I = PyInt_AsLong($input); + //$1 = &I; + $1 = new TInt(PyInt_AsLong($input)); +} + +%typemap(freearg) TInt& { + free($1); +} + +%typemap(in) const TInt& { +//%typemap(in) const TInt& value { + //TInt I = PyInt_AsLong($input); + //$1 = &I; + $1 = new TInt(PyInt_AsLong($input)); +} + +%typemap(freearg) const TInt& { + free($1); +} + +%typemap(in) TInt { + //TInt I = PyInt_AsLong($input); + //$1 = I; + $1 = TInt(PyInt_AsLong($input)); +} + +%typemap(in) TInt defaultValue { + //TInt I = PyInt_AsLong($input); + //$1 = I; + $1 = TInt(PyInt_AsLong($input)); +} + +%typemap(out) TInt { + $result = PyInt_FromLong((long) ($1.Val)); +} + +%typemap(out) TInt& { + $result = PyInt_FromLong((long) ($1->Val)); +} + + +%typecheck(SWIG_TYPECHECK_INTEGER) + int, short, long, + unsigned int, unsigned short, unsigned long, + signed char, unsigned char, + long long, unsigned long long, + const int &, const short &, const long &, + const unsigned int &, const unsigned short &, const unsigned long &, + const long long &, const unsigned long long &, + enum SWIGTYPE, + bool, const bool &, TInt, TInt&, const TInt, const TInt& +{ + $1 = (PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0; +} + +// +// TFlt +// + +// Translate Python floats to TFlt + +%typemap(in) TFlt& { + //TFlt F = PyFloat_AsDouble($input); + //$1 = &F; + $1 = new TFlt(PyFloat_AsDouble($input)); +} + +%typemap(freearg) TFlt& { + free($1); +} + +%typemap(in) const TFlt& { + //TFlt F = PyFloat_AsDouble($input); + //$1 = &F; + $1 = new TFlt(PyFloat_AsDouble($input)); +} + +%typemap(freearg) const TFlt& { + free($1); +} + +%typemap(in) TFlt { + //TFlt F = PyFloat_AsDouble($input); + //$1 = F; + $1 = TFlt(PyFloat_AsDouble($input)); +} + +%typemap(in) TFlt defaultValue { + TFlt F = PyFloat_AsDouble($input); + $1 = F; + //$1 = TFlt(PyFloat_AsDouble($input)); +} + +%typemap(out) TFlt { + $result = PyFloat_FromDouble((double) ($1.Val)); +} + +%typemap(out) TFlt& { + $result = PyFloat_FromDouble((double) ($1->Val)); +} + +%typecheck(SWIG_TYPECHECK_DOUBLE) + float, float &, const float, const float &, + double, double &, const double, const double &, + TFlt, TFlt &, const TFlt, const TFlt & +{ + $1 = (PyFloat_Check($input) || PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0; +} + +// +// TStr +// + +// Translate Python strings to SNAP TStr +//%typemap(in) const TStr& attr { +// TStr S(PyString_AsString($input)); +// $1 = &S; +//} + +//%typemap(in) TStr { + //TStr S(PyString_AsString($input)); + //$1 = &S; +// $1 = TStr(PyString_AsString($input)); +//} + +%typemap(in) TStr { + //TStr S(PyString_AsString($input)); + //$1 = &S; + if (PyString_Check($input)) { + $1 = TStr(PyString_AsString($input)); + } else { + $1 = TStr(PyBytes_AS_STRING( + PyUnicode_AsEncodedString($input, "utf-8", "Error ~"))); + } +} + +//%typemap(in) TStr& { + //TStr S(PyString_AsString($input)); + //$1 = &S; + //$1 = new TStr(PyString_AsString($input)); +//} + +%typemap(in) TStr& { + //TStr S(PyString_AsString($input)); + //$1 = &S; + if (PyString_Check($input)) { + $1 = new TStr(PyString_AsString($input)); + } else { + $1 = new TStr(PyBytes_AS_STRING( + PyUnicode_AsEncodedString($input, "utf-8", "Error ~"))); + } +} + +%typemap(freearg) TStr& { + free($1); +} + +//%typemap(in) const TStr& { + //TStr S(PyString_AsString($input)); + //$1 = &S; + //$1 = new TStr(PyString_AsString($input)); +//} + +%typemap(in) const TStr& { + //TStr S(PyString_AsString($input)); + //$1 = &S; + if (PyString_Check($input)) { + $1 = new TStr(PyString_AsString($input)); + } else { + $1 = new TStr(PyBytes_AS_STRING( + PyUnicode_AsEncodedString($input, "utf-8", "Error ~"))); + } +} + +%typemap(freearg) const TStr& { + free($1); +} + +//%typemap(in) TStr defaultValue { +// TStr S(PyString_AsString($input)); +// $1 = S; +// //$1 = TStr(PyString_AsString($input)); +//} + +%typemap(in) TStr defaultValue { + if (PyString_Check($input)) { + TStr S(PyString_AsString($input)); + $1 = S; + } else { + TStr S(PyBytes_AS_STRING( + PyUnicode_AsEncodedString($input, "utf-8", "Error ~"))); + $1 = S; + } + + //$1 = TStr(PyString_AsString($input)); +} + +%typemap(out) TStr { + $result = PyString_FromString($1.CStr()); +} + +%typemap(out) TStr& { + $result = PyString_FromString($1->CStr()); +} + +//%typecheck(SWIG_TYPECHECK_STRING) char *, const char *, TStr, TStr&, const TStr, const TStr& { +// $1 = PyString_Check($input) ? 1 : 0; +//} + +%typecheck(SWIG_TYPECHECK_STRING) char *, const char *, TStr, TStr&, const TStr, const TStr& { + $1 = (PyString_Check($input) || PyUnicode_Check($input)) ? 1 : 0; +} + + +//%typemap(in) (char *str, int len) { +// $1 = PyString_AsString($input); /* char *str */ +// $2 = PyString_Size($input); /* int len */ +//} + +%typemap(in) (char *str, int len) { + if (PyString_Check($input)) { + $1 = PyString_AsString($input); /* char *str */ + $2 = PyString_Size($input); /* int len */ + } else { + $1 = PyBytes_AS_STRING( + PyUnicode_AsEncodedString($input, "utf-8", "Error ~")); + $2 = PyString_Size( + PyUnicode_AsEncodedString($input, "utf-8", "Error ~")); + } +} + +// Create type for fixed-size Python lists of doubles. +%typemap(in) double [ANY] (double temp[$1_dim0]) { + int i; + if (!PySequence_Check($input)) { + PyErr_SetString(PyExc_ValueError,"Expected a sequence"); + return NULL; + } + if (PySequence_Length($input) != $1_dim0) { + PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements"); + return NULL; + } + for (i = 0; i < $1_dim0; i++) { + PyObject *o = PySequence_GetItem($input,i); + if (PyNumber_Check(o)) { + temp[i] = (double) PyFloat_AsDouble(o); + } else { + PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); + return NULL; + } + } + $1 = temp; +} + +// Create type for Python fixed-size lists of integers. +%typemap(in) int[ANY] (int temp[$1_dim0]) { + int i; + if (!PySequence_Check($input)) { + PyErr_SetString(PyExc_ValueError,"Expected a sequence"); + return NULL; + } + if (PySequence_Length($input) != $1_dim0) { + PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected $1_dim0 elements"); + return NULL; + } + for (i = 0; i < $1_dim0; i++) { + PyObject *o = PySequence_GetItem($input,i); + if (PyNumber_Check(o)) { + temp[i] = (int) PyInt_AsLong(o); + } else { + PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); + return NULL; + } + } + $1 = temp; +} + +// Slow but safe. Create type for Python variable-size lists of integers (must keep argument name or create typemap. +%typemap(in) (int *arraySlow, int lengthSlow) { + int i; + if (!PySequence_Check($input)) { + PyErr_SetString(PyExc_ValueError,"Expected a sequence"); + return NULL; + } + int lengthSlow = PySequence_Size($input); + int *temp = (int *) malloc(lengthSlow*sizeof(int)); + for (i = 0; i < lengthSlow; i++) { + PyObject *o = PySequence_GetItem($input,i); + if (PyNumber_Check(o)) { + temp[i] = (int) PyInt_AsLong(o); + } else { + PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); + return NULL; + } + } + $1 = temp; + $2 = lengthSlow; +} + +// Fast. Create type for Python variable-size lists of integers (must keep argument name or create typemap. +%typemap(in) (int *array, int length) { + int i; + PyObject* seq = PySequence_Fast($input, "expected a sequence"); + int length = PySequence_Size($input); + int *temp = (int *) malloc(length*sizeof(int)); + for (i = 0; i < length; i++) { + temp[i] = (int) PyInt_AsLong(PySequence_Fast_GET_ITEM(seq, i)); + } + Py_DECREF(seq); + $1 = temp; + $2 = length; +} +%typemap(freearg) (int *array, int length) { + if ($1) free($1); +} + +// Convert an TIntV to a Python list + +%module outarg + +%typemap(argout) TIntV *OutValue { + $result = PyList_New($1->Len()); + for (int i = 0; i < $1->Len(); ++i) { + PyList_SetItem($result, i, PyInt_FromLong((*$1)[i])); + } + delete $1; // Avoid a leak since you called new +} + +%typemap(in,numinputs=0) TIntV *OutValue(TIntV temp) { + $1 = &temp; +} + + +// Rename argument example. +%typemap(in) (char *buffer, int size) = (char *str, int len); + +%include "snap_types.h" + diff --git a/snap-python/source/swig/snappy-VS19.sln b/snap-python/source/swig/snappy-VS19.sln new file mode 100644 index 0000000000000000000000000000000000000000..97f833385ad4b9e458f9926dc3a4ee19c4c38e1d --- /dev/null +++ b/snap-python/source/swig/snappy-VS19.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Express 2012 for Windows Desktop +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Snappy", "snappy.vcxproj", "{4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Debug|Win32.ActiveCfg = Release|x64 + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Debug|Win32.Build.0 = Release|x64 + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Debug|x64.ActiveCfg = Debug|x64 + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Debug|x64.Build.0 = Debug|x64 + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Release|Win32.ActiveCfg = Release|Win32 + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Release|Win32.Build.0 = Release|Win32 + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Release|x64.ActiveCfg = Release|x64 + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/snap-python/source/swig/snappy.vcxproj b/snap-python/source/swig/snappy.vcxproj new file mode 100644 index 0000000000000000000000000000000000000000..c208c3f482af26c3161225c3eb99175f34a01f09 --- /dev/null +++ b/snap-python/source/swig/snappy.vcxproj @@ -0,0 +1,170 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {4C27E0F4-3E99-41CF-AF25-ABCCD7878E6C} + Win32Proj + SNAPPY + Snappy + + + + Application + true + v142 + Unicode + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + DynamicLibrary + false + v142 + true + MultiByte + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + $(SolutionDir) + _snap + .pyd + S:\snap-core;S:\glib-core;S:\snap-adv;$(IncludePath) + + + + NotUsing + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + Level3 + NotUsing + MaxSpeed + true + true + WIN32;NDEBUG;SW_SNAPPY;_WINDOWS;%(PreprocessorDefinitions) + true + P:\swig;S:\glib-core;S:\snap-core;C:\Python27\include;%(AdditionalIncludeDirectories) + /bigobj %(AdditionalOptions) + false + + + Windows + true + true + true + C:\Python27\libs;%(AdditionalLibraryDirectories) + python27.lib;%(AdditionalDependencies) + + + + + + + + + + + + + + + + WIN32;NDEBUG;SW_SNAPPY;_WINDOWS;%(PreprocessorDefinitions) + + + + + + \ No newline at end of file diff --git a/snap-python/source/swig/snappy3-VS19.sln b/snap-python/source/swig/snappy3-VS19.sln new file mode 100644 index 0000000000000000000000000000000000000000..e6f4941b614e43391ec85ebc781bdd03b3655d6e --- /dev/null +++ b/snap-python/source/swig/snappy3-VS19.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29215.179 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Snappy3", "snappy3.vcxproj", "{B531C6EC-A631-48F8-8036-A86C5C60FFBB}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Debug|Win32.ActiveCfg = Debug|Win32 + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Debug|Win32.Build.0 = Debug|Win32 + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Debug|x64.ActiveCfg = Debug|x64 + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Debug|x64.Build.0 = Debug|x64 + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Release|Win32.ActiveCfg = Release|Win32 + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Release|Win32.Build.0 = Release|Win32 + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Release|x64.ActiveCfg = Release|x64 + {B531C6EC-A631-48F8-8036-A86C5C60FFBB}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {051F2EC0-838E-4938-8594-01C0B3C80CB0} + EndGlobalSection +EndGlobal diff --git a/snap-python/source/swig/snappy3.vcxproj b/snap-python/source/swig/snappy3.vcxproj new file mode 100644 index 0000000000000000000000000000000000000000..0b8f9e23c9ac1f837bb9c3e41770fd49de07a982 --- /dev/null +++ b/snap-python/source/swig/snappy3.vcxproj @@ -0,0 +1,170 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {B531C6EC-A631-48F8-8036-A86C5C60FFBB} + Win32Proj + SNAPPY3 + Snappy3 + + + + Application + true + v142 + Unicode + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + DynamicLibrary + false + v142 + true + MultiByte + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + $(SolutionDir) + _snap + .pyd + S:\snap-core;S:\glib-core;S:\snap-adv;$(IncludePath) + + + + NotUsing + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Use + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + + + + + Level3 + NotUsing + MaxSpeed + true + true + WIN32;NDEBUG;SW_SNAPPY;_WINDOWS;%(PreprocessorDefinitions) + true + P:\swig;S:\glib-core;S:\snap-core;C:\Program Files\Python37\include;%(AdditionalIncludeDirectories) + /bigobj %(AdditionalOptions) + false + + + Windows + true + true + true + C:\Program Files\Python37\libs;%(AdditionalLibraryDirectories) + python37.lib;%(AdditionalDependencies) + + + + + + + + + + + + + + + + WIN32;NDEBUG;SW_SNAPPY;_WINDOWS;%(PreprocessorDefinitions) + + + + + + \ No newline at end of file diff --git a/snap-python/source/swig/snapsw.h b/snap-python/source/swig/snapsw.h new file mode 100644 index 0000000000000000000000000000000000000000..e7cf32120a6a0e81ffac44ed4024dbf34ede5c10 --- /dev/null +++ b/snap-python/source/swig/snapsw.h @@ -0,0 +1,222 @@ +#include + +namespace TSnap { + +typedef TVec TIntV; +typedef TVec TIntIntVV; +typedef THash > TIntIntVH; +//typedef THash TIntH; + +void SeedRandom() { + long int ITime; + long int IPid; + long int RSeed; + + ITime = (long int) time(NULL); + IPid = (long int) getpid(); + + RSeed = ITime * IPid; + srand48(RSeed); +} + +void Randomize(TIntV& Vec) { + int Pos; + int Last = Vec.Len() - 1; + for (int ValN = Last; ValN > 0; ValN--) { + Pos = (long) (drand48() * ValN); + Vec.Swap(ValN, Pos); + } +} + +int StdDist(double Mean, double Dev) { + int i; + double x; + + x = -6.0; + for (i = 0; i < 12; i++) { + x += drand48(); + } + + x *= Dev; + x += Mean; + + return int(x + 0.5); +} + +#if 0 +void GetDegrees(TIntV* Nodes, double Mean, double Dev) { + int i; + int d; + int Len; + printf("GetDegrees\n"); + printf("Nodes Len %d\n",Nodes->Len()); + + Len = Nodes->Len(); + for (i = 0; i < Len; i++) { + d = StdDist(Mean, Dev); + printf("degree1 %d %d\n", i, d); + (*Nodes)[i] = d; + } + + for (i = 0; i < Len; i++) { + printf("degree2 %d %d\n", i, Nodes->GetVal(i).Val); + } +} +#endif + +void GetDegrees(TIntV& Nodes, double Mean, double Dev) { + int i; + int d; + int Len; + printf("GetDegrees\n"); + printf("Nodes Len %d\n",Nodes.Len()); + + // assign degree to each node + Len = Nodes.Len(); + for (i = 0; i < Len; i++) { + d = StdDist(Mean, Dev); + printf("degree1 %d %d\n", i, d); + Nodes[i] = d; + } + + for (i = 0; i < Len; i++) { + printf("degree2 %d %d\n", i, Nodes[i].Val); + } +} + +void IncVal(TIntV& Nodes, int disp) { + int i; + int Len; + + // increment value for each element + Len = Nodes.Len(); + for (i = 0; i < Len; i++) { + Nodes[i] += disp; + } +} + +void AssignRndTask(const TIntV& Nodes, TIntIntVV& Tasks) { + int i; + int j; + int n; + int t; + int NumNodes; + int NumTasks; + printf("AssignRndTask\n"); + printf("Nodes Len %d\n",Nodes.Len()); + printf("Tasks Len %d\n",Tasks.Len()); + + NumNodes = Nodes.Len(); + NumTasks = Tasks.Len(); + + // distribute stubs randomly to tasks + for (i = 0; i < NumNodes; i++) { + n = Nodes[i].Val; + printf("degree3 %d %d\n", i, n); + for (j = 0; j < n; j++) { + t = (long) (drand48() * NumTasks); + Tasks[t].Add(i); + } + } +} + +void AssignEdges(const TIntV& Pairs, TIntIntVV& Tasks, int tsize) { + int i; + int NumStubs; + int NumTasks; + int TaskId; + int Node1; + int Node2; + + printf("AssignEdges\n"); + printf("Pairs Len %d\n",Pairs.Len()); + printf("Tasks Len %d\n",Tasks.Len()); + + NumStubs = Pairs.Len(); + NumTasks = Tasks.Len(); + + // distribute edges to tasks + for (i = 0; i < NumStubs-1; i += 2) { + + Node1 = Pairs.GetVal(i).Val; + Node2 = Pairs.GetVal(i+1).Val; + + // add an edge twice, once for each end node + TaskId = Node1 / tsize; + Tasks[TaskId].Add(Node1); + Tasks[TaskId].Add(Node2); + + TaskId = Node2 / tsize; + Tasks[TaskId].Add(Node2); + Tasks[TaskId].Add(Node1); + } +} + +void GetAdjLists(const TIntV& Edges, TIntIntVH& AdjLists) { + int i; + int NumStubs; + int Node1; + int Node2; + + printf("GetAdjLists\n"); + printf("Edges1 Len %d\n",Edges.Len()); + + NumStubs = Edges.Len(); + + // distribute node pairs to adjacency lists + for (i = 0; i < NumStubs-1; i += 2) { + Node1 = Edges.GetVal(i).Val; + Node2 = Edges.GetVal(i+1).Val; + + AdjLists.AddKey(Node1); + AdjLists(Node1).AddMerged(Node2); + } +} + +void GetNeighborhood(const TIntV& Nodes, const TIntIntVH& AdjLists, TIntV& Hood) { + int i; + int j; + int Node; + int NumNodes; + int NumNeighbors; + int Neighbor; + TIntH HashHood; + TIntV Neighbors; + + NumNodes = Nodes.Len(); + + // create a union of all neighbors + for (i = 0; i < NumNodes; i++) { + Node = Nodes.GetVal(i).Val; + Neighbors = AdjLists.GetDat(Node); + NumNeighbors = Neighbors.Len(); + for (j = 0; j < NumNeighbors; j++) { + Neighbor = Neighbors.GetVal(j).Val; + HashHood.AddDat(Neighbor,0); + } + } + + // change a hash table to a vector + HashHood.GetKeyV(Hood); +} + + +void Edge2Hash(const TIntV& Edges, TIntH& Hash) { + int i; + int Num; + int Key; + int Value; + + printf("Edges2 Len %d\n",Edges.Len()); + Num = Edges.Len(); + + for (i = 0; i < Num-1; i += 2) { + Key = Edges.GetVal(i).Val; + Value = Edges.GetVal(i+1).Val; + + Hash.AddDat(Key, Value); + } +} + +}; // namespace TSnap + diff --git a/snap-python/source/swig/snapswig.h b/snap-python/source/swig/snapswig.h new file mode 100644 index 0000000000000000000000000000000000000000..bced2a745dc771714613551f06c8b4aa8f94f9c0 --- /dev/null +++ b/snap-python/source/swig/snapswig.h @@ -0,0 +1,773 @@ +class TNGraphNodeI { +private: + TNGraph::TNodeI NI; +public: + TNGraphNodeI() : NI() { } + TNGraphNodeI(const TNGraph::TNodeI& NodeI) : NI(NodeI) { } + TNGraphNodeI& operator = (const TNGraph::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TNGraphNodeI& operator++ (int) { NI++; return *this; } + TNGraphNodeI& Next() { NI++; return *this; } + bool operator < (const TNGraphNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TNGraphNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns C++ node iterator. + TNGraph::TNodeI GetNI() const { return NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Sorts the adjacency lists of the current node. + void SortNIdV() { NI.SortNIdV(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TNGraph::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TNGraph::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TNGraph::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; + +class TDirNetNodeI { +private: + TDirNet::TNodeI NI; +public: + TDirNetNodeI() : NI() { } + TDirNetNodeI(const TDirNet::TNodeI& NodeI) : NI(NodeI) { } + TDirNetNodeI& operator = (const TDirNet::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TDirNetNodeI& operator++ (int) { NI++; return *this; } + TDirNetNodeI& Next() { NI++; return *this; } + bool operator < (const TDirNetNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TDirNetNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Sorts the adjacency lists of the current node. + void SortNIdV() { NI.SortNIdV(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TDirNet::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TDirNet::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TDirNet::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; + +#ifdef GCC_ATOMIC +class TNGraphMPNodeI { +private: + TNGraphMP::TNodeI NI; +public: + TNGraphMPNodeI() : NI() { } + TNGraphMPNodeI(const TNGraphMP::TNodeI& NodeI) : NI(NodeI) { } + TNGraphMPNodeI& operator = (const TNGraphMP::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TNGraphMPNodeI& operator++ (int) { NI++; return *this; } + TNGraphMPNodeI& Next() { NI++; return *this; } + bool operator < (const TNGraphMPNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TNGraphMPNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Sorts the adjacency lists of the current node. + void SortNIdV() { NI.SortNIdV(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TNGraphMP::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TNGraphMP::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TNGraphMP::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; +#endif // GCC_ATOMIC + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TNGraphEdgeI { +private: + TNGraph::TEdgeI EI; +public: + TNGraphEdgeI() : EI() { } + TNGraphEdgeI(const TNGraph::TEdgeI& EdgeI) : EI(EdgeI) { } + TNGraphEdgeI& operator = (const TNGraph::TEdgeI& EdgeI) { EI = EdgeI; return *this; } + /// Increment iterator. + TNGraphEdgeI& operator++ (int) { EI++; return *this; } + TNGraphEdgeI& Next() { EI++; return *this; } + bool operator < (const TNGraphEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TNGraphEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Returns C++ edge iterator. + TNGraph::TEdgeI GetEI() const { return EI; } + /// Gets edge ID. Always returns -1, since edges do not have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Returns the ID of the source node of the edge. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Returns the ID of the destination node of the edge. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TDirNetEdgeI { +private: + TDirNet::TEdgeI EI; +public: + TDirNetEdgeI() : EI() { } + TDirNetEdgeI(const TDirNet::TEdgeI& EdgeI) : EI(EdgeI) { } + TDirNetEdgeI& operator = (const TDirNet::TEdgeI& EdgeI) { EI = EdgeI; return *this; } + /// Increment iterator. + TDirNetEdgeI& operator++ (int) { EI++; return *this; } + TDirNetEdgeI& Next() { EI++; return *this; } + bool operator < (const TDirNetEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TDirNetEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1, since edges do not have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +#ifdef GCC_ATOMIC +/// Edge iterator. Only forward iteration (operator++) is supported. +class TNGraphMPEdgeI { +private: + TNGraphMP::TEdgeI EI; +public: + TNGraphMPEdgeI() : EI() { } + TNGraphMPEdgeI(const TNGraphMP::TEdgeI& EdgeI) : EI(EdgeI) { } + TNGraphMPEdgeI& operator = (const TNGraphMP::TEdgeI& EdgeI) { EI = EdgeI; return *this; } + /// Increment iterator. + TNGraphMPEdgeI& operator++ (int) { EI++; return *this; } + TNGraphMPEdgeI& Next() { EI++; return *this; } + bool operator < (const TNGraphMPEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TNGraphMPEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1, since edges do not have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. + int GetDstNId() const { return EI.GetDstNId(); } +}; +#endif // GCC_ATOMIC + +class TUNGraphNodeI { +private: + TUNGraph::TNodeI NI; +public: + TUNGraphNodeI() : NI() { } + TUNGraphNodeI(const TUNGraph::TNodeI& NodeI) : NI(NodeI) { } + TUNGraphNodeI& operator = (const TUNGraph::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TUNGraphNodeI& operator++ (int) { NI++; return *this; } + TUNGraphNodeI& Next() { NI++; return *this; } + bool operator < (const TUNGraphNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TUNGraphNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns C++ node iterator. + TUNGraph::TNodeI GetNI() const { return NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Sorts the adjacency lists of the current node. + void SortNIdV() { NI.SortNIdV(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TUNGraph::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TUNGraph::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TUNGraph::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; + +class TUndirNetNodeI { +private: + TUndirNet::TNodeI NI; +public: + TUndirNetNodeI() : NI() { } + TUndirNetNodeI(const TUndirNet::TNodeI& NodeI) : NI(NodeI) { } + TUndirNetNodeI& operator = (const TUndirNet::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TUndirNetNodeI& operator++ (int) { NI++; return *this; } + TUndirNetNodeI& Next() { NI++; return *this; } + bool operator < (const TUndirNetNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TUndirNetNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Sorts the adjacency lists of the current node. + void SortNIdV() { NI.SortNIdV(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TUndirNet::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TUndirNet::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TUndirNet::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TUNGraphEdgeI { +private: + TUNGraph::TEdgeI EI; +public: + TUNGraphEdgeI() : EI() { } + TUNGraphEdgeI(const TUNGraph::TEdgeI& EdgeI) : EI(EdgeI) { } + TUNGraphEdgeI& operator = (const TUNGraph::TEdgeI& EdgeI) { EI = EdgeI; return *this; } + /// Increment iterator. + TUNGraphEdgeI& operator++ (int) { EI++; return *this; } + TUNGraphEdgeI& Next() { EI++; return *this; } + bool operator < (const TUNGraphEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TUNGraphEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Returns C++ edge iterator. + TUNGraph::TEdgeI GetEI() const { return EI; } + /// Gets edge ID. Always returns -1, since edges do not have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +class TUndirNetEdgeI { +private: + TUndirNet::TEdgeI EI; +public: + TUndirNetEdgeI() : EI() { } + TUndirNetEdgeI(const TUndirNet::TEdgeI& EdgeI) : EI(EdgeI) { } + TUndirNetEdgeI& operator = (const TUndirNet::TEdgeI& EdgeI) { EI = EdgeI; return *this; } + /// Increment iterator. + TUndirNetEdgeI& operator++ (int) { EI++; return *this; } + TUndirNetEdgeI& Next() { EI++; return *this; } + bool operator < (const TUndirNetEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TUndirNetEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +class TNEANetNodeI { +private: + TNEANet::TNodeI NI; +public: + TNEANetNodeI() : NI() { } + TNEANetNodeI(const TNEANet::TNodeI& NodeI) : NI(NodeI) { } + TNEANetNodeI& operator = (const TNEANet::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TNEANetNodeI& operator++ (int) { NI++; return *this; } + TNEANetNodeI& Next() { NI++; return *this; } + bool operator < (const TNEANetNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TNEANetNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns C++ node iterator. + TNEANet::TNodeI GetNI() const { return NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TNEANet::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TNEANet::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TNEANet::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } + + /// Returns ID of EdgeN-th in-edge. + int GetInEId(const int& EdgeN) const { return NI.GetInEId(EdgeN); } + /// Returns ID of EdgeN-th out-edge. + int GetOutEId(const int& EdgeN) const { return NI.GetOutEId(EdgeN); } + /// Returns ID of EdgeN-th in or out-edge. + int GetNbrEId(const int& EdgeN) const { return NI.GetNbrEId(EdgeN); } + /// Tests whether the edge with ID EId is an in-edge of current node. + bool IsInEId(const int& EId) const { return NI.IsInEId(EId); } + /// Tests whether the edge with ID EId is an out-edge of current node. + bool IsOutEId(const int& EId) const { return NI.IsOutEId(EId); } + /// Tests whether the edge with ID EId is an in or out-edge of current node. + bool IsNbrEId(const int& EId) const { return NI.IsInEId(EId) || NI.IsOutEId(EId); } + /// Gets vector of attribute names. + void GetAttrNames(TStrV& Names) const { NI.GetAttrNames(Names); } + /// Gets vector of attribute values. + void GetAttrVal(TStrV& Val) const { NI.GetAttrVal(Val); } + /// Gets vector of int attribute names. + void GetIntAttrNames(TStrV& Names) const { NI.GetIntAttrNames(Names); } + /// Gets vector of int attribute values. + void GetIntAttrVal(TIntV& Val) const { NI.GetIntAttrVal(Val); } + /// Gets vector of int attribute names. + void GetIntVAttrNames(TStrV& Names) const { NI.GetIntVAttrNames(Names); } + /// Gets vector of int attribute values. + void GetIntVAttrVal(TVec& Val) const { NI.GetIntVAttrVal(Val); } + /// Gets vector of str attribute names. + void GetStrAttrNames(TStrV& Names) const { NI.GetStrAttrNames(Names); } + /// Gets vector of str attribute values. + void GetStrAttrVal(TStrV& Val) const { NI.GetStrAttrVal(Val); } + /// Gets vector of flt attribute names. + void GetFltAttrNames(TStrV& Names) const { NI.GetFltAttrNames(Names); } + /// Gets vector of flt attribute values. + void GetFltAttrVal(TFltV& Val) const { NI.GetFltAttrVal(Val); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TNEANetEdgeI { +private: + TNEANet::TEdgeI EI; +public: + TNEANetEdgeI() : EI() { } + TNEANetEdgeI(const TNEANet::TEdgeI& EdgeI) : EI(EdgeI) { } + TNEANetEdgeI& operator = (const TNEANet::TEdgeI& EdgeI) + { EI = EdgeI; return *this; } + /// Increment iterator. + TNEANetEdgeI& operator++ (int) { EI++; return *this; } + TNEANetEdgeI& Next() { EI++; return *this; } + bool operator < (const TNEANetEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TNEANetEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Returns C++ edge iterator. + TNEANet::TEdgeI GetEI() const { return EI; } + /// Returns edge ID. Only multigraphs have explicit edge IDs. + int GetId() const { return EI.GetId(); } + /// Returns the ID of the source node of the edge. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Returns the ID of the destination node of the edge. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +typedef TIntV::TIter TIntVecIter; + +/// Node/edge integer attribute iterator. Iterates through all nodes/edges for one integer attribute. +class TNEANetAIntI { +private: + TNEANet::TAIntI IntAI; +public: + TNEANetAIntI() : IntAI() { } + TNEANetAIntI(const TIntVecIter& HIter, TStr attribute, bool isEdgeIter, + const TNEANet* GraphPt) : + IntAI(HIter, attribute, isEdgeIter, GraphPt) { } + TNEANetAIntI(const TNEANet::TAIntI& I) : IntAI(I) { } + TNEANetAIntI& operator = (const TNEANetAIntI& I) + { IntAI = I.IntAI; return *this; } + TNEANetAIntI& Next() { IntAI++; return *this; } + bool operator < (const TNEANetAIntI& I) const { return IntAI < I.IntAI; } + bool operator == (const TNEANetAIntI& I) const { return IntAI == I.IntAI; } + /// Returns an attribute of the node. + int GetDat() const { return IntAI.GetDat().Val; } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return IntAI.IsDeleted(); }; + TNEANetAIntI& operator++(int) { IntAI++; return *this; } +// friend class TNEANet; +}; + +typedef TStrV::TIter TStrVecIter; + +/// Node/edge string attribute iterator. Iterates through all nodes/edges for one string attribute. +class TNEANetAStrI { +private: + TNEANet::TAStrI StrAI; +public: + TNEANetAStrI() : StrAI() { } + TNEANetAStrI(const TStrVecIter& HIter, TStr attribute, bool isEdgeIter, + const TNEANet* GraphPt) : + StrAI(HIter, attribute, isEdgeIter, GraphPt) { } + TNEANetAStrI(const TNEANet::TAStrI& I) : StrAI(I) { } + TNEANetAStrI& operator = (const TNEANetAStrI& I) + { StrAI = I.StrAI; return *this; } + TNEANetAStrI& Next() { StrAI++; return *this; } + bool operator < (const TNEANetAStrI& I) const { return StrAI < I.StrAI; } + bool operator == (const TNEANetAStrI& I) const { return StrAI == I.StrAI; } + /// Returns an attribute of the node. + const char * GetDat() const { return StrAI.GetDat().CStr(); } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return StrAI.IsDeleted(); }; + TNEANetAStrI& operator++(int) { StrAI++; return *this; } + // friend class TNEANet; +}; + + +typedef TFltV::TIter TFltVecIter; + +/// Node/edge float attribute iterator. Iterates through all nodes/edges for one float attribute. +class TNEANetAFltI { +private: + TNEANet::TAFltI FltAI; +public: + TNEANetAFltI() : FltAI() { } + TNEANetAFltI(const TFltVecIter& HIter, TStr attribute, bool isEdgeIter, + const TNEANet* GraphPt) : + FltAI(HIter, attribute, isEdgeIter, GraphPt) { } + TNEANetAFltI(const TNEANet::TAFltI& I) : FltAI(I) { } + TNEANetAFltI& operator = (const TNEANetAFltI& I) + { FltAI = I.FltAI; return *this; } + TNEANetAFltI& Next() { FltAI++; return *this; } + bool operator < (const TNEANetAFltI& I) const { return FltAI < I.FltAI; } + bool operator == (const TNEANetAFltI& I) const { return FltAI == I.FltAI; } + /// Returns an attribute of the node. + double GetDat() const { return FltAI.GetDat().Val; } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return FltAI.IsDeleted(); }; + TNEANetAFltI& operator++(int) { FltAI++; return *this; } + // friend class TNEANet; +}; + + +#ifdef GCC_ATOMIC +class TNEANetMPNodeI { +private: + TNEANetMP::TNodeI NI; +public: + TNEANetMPNodeI() : NI() { } + TNEANetMPNodeI(const TNEANetMP::TNodeI& NodeI) : NI(NodeI) { } + TNEANetMPNodeI& operator = (const TNEANetMP::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TNEANetMPNodeI& operator++ (int) { NI++; return *this; } + TNEANetMPNodeI& Next() { NI++; return *this; } + bool operator < (const TNEANetMPNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TNEANetMPNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TNEANetMP::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TNEANetMP::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TNEANetMP::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } + /// Returns ID of EdgeN-th in-edge. + int GetInEId(const int& EdgeN) const { return NI.GetInEId(EdgeN); } + /// Returns ID of EdgeN-th out-edge. + int GetOutEId(const int& EdgeN) const { return NI.GetOutEId(EdgeN); } + /// Returns ID of EdgeN-th in or out-edge. + int GetNbrEId(const int& EdgeN) const { return NI.GetNbrEId(EdgeN); } + /// Tests whether the edge with ID EId is an in-edge of current node. + bool IsInEId(const int& EId) const { return NI.IsInEId(EId); } + /// Tests whether the edge with ID EId is an out-edge of current node. + bool IsOutEId(const int& EId) const { return NI.IsOutEId(EId); } + /// Tests whether the edge with ID EId is an in or out-edge of current node. + bool IsNbrEId(const int& EId) const { return NI.IsInEId(EId) || NI.IsOutEId(EId); } + /// Gets vector of attribute names. + void GetAttrNames(TStrV& Names) const { NI.GetAttrNames(Names); } + /// Gets vector of attribute values. + void GetAttrVal(TStrV& Val) const { NI.GetAttrVal(Val); } + /// Gets vector of int attribute names. + void GetIntAttrNames(TStrV& Names) const { NI.GetIntAttrNames(Names); } + /// Gets vector of int attribute values. + void GetIntAttrVal(TIntV& Val) const { NI.GetIntAttrVal(Val); } + /// Gets vector of str attribute names. + void GetStrAttrNames(TStrV& Names) const { NI.GetStrAttrNames(Names); } + /// Gets vector of str attribute values. + void GetStrAttrVal(TStrV& Val) const { NI.GetStrAttrVal(Val); } + /// Gets vector of flt attribute names. + void GetFltAttrNames(TStrV& Names) const { NI.GetFltAttrNames(Names); } + /// Gets vector of flt attribute values. + void GetFltAttrVal(TFltV& Val) const { NI.GetFltAttrVal(Val); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TNEANetMPEdgeI { +private: + TNEANetMP::TEdgeI EI; +public: + TNEANetMPEdgeI() : EI() { } + TNEANetMPEdgeI(const TNEANetMP::TEdgeI& EdgeI) : EI(EdgeI) { } + TNEANetMPEdgeI& operator = (const TNEANetMP::TEdgeI& EdgeI) + { EI = EdgeI; return *this; } + /// Increment iterator. + TNEANetMPEdgeI& operator++ (int) { EI++; return *this; } + TNEANetMPEdgeI& Next() { EI++; return *this; } + bool operator < (const TNEANetMPEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TNEANetMPEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; +#endif // GCC_ATOMIC + + +class TModeNetNodeI { +private: + TModeNet::TNodeI NI; +public: + TModeNetNodeI() : NI() { } + TModeNetNodeI(const TModeNet::TNodeI& NodeI) : NI(NodeI) { } + TModeNetNodeI& operator = (const TModeNet::TNodeI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TModeNetNodeI& operator++ (int) { NI++; return *this; } + TModeNetNodeI& Next() { NI++; return *this; } + bool operator < (const TModeNetNodeI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TModeNetNodeI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetId() const { return NI.GetId(); } + /// Returns degree of the current node, the sum of in-degree and out-degree. + int GetDeg() const { return NI.GetDeg(); } + /// Returns in-degree of the current node. + int GetInDeg() const { return NI.GetInDeg(); } + /// Returns out-degree of the current node. + int GetOutDeg() const { return NI.GetOutDeg(); } + /// Returns ID of NodeN-th in-node (the node pointing to the current node). ##TNEANet::TNodeI::GetInNId + int GetInNId(const int& NodeN) const { return NI.GetInNId(NodeN); } + /// Returns ID of NodeN-th out-node (the node the current node points to). ##TNEANet::TNodeI::GetOutNId + int GetOutNId(const int& NodeN) const { return NI.GetOutNId(NodeN); } + /// Returns ID of NodeN-th neighboring node. ##TNEANet::TNodeI::GetNbrNId + int GetNbrNId(const int& NodeN) const { return NI.GetNbrNId(NodeN); } + /// Tests whether node with ID NId points to the current node. + bool IsInNId(const int& NId) const { return NI.IsInNId(NId); } + /// Tests whether the current node points to node with ID NId. + bool IsOutNId(const int& NId) const { return NI.IsOutNId(NId); } + /// Tests whether node with ID NId is a neighbor of the current node. + bool IsNbrNId(const int& NId) const { return NI.IsOutNId(NId) || NI.IsInNId(NId); } + /// Returns ID of EdgeN-th in-edge. + int GetInEId(const int& EdgeN) const { return NI.GetInEId(EdgeN); } + /// Returns ID of EdgeN-th out-edge. + int GetOutEId(const int& EdgeN) const { return NI.GetOutEId(EdgeN); } + /// Returns ID of EdgeN-th in or out-edge. + int GetNbrEId(const int& EdgeN) const { return NI.GetNbrEId(EdgeN); } + /// Tests whether the edge with ID EId is an in-edge of current node. + bool IsInEId(const int& EId) const { return NI.IsInEId(EId); } + /// Tests whether the edge with ID EId is an out-edge of current node. + bool IsOutEId(const int& EId) const { return NI.IsOutEId(EId); } + /// Tests whether the edge with ID EId is an in or out-edge of current node. + bool IsNbrEId(const int& EId) const { return NI.IsInEId(EId) || NI.IsOutEId(EId); } + /// Gets vector of attribute names. + void GetAttrNames(TStrV& Names) const { NI.GetAttrNames(Names); } + /// Gets vector of attribute values. + void GetAttrVal(TStrV& Val) const { NI.GetAttrVal(Val); } + /// Gets vector of int attribute names. + void GetIntAttrNames(TStrV& Names) const { NI.GetIntAttrNames(Names); } + /// Gets vector of int attribute values. + void GetIntAttrVal(TIntV& Val) const { NI.GetIntAttrVal(Val); } + /// Gets vector of int attribute names. + void GetIntVAttrNames(TStrV& Names) const { NI.GetIntVAttrNames(Names); } + /// Gets vector of int attribute values. + void GetIntVAttrVal(TVec& Val) const { NI.GetIntVAttrVal(Val); } + /// Gets vector of str attribute names. + void GetStrAttrNames(TStrV& Names) const { NI.GetStrAttrNames(Names); } + /// Gets vector of str attribute values. + void GetStrAttrVal(TStrV& Val) const { NI.GetStrAttrVal(Val); } + /// Gets vector of flt attribute names. + void GetFltAttrNames(TStrV& Names) const { NI.GetFltAttrNames(Names); } + /// Gets vector of flt attribute values. + void GetFltAttrVal(TFltV& Val) const { NI.GetFltAttrVal(Val); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TModeNetEdgeI { +private: + TNEANet::TEdgeI EI; +public: + TModeNetEdgeI() : EI() { } + TModeNetEdgeI(const TNEANet::TEdgeI& EdgeI) : EI(EdgeI) { } + TModeNetEdgeI& operator = (const TNEANet::TEdgeI& EdgeI) + { EI = EdgeI; return *this; } + /// Increment iterator. + TModeNetEdgeI& operator++ (int) { EI++; return *this; } + TModeNetEdgeI& Next() { EI++; return *this; } + bool operator < (const TModeNetEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TModeNetEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TCrossNetEdgeI { +private: + TCrossNet::TCrossEdgeI EI; +public: + TCrossNetEdgeI() : EI() { } + TCrossNetEdgeI(const TCrossNet::TCrossEdgeI& EdgeI) : EI(EdgeI) { } + TCrossNetEdgeI& operator = (const TCrossNet::TCrossEdgeI& EdgeI) + { EI = EdgeI; return *this; } + /// Increment iterator. + TCrossNetEdgeI& operator++ (int) { EI++; return *this; } + TCrossNetEdgeI& Next() { EI++; return *this; } + bool operator < (const TCrossNetEdgeI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TCrossNetEdgeI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetId() const { return EI.GetId(); } + /// Gets the source of an edge. Since the graph is undirected this is the node with smaller ID of the edge endpoints. + int GetSrcNId() const { return EI.GetSrcNId(); } + /// Gets destination of an edge. Since the graph is undirected this is the node with greater ID of the edge endpoints. + int GetDstNId() const { return EI.GetDstNId(); } +}; + +/// Node/Edge Attr iterator. Iterate through all node for one attr value. +class TCrossNetAIntI { +private: + TCrossNet::TAIntI IntAI; +public: + TCrossNetAIntI() : IntAI() { } + TCrossNetAIntI(const TIntVecIter& HIter, TStr attribute, + const TCrossNet* GraphPt) : + IntAI(HIter, attribute, GraphPt) { } + TCrossNetAIntI(const TCrossNet::TAIntI& I) : IntAI(I) { } + TCrossNetAIntI& operator = (const TCrossNetAIntI& I) + { IntAI = I.IntAI; return *this; } + TCrossNetAIntI& Next() { IntAI++; return *this; } + bool operator < (const TCrossNetAIntI& I) const { return IntAI < I.IntAI; } + bool operator == (const TCrossNetAIntI& I) const { return IntAI == I.IntAI; } + /// Returns an attribute of the node. + int GetDat() const { return IntAI.GetDat().Val; } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return IntAI.IsDeleted(); }; + TCrossNetAIntI& operator++(int) { IntAI++; return *this; } +// friend class TCrossNet; +}; + +/// Node/Edge Attr iterator. Iterate through all node for one attr value. +class TCrossNetAStrI { +private: + TCrossNet::TAStrI StrAI; +public: + TCrossNetAStrI() : StrAI() { } + TCrossNetAStrI(const TStrVecIter& HIter, TStr attribute, + const TCrossNet* GraphPt) : + StrAI(HIter, attribute, GraphPt) { } + TCrossNetAStrI(const TCrossNet::TAStrI& I) : StrAI(I) { } + TCrossNetAStrI& operator = (const TCrossNetAStrI& I) + { StrAI = I.StrAI; return *this; } + TCrossNetAStrI& Next() { StrAI++; return *this; } + bool operator < (const TCrossNetAStrI& I) const { return StrAI < I.StrAI; } + bool operator == (const TCrossNetAStrI& I) const { return StrAI == I.StrAI; } + /// Returns an attribute of the node. + const char * GetDat() const { return StrAI.GetDat().CStr(); } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return StrAI.IsDeleted(); }; + TCrossNetAStrI& operator++(int) { StrAI++; return *this; } + // friend class TCrossNet; +}; + + +/// Node/Edge Attr iterator. Iterate through all node for one attr value. +class TCrossNetAFltI { +private: + TCrossNet::TAFltI FltAI; +public: + TCrossNetAFltI() : FltAI() { } + TCrossNetAFltI(const TFltVecIter& HIter, TStr attribute, + const TCrossNet* GraphPt) : + FltAI(HIter, attribute, GraphPt) { } + TCrossNetAFltI(const TCrossNet::TAFltI& I) : FltAI(I) { } + TCrossNetAFltI& operator = (const TCrossNetAFltI& I) + { FltAI = I.FltAI; return *this; } + TCrossNetAFltI& Next() { FltAI++; return *this; } + bool operator < (const TCrossNetAFltI& I) const { return FltAI < I.FltAI; } + bool operator == (const TCrossNetAFltI& I) const { return FltAI == I.FltAI; } + /// Returns an attribute of the node. + double GetDat() const { return FltAI.GetDat().Val; } + /// Returns true if node or edge has been deleted. + bool IsDeleted() const { return FltAI.IsDeleted(); }; + TCrossNetAFltI& operator++(int) { FltAI++; return *this; } + // friend class TCrossNet; +}; + + +class TMMNetModeNetI { +private: + TMMNet::TModeNetI NI; +public: + TMMNetModeNetI() : NI() { } + TMMNetModeNetI(const TMMNet::TModeNetI& NodeI) : NI(NodeI) { } + TMMNetModeNetI& operator = (const TMMNet::TModeNetI& NodeI) { NI = NodeI; return *this; } + /// Increment iterator. + TMMNetModeNetI& operator++ (int) { NI++; return *this; } + TMMNetModeNetI& Next() { NI++; return *this; } + + bool operator < (const TMMNetModeNetI& NodeI) const { return NI < NodeI.NI; } + bool operator == (const TMMNetModeNetI& NodeI) const { return NI == NodeI.NI; } + /// Returns ID of the current node. + int GetModeId() { return NI.GetModeId(); } + TModeNet& GetModeNet() { return NI.GetModeNet(); } +}; + + + +/// Edge iterator. Only forward iteration (operator++) is supported. +class TMMNetCrossNetI { +private: + TMMNet::TCrossNetI EI; +public: + TMMNetCrossNetI() : EI() { } + TMMNetCrossNetI(const TMMNet::TCrossNetI& EdgeI) : EI(EdgeI) { } + TMMNetCrossNetI& operator = (const TMMNet::TCrossNetI& EdgeI) + { EI = EdgeI; return *this; } + /// Increment iterator. + TMMNetCrossNetI& operator++ (int) { EI++; return *this; } + TMMNetCrossNetI& Next() { EI++; return *this; } + bool operator < (const TMMNetCrossNetI& EdgeI) const { return EI < EdgeI.EI; } + bool operator == (const TMMNetCrossNetI& EdgeI) const { return EI == EdgeI.EI; } + /// Gets edge ID. Always returns -1 since only edges in multigraphs have explicit IDs. + int GetCrossId() { return EI.GetCrossId(); } + TCrossNet& GetCrossNet() { return EI.GetCrossNet(); } + +}; diff --git a/snap-python/source/swig/tcrossnet.i b/snap-python/source/swig/tcrossnet.i new file mode 100644 index 0000000000000000000000000000000000000000..a2a14ec17b4377245db7c9f53e41683020a7257e --- /dev/null +++ b/snap-python/source/swig/tcrossnet.i @@ -0,0 +1,34 @@ +// tcrossnet.i +// Templates for SNAP TCrossNet, PNEANet +// + +%extend TCrossNet { + TCrossNetEdgeI BegEI() { + return TCrossNetEdgeI($self->BegEdgeI()); + } + TCrossNetEdgeI EndEI() { + return TCrossNetEdgeI($self->EndEdgeI()); + } + + TCrossNetAIntI BegEAIntI(const TStr& attr) { + return TCrossNetAIntI($self->BegEAIntI(attr)); + } + TCrossNetAIntI EndEAIntI(const TStr& attr) { + return TCrossNetAIntI($self->EndEAIntI(attr)); + } + + TCrossNetAStrI BegEAStrI(const TStr& attr) { + return TCrossNetAStrI($self->BegEAStrI(attr)); + } + TCrossNetAStrI EndEAStrI(const TStr& attr) { + return TCrossNetAStrI($self->EndEAStrI(attr)); + } + + TCrossNetAFltI BegEAFltI(const TStr& attr) { + return TCrossNetAFltI($self->BegEAFltI(attr)); + } + TCrossNetAFltI EndEAFltI(const TStr& attr) { + return TCrossNetAFltI($self->EndEAFltI(attr)); + } + +}; diff --git a/snap-python/source/swig/thash.i b/snap-python/source/swig/thash.i new file mode 100644 index 0000000000000000000000000000000000000000..9e43479981ee10de00f00df155c98e3b93537ea7 --- /dev/null +++ b/snap-python/source/swig/thash.i @@ -0,0 +1,914 @@ +%pythoncode %{ + +# +# define __getitem__ for [] addressing +# +def getitem_hash(self, i): + return self.GetDat(i) + +def setitem_hash(self, key, value): + self.AddDat(key, value) + +def delitem_hash(self, key): + self.DelKey(key) + +def len_hash(self): + return self.Len() + +def clear_hash(self): + self.Clr() + +def copy_hash(self): + return self + +def get_hash(self, key): + if not key in self: + return None + else: + return self[key] + +def items_hash(self): + ret_list = [] + for key in self: + ret_list.append((key, self[key])) + return ret_list + +def keys_hash(self): + ret_list = [] + for key in self: + ret_list.append(key) + return ret_list + +def pop_hash(self, key): + ret_value = self[key] + self.DelKey(key) + return ret_value + +def setdefault_hash(self, key, default): + if key not in self: + self[key] = default + return default + else: + return self[key] + +def update_hash(self, hash): + for key in hash: + self[key] = hash[key] + +def values_hash(self): + ret_list = [] + for key in self: + ret_list.append(self[key]) + return ret_list + +def copy_hash(self): + return self + + +# +# define iterator for THash +# + +class IterHash: + def __init__(self, hash): + self.hash = hash + self.iter = None + + def __iter__(self): + return self + + def __next__(self): + return self.next() + + def next(self): + if self.hash.Len() == 0: + raise StopIteration + if not self.iter: + self.iter = self.hash.BegI() + if not self.iter: + raise StopIteration + if self.iter: + return self.iter.GetKey() + return self.iter + + if self.iter.IsEnd(): + raise StopIteration + + self.iter.Next() + + if self.iter.IsEnd(): + raise StopIteration + + if self.iter: + return self.iter.GetKey() + return self.iter + +def iterhash(self): + return IterHash(self) + +TIntH.__getitem__ = getitem_hash +TIntH.__setitem__ = setitem_hash +TIntH.__delitem__ = delitem_hash +TIntH.__len__ = len_hash +TIntH.__iter__ = iterhash +TIntH.clear = clear_hash +TIntH.get = get_hash +TIntH.items = items_hash +TIntH.keys = keys_hash +TIntH.pop = pop_hash +TIntH.setdefault = setdefault_hash +TIntH.update = update_hash +TIntH.values = values_hash +TIntH.copy = copy_hash +TIntIntH.__getitem__ = getitem_hash +TIntIntH.__setitem__ = setitem_hash +TIntIntH.__delitem__ = delitem_hash +TIntIntH.__len__ = len_hash +TIntIntH.__iter__ = iterhash +TIntIntH.clear = clear_hash +TIntIntH.get = get_hash +TIntIntH.items = items_hash +TIntIntH.keys = keys_hash +TIntIntH.pop = pop_hash +TIntIntH.setdefault = setdefault_hash +TIntIntH.update = update_hash +TIntIntH.values = values_hash +TIntIntH.copy = copy_hash +TIntFltH.__getitem__ = getitem_hash +TIntFltH.__setitem__ = setitem_hash +TIntFltH.__delitem__ = delitem_hash +TIntFltH.__len__ = len_hash +TIntFltH.__iter__ = iterhash +TIntFltH.clear = clear_hash +TIntFltH.get = get_hash +TIntFltH.items = items_hash +TIntFltH.keys = keys_hash +TIntFltH.pop = pop_hash +TIntFltH.setdefault = setdefault_hash +TIntFltH.update = update_hash +TIntFltH.values = values_hash +TIntFltH.copy = copy_hash +TIntStrH.__getitem__ = getitem_hash +TIntStrH.__setitem__ = setitem_hash +TIntStrH.__delitem__ = delitem_hash +TIntStrH.__len__ = len_hash +TIntStrH.__iter__ = iterhash +TIntStrH.clear = clear_hash +TIntStrH.get = get_hash +TIntStrH.items = items_hash +TIntStrH.keys = keys_hash +TIntStrH.pop = pop_hash +TIntStrH.setdefault = setdefault_hash +TIntStrH.update = update_hash +TIntStrH.values = values_hash +TIntStrH.copy = copy_hash +TIntPrFltH.__getitem__ = getitem_hash +TIntPrFltH.__setitem__ = setitem_hash +TIntPrFltH.__delitem__ = delitem_hash +TIntPrFltH.__len__ = len_hash +TIntPrFltH.__iter__ = iterhash +TIntPrFltH.clear = clear_hash +TIntPrFltH.get = get_hash +TIntPrFltH.items = items_hash +TIntPrFltH.keys = keys_hash +TIntPrFltH.pop = pop_hash +TIntPrFltH.setdefault = setdefault_hash +TIntPrFltH.update = update_hash +TIntPrFltH.values = values_hash +TIntPrFltH.copy = copy_hash +TStrIntH.__getitem__ = getitem_hash +TStrIntH.__setitem__ = setitem_hash +TStrIntH.__iter__ = iterhash +TStrIntH.__delitem__ = delitem_hash +TStrIntH.__len__ = len_hash +TStrIntH.clear = clear_hash +TStrIntH.get = get_hash +TStrIntH.items = items_hash +TStrIntH.keys = keys_hash +TStrIntH.pop = pop_hash +TStrIntH.setdefault = setdefault_hash +TStrIntH.update = update_hash +TStrIntH.values = values_hash +TStrIntH.copy = copy_hash +%} + + +#if SNAP_ALL +%pythoncode %{ +TUInt64H.__iter__ = iterhash +TUInt64H.__getitem__ = getitem_hash +TUInt64H.__setitem__ = setitem_hash +TUInt64H.__delitem__ = delitem_hash +TUInt64H.__len__ = len_hash +TUInt64H.clear = clear_hash +TUInt64H.get = get_hash +TUInt64H.items = items_hash +TUInt64H.keys = keys_hash +TUInt64H.pop = pop_hash +TUInt64H.setdefault = setdefault_hash +TUInt64H.update = update_hash +TUInt64H.values = values_hash +TUInt64H.copy = copy_hash +TIntBoolH.__iter__ = iterhash +TIntBoolH.__getitem__ = getitem_hash +TIntBoolH.__setitem__ = setitem_hash +TIntBoolH.__delitem__ = delitem_hash +TIntBoolH.__len__ = len_hash +TIntBoolH.clear = clear_hash +TIntBoolH.get = get_hash +TIntBoolH.items = items_hash +TIntBoolH.keys = keys_hash +TIntBoolH.pop = pop_hash +TIntBoolH.setdefault = setdefault_hash +TIntBoolH.update = update_hash +TIntBoolH.values = values_hash +TIntBoolH.copy = copy_hash +TIntUInt64H.__iter__ = iterhash +TIntUInt64H.__getitem__ = getitem_hash +TIntUInt64H.__setitem__ = setitem_hash +TIntUInt64H.__delitem__ = delitem_hash +TIntUInt64H.__len__ = len_hash +TIntUInt64H.clear = clear_hash +TIntUInt64H.get = get_hash +TIntUInt64H.items = items_hash +TIntUInt64H.keys = keys_hash +TIntUInt64H.pop = pop_hash +TIntUInt64H.setdefault = setdefault_hash +TIntUInt64H.update = update_hash +TIntUInt64H.values = values_hash +TIntUInt64H.copy = copy_hash +TIntIntVH.__iter__ = iterhash +TIntIntVH.__getitem__ = getitem_hash +TIntIntVH.__setitem__ = setitem_hash +TIntIntVH.__delitem__ = delitem_hash +TIntIntVH.__len__ = len_hash +TIntIntVH.clear = clear_hash +TIntIntVH.get = get_hash +TIntIntVH.items = items_hash +TIntIntVH.keys = keys_hash +TIntIntVH.pop = pop_hash +TIntIntVH.setdefault = setdefault_hash +TIntIntVH.update = update_hash +TIntIntVH.values = values_hash +TIntIntVH.copy = copy_hash +TIntIntHH.__iter__ = iterhash +TIntIntHH.__getitem__ = getitem_hash +TIntIntHH.__setitem__ = setitem_hash +TIntIntHH.__delitem__ = delitem_hash +TIntIntHH.__len__ = len_hash +TIntIntHH.clear = clear_hash +TIntIntHH.get = get_hash +TIntIntHH.items = items_hash +TIntIntHH.keys = keys_hash +TIntIntHH.pop = pop_hash +TIntIntHH.setdefault = setdefault_hash +TIntIntHH.update = update_hash +TIntIntHH.values = values_hash +TIntIntHH.copy = copy_hash +TIntFltPrH.__iter__ = iterhash +TIntFltPrH.__getitem__ = getitem_hash +TIntFltPrH.__setitem__ = setitem_hash +TIntFltPrH.__delitem__ = delitem_hash +TIntFltPrH.__len__ = len_hash +TIntFltPrH.clear = clear_hash +TIntFltPrH.get = get_hash +TIntFltPrH.items = items_hash +TIntFltPrH.keys = keys_hash +TIntFltPrH.pop = pop_hash +TIntFltPrH.setdefault = setdefault_hash +TIntFltPrH.update = update_hash +TIntFltPrH.values = values_hash +TIntFltPrH.copy = copy_hash +TIntFltTrH.__iter__ = iterhash +TIntFltTrH.__getitem__ = getitem_hash +TIntFltTrH.__setitem__ = setitem_hash +TIntFltTrH.__delitem__ = delitem_hash +TIntFltTrH.__len__ = len_hash +TIntFltTrH.clear = clear_hash +TIntFltTrH.get = get_hash +TIntFltTrH.items = items_hash +TIntFltTrH.keys = keys_hash +TIntFltTrH.pop = pop_hash +TIntFltTrH.setdefault = setdefault_hash +TIntFltTrH.update = update_hash +TIntFltTrH.values = values_hash +TIntFltTrH.copy = copy_hash +TIntFltVH.__iter__ = iterhash +TIntFltVH.__getitem__ = getitem_hash +TIntFltVH.__setitem__ = setitem_hash +TIntFltVH.__delitem__ = delitem_hash +TIntFltVH.__len__ = len_hash +TIntFltVH.clear = clear_hash +TIntFltVH.get = get_hash +TIntFltVH.items = items_hash +TIntFltVH.keys = keys_hash +TIntFltVH.pop = pop_hash +TIntFltVH.setdefault = setdefault_hash +TIntFltVH.update = update_hash +TIntFltVH.values = values_hash +TIntFltVH.copy = copy_hash +TIntStrVH.__iter__ = iterhash +TIntStrVH.__getitem__ = getitem_hash +TIntStrVH.__setitem__ = setitem_hash +TIntStrVH.__delitem__ = delitem_hash +TIntStrVH.__len__ = len_hash +TIntStrVH.clear = clear_hash +TIntStrVH.get = get_hash +TIntStrVH.items = items_hash +TIntStrVH.keys = keys_hash +TIntStrVH.pop = pop_hash +TIntStrVH.setdefault = setdefault_hash +TIntStrVH.update = update_hash +TIntStrVH.values = values_hash +TIntStrVH.copy = copy_hash +TIntIntPrH.__iter__ = iterhash +TIntIntPrH.__getitem__ = getitem_hash +TIntIntPrH.__setitem__ = setitem_hash +TIntIntPrH.__delitem__ = delitem_hash +TIntIntPrH.__len__ = len_hash +TIntIntPrH.clear = clear_hash +TIntIntPrH.get = get_hash +TIntIntPrH.items = items_hash +TIntIntPrH.keys = keys_hash +TIntIntPrH.pop = pop_hash +TIntIntPrH.setdefault = setdefault_hash +TIntIntPrH.update = update_hash +TIntIntPrH.values = values_hash +TIntIntPrH.copy = copy_hash +TIntIntPrVH.__iter__ = iterhash +TIntIntPrVH.__getitem__ = getitem_hash +TIntIntPrVH.__setitem__ = setitem_hash +TIntIntPrVH.__delitem__ = delitem_hash +TIntIntPrVH.__len__ = len_hash +TIntIntPrVH.clear = clear_hash +TIntIntPrVH.get = get_hash +TIntIntPrVH.items = items_hash +TIntIntPrVH.keys = keys_hash +TIntIntPrVH.pop = pop_hash +TIntIntPrVH.setdefault = setdefault_hash +TIntIntPrVH.update = update_hash +TIntIntPrVH.values = values_hash +TIntIntPrVH.copy = copy_hash +TUInt64StrVH.__iter__ = iterhash +TUInt64StrVH.__getitem__ = getitem_hash +TUInt64StrVH.__setitem__ = setitem_hash +TUInt64StrVH.__delitem__ = delitem_hash +TUInt64StrVH.__len__ = len_hash +TUInt64StrVH.clear = clear_hash +TUInt64StrVH.get = get_hash +TUInt64StrVH.items = items_hash +TUInt64StrVH.keys = keys_hash +TUInt64StrVH.pop = pop_hash +TUInt64StrVH.setdefault = setdefault_hash +TUInt64StrVH.update = update_hash +TUInt64StrVH.values = values_hash +TUInt64StrVH.copy = copy_hash +TIntPrIntH.__iter__ = iterhash +TIntPrIntH.__getitem__ = getitem_hash +TIntPrIntH.__setitem__ = setitem_hash +TIntPrIntH.__delitem__ = delitem_hash +TIntPrIntH.__len__ = len_hash +TIntPrIntH.clear = clear_hash +TIntPrIntH.get = get_hash +TIntPrIntH.items = items_hash +TIntPrIntH.keys = keys_hash +TIntPrIntH.pop = pop_hash +TIntPrIntH.setdefault = setdefault_hash +TIntPrIntH.update = update_hash +TIntPrIntH.values = values_hash +TIntPrIntH.copy = copy_hash +TIntPrIntVH.__iter__ = iterhash +TIntPrIntVH.__getitem__ = getitem_hash +TIntPrIntVH.__setitem__ = setitem_hash +TIntPrIntVH.__delitem__ = delitem_hash +TIntPrIntVH.__len__ = len_hash +TIntPrIntVH.clear = clear_hash +TIntPrIntVH.get = get_hash +TIntPrIntVH.items = items_hash +TIntPrIntVH.keys = keys_hash +TIntPrIntVH.pop = pop_hash +TIntPrIntVH.setdefault = setdefault_hash +TIntPrIntVH.update = update_hash +TIntPrIntVH.values = values_hash +TIntPrIntVH.copy = copy_hash +TIntPrIntPrVH.__iter__ = iterhash +TIntPrIntPrVH.__getitem__ = getitem_hash +TIntPrIntPrVH.__setitem__ = setitem_hash +TIntPrIntPrVH.__delitem__ = delitem_hash +TIntPrIntPrVH.__len__ = len_hash +TIntPrIntPrVH.clear = clear_hash +TIntPrIntPrVH.get = get_hash +TIntPrIntPrVH.items = items_hash +TIntPrIntPrVH.keys = keys_hash +TIntPrIntPrVH.pop = pop_hash +TIntPrIntPrVH.setdefault = setdefault_hash +TIntPrIntPrVH.update = update_hash +TIntPrIntPrVH.values = values_hash +TIntPrIntPrVH.copy = copy_hash +TIntTrIntH.__iter__ = iterhash +TIntTrIntH.__getitem__ = getitem_hash +TIntTrIntH.__setitem__ = setitem_hash +TIntTrIntH.__delitem__ = delitem_hash +TIntTrIntH.__len__ = len_hash +TIntTrIntH.clear = clear_hash +TIntTrIntH.get = get_hash +TIntTrIntH.items = items_hash +TIntTrIntH.keys = keys_hash +TIntTrIntH.pop = pop_hash +TIntTrIntH.setdefault = setdefault_hash +TIntTrIntH.update = update_hash +TIntTrIntH.values = values_hash +TIntTrIntH.copy = copy_hash +TIntVIntH.__iter__ = iterhash +TIntVIntH.__getitem__ = getitem_hash +TIntVIntH.__setitem__ = setitem_hash +TIntVIntH.__delitem__ = delitem_hash +TIntVIntH.__len__ = len_hash +TIntVIntH.clear = clear_hash +TIntVIntH.get = get_hash +TIntVIntH.items = items_hash +TIntVIntH.keys = keys_hash +TIntVIntH.pop = pop_hash +TIntVIntH.setdefault = setdefault_hash +TIntVIntH.update = update_hash +TIntVIntH.values = values_hash +TIntVIntH.copy = copy_hash +TUIntH.__iter__ = iterhash +TUIntH.__getitem__ = getitem_hash +TUIntH.__setitem__ = setitem_hash +TUIntH.__delitem__ = delitem_hash +TUIntH.__len__ = len_hash +TUIntH.clear = clear_hash +TUIntH.get = get_hash +TUIntH.items = items_hash +TUIntH.keys = keys_hash +TUIntH.pop = pop_hash +TUIntH.setdefault = setdefault_hash +TUIntH.update = update_hash +TUIntH.values = values_hash +TUIntH.copy = copy_hash +TIntTrFltH.__iter__ = iterhash +TIntTrFltH.__getitem__ = getitem_hash +TIntTrFltH.__setitem__ = setitem_hash +TIntTrFltH.__delitem__ = delitem_hash +TIntTrFltH.__len__ = len_hash +TIntTrFltH.clear = clear_hash +TIntTrFltH.get = get_hash +TIntTrFltH.items = items_hash +TIntTrFltH.keys = keys_hash +TIntTrFltH.pop = pop_hash +TIntTrFltH.setdefault = setdefault_hash +TIntTrFltH.update = update_hash +TIntTrFltH.values = values_hash +TIntTrFltH.copy = copy_hash +TIntPrStrH.__iter__ = iterhash +TIntPrStrH.__getitem__ = getitem_hash +TIntPrStrH.__setitem__ = setitem_hash +TIntPrStrH.__delitem__ = delitem_hash +TIntPrStrH.__len__ = len_hash +TIntPrStrH.clear = clear_hash +TIntPrStrH.get = get_hash +TIntPrStrH.items = items_hash +TIntPrStrH.keys = keys_hash +TIntPrStrH.pop = pop_hash +TIntPrStrH.setdefault = setdefault_hash +TIntPrStrH.update = update_hash +TIntPrStrH.values = values_hash +TIntPrStrH.copy = copy_hash +TIntPrStrVH.__iter__ = iterhash +TIntPrStrVH.__getitem__ = getitem_hash +TIntPrStrVH.__setitem__ = setitem_hash +TIntPrStrVH.__delitem__ = delitem_hash +TIntPrStrVH.__len__ = len_hash +TIntPrStrVH.clear = clear_hash +TIntPrStrVH.get = get_hash +TIntPrStrVH.items = items_hash +TIntPrStrVH.keys = keys_hash +TIntPrStrVH.pop = pop_hash +TIntPrStrVH.setdefault = setdefault_hash +TIntPrStrVH.update = update_hash +TIntPrStrVH.values = values_hash +TIntPrStrVH.copy = copy_hash +TIntStrPrIntH.__iter__ = iterhash +TIntStrPrIntH.__getitem__ = getitem_hash +TIntStrPrIntH.__setitem__ = setitem_hash +TIntStrPrIntH.__delitem__ = delitem_hash +TIntStrPrIntH.__len__ = len_hash +TIntStrPrIntH.clear = clear_hash +TIntStrPrIntH.get = get_hash +TIntStrPrIntH.items = items_hash +TIntStrPrIntH.keys = keys_hash +TIntStrPrIntH.pop = pop_hash +TIntStrPrIntH.setdefault = setdefault_hash +TIntStrPrIntH.update = update_hash +TIntStrPrIntH.values = values_hash +TIntStrPrIntH.copy = copy_hash +TFltFltH.__iter__ = iterhash +TFltFltH.__getitem__ = getitem_hash +TFltFltH.__setitem__ = setitem_hash +TFltFltH.__delitem__ = delitem_hash +TFltFltH.__len__ = len_hash +TFltFltH.clear = clear_hash +TFltFltH.get = get_hash +TFltFltH.items = items_hash +TFltFltH.keys = keys_hash +TFltFltH.pop = pop_hash +TFltFltH.setdefault = setdefault_hash +TFltFltH.update = update_hash +TFltFltH.values = values_hash +TFltFltH.copy = copy_hash +TStrH.__iter__ = iterhash +TStrH.__getitem__ = getitem_hash +TStrH.__setitem__ = setitem_hash +TStrH.__delitem__ = delitem_hash +TStrH.__len__ = len_hash +TStrH.clear = clear_hash +TStrH.get = get_hash +TStrH.items = items_hash +TStrH.keys = keys_hash +TStrH.pop = pop_hash +TStrH.setdefault = setdefault_hash +TStrH.update = update_hash +TStrH.values = values_hash +TStrH.copy = copy_hash +TStrBoolH.__iter__ = iterhash +TStrBoolH.__getitem__ = getitem_hash +TStrBoolH.__setitem__ = setitem_hash +TStrBoolH.__delitem__ = delitem_hash +TStrBoolH.__len__ = len_hash +TStrBoolH.clear = clear_hash +TStrBoolH.get = get_hash +TStrBoolH.items = items_hash +TStrBoolH.keys = keys_hash +TStrBoolH.pop = pop_hash +TStrBoolH.setdefault = setdefault_hash +TStrBoolH.update = update_hash +TStrBoolH.values = values_hash +TStrBoolH.copy = copy_hash +TStrIntPrH.__iter__ = iterhash +TStrIntPrH.__getitem__ = getitem_hash +TStrIntPrH.__setitem__ = setitem_hash +TStrIntPrH.__delitem__ = delitem_hash +TStrIntPrH.__len__ = len_hash +TStrIntPrH.clear = clear_hash +TStrIntPrH.get = get_hash +TStrIntPrH.items = items_hash +TStrIntPrH.keys = keys_hash +TStrIntPrH.pop = pop_hash +TStrIntPrH.setdefault = setdefault_hash +TStrIntPrH.update = update_hash +TStrIntPrH.values = values_hash +TStrIntPrH.copy = copy_hash +TStrIntVH.__iter__ = iterhash +TStrIntVH.__getitem__ = getitem_hash +TStrIntVH.__setitem__ = setitem_hash +TStrIntVH.__delitem__ = delitem_hash +TStrIntVH.__len__ = len_hash +TStrIntVH.clear = clear_hash +TStrIntVH.get = get_hash +TStrIntVH.items = items_hash +TStrIntVH.keys = keys_hash +TStrIntVH.pop = pop_hash +TStrIntVH.setdefault = setdefault_hash +TStrIntVH.update = update_hash +TStrIntVH.values = values_hash +TStrIntVH.copy = copy_hash +TStrUInt64H.__iter__ = iterhash +TStrUInt64H.__getitem__ = getitem_hash +TStrUInt64H.__setitem__ = setitem_hash +TStrUInt64H.__delitem__ = delitem_hash +TStrUInt64H.__len__ = len_hash +TStrUInt64H.clear = clear_hash +TStrUInt64H.get = get_hash +TStrUInt64H.items = items_hash +TStrUInt64H.keys = keys_hash +TStrUInt64H.pop = pop_hash +TStrUInt64H.setdefault = setdefault_hash +TStrUInt64H.update = update_hash +TStrUInt64H.values = values_hash +TStrUInt64H.copy = copy_hash +TStrUInt64VH.__iter__ = iterhash +TStrUInt64VH.__getitem__ = getitem_hash +TStrUInt64VH.__setitem__ = setitem_hash +TStrUInt64VH.__delitem__ = delitem_hash +TStrUInt64VH.__len__ = len_hash +TStrUInt64VH.clear = clear_hash +TStrUInt64VH.get = get_hash +TStrUInt64VH.items = items_hash +TStrUInt64VH.keys = keys_hash +TStrUInt64VH.pop = pop_hash +TStrUInt64VH.setdefault = setdefault_hash +TStrUInt64VH.update = update_hash +TStrUInt64VH.values = values_hash +TStrUInt64VH.copy = copy_hash +TStrIntPrVH.__iter__ = iterhash +TStrIntPrVH.__getitem__ = getitem_hash +TStrIntPrVH.__setitem__ = setitem_hash +TStrIntPrVH.__delitem__ = delitem_hash +TStrIntPrVH.__len__ = len_hash +TStrIntPrVH.clear = clear_hash +TStrIntPrVH.get = get_hash +TStrIntPrVH.items = items_hash +TStrIntPrVH.keys = keys_hash +TStrIntPrVH.pop = pop_hash +TStrIntPrVH.setdefault = setdefault_hash +TStrIntPrVH.update = update_hash +TStrIntPrVH.values = values_hash +TStrIntPrVH.copy = copy_hash +TStrFltH.__iter__ = iterhash +TStrFltH.__getitem__ = getitem_hash +TStrFltH.__setitem__ = setitem_hash +TStrFltH.__delitem__ = delitem_hash +TStrFltH.__len__ = len_hash +TStrFltH.clear = clear_hash +TStrFltH.get = get_hash +TStrFltH.items = items_hash +TStrFltH.keys = keys_hash +TStrFltH.pop = pop_hash +TStrFltH.setdefault = setdefault_hash +TStrFltH.update = update_hash +TStrFltH.values = values_hash +TStrFltH.copy = copy_hash +TStrFltVH.__iter__ = iterhash +TStrFltVH.__getitem__ = getitem_hash +TStrFltVH.__setitem__ = setitem_hash +TStrFltVH.__delitem__ = delitem_hash +TStrFltVH.__len__ = len_hash +TStrFltVH.clear = clear_hash +TStrFltVH.get = get_hash +TStrFltVH.items = items_hash +TStrFltVH.keys = keys_hash +TStrFltVH.pop = pop_hash +TStrFltVH.setdefault = setdefault_hash +TStrFltVH.update = update_hash +TStrFltVH.values = values_hash +TStrFltVH.copy = copy_hash +TStrStrH.__iter__ = iterhash +TStrStrH.__getitem__ = getitem_hash +TStrStrH.__setitem__ = setitem_hash +TStrStrH.__delitem__ = delitem_hash +TStrStrH.__len__ = len_hash +TStrStrH.clear = clear_hash +TStrStrH.get = get_hash +TStrStrH.items = items_hash +TStrStrH.keys = keys_hash +TStrStrH.pop = pop_hash +TStrStrH.setdefault = setdefault_hash +TStrStrH.update = update_hash +TStrStrH.values = values_hash +TStrStrH.copy = copy_hash +TStrStrPrH.__iter__ = iterhash +TStrStrPrH.__getitem__ = getitem_hash +TStrStrPrH.__setitem__ = setitem_hash +TStrStrPrH.__delitem__ = delitem_hash +TStrStrPrH.__len__ = len_hash +TStrStrPrH.clear = clear_hash +TStrStrPrH.get = get_hash +TStrStrPrH.items = items_hash +TStrStrPrH.keys = keys_hash +TStrStrPrH.pop = pop_hash +TStrStrPrH.setdefault = setdefault_hash +TStrStrPrH.update = update_hash +TStrStrPrH.values = values_hash +TStrStrPrH.copy = copy_hash +TStrStrVH.__iter__ = iterhash +TStrStrVH.__getitem__ = getitem_hash +TStrStrVH.__setitem__ = setitem_hash +TStrStrVH.__delitem__ = delitem_hash +TStrStrVH.__len__ = len_hash +TStrStrVH.clear = clear_hash +TStrStrVH.get = get_hash +TStrStrVH.items = items_hash +TStrStrVH.keys = keys_hash +TStrStrVH.pop = pop_hash +TStrStrVH.setdefault = setdefault_hash +TStrStrVH.update = update_hash +TStrStrVH.values = values_hash +TStrStrVH.copy = copy_hash +TStrStrPrVH.__iter__ = iterhash +TStrStrPrVH.__getitem__ = getitem_hash +TStrStrPrVH.__setitem__ = setitem_hash +TStrStrPrVH.__delitem__ = delitem_hash +TStrStrPrVH.__len__ = len_hash +TStrStrPrVH.clear = clear_hash +TStrStrPrVH.get = get_hash +TStrStrPrVH.items = items_hash +TStrStrPrVH.keys = keys_hash +TStrStrPrVH.pop = pop_hash +TStrStrPrVH.setdefault = setdefault_hash +TStrStrPrVH.update = update_hash +TStrStrPrVH.values = values_hash +TStrStrPrVH.copy = copy_hash +TStrStrKdVH.__iter__ = iterhash +TStrStrKdVH.__getitem__ = getitem_hash +TStrStrKdVH.__setitem__ = setitem_hash +TStrStrKdVH.__delitem__ = delitem_hash +TStrStrKdVH.__len__ = len_hash +TStrStrKdVH.clear = clear_hash +TStrStrKdVH.get = get_hash +TStrStrKdVH.items = items_hash +TStrStrKdVH.keys = keys_hash +TStrStrKdVH.pop = pop_hash +TStrStrKdVH.setdefault = setdefault_hash +TStrStrKdVH.update = update_hash +TStrStrKdVH.values = values_hash +TStrStrKdVH.copy = copy_hash +TStrIntFltPrH.__iter__ = iterhash +TStrIntFltPrH.__getitem__ = getitem_hash +TStrIntFltPrH.__setitem__ = setitem_hash +TStrIntFltPrH.__delitem__ = delitem_hash +TStrIntFltPrH.__len__ = len_hash +TStrIntFltPrH.clear = clear_hash +TStrIntFltPrH.get = get_hash +TStrIntFltPrH.items = items_hash +TStrIntFltPrH.keys = keys_hash +TStrIntFltPrH.pop = pop_hash +TStrIntFltPrH.setdefault = setdefault_hash +TStrIntFltPrH.update = update_hash +TStrIntFltPrH.values = values_hash +TStrIntFltPrH.copy = copy_hash +TStrStrIntPrVH.__iter__ = iterhash +TStrStrIntPrVH.__getitem__ = getitem_hash +TStrStrIntPrVH.__setitem__ = setitem_hash +TStrStrIntPrVH.__delitem__ = delitem_hash +TStrStrIntPrVH.__len__ = len_hash +TStrStrIntPrVH.clear = clear_hash +TStrStrIntPrVH.get = get_hash +TStrStrIntPrVH.items = items_hash +TStrStrIntPrVH.keys = keys_hash +TStrStrIntPrVH.pop = pop_hash +TStrStrIntPrVH.setdefault = setdefault_hash +TStrStrIntPrVH.update = update_hash +TStrStrIntPrVH.values = values_hash +TStrStrIntPrVH.copy = copy_hash +TStrStrIntKdVH.__iter__ = iterhash +TStrStrIntKdVH.__getitem__ = getitem_hash +TStrStrIntKdVH.__setitem__ = setitem_hash +TStrStrIntKdVH.__delitem__ = delitem_hash +TStrStrIntKdVH.__len__ = len_hash +TStrStrIntKdVH.clear = clear_hash +TStrStrIntKdVH.get = get_hash +TStrStrIntKdVH.items = items_hash +TStrStrIntKdVH.keys = keys_hash +TStrStrIntKdVH.pop = pop_hash +TStrStrIntKdVH.setdefault = setdefault_hash +TStrStrIntKdVH.update = update_hash +TStrStrIntKdVH.values = values_hash +TStrStrIntKdVH.copy = copy_hash +TStrPrBoolH.__iter__ = iterhash +TStrPrBoolH.__getitem__ = getitem_hash +TStrPrBoolH.__setitem__ = setitem_hash +TStrPrBoolH.__delitem__ = delitem_hash +TStrPrBoolH.__len__ = len_hash +TStrPrBoolH.clear = clear_hash +TStrPrBoolH.get = get_hash +TStrPrBoolH.items = items_hash +TStrPrBoolH.keys = keys_hash +TStrPrBoolH.pop = pop_hash +TStrPrBoolH.setdefault = setdefault_hash +TStrPrBoolH.update = update_hash +TStrPrBoolH.values = values_hash +TStrPrBoolH.copy = copy_hash +TStrPrIntH.__iter__ = iterhash +TStrPrIntH.__getitem__ = getitem_hash +TStrPrIntH.__setitem__ = setitem_hash +TStrPrIntH.__delitem__ = delitem_hash +TStrPrIntH.__len__ = len_hash +TStrPrIntH.clear = clear_hash +TStrPrIntH.get = get_hash +TStrPrIntH.items = items_hash +TStrPrIntH.keys = keys_hash +TStrPrIntH.pop = pop_hash +TStrPrIntH.setdefault = setdefault_hash +TStrPrIntH.update = update_hash +TStrPrIntH.values = values_hash +TStrPrIntH.copy = copy_hash +TStrPrFltH.__iter__ = iterhash +TStrPrFltH.__getitem__ = getitem_hash +TStrPrFltH.__setitem__ = setitem_hash +TStrPrFltH.__delitem__ = delitem_hash +TStrPrFltH.__len__ = len_hash +TStrPrFltH.clear = clear_hash +TStrPrFltH.get = get_hash +TStrPrFltH.items = items_hash +TStrPrFltH.keys = keys_hash +TStrPrFltH.pop = pop_hash +TStrPrFltH.setdefault = setdefault_hash +TStrPrFltH.update = update_hash +TStrPrFltH.values = values_hash +TStrPrFltH.copy = copy_hash +TStrPrStrH.__iter__ = iterhash +TStrPrStrH.__getitem__ = getitem_hash +TStrPrStrH.__setitem__ = setitem_hash +TStrPrStrH.__delitem__ = delitem_hash +TStrPrStrH.__len__ = len_hash +TStrPrStrH.clear = clear_hash +TStrPrStrH.get = get_hash +TStrPrStrH.items = items_hash +TStrPrStrH.keys = keys_hash +TStrPrStrH.pop = pop_hash +TStrPrStrH.setdefault = setdefault_hash +TStrPrStrH.update = update_hash +TStrPrStrH.values = values_hash +TStrPrStrH.copy = copy_hash +TStrPrStrVH.__iter__ = iterhash +TStrPrStrVH.__getitem__ = getitem_hash +TStrPrStrVH.__setitem__ = setitem_hash +TStrPrStrVH.__delitem__ = delitem_hash +TStrPrStrVH.__len__ = len_hash +TStrPrStrVH.clear = clear_hash +TStrPrStrVH.get = get_hash +TStrPrStrVH.items = items_hash +TStrPrStrVH.keys = keys_hash +TStrPrStrVH.pop = pop_hash +TStrPrStrVH.setdefault = setdefault_hash +TStrPrStrVH.update = update_hash +TStrPrStrVH.values = values_hash +TStrPrStrVH.copy = copy_hash +TStrTrIntH.__iter__ = iterhash +TStrTrIntH.__getitem__ = getitem_hash +TStrTrIntH.__setitem__ = setitem_hash +TStrTrIntH.__delitem__ = delitem_hash +TStrTrIntH.__len__ = len_hash +TStrTrIntH.clear = clear_hash +TStrTrIntH.get = get_hash +TStrTrIntH.items = items_hash +TStrTrIntH.keys = keys_hash +TStrTrIntH.pop = pop_hash +TStrTrIntH.setdefault = setdefault_hash +TStrTrIntH.update = update_hash +TStrTrIntH.values = values_hash +TStrTrIntH.copy = copy_hash +TStrIntPrIntH.__iter__ = iterhash +TStrIntPrIntH.__getitem__ = getitem_hash +TStrIntPrIntH.__setitem__ = setitem_hash +TStrIntPrIntH.__delitem__ = delitem_hash +TStrIntPrIntH.__len__ = len_hash +TStrIntPrIntH.clear = clear_hash +TStrIntPrIntH.get = get_hash +TStrIntPrIntH.items = items_hash +TStrIntPrIntH.keys = keys_hash +TStrIntPrIntH.pop = pop_hash +TStrIntPrIntH.setdefault = setdefault_hash +TStrIntPrIntH.update = update_hash +TStrIntPrIntH.values = values_hash +TStrIntPrIntH.copy = copy_hash +TStrVH.__iter__ = iterhash +TStrVH.__getitem__ = getitem_hash +TStrVH.__setitem__ = setitem_hash +TStrVH.__delitem__ = delitem_hash +TStrVH.__len__ = len_hash +TStrVH.clear = clear_hash +TStrVH.get = get_hash +TStrVH.items = items_hash +TStrVH.keys = keys_hash +TStrVH.pop = pop_hash +TStrVH.setdefault = setdefault_hash +TStrVH.update = update_hash +TStrVH.values = values_hash +TStrVH.copy = copy_hash +TStrVIntVH.__iter__ = iterhash +TStrVIntVH.__getitem__ = getitem_hash +TStrVIntVH.__setitem__ = setitem_hash +TStrVIntVH.__delitem__ = delitem_hash +TStrVIntVH.__len__ = len_hash +TStrVIntVH.clear = clear_hash +TStrVIntVH.get = get_hash +TStrVIntVH.items = items_hash +TStrVIntVH.keys = keys_hash +TStrVIntVH.pop = pop_hash +TStrVIntVH.setdefault = setdefault_hash +TStrVIntVH.update = update_hash +TStrVIntVH.values = values_hash +TStrVIntVH.copy = copy_hash +TStrVStrH.__iter__ = iterhash +TStrVStrH.__getitem__ = getitem_hash +TStrVStrH.__setitem__ = setitem_hash +TStrVStrH.__delitem__ = delitem_hash +TStrVStrH.__len__ = len_hash +TStrVStrH.clear = clear_hash +TStrVStrH.get = get_hash +TStrVStrH.items = items_hash +TStrVStrH.keys = keys_hash +TStrVStrH.pop = pop_hash +TStrVStrH.setdefault = setdefault_hash +TStrVStrH.update = update_hash +TStrVStrH.values = values_hash +TStrVStrH.copy = copy_hash +TStrVStrVH.__iter__ = iterhash +TStrVStrVH.__getitem__ = getitem_hash +TStrVStrVH.__setitem__ = setitem_hash +TStrVStrVH.__delitem__ = delitem_hash +TStrVStrVH.__len__ = len_hash +TStrVStrVH.clear = clear_hash +TStrVStrVH.get = get_hash +TStrVStrVH.items = items_hash +TStrVStrVH.keys = keys_hash +TStrVStrVH.pop = pop_hash +TStrVStrVH.setdefault = setdefault_hash +TStrVStrVH.update = update_hash +TStrVStrVH.values = values_hash +TStrVStrVH.copy = copy_hash +%} +#endif + diff --git a/snap-python/source/swig/thashset.i b/snap-python/source/swig/thashset.i new file mode 100644 index 0000000000000000000000000000000000000000..a64f37d3cb66a51e914b439749564091aaad9c41 --- /dev/null +++ b/snap-python/source/swig/thashset.i @@ -0,0 +1,60 @@ +%pythoncode %{ + +# +# define __getitem__ for [] addressing +# +def getitem_hashset(self, i): + return self.GetSetKey(i) + +def delitem_hashset(self, i): + self.DelKey(i) + +def contains_hashset(self, key): + return self.IsKey(key) + +# +# define iterator for THashSet +# + +class IterHashSet: + def __init__(self, hash): + self.hash = hash + self.iter = None + + def __iter__(self): + return self + + def __next__(self): + return self.next() + + def next(self): + if self.hash.Len() == 0: + raise StopIteration + if not self.iter: + self.iter = self.hash.BegI() + if not self.iter: + raise StopIteration + if self.iter: + return self.iter.GetKey() + return self.iter + + if self.iter.IsEnd(): + raise StopIteration + + self.iter.Next() + + if self.iter.IsEnd(): + raise StopIteration + + if self.iter: + return self.iter.GetKey() + return self.iter + +def iterhashset(self): + return IterHashSet(self) + + +TIntSet.__iter__ = iterhashset +TIntSet.__contains__ = contains_hashset + +%} diff --git a/snap-python/source/swig/tmodenet.i b/snap-python/source/swig/tmodenet.i new file mode 100644 index 0000000000000000000000000000000000000000..310eb362a95779138290f41c9d1675ce4af11fda --- /dev/null +++ b/snap-python/source/swig/tmodenet.i @@ -0,0 +1,16 @@ +// tmodenet.i +// Templates for SNAP TModeNet +// + +%extend TModeNet { + TModeNetNodeI BegMMNI() { + return TModeNetNodeI($self->BegMMNI()); + } + TModeNetNodeI EndMMNI() { + return TModeNetNodeI($self->EndMMNI()); + } + TModeNetNodeI GetMMNI(const int &NId) { + return TModeNetNodeI($self->GetMMNI(NId)); + } +}; + diff --git a/snap-python/source/swig/tvec.i b/snap-python/source/swig/tvec.i new file mode 100644 index 0000000000000000000000000000000000000000..42ca0e5c5d2977e94b4aab496393e68155fdca95 --- /dev/null +++ b/snap-python/source/swig/tvec.i @@ -0,0 +1,1558 @@ +%pythoncode %{ + +# +# define __getitem__ for [] addressing +# + +def getitem_vec(self, i): + return self.GetVal(i) + +def setitem_vec(self, i, val): + self.SetVal(i, val) + +def len_vec(self): + return self.Len() + +def delitem_vec(self, i): + self.Del(i) + +def append_vec(self, val): + self.Add(val) + +def extend_vec(self, tvec): + self.AddV(tvec) + +def clear_vec(self): + self.Clr() + +def insert_vec(self, index, val): + self.Ins(index, val) + +def remove_vec(self, val): + bool = self.DelIfIn(val) + if not bool: + raise Exception("ValueError: list.remove({}): {} is not in list".format(val, val)) + +def index_vec(self, val): + for i in range(self.Len()): + if self[i] == val: + return i + raise Exception("ValueError: {} is not in list".format(val)) + +def count_vec(self, val): + count = 0 + for i in range(self.Len()): + if self[i] == val: + count += 1 + return count + +def pop_vec(self, index): + ret_val = self[index] + del self[index] + return ret_val + +def reverse_vec(self): + for i in range(len(self) // 2): + elem = self[i] + self[i] = self[len(self) - 1 - i] + self[len(self) - 1 - i] = elem + +def sort_vec(self, asc=False): + self.Sort(asc) + +def copy_vec(self): + return self + + + + +# +# define iterator for TVec +# + +class IterVec: + def __init__(self, vec): + self.vec = vec + self.count = -1 + + def __iter__(self): + return self + + def __next__(self): + return self.next() + + def next(self): + if self.count+1 < self.vec.Len(): + self.count += 1 + return self.vec[self.count] + + raise StopIteration + +def itervec(self): + return IterVec(self) + +# expand TVec types with methods __iter__ and __getitem__ + +TIntV.__getitem__ = getitem_vec +TIntV.__setitem__ = setitem_vec +TIntV.__iter__ = itervec +TIntV.__len__ = len_vec +TIntV.__delitem__ = delitem_vec +TIntV.append = append_vec +TIntV.extend = extend_vec +TIntV.clear = clear_vec +TIntV.insert = insert_vec +TIntV.remove = remove_vec +TIntV.index = index_vec +TIntV.count = count_vec +TIntV.pop = pop_vec +TIntV.reverse = reverse_vec +TIntV.sort = sort_vec +TIntV.copy = copy_vec +TFltV.__getitem__ = getitem_vec +TFltV.__setitem__ = setitem_vec +TFltV.__iter__ = itervec +TFltV.__len__ = len_vec +TFltV.__delitem__ = delitem_vec +TFltV.append = append_vec +TFltV.extend = extend_vec +TFltV.clear = clear_vec +TFltV.insert = insert_vec +TFltV.remove = remove_vec +TFltV.index = index_vec +TFltV.count = count_vec +TFltV.pop = pop_vec +TFltV.reverse = reverse_vec +TFltV.sort = sort_vec +TFltV.copy = copy_vec +TStrV.__getitem__ = getitem_vec +TStrV.__setitem__ = setitem_vec +TStrV.__iter__ = itervec +TStrV.__len__ = len_vec +TStrV.__delitem__ = delitem_vec +TStrV.append = append_vec +TStrV.extend = extend_vec +TStrV.clear = clear_vec +TStrV.insert = insert_vec +TStrV.remove = remove_vec +TStrV.index = index_vec +TStrV.count = count_vec +TStrV.pop = pop_vec +TStrV.reverse = reverse_vec +TStrV.sort = sort_vec +TStrV.copy = copy_vec +TIntPrV.__getitem__ = getitem_vec +TIntPrV.__setitem__ = setitem_vec +TIntPrV.__iter__ = itervec +TIntPrV.__len__ = len_vec +TIntPrV.__delitem__ = delitem_vec +TIntPrV.append = append_vec +TIntPrV.extend = extend_vec +TIntPrV.clear = clear_vec +TIntPrV.insert = insert_vec +TIntPrV.remove = remove_vec +TIntPrV.index = index_vec +TIntPrV.count = count_vec +TIntPrV.pop = pop_vec +TIntPrV.reverse = reverse_vec +TIntPrV.sort = sort_vec +TIntPrV.copy = copy_vec +TFltPrV.__getitem__ = getitem_vec +TFltPrV.__setitem__ = setitem_vec +TFltPrV.__iter__ = itervec +TFltPrV.__len__ = len_vec +TFltPrV.__delitem__ = delitem_vec +TFltPrV.append = append_vec +TFltPrV.extend = extend_vec +TFltPrV.clear = clear_vec +TFltPrV.insert = insert_vec +TFltPrV.remove = remove_vec +TFltPrV.index = index_vec +TFltPrV.count = count_vec +TFltPrV.pop = pop_vec +TFltPrV.reverse = reverse_vec +TFltPrV.sort = sort_vec +TFltPrV.copy = copy_vec +TStrIntPrV.__getitem__ = getitem_vec +TStrIntPrV.__setitem__ = setitem_vec +TStrIntPrV.__iter__ = itervec +TStrIntPrV.__len__ = len_vec +TStrIntPrV.__delitem__ = delitem_vec +TStrIntPrV.append = append_vec +TStrIntPrV.extend = extend_vec +TStrIntPrV.clear = clear_vec +TStrIntPrV.insert = insert_vec +TStrIntPrV.remove = remove_vec +TStrIntPrV.index = index_vec +TStrIntPrV.count = count_vec +TStrIntPrV.pop = pop_vec +TStrIntPrV.reverse = reverse_vec +TStrIntPrV.sort = sort_vec +TStrIntPrV.copy = copy_vec +TIntTrV.__getitem__ = getitem_vec +TIntTrV.__setitem__ = setitem_vec +TIntTrV.__iter__ = itervec +TIntTrV.__len__ = len_vec +TIntTrV.__delitem__ = delitem_vec +TIntTrV.append = append_vec +TIntTrV.extend = extend_vec +TIntTrV.clear = clear_vec +TIntTrV.insert = insert_vec +TIntTrV.remove = remove_vec +TIntTrV.index = index_vec +TIntTrV.count = count_vec +TIntTrV.pop = pop_vec +TIntTrV.reverse = reverse_vec +TIntTrV.sort = sort_vec +TIntTrV.copy = copy_vec +TIntFltKdV.__getitem__ = getitem_vec +TIntFltKdV.__setitem__ = setitem_vec +TIntFltKdV.__iter__ = itervec +TIntFltKdV.__len__ = len_vec +TIntFltKdV.__delitem__ = delitem_vec +TIntFltKdV.append = append_vec +TIntFltKdV.extend = extend_vec +TIntFltKdV.clear = clear_vec +TIntFltKdV.insert = insert_vec +TIntFltKdV.remove = remove_vec +TIntFltKdV.index = index_vec +TIntFltKdV.count = count_vec +TIntFltKdV.pop = pop_vec +TIntFltKdV.reverse = reverse_vec +TIntFltKdV.sort = sort_vec +TIntFltKdV.copy = copy_vec +TIntIntVV.__getitem__ = getitem_vec +TIntIntVV.__setitem__ = setitem_vec +TIntIntVV.__iter__ = itervec +TIntIntVV.__len__ = len_vec +TIntIntVV.__delitem__ = delitem_vec +TIntIntVV.append = append_vec +TIntIntVV.extend = extend_vec +TIntIntVV.clear = clear_vec +TIntIntVV.insert = insert_vec +TIntIntVV.remove = remove_vec +TIntIntVV.index = index_vec +TIntIntVV.count = count_vec +TIntIntVV.pop = pop_vec +TIntIntVV.reverse = reverse_vec +TIntIntVV.sort = sort_vec +TIntIntVV.copy = copy_vec +PNEANetV.__getitem__ = getitem_vec +PNEANetV.__setitem__ = setitem_vec +PNEANetV.__iter__ = itervec +PNEANetV.__len__ = len_vec +PNEANetV.__delitem__ = delitem_vec +PNEANetV.append = append_vec +PNEANetV.extend = extend_vec +PNEANetV.clear = clear_vec +PNEANetV.insert = insert_vec +PNEANetV.remove = remove_vec +PNEANetV.index = index_vec +PNEANetV.count = count_vec +PNEANetV.pop = pop_vec +PNEANetV.reverse = reverse_vec +PNEANetV.sort = sort_vec +PNEANetV.copy = copy_vec +TFltVFltV.__getitem__ = getitem_vec +TFltVFltV.__setitem__ = setitem_vec +TFltVFltV.__iter__ = itervec +TFltVFltV.__len__ = len_vec +TFltVFltV.__delitem__ = delitem_vec +TFltVFltV.append = append_vec +TFltVFltV.extend = extend_vec +TFltVFltV.clear = clear_vec +TFltVFltV.insert = insert_vec +TFltVFltV.remove = remove_vec +TFltVFltV.index = index_vec +TFltVFltV.count = count_vec +TFltVFltV.pop = pop_vec +TFltVFltV.reverse = reverse_vec +TFltVFltV.sort = sort_vec +TFltVFltV.copy = copy_vec +TCnComV.__getitem__ = getitem_vec +TCnComV.__setitem__ = setitem_vec +TCnComV.__iter__ = itervec +TCnComV.__len__ = len_vec +TCnComV.__delitem__ = delitem_vec +TCnComV.append = append_vec +TCnComV.extend = extend_vec +TCnComV.clear = clear_vec +TCnComV.insert = insert_vec +TCnComV.remove = remove_vec +TCnComV.index = index_vec +TCnComV.count = count_vec +TCnComV.pop = pop_vec +TCnComV.reverse = reverse_vec +TCnComV.sort = sort_vec +TCnComV.copy = copy_vec +TCnCom.__getitem__ = getitem_vec +TCnCom.__setitem__ = setitem_vec +TCnCom.__iter__ = itervec +TCnCom.__len__ = len_vec +TCnCom.__delitem__ = delitem_vec +TCnCom.append = append_vec +TCnCom.extend = extend_vec +TCnCom.clear = clear_vec +TCnCom.insert = insert_vec +TCnCom.remove = remove_vec +TCnCom.index = index_vec +TCnCom.count = count_vec +TCnCom.pop = pop_vec +TCnCom.reverse = reverse_vec +TCnCom.sort = sort_vec +TCnCom.copy = copy_vec +Schema.__getitem__ = getitem_vec +Schema.__setitem__ = setitem_vec +Schema.__iter__ = itervec +Schema.__len__ = len_vec +Schema.__delitem__ = delitem_vec +Schema.append = append_vec +Schema.extend = extend_vec +Schema.clear = clear_vec +Schema.insert = insert_vec +Schema.remove = remove_vec +Schema.index = index_vec +Schema.count = count_vec +Schema.pop = pop_vec +Schema.reverse = reverse_vec +Schema.sort = sort_vec +Schema.copy = copy_vec +%} + +#if SNAP_ALL +%pythoncode %{ +TBoolV.__getitem__ = getitem_vec +TBoolV.__setitem__ = setitem_vec +TBoolV.__iter__ = itervec +TBoolV.__len__ = len_vec +TBoolV.__delitem__ = delitem_vec +TBoolV.append = append_vec +TBoolV.extend = extend_vec +TBoolV.clear = clear_vec +TBoolV.insert = insert_vec +TBoolV.remove = remove_vec +TBoolV.index = index_vec +TBoolV.count = count_vec +TBoolV.pop = pop_vec +TBoolV.reverse = reverse_vec +TBoolV.sort = sort_vec +TBoolV.copy = copy_vec +TChV.__getitem__ = getitem_vec +TChV.__setitem__ = setitem_vec +TChV.__iter__ = itervec +TChV.__len__ = len_vec +TChV.__delitem__ = delitem_vec +TChV.append = append_vec +TChV.extend = extend_vec +TChV.clear = clear_vec +TChV.insert = insert_vec +TChV.remove = remove_vec +TChV.index = index_vec +TChV.count = count_vec +TChV.pop = pop_vec +TChV.reverse = reverse_vec +TChV.sort = sort_vec +TChV.copy = copy_vec +TUChV.__getitem__ = getitem_vec +TUChV.__setitem__ = setitem_vec +TUChV.__iter__ = itervec +TUChV.__len__ = len_vec +TUChV.__delitem__ = delitem_vec +TUChV.append = append_vec +TUChV.extend = extend_vec +TUChV.clear = clear_vec +TUChV.insert = insert_vec +TUChV.remove = remove_vec +TUChV.index = index_vec +TUChV.count = count_vec +TUChV.pop = pop_vec +TUChV.reverse = reverse_vec +TUChV.sort = sort_vec +TUChV.copy = copy_vec +TUIntV.__getitem__ = getitem_vec +TUIntV.__setitem__ = setitem_vec +TUIntV.__iter__ = itervec +TUIntV.__len__ = len_vec +TUIntV.__delitem__ = delitem_vec +TUIntV.append = append_vec +TUIntV.extend = extend_vec +TUIntV.clear = clear_vec +TUIntV.insert = insert_vec +TUIntV.remove = remove_vec +TUIntV.index = index_vec +TUIntV.count = count_vec +TUIntV.pop = pop_vec +TUIntV.reverse = reverse_vec +TUIntV.sort = sort_vec +TUIntV.copy = copy_vec +TUInt64V.__getitem__ = getitem_vec +TUInt64V.__setitem__ = setitem_vec +TUInt64V.__iter__ = itervec +TUInt64V.__len__ = len_vec +TUInt64V.__delitem__ = delitem_vec +TUInt64V.append = append_vec +TUInt64V.extend = extend_vec +TUInt64V.clear = clear_vec +TUInt64V.insert = insert_vec +TUInt64V.remove = remove_vec +TUInt64V.index = index_vec +TUInt64V.count = count_vec +TUInt64V.pop = pop_vec +TUInt64V.reverse = reverse_vec +TUInt64V.sort = sort_vec +TUInt64V.copy = copy_vec +TSFltV.__getitem__ = getitem_vec +TSFltV.__setitem__ = setitem_vec +TSFltV.__iter__ = itervec +TSFltV.__len__ = len_vec +TSFltV.__delitem__ = delitem_vec +TSFltV.append = append_vec +TSFltV.extend = extend_vec +TSFltV.clear = clear_vec +TSFltV.insert = insert_vec +TSFltV.remove = remove_vec +TSFltV.index = index_vec +TSFltV.count = count_vec +TSFltV.pop = pop_vec +TSFltV.reverse = reverse_vec +TSFltV.sort = sort_vec +TSFltV.copy = copy_vec +TAscFltV.__getitem__ = getitem_vec +TAscFltV.__setitem__ = setitem_vec +TAscFltV.__iter__ = itervec +TAscFltV.__len__ = len_vec +TAscFltV.__delitem__ = delitem_vec +TAscFltV.append = append_vec +TAscFltV.extend = extend_vec +TAscFltV.clear = clear_vec +TAscFltV.insert = insert_vec +TAscFltV.remove = remove_vec +TAscFltV.index = index_vec +TAscFltV.count = count_vec +TAscFltV.pop = pop_vec +TAscFltV.reverse = reverse_vec +TAscFltV.sort = sort_vec +TAscFltV.copy = copy_vec +TChAV.__getitem__ = getitem_vec +TChAV.__setitem__ = setitem_vec +TChAV.__iter__ = itervec +TChAV.__len__ = len_vec +TChAV.__delitem__ = delitem_vec +TChAV.append = append_vec +TChAV.extend = extend_vec +TChAV.clear = clear_vec +TChAV.insert = insert_vec +TChAV.remove = remove_vec +TChAV.index = index_vec +TChAV.count = count_vec +TChAV.pop = pop_vec +TChAV.reverse = reverse_vec +TChAV.sort = sort_vec +TChAV.copy = copy_vec +TIntQuV.__getitem__ = getitem_vec +TIntQuV.__setitem__ = setitem_vec +TIntQuV.__iter__ = itervec +TIntQuV.__len__ = len_vec +TIntQuV.__delitem__ = delitem_vec +TIntQuV.append = append_vec +TIntQuV.extend = extend_vec +TIntQuV.clear = clear_vec +TIntQuV.insert = insert_vec +TIntQuV.remove = remove_vec +TIntQuV.index = index_vec +TIntQuV.count = count_vec +TIntQuV.pop = pop_vec +TIntQuV.reverse = reverse_vec +TIntQuV.sort = sort_vec +TIntQuV.copy = copy_vec +TFltTrV.__getitem__ = getitem_vec +TFltTrV.__setitem__ = setitem_vec +TFltTrV.__iter__ = itervec +TFltTrV.__len__ = len_vec +TFltTrV.__delitem__ = delitem_vec +TFltTrV.append = append_vec +TFltTrV.extend = extend_vec +TFltTrV.clear = clear_vec +TFltTrV.insert = insert_vec +TFltTrV.remove = remove_vec +TFltTrV.index = index_vec +TFltTrV.count = count_vec +TFltTrV.pop = pop_vec +TFltTrV.reverse = reverse_vec +TFltTrV.sort = sort_vec +TFltTrV.copy = copy_vec +TIntKdV.__getitem__ = getitem_vec +TIntKdV.__setitem__ = setitem_vec +TIntKdV.__iter__ = itervec +TIntKdV.__len__ = len_vec +TIntKdV.__delitem__ = delitem_vec +TIntKdV.append = append_vec +TIntKdV.extend = extend_vec +TIntKdV.clear = clear_vec +TIntKdV.insert = insert_vec +TIntKdV.remove = remove_vec +TIntKdV.index = index_vec +TIntKdV.count = count_vec +TIntKdV.pop = pop_vec +TIntKdV.reverse = reverse_vec +TIntKdV.sort = sort_vec +TIntKdV.copy = copy_vec +TUChIntPrV.__getitem__ = getitem_vec +TUChIntPrV.__setitem__ = setitem_vec +TUChIntPrV.__iter__ = itervec +TUChIntPrV.__len__ = len_vec +TUChIntPrV.__delitem__ = delitem_vec +TUChIntPrV.append = append_vec +TUChIntPrV.extend = extend_vec +TUChIntPrV.clear = clear_vec +TUChIntPrV.insert = insert_vec +TUChIntPrV.remove = remove_vec +TUChIntPrV.index = index_vec +TUChIntPrV.count = count_vec +TUChIntPrV.pop = pop_vec +TUChIntPrV.reverse = reverse_vec +TUChIntPrV.sort = sort_vec +TUChIntPrV.copy = copy_vec +TUChUInt64PrV.__getitem__ = getitem_vec +TUChUInt64PrV.__setitem__ = setitem_vec +TUChUInt64PrV.__iter__ = itervec +TUChUInt64PrV.__len__ = len_vec +TUChUInt64PrV.__delitem__ = delitem_vec +TUChUInt64PrV.append = append_vec +TUChUInt64PrV.extend = extend_vec +TUChUInt64PrV.clear = clear_vec +TUChUInt64PrV.insert = insert_vec +TUChUInt64PrV.remove = remove_vec +TUChUInt64PrV.index = index_vec +TUChUInt64PrV.count = count_vec +TUChUInt64PrV.pop = pop_vec +TUChUInt64PrV.reverse = reverse_vec +TUChUInt64PrV.sort = sort_vec +TUChUInt64PrV.copy = copy_vec +TIntUInt64PrV.__getitem__ = getitem_vec +TIntUInt64PrV.__setitem__ = setitem_vec +TIntUInt64PrV.__iter__ = itervec +TIntUInt64PrV.__len__ = len_vec +TIntUInt64PrV.__delitem__ = delitem_vec +TIntUInt64PrV.append = append_vec +TIntUInt64PrV.extend = extend_vec +TIntUInt64PrV.clear = clear_vec +TIntUInt64PrV.insert = insert_vec +TIntUInt64PrV.remove = remove_vec +TIntUInt64PrV.index = index_vec +TIntUInt64PrV.count = count_vec +TIntUInt64PrV.pop = pop_vec +TIntUInt64PrV.reverse = reverse_vec +TIntUInt64PrV.sort = sort_vec +TIntUInt64PrV.copy = copy_vec +TIntUInt64KdV.__getitem__ = getitem_vec +TIntUInt64KdV.__setitem__ = setitem_vec +TIntUInt64KdV.__iter__ = itervec +TIntUInt64KdV.__len__ = len_vec +TIntUInt64KdV.__delitem__ = delitem_vec +TIntUInt64KdV.append = append_vec +TIntUInt64KdV.extend = extend_vec +TIntUInt64KdV.clear = clear_vec +TIntUInt64KdV.insert = insert_vec +TIntUInt64KdV.remove = remove_vec +TIntUInt64KdV.index = index_vec +TIntUInt64KdV.count = count_vec +TIntUInt64KdV.pop = pop_vec +TIntUInt64KdV.reverse = reverse_vec +TIntUInt64KdV.sort = sort_vec +TIntUInt64KdV.copy = copy_vec +TIntFltPrV.__getitem__ = getitem_vec +TIntFltPrV.__setitem__ = setitem_vec +TIntFltPrV.__iter__ = itervec +TIntFltPrV.__len__ = len_vec +TIntFltPrV.__delitem__ = delitem_vec +TIntFltPrV.append = append_vec +TIntFltPrV.extend = extend_vec +TIntFltPrV.clear = clear_vec +TIntFltPrV.insert = insert_vec +TIntFltPrV.remove = remove_vec +TIntFltPrV.index = index_vec +TIntFltPrV.count = count_vec +TIntFltPrV.pop = pop_vec +TIntFltPrV.reverse = reverse_vec +TIntFltPrV.sort = sort_vec +TIntFltPrV.copy = copy_vec +TIntFltPrKdV.__getitem__ = getitem_vec +TIntFltPrKdV.__setitem__ = setitem_vec +TIntFltPrKdV.__iter__ = itervec +TIntFltPrKdV.__len__ = len_vec +TIntFltPrKdV.__delitem__ = delitem_vec +TIntFltPrKdV.append = append_vec +TIntFltPrKdV.extend = extend_vec +TIntFltPrKdV.clear = clear_vec +TIntFltPrKdV.insert = insert_vec +TIntFltPrKdV.remove = remove_vec +TIntFltPrKdV.index = index_vec +TIntFltPrKdV.count = count_vec +TIntFltPrKdV.pop = pop_vec +TIntFltPrKdV.reverse = reverse_vec +TIntFltPrKdV.sort = sort_vec +TIntFltPrKdV.copy = copy_vec +TFltIntPrV.__getitem__ = getitem_vec +TFltIntPrV.__setitem__ = setitem_vec +TFltIntPrV.__iter__ = itervec +TFltIntPrV.__len__ = len_vec +TFltIntPrV.__delitem__ = delitem_vec +TFltIntPrV.append = append_vec +TFltIntPrV.extend = extend_vec +TFltIntPrV.clear = clear_vec +TFltIntPrV.insert = insert_vec +TFltIntPrV.remove = remove_vec +TFltIntPrV.index = index_vec +TFltIntPrV.count = count_vec +TFltIntPrV.pop = pop_vec +TFltIntPrV.reverse = reverse_vec +TFltIntPrV.sort = sort_vec +TFltIntPrV.copy = copy_vec +TFltUInt64PrV.__getitem__ = getitem_vec +TFltUInt64PrV.__setitem__ = setitem_vec +TFltUInt64PrV.__iter__ = itervec +TFltUInt64PrV.__len__ = len_vec +TFltUInt64PrV.__delitem__ = delitem_vec +TFltUInt64PrV.append = append_vec +TFltUInt64PrV.extend = extend_vec +TFltUInt64PrV.clear = clear_vec +TFltUInt64PrV.insert = insert_vec +TFltUInt64PrV.remove = remove_vec +TFltUInt64PrV.index = index_vec +TFltUInt64PrV.count = count_vec +TFltUInt64PrV.pop = pop_vec +TFltUInt64PrV.reverse = reverse_vec +TFltUInt64PrV.sort = sort_vec +TFltUInt64PrV.copy = copy_vec +TFltStrPrV.__getitem__ = getitem_vec +TFltStrPrV.__setitem__ = setitem_vec +TFltStrPrV.__iter__ = itervec +TFltStrPrV.__len__ = len_vec +TFltStrPrV.__delitem__ = delitem_vec +TFltStrPrV.append = append_vec +TFltStrPrV.extend = extend_vec +TFltStrPrV.clear = clear_vec +TFltStrPrV.insert = insert_vec +TFltStrPrV.remove = remove_vec +TFltStrPrV.index = index_vec +TFltStrPrV.count = count_vec +TFltStrPrV.pop = pop_vec +TFltStrPrV.reverse = reverse_vec +TFltStrPrV.sort = sort_vec +TFltStrPrV.copy = copy_vec +TAscFltStrPrV.__getitem__ = getitem_vec +TAscFltStrPrV.__setitem__ = setitem_vec +TAscFltStrPrV.__iter__ = itervec +TAscFltStrPrV.__len__ = len_vec +TAscFltStrPrV.__delitem__ = delitem_vec +TAscFltStrPrV.append = append_vec +TAscFltStrPrV.extend = extend_vec +TAscFltStrPrV.clear = clear_vec +TAscFltStrPrV.insert = insert_vec +TAscFltStrPrV.remove = remove_vec +TAscFltStrPrV.index = index_vec +TAscFltStrPrV.count = count_vec +TAscFltStrPrV.pop = pop_vec +TAscFltStrPrV.reverse = reverse_vec +TAscFltStrPrV.sort = sort_vec +TAscFltStrPrV.copy = copy_vec +TIntStrPrV.__getitem__ = getitem_vec +TIntStrPrV.__setitem__ = setitem_vec +TIntStrPrV.__iter__ = itervec +TIntStrPrV.__len__ = len_vec +TIntStrPrV.__delitem__ = delitem_vec +TIntStrPrV.append = append_vec +TIntStrPrV.extend = extend_vec +TIntStrPrV.clear = clear_vec +TIntStrPrV.insert = insert_vec +TIntStrPrV.remove = remove_vec +TIntStrPrV.index = index_vec +TIntStrPrV.count = count_vec +TIntStrPrV.pop = pop_vec +TIntStrPrV.reverse = reverse_vec +TIntStrPrV.sort = sort_vec +TIntStrPrV.copy = copy_vec +TIntIntStrTrV.__getitem__ = getitem_vec +TIntIntStrTrV.__setitem__ = setitem_vec +TIntIntStrTrV.__iter__ = itervec +TIntIntStrTrV.__len__ = len_vec +TIntIntStrTrV.__delitem__ = delitem_vec +TIntIntStrTrV.append = append_vec +TIntIntStrTrV.extend = extend_vec +TIntIntStrTrV.clear = clear_vec +TIntIntStrTrV.insert = insert_vec +TIntIntStrTrV.remove = remove_vec +TIntIntStrTrV.index = index_vec +TIntIntStrTrV.count = count_vec +TIntIntStrTrV.pop = pop_vec +TIntIntStrTrV.reverse = reverse_vec +TIntIntStrTrV.sort = sort_vec +TIntIntStrTrV.copy = copy_vec +TIntIntFltTrV.__getitem__ = getitem_vec +TIntIntFltTrV.__setitem__ = setitem_vec +TIntIntFltTrV.__iter__ = itervec +TIntIntFltTrV.__len__ = len_vec +TIntIntFltTrV.__delitem__ = delitem_vec +TIntIntFltTrV.append = append_vec +TIntIntFltTrV.extend = extend_vec +TIntIntFltTrV.clear = clear_vec +TIntIntFltTrV.insert = insert_vec +TIntIntFltTrV.remove = remove_vec +TIntIntFltTrV.index = index_vec +TIntIntFltTrV.count = count_vec +TIntIntFltTrV.pop = pop_vec +TIntIntFltTrV.reverse = reverse_vec +TIntIntFltTrV.sort = sort_vec +TIntIntFltTrV.copy = copy_vec +TIntFltIntTrV.__getitem__ = getitem_vec +TIntFltIntTrV.__setitem__ = setitem_vec +TIntFltIntTrV.__iter__ = itervec +TIntFltIntTrV.__len__ = len_vec +TIntFltIntTrV.__delitem__ = delitem_vec +TIntFltIntTrV.append = append_vec +TIntFltIntTrV.extend = extend_vec +TIntFltIntTrV.clear = clear_vec +TIntFltIntTrV.insert = insert_vec +TIntFltIntTrV.remove = remove_vec +TIntFltIntTrV.index = index_vec +TIntFltIntTrV.count = count_vec +TIntFltIntTrV.pop = pop_vec +TIntFltIntTrV.reverse = reverse_vec +TIntFltIntTrV.sort = sort_vec +TIntFltIntTrV.copy = copy_vec +TIntStrIntTrV.__getitem__ = getitem_vec +TIntStrIntTrV.__setitem__ = setitem_vec +TIntStrIntTrV.__iter__ = itervec +TIntStrIntTrV.__len__ = len_vec +TIntStrIntTrV.__delitem__ = delitem_vec +TIntStrIntTrV.append = append_vec +TIntStrIntTrV.extend = extend_vec +TIntStrIntTrV.clear = clear_vec +TIntStrIntTrV.insert = insert_vec +TIntStrIntTrV.remove = remove_vec +TIntStrIntTrV.index = index_vec +TIntStrIntTrV.count = count_vec +TIntStrIntTrV.pop = pop_vec +TIntStrIntTrV.reverse = reverse_vec +TIntStrIntTrV.sort = sort_vec +TIntStrIntTrV.copy = copy_vec +TUIntIntKdV.__getitem__ = getitem_vec +TUIntIntKdV.__setitem__ = setitem_vec +TUIntIntKdV.__iter__ = itervec +TUIntIntKdV.__len__ = len_vec +TUIntIntKdV.__delitem__ = delitem_vec +TUIntIntKdV.append = append_vec +TUIntIntKdV.extend = extend_vec +TUIntIntKdV.clear = clear_vec +TUIntIntKdV.insert = insert_vec +TUIntIntKdV.remove = remove_vec +TUIntIntKdV.index = index_vec +TUIntIntKdV.count = count_vec +TUIntIntKdV.pop = pop_vec +TUIntIntKdV.reverse = reverse_vec +TUIntIntKdV.sort = sort_vec +TUIntIntKdV.copy = copy_vec +TIntPrFltKdV.__getitem__ = getitem_vec +TIntPrFltKdV.__setitem__ = setitem_vec +TIntPrFltKdV.__iter__ = itervec +TIntPrFltKdV.__len__ = len_vec +TIntPrFltKdV.__delitem__ = delitem_vec +TIntPrFltKdV.append = append_vec +TIntPrFltKdV.extend = extend_vec +TIntPrFltKdV.clear = clear_vec +TIntPrFltKdV.insert = insert_vec +TIntPrFltKdV.remove = remove_vec +TIntPrFltKdV.index = index_vec +TIntPrFltKdV.count = count_vec +TIntPrFltKdV.pop = pop_vec +TIntPrFltKdV.reverse = reverse_vec +TIntPrFltKdV.sort = sort_vec +TIntPrFltKdV.copy = copy_vec +TIntStrKdV.__getitem__ = getitem_vec +TIntStrKdV.__setitem__ = setitem_vec +TIntStrKdV.__iter__ = itervec +TIntStrKdV.__len__ = len_vec +TIntStrKdV.__delitem__ = delitem_vec +TIntStrKdV.append = append_vec +TIntStrKdV.extend = extend_vec +TIntStrKdV.clear = clear_vec +TIntStrKdV.insert = insert_vec +TIntStrKdV.remove = remove_vec +TIntStrKdV.index = index_vec +TIntStrKdV.count = count_vec +TIntStrKdV.pop = pop_vec +TIntStrKdV.reverse = reverse_vec +TIntStrKdV.sort = sort_vec +TIntStrKdV.copy = copy_vec +TIntStrPrPrV.__getitem__ = getitem_vec +TIntStrPrPrV.__setitem__ = setitem_vec +TIntStrPrPrV.__iter__ = itervec +TIntStrPrPrV.__len__ = len_vec +TIntStrPrPrV.__delitem__ = delitem_vec +TIntStrPrPrV.append = append_vec +TIntStrPrPrV.extend = extend_vec +TIntStrPrPrV.clear = clear_vec +TIntStrPrPrV.insert = insert_vec +TIntStrPrPrV.remove = remove_vec +TIntStrPrPrV.index = index_vec +TIntStrPrPrV.count = count_vec +TIntStrPrPrV.pop = pop_vec +TIntStrPrPrV.reverse = reverse_vec +TIntStrPrPrV.sort = sort_vec +TIntStrPrPrV.copy = copy_vec +TIntStrVPrV.__getitem__ = getitem_vec +TIntStrVPrV.__setitem__ = setitem_vec +TIntStrVPrV.__iter__ = itervec +TIntStrVPrV.__len__ = len_vec +TIntStrVPrV.__delitem__ = delitem_vec +TIntStrVPrV.append = append_vec +TIntStrVPrV.extend = extend_vec +TIntStrVPrV.clear = clear_vec +TIntStrVPrV.insert = insert_vec +TIntStrVPrV.remove = remove_vec +TIntStrVPrV.index = index_vec +TIntStrVPrV.count = count_vec +TIntStrVPrV.pop = pop_vec +TIntStrVPrV.reverse = reverse_vec +TIntStrVPrV.sort = sort_vec +TIntStrVPrV.copy = copy_vec +TIntIntVIntTrV.__getitem__ = getitem_vec +TIntIntVIntTrV.__setitem__ = setitem_vec +TIntIntVIntTrV.__iter__ = itervec +TIntIntVIntTrV.__len__ = len_vec +TIntIntVIntTrV.__delitem__ = delitem_vec +TIntIntVIntTrV.append = append_vec +TIntIntVIntTrV.extend = extend_vec +TIntIntVIntTrV.clear = clear_vec +TIntIntVIntTrV.insert = insert_vec +TIntIntVIntTrV.remove = remove_vec +TIntIntVIntTrV.index = index_vec +TIntIntVIntTrV.count = count_vec +TIntIntVIntTrV.pop = pop_vec +TIntIntVIntTrV.reverse = reverse_vec +TIntIntVIntTrV.sort = sort_vec +TIntIntVIntTrV.copy = copy_vec +TIntIntIntVTrV.__getitem__ = getitem_vec +TIntIntIntVTrV.__setitem__ = setitem_vec +TIntIntIntVTrV.__iter__ = itervec +TIntIntIntVTrV.__len__ = len_vec +TIntIntIntVTrV.__delitem__ = delitem_vec +TIntIntIntVTrV.append = append_vec +TIntIntIntVTrV.extend = extend_vec +TIntIntIntVTrV.clear = clear_vec +TIntIntIntVTrV.insert = insert_vec +TIntIntIntVTrV.remove = remove_vec +TIntIntIntVTrV.index = index_vec +TIntIntIntVTrV.count = count_vec +TIntIntIntVTrV.pop = pop_vec +TIntIntIntVTrV.reverse = reverse_vec +TIntIntIntVTrV.sort = sort_vec +TIntIntIntVTrV.copy = copy_vec +TUInt64IntPrV.__getitem__ = getitem_vec +TUInt64IntPrV.__setitem__ = setitem_vec +TUInt64IntPrV.__iter__ = itervec +TUInt64IntPrV.__len__ = len_vec +TUInt64IntPrV.__delitem__ = delitem_vec +TUInt64IntPrV.append = append_vec +TUInt64IntPrV.extend = extend_vec +TUInt64IntPrV.clear = clear_vec +TUInt64IntPrV.insert = insert_vec +TUInt64IntPrV.remove = remove_vec +TUInt64IntPrV.index = index_vec +TUInt64IntPrV.count = count_vec +TUInt64IntPrV.pop = pop_vec +TUInt64IntPrV.reverse = reverse_vec +TUInt64IntPrV.sort = sort_vec +TUInt64IntPrV.copy = copy_vec +TUInt64FltPrV.__getitem__ = getitem_vec +TUInt64FltPrV.__setitem__ = setitem_vec +TUInt64FltPrV.__iter__ = itervec +TUInt64FltPrV.__len__ = len_vec +TUInt64FltPrV.__delitem__ = delitem_vec +TUInt64FltPrV.append = append_vec +TUInt64FltPrV.extend = extend_vec +TUInt64FltPrV.clear = clear_vec +TUInt64FltPrV.insert = insert_vec +TUInt64FltPrV.remove = remove_vec +TUInt64FltPrV.index = index_vec +TUInt64FltPrV.count = count_vec +TUInt64FltPrV.pop = pop_vec +TUInt64FltPrV.reverse = reverse_vec +TUInt64FltPrV.sort = sort_vec +TUInt64FltPrV.copy = copy_vec +TUInt64StrPrV.__getitem__ = getitem_vec +TUInt64StrPrV.__setitem__ = setitem_vec +TUInt64StrPrV.__iter__ = itervec +TUInt64StrPrV.__len__ = len_vec +TUInt64StrPrV.__delitem__ = delitem_vec +TUInt64StrPrV.append = append_vec +TUInt64StrPrV.extend = extend_vec +TUInt64StrPrV.clear = clear_vec +TUInt64StrPrV.insert = insert_vec +TUInt64StrPrV.remove = remove_vec +TUInt64StrPrV.index = index_vec +TUInt64StrPrV.count = count_vec +TUInt64StrPrV.pop = pop_vec +TUInt64StrPrV.reverse = reverse_vec +TUInt64StrPrV.sort = sort_vec +TUInt64StrPrV.copy = copy_vec +TUInt64IntKdV.__getitem__ = getitem_vec +TUInt64IntKdV.__setitem__ = setitem_vec +TUInt64IntKdV.__iter__ = itervec +TUInt64IntKdV.__len__ = len_vec +TUInt64IntKdV.__delitem__ = delitem_vec +TUInt64IntKdV.append = append_vec +TUInt64IntKdV.extend = extend_vec +TUInt64IntKdV.clear = clear_vec +TUInt64IntKdV.insert = insert_vec +TUInt64IntKdV.remove = remove_vec +TUInt64IntKdV.index = index_vec +TUInt64IntKdV.count = count_vec +TUInt64IntKdV.pop = pop_vec +TUInt64IntKdV.reverse = reverse_vec +TUInt64IntKdV.sort = sort_vec +TUInt64IntKdV.copy = copy_vec +TUInt64FltKdV.__getitem__ = getitem_vec +TUInt64FltKdV.__setitem__ = setitem_vec +TUInt64FltKdV.__iter__ = itervec +TUInt64FltKdV.__len__ = len_vec +TUInt64FltKdV.__delitem__ = delitem_vec +TUInt64FltKdV.append = append_vec +TUInt64FltKdV.extend = extend_vec +TUInt64FltKdV.clear = clear_vec +TUInt64FltKdV.insert = insert_vec +TUInt64FltKdV.remove = remove_vec +TUInt64FltKdV.index = index_vec +TUInt64FltKdV.count = count_vec +TUInt64FltKdV.pop = pop_vec +TUInt64FltKdV.reverse = reverse_vec +TUInt64FltKdV.sort = sort_vec +TUInt64FltKdV.copy = copy_vec +TUInt64StrKdV.__getitem__ = getitem_vec +TUInt64StrKdV.__setitem__ = setitem_vec +TUInt64StrKdV.__iter__ = itervec +TUInt64StrKdV.__len__ = len_vec +TUInt64StrKdV.__delitem__ = delitem_vec +TUInt64StrKdV.append = append_vec +TUInt64StrKdV.extend = extend_vec +TUInt64StrKdV.clear = clear_vec +TUInt64StrKdV.insert = insert_vec +TUInt64StrKdV.remove = remove_vec +TUInt64StrKdV.index = index_vec +TUInt64StrKdV.count = count_vec +TUInt64StrKdV.pop = pop_vec +TUInt64StrKdV.reverse = reverse_vec +TUInt64StrKdV.sort = sort_vec +TUInt64StrKdV.copy = copy_vec +TFltBoolKdV.__getitem__ = getitem_vec +TFltBoolKdV.__setitem__ = setitem_vec +TFltBoolKdV.__iter__ = itervec +TFltBoolKdV.__len__ = len_vec +TFltBoolKdV.__delitem__ = delitem_vec +TFltBoolKdV.append = append_vec +TFltBoolKdV.extend = extend_vec +TFltBoolKdV.clear = clear_vec +TFltBoolKdV.insert = insert_vec +TFltBoolKdV.remove = remove_vec +TFltBoolKdV.index = index_vec +TFltBoolKdV.count = count_vec +TFltBoolKdV.pop = pop_vec +TFltBoolKdV.reverse = reverse_vec +TFltBoolKdV.sort = sort_vec +TFltBoolKdV.copy = copy_vec +TFltIntKdV.__getitem__ = getitem_vec +TFltIntKdV.__setitem__ = setitem_vec +TFltIntKdV.__iter__ = itervec +TFltIntKdV.__len__ = len_vec +TFltIntKdV.__delitem__ = delitem_vec +TFltIntKdV.append = append_vec +TFltIntKdV.extend = extend_vec +TFltIntKdV.clear = clear_vec +TFltIntKdV.insert = insert_vec +TFltIntKdV.remove = remove_vec +TFltIntKdV.index = index_vec +TFltIntKdV.count = count_vec +TFltIntKdV.pop = pop_vec +TFltIntKdV.reverse = reverse_vec +TFltIntKdV.sort = sort_vec +TFltIntKdV.copy = copy_vec +TFltUInt64KdV.__getitem__ = getitem_vec +TFltUInt64KdV.__setitem__ = setitem_vec +TFltUInt64KdV.__iter__ = itervec +TFltUInt64KdV.__len__ = len_vec +TFltUInt64KdV.__delitem__ = delitem_vec +TFltUInt64KdV.append = append_vec +TFltUInt64KdV.extend = extend_vec +TFltUInt64KdV.clear = clear_vec +TFltUInt64KdV.insert = insert_vec +TFltUInt64KdV.remove = remove_vec +TFltUInt64KdV.index = index_vec +TFltUInt64KdV.count = count_vec +TFltUInt64KdV.pop = pop_vec +TFltUInt64KdV.reverse = reverse_vec +TFltUInt64KdV.sort = sort_vec +TFltUInt64KdV.copy = copy_vec +TFltIntPrKdV.__getitem__ = getitem_vec +TFltIntPrKdV.__setitem__ = setitem_vec +TFltIntPrKdV.__iter__ = itervec +TFltIntPrKdV.__len__ = len_vec +TFltIntPrKdV.__delitem__ = delitem_vec +TFltIntPrKdV.append = append_vec +TFltIntPrKdV.extend = extend_vec +TFltIntPrKdV.clear = clear_vec +TFltIntPrKdV.insert = insert_vec +TFltIntPrKdV.remove = remove_vec +TFltIntPrKdV.index = index_vec +TFltIntPrKdV.count = count_vec +TFltIntPrKdV.pop = pop_vec +TFltIntPrKdV.reverse = reverse_vec +TFltIntPrKdV.sort = sort_vec +TFltIntPrKdV.copy = copy_vec +TFltKdV.__getitem__ = getitem_vec +TFltKdV.__setitem__ = setitem_vec +TFltKdV.__iter__ = itervec +TFltKdV.__len__ = len_vec +TFltKdV.__delitem__ = delitem_vec +TFltKdV.append = append_vec +TFltKdV.extend = extend_vec +TFltKdV.clear = clear_vec +TFltKdV.insert = insert_vec +TFltKdV.remove = remove_vec +TFltKdV.index = index_vec +TFltKdV.count = count_vec +TFltKdV.pop = pop_vec +TFltKdV.reverse = reverse_vec +TFltKdV.sort = sort_vec +TFltKdV.copy = copy_vec +TFltStrKdV.__getitem__ = getitem_vec +TFltStrKdV.__setitem__ = setitem_vec +TFltStrKdV.__iter__ = itervec +TFltStrKdV.__len__ = len_vec +TFltStrKdV.__delitem__ = delitem_vec +TFltStrKdV.append = append_vec +TFltStrKdV.extend = extend_vec +TFltStrKdV.clear = clear_vec +TFltStrKdV.insert = insert_vec +TFltStrKdV.remove = remove_vec +TFltStrKdV.index = index_vec +TFltStrKdV.count = count_vec +TFltStrKdV.pop = pop_vec +TFltStrKdV.reverse = reverse_vec +TFltStrKdV.sort = sort_vec +TFltStrKdV.copy = copy_vec +TFltStrPrPrV.__getitem__ = getitem_vec +TFltStrPrPrV.__setitem__ = setitem_vec +TFltStrPrPrV.__iter__ = itervec +TFltStrPrPrV.__len__ = len_vec +TFltStrPrPrV.__delitem__ = delitem_vec +TFltStrPrPrV.append = append_vec +TFltStrPrPrV.extend = extend_vec +TFltStrPrPrV.clear = clear_vec +TFltStrPrPrV.insert = insert_vec +TFltStrPrPrV.remove = remove_vec +TFltStrPrPrV.index = index_vec +TFltStrPrPrV.count = count_vec +TFltStrPrPrV.pop = pop_vec +TFltStrPrPrV.reverse = reverse_vec +TFltStrPrPrV.sort = sort_vec +TFltStrPrPrV.copy = copy_vec +TFltIntIntTrV.__getitem__ = getitem_vec +TFltIntIntTrV.__setitem__ = setitem_vec +TFltIntIntTrV.__iter__ = itervec +TFltIntIntTrV.__len__ = len_vec +TFltIntIntTrV.__delitem__ = delitem_vec +TFltIntIntTrV.append = append_vec +TFltIntIntTrV.extend = extend_vec +TFltIntIntTrV.clear = clear_vec +TFltIntIntTrV.insert = insert_vec +TFltIntIntTrV.remove = remove_vec +TFltIntIntTrV.index = index_vec +TFltIntIntTrV.count = count_vec +TFltIntIntTrV.pop = pop_vec +TFltIntIntTrV.reverse = reverse_vec +TFltIntIntTrV.sort = sort_vec +TFltIntIntTrV.copy = copy_vec +TFltFltStrTrV.__getitem__ = getitem_vec +TFltFltStrTrV.__setitem__ = setitem_vec +TFltFltStrTrV.__iter__ = itervec +TFltFltStrTrV.__len__ = len_vec +TFltFltStrTrV.__delitem__ = delitem_vec +TFltFltStrTrV.append = append_vec +TFltFltStrTrV.extend = extend_vec +TFltFltStrTrV.clear = clear_vec +TFltFltStrTrV.insert = insert_vec +TFltFltStrTrV.remove = remove_vec +TFltFltStrTrV.index = index_vec +TFltFltStrTrV.count = count_vec +TFltFltStrTrV.pop = pop_vec +TFltFltStrTrV.reverse = reverse_vec +TFltFltStrTrV.sort = sort_vec +TFltFltStrTrV.copy = copy_vec +TAscFltIntPrV.__getitem__ = getitem_vec +TAscFltIntPrV.__setitem__ = setitem_vec +TAscFltIntPrV.__iter__ = itervec +TAscFltIntPrV.__len__ = len_vec +TAscFltIntPrV.__delitem__ = delitem_vec +TAscFltIntPrV.append = append_vec +TAscFltIntPrV.extend = extend_vec +TAscFltIntPrV.clear = clear_vec +TAscFltIntPrV.insert = insert_vec +TAscFltIntPrV.remove = remove_vec +TAscFltIntPrV.index = index_vec +TAscFltIntPrV.count = count_vec +TAscFltIntPrV.pop = pop_vec +TAscFltIntPrV.reverse = reverse_vec +TAscFltIntPrV.sort = sort_vec +TAscFltIntPrV.copy = copy_vec +TAscFltIntKdV.__getitem__ = getitem_vec +TAscFltIntKdV.__setitem__ = setitem_vec +TAscFltIntKdV.__iter__ = itervec +TAscFltIntKdV.__len__ = len_vec +TAscFltIntKdV.__delitem__ = delitem_vec +TAscFltIntKdV.append = append_vec +TAscFltIntKdV.extend = extend_vec +TAscFltIntKdV.clear = clear_vec +TAscFltIntKdV.insert = insert_vec +TAscFltIntKdV.remove = remove_vec +TAscFltIntKdV.index = index_vec +TAscFltIntKdV.count = count_vec +TAscFltIntKdV.pop = pop_vec +TAscFltIntKdV.reverse = reverse_vec +TAscFltIntKdV.sort = sort_vec +TAscFltIntKdV.copy = copy_vec +TStrPrV.__getitem__ = getitem_vec +TStrPrV.__setitem__ = setitem_vec +TStrPrV.__iter__ = itervec +TStrPrV.__len__ = len_vec +TStrPrV.__delitem__ = delitem_vec +TStrPrV.append = append_vec +TStrPrV.extend = extend_vec +TStrPrV.clear = clear_vec +TStrPrV.insert = insert_vec +TStrPrV.remove = remove_vec +TStrPrV.index = index_vec +TStrPrV.count = count_vec +TStrPrV.pop = pop_vec +TStrPrV.reverse = reverse_vec +TStrPrV.sort = sort_vec +TStrPrV.copy = copy_vec +TStrFltPrV.__getitem__ = getitem_vec +TStrFltPrV.__setitem__ = setitem_vec +TStrFltPrV.__iter__ = itervec +TStrFltPrV.__len__ = len_vec +TStrFltPrV.__delitem__ = delitem_vec +TStrFltPrV.append = append_vec +TStrFltPrV.extend = extend_vec +TStrFltPrV.clear = clear_vec +TStrFltPrV.insert = insert_vec +TStrFltPrV.remove = remove_vec +TStrFltPrV.index = index_vec +TStrFltPrV.count = count_vec +TStrFltPrV.pop = pop_vec +TStrFltPrV.reverse = reverse_vec +TStrFltPrV.sort = sort_vec +TStrFltPrV.copy = copy_vec +TStrIntKdV.__getitem__ = getitem_vec +TStrIntKdV.__setitem__ = setitem_vec +TStrIntKdV.__iter__ = itervec +TStrIntKdV.__len__ = len_vec +TStrIntKdV.__delitem__ = delitem_vec +TStrIntKdV.append = append_vec +TStrIntKdV.extend = extend_vec +TStrIntKdV.clear = clear_vec +TStrIntKdV.insert = insert_vec +TStrIntKdV.remove = remove_vec +TStrIntKdV.index = index_vec +TStrIntKdV.count = count_vec +TStrIntKdV.pop = pop_vec +TStrIntKdV.reverse = reverse_vec +TStrIntKdV.sort = sort_vec +TStrIntKdV.copy = copy_vec +TStrFltKdV.__getitem__ = getitem_vec +TStrFltKdV.__setitem__ = setitem_vec +TStrFltKdV.__iter__ = itervec +TStrFltKdV.__len__ = len_vec +TStrFltKdV.__delitem__ = delitem_vec +TStrFltKdV.append = append_vec +TStrFltKdV.extend = extend_vec +TStrFltKdV.clear = clear_vec +TStrFltKdV.insert = insert_vec +TStrFltKdV.remove = remove_vec +TStrFltKdV.index = index_vec +TStrFltKdV.count = count_vec +TStrFltKdV.pop = pop_vec +TStrFltKdV.reverse = reverse_vec +TStrFltKdV.sort = sort_vec +TStrFltKdV.copy = copy_vec +TStrAscFltKdV.__getitem__ = getitem_vec +TStrAscFltKdV.__setitem__ = setitem_vec +TStrAscFltKdV.__iter__ = itervec +TStrAscFltKdV.__len__ = len_vec +TStrAscFltKdV.__delitem__ = delitem_vec +TStrAscFltKdV.append = append_vec +TStrAscFltKdV.extend = extend_vec +TStrAscFltKdV.clear = clear_vec +TStrAscFltKdV.insert = insert_vec +TStrAscFltKdV.remove = remove_vec +TStrAscFltKdV.index = index_vec +TStrAscFltKdV.count = count_vec +TStrAscFltKdV.pop = pop_vec +TStrAscFltKdV.reverse = reverse_vec +TStrAscFltKdV.sort = sort_vec +TStrAscFltKdV.copy = copy_vec +TStrTrV.__getitem__ = getitem_vec +TStrTrV.__setitem__ = setitem_vec +TStrTrV.__iter__ = itervec +TStrTrV.__len__ = len_vec +TStrTrV.__delitem__ = delitem_vec +TStrTrV.append = append_vec +TStrTrV.extend = extend_vec +TStrTrV.clear = clear_vec +TStrTrV.insert = insert_vec +TStrTrV.remove = remove_vec +TStrTrV.index = index_vec +TStrTrV.count = count_vec +TStrTrV.pop = pop_vec +TStrTrV.reverse = reverse_vec +TStrTrV.sort = sort_vec +TStrTrV.copy = copy_vec +TStrQuV.__getitem__ = getitem_vec +TStrQuV.__setitem__ = setitem_vec +TStrQuV.__iter__ = itervec +TStrQuV.__len__ = len_vec +TStrQuV.__delitem__ = delitem_vec +TStrQuV.append = append_vec +TStrQuV.extend = extend_vec +TStrQuV.clear = clear_vec +TStrQuV.insert = insert_vec +TStrQuV.remove = remove_vec +TStrQuV.index = index_vec +TStrQuV.count = count_vec +TStrQuV.pop = pop_vec +TStrQuV.reverse = reverse_vec +TStrQuV.sort = sort_vec +TStrQuV.copy = copy_vec +TStrFltFltTrV.__getitem__ = getitem_vec +TStrFltFltTrV.__setitem__ = setitem_vec +TStrFltFltTrV.__iter__ = itervec +TStrFltFltTrV.__len__ = len_vec +TStrFltFltTrV.__delitem__ = delitem_vec +TStrFltFltTrV.append = append_vec +TStrFltFltTrV.extend = extend_vec +TStrFltFltTrV.clear = clear_vec +TStrFltFltTrV.insert = insert_vec +TStrFltFltTrV.remove = remove_vec +TStrFltFltTrV.index = index_vec +TStrFltFltTrV.count = count_vec +TStrFltFltTrV.pop = pop_vec +TStrFltFltTrV.reverse = reverse_vec +TStrFltFltTrV.sort = sort_vec +TStrFltFltTrV.copy = copy_vec +TStrStrIntTrV.__getitem__ = getitem_vec +TStrStrIntTrV.__setitem__ = setitem_vec +TStrStrIntTrV.__iter__ = itervec +TStrStrIntTrV.__len__ = len_vec +TStrStrIntTrV.__delitem__ = delitem_vec +TStrStrIntTrV.append = append_vec +TStrStrIntTrV.extend = extend_vec +TStrStrIntTrV.clear = clear_vec +TStrStrIntTrV.insert = insert_vec +TStrStrIntTrV.remove = remove_vec +TStrStrIntTrV.index = index_vec +TStrStrIntTrV.count = count_vec +TStrStrIntTrV.pop = pop_vec +TStrStrIntTrV.reverse = reverse_vec +TStrStrIntTrV.sort = sort_vec +TStrStrIntTrV.copy = copy_vec +TStrKdV.__getitem__ = getitem_vec +TStrKdV.__setitem__ = setitem_vec +TStrKdV.__iter__ = itervec +TStrKdV.__len__ = len_vec +TStrKdV.__delitem__ = delitem_vec +TStrKdV.append = append_vec +TStrKdV.extend = extend_vec +TStrKdV.clear = clear_vec +TStrKdV.insert = insert_vec +TStrKdV.remove = remove_vec +TStrKdV.index = index_vec +TStrKdV.count = count_vec +TStrKdV.pop = pop_vec +TStrKdV.reverse = reverse_vec +TStrKdV.sort = sort_vec +TStrKdV.copy = copy_vec +TStrStrVPrV.__getitem__ = getitem_vec +TStrStrVPrV.__setitem__ = setitem_vec +TStrStrVPrV.__iter__ = itervec +TStrStrVPrV.__len__ = len_vec +TStrStrVPrV.__delitem__ = delitem_vec +TStrStrVPrV.append = append_vec +TStrStrVPrV.extend = extend_vec +TStrStrVPrV.clear = clear_vec +TStrStrVPrV.insert = insert_vec +TStrStrVPrV.remove = remove_vec +TStrStrVPrV.index = index_vec +TStrStrVPrV.count = count_vec +TStrStrVPrV.pop = pop_vec +TStrStrVPrV.reverse = reverse_vec +TStrStrVPrV.sort = sort_vec +TStrStrVPrV.copy = copy_vec +TStrVIntPrV.__getitem__ = getitem_vec +TStrVIntPrV.__setitem__ = setitem_vec +TStrVIntPrV.__iter__ = itervec +TStrVIntPrV.__len__ = len_vec +TStrVIntPrV.__delitem__ = delitem_vec +TStrVIntPrV.append = append_vec +TStrVIntPrV.extend = extend_vec +TStrVIntPrV.clear = clear_vec +TStrVIntPrV.insert = insert_vec +TStrVIntPrV.remove = remove_vec +TStrVIntPrV.index = index_vec +TStrVIntPrV.count = count_vec +TStrVIntPrV.pop = pop_vec +TStrVIntPrV.reverse = reverse_vec +TStrVIntPrV.sort = sort_vec +TStrVIntPrV.copy = copy_vec +TFltIntIntIntQuV.__getitem__ = getitem_vec +TFltIntIntIntQuV.__setitem__ = setitem_vec +TFltIntIntIntQuV.__iter__ = itervec +TFltIntIntIntQuV.__len__ = len_vec +TFltIntIntIntQuV.__delitem__ = delitem_vec +TFltIntIntIntQuV.append = append_vec +TFltIntIntIntQuV.extend = extend_vec +TFltIntIntIntQuV.clear = clear_vec +TFltIntIntIntQuV.insert = insert_vec +TFltIntIntIntQuV.remove = remove_vec +TFltIntIntIntQuV.index = index_vec +TFltIntIntIntQuV.count = count_vec +TFltIntIntIntQuV.pop = pop_vec +TFltIntIntIntQuV.reverse = reverse_vec +TFltIntIntIntQuV.sort = sort_vec +TFltIntIntIntQuV.copy = copy_vec +TIntStrIntIntQuV.__getitem__ = getitem_vec +TIntStrIntIntQuV.__setitem__ = setitem_vec +TIntStrIntIntQuV.__iter__ = itervec +TIntStrIntIntQuV.__len__ = len_vec +TIntStrIntIntQuV.__delitem__ = delitem_vec +TIntStrIntIntQuV.append = append_vec +TIntStrIntIntQuV.extend = extend_vec +TIntStrIntIntQuV.clear = clear_vec +TIntStrIntIntQuV.insert = insert_vec +TIntStrIntIntQuV.remove = remove_vec +TIntStrIntIntQuV.index = index_vec +TIntStrIntIntQuV.count = count_vec +TIntStrIntIntQuV.pop = pop_vec +TIntStrIntIntQuV.reverse = reverse_vec +TIntStrIntIntQuV.sort = sort_vec +TIntStrIntIntQuV.copy = copy_vec +TIntIntPrPrV.__getitem__ = getitem_vec +TIntIntPrPrV.__setitem__ = setitem_vec +TIntIntPrPrV.__iter__ = itervec +TIntIntPrPrV.__len__ = len_vec +TIntIntPrPrV.__delitem__ = delitem_vec +TIntIntPrPrV.append = append_vec +TIntIntPrPrV.extend = extend_vec +TIntIntPrPrV.clear = clear_vec +TIntIntPrPrV.insert = insert_vec +TIntIntPrPrV.remove = remove_vec +TIntIntPrPrV.index = index_vec +TIntIntPrPrV.count = count_vec +TIntIntPrPrV.pop = pop_vec +TIntIntPrPrV.reverse = reverse_vec +TIntIntPrPrV.sort = sort_vec +TIntIntPrPrV.copy = copy_vec +PFltV.__getitem__ = getitem_vec +PFltV.__setitem__ = setitem_vec +PFltV.__iter__ = itervec +PFltV.__len__ = len_vec +PFltV.__delitem__ = delitem_vec +PFltV.append = append_vec +PFltV.extend = extend_vec +PFltV.clear = clear_vec +PFltV.insert = insert_vec +PFltV.remove = remove_vec +PFltV.index = index_vec +PFltV.count = count_vec +PFltV.pop = pop_vec +PFltV.reverse = reverse_vec +PFltV.sort = sort_vec +PFltV.copy = copy_vec +PAscFltV.__getitem__ = getitem_vec +PAscFltV.__setitem__ = setitem_vec +PAscFltV.__iter__ = itervec +PAscFltV.__len__ = len_vec +PAscFltV.__delitem__ = delitem_vec +PAscFltV.append = append_vec +PAscFltV.extend = extend_vec +PAscFltV.clear = clear_vec +PAscFltV.insert = insert_vec +PAscFltV.remove = remove_vec +PAscFltV.index = index_vec +PAscFltV.count = count_vec +PAscFltV.pop = pop_vec +PAscFltV.reverse = reverse_vec +PAscFltV.sort = sort_vec +PAscFltV.copy = copy_vec +PStrV.__getitem__ = getitem_vec +PStrV.__setitem__ = setitem_vec +PStrV.__iter__ = itervec +PStrV.__len__ = len_vec +PStrV.__delitem__ = delitem_vec +PStrV.append = append_vec +PStrV.extend = extend_vec +PStrV.clear = clear_vec +PStrV.insert = insert_vec +PStrV.remove = remove_vec +PStrV.index = index_vec +PStrV.count = count_vec +PStrV.pop = pop_vec +PStrV.reverse = reverse_vec +PStrV.sort = sort_vec +PStrV.copy = copy_vec +TBoolVV.__getitem__ = getitem_vec +TBoolVV.__setitem__ = setitem_vec +TBoolVV.__iter__ = itervec +TBoolVV.__len__ = len_vec +TBoolVV.__delitem__ = delitem_vec +TBoolVV.append = append_vec +TBoolVV.extend = extend_vec +TBoolVV.clear = clear_vec +TBoolVV.insert = insert_vec +TBoolVV.remove = remove_vec +TBoolVV.index = index_vec +TBoolVV.count = count_vec +TBoolVV.pop = pop_vec +TBoolVV.reverse = reverse_vec +TBoolVV.sort = sort_vec +TBoolVV.copy = copy_vec +TChVV.__getitem__ = getitem_vec +TChVV.__setitem__ = setitem_vec +TChVV.__iter__ = itervec +TChVV.__len__ = len_vec +TChVV.__delitem__ = delitem_vec +TChVV.append = append_vec +TChVV.extend = extend_vec +TChVV.clear = clear_vec +TChVV.insert = insert_vec +TChVV.remove = remove_vec +TChVV.index = index_vec +TChVV.count = count_vec +TChVV.pop = pop_vec +TChVV.reverse = reverse_vec +TChVV.sort = sort_vec +TChVV.copy = copy_vec +TIntVV.__getitem__ = getitem_vec +TIntVV.__setitem__ = setitem_vec +TIntVV.__iter__ = itervec +TIntVV.__len__ = len_vec +TIntVV.__delitem__ = delitem_vec +TIntVV.append = append_vec +TIntVV.extend = extend_vec +TIntVV.clear = clear_vec +TIntVV.insert = insert_vec +TIntVV.remove = remove_vec +TIntVV.index = index_vec +TIntVV.count = count_vec +TIntVV.pop = pop_vec +TIntVV.reverse = reverse_vec +TIntVV.sort = sort_vec +TIntVV.copy = copy_vec +TSFltVV.__getitem__ = getitem_vec +TSFltVV.__setitem__ = setitem_vec +TSFltVV.__iter__ = itervec +TSFltVV.__len__ = len_vec +TSFltVV.__delitem__ = delitem_vec +TSFltVV.append = append_vec +TSFltVV.extend = extend_vec +TSFltVV.clear = clear_vec +TSFltVV.insert = insert_vec +TSFltVV.remove = remove_vec +TSFltVV.index = index_vec +TSFltVV.count = count_vec +TSFltVV.pop = pop_vec +TSFltVV.reverse = reverse_vec +TSFltVV.sort = sort_vec +TSFltVV.copy = copy_vec +TFltVV.__getitem__ = getitem_vec +TFltVV.__setitem__ = setitem_vec +TFltVV.__iter__ = itervec +TFltVV.__len__ = len_vec +TFltVV.__delitem__ = delitem_vec +TFltVV.append = append_vec +TFltVV.extend = extend_vec +TFltVV.clear = clear_vec +TFltVV.insert = insert_vec +TFltVV.remove = remove_vec +TFltVV.index = index_vec +TFltVV.count = count_vec +TFltVV.pop = pop_vec +TFltVV.reverse = reverse_vec +TFltVV.sort = sort_vec +TFltVV.copy = copy_vec +TStrVV.__getitem__ = getitem_vec +TStrVV.__setitem__ = setitem_vec +TStrVV.__iter__ = itervec +TStrVV.__len__ = len_vec +TStrVV.__delitem__ = delitem_vec +TStrVV.append = append_vec +TStrVV.extend = extend_vec +TStrVV.clear = clear_vec +TStrVV.insert = insert_vec +TStrVV.remove = remove_vec +TStrVV.index = index_vec +TStrVV.count = count_vec +TStrVV.pop = pop_vec +TStrVV.reverse = reverse_vec +TStrVV.sort = sort_vec +TStrVV.copy = copy_vec +TIntPrVV.__getitem__ = getitem_vec +TIntPrVV.__setitem__ = setitem_vec +TIntPrVV.__iter__ = itervec +TIntPrVV.__len__ = len_vec +TIntPrVV.__delitem__ = delitem_vec +TIntPrVV.append = append_vec +TIntPrVV.extend = extend_vec +TIntPrVV.clear = clear_vec +TIntPrVV.insert = insert_vec +TIntPrVV.remove = remove_vec +TIntPrVV.index = index_vec +TIntPrVV.count = count_vec +TIntPrVV.pop = pop_vec +TIntPrVV.reverse = reverse_vec +TIntPrVV.sort = sort_vec +TIntPrVV.copy = copy_vec +TIntVVV.__getitem__ = getitem_vec +TIntVVV.__setitem__ = setitem_vec +TIntVVV.__iter__ = itervec +TIntVVV.__len__ = len_vec +TIntVVV.__delitem__ = delitem_vec +TIntVVV.append = append_vec +TIntVVV.extend = extend_vec +TIntVVV.clear = clear_vec +TIntVVV.insert = insert_vec +TIntVVV.remove = remove_vec +TIntVVV.index = index_vec +TIntVVV.count = count_vec +TIntVVV.pop = pop_vec +TIntVVV.reverse = reverse_vec +TIntVVV.sort = sort_vec +TIntVVV.copy = copy_vec +TFltVVV.__getitem__ = getitem_vec +TFltVVV.__setitem__ = setitem_vec +TFltVVV.__iter__ = itervec +TFltVVV.__len__ = len_vec +TFltVVV.__delitem__ = delitem_vec +TFltVVV.append = append_vec +TFltVVV.extend = extend_vec +TFltVVV.clear = clear_vec +TFltVVV.insert = insert_vec +TFltVVV.remove = remove_vec +TFltVVV.index = index_vec +TFltVVV.count = count_vec +TFltVVV.pop = pop_vec +TFltVVV.reverse = reverse_vec +TFltVVV.sort = sort_vec +TFltVVV.copy = copy_vec +%} +#endif + diff --git a/snap-python/source/swig/update_dynlib.sh b/snap-python/source/swig/update_dynlib.sh new file mode 100644 index 0000000000000000000000000000000000000000..c75a1aaba2f2287e1016d1cf5d800c2c2c05d5e1 --- /dev/null +++ b/snap-python/source/swig/update_dynlib.sh @@ -0,0 +1,46 @@ +# +# The script updates the dynamic library in _snap.so +# for a non-system Python, such as Anaconda or Homebrew +# +# Usage: +# update_dynlib.sh +# + +ORIG_PATH=/System/Library/Frameworks/Python.framework/Versions/2.7/Python +if [ "$2" = "3" ]; then + ORIG_PATH=/usr/local/opt/python/Frameworks/Python.framework/Versions/3.7/Python +fi + +LIB_NAME=_snap.so +BACKUP_NAME=_snap-bak.so + +# test for a non-empty parameter +if test -z "$1"; then + echo "*** Usage: update_dynlib.sh " + exit 42 +fi + +NEW_PATH=$1 + +if [ "$ORIG_PATH" = "$NEW_PATH" ]; then + echo "exiting, the new path is the same as the current one" $ORIG_PATH $NEW_PATH + exit 0 +fi + +# create a backup copy, if it does not yet exist +if [ ! -f $BACKUP_NAME ]; then + echo "creating a backup copy" $BACKUP_NAME "..." + cp -a $LIB_NAME $BACKUP_NAME +fi + +# take a fresh copy from backup +echo "getting a new copy of" $LIB_NAME "from" $BACKUP_NAME "..." +cp -a $BACKUP_NAME $LIB_NAME + +# change the Python library path +echo "current Python library path is" $ORIG_PATH +echo "changing the Python library path to" $NEW_PATH "..." +./install_name_tool -change $ORIG_PATH $NEW_PATH $LIB_NAME + +exit 0 + diff --git a/snap-python/source/test/Makefile b/snap-python/source/test/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..6ff69a208fc24339a7623fa3fe2e60fdb6e20fca --- /dev/null +++ b/snap-python/source/test/Makefile @@ -0,0 +1,24 @@ +# +# Makefile for running +# +PYTHON=python +PYTHONPATH=../swig + +test: TestAll + +all: tneanet epinions + +TestAll: + cp ../swig/_snap.so . + cp ../swig/snap.py . + ./test-snappy.sh + +epinions: + $(PYTHON) printstat.py data/p2p-Gnutella08.txt epinions + +tneanet: + $(PYTHON) tneanet.py + +clean: + rm -f test.graph *.txt *.html + diff --git a/snap-python/source/test/adjlist.py b/snap-python/source/test/adjlist.py new file mode 100644 index 0000000000000000000000000000000000000000..545a64c7f65862196de2bebc1a82b6756e666511 --- /dev/null +++ b/snap-python/source/test/adjlist.py @@ -0,0 +1,104 @@ +import random +import os +import sys +import time + +sys.path.append("../swig") +import snap as Snap + +numnodes = 100 +valrange = numnodes / 10 + +Edges = Snap.TIntV() + +for i in range(0,numnodes): + Edges.Add(int(random.random() * valrange)) + +d = {} +for i in range(0,numnodes,2): + print("Edges", i/2, Edges.GetVal(i).Val, Edges.GetVal(i+1).Val) + d[(Edges.GetVal(i).Val,Edges.GetVal(i+1).Val)] = 1 + +Hash = Snap.TIntH() +print("type", type(Edges), type(Hash)) +Snap.Edge2Hash(Edges,Hash) + +for i in range(0,valrange): + Vec2 = Hash.GetDat(i) + print(i, Vec2.Val) + +AdjLists = Snap.TIntIntVH() +print("type", type(Edges), type(AdjLists)) +Snap.GetAdjLists(Edges, AdjLists) + +size = 0 +for i in range(0,valrange): + Vec2 = AdjLists.GetDat(i) + size += Vec2.Len() + + for j in range(0,Vec2.Len()): + print(i, Vec2.GetVal(j).Val) + +print("done", Edges.Len(), AdjLists.Len(), size, len(d)) + + +sys.exit(0) + +#print("dir(Snap.TIntV)", dir(Snap.TIntV)) +Vec1 = Snap.TIntV(numnodes) +#print("dir(Vec1)", dir(Vec1)) +print("Len Vec1", Vec1.Len()) + +#print("dir(Snap.TIntIntVV)", dir(Snap.TIntIntVV)) +Vec2 = Snap.TIntIntVV(numtask) +#print("dir(Vec2)", dir(Vec2)) +print("Len Vec2", Vec2.Len()) + +print("Vec1", type(Vec1)) + +Snap.GetDegrees(Vec1, 10.0, 1.5) + +for i in range(0,Vec1.Len()): + print("Vec1", i, Vec1.GetVal(i).Val) + +Snap.AssignRndTask(Vec1, Vec2) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print("Vec3", i, Vec3.Len()) + + for j in range(0,Vec3.Len()): + print("Vec4", i, j, Vec3.GetVal(j).Val) + +sys.exit(0) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print("Vec3", i, Vec3.Len()) + + h = httplib.HTTPConnection("rokl1.stanford.edu",8100) + #h.request("POST","/msg/GenStubs-0/GenTasks-2","12345",{"User-agent": "007"}) + h.connect() + url = "/msg/GenStubs-0/GenTasks-%d" % (i) + h.putrequest("POST",url) + h.putheader("User-Agent", "007") + #h.putheader("Content-Length", "9") + h.putheader("Content-Length", str(Vec3.GetMemSize())) + h.endheaders() + + fileno = h.sock.fileno() + print("fileno", fileno) + + n = Vec3.Send(fileno) + #n = os.write(fileno,"123abcdef") + print(n) + + #h.send("abc123") + + res = h.getresponse() + print(res.status, res.reason) + data = res.read() + print(len(data)) + print(data) + + diff --git a/snap-python/source/test/attributes.py b/snap-python/source/test/attributes.py new file mode 100644 index 0000000000000000000000000000000000000000..a572065496ff07d065c330a0c1f35eb58dfc314f --- /dev/null +++ b/snap-python/source/test/attributes.py @@ -0,0 +1,41 @@ +import snap + +nodes = 10 +G = snap.GenFull(snap.PNEANet,nodes) + +# define int, float and str attributes on nodes +G.AddIntAttrN("NValInt", 0) +G.AddFltAttrN("NValFlt", 0.0) +G.AddStrAttrN("NValStr", "0") + +# define an int attribute on edges +G.AddIntAttrE("EValInt", 0) + +# add attribute values, node ID for nodes, edge ID for edges + +for NI in G.Nodes(): + nid = NI.GetId() + val = nid + G.AddIntAttrDatN(nid, val, "NValInt") + G.AddFltAttrDatN(nid, float(val), "NValFlt") + G.AddStrAttrDatN(nid, str(val), "NValStr") + + for nid1 in NI.GetOutEdges(): + eid = G.GetEId(nid,nid1) + val = eid + G.AddIntAttrDatE(eid, val, "EValInt") + +# print(out attribute values) + +for NI in G.Nodes(): + nid = NI.GetId() + ival = G.GetIntAttrDatN(nid, "NValInt") + fval = G.GetFltAttrDatN(nid, "NValFlt") + sval = G.GetStrAttrDatN(nid, "NValStr") + print("node %d, NValInt %d, NValFlt %.2f, NValStr %s" % (nid, ival, fval, sval)) + + for nid1 in NI.GetOutEdges(): + eid = G.GetEId(nid, nid1) + val = G.GetIntAttrDatE(eid, "EValInt") + print("edge %d (%d,%d), EValInt %d" % (eid, nid, nid1, val)) + diff --git a/snap-python/source/test/attrtest.py b/snap-python/source/test/attrtest.py new file mode 100644 index 0000000000000000000000000000000000000000..96b884bbc51b54aa9c615e54eadb1d2729b02662 --- /dev/null +++ b/snap-python/source/test/attrtest.py @@ -0,0 +1,29 @@ +import snap + +#print(snap.Version) + +#G = snap.LoadEdgeList(snap.PNEANet, "g1.edgelist", 0, 1) +#G.AddIntAttrN("NValInt", 0) +#print(G.GetIntAttrDatN(1, "NValInt")) +#G.AddIntAttrDatN(1, 10, "NValInt") +#print(G.GetIntAttrDatN(1, "NValInt")) + +g1 = snap.LoadEdgeList(snap.PNEANet, "data/g1.edgelist") + +g1.AddIntAttrN("NValInt", 55) + +nids = sorted([node.GetId() for node in g1.Nodes()]) + +print(g1.GetIntAttrDatN(nids[0], "NValInt")) +print(g1.GetIntAttrDatN(nids[1], "NValInt")) +print(g1.GetIntAttrDatN(nids[2], "NValInt")) + +g1.AddIntAttrDatN(nids[0], 42, "NValInt") +g1.AddIntAttrDatN(nids[1], 42, "NValInt") +g1.AddIntAttrDatN(nids[2], 42, "NValInt") +print(g1.GetIntAttrDatN(nids[0], "NValInt")) +print(g1.GetIntAttrDatN(nids[1], "NValInt")) +print(g1.GetIntAttrDatN(nids[2], "NValInt")) + +print(snap.Version) + diff --git a/snap-python/source/test/bfs.py b/snap-python/source/test/bfs.py new file mode 100644 index 0000000000000000000000000000000000000000..f192d1acc2a41902d9aac628bf3bdabc58bbe9d9 --- /dev/null +++ b/snap-python/source/test/bfs.py @@ -0,0 +1,45 @@ +import snap + +class BfsTreeDirectedGraphTest: + def __init__(self): + g = snap.PNGraph.New() + for i in range(5): + g.AddNode(i) + g.AddEdge(0, 1) + g.AddEdge(1, 2) + g.AddEdge(1, 3) + g.AddEdge(2, 4) + self.g = g + + def createBfsFollowingOutLinks(self): + bfs_graph = snap.GetBfsTree(self.g, 1, True, False) + expected_mapping = {1: [2, 3], 2: [4]} + self.verify(bfs_graph, expected_mapping, 3) + + def createBfsFollowingInLinks(self): + bfs_graph = snap.GetBfsTree(self.g, 1, False, True) + expected_mapping = {1: [0]} + self.verify(bfs_graph, expected_mapping, 1) + + def createBfsFollowingOutAndInLinks(self): + bfs_graph = snap.GetBfsTree(self.g, 1, True, True) + expected_mapping = {1: [0,2,3], 2:[4]} + self.verify(bfs_graph, expected_mapping, 4) + + def createBfsFollowingNoLinks(self): + bfs_graph = snap.GetBfsTree(self.g, 1, False, False) + expected_mapping = {} + self.verify(bfs_graph, expected_mapping, 0) + + def verify(self, bfs_graph, expected_mapping, expected_edge_count): + assert len(list(bfs_graph.Edges())) == expected_edge_count + for edge in bfs_graph.Edges(): + assert edge.GetDstNId() in expected_mapping.get(edge.GetSrcNId()) + +if __name__ == '__main__': + test = BfsTreeDirectedGraphTest() + test.createBfsFollowingOutLinks() + test.createBfsFollowingInLinks() + test.createBfsFollowingNoLinks() + test.createBfsFollowingOutAndInLinks() + diff --git a/snap-python/source/test/bug-2015-130-GetRndNI.py b/snap-python/source/test/bug-2015-130-GetRndNI.py new file mode 100644 index 0000000000000000000000000000000000000000..69e742c58701d9ffeb556d9958fcdbce350ec5fe --- /dev/null +++ b/snap-python/source/test/bug-2015-130-GetRndNI.py @@ -0,0 +1,8 @@ +import snap + +G = snap.GenFull(snap.PNEANet, 100) +NI = G.GetRndNI() + +# result is not well formed, the following statement fails +print(NI.GetId()) + diff --git a/snap-python/source/test/bug-2015-18-attr.py b/snap-python/source/test/bug-2015-18-attr.py new file mode 100644 index 0000000000000000000000000000000000000000..5c2cf41a079ac77881a1fe94ca6baabb15d184d7 --- /dev/null +++ b/snap-python/source/test/bug-2015-18-attr.py @@ -0,0 +1,39 @@ +import snap + +Gnea = snap.TNEANet.New() # Create an empty graph +Gnea.AddStrAttrN('name') # Add a node attribute "name" + +# this code fails +# if works, if the attribute definition is moved to after edges are added +Gnea.AddIntAttrE('weight') # Add an edge attribute "weight" + +# Add some nodes +Gnea.AddNode(0) +Gnea.AddNode(1) +Gnea.AddNode(2) + +# Fill in the attribute "name" +Gnea.AddStrAttrDatN(0, 'zero', 'name') +Gnea.AddStrAttrDatN(1, 'one', 'name') +Gnea.AddStrAttrDatN(2, 'two', 'name') + +# Retrieve attribute "name" +Gnea.GetStrAttrDatN(0, 'name') +Gnea.GetStrAttrDatN(1, 'name') +Gnea.GetStrAttrDatN(2, 'name') + +# Add some edges +Gnea.AddEdge(0, 1, -1) +Gnea.AddEdge(1, 2, -1) +Gnea.AddEdge(2, 0, -1) + +#Gnea.AddIntAttrE('weight') # Add an edge attribute "weight" + +# Fill in the edge attribute "weight" +for x in Gnea.Edges(): + Gnea.AddIntAttrDatE(x.GetId(), x.GetId()*3+1, 'weight') + +# Retrieve the attribute "weight" +for x in Gnea.Edges(): + print(Gnea.GetIntAttrDatE(x.GetId(), 'weight')) + diff --git a/snap-python/source/test/bug-20150706-pagerank.py b/snap-python/source/test/bug-20150706-pagerank.py new file mode 100644 index 0000000000000000000000000000000000000000..a9ef16f87d413d66440269ca6eb79b7e4f065f90 --- /dev/null +++ b/snap-python/source/test/bug-20150706-pagerank.py @@ -0,0 +1,8 @@ +import snap + +Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) +PRankH = snap.TIntFltH() +snap.GetPageRank(Graph, PRankH) + +snap.GetPageRank(Graph, PRankH, C=0.85) + diff --git a/snap-python/source/test/bug-328-cnm.py b/snap-python/source/test/bug-328-cnm.py new file mode 100644 index 0000000000000000000000000000000000000000..7dd3e929ddeade88ababec87d888fc01716a9963 --- /dev/null +++ b/snap-python/source/test/bug-328-cnm.py @@ -0,0 +1,7 @@ +import snap + +g = snap.LoadEdgeList(snap.PUNGraph, 'data/final_sorted_edges.txt', 0, 1) +CmtyV = snap.TCnComV() + +modularity = snap.CommunityCNM(g, CmtyV) +print(modularity) diff --git a/snap-python/source/test/bug-585-genrndpowerlaw.py b/snap-python/source/test/bug-585-genrndpowerlaw.py new file mode 100644 index 0000000000000000000000000000000000000000..3889d6e5f5c637ec16ca48db10b1918719c992a2 --- /dev/null +++ b/snap-python/source/test/bug-585-genrndpowerlaw.py @@ -0,0 +1,10 @@ +import snap + +# this fails +G = snap.GenRndPowerLaw(1000, 1.374, True) +print("True works!") + +# this works +G = snap.GenRndPowerLaw(1000, 1.374, False) +print("False works!") + diff --git a/snap-python/source/test/bug-AddFltAttrN.py b/snap-python/source/test/bug-AddFltAttrN.py new file mode 100644 index 0000000000000000000000000000000000000000..5233cfe87bb8f29a4f0a0fa9bf132e4dfbc7905a --- /dev/null +++ b/snap-python/source/test/bug-AddFltAttrN.py @@ -0,0 +1,14 @@ +import snap +G = snap.GenFull(snap.PNEANet, 1) +G.AddFltAttrN("NValFlt", 0.0) +G.AddFltAttrN("NValFlt2", 0.0) +G.AddFltAttrN("NValFlt3", 0.0) +nid = G.GetNI(0) +G.AddFltAttrDatN(nid, float(1), "NValFlt") +G.AddFltAttrDatN(nid, float(5), "NValFlt2") +G.AddFltAttrDatN(nid, float(10), "NValFlt3") +fval = G.GetFltAttrDatN(nid, "NValFlt") +fval2 = G.GetFltAttrDatN(nid, "NValFlt2") +fval3 = G.GetFltAttrDatN(nid, "NValFlt3") +print(fval, fval2, fval3) # prints 10.0, 10.0, 10.0 instead of 1.0, 5.0, 10.0 + diff --git a/snap-python/source/test/bug-attr-mem.py b/snap-python/source/test/bug-attr-mem.py new file mode 100644 index 0000000000000000000000000000000000000000..bdc8079eff8d89b3f2369de8ae89ec0df268736b --- /dev/null +++ b/snap-python/source/test/bug-attr-mem.py @@ -0,0 +1,149 @@ +#!/usr/bin/python + +# +# the memory keeps growing while traversing the graph +# find out why this is happening +# + +import os, sys +sys.path.append('/home/user/snap-python/swig') +import snap as sn +import numpy as np +import memory_profiler +import gc + +def writeLoop(graph): + nID = graph.BegNI() + while nID < graph.EndNI(): + #write attribute + graph.AddFltAttrDatN(nID,np.random.random(1),'attr') + nID.Next() + return graph + +def readLoop(graph): + NI = graph.BegNAFltI('attr') + while NI < graph.EndNAFltI('attr'): + NI.GetDat() + NI.Next() + return graph + +@profile +def repeatChangeAttr(graph): + for i in range(1,10): + writeLoop(graph) + #graph = writeLoop(graph) + for i in range(1,10): + readLoop(graph) + #graph = readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + readLoop(graph) + +graph = sn.TNEANet() +#graph.AddFltAttrN("attr", 1.) +for i in range(1000): + graph.AddNode(i) +repeatChangeAttr(graph) + diff --git a/snap-python/source/test/cncom.py b/snap-python/source/test/cncom.py new file mode 100644 index 0000000000000000000000000000000000000000..62dca2818475b0a09d13015379e00a7d6dc6dc8d --- /dev/null +++ b/snap-python/source/test/cncom.py @@ -0,0 +1,51 @@ +import snap + +# create a random directed graph +G = snap.GenRndGnm(snap.PNGraph, 10000, 5000) + +# test if the graph is connected or weakly connected +print("IsConnected(G) =", snap.IsConnected(G)) +print("IsWeaklyConnected(G) =", snap.IsWeaklyConn(G)) + +# get the weakly connected component counts +WccSzCnt = snap.TIntPrV() +snap.GetWccSzCnt(G, WccSzCnt) +for i in range (0, WccSzCnt.Len()): + print("WccSzCnt[%d] = (%d, %d)" % ( + i, WccSzCnt[i].Val1.Val, WccSzCnt[i].Val2.Val)) + +# return nodes in the same weakly connected component as node 1 +CnCom = snap.TIntV() +snap.GetNodeWcc(G, 1, CnCom) +print("CnCom.Len() = %d" % (CnCom.Len())) + +# get nodes in weakly connected components +WCnComV = snap.TCnComV() +snap.GetWccs(G, WCnComV) +for i in range(0, WCnComV.Len()): + print("WCnComV[%d].Len() = %d" % (i, WCnComV[i].Len())) + for j in range (0, WCnComV[i].Len()): + print("WCnComV[%d][%d] = %d" % (i, j, WCnComV[i][j])) + +# get the size of the maximum weakly connected component +MxWccSz = snap.GetMxWccSz(G); +print("MxWccSz = %.5f" % (MxWccSz)) + +# get the graph with the largest weakly connected component +GMx = snap.GetMxWcc(G); +print("GMx: GetNodes() = %d, GetEdges() = %d" % ( + GMx.GetNodes(), GMx.GetEdges())) + +# get strongly connected components +SCnComV = snap.TCnComV() +snap.GetSccs(G, SCnComV) +for i in range(0, SCnComV.Len()): + print("SCnComV[%d].Len() = %d" % (i, SCnComV[i].Len())) + +# get the graph representing the largest bi-connected component +GMxBi = snap.GetMxBiCon(G) +print("GMxBi: GetNodes() = %d, GetEdges() = %d" % ( + GMxBi.GetNodes(), GMxBi.GetEdges())) + + + diff --git a/snap-python/source/test/cpm_communities.py b/snap-python/source/test/cpm_communities.py new file mode 100644 index 0000000000000000000000000000000000000000..fdaa4b814205c95256df63aff20087fe9088e422 --- /dev/null +++ b/snap-python/source/test/cpm_communities.py @@ -0,0 +1,32 @@ +# +# clique percolation method for community detection +# + +import sys + +import snap + +def cmp(gname, size): + G = snap.LoadEdgeList(snap.PUNGraph, gname, 0, 1) + print("G: Nodes %d, Edges %d" % (G.GetNodes(), G.GetEdges())) + + Communities = snap.TIntIntVV() + snap.TCliqueOverlap_GetCPMCommunities(G, size, Communities) + + print("---------------") + for C in Communities: + for I in C: + print(I) + print("---------------") + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print("Usage: " + sys.argv[0] + " ") + sys.exit(1) + + gname = sys.argv[1] + size = int(sys.argv[2]) + + cmp(gname, size) + diff --git a/snap-python/source/test/data/cooccurrence.txt b/snap-python/source/test/data/cooccurrence.txt new file mode 100644 index 0000000000000000000000000000000000000000..29508911fb49bc3260efa166794a530557ff007a --- /dev/null +++ b/snap-python/source/test/data/cooccurrence.txt @@ -0,0 +1,45 @@ +11 24 +11 39 +11 15 +11 14 +11 16 +11 1 +11 3 +11 8 +24 10 +24 3 +24 15 +39 1 +39 14 +39 10 +27 3 +15 12 +15 14 +15 17 +15 3 +15 7 +14 16 +14 1 +14 3 +14 7 +17 3 +17 12 +16 1 +16 3 +1 3 +1 8 +3 2 +3 5 +3 7 +3 8 +2 5 +2 7 +5 4 +5 7 +5 6 +4 7 +7 6 +7 8 +6 9 +6 8 +9 8 diff --git a/snap-python/source/test/data/data-table.txt b/snap-python/source/test/data/data-table.txt new file mode 100644 index 0000000000000000000000000000000000000000..063432ac3f42d79fbf05c6a84085951e940dfeb4 --- /dev/null +++ b/snap-python/source/test/data/data-table.txt @@ -0,0 +1,5 @@ +0 0 0.05589686079 +0 1 1.96948472187 +0 2 2.77225393491 +0 3 3.80078155692 +0 4 4.5007046228 diff --git a/snap-python/source/test/data/example-LoadConnListStr.txt b/snap-python/source/test/data/example-LoadConnListStr.txt new file mode 100644 index 0000000000000000000000000000000000000000..51007b7a2dccf871725e28acd342ee26beefa826 --- /dev/null +++ b/snap-python/source/test/data/example-LoadConnListStr.txt @@ -0,0 +1,2 @@ +A B C +B C D diff --git a/snap-python/source/test/data/final_sorted_edges.txt b/snap-python/source/test/data/final_sorted_edges.txt new file mode 100644 index 0000000000000000000000000000000000000000..304d77cc099208b416c0d380380e7d5f1614dbd2 --- /dev/null +++ b/snap-python/source/test/data/final_sorted_edges.txt @@ -0,0 +1,63738 @@ +1000 21747 +1000 27233 +1000 5470 +10001 17080 +10001 851580 +1000122 113916 +1000146 1264948 +10003 37359 +10003 5467 +10003 9996 +100031 139721 +100031 88744 +100036 117480 +100037 17015 +100037 17960 +100037 51979 +100039 42238 +10004 193703 +1000598 1398126 +1000598 1398127 +100064 1138951 +100064 236447 +100064 66851 +100083 100082 +1000837 2567822 +1001187 1005784 +100119 22291 +100145 1065010 +100145 479893 +1001725 496703 +1001725 662168 +1001727 147502 +100188 738439 +100192 119962 +100193 239682 +1001954 2518486 +100199 100200 +1002 10780 +1002 442875 +1002 915145 +1002004 1167570 +1002030 1158581 +1002032 1269315 +1002032 325653 +1002128 1002192 +1002140 1002118 +100224 185163 +100230 224315 +1002339 1002335 +1002339 1419822 +1002339 342154 +1002340 2171919 +1002403 1002404 +1002403 397620 +1002403 543206 +1002403 833838 +1002403 844419 +1002403 861487 +1002403 912007 +1002404 397620 +1002404 844419 +1002404 861487 +1002404 912007 +100242 2069 +1002543 3074567 +1002543 532086 +100257 464214 +100257 464215 +100257 833639 +1002691 126036 +100276 110156 +100276 249861 +100276 255041 +100276 38256 +10029 820518 +10031 18187 +10031 21173 +10031 45071 +100313 1570188 +100313 2605787 +100313 44915 +100313 54187 +100313 66727 +100313 801 +100313 9967 +1003177 1003179 +1003177 1053170 +1003177 1173606 +1003177 2604177 +1003177 277423 +1003177 754974 +1003177 832942 +1003177 833071 +1003177 855072 +1003177 861581 +1003179 1053170 +1003179 2604177 +1003179 277423 +1003179 577808 +1003179 754974 +1003179 832942 +1003179 833071 +1003179 833553 +1003179 855072 +1003179 861581 +1003270 839042 +1003274 243496 +1003274 491321 +1003274 75559 +100328 40633 +1003290 24072 +100344 27012 +100346 337276 +1003493 54422 +1003493 555263 +100350 185169 +1003513 1448069 +1003513 388889 +10036 3696 +10036 63183 +100372 70956 +100375 5478 +1003857 17679 +1003869 184622 +1003938 37234 +1003938 43485 +1004027 1092096 +1004027 1097988 +1004027 91993 +1004028 269254 +1004252 1906340 +10043 1143320 +100430 189193 +100430 2105051 +100430 253733 +1004349 1004350 +1004477 663387 +1004480 814826 +100450 145311 +100450 196189 +100450 236526 +100450 257181 +100450 415965 +100450 88809 +100457 100457 +100457 132592 +100457 1403 +100457 151311 +100457 215179 +100457 22979 +100457 243564 +100457 26923 +100457 324902 +100457 474643 +100457 638252 +100457 69589 +100457 9796 +10046 1413 +10046 1560 +10046 16035 +10046 2309 +10046 95861 +1004773 1267104 +1004773 1267105 +1004773 1267106 +100502 294515 +100502 550701 +100502 82740 +1005220 1005221 +1005220 202092 +1005220 26955 +1005220 95539 +1005221 202092 +1005221 26955 +1005221 95539 +1005254 962182 +10053 99026 +1005346 1960978 +1005346 417259 +1005367 1005368 +1005367 1052939 +1005368 1052939 +100545 108780 +100545 1089536 +1005458 1005457 +100546 105225 +100558 219540 +100558 25495 +10056 6653 +100570 67552 +1005707 698773 +1005707 945427 +100584 202255 +100584 62837 +1005861 600970 +1005861 600973 +100591 308438 +100591 94874 +100595 48446 +100595 67552 +1005954 283469 +1005954 834223 +1006141 350481 +100615 404969 +100615 67648 +100648 146731 +100668 258770 +100668 43082 +10069 3480 +10069 69531 +1006977 1076878 +1006977 1568347 +1006977 1886955 +1006977 840730 +1006985 2123355 +1006985 922565 +100707 72872 +100711 455087 +100711 67718 +1007236 842825 +1007236 846158 +100729 1224647 +100729 153407 +1007359 1007360 +100736 3285675 +100736 33670 +1007492 1262335 +1007492 1299987 +1007492 1787565 +100752 100756 +100752 109832 +100752 14743 +100752 17587 +100752 188242 +100752 261878 +100752 528025 +100752 65049 +100756 109832 +100756 145858 +100756 173081 +100756 173399 +100756 174193 +100756 175380 +100756 210948 +100756 404077 +1007561 1670100 +1007561 970535 +100774 274993 +100774 5137 +100785 5359 +10079 271001 +1007910 1007911 +1007910 1697807 +1007910 29981 +1007954 828840 +100801 727693 +100811 100812 +1008418 1008417 +10086 22430 +1008628 966186 +100863 100862 +100864 1891384 +1008685 3163211 +1008722 1211358 +1008831 248718 +1008835 1005351 +1008929 2532861 +1009007 1062950 +1009100 1930994 +10092 295369 +10092 299240 +1009206 527475 +1009206 960417 +1009232 2483583 +1009232 3478263 +1009232 393383 +1009232 716084 +1009232 832962 +1009232 836185 +1009232 898403 +1009232 926325 +1009253 1180987 +1009253 188502 +1009267 996474 +100928 314354 +1009305 1333500 +1009305 3564955 +1009438 90847 +1009447 1147100 +1009447 1435431 +1009447 375279 +1009447 617133 +1009447 833033 +100946 250303 +1009492 1009490 +10095 145272 +10095 29958 +1009563 355 +1009568 1009570 +1009586 270172 +1009586 289621 +1009586 3182008 +1009586 431861 +1009739 1148312 +1009767 1198111 +100989 1535655 +100989 3572685 +100998 782702 +1010199 1240133 +1010199 1441830 +1010199 206281 +1010199 395913 +1010199 532418 +1010199 688716 +101028 34568 +101044 101045 +1010457 1504962 +101046 179561 +101088 294308 +101095 33066 +101113 45534 +10112 960163 +1011320 2786013 +10115 74434 +1011603 17591 +101162 280565 +1011972 64166 +1011986 1031993 +1011986 1129568 +1011986 1205065 +1011986 1362287 +1011986 1406392 +1011986 1424606 +1011986 1516786 +1011986 1516791 +1011986 1516797 +1011986 1516820 +1011986 395913 +1011986 690972 +1011986 712500 +1011986 841357 +1011986 880605 +1011986 899900 +1011986 978076 +1012051 191911 +1012233 1012234 +1012287 3348038 +1012324 1603612 +1012357 1083537 +1012379 1027116 +1012379 452918 +1012379 452919 +1012379 538864 +1012386 3320774 +1012451 448484 +10125 233524 +10127 726 +1012727 274209 +101289 144526 +101289 24422 +101289 24944 +1012931 1905440 +1012931 2545162 +1013037 1013038 +1013037 1013040 +1013040 1013038 +1013046 74022 +101317 199819 +101317 30882 +101324 398677 +101324 551324 +101324 551325 +101324 9796 +1013331 1492922 +1013331 833168 +1013331 835519 +1013331 845919 +101336 522367 +101336 82010 +1013386 818356 +1013493 282986 +1013493 298689 +101350 393204 +1014 1004 +1014 195631 +1014 30816 +1014 67442 +10140 1859 +101410 552374 +1014245 1924932 +1014252 1014251 +10144 116149 +10144 70867 +10144 80838 +1014466 454293 +1014466 532086 +1014511 1031847 +1014584 1454754 +1014584 621418 +1014610 1326043 +10147 139692 +101487 106101 +1015 1018 +1015 3194 +1015 389119 +1015 473 +1015 73435 +1015 9704 +10151 232749 +101510 553852 +1015366 160481 +1015381 77923 +1015406 65807 +1015406 833179 +1015406 842888 +1015420 754894 +101543 92898 +101552 455230 +1015633 1239161 +1015633 194985 +10157 29692 +1015767 1015768 +1015817 1015826 +1015817 1015827 +1015827 1015826 +1015831 1015817 +1015831 1015826 +1015831 1015827 +1015876 1828463 +10159 511658 +10159 67703 +101597 1028154 +101597 1495753 +101597 1523160 +101597 2075854 +101597 516159 +1016184 33801 +10163 13811 +1016300 2260331 +1016300 434336 +1016334 1016333 +1016334 1016335 +1016335 1016333 +101637 326896 +1016421 1135730 +1016432 272994 +101648 12069 +1016486 2137164 +1016605 2605799 +1016605 647843 +1016717 1047651 +101676 258124 +101676 397953 +1016856 743938 +101700 1272728 +1017165 1174410 +1017165 1303882 +1017165 1499605 +1017165 384225 +1017264 725144 +101741 2154431 +10176 145263 +1017619 835735 +1017637 2402320 +1018058 1023799 +1018058 707379 +10181 85061 +1018138 1806908 +1018212 343158 +101822 30148 +101840 269474 +101840 827110 +101853 285416 +101853 5521 +101853 8349 +101866 95252 +1018867 64064 +101887 177499 +101887 99241 +1019 225388 +1019 245 +1019 3006 +1019 38965 +1019 6478 +1019 819493 +101902 918040 +101923 274267 +1019239 964451 +101940 374980 +101948 22509 +101952 101953 +101952 305303 +101952 54336 +101953 54336 +10196 23732 +1019691 1019690 +10197 16619 +10197 296445 +1019861 1607136 +1019861 2220205 +10199 1130508 +1019926 1201493 +102004 437936 +102010 13811 +102027 243560 +102027 68225 +1020295 1020303 +10203 145252 +10203 32352 +10203 486924 +10203 61827 +1020377 319968 +1020377 372878 +102044 10282 +102044 315225 +1020583 1292167 +102078 135230 +1020821 922245 +1020855 310232 +1020906 1437323 +102091 372164 +102091 407260 +102100 55104 +102110 130472 +102110 207808 +102110 207809 +102110 4476 +10212 2115 +10212 3497 +1021215 1116783 +1021215 1368030 +1021215 192322 +1021215 497542 +102125 1881839 +102126 203913 +102126 42657 +102126 66385 +102132 5178 +102132 70841 +102132 72068 +1021443 2414157 +1021584 1679850 +1021584 181223 +102160 514849 +1021818 618668 +1021942 1360089 +1021942 1787676 +1021942 2186352 +1021942 835088 +1021944 1057453 +1021944 1825898 +1021944 435555 +1021944 595478 +1021944 835113 +1021948 1009230 +1021948 864674 +1021948 896804 +1021949 1021948 +1021949 1284343 +1021949 864674 +1021949 896804 +1021989 1292320 +1022025 299702 +1022025 744723 +1022025 814478 +1022025 833076 +1022025 833687 +1022025 834073 +1022025 835518 +1022025 837512 +1022025 842238 +1022025 842888 +1022025 915657 +1022066 163029 +10221 178806 +10221 44101 +1022156 1021986 +1022180 1021471 +1022249 1022250 +102243 246259 +102243 25958 +1022514 20184 +1022736 610062 +1022781 1888624 +1022781 885816 +102293 102293 +102293 32166 +102293 48245 +1022985 99663 +1023 1016 +1023 17308 +1023 2187 +1023 5489 +102301 28933 +102301 8109 +1023041 711731 +1023151 144864 +102318 102318 +1023329 1425233 +102359 46134 +102361 1377103 +1023670 578727 +1023677 349296 +1023677 626175 +1023677 712500 +1023684 1018443 +102375 158822 +102375 364257 +102375 996604 +1023796 1438649 +102404 166518 +102404 355 +102404 73921 +1024117 1029487 +1024128 1185262 +1024257 420763 +1024263 406273 +1024263 446471 +1024263 866651 +102433 21057 +102433 33905 +102442 12958 +1024659 312739 +1024678 1640301 +1024678 1720758 +1024678 1739627 +1024678 1739630 +1024678 1739632 +1024678 2129819 +1024678 2130303 +1024678 837674 +1024678 852711 +1024732 1845805 +10250 272327 +102506 1022025 +102506 1260218 +102506 1294869 +102506 1353208 +102506 1528200 +102506 1586786 +102506 1586787 +102506 1708583 +102506 1777307 +102506 224329 +102506 253245 +102506 27519 +102506 418175 +102506 425124 +102506 425125 +102506 435555 +102506 451534 +102506 454293 +102506 455839 +102506 495010 +102506 517158 +102506 547971 +102506 550341 +102506 576237 +102506 617133 +102506 653372 +102506 683292 +102506 688716 +102506 696260 +102506 809856 +102506 833169 +102506 833217 +102506 833687 +102506 833716 +102506 834071 +102506 834226 +102506 835113 +102506 837528 +102506 837530 +102506 837545 +102506 839085 +102506 839411 +102506 839990 +102506 842132 +102506 842238 +102506 848540 +102506 854161 +102506 854162 +102506 862694 +102506 865050 +102506 866648 +102506 867893 +102506 867894 +102506 880607 +102506 880609 +102506 887456 +102506 890814 +102506 899625 +102506 906296 +102506 906298 +102506 912007 +102506 912702 +102506 914678 +102506 941850 +102506 965144 +102506 978211 +102506 986214 +102507 40120 +1025076 2000491 +1025294 943425 +1025294 943426 +1025303 1283949 +1025303 1697250 +1025436 1025437 +1025618 3514749 +102568 1347282 +1025795 1383928 +1025795 983481 +1025832 3331684 +1025834 441528 +1025834 841590 +1025921 192325 +1025956 785508 +1026176 2013697 +1026198 253245 +1026198 395913 +10262 1373 +1026268 1052459 +1026268 726336 +10263 109928 +10263 1237153 +10263 302711 +10263 38210 +10263 90541 +1026307 1583001 +102636 214774 +102638 46333 +1026532 1026531 +1026736 845763 +1026736 870792 +1026737 837582 +1026737 837585 +10268 552851 +10268 785600 +102703 384696 +1027076 502329 +10271 2964 +1027116 452918 +1027116 452919 +1027116 538864 +10272 5243 +10272 702 +102727 1760470 +102733 51881 +1027396 667541 +1027471 651280 +10275 21957 +1027652 1341664 +1027680 425068 +1027687 1209194 +1027687 1554211 +1027687 1886097 +1027687 424576 +1027687 711106 +1027687 754974 +1027687 832768 +1027687 959411 +1027727 2691305 +102781 1214647 +102781 21945 +102781 51007 +1027817 1027821 +102789 96062 +1027989 1471362 +1027989 180634 +1027989 374770 +1027989 439663 +1027989 714002 +1027989 821985 +1028165 3834434 +1028377 1730499 +1028493 1478943 +1028493 2510842 +1028493 2927868 +1028502 1092524 +1028502 1354730 +1028502 268272 +1028502 271874 +1028502 289522 +1028502 3506857 +1028502 841301 +1028502 859446 +1028502 859998 +1028502 869570 +1028502 871323 +1028532 2203966 +1028602 1731476 +1028602 704625 +1028634 280847 +102898 113750 +102898 115941 +10290 101941 +10290 2108 +10290 285760 +10290 41578 +10290 42831 +10290 484799 +10290 527838 +1029091 183869 +1029180 461602 +1029188 59769 +1029316 1050714 +1029382 1288060 +1029398 848467 +1029401 194 +102947 5951 +103 10876 +10300 2561715 +103000 1301272 +103004 90309 +103010 159819 +1030107 1309971 +1030107 1309972 +1030107 1309975 +1030107 1309977 +1030107 522210 +1030107 873294 +1030128 1799827 +103020 103579 +1030330 1030329 +1030330 1030331 +1030331 1030329 +1030364 1719022 +1030364 2907890 +1030364 561621 +1030429 661008 +1030490 1030495 +1030558 260744 +1030558 277423 +1030558 283127 +1030558 641250 +1030558 835519 +1030574 1024403 +103064 91290 +103064 94078 +1030674 736606 +1030737 456782 +1030757 1030756 +1031 225760 +1031 28209 +1031 36158 +1031 778716 +10310 19301 +10310 65273 +1031230 2124113 +1031230 283127 +1031230 754974 +1031230 834057 +1031230 837498 +1031230 838200 +1031230 838203 +1031230 855072 +1031230 861487 +1031262 1653542 +1031262 577808 +1031370 1791419 +1031467 283127 +1031467 575046 +1031467 578737 +1031467 833168 +1031467 833553 +1031467 865054 +1031467 869605 +1031522 245061 +103160 61752 +103178 25534 +10319 140607 +10319 15881 +10319 192521 +1031919 844738 +103197 100040 +1031993 1362287 +1031993 1406392 +1031993 1424606 +1031993 1516791 +1031993 1516797 +1031993 1516820 +1031993 880605 +1031993 899900 +1031998 1306699 +1031998 1676573 +1031998 2757853 +1031998 312456 +1031998 312590 +1031998 759599 +1032 39020 +1032 5104 +10320 32915 +103204 163850 +1032219 1092558 +1032225 1129949 +1032225 262940 +1032225 368137 +1032226 1032225 +1032226 1032277 +1032226 1032278 +1032226 833560 +1032226 858372 +1032231 667503 +1032231 833098 +1032231 833446 +1032231 859036 +1032231 921168 +1032240 1990133 +1032240 2666389 +1032240 267134 +1032240 538646 +1032240 688034 +1032240 851590 +1032262 1022025 +1032262 1084955 +1032262 2099932 +1032262 302078 +1032262 522209 +1032262 522210 +1032262 832924 +1032262 833168 +1032262 833687 +1032262 835036 +1032262 861485 +1032262 868798 +1032265 842888 +1032277 1032278 +1032277 833560 +1032277 833628 +1032278 526591 +1032278 577808 +1032278 833560 +1032278 833628 +103238 2091 +103238 95769 +1032415 1148092 +1032419 1620989 +103257 507205 +103268 3782412 +1032727 101840 +103275 30212 +1033075 995880 +103312 28496 +1033222 144927 +1033222 307722 +1033222 317259 +1033258 1679489 +1033258 696225 +1033258 835112 +1033313 228181 +1033339 62590 +103339 1364240 +103351 1175829 +1033633 1033634 +1033633 7137 +1033634 7137 +10337 10337 +10337 285484 +1033718 1191161 +103381 9373 +1033925 109832 +1034077 1116709 +103419 279304 +10343 148391 +103432 64066 +103432 71131 +1034321 1034320 +1034411 2786693 +1034411 612349 +1034464 823061 +1034464 95537 +103447 168398 +103447 194 +103447 593963 +103447 71521 +1034532 869772 +1034601 827918 +1034696 478936 +1034714 1025551 +1034738 297605 +1034738 466777 +1034738 937138 +10348 169166 +1034853 1551503 +1034853 2043981 +1034853 2107647 +1034853 602946 +1034853 743753 +1034883 545923 +1034911 1726981 +1034911 918927 +103497 110964 +1034981 835090 +1034981 885767 +1035 3918 +1035 71827 +1035081 1035079 +1035081 1035082 +1035082 1035079 +1035093 127139 +10352 11368 +10352 132585 +10352 25872 +103526 272715 +1035281 1035282 +1035281 190141 +1035341 1712542 +1035377 1376300 +103540 584402 +103545 210961 +1035451 254625 +10355 18160 +10355 488720 +10355 844372 +103585 48277 +1035864 624129 +10359 201425 +103590 3283039 +10360 223505 +10360 23812 +10360 31351 +1036154 553093 +1036225 1018838 +1036239 1036239 +10363 23859 +10363 2753696 +10363 634 +103640 77923 +103645 87892 +1036478 887587 +1036751 1036752 +1036751 840538 +1036759 1036758 +103677 72883 +1036857 411631 +1037158 783608 +1037173 1764657 +103718 72240 +103718 99415 +1037252 1276663 +1037360 138108 +1037360 543584 +1037403 1037420 +1037403 1418465 +10377 10431 +1037716 1046943 +1037716 1046946 +1037718 950082 +1037730 1297439 +1037731 1037730 +1037838 169099 +1037838 249403 +1037865 146066 +1038016 2418782 +1038052 834223 +1038052 837008 +10381 45938 +1038138 1081108 +1038166 443838 +1038212 1523364 +1038267 422415 +10383 11202 +10383 12340 +10383 23035 +10383 24230 +10383 2811 +1038332 390053 +1038332 897158 +1038471 1038470 +1038546 262940 +1038546 289522 +1038546 835518 +103858 90863 +10389 66373 +103892 233501 +10391 2264 +10391 2526230 +10391 66253 +1039405 1636578 +103944 67423 +1039442 1031612 +1039625 1143318 +1039625 1367480 +1039625 845785 +1039625 870832 +1039625 986222 +103976 71916 +104006 270073 +1040184 3230409 +1040366 1040365 +1040473 299702 +1040506 283469 +1040507 216140 +1040507 833317 +1040507 855790 +1040507 860273 +104055 104056 +1040749 1283944 +1040749 1341647 +1040749 2464761 +1040749 840069 +1040777 283122 +10408 1735 +1040863 268984 +1040877 776067 +1041164 1033573 +1041164 835739 +1041164 849795 +1041246 673449 +1041278 1100 +10413 28257 +1041371 1041368 +1041426 1041425 +10416 32024 +10416 36174 +104175 132830 +1041800 1041801 +1041812 510556 +1041961 341656 +1041969 1864137 +1041969 435555 +1041969 517158 +1041969 716084 +1041969 836184 +1041969 836185 +1041969 839514 +1041969 848263 +1041969 854161 +1041969 855072 +1041969 858964 +1041969 863279 +1042095 408230 +1042183 1281646 +1042183 1447166 +1042302 44775 +1042373 1207617 +10424 40147 +1042444 224822 +1042444 677298 +1042460 262940 +1042460 762355 +1042460 867991 +104257 1135192 +104257 2075 +1042743 321099 +1042797 1244401 +1042803 314238 +1042993 2763350 +10430 26923 +10430 400096 +10430 4736 +10430 6748 +10430 87251 +1043006 115864 +1043028 13511 +1043044 1043043 +1043044 382934 +1043044 885100 +10431 405053 +104319 113599 +104319 1777 +1043208 1043205 +1043208 1336426 +1043208 730302 +1043259 212188 +1043294 2532541 +104335 3190 +104335 57176 +1043429 3180055 +1043429 846970 +104343 104307 +104374 3499 +10438 135014 +10438 183076 +1043862 421949 +1043862 54574 +1043892 1043903 +1043922 696225 +1043922 871496 +1043922 890414 +104408 3558 +1044184 1044185 +1044186 830422 +1044192 1492318 +1044334 835112 +1044334 835187 +104468 1119713 +104468 796144 +1044695 862287 +104472 278279 +1044803 1044792 +104497 104921 +1044987 1216613 +104514 177340 +104514 264223 +104514 32192 +104514 434336 +104514 456210 +104514 465983 +104514 774478 +104514 774486 +1045250 142204 +1045250 76720 +1045252 36381 +104526 113655 +1045323 1433716 +104533 148809 +104533 473021 +1045354 4831 +1045524 515354 +1045530 1135228 +1045530 500231 +1045530 649585 +1045530 834088 +1045530 834094 +1045530 835650 +104558 194738 +10457 1074920 +104582 177708 +104582 60405 +1045824 578127 +10459 94610 +1046 304114 +1046 50963 +1046 9591 +1046012 1046012 +1046012 1649689 +1046024 1038078 +1046133 504537 +1046133 73815 +10462 344215 +10462 4948 +10463 3474 +104636 659888 +10465 10466 +10465 21698 +1046517 1415870 +1046517 1640312 +1046517 2358508 +1046517 2410878 +1046517 3292283 +1046517 3292284 +1046517 833629 +104673 251778 +104680 35022 +10469 134038 +10469 2308 +10469 2376385 +10469 342807 +104691 153391 +104691 16501 +104691 167260 +1046942 696225 +1046942 864674 +1046943 1046946 +1046945 1315847 +1046945 922551 +1046945 978175 +1047 858123 +10470 602291 +10470 6264 +1047108 1047109 +104712 40528 +10472 10472 +10472 114282 +10472 119661 +10472 124436 +10472 137276 +10472 151292 +10472 19146 +10472 230520 +10472 264998 +10472 35148 +10472 46667 +10472 672090 +10472 71346 +10472 89110 +10472 9165 +1047263 2755461 +1047361 42895 +1047420 835090 +1047420 885767 +1047428 326666 +1047614 2267218 +1047628 647782 +1047628 837008 +1047947 1092492 +1047947 905213 +1048110 1619482 +1048110 832655 +1048110 833722 +1048110 833879 +1048110 836151 +1048110 836152 +1048110 836154 +1048110 836155 +1048110 836156 +1048110 861648 +104843 437 +1048430 224329 +1048430 262940 +1048430 3397762 +1048430 502809 +1048431 836049 +1048457 76828 +1048497 309514 +1048557 1909276 +1048624 1468965 +1048662 1370842 +1048662 347067 +1048765 1008952 +104896 2727110 +104896 40953 +1049 1056968 +1049 136092 +1049 1462131 +1049 1618691 +1049 2807 +1049 38399 +1049 855914 +1049026 1314669 +104909 270633 +104913 104914 +104934 220743 +104937 269668 +1049417 77243 +1049440 1251465 +104945 435125 +1049538 29052 +1049539 1049538 +1049539 29052 +1049548 145057 +1049652 1626507 +10497 2266 +10497 41107 +1049738 1049739 +104975 570566 +104975 669907 +1049795 203954 +1049884 1047744 +104991 61686 +1049945 1921649 +105001 109395 +1050100 2007580 +1050100 2007581 +1050278 391679 +1050295 1050296 +1050295 1050297 +1050295 425125 +1050295 446105 +1050295 455839 +1050295 497008 +1050295 854918 +1050296 227843 +1050296 425125 +1050296 446105 +1050296 455839 +1050296 854918 +1050296 873811 +1050296 938087 +1050297 1050296 +1050297 425125 +1050297 446105 +1050297 455839 +1050297 497008 +1050297 854918 +105033 290829 +105033 73973 +10504 36143 +10504 36144 +10504 67774 +1050404 1050405 +1050497 1050496 +1050534 806436 +1050534 843897 +1050671 8456 +1050714 1431903 +1050714 302839 +10508 2661 +1050812 2570937 +1051 106331 +105101 42487 +105113 323154 +105134 15973 +1051383 3557206 +10514 149325 +10514 253395 +10514 255116 +10514 285231 +10514 315947 +10514 41417 +1051616 454981 +105173 229216 +105185 35086 +105185 4687 +10519 113091 +10519 5978 +1052201 1052202 +1052270 881101 +105236 105239 +105236 1627318 +105239 1627318 +1052424 1150819 +1052424 898855 +105272 1061784 +105272 2164503 +105272 45641 +105273 15560 +105273 214519 +105273 472394 +105273 83232 +1052749 363207 +10529 2265022 +10529 262940 +10529 266136 +10529 76111 +1053059 289522 +1053059 696200 +1053059 835518 +1053164 1745990 +1053170 653372 +1053170 754974 +1053194 1015406 +1053194 1449987 +1053194 796210 +1053194 833179 +1053194 844081 +10533 1471871 +10533 283290 +10533 36863 +10533 36864 +10533 44133 +105343 297515 +105343 66144 +105343 87215 +105343 87216 +1053431 432960 +105348 303144 +10535 243203 +1053504 3797221 +105357 16409 +1053619 1426021 +1053753 688356 +1053916 1053915 +1053916 578730 +1054 1055 +1054055 209763 +1054060 1548002 +1054091 1221363 +1054091 2505308 +1054091 2540931 +1054126 364714 +10543 155980 +1054398 115461 +1054398 115469 +1054398 304968 +1054398 361808 +1054398 361814 +1054398 410038 +1054398 456926 +1054398 552196 +1054398 95539 +105453 157990 +105453 50703 +1054547 322364 +105456 167646 +105456 212995 +105456 22428 +105456 224983 +105460 2711752 +1054626 1055198 +1054626 2326899 +1054626 843148 +105466 91567 +1054861 2065231 +1054869 840456 +105495 238317 +1054975 1054974 +1054975 393879 +1055 15585 +1055021 1716554 +1055198 2326899 +1055198 843148 +1055533 1228647 +1055533 1228648 +1055630 526416 +1055630 978211 +105569 210110 +1055743 272381 +1056 22140 +1056038 1102665 +1056038 858756 +1056038 884062 +105606 54775 +105606 54776 +1056568 931384 +105658 313920 +105661 257898 +105692 167748 +105692 45008 +1057076 1233375 +1057076 267134 +1057076 3042186 +1057076 415725 +1057076 833166 +1057076 894188 +1057162 555263 +1057185 1057191 +105732 292203 +105732 540049 +105732 56168 +105733 29718 +1057451 448007 +1057451 448010 +1057451 648030 +1057451 883315 +1057451 956952 +1057453 1346687 +1057453 435555 +1057453 835112 +1057453 835113 +1057453 839233 +1057453 842238 +1057742 1831640 +10578 190363 +10578 4848 +10578 93292 +105781 17546 +1057894 29059 +1057897 114803 +1057897 115376 +1057897 117480 +1058170 604396 +1058170 842233 +1058170 842888 +1058304 779781 +1058304 837442 +1058304 839007 +105832 568306 +1058540 115469 +1058540 304968 +1058540 339765 +1058540 522209 +1058540 522210 +1058540 552196 +1058540 712500 +1058540 736604 +1058540 744724 +1058540 861272 +1058540 861275 +1058540 861276 +1058540 872030 +10586 9557 +105862 116679 +105862 171290 +105862 194 +105862 25872 +105862 2607246 +105862 267136 +105862 2907655 +105862 386488 +105862 386860 +105862 411436 +105862 52145 +105862 763850 +105862 77086 +105862 795052 +105862 847754 +105862 985028 +105865 146066 +105865 382294 +1058687 960689 +105869 310492 +105869 386857 +105870 2103738 +105878 173478 +105878 175703 +10589 261286 +1058959 1350877 +1059060 192325 +1059060 623293 +1059101 2153848 +105915 191416 +1059168 119483 +1059168 1300593 +1059168 2411851 +1059168 2674351 +1059168 3370367 +10592 48727 +1059249 1615916 +105968 120828 +1059960 1059959 +1060 10600 +1060 1439055 +1060 144644 +1060 16409 +1060 1825 +1060 2214416 +1060 52584 +1060 97260 +106006 3753336 +106006 6270 +106006 79089 +1060119 798452 +1060127 1250269 +1060131 1060130 +1060131 1060131 +1060266 1060267 +1060266 1060268 +1060266 260744 +1060266 833891 +1060266 898730 +1060266 926720 +1060267 898730 +1060268 1060267 +1060268 260744 +1060268 898730 +1060268 926720 +10603 72025 +10604 614425 +1060402 1404521 +106047 1089768 +106047 229194 +106047 474884 +106047 693015 +106066 448718 +1060736 366820 +106075 41509 +1060843 828944 +106085 154429 +1060885 1739573 +1060885 1739574 +1060885 1739575 +1060885 262376 +1060885 646485 +1060885 71825 +106093 715586 +1060954 1666884 +1060956 350933 +106097 66261 +1061 559072 +1061083 1603261 +1061083 345477 +1061083 977708 +1061142 1061141 +1061172 2019736 +106149 123005 +1061532 288534 +1061549 1884995 +1061549 2280654 +1061549 506682 +10616 249946 +10616 255280 +106188 282245 +106197 106198 +1062126 1179182 +106213 31185 +106213 34955 +1062360 832900 +1062360 95544 +10624 1446880 +106257 11539 +1062706 2027931 +10628 141714 +10628 162275 +10628 259 +10628 27472 +10628 31286 +10628 35086 +10628 362423 +10628 46467 +10628 474921 +106299 31461 +1063052 1233999 +1063052 269254 +106309 3470 +106320 106321 +1063297 1478923 +1063297 908938 +1063696 2466587 +1063696 44422 +1063698 35646 +1063698 402640 +106376 235235 +1064 4687 +10640 128058 +10640 259181 +10640 4948 +1064088 77923 +1064107 1022025 +1064107 744723 +1064108 573239 +1064108 855072 +106417 108754 +1064181 1064183 +1064284 1132858 +1064284 1558876 +10644 11986 +10644 47050 +10644 58236 +10645 11336 +10645 817 +106454 688169 +106467 85101 +106474 301099 +1064909 1495552 +106496 5044 +1065000 1042460 +1065000 490281 +1065000 986222 +1065010 1124616 +1065010 137880 +1065010 174968 +1065010 292681 +1065010 383281 +1065010 479893 +1065010 90037 +1065010 982496 +1065046 1065047 +1065046 1451766 +1065046 432737 +1065047 1451766 +1065047 432737 +1065087 1455166 +1065101 95623 +1065108 1400196 +10652 1328 +10652 328741 +1065216 1065211 +106523 79326 +1065243 1055826 +1065463 1293297 +10656 194 +10656 36932 +10656 81282 +106562 63678 +1065633 677636 +1065654 538156 +1065684 1447138 +10657 22707 +10657 917 +1065719 161272 +1065742 1622952 +106575 44326 +10659 17222 +106596 299172 +106596 320446 +106596 364895 +1065987 29051 +1066081 880725 +1066124 1066123 +1066340 1092516 +106641 285739 +106641 385627 +1066447 1040777 +1066447 1341604 +1066447 1430196 +1066447 1919176 +1066447 1931864 +1066447 1931865 +1066447 577808 +106651 116683 +106651 77088 +1066773 1492648 +1066773 1492651 +1066948 612349 +1066952 458083 +106698 26747 +10670 121726 +106719 1216733 +106719 122129 +1067197 4349 +10672 11889 +106720 21128 +106720 227408 +106720 48354 +106720 5682 +106720 609975 +106738 1168286 +106757 1345127 +106765 1080983 +106765 1469995 +106765 547341 +106765 58018 +10677 4967 +106778 23102 +106778 85858 +1068 149686 +1068 16568 +1068 33573 +1068 4179 +1068 50867 +106802 17827 +106802 185751 +106802 281551 +106802 310688 +106802 317584 +1068168 29782 +106819 12764 +106819 626749 +10682 102631 +106823 8358 +1068298 262940 +1068298 842135 +10683 88509 +1068334 952486 +1068386 301157 +1068509 270296 +10686 14934 +10686 2155 +10686 45529 +10686 45530 +10686 459 +10686 513617 +106870 249238 +1068721 1068722 +1068721 1068723 +1068721 566828 +1068722 1068723 +106878 117051 +106878 265931 +1068815 1563412 +106892 195351 +106892 212400 +106892 278 +106892 3924 +106892 418806 +106909 234181 +106909 397977 +1069136 1166964 +1069136 577454 +1069500 835430 +1069527 1235199 +1069527 1235200 +1069622 128396 +1069633 14015 +10697 18692 +1069915 2911456 +106999 121519 +107 416 +107005 87558 +1070145 170759 +1070145 2645574 +1070145 526591 +1070145 561054 +1070145 833168 +1070145 837512 +1070145 838932 +1070145 844418 +1070194 1124597 +10702 233190 +10702 28521 +1070332 1070333 +10704 26065 +1070813 309767 +107095 115004 +107095 3260638 +107097 7870 +1071250 2951126 +1071250 684263 +1071250 724097 +1071250 890593 +1071276 342543 +1071276 703271 +1071287 744724 +1071287 858480 +1071526 1071528 +1071701 550738 +1071886 2774269 +107196 409899 +107221 31351 +107223 87884 +107270 8602 +107278 778425 +1072839 291339 +10729 109437 +107303 591778 +107305 102865 +107309 290963 +1073100 2753 +107386 105456 +107386 212995 +107386 22428 +107386 224983 +10739 36301 +10739 438548 +10742 59530 +107423 107422 +107436 191608 +107436 75608 +10745 18440 +10745 217700 +10745 43937 +10745 676618 +1074734 134250 +1075087 4937 +107527 3581246 +107527 37236 +107528 314309 +107530 216292 +1075321 2571184 +10754 1009206 +10754 1107308 +10754 124158 +10754 1361543 +10754 155404 +10754 452440 +10754 55500 +10754 68620 +10754 809748 +10754 91348 +10754 97523 +10754 98446 +107547 570882 +107547 61048 +107547 980833 +107560 107560 +107560 132830 +107560 231661 +107560 98062 +107561 419733 +1075630 244342 +1075630 61833 +107597 80117 +1076 10070 +1076237 1171255 +1076237 948478 +1076298 1428453 +1076301 162275 +10765 76125 +10765 7708 +1076556 354103 +1076556 526739 +107658 363729 +1076878 1886955 +107707 20621 +107713 30918 +107714 20839 +107718 130629 +107718 130630 +107718 1422157 +107718 1459593 +107718 38588 +1077351 1147583 +10774 2654 +10774 4809 +10774 4810 +10774 64469 +107746 53728 +107748 1976097 +107751 328931 +107769 13732 +107769 211036 +107769 36100 +10777 42669 +10777 59214 +107771 50513 +1077818 1450166 +1077818 296959 +1077818 354659 +1077888 1077887 +10780 21139 +107822 217774 +10783 1374 +10783 50997 +107839 12830 +10784 135377 +10784 15509 +1078501 1078505 +1078502 1078501 +1078502 1078505 +1078619 60880 +1078620 926588 +1078855 258113 +107893 425809 +1078962 943425 +1079035 1092691 +1079121 252034 +1079206 1385247 +1079267 93024 +107931 107947 +107937 107936 +107945 268325 +107947 388313 +1079561 517158 +1079561 704150 +1079593 129830 +1079679 1467272 +107990 207401 +108 12185 +108 1653 +108 197656 +108 337854 +108 4982 +108 58962 +108 81210 +1080 1045753 +1080 166208 +1080 244096 +1080 437 +1080246 1080247 +1080246 2578612 +1080246 270225 +1080246 368137 +1080246 424576 +1080246 744724 +1080246 841593 +1080246 842223 +1080246 851310 +1080246 858371 +1080246 900979 +1080246 937077 +1080247 368137 +1080247 415720 +1080247 841593 +1080247 842223 +1080247 851310 +1080247 900979 +1080247 998856 +1080248 1481537 +1080248 1481547 +1080248 855073 +10804 1531 +10804 4861 +1080471 212364 +1080491 23333 +1080491 4 +1080491 987669 +108050 50984 +1080658 6384 +108068 82772 +1080851 398264 +1080984 1759362 +1080984 1979478 +1080984 2768272 +108112 368738 +108112 45966 +108112 95404 +108129 381343 +108129 898981 +1081398 167573 +1081398 816964 +10818 11910 +10818 16575 +10818 41789 +108184 40792 +10819 37749 +10819 86533 +108190 6106 +108194 11013 +108206 920539 +1082152 37722 +10824 5032 +10824 56196 +1082403 1796403 +108257 58349 +1082633 1109894 +108268 126456 +10827 149 +10828 246221 +1082911 1082910 +1082974 489463 +1083 192370 +1083 247506 +108338 135390 +108339 108340 +108343 267717 +108343 267719 +108343 2701234 +108343 636636 +108347 288050 +1083605 1770598 +1083605 1946601 +1083646 1679470 +10837 108265 +10837 13963 +10837 1458295 +1083751 1177033 +1083751 2079526 +108385 255093 +1083859 954338 +10841 110003 +1084246 1084247 +1084246 1641953 +1084336 3323461 +108439 1031467 +108439 1053170 +108439 1061521 +108439 1086491 +108439 1092492 +108439 1136579 +108439 11696 +108439 1173606 +108439 1428466 +108439 153980 +108439 1716925 +108439 1933252 +108439 1964161 +108439 1964162 +108439 2068346 +108439 2333550 +108439 2371481 +108439 239236 +108439 2409461 +108439 2409463 +108439 253133 +108439 2604177 +108439 260744 +108439 262940 +108439 27519 +108439 277423 +108439 283122 +108439 283127 +108439 299702 +108439 310388 +108439 349149 +108439 361814 +108439 368137 +108439 374006 +108439 388185 +108439 395913 +108439 397620 +108439 406281 +108439 406283 +108439 415720 +108439 446577 +108439 451535 +108439 454293 +108439 472036 +108439 479033 +108439 517158 +108439 517165 +108439 522209 +108439 522210 +108439 526592 +108439 532276 +108439 538821 +108439 539131 +108439 547969 +108439 547971 +108439 561054 +108439 573239 +108439 575046 +108439 578737 +108439 587167 +108439 604396 +108439 610799 +108439 683885 +108439 688716 +108439 694647 +108439 696225 +108439 696257 +108439 754894 +108439 754974 +108439 795184 +108439 809856 +108439 832701 +108439 832917 +108439 833073 +108439 833076 +108439 833162 +108439 833164 +108439 833167 +108439 833168 +108439 833445 +108439 833549 +108439 833553 +108439 833770 +108439 834073 +108439 834378 +108439 835190 +108439 836124 +108439 837498 +108439 839679 +108439 839696 +108439 842238 +108439 845919 +108439 850892 +108439 850897 +108439 855072 +108439 855890 +108439 865054 +108439 865654 +108439 865655 +108439 867985 +108439 867988 +108439 869589 +108439 869605 +108439 870631 +108439 870853 +108439 872098 +108439 907452 +108439 912593 +108439 926979 +108439 931384 +108439 966857 +108439 996441 +1084770 3820 +1084800 69576 +1084955 1022025 +1084955 833687 +1084956 1615221 +1084956 260744 +1084956 283122 +1084956 526592 +1084956 641250 +1084956 646857 +1084956 833167 +1084956 833168 +1084956 996444 +1085523 1497219 +1085558 1300593 +108557 1309836 +108565 1092565 +108565 1259101 +108565 153980 +108565 1735555 +108565 1787599 +108565 192325 +108565 260744 +108565 262940 +108565 269254 +108565 271870 +108565 27519 +108565 282137 +108565 283122 +108565 283123 +108565 2996792 +108565 299702 +108565 317584 +108565 3248391 +108565 361074 +108565 368137 +108565 377139 +108565 395913 +108565 397617 +108565 397620 +108565 406273 +108565 406278 +108565 406281 +108565 406283 +108565 415720 +108565 424576 +108565 442174 +108565 448007 +108565 448010 +108565 454293 +108565 488362 +108565 490777 +108565 499563 +108565 532086 +108565 547971 +108565 552196 +108565 555462 +108565 626175 +108565 627442 +108565 696188 +108565 696215 +108565 696225 +108565 703271 +108565 712500 +108565 744724 +108565 774485 +108565 796660 +108565 809856 +108565 826517 +108565 832951 +108565 833128 +108565 833317 +108565 833560 +108565 833579 +108565 833686 +108565 835090 +108565 835518 +108565 837550 +108565 839081 +108565 846299 +108565 846301 +108565 850891 +108565 851312 +108565 855761 +108565 859452 +108565 869694 +108565 872098 +108565 881443 +108565 885767 +108565 895152 +108565 913209 +108565 92243 +108565 926716 +108565 926722 +108565 933757 +108565 95536 +108565 95540 +108565 978851 +108565 999914 +108566 1029398 +108566 1041310 +108566 1046943 +108566 1046946 +108566 1053916 +108566 1054869 +108566 1056568 +108566 1079561 +108566 108568 +108566 1092619 +108566 1109417 +108566 1111129 +108566 1135199 +108566 1152498 +108566 1155414 +108566 1173666 +108566 1173667 +108566 1187662 +108566 1218161 +108566 1245781 +108566 1267716 +108566 1267717 +108566 1283947 +108566 1337779 +108566 1381485 +108566 1440950 +108566 153980 +108566 1575081 +108566 1583478 +108566 1588331 +108566 1658389 +108566 1769149 +108566 1823637 +108566 1855232 +108566 1919644 +108566 1934787 +108566 1977093 +108566 200786 +108566 2041740 +108566 2041741 +108566 2052077 +108566 207945 +108566 2108156 +108566 214405 +108566 2293395 +108566 2356605 +108566 2466136 +108566 259802 +108566 260744 +108566 262940 +108566 2640719 +108566 269254 +108566 271870 +108566 283122 +108566 299702 +108566 3124487 +108566 324481 +108566 341147 +108566 343905 +108566 359068 +108566 361608 +108566 368137 +108566 375279 +108566 377139 +108566 379809 +108566 388185 +108566 391762 +108566 393383 +108566 395913 +108566 397617 +108566 406423 +108566 415720 +108566 415725 +108566 434124 +108566 446471 +108566 452918 +108566 500231 +108566 514466 +108566 517163 +108566 522210 +108566 532086 +108566 532425 +108566 538821 +108566 617133 +108566 626175 +108566 641164 +108566 646859 +108566 65796 +108566 671328 +108566 700443 +108566 703539 +108566 704150 +108566 712500 +108566 716084 +108566 730308 +108566 734491 +108566 754485 +108566 754732 +108566 762680 +108566 793064 +108566 807322 +108566 809856 +108566 826839 +108566 832900 +108566 832952 +108566 832962 +108566 832995 +108566 833068 +108566 833097 +108566 833217 +108566 833293 +108566 833851 +108566 834240 +108566 834388 +108566 834396 +108566 834397 +108566 834398 +108566 834577 +108566 834640 +108566 834643 +108566 834646 +108566 835073 +108566 835548 +108566 835735 +108566 836114 +108566 836185 +108566 836442 +108566 836744 +108566 836897 +108566 837386 +108566 837442 +108566 837527 +108566 837568 +108566 837582 +108566 837584 +108566 837585 +108566 837588 +108566 837589 +108566 837660 +108566 837661 +108566 837881 +108566 838040 +108566 840391 +108566 840456 +108566 840462 +108566 841439 +108566 841803 +108566 842132 +108566 842146 +108566 842233 +108566 842265 +108566 842308 +108566 842822 +108566 842825 +108566 842832 +108566 843658 +108566 844246 +108566 844416 +108566 845155 +108566 845160 +108566 845769 +108566 846158 +108566 846277 +108566 847372 +108566 848261 +108566 849062 +108566 853844 +108566 856275 +108566 857765 +108566 858575 +108566 858577 +108566 858578 +108566 858579 +108566 861690 +108566 861942 +108566 861945 +108566 866595 +108566 868236 +108566 869650 +108566 870833 +108566 877523 +108566 883380 +108566 883381 +108566 894376 +108566 900378 +108566 900433 +108566 909961 +108566 912299 +108566 912702 +108566 914150 +108566 917033 +108566 917554 +108566 917612 +108566 926717 +108566 931304 +108566 931308 +108566 931349 +108566 931384 +108566 950550 +108566 95541 +108566 95544 +108566 95546 +108566 960922 +108566 960940 +108566 960952 +108566 961746 +108566 961787 +108566 962494 +108566 963376 +108566 974043 +108566 980231 +108566 981904 +108566 989683 +108568 1022025 +108568 1032187 +108568 1032225 +108568 1043208 +108568 1043922 +108568 1046945 +108568 1046946 +108568 1048431 +108568 1051616 +108568 1089583 +108568 1097417 +108568 1129949 +108568 1197745 +108568 1204589 +108568 1206836 +108568 1222912 +108568 1233375 +108568 1278450 +108568 1313279 +108568 1328725 +108568 1336426 +108568 1528426 +108568 153980 +108568 1596232 +108568 1604940 +108568 1629091 +108568 1692113 +108568 1697098 +108568 1709635 +108568 1825132 +108568 1935328 +108568 2013781 +108568 2054086 +108568 2068048 +108568 207945 +108568 216140 +108568 2196755 +108568 2394180 +108568 262940 +108568 267134 +108568 269254 +108568 271870 +108568 276145 +108568 283122 +108568 299702 +108568 3018790 +108568 304975 +108568 3119866 +108568 3187957 +108568 3411323 +108568 3509190 +108568 355662 +108568 3606604 +108568 393383 +108568 397617 +108568 397620 +108568 415725 +108568 446577 +108568 448007 +108568 448010 +108568 454293 +108568 492930 +108568 499563 +108568 517153 +108568 517158 +108568 522210 +108568 527161 +108568 532086 +108568 532089 +108568 552195 +108568 561054 +108568 578719 +108568 578727 +108568 578737 +108568 590074 +108568 631586 +108568 639840 +108568 641250 +108568 646859 +108568 683885 +108568 696171 +108568 696188 +108568 696225 +108568 696238 +108568 700443 +108568 703271 +108568 706861 +108568 712270 +108568 716084 +108568 728361 +108568 730302 +108568 754894 +108568 754974 +108568 793064 +108568 795171 +108568 828590 +108568 832962 +108568 833071 +108568 833075 +108568 833076 +108568 833097 +108568 833108 +108568 833169 +108568 833560 +108568 833667 +108568 833686 +108568 833698 +108568 833722 +108568 833792 +108568 834378 +108568 834577 +108568 834640 +108568 834643 +108568 835265 +108568 835518 +108568 835735 +108568 836049 +108568 836151 +108568 836156 +108568 836185 +108568 836608 +108568 836885 +108568 837661 +108568 838972 +108568 840034 +108568 841441 +108568 842085 +108568 842238 +108568 842824 +108568 842829 +108568 844418 +108568 845359 +108568 845760 +108568 845769 +108568 845771 +108568 846277 +108568 847372 +108568 849128 +108568 849153 +108568 849477 +108568 850906 +108568 851589 +108568 851590 +108568 855761 +108568 855971 +108568 857318 +108568 861487 +108568 861500 +108568 866595 +108568 867236 +108568 867251 +108568 867995 +108568 868370 +108568 869694 +108568 871496 +108568 874943 +108568 880957 +108568 882022 +108568 882758 +108568 890414 +108568 890926 +108568 893638 +108568 895161 +108568 899624 +108568 899626 +108568 907454 +108568 916889 +108568 925945 +108568 931349 +108568 931384 +108568 935301 +108568 935812 +108568 940156 +108568 944561 +108568 949173 +108568 954643 +108568 95546 +108568 96123 +108568 970416 +108568 973391 +108568 973801 +108568 978175 +108568 980515 +108568 983825 +108568 988605 +1085989 41272 +108620 108619 +108620 196988 +108620 77180 +1086397 1485861 +108652 1507277 +108652 19619 +1086561 478424 +108680 127864 +108686 1094178 +108694 290448 +1087 22232 +108708 29690 +108708 71703 +108722 132084 +1087345 1087346 +108735 144351 +108748 127260 +108764 1058728 +108764 120879 +108764 19504 +108764 3313416 +108764 33468 +108764 396836 +1087977 284554 +108818 582909 +1088278 31617 +1088286 1397844 +108833 18956 +1088434 1088436 +1088434 1088437 +1088434 1117783 +1088434 1117784 +1088436 1088437 +1088436 1117783 +1088436 1117784 +1088437 1117783 +1088437 1117784 +1088536 1153210 +1088536 861942 +1088536 861945 +1088746 95537 +1088841 1971282 +1088923 2661482 +108896 6274 +1088982 247945 +1088982 36174 +1088982 394909 +1089019 1147216 +1089019 1181116 +108939 1182247 +108944 1402292 +108944 197255 +1089583 1336426 +108968 133981 +108970 232474 +108975 755910 +1089763 1912861 +1089769 948091 +10898 100313 +10898 224 +10898 28517 +10898 2953 +10898 32216 +10898 32843 +10898 357262 +10898 44915 +10898 58574 +10898 78659 +10898 801 +10898 86545 +1089911 398271 +1089911 993736 +109 1719 +109 232877 +109 505061 +109 537039 +1090 10142 +1090 1091 +1090 409899 +1090 87774 +109010 109011 +1090284 1090285 +1090284 1090286 +1090286 1090285 +109035 44030 +109039 109040 +109046 31009 +1090634 1097696 +1090919 1401908 +1091 10142 +1091 753783 +1091008 466683 +109116 593912 +1091167 1204535 +109129 21070 +109129 279144 +109129 45752 +1091307 1244239 +1091307 1346483 +1091307 1395738 +1091307 1757517 +1091307 194 +1091307 2120864 +1091307 550337 +1091307 807161 +1091307 941372 +1091436 1997740 +1091436 1997741 +109146 23508 +109146 36180 +1091530 140740 +1091530 3297114 +1091530 799148 +1091589 1924662 +10916 238694 +10916 249039 +10916 29735 +10916 528881 +1091715 157220 +10918 4102 +1092074 1092075 +1092092 226459 +1092188 976018 +10922 11887 +10922 8982 +109229 109229 +109229 36100 +109229 97139 +10923 347927 +10923 997017 +1092317 940128 +10924 25771 +1092483 712500 +1092486 896006 +1092486 896007 +1092490 1015406 +1092490 1053194 +1092490 1449987 +1092490 796210 +1092490 833179 +1092490 844081 +1092524 1354730 +1092524 1531265 +1092524 153980 +1092524 3506857 +1092524 859446 +1092524 859998 +1092524 973597 +1092543 304975 +1092548 281455 +1092548 703271 +1092565 1092564 +1092638 861942 +1092638 861945 +10927 15108 +10927 240485 +10927 294196 +10927 50141 +10928 1495753 +10928 289198 +10928 3303159 +10928 3316810 +10928 437936 +10928 66020 +1092822 1743537 +1092822 528134 +1092824 495198 +1092830 1128524 +1093016 1244555 +1093094 1536084 +1093094 158120 +1093094 724168 +1093094 985480 +109316 94841 +1093169 7029 +1093444 3109339 +10936 22278 +10936 26923 +10936 323 +10937 16677 +10937 199818 +10937 285 +10937 2851 +10937 446483 +10937 45392 +10937 57811 +10937 7830 +1093770 1094381 +10939 48772 +109392 920559 +109397 112569 +109397 194 +1094 149 +10940 31814 +1094111 883315 +109418 191200 +109418 266722 +109418 520028 +1094217 109688 +109446 109455 +109446 1345456 +109446 270350 +1094535 1610796 +109455 270350 +109458 1072839 +109458 1933060 +109458 291339 +109458 396939 +109458 86472 +1094581 2039504 +109475 137149 +10948 204298 +1094964 1375266 +1095022 1152841 +1095022 3887149 +109513 182673 +109513 185582 +109513 197812 +109513 212142 +109514 415859 +109514 526750 +109517 503123 +109517 808345 +109519 153882 +1095210 1118443 +1095210 1422868 +1095317 76373 +109554 6375 +10958 11569 +1096 22654 +1096 88540 +109601 201077 +1096231 385924 +10963 238850 +10966 141240 +109661 626175 +109661 647294 +109661 715381 +109662 12550 +109665 429860 +109665 6249 +109665 73785 +1096693 841803 +1096693 842307 +1096693 891601 +1096738 9965 +1096780 1275956 +1096780 3248391 +1096780 703271 +1096780 880957 +1096804 950369 +1096877 1096677 +1096877 2277860 +1096877 511049 +109688 1399 +109688 637608 +1097 237659 +1097 54945 +1097157 1491576 +1097157 191242 +109725 132940 +109725 7053 +1097304 1434251 +1097417 1043922 +1097417 696225 +1097417 871496 +1097417 890414 +1097433 162275 +10975 46004 +109780 153188 +1097804 833014 +109781 84830 +1097891 2658812 +1097894 1467673 +1097946 925586 +1097988 1092096 +1098 1559511 +1098 1846834 +1098 4803 +10980 169412 +1098028 3162744 +1098028 437970 +1098028 614195 +1098050 1269004 +1098050 1269007 +1098050 1269041 +1098061 71172 +1098128 1077175 +109832 110153 +109832 39838 +1098410 1023796 +1098410 1236553 +1098410 1438649 +1098410 842641 +1098410 871873 +1098410 897150 +1098443 111868 +1098443 3018372 +109850 261772 +1098614 1097489 +10988 1339808 +109899 136571 +1099 1489 +1099 2192 +109904 109904 +109904 664891 +10991 1084519 +10991 128173 +10991 1317735 +10991 1492650 +10991 17587 +10991 217492 +10991 223131 +10991 35746 +109920 117816 +109920 7379 +1099290 844849 +10993 53029 +109934 316539 +109934 580068 +10995 14014 +1099725 1931574 +1099725 2447802 +1099725 642828 +10999 1769553 +11 29856 +110 136084 +1100 180252 +110002 101899 +110002 280557 +110002 583942 +110003 1087 +110003 223233 +110003 469050 +110003 77343 +11001 11432 +11001 229057 +11001 9561 +110043 79505 +1100480 1486500 +1100480 2166243 +1100480 236948 +1100480 310013 +1100480 940904 +1100583 411144 +1100584 1100583 +1100584 1100584 +1100584 411144 +1100647 1135363 +1100647 95537 +1100890 799363 +1100914 18055 +1100914 2716491 +1100914 688708 +1100918 1100920 +110104 741755 +11012 17961 +11012 271311 +11012 28332 +11014 183960 +110153 1175722 +110154 162426 +1101544 111506 +1101544 1880115 +1101553 1600955 +110156 1143663 +110156 249861 +110156 255041 +110156 38256 +110156 582883 +110156 90037 +11016 10975 +110189 119870 +1101980 930398 +1102 1100 +1102 56922 +1102057 199183 +1102057 2145356 +110218 400961 +1102306 2215807 +1102627 1478514 +1102627 857251 +110271 85359 +11028 6197 +1103 1102 +1103115 17961 +11034 19069 +11034 5968 +110344 400006 +1103538 1103539 +110359 112754 +110359 26918 +110391 64928 +1104 128021 +1104 1946 +1104 2045877 +1104 232763 +1104 2635 +1104 2751 +1104 28123 +1104 29694 +1104 3066 +1104 412413 +1104 57254 +1104 6681 +1104027 8090 +110406 51106 +1104223 289522 +110426 1841777 +110426 234663 +110426 993429 +110436 824680 +1104512 401666 +1104767 1405024 +1104767 1416655 +1104767 1932292 +1104767 1998849 +1104767 1998850 +1104767 2015317 +1104767 626008 +1104767 768662 +1104991 1083538 +11050 29539 +11050 518366 +11050 5954 +1105192 115461 +1105192 386761 +1105192 933318 +1105255 567511 +1105255 698927 +1105255 799352 +1105374 1290356 +11054 7688 +11055 114163 +110556 46699 +110567 99242 +110570 77354 +1105715 3814087 +1105767 1226027 +1105831 3374418 +110593 223473 +110593 254198 +110593 293346 +1106045 1106044 +1106205 247477 +110656 2352598 +110656 2352599 +110658 64590 +11066 842278 +1106631 807822 +11069 39008 +1107 214654 +1107018 1131052 +1107031 822472 +110704 195667 +110704 8261 +1107070 669685 +110715 4205 +11072 11066 +11072 25893 +110724 87296 +110728 110729 +110728 4781 +1107285 214420 +110729 4781 +11073 10263 +11073 115650 +1107308 1107309 +1107318 1841539 +1107318 1994550 +11074 16797 +110747 1203123 +110747 1215024 +110747 401998 +1107501 931547 +1107505 1374033 +1107505 1398149 +1108032 1149094 +1108032 814152 +1108036 1108037 +110811 564303 +11084 134998 +11084 25734 +1108439 1983 +1108439 289 +110844 110154 +110844 1272781 +110844 130964 +110844 1570 +110844 211211 +110844 31751 +110844 51272 +110844 92281 +11085 10294 +110863 2725 +1108808 1521038 +1108905 1088434 +1108905 1088436 +1108905 1088437 +1108905 1117783 +1108905 1117784 +1108913 322546 +110894 403546 +1108954 391800 +1108958 1654441 +1108958 27952 +110901 13855 +110901 231726 +1109167 1144751 +1109167 1144752 +1109167 1287726 +1109167 1287727 +110925 5160 +110926 113361 +110926 556713 +110926 610062 +110935 163759 +1109391 845154 +1109393 659779 +1109393 834088 +110966 110967 +110966 113282 +110967 113282 +1109773 1272968 +1109941 1063214 +1109941 1603300 +1109941 21833 +1109941 72627 +110995 108020 +1110 1794318 +1110 79078 +1110062 1110063 +1110062 153980 +1110062 614613 +1110062 690972 +1110062 834522 +1110062 838776 +1110063 153980 +11101 10916 +11101 7090 +11101 810205 +11101 810208 +1110141 43281 +1110255 1521611 +111029 168716 +111032 219596 +111053 18171 +111053 280429 +111053 89520 +1110633 974318 +111066 897799 +111067 378421 +111067 929663 +1110689 1183911 +11107 1337593 +11107 597234 +1110798 725144 +1110798 890675 +1110828 447957 +1111 152459 +1111 18620 +111101 183841 +1111129 1658389 +11112 1188261 +11112 304638 +111134 128955 +111139 111138 +111153 306943 +111160 2841824 +1111647 1137815 +1111721 1452918 +111179 79095 +111232 20461 +111232 66418 +1112340 880077 +1112341 1831642 +1112345 67805 +11124 11125 +111265 30256 +1113148 310803 +111320 40582 +11133 10802 +11133 11160 +1113331 1262207 +1113331 193795 +111353 156492 +111353 372799 +111353 519116 +1113596 1177839 +1113596 1377315 +11136 143916 +11136 239367 +11136 500606 +1113636 1007044 +1113636 1019835 +1113650 1264256 +1113650 15787 +1113650 366003 +1113757 361544 +111377 26632 +111387 163554 +111387 163555 +111387 175909 +1114 1165 +1114 695689 +1114 962052 +11140 170015 +11140 2813 +11140 3111 +11140 52786 +1114048 1661527 +111419 156513 +111437 210568 +111437 506370 +1114533 1171517 +111455 688 +1114557 154285 +1114557 212299 +1114557 260744 +1114557 368137 +1114557 843041 +1114557 853983 +1114557 92243 +1114557 926596 +1114557 999189 +111465 495042 +111481 599559 +1114885 1410067 +1114885 505738 +1114917 1012509 +1114917 1604940 +1114917 1862785 +1114917 373345 +1114917 526589 +1114917 837871 +1115 996529 +111502 172962 +111502 229665 +111502 321128 +111502 388514 +111502 415036 +111502 449405 +111502 61920 +111502 98498 +111506 1880115 +111506 218659 +1115089 1423273 +111519 734860 +111523 246441 +1115338 1334023 +1115338 2989950 +1115338 3184805 +1115353 1178325 +1115383 128124 +111545 1133281 +111545 116296 +111545 120345 +111545 223782 +111545 304114 +111545 571753 +111545 759942 +111582 113916 +111582 22615 +111582 234138 +111582 2350038 +111582 645127 +111582 68702 +111582 944882 +1116136 167317 +1116136 7710 +1116136 904910 +1116169 811625 +111637 17396 +111645 113916 +111645 191756 +111645 339248 +111645 446205 +111646 120460 +111646 505715 +111650 111650 +111650 1291459 +111650 186773 +111650 31418 +111650 6123 +111650 6601 +111650 93386 +111654 131461 +111654 233687 +111654 600387 +1116595 103747 +1116668 85768 +1116725 1234689 +1116783 1031891 +1116811 283473 +1116811 3488542 +1116811 448008 +1116811 841213 +1116811 95544 +1117114 1770632 +1117114 433979 +1117180 21147 +1117276 1378565 +1117276 1575344 +1117433 166284 +1117694 132882 +1117694 407748 +1117696 542 +1117696 558784 +1117696 615829 +1117754 164217 +1117783 1117784 +1117786 849349 +1117934 1584642 +1117934 1876949 +1117934 456764 +1118 1456334 +1118 3675 +1118 376087 +111815 155801 +1118166 1277238 +1118166 1653617 +1118175 1118177 +111838 64064 +111843 11525 +1118443 1422868 +111868 1496774 +111868 379636 +111868 477205 +111868 8202 +1118697 1504918 +1118717 373107 +1118877 1032842 +11190 209940 +11190 43672 +11190 44525 +111907 1538794 +111907 218836 +1119078 1299163 +1119083 1200381 +1119083 210244 +1119091 899146 +1119276 1119276 +1119276 1719085 +1119276 1823055 +111949 8410 +11195 191103 +11195 43672 +11195 46910 +11195 56469 +11197 16242 +11197 21135 +11197 708750 +1119849 253110 +112 14920 +112 276136 +1120029 806436 +1120029 843324 +1120073 1240479 +1120073 639379 +11202 2811 +11202 92788 +1120221 557109 +112027 112363 +112027 85499 +11203 2944 +112039 244051 +1120458 520684 +1120489 266389 +1120895 1120896 +1121212 1385852 +1121605 1121604 +1121866 820353 +1121888 1250614 +1121888 291688 +1121888 496778 +1121948 826840 +1121948 837060 +1121948 861487 +1121948 915657 +1122081 820748 +1122169 1046945 +1122169 1236438 +1122169 1558211 +1122169 833168 +1122169 922551 +1122328 1081196 +1122439 145191 +1122439 673009 +1122439 985251 +1122606 1147814 +1122674 226851 +1122890 989917 +11230 11279 +112317 10574 +112323 230048 +112323 578565 +1123268 1123269 +1123409 376312 +112355 152538 +112363 85499 +1123684 3136209 +112394 168224 +112406 116324 +1124484 2470688 +11245 120884 +11245 7627 +11245 7828 +1124512 2185133 +1124596 1070194 +1124596 1124597 +1124598 1070194 +1124598 1124596 +1124598 1124597 +112484 207676 +112485 717897 +1124933 60742 +11254 124429 +112555 160061 +1125579 2095346 +1125579 806700 +112558 6270 +112572 99787 +1125827 428544 +112584 306202 +1125849 935478 +112585 256638 +112586 1517502 +112586 606027 +112586 783978 +1125999 2541 +1126066 179709 +1126066 2021875 +112608 2184586 +1126320 1200943 +1126320 1968914 +1126409 999914 +11267 169148 +1126734 2034018 +1126771 251976 +1127308 604262 +112737 132084 +112737 9741 +112738 4970 +1127509 1646875 +1127509 3010101 +1127509 454981 +1127509 835415 +1127509 970416 +1127509 988905 +112754 51988 +1127697 1846272 +112775 112778 +112775 117415 +112775 154702 +112775 21763 +112775 29895 +112775 37236 +112775 88496 +112777 154702 +112778 154701 +112786 221030 +112793 113041 +112793 13820 +112795 110744 +112795 1109773 +112795 1272968 +112798 2338239 +112798 740890 +112799 341346 +112800 112801 +112801 101756 +112801 1029257 +112801 112795 +112801 113041 +112801 368901 +112801 471122 +112801 471123 +112805 42191 +1128299 1189687 +1128299 1219713 +1128299 1297976 +1128299 857406 +1128350 1613602 +11287 13190 +1128724 1952102 +1128785 1128783 +112879 568832 +112881 2192736 +112884 49244 +112889 1429542 +112889 1429543 +112891 356790 +112892 375414 +112897 82738 +1129 5140 +112900 191294 +1129430 256972 +1129490 2310352 +1129568 395913 +1129568 712500 +112958 1194311 +112958 236339 +112958 365230 +112961 188627 +112961 188628 +112965 243638 +112966 101847 +112977 165262 +112983 69702 +1129912 1568141 +1129949 1220779 +1129949 1640338 +1129949 262940 +1129949 368137 +1129949 833787 +1129949 833824 +113 316772 +1130211 1561932 +113025 113026 +113041 1377088 +113048 225225 +1130686 1018517 +113071 1322663 +113071 228763 +1130742 1130743 +1130829 421547 +113090 10519 +113090 113091 +1130935 1981602 +113094 1224348 +113094 1479359 +113094 57280 +113094 63119 +113094 925303 +113126 91761 +113131 130471 +113131 50179 +113146 1051696 +1131627 1317447 +1131718 1131717 +1131825 3127952 +113185 184 +113185 664367 +1131908 51368 +1131912 1131913 +1132040 1337504 +1132040 407126 +1132052 783189 +113213 106490 +113213 416234 +11323 241251 +1132388 672508 +11324 1087230 +11324 14111 +11324 228904 +11324 553396 +1132446 1834073 +1132446 2544136 +1132446 689243 +1132489 95546 +11325 1425 +11325 2718 +113261 69358 +1132782 880824 +1132858 1558876 +1132998 1438254 +11332 130718 +11332 73368 +11333 47919 +11333 61944 +1133325 1314007 +1133325 871121 +113333 1004529 +1133351 1133352 +1133536 2527504 +1133586 1242077 +113361 556713 +113366 208659 +113366 31820 +113397 359871 +113407 2810073 +113418 245232 +113418 31121 +113418 797402 +113428 32197 +113430 59226 +113432 283558 +1134484 262181 +1134613 1764775 +1134613 817317 +113463 148445 +113467 144910 +113470 67039 +113471 88548 +113477 34932 +1134793 1000561 +113497 100756 +113497 109832 +113497 66154 +113497 76911 +113499 113497 +1135091 1689341 +1135091 417333 +1135123 1157781 +1135123 840752 +1135164 2040190 +1135197 552195 +1135197 688716 +1135197 833686 +1135197 845359 +1135197 939230 +1135199 207945 +1135199 446471 +1135228 649585 +1135228 834088 +1135228 835650 +1135258 152529 +1135258 6540 +113526 2497873 +1135361 266389 +1135361 36860 +1135363 168907 +11358 80588 +113586 1715278 +113586 452986 +113599 104876 +113599 1777 +1136040 62991 +1136139 1183157 +1136139 627128 +1136486 1081411 +1136488 792382 +1136525 1244083 +113655 252161 +1136577 1496456 +1136577 1807 +1136579 2068346 +1136579 522209 +1136579 522210 +1136579 833168 +1136579 839696 +113659 1026065 +113659 93146 +113663 202114 +113673 181523 +113673 22757 +113673 79091 +113673 80019 +113673 80027 +113679 63771 +113712 113713 +1137124 2556643 +1137249 1461920 +1137371 853432 +113750 115941 +1137762 965350 +113778 25010 +1137834 375924 +1137844 1427815 +1137844 309991 +113788 111582 +113789 113945 +1138058 1164867 +113813 748204 +1138172 2548125 +11382 16119 +1138200 1413797 +1138200 1432923 +1138200 1490523 +1138200 2080717 +1138200 2231485 +1138200 2799231 +1138200 3525952 +1138200 3567131 +1138200 535723 +1138200 559497 +1138200 757837 +1138200 887155 +1138217 1025076 +1138217 2000491 +113823 56406 +1138302 921435 +11386 27529 +113886 148308 +113886 228066 +1138899 1138898 +1138899 1138901 +1138899 2006344 +1138899 575045 +1138899 873186 +1138900 1825983 +1138900 2873325 +1138900 2873326 +1138900 2873327 +1138901 1138898 +1138901 2006344 +113895 21504 +1138961 322517 +1138961 857132 +1138996 12857 +1139044 1038 +113907 43099 +11391 22637 +113916 201470 +113916 79211 +113926 160610 +11393 237564 +11393 27969 +11393 30643 +11393 69967 +1139449 1139451 +113945 175914 +1139584 834306 +1139802 301733 +1139863 79220 +11399 13665 +11399 7025 +1140 1193 +1140 20195 +1140 21068 +1140 750 +1140208 374522 +1140208 45392 +1140208 612349 +1140243 192325 +114032 358997 +1140478 1472363 +1140847 3039054 +114092 24580 +1141 12051 +1141 4978 +114110 408913 +114123 331799 +114126 81440 +11414 117334 +1141504 755957 +1141532 1141531 +1141625 260209 +1141651 227234 +1141688 559002 +114178 479706 +1141795 239236 +1141795 283122 +1141795 623293 +11418 28521 +11419 64601 +1142337 10290 +1142516 832661 +1142516 95546 +114257 15169 +1142686 1122911 +1142686 250730 +1142688 872167 +114270 31418 +114270 577653 +114288 119025 +11429 11426 +1142909 145811 +1142983 7217 +1142990 34955 +11432 114297 +11432 11432 +11432 18382 +11432 198427 +11432 21503 +11432 229057 +11432 25009 +11432 31516 +11432 36381 +11432 453219 +11432 593813 +11432 6123 +11432 93383 +11432 9561 +11433 111359 +11433 113916 +11433 116010 +11433 129259 +11433 21503 +11433 21504 +11433 30816 +11433 31424 +11433 79211 +11433 91484 +11434 113778 +11434 11432 +11434 1147 +11434 17391 +11434 177713 +11434 20427 +11434 21504 +11434 6123 +1143483 19767 +11435 113916 +114367 1939366 +11438 11573 +11438 133075 +11438 1397472 +11438 153051 +11438 215194 +11438 237066 +114390 1214435 +114390 574093 +11440 34169 +1144106 786590 +1144136 1166650 +114457 8346 +114457 8349 +114457 960293 +1144691 259369 +11447 1817241 +11447 87241 +1144751 1144752 +114483 268583 +11449 18984 +114505 198501 +114505 78243 +1145056 1145055 +1145122 476221 +1145122 791414 +114532 110844 +114532 1463 +114532 21748 +114532 4 +114532 9467 +114532 9704 +1145469 132000 +1145501 2606049 +1145501 92184 +11456 148323 +114566 74189 +1145807 170884 +1145980 4013 +1146034 2284146 +1146510 1216464 +1146664 838991 +1146734 1005319 +1146958 1009767 +1146958 1198111 +1147 11432 +1147 1147 +1147 759425 +1147 838654 +1147 838655 +114710 1356 +114710 2510433 +114710 546596 +114710 843618 +1147295 1147294 +1147295 436743 +114733 253217 +114733 416154 +1147511 2745683 +114763 114764 +1147766 1147767 +1147860 1470078 +1147936 1776044 +1147936 604071 +114803 115376 +1148036 1148035 +114823 110359 +114823 112754 +114823 26918 +114823 28738 +114823 36099 +114823 36988 +114823 66144 +11488 17533 +114883 552159 +1148893 852338 +1148894 1148893 +1148894 852338 +1149094 814152 +11491 2159731 +11491 228032 +11491 244065 +11491 37905 +11491 4033 +11491 550073 +11491 72795 +114916 366273 +114919 22877 +1149223 2785274 +1149500 514894 +1149515 1887297 +1149661 959370 +1149672 1149671 +1149753 395913 +1149753 406273 +1149753 966985 +1149753 986112 +114979 293154 +1149872 830422 +115016 266260 +115016 547535 +115018 62912 +1150315 1156427 +1150333 1163926 +1150333 1759585 +1150333 3981191 +1150333 3981192 +1150495 1150496 +1150495 975597 +1150496 975597 +1150501 1202393 +115060 115061 +115060 3096 +115061 3096 +1150757 669485 +1150778 161608 +115091 63230 +1151 1100 +1151139 2116208 +1151139 534293 +1151297 1040266 +1151333 1548103 +1151333 2203553 +1151333 979552 +1151374 1077175 +1151374 1098128 +1151374 1427885 +1151402 1239041 +1151425 413878 +1151425 625001 +115177 372524 +1151823 288508 +1151823 3025035 +1151992 269254 +1152266 192325 +1152266 617133 +1152266 832942 +1152266 946948 +115251 176526 +115251 216448 +115251 222827 +1152605 1696713 +115270 232373 +1152705 1026513 +1152705 567941 +1152871 1495753 +1152871 1660363 +115297 75876 +115308 629718 +1153210 861942 +1153210 861945 +1153238 1153282 +1153613 154537 +1153675 952480 +1153713 175995 +11538 216097 +1153800 2187 +1153853 12884 +1153964 117845 +1154 20195 +1154060 732838 +115410 1874390 +115410 229853 +1154116 1485495 +1154119 94487 +1154202 1347288 +11543 24390 +1154357 319970 +11546 101707 +1154603 1769424 +115461 1014466 +115461 1015406 +115461 1039346 +115461 1068298 +115461 108439 +115461 1086491 +115461 1114533 +115461 115469 +115461 1171517 +115461 1336426 +115461 1351877 +115461 1467174 +115461 1558190 +115461 1595298 +115461 1604742 +115461 1636229 +115461 1671770 +115461 1734742 +115461 1950815 +115461 2004798 +115461 216140 +115461 224329 +115461 2324662 +115461 260744 +115461 262940 +115461 269254 +115461 271870 +115461 27519 +115461 276145 +115461 2801102 +115461 283122 +115461 283125 +115461 299702 +115461 304968 +115461 339756 +115461 343871 +115461 349149 +115461 361814 +115461 388185 +115461 3887234 +115461 410038 +115461 435555 +115461 454293 +115461 550341 +115461 552196 +115461 595478 +115461 604396 +115461 627128 +115461 653372 +115461 696215 +115461 732482 +115461 736605 +115461 744723 +115461 754894 +115461 759182 +115461 762355 +115461 784121 +115461 806436 +115461 809856 +115461 832917 +115461 833033 +115461 833038 +115461 833179 +115461 834226 +115461 834577 +115461 834646 +115461 835112 +115461 835204 +115461 835739 +115461 838929 +115461 841590 +115461 842134 +115461 842135 +115461 843513 +115461 844250 +115461 846277 +115461 846281 +115461 848555 +115461 849795 +115461 875252 +115461 875256 +115461 883380 +115461 883641 +115461 900448 +115461 915941 +115461 939901 +115463 108566 +115463 260744 +115463 283122 +115463 375279 +115463 497542 +115463 550341 +115463 578734 +115463 623293 +115463 641164 +115463 65796 +115463 662168 +115463 671328 +115463 793064 +115463 832900 +115463 832962 +115463 833097 +115463 834226 +115463 834640 +115463 834643 +115463 835735 +115463 836895 +115463 837582 +115463 837585 +115463 844416 +115463 867925 +115463 870833 +115463 95537 +115463 95541 +115463 95543 +115463 999914 +115464 115464 +115464 1202353 +115464 2030478 +115464 2738826 +115464 361603 +115464 859780 +115464 928199 +115464 991532 +115466 1009447 +115466 1032521 +115466 1137908 +115466 115469 +115466 1208567 +115466 1435431 +115466 2209779 +115466 224329 +115466 255709 +115466 260744 +115466 262940 +115466 27519 +115466 283122 +115466 299702 +115466 322537 +115466 347268 +115466 374006 +115466 388185 +115466 395913 +115466 406278 +115466 406281 +115466 406283 +115466 415720 +115466 448008 +115466 448010 +115466 454293 +115466 454981 +115466 456764 +115466 517144 +115466 522209 +115466 547971 +115466 617133 +115466 627128 +115466 648567 +115466 688716 +115466 696188 +115466 696225 +115466 706861 +115466 711106 +115466 712270 +115466 712500 +115466 744724 +115466 754894 +115466 784121 +115466 805380 +115466 809856 +115466 810424 +115466 832915 +115466 832992 +115466 833033 +115466 833128 +115466 833179 +115466 833686 +115466 833697 +115466 834378 +115466 834577 +115466 835066 +115466 835409 +115466 835739 +115466 837550 +115466 838243 +115466 838295 +115466 838384 +115466 841294 +115466 842132 +115466 843513 +115466 843647 +115466 855072 +115466 867979 +115466 867991 +115466 883641 +115466 884545 +115466 906873 +115466 920313 +115466 970416 +115466 978211 +115467 119484 +115467 227870 +115467 395913 +115467 532414 +115467 578743 +115467 775237 +115469 1011986 +115469 1026198 +115469 1031993 +115469 1055111 +115469 1055533 +115469 1067144 +115469 1092483 +115469 11696 +115469 1192702 +115469 1205065 +115469 1228647 +115469 1228648 +115469 1251923 +115469 1260606 +115469 1327245 +115469 1362287 +115469 1386787 +115469 1406392 +115469 1424606 +115469 1433248 +115469 1433251 +115469 1433853 +115469 1516786 +115469 1516791 +115469 1516797 +115469 1516820 +115469 153980 +115469 1685019 +115469 1802107 +115469 1951773 +115469 1982778 +115469 2057828 +115469 212299 +115469 212301 +115469 2323597 +115469 2446086 +115469 2446087 +115469 253245 +115469 258078 +115469 260744 +115469 262940 +115469 269254 +115469 271870 +115469 271877 +115469 2737571 +115469 283122 +115469 283125 +115469 283473 +115469 289522 +115469 294480 +115469 299702 +115469 310388 +115469 333892 +115469 334081 +115469 361814 +115469 368137 +115469 377139 +115469 388185 +115469 394791 +115469 395913 +115469 397617 +115469 406271 +115469 406278 +115469 406285 +115469 410038 +115469 415720 +115469 432960 +115469 435555 +115469 446577 +115469 448007 +115469 448010 +115469 454293 +115469 457732 +115469 465982 +115469 472036 +115469 490290 +115469 502826 +115469 517144 +115469 526576 +115469 539271 +115469 539272 +115469 543428 +115469 547971 +115469 552196 +115469 567511 +115469 575941 +115469 617133 +115469 626175 +115469 627128 +115469 628237 +115469 653535 +115469 688716 +115469 690972 +115469 696200 +115469 703271 +115469 712500 +115469 718775 +115469 744724 +115469 754894 +115469 754974 +115469 767788 +115469 779502 +115469 784121 +115469 805380 +115469 810424 +115469 832917 +115469 832924 +115469 832992 +115469 833179 +115469 833181 +115469 833560 +115469 833697 +115469 833698 +115469 834229 +115469 834611 +115469 834646 +115469 835518 +115469 837568 +115469 838380 +115469 838409 +115469 844250 +115469 855761 +115469 858577 +115469 861690 +115469 862699 +115469 880605 +115469 899900 +115469 906658 +115469 908890 +115469 921040 +115469 921042 +115469 92243 +115469 931685 +115469 95546 +115469 966368 +115469 984958 +115469 999914 +1154796 434124 +1155411 1422857 +1155411 576026 +1155411 754894 +1155411 832917 +1155411 871496 +1155411 895582 +1155411 970420 +1155414 1381485 +1155414 207945 +1155414 361608 +1155414 406423 +1155414 832995 +1155414 834397 +1155414 961746 +115551 680218 +115551 86163 +1155903 1468981 +1155903 239566 +1155903 633282 +1155903 663652 +1156313 1308094 +115648 548815 +1156549 2263651 +115656 1935 +1156906 1058254 +1157107 766102 +115715 8175 +1157266 354407 +11573 24532 +11573 272447 +11573 441261 +11574 106458 +11574 11573 +11574 36378 +11574 6070 +11574 61939 +1157405 256562 +1157474 243277 +1157481 1157491 +1157481 627128 +11575 11573 +11575 225223 +11575 39206 +115754 123447 +1157619 1269513 +1157619 1270472 +1157619 1346429 +1157619 1419770 +1157619 229566 +1157619 424276 +1157619 740149 +1157619 836106 +1157619 844443 +115766 37234 +115766 9828 +115796 1113605 +115796 1113639 +1158058 813126 +115809 115810 +11581 843618 +1158120 373377 +1158120 455099 +1158120 721331 +115826 25375 +11583 28497 +11584 16893 +11584 16930 +11584 232313 +115844 99402 +1158582 1257803 +1158582 2806414 +115863 146052 +115863 146066 +115863 352647 +115863 386857 +115863 386863 +115863 97535 +115864 49803 +115864 498171 +1158755 1677110 +115888 117668 +115888 283569 +1158913 1158915 +1158998 1721323 +115927 185847 +11593 1196835 +11593 1344 +11593 269430 +11593 372997 +11593 5965 +11593 619075 +115941 382934 +1159609 108343 +1159609 2701234 +1159609 593613 +1159609 593617 +1159609 636636 +1159609 833332 +1159613 1230754 +1159613 1506509 +1159613 1564317 +1159613 974665 +1159961 7679 +116 18956 +116 30782 +1160 184840 +1160 3415 +1160 7841 +116010 1032611 +116010 114297 +116010 145639 +116010 2312 +116010 3478411 +116010 800646 +116011 177257 +1160362 1009232 +1160362 2483583 +1160362 406423 +1160362 754958 +1160397 1746347 +11606 11607 +11606 21349 +11606 36134 +116072 1841003 +116072 46782 +116072 55203 +1160759 1178089 +1161154 1640151 +1161183 1161184 +116119 99243 +1161270 1161269 +116132 529373 +1161582 19881 +1161810 1561760 +1161810 1611920 +1161810 920263 +116189 2279867 +116201 436855 +116217 347301 +1162365 363087 +11624 11584 +1162425 1013239 +11625 11584 +11625 154418 +11625 16930 +11625 200645 +11625 200646 +11625 231919 +11625 238904 +11625 335065 +11625 48215 +11625 5965 +116253 2725 +116256 505754 +11627 11624 +11627 223216 +1162738 674785 +116296 304114 +1163211 2592554 +1163211 3584756 +1163364 288358 +1163402 942359 +116345 450186 +1163455 96273 +116348 1065010 +116348 132084 +116348 229665 +116348 357753 +116360 787700 +1163649 2832018 +116366 254578 +116381 322258 +1163926 1759585 +1163926 3079028 +1163926 3981192 +1164 14634 +1164 32655 +1164 34563 +1164 879 +1164232 592269 +1164327 1919669 +1164342 1196443 +11645 2325 +11645 30950 +11649 2264 +1165 2596 +1165 8330 +1165015 952395 +1165015 991190 +11652 20364 +11652 65273 +1165213 498573 +1165383 289089 +1165410 1748328 +1165499 805613 +1165554 265566 +1165556 1031262 +1165556 1239660 +1165556 1415870 +1165556 1415871 +1165556 1653542 +1165556 1909874 +1165556 577808 +1165556 833625 +1165556 854228 +1165556 858375 +1165562 1009447 +1165562 1147100 +1165562 179709 +1165562 696257 +1165562 837674 +1165562 905491 +1165636 289522 +1165636 975597 +1165705 81576 +116601 276060 +116602 109961 +116602 7213 +116604 257377 +116604 339700 +1166174 2917759 +1166174 497259 +11663 11858 +1166337 1104767 +1166337 1405024 +1166337 1416655 +1166337 1932292 +1166337 1998849 +1166337 1998850 +1166337 2015317 +1166337 244096 +1166337 626008 +1166337 768662 +11664 27263 +1166441 1195564 +116661 113774 +116679 105869 +116679 116681 +116679 167557 +116679 169783 +116679 310505 +116679 370771 +116679 375953 +116681 94500 +1166828 870670 +116683 105865 +116683 106541 +116683 162553 +116683 258318 +116683 258388 +116683 2652537 +116683 27657 +116683 2818966 +1166843 412749 +116685 115863 +116685 219982 +116685 386863 +1166944 898038 +1166944 978661 +1166964 1214712 +1166964 1254914 +1166964 1402603 +1166964 286269 +1166964 313803 +1166964 31444 +1166964 326945 +1166964 433615 +1166964 438264 +116703 107561 +1167089 1123409 +116709 106541 +116709 106651 +116709 157220 +116709 167557 +116709 29821 +116709 402224 +116709 828873 +116712 386863 +1167335 1993486 +1167467 1245031 +1167467 1245032 +1167467 1245033 +1167467 1278653 +1167467 2316576 +1167467 2918310 +1167467 837527 +11676 1034034 +11676 110839 +11676 231118 +11676 315408 +11676 448993 +11676 567693 +1167633 256323 +1167655 2601050 +1167664 650070 +116787 110103 +1167873 1167875 +1167873 1950887 +116790 113673 +116790 181523 +116798 13358 +116798 38806 +1168019 2079893 +116805 2662837 +11681 26657 +11681 8356 +11682 27941 +11682 418557 +116830 164363 +1168371 1345894 +1168371 140234 +1168371 257966 +1168371 284994 +1168371 44937 +1168371 706774 +1168648 1387652 +1168648 1387658 +1168685 1501948 +1168685 1627281 +11687 100648 +1168814 1003513 +1168814 1448069 +1168814 388889 +1168835 21508 +1168843 3522180 +1168897 1361709 +11691 1362458 +11691 318507 +11691 349785 +11691 369068 +11691 640396 +1169313 678079 +1169330 1462868 +11695 461570 +1169513 1245031 +1169513 1245033 +1169513 1278653 +1169513 2551032 +1169513 2551035 +1169513 2551039 +1169513 3248391 +1169513 3370810 +1169515 1245033 +1169515 1278653 +1169515 3248391 +1169516 1278653 +1169516 2551038 +1169516 2551039 +1169516 2918308 +1169516 3248391 +11696 1011986 +11696 1031993 +11696 1068298 +11696 1105255 +11696 1153041 +11696 115461 +11696 1205065 +11696 1269390 +11696 1362287 +11696 1406392 +11696 1424606 +11696 1516786 +11696 1516791 +11696 1516797 +11696 1516820 +11696 174100 +11696 262940 +11696 27519 +11696 299702 +11696 379809 +11696 388185 +11696 457732 +11696 547969 +11696 547971 +11696 567511 +11696 576026 +11696 690972 +11696 698927 +11696 767788 +11696 799352 +11696 809856 +11696 832962 +11696 835735 +11696 841357 +11696 842135 +11696 848555 +11696 855065 +11696 870631 +11696 880605 +11696 884062 +11696 899900 +11696 926316 +11696 95537 +11696 999914 +1169602 299084 +1169724 415393 +1169747 409252 +1169798 1205278 +11700 6010 +1170033 919938 +1170046 1611 +1170046 721281 +117017 117018 +1170477 932321 +117051 76828 +11706 12458 +11706 15108 +11706 18547 +11706 20579 +1170762 1594756 +1171 19154 +11711 45161 +11712 980145 +1171255 573029 +1171255 948478 +1171419 32530 +117163 123904 +117163 396942 +1171649 407303 +117179 117180 +1171936 201620 +117195 135261 +117224 64664 +1172267 843870 +1172316 1951275 +1172316 317584 +117236 1219094 +1172411 296624 +1172441 103126 +1172814 1417926 +1172814 434336 +1172832 217162 +1173063 1173062 +1173227 240638 +1173256 2048518 +11733 1409 +11733 1636932 +11733 194 +11733 9912 +117352 682096 +1173606 1003179 +1173606 1053170 +1173606 861581 +1173665 260744 +1173665 448010 +1173665 451535 +1173665 517163 +1173665 578727 +1173665 696225 +1173665 833697 +1173665 847180 +1173665 858577 +1173665 890414 +1173666 1173667 +1173680 415964 +11737 53259 +1173870 1116668 +117399 73291 +1174 1617 +117415 1051454 +117415 1093326 +117415 29895 +117419 2780724 +117419 331100 +117420 224073 +117420 520123 +1174410 1353787 +1174486 937815 +11745 400432 +11746 39829 +117461 209673 +117472 12819 +1174729 421997 +117480 1057939 +117480 114803 +117480 115376 +1174805 4690 +1174858 669426 +11749 18353 +11749 223468 +11749 36377 +11749 38910 +1175 4197 +1175 522376 +1175050 36100 +1175088 1486126 +117523 333415 +1175368 170092 +1175368 318396 +117541 2535488 +1175736 1175692 +1175775 1175775 +117598 17413 +1176201 127076 +117626 86464 +117652 367899 +1176685 1176686 +1176685 1476125 +1176686 1476125 +1176855 2486004 +117687 269254 +11769 203750 +11769 322932 +11769 395900 +11769 614963 +11769 678387 +1177 1906 +1177032 1177033 +1177051 2039304 +1177051 453814 +117710 154701 +117710 41891 +117710 438141 +117718 164363 +117718 91588 +117723 291641 +117723 304190 +117723 347203 +117723 388836 +117723 411692 +117723 54520 +117723 90203 +1177344 2307652 +1177603 1041345 +117773 117774 +1177811 1367250 +1177811 283127 +1177811 754974 +1178 48825 +1178021 97498 +1178086 1160759 +1178086 1178089 +117819 235990 +117851 1454103 +11786 21032 +1178677 1178678 +1178677 1292259 +1178677 2482 +1178677 44844 +1178678 1292259 +11787 1881423 +11789 800776 +117890 117891 +1178954 2014190 +1178954 2027931 +1178954 2176711 +1178954 2176712 +1179 1180 +1179050 1496725 +1179065 21032 +117914 901233 +1179182 1014245 +1179182 1179182 +1179182 1206273 +1179182 1481471 +117919 187715 +1179326 1163547 +1179810 1209910 +1179810 534859 +1179820 4948 +1179821 1036154 +1179821 1257632 +1179914 614648 +1180129 1180128 +11802 543427 +118025 111582 +1180370 1121920 +1180391 36506 +1180391 41388 +118040 4687 +118042 1130861 +1180421 848600 +1180430 534451 +118061 98300 +118078 58369 +1180800 148227 +118082 1372396 +1180987 1009267 +1180987 1040169 +118102 7036 +1181067 785726 +118127 11733 +118127 1244445 +118127 13332 +118127 31347 +118127 35516 +118127 493012 +118127 54089 +118127 7921 +11813 287139 +11813 47405 +11813 56129 +118171 33184 +1181868 1479184 +1181868 1967610 +1181868 243613 +1181868 7806 +11819 39359 +1182 10430 +11820 113659 +11820 219866 +11820 3337 +11820 46955 +1182097 2348113 +118223 215559 +118228 176724 +1182302 1182301 +118241 2265 +1182579 10001 +1182581 1716872 +1182581 3430871 +1182582 1195374 +1182582 1954790 +1182582 2356435 +1182582 2356436 +1182783 415720 +11828 46627 +1182853 1124075 +11829 332 +11829 336768 +11829 51731 +11829 546934 +11829 6075 +11829 7511 +1183 3497 +118307 1319181 +118307 198433 +118307 344109 +118307 781154 +118307 799858 +118313 366822 +1183147 148999 +1183147 1523681 +1183147 2006245 +118328 118329 +118328 87251 +118329 87251 +1183315 29895 +1183315 77811 +1183460 1182715 +1183590 2419637 +1183590 446105 +1183590 552195 +1183590 641250 +1183590 688716 +1183590 853359 +1183639 1239660 +1183639 170759 +1183639 170760 +11837 37224 +1183964 1288971 +1184041 274531 +11841 9504 +1184566 598920 +1184684 1206854 +1185229 918803 +11853 134395 +1185990 153980 +1186 4124 +1186 46740 +1186 762019 +118601 99341 +11864 3302 +118648 65080 +1186608 246221 +1186813 1036751 +1186813 1036752 +1186813 2859358 +1186814 1186813 +1186834 8501 +1186844 1048983 +118709 74197 +1187198 1187199 +11872 1607151 +11872 2791022 +11872 3142738 +11872 451731 +11872 67124 +1187275 64259 +1187285 1491212 +1187285 708613 +1187741 252868 +11879 163850 +11879 18839 +11879 31844 +11879 41232 +11879 66358 +1188 10504 +1188 10994 +1188 15283 +1188 286715 +1188 67774 +11880 215482 +1188140 1188139 +1188198 2066042 +1188261 304638 +118836 17035 +11884 227571 +1188403 1076301 +1188403 162275 +118853 110413 +11886 854223 +11887 1295 +11887 14674 +11887 1605572 +11887 66851 +11887 73336 +11887 78873 +11887 85524 +118891 13594 +1188913 1271316 +11892 147081 +118926 100946 +118933 118934 +1189388 1151238 +1189388 1228655 +118939 2744606 +118939 316586 +118939 467740 +118940 1157738 +118942 260860 +118947 20513 +1189620 1411076 +1189620 455477 +118964 452083 +1189642 1128299 +1189668 1390870 +1189668 900097 +118999 207468 +118999 289613 +118999 336402 +118999 643584 +119 223165 +119 87224 +119 879 +119 9644 +119005 772151 +119009 816783 +119012 57857 +1190223 14111 +1190319 79029 +1190614 918469 +1190697 29158 +119083 499563 +119083 645741 +119083 837533 +119084 190370 +119084 282639 +119084 282644 +119084 494994 +119084 65807 +11909 49244 +1191204 19274 +11913 40583 +11913 49529 +11913 74170 +11913 82979 +11913 89554 +1191308 519934 +1191308 822410 +1191308 822517 +119142 241513 +1191463 260208 +1191708 1229160 +119188 55454 +1192098 53760 +1192145 352173 +1192282 1454794 +1192282 3123629 +1192372 394778 +119250 147708 +1192643 1025033 +1192800 1192800 +1192800 201625 +1192800 596004 +1192811 1192811 +1192811 166847 +1192829 1219756 +1192829 1977334 +1192841 1468646 +1192841 1552022 +1192841 835518 +1192841 855061 +1192841 861690 +1192848 276435 +1192848 585178 +1192848 998666 +119285 376424 +119296 241311 +119304 978128 +1193226 386441 +1193310 1193311 +119339 119340 +119347 32439 +119349 50200 +119396 121732 +1194142 926716 +1194448 1247653 +1194448 1468726 +1194448 1468727 +1194500 289366 +1194554 67435 +119483 1532214 +119484 227870 +119484 294480 +119484 462257 +119484 465983 +119484 578743 +119484 732482 +1194848 3021306 +1194864 503126 +1195074 381060 +119518 361356 +1195374 1954790 +1195410 1490529 +1195410 677545 +119546 119546 +119546 233061 +119546 397676 +119546 90203 +119546 94500 +11955 24494 +1195536 3640178 +1195709 1357693 +119581 269252 +119587 1148597 +119589 10351 +1196 215 +1196088 1129490 +1196088 2310352 +1196088 2808101 +119610 84369 +1196411 1313992 +119647 15970 +1196488 888572 +119661 4742 +1197 1203 +1197 26175 +119715 116935 +119715 287519 +119743 212713 +119743 224600 +1197459 1197460 +1197568 920935 +1197745 1024263 +1197745 446471 +1197745 849153 +119775 94853 +119791 5974 +119799 17885 +119799 201577 +1198051 1103523 +119827 132591 +119843 1158582 +119843 1257803 +119843 2806414 +1198438 1252580 +1199 1581 +1199068 1240479 +1199129 1682697 +1199255 323172 +119930 84137 +1199356 1288459 +1199356 224329 +1199356 262940 +1199356 269254 +1199356 397620 +1199356 492245 +1199356 539271 +1199356 539272 +1199356 754974 +1199356 833033 +1199356 95537 +1199400 1199399 +1199553 3655502 +1199553 741653 +1199781 976640 +1200 1415 +120009 210316 +1200241 1200242 +120034 82211 +1200386 1731193 +1200471 1917218 +1200471 900448 +12007 12974 +12007 227504 +12007 583687 +1200733 1751436 +1200733 703268 +1200733 839640 +1200911 2644078 +1200911 267134 +1200911 841441 +1200929 1967985 +1200929 232990 +1200943 1968914 +120121 350601 +120145 48860 +12016 121978 +12016 16 +12016 29360 +12017 36549 +120181 126220 +1202043 345813 +1202092 236639 +1202128 56534 +120214 258476 +1202325 1092252 +1202325 418853 +120233 363546 +1202353 2030478 +120236 120236 +120236 1813779 +120236 193064 +120236 62148 +12024 247030 +1202525 30396 +120256 22076 +120256 69414 +12027 128326 +120290 217672 +120290 234184 +1203002 1802306 +120307 178698 +120307 382819 +120307 76242 +12031 208014 +120312 253240 +120312 254976 +120312 257008 +120312 306715 +120312 55906 +120312 702275 +120328 253447 +120328 253462 +120328 297020 +120328 297021 +120328 312587 +120328 41904 +120328 42708 +120328 736721 +120331 3550 +120331 47579 +120331 549 +1203457 2385844 +12036 2499670 +12036 35832 +1203614 396675 +120376 416210 +1203987 2017249 +1204 19849 +1204 40810 +120404 100457 +12042 177291 +120428 21504 +120430 120430 +120430 190146 +120430 191993 +120430 1949181 +120430 266253 +120430 311327 +120446 113102 +1204589 1206836 +120459 120461 +120460 124683 +120460 25010 +1204667 1204681 +1204773 1088286 +1204849 1204851 +1205012 2735204 +1205065 1031993 +1205065 1362287 +1205065 1406392 +1205065 1424606 +1205065 1516791 +1205065 1516797 +1205065 1516820 +1205065 880605 +1205065 899900 +12051 1102 +120513 68434 +1205278 1926030 +12053 1139 +120532 1923075 +1205338 2383016 +120537 160299 +1205385 1512967 +12055 22115 +1205575 14894 +1205575 15824 +1205712 884530 +1205778 28517 +12058 379514 +1205848 253245 +1205848 262940 +1205860 1230642 +1205899 190371 +1205899 335124 +1205899 66089 +1205899 905337 +120591 25283 +120593 4681 +1206128 1164753 +120620 30552 +120620 64694 +120623 297693 +120623 317191 +120623 432415 +120623 95459 +1206451 877201 +1206709 2460152 +1207 437362 +1207145 113813 +12072 104429 +12074 24708 +1207617 1207622 +120788 1147 +120788 229864 +120808 1628089 +120808 214193 +120808 3484298 +1208293 1208298 +1208399 335273 +1208452 1080248 +1208452 1220779 +1208452 1481537 +1208452 1481547 +1208452 2129819 +1208452 577808 +1208452 837674 +1208452 855073 +1208452 882141 +1208452 889836 +1208452 974483 +1208455 833628 +120848 13196 +120866 21517 +1208686 12884 +1208686 279413 +12087 49140 +1208701 926813 +1208711 1877151 +12088 79108 +120883 39771 +1208893 2598362 +1208970 2480552 +1208970 922947 +1209103 1341208 +120913 120828 +120913 759735 +1209194 959411 +12094 634 +12094 950 +12095 29356 +1209525 552195 +1209525 833125 +1209525 833686 +1209525 861270 +12097 122578 +120990 37673 +1209910 534859 +1210005 180914 +1210157 759522 +12102 614472 +121026 1016722 +121026 237552 +1210457 299993 +1210569 1731356 +12106 2370729 +121084 217653 +121084 353424 +1211012 394791 +1211012 502826 +1211021 852709 +1211021 861690 +1211021 92243 +1211021 997191 +121108 121109 +121109 167743 +121109 622365 +121112 107784 +121167 133752 +121167 170871 +1211725 1459482 +121176 1301338 +121176 93386 +1211788 1432193 +121179 17528 +1212027 101543 +1212175 289089 +1212192 1390809 +121235 10290 +1212526 2077070 +1212527 114493 +1212527 27952 +1212527 422501 +1212667 797149 +1212667 838338 +1212792 1644815 +1213123 27519 +1213123 809856 +1213235 662438 +1213373 1753884 +1213526 310513 +121355 233447 +1213624 1515195 +1213624 1623587 +1213624 2101741 +1213641 2264015 +1213641 2285263 +1213641 2290101 +1213797 237500 +1213797 765133 +1213835 2181532 +121387 20585 +121387 542448 +1214261 2982406 +1214261 76461 +121440 1458 +1214647 788798 +121471 100801 +121471 107741 +121471 122841 +121471 15361 +121471 795116 +1214712 1237605 +1214712 1465867 +1214811 1214810 +1215024 401998 +1215191 1215174 +1215260 1312750 +1215262 1291459 +1215293 438264 +1215409 1215408 +1215416 1715288 +1215416 3081338 +121545 400109 +121549 81356 +1215650 1526532 +12157 46035 +1215742 1768 +1215742 210741 +1215742 3994863 +1215796 1399 +12159 102222 +12159 130979 +121598 37122 +1215991 1215992 +1215991 1616762 +1215992 1616762 +1215999 1825047 +1216065 2498725 +1216065 688151 +121607 3476 +121607 916708 +121611 31009 +121611 58770 +121627 1429906 +1216325 2954460 +121637 232956 +121637 910493 +1216663 1216664 +1216959 12339 +1216959 535408 +1217320 59048 +1217354 3049810 +1217375 413602 +1217456 1195579 +12176 118854 +12176 1409 +12176 147960 +12176 209937 +1217655 1329776 +12178 14842 +12178 74658 +121793 168409 +121793 2253450 +121793 505061 +121793 744954 +121799 4536 +1218 1329558 +1218044 1497993 +121805 113895 +121805 21504 +121805 22612 +12181 183427 +12181 250900 +12181 3660534 +12181 6919 +121811 175909 +121811 175910 +121811 237593 +121813 1031510 +121813 111646 +121813 163548 +121813 177903 +121813 942767 +12182 134209 +12182 174911 +1218226 1642082 +121837 279253 +121839 111645 +121839 131278 +121839 372796 +121839 482792 +121839 754781 +1218803 1188682 +121887 201306 +121887 731 +121892 82343 +1218950 505558 +1219329 102932 +1219487 1051522 +12196 216 +12196 419396 +1219713 857406 +1219713 943113 +121977 121978 +121995 305960 +1220 2089744 +12200 340351 +12200 362057 +1220091 570608 +122048 167880 +1220498 310509 +122055 273367 +12206 62078 +1220778 1061521 +1220778 1220779 +1220778 696225 +1220779 1061521 +1220779 1080248 +1220779 1481537 +1220779 1481547 +1220779 2193682 +1220779 696188 +1220779 696225 +1220779 833787 +1220779 838929 +1220779 844418 +1220779 855073 +12208 3857 +122088 177869 +1221008 1566166 +1221008 1989896 +122133 1198535 +1221410 427948 +1221422 310501 +1221747 870326 +122177 568934 +1221851 1336448 +1221980 110153 +1221980 1175722 +1222077 1781 +12223 29226 +1222502 194080 +12228 33573 +122286 2264 +1223005 224990 +122313 195502 +122314 355659 +1223398 1223397 +12236 1451444 +12236 183267 +12236 2442622 +12236 456439 +122369 81310 +122384 45008 +1223876 2029742 +1223922 522847 +1223960 346035 +122399 122400 +12240 142031 +122418 180140 +122418 233184 +1224223 699163 +122427 355659 +122439 191044 +122439 192745 +122439 241674 +122439 27700 +122448 53799 +1224766 2674068 +12251 3921758 +12251 44364 +1225283 736224 +1225323 1273187 +12254 19508 +122565 320567 +1225785 1225810 +1225785 772128 +122580 172014 +122580 172015 +1225816 1225815 +1225831 93811 +1225926 2885352 +12260 12264 +12260 34933 +1226027 2569868 +1226027 3340594 +122603 1268151 +122603 31453 +12261 176073 +1226156 30538 +122642 25968 +1226592 1226593 +1226706 47464 +122678 41815 +122690 153055 +122690 20431 +122690 250146 +1226949 1116086 +122695 3870 +1226970 1304159 +1226970 1456389 +1226970 1858552 +1226970 1858570 +1226970 1897627 +1226970 2018122 +1226970 629277 +1227 8828 +1227320 162345 +1227320 20977 +1227616 1133351 +1227616 1133352 +1227616 224467 +1227656 1166641 +1227835 1461538 +122792 108897 +1228102 3264142 +1228255 38603 +1228255 42404 +12283 10157 +12283 17640 +12283 51881 +1228386 867996 +122841 15361 +122843 232280 +1228442 896804 +1228442 95544 +1228442 978211 +1228473 1092548 +1228473 1506707 +1228473 281455 +1228473 703271 +12285 10435 +12285 11617 +12285 1268 +12285 1618090 +12285 21032 +12285 23005 +12285 2906 +12285 3101 +12285 3338 +12285 3365 +12285 416172 +12285 418028 +12285 4825 +12285 5762 +12285 5867 +12285 67218 +1228549 1788460 +12286 207380 +12286 31798 +1228647 1228648 +12287 21742 +12288 205545 +12288 207088 +1228863 1409 +1229013 1960768 +1229013 938576 +1229039 28587 +1229193 499708 +1229193 606892 +122932 122931 +122932 26579 +122932 30991 +122932 344614 +122932 91619 +12295 11787 +1229555 2428251 +122975 300828 +1229928 1956397 +1229928 840069 +1229932 840069 +1229947 432780 +1229978 526591 +122999 61048 +122999 89110 +1230033 1900746 +1230037 1942786 +123005 94014 +1230107 932321 +12304 29777 +1230625 104712 +1230754 1564317 +1230754 974665 +1230823 1061809 +1230823 1230823 +1230823 1643630 +1230834 805055 +1230979 192325 +1231124 1047575 +12313 70129 +12314 120645 +12314 61923 +12314 7991 +1231474 1231475 +1231482 1401410 +123159 1117243 +123159 153980 +123159 736047 +1231606 1396381 +1231627 641000 +1231661 1242438 +1231804 292537 +1231845 1337289 +1231858 938507 +1232111 1403461 +1232111 1523148 +1232111 1796403 +1232111 2428201 +123235 23846 +123235 347896 +123235 511133 +1232367 272902 +1232466 1056415 +1232612 1232612 +1232612 444577 +123265 213319 +123265 92386 +1232670 249449 +1232708 59411 +1232786 3084646 +1233 13665 +1233 436519 +1233 551966 +1233084 547620 +123311 354335 +12332 1435021 +1233375 262940 +1233375 337094 +1233375 527161 +1233375 700443 +1233375 833166 +1233375 844418 +1233376 844675 +1233507 1216545 +12336 12337 +12336 12338 +1233607 1005954 +1233607 843913 +1233635 1341436 +12337 12338 +1233726 216134 +123374 47336 +1233825 2665958 +12339 23387 +12339 2927356 +123393 532 +12340 11202 +12340 228032 +12340 23035 +12340 2811 +1234001 825043 +1234001 855971 +12341 10389 +12341 285048 +123417 1044987 +123417 1216613 +1234289 261451 +1234289 604396 +12343 13561 +1234335 11073 +1234335 3918 +1234335 78659 +1234386 1602745 +12344 154345 +12344 18628 +12344 60708 +123461 145180 +1234806 1028502 +1234806 1234805 +1234806 1351694 +1234806 153980 +1234806 271874 +1234866 1987301 +1234866 833765 +1234866 985192 +123495 605940 +123514 218120 +1235199 1235200 +1235322 306954 +1235358 1469594 +1235492 1498559 +1235492 1498560 +1235492 1498561 +1235492 1498562 +1235492 676367 +1235492 857611 +1235543 27952 +1235696 728918 +1235705 37236 +123576 1092245 +123578 10267 +123581 120328 +123581 9375 +1235882 1125825 +1235958 1229555 +1235958 63332 +1235958 637603 +1236 3338 +1236 5309 +1236112 11584 +1236112 1322663 +1236112 146984 +1236112 4000564 +1236415 572623 +1236436 833167 +1236436 858380 +1236436 858475 +1236436 865655 +1236436 882026 +1236436 895152 +1236438 1046945 +1236438 1353208 +1236438 1558211 +1236438 2402947 +1236438 2402948 +1236438 451534 +1236438 646866 +1236438 833168 +1236438 842085 +1236438 845760 +1236438 861476 +1236438 922551 +1236438 941855 +1236553 1023796 +1236553 1438649 +1236553 2066290 +1236553 522269 +1236553 833217 +1236553 842641 +1236553 871873 +1236553 897150 +12367 153585 +12367 271018 +1236717 2087414 +1236836 52312 +1236926 222785 +1236926 634 +1237 48670 +1237 50572 +1237 78632 +123703 896898 +1237082 1237083 +1237083 1462461 +12372 3837 +123724 69536 +123759 220832 +123759 369963 +123759 756437 +123759 921867 +1237635 891455 +1237668 2449670 +1237668 4015 +1237755 2111894 +123784 226808 +1237921 683920 +123799 390573 +1238272 3080660 +12384 100051 +12384 10980 +1238428 383459 +123859 210705 +1238738 283127 +1238738 754974 +1238826 1589374 +1238826 1927469 +1239015 1050148 +1239015 2973221 +1239015 725144 +1239015 835036 +1239015 912553 +1239015 986222 +123904 253462 +123904 391 +123904 700504 +123904 99731 +1239041 897153 +1239160 991660 +1239162 1271720 +1239162 1274950 +123941 220870 +1239415 1243738 +1239503 180204 +1239503 49435 +1239503 66020 +123951 49633 +1239616 1873860 +1239616 863254 +1239660 1031262 +1239660 1246887 +1239660 1307759 +1239660 1341603 +1239660 1415871 +1239660 1440242 +1239660 1481548 +1239660 1653542 +1239660 170759 +1239660 1909874 +1239660 517144 +1239660 577808 +1239660 696257 +1239660 833625 +1239660 841593 +1239660 854228 +1239660 855057 +1239660 858375 +1239660 889200 +1239660 900979 +1239660 973041 +1239969 1225785 +1239969 1225810 +1240133 1441830 +1240133 206281 +1240133 532418 +1240133 688716 +124039 12214 +124039 12216 +124039 4382 +1240479 639379 +12408 46607 +1240843 2142579 +1241159 7275 +1241251 604039 +1241315 1259762 +1241315 1328764 +1241315 833550 +1241458 988905 +12415 2962584 +12415 45774 +124158 184812 +124158 187471 +1241682 911343 +12417 100887 +1241794 1241795 +1241794 1241796 +1241795 1241796 +12423 535287 +124237 43571 +1242407 1799462 +1242418 1242419 +1242657 1242703 +124280 1229810 +1242825 27952 +1243697 1263389 +1243697 1499372 +1243798 1104490 +1243799 1104490 +1243799 1243798 +1244 11733 +1244 4980 +1244017 791693 +1244149 114257 +124436 147379 +124436 162975 +124436 237064 +124436 335067 +124436 338277 +124436 772913 +124436 798533 +124436 89110 +1244603 829166 +124483 115826 +124483 152818 +124483 25375 +124483 387758 +124483 40820 +124483 46512 +1244962 1855423 +1244962 474183 +124497 7552 +1245031 1169515 +1245031 1245032 +1245031 1245033 +1245031 1278653 +1245031 1420541 +1245031 1496956 +1245031 2316576 +1245031 2333160 +1245031 2551034 +1245031 2551038 +1245031 2551039 +1245031 2918310 +1245031 3248391 +1245032 1245033 +1245032 1278653 +1245032 2316576 +1245032 2551034 +1245032 2551038 +1245032 2551039 +1245032 2918310 +1245032 3248391 +1245032 3370810 +1245033 1278653 +1245033 2316576 +1245033 3248391 +1245035 1169515 +1245035 1245031 +1245035 1245033 +1245035 1278653 +1245035 3248391 +1245035 837527 +1245260 1393867 +1245433 90203 +124548 23859 +1245521 144225 +1245521 238212 +1245575 1404047 +1245575 1421398 +1245575 731416 +1245575 834330 +1245575 909193 +1245575 909961 +12458 71649 +124592 194652 +124592 29823 +124592 712 +124592 72671 +124603 27811 +1246115 1246936 +1246162 2477289 +1246211 207905 +1246211 251434 +1246211 563926 +1246251 1427227 +124628 54756 +1246562 1901776 +1246608 1820473 +124685 135121 +1246886 1057453 +1246886 1239660 +1246886 1252375 +1246886 1346687 +1246886 2027433 +1246886 27519 +1246886 517144 +1246886 583138 +1246886 809856 +1246886 839233 +1246886 855057 +1246886 859446 +1246887 1307759 +12469 289282 +1246963 835739 +1247 1410067 +1247 18951 +1247 24673 +1247 2471724 +1247 38469 +1247 46478 +1247 961093 +12470 25777 +1247059 262405 +124726 280081 +1247497 538156 +1247572 636046 +1247653 1015031 +1247653 41457 +1247814 1219857 +1247922 537450 +1247922 537454 +1248 10001 +1248 17080 +1248 180460 +1248 2074 +1248 402233 +1248 8425 +1248 9165 +1248 9994 +1248030 1536685 +1248064 1475937 +124819 1515 +1248220 624805 +1248220 696473 +1248220 719020 +12485 41734 +124855 337107 +1248575 1145807 +1248575 170884 +1248603 842888 +1248603 883315 +1248638 1248638 +12488 11572 +124884 138270 +124892 193737 +1249004 2314270 +1249014 1009232 +1249014 1628108 +1249014 898403 +124918 23129 +1249240 2878437 +1249260 1447280 +1249304 3051231 +1249311 2281098 +1249311 39874 +1249311 834073 +1249311 839080 +1249324 942277 +12495 143004 +12495 878782 +1249501 48977 +1249513 171 +1249513 44018 +1249544 2086670 +124964 3137153 +1249872 24188 +1249878 1647277 +1250 1251 +1250 36949 +1250022 355285 +1250112 2736228 +1250175 1032240 +1250175 1990133 +1250175 2666389 +1250175 267134 +1250175 538646 +1250175 688034 +1250175 851590 +1250201 889004 +1250249 1250489 +1250331 1250330 +1250464 1250465 +1250532 1013686 +125059 20427 +125059 50357 +1250614 1015031 +1250614 1194475 +1250614 1247653 +1250614 862914 +1250628 1213121 +1251 36949 +125101 1102242 +125101 1290833 +125101 269254 +125101 59756 +125101 82605 +1251229 110977 +125155 116253 +125155 125155 +125155 2725 +1251682 1361690 +1251682 1361691 +1251682 1386786 +12517 14603 +12518 40634 +1251801 1262710 +125190 212095 +1251923 333892 +1251923 526576 +1251923 628237 +1251923 718775 +125196 830983 +125196 9970 +1251963 1251963 +1251963 1517856 +1251963 1594508 +1252022 1252023 +125203 145288 +1252337 1252338 +1252375 27519 +1252375 583138 +1252375 809856 +125246 194 +1252486 1252539 +1252486 1252540 +1252486 1252541 +1252539 1252541 +1252540 1252539 +1252540 1252541 +125260 125261 +12528 208192 +12528 369826 +12528 44326 +12528 54391 +125296 15444 +1252978 649582 +1252978 649584 +125313 323821 +125330 198924 +1253452 473259 +1253619 71844 +1253621 1369126 +12537 1163547 +12537 538453 +1253708 475044 +1253734 21139 +1253734 2481597 +125388 238238 +125388 501620 +125388 785864 +125425 190371 +1254320 1534523 +12544 545 +1254418 741812 +1254610 1892739 +1254610 2794067 +1254724 2716696 +1254803 410380 +1254803 428883 +1254803 516473 +1254804 303726 +1254804 980833 +1254914 313803 +1255 693 +12551 1065742 +12551 12879 +12551 12884 +12551 157697 +12551 1622952 +12551 184421 +12551 227945 +12551 342474 +12551 44779 +12551 51639 +12551 62925 +12551 781956 +12551 79687 +125518 7253 +125518 797983 +1255265 375953 +1255265 386860 +125547 134016 +125548 1149515 +125548 30428 +125548 430816 +125548 47796 +12556 8884 +1255713 1021211 +1255713 1273314 +1255713 435555 +125598 13 +1255998 1190614 +1255998 918469 +1256040 1653610 +125642 3052 +1256436 482066 +1256436 88401 +1256441 1488101 +1256441 1960192 +1256453 660314 +1256791 847330 +1257025 15975 +1257130 356317 +1257130 834322 +1257130 834324 +1257130 834329 +1257130 836105 +1257130 842641 +1257130 842645 +1257130 897150 +1257130 897153 +1257186 107947 +1257186 388313 +1257495 1279470 +1257495 2371015 +1257495 849267 +1257569 440396 +1257632 1036154 +125772 186189 +125772 39954 +1257803 2806414 +1257914 1257915 +12580 2962584 +125802 1054362 +125802 1271647 +125802 2050722 +125802 320099 +125802 85524 +125802 983433 +1258024 1689931 +1258097 214656 +1258379 774755 +125838 1870211 +12584 1134782 +12584 1192811 +12584 2053793 +125878 13092 +125878 17797 +12588 1370 +12588 283331 +12588 29656 +12588 364353 +12588 45761 +12588 498183 +1258846 1370680 +12589 577434 +1259101 1263534 +1259101 1477343 +1259101 1511355 +1259101 2025291 +1259101 2048924 +1259101 2460882 +1259101 260744 +1259101 27519 +1259101 283122 +1259101 299702 +1259101 3460300 +1259101 388185 +1259101 415720 +1259101 439664 +1259101 454293 +1259101 459674 +1259101 459676 +1259101 479033 +1259101 479036 +1259101 542501 +1259101 573239 +1259101 575046 +1259101 683885 +1259101 688716 +1259101 696215 +1259101 696225 +1259101 696238 +1259101 754974 +1259101 809856 +1259101 833167 +1259101 833169 +1259101 833543 +1259101 833553 +1259101 833787 +1259101 836585 +1259101 837060 +1259101 851344 +1259101 855072 +1259101 855971 +1259101 865655 +1259101 872584 +1259101 899898 +1259101 900448 +1259101 999914 +1259109 1182579 +125912 187475 +125925 125927 +125925 484860 +1259253 144032 +1259272 1037730 +1259272 1037731 +12593 253 +12593 45877 +12593 459602 +1259504 2753732 +1259504 504753 +1259586 285400 +12596 136227 +12596 1364629 +12596 23701 +12596 244175 +12596 292376 +12596 332609 +12596 41425 +12596 44125 +12596 545673 +1259619 661674 +1259743 87301 +1259761 1259762 +1259761 835415 +1259761 859446 +1259761 908890 +1259762 835415 +1259762 908890 +125990 1036049 +125991 255665 +1259973 2449453 +126 1094 +126 782 +126011 542115 +126017 270231 +126017 344907 +1260218 454293 +1260218 833169 +1260218 842132 +1260218 887456 +126023 31461 +126035 532446 +1260354 1811 +126048 255878 +1260606 1802107 +1260606 1982778 +1260606 490290 +1260606 835735 +1260606 862699 +1260663 52145 +1260698 837527 +1260698 850908 +126072 173279 +126073 1065010 +126073 181011 +126073 3280719 +126073 90037 +126073 92281 +126092 18700 +126092 421263 +126092 915075 +1260950 754977 +1260982 262598 +1261017 259887 +126111 126113 +126111 180456 +126111 4618 +1261174 1381892 +12612 18875 +126120 25954 +126120 60678 +126132 113805 +1261428 424150 +1261428 833903 +1261428 945174 +126152 376280 +12617 12626 +12617 135377 +12617 15509 +12617 176837 +12617 21977 +12617 31821 +12617 39719 +12617 78405 +126193 29130 +1261968 1447193 +1262207 193795 +1262226 1262227 +1262226 92623 +1262227 92623 +1262231 1618084 +1262231 198067 +126226 250632 +126227 126228 +1262335 1299987 +1262335 388185 +1262335 406281 +1262335 832989 +1262335 905982 +1262505 1823420 +1262505 444606 +1262505 492930 +1262505 696134 +1262505 696215 +1262505 704150 +1262505 833376 +1262505 835968 +126253 250157 +126253 269227 +12626 135377 +12626 15509 +12626 193237 +12626 31821 +126279 80852 +126286 469512 +1263034 620186 +12631 101087 +12631 166065 +12631 184178 +12631 316431 +12631 316432 +126329 7485 +12633 20956 +1263303 2797136 +1263389 1427917 +1263389 1499372 +12634 19828 +12634 3543 +1263534 459674 +1263566 2736228 +1263566 867995 +126359 565909 +126389 149007 +1264004 254091 +1264237 1024263 +1264237 446471 +1264256 366003 +126430 121179 +126430 143595 +126430 17528 +1264305 1190699 +126432 395847 +126442 206215 +126455 14592 +126457 108268 +126457 126456 +126459 14592 +1264625 145811 +1264626 1264625 +1264626 145811 +1264839 450674 +126491 315978 +1264935 15540 +1265127 2605389 +1265284 1103235 +1265292 293990 +1265303 721809 +126531 13151 +1265313 2499852 +1265314 1005207 +1265314 1017264 +1265314 459673 +1265314 532086 +1265314 532088 +1265314 725144 +1265314 861270 +1265314 891202 +1265373 200278 +1265373 757837 +1265468 944875 +1265566 1266883 +1265566 312587 +1265566 870181 +1265582 142092 +1265582 263865 +1265582 3826100 +126595 536041 +1266139 974520 +1266266 12339 +1266373 1261996 +1266469 517415 +1266883 870181 +126703 2264 +126703 57698 +126708 31215 +1267105 1267104 +1267105 1267106 +1267106 1267104 +12672 5509 +1267623 152709 +1267623 1561956 +1267623 1619779 +1267623 3439800 +1267623 672090 +1267623 758462 +1267716 1267717 +1267716 2606344 +1267716 2606345 +1267716 3068272 +1267716 793064 +1267716 837585 +126783 149305 +126798 804120 +1268 129798 +1268 16 +1268 20089 +1268 219321 +1268 31249 +1268 3365 +1268 5867 +1268 67218 +1268 9050 +1268217 105865 +1268217 386488 +1268262 541919 +12683 124855 +12683 43921 +12683 77656 +12684 133888 +12684 4105 +1268525 369619 +12686 145288 +12686 270225 +1269 109961 +1269 9044 +1269004 1269007 +1269006 1378288 +1269008 2170838 +1269008 351304 +1269235 577765 +126926 41963 +1269315 1312103 +1269315 325653 +1269369 974269 +1269390 832962 +1269390 835735 +1269391 115469 +1269391 921040 +1269391 921042 +1269484 370680 +126954 411152 +1269571 1316907 +1269571 336543 +126967 141718 +126967 159214 +126967 200319 +126967 322440 +126976 110844 +126976 51272 +1269906 3432198 +127035 51927 +1270444 1470098 +1270444 2716967 +1270445 2870567 +1270446 2154501 +1270472 1269513 +127064 206180 +1270649 1702453 +12707 134514 +1270739 1295680 +1270739 1473891 +1270739 498426 +1270739 592639 +127075 108970 +127075 232474 +127075 248497 +127075 398223 +127076 13667 +127076 219675 +127076 402523 +12710 49845 +1271020 1098050 +1271020 1269004 +1271020 1269007 +1271206 1271205 +1271328 1271329 +1271365 239587 +127137 57448 +1271437 310492 +1271477 1123504 +1271812 1618848 +1271910 79439 +127199 50577 +127199 53438 +1272024 1089301 +1272024 952583 +1272042 1295668 +1272324 1245575 +1272324 1404047 +1272324 1421398 +1272324 1628927 +1272324 731416 +1272324 834330 +1272324 909193 +1272324 909198 +1272324 909961 +1272324 923346 +1272551 2334191 +127256 1326940 +127259 38057 +127259 49736 +127261 127262 +1272632 1332231 +1272632 1332235 +127272 104556 +1272734 1272735 +1272939 1458934 +1272986 2382491 +127312 409374 +1273314 1021211 +1273314 435555 +1273408 77521 +1273907 1520127 +1274085 2392345 +1274114 1279647 +1274233 2336560 +1274375 725023 +1274375 873546 +12748 55504 +1274836 10746 +1274998 54598 +12751 21357 +1275273 452717 +1275390 61689 +127567 255811 +12757 12659 +12759 13541 +1275956 3248391 +1275956 880957 +1276067 2119272 +1276067 995834 +12764 101853 +12764 110523 +127646 220884 +1276766 2035861 +1276766 2035862 +1276950 1311190 +1276950 2607057 +12770 22950 +12770 289724 +1277011 2128083 +12773 7679 +1277422 848468 +127779 28525 +127779 65887 +1277801 1223177 +1277834 324576 +12780 216405 +12780 29276 +12780 58532 +12780 69975 +1278248 1967192 +1278450 935301 +127864 950170 +1278653 2316576 +1278653 3248391 +1278947 1126944 +1278966 2350140 +1278966 2350141 +1279 1249728 +1279130 922645 +1279143 28517 +1279155 1305199 +1279344 454293 +1279470 2371015 +12796 2141208 +1279686 192327 +1279686 262940 +1279686 696260 +1279686 835968 +1279702 1569594 +1279702 220342 +12798 10994 +12798 17146 +12798 29207 +12798 30790 +12798 4687 +1279835 1250575 +1280 1670383 +1280 21881 +1280 253934 +128012 42237 +1280175 716316 +1280203 2033896 +128038 102951 +128038 66418 +1280447 1413277 +1280480 1204827 +128053 886366 +128056 128056 +128056 199818 +128056 227480 +128056 86975 +128056 91014 +1280808 1385955 +128099 115102 +12810 54145 +12810 682029 +128132 428547 +1281462 1678153 +128164 426254 +1281680 108566 +1281680 1993559 +128173 14753 +128173 251993 +128173 31777 +128173 53121 +1282024 1742527 +128204 2299170 +128204 3000433 +12821 396683 +12822 16388 +1282539 977722 +128264 21587 +12827 178916 +12827 193205 +12827 2153 +1282730 1541603 +1282730 283127 +1282730 446577 +1282730 538646 +1282730 839257 +1282730 855060 +1282730 861487 +1282730 865659 +1282769 99864 +12828 753872 +12831 17302 +12832 17417 +128375 2331778 +1283938 1334420 +1283938 1476956 +1283947 457732 +1283949 1042862 +1283949 1697250 +1283949 1697254 +128395 245017 +128396 235979 +128396 238626 +128396 255556 +128396 256666 +1284 365996 +1284 41818 +1284086 316770 +1284109 1248030 +1284109 1536685 +1284343 361074 +1284345 1284343 +1284573 641164 +1284573 844416 +12846 73202 +12848 1069472 +12850 446561 +12850 54604 +128515 128516 +1285336 1285337 +1285433 1569285 +1285585 801146 +1285585 869716 +12856 57512 +12856 62886 +128568 227318 +12857 1035281 +12857 193117 +12857 2260153 +12857 482638 +12857 60763 +1285796 2258835 +12859 7144 +1286 230888 +1286 232935 +1286 258 +1286 26579 +1286 751609 +1286 880065 +1286228 2995650 +128636 543404 +128642 132021 +1286653 716373 +12867 48379 +1286792 306300 +128680 19436 +12869 378138 +12869 413164 +12869 535617 +12869 76971 +1287 239 +1287 301926 +1287 39120 +128718 77001 +128730 1588134 +1287420 1287419 +128744 1092557 +128744 900891 +1287726 1144751 +1287726 1144752 +1287727 1144751 +1287727 1144752 +1287727 1287726 +12879 337666 +12879 672102 +128828 121934 +128828 141604 +12883 12551 +12883 169280 +12883 186583 +12883 75455 +12883 76933 +12883 84265 +128832 935278 +12884 100430 +12884 12881 +12884 203324 +12884 2452634 +12884 79253 +1288425 2098157 +1288455 1551275 +1288455 870792 +1288459 492245 +1288459 95537 +1288586 1137834 +1288587 2519044 +12886 65997 +12886 75305 +1288689 1350877 +12887 526739 +12888 12544 +12888 73368 +1288830 2337642 +1289 68377 +128905 801801 +12892 1044 +12892 71586 +1289417 435555 +1289417 835066 +1289417 835112 +1289799 104604 +1289850 569596 +1289935 1442493 +129020 39206 +1290228 1222148 +1290356 1709811 +1290374 269254 +1290374 817480 +1290374 966987 +1290374 975145 +129041 620369 +1290645 1009232 +1290645 1160362 +1290645 2483583 +1290645 406423 +1290645 610802 +1290645 754958 +129073 195496 +129073 204834 +1290791 1290790 +1290885 2255451 +129098 123397 +129098 60141 +1290994 1243323 +12910 41509 +1291232 222775 +1291241 50980 +1291296 319978 +1291352 982126 +1291421 1486572 +1291421 2206368 +1291440 3100869 +1292 16951 +12921 1398 +1292145 668023 +12924 58097 +1292422 470619 +12926 202461 +12926 93249 +1292640 978601 +1293297 1292640 +1293338 1293336 +1293394 3140474 +1293551 1078885 +1293551 94841 +1293589 125431 +129362 5107 +129369 287791 +12937 62320 +1293805 1331664 +12940 1403 +12940 39270 +1294342 1224507 +1294345 1908726 +1294345 2518110 +1294345 2532965 +1294345 282137 +1294345 853477 +1294345 862694 +1294345 883123 +1294345 961426 +1294345 982123 +1294414 19600 +129466 631550 +1294686 2326597 +129470 122390 +12949 107170 +1295102 292718 +1295431 1295432 +1295431 336551 +1295431 701295 +1295435 223545 +1295435 680514 +1295436 2521016 +1295491 2243597 +1295671 1350896 +12958 433360 +1295852 651104 +129603 137832 +129615 1256642 +1296215 99731 +1296321 366605 +129633 1603013 +129637 222324 +12965 12965 +12965 147379 +12965 201958 +12965 247945 +12965 2823 +12965 348433 +12965 348434 +12965 36174 +12965 45382 +12965 516516 +12965 69589 +12965 9796 +12967 154746 +129676 129676 +129676 1305835 +129676 180239 +129676 2723334 +129676 3805 +129676 799124 +129681 361539 +129681 645208 +12969 45771 +129691 336243 +1297015 1269604 +129723 381551 +129723 599039 +129737 2730 +129737 37724 +129737 661 +12974 10355 +12974 104934 +12974 115995 +12974 12969 +12974 14111 +12974 14974 +12974 197325 +12974 200167 +12974 203700 +12974 220743 +12974 339324 +12974 605817 +12974 844372 +1297433 1632728 +1297439 299702 +1297439 388185 +1297439 978333 +129744 100457 +129744 129743 +129744 1599042 +129744 822684 +1297580 1430822 +1297867 162586 +1297867 2043917 +1297867 75876 +1297900 1094847 +1297900 696225 +1297902 1297902 +1297902 1354136 +1297902 1412615 +129798 104175 +1298 1298 +1298111 1857637 +129830 845446 +129830 931190 +1298411 899808 +1298470 3464785 +1298470 3793961 +1298553 274143 +129858 199605 +129858 256225 +129858 96266 +129876 2819225 +1298913 1395381 +129912 221118 +129913 120691 +129914 10308 +12992 103881 +12995 8803 +1299924 267726 +13 132880 +13 146216 +13 160061 +13 207447 +13 211987 +13 21596 +13 56890 +13 63322 +13 716 +13 9544 +13 9546 +130002 682043 +130005 691020 +1300061 420689 +1300194 1010312 +1300593 119483 +1300593 582748 +1300607 599491 +1300661 2151235 +130067 140890 +1300737 1277579 +1300737 2220261 +1300808 526591 +1300808 855072 +1300812 1028502 +1300812 269254 +1300812 434656 +1300812 832917 +130091 424084 +130102 418524 +130123 1045800 +1301514 1282336 +130180 119661 +130180 1403 +130180 282524 +1301833 1706943 +130185 170846 +1301913 932064 +1301915 1900632 +1301915 328856 +1301915 653535 +1301915 836488 +1301915 863507 +1301946 57811 +13020 2923804 +13020 3175042 +13020 7766 +1302045 3880 +130210 246248 +1302150 1490203 +1302150 796454 +1302163 1402814 +1302163 1873219 +1302255 1769892 +130243 29869 +130243 8913 +130277 289738 +13029 1414 +13029 17377 +1302921 1125781 +1302961 1398497 +1302961 1899393 +1302961 390039 +13031 359246 +13031 65099 +130315 605817 +130337 23616 +1303455 342648 +1303589 1317138 +1303648 64706 +130366 14092 +130366 254850 +130367 211100 +13038 10176 +13038 145263 +130381 259126 +1303882 1174410 +1304153 1514857 +1304401 1304399 +1304405 1595366 +1304427 1304426 +130476 112466 +130476 729619 +1304777 423060 +130488 141611 +1305084 929395 +130511 129878 +130532 43011 +130532 50595 +130532 62919 +1305345 65419 +1305691 390114 +1305809 1647789 +1305876 1145083 +130589 212002 +130589 222210 +130589 257423 +130593 463142 +1305939 1879701 +1305995 2092068 +1305998 305215 +1306060 1229592 +1306131 3488542 +130629 1422157 +130630 130629 +130630 1422157 +130643 2112674 +1306527 843324 +130655 85944 +130666 240231 +130668 239169 +130668 28538 +1306699 1676573 +1306699 2757853 +1306699 312590 +1306699 759599 +1306932 885551 +130715 44779 +1307204 1715891 +1307387 11084 +130747 26712 +13076 106886 +1307709 2141820 +1307709 2141821 +1307709 289323 +1307709 445532 +1307709 446105 +1307709 696215 +1307709 796211 +130772 130773 +1307754 999914 +130788 2299321 +130802 108020 +1308052 1116710 +130817 285474 +1308194 192083 +130827 1125437 +130831 1210334 +1308580 1015351 +1308580 921271 +13087 100546 +13087 11004 +13087 12819 +13087 14863 +13087 1607925 +13087 21537 +13087 22743 +13087 26310 +13087 29362 +13087 29636 +13087 3219509 +13087 384572 +13087 426957 +13087 44030 +13087 52083 +13087 603068 +13087 65122 +13087 75775 +1308850 377050 +1309 25528 +1309 858 +1309032 2066771 +13092 17797 +13092 2969591 +13092 35134 +13092 36517 +13092 39699 +13094 13094 +13094 35126 +1309491 1683019 +1309491 2904212 +130964 291293 +1309641 101469 +1309641 162862 +1309830 50198 +1309971 1309972 +1309971 1309975 +1309971 1309977 +1309971 522210 +1309971 873294 +1309972 1309975 +1309972 1309977 +1309972 522210 +1309972 873294 +1309975 1309977 +1309975 522210 +1309975 873294 +1309977 522210 +1309977 873294 +13100 684029 +1310027 1014112 +1310073 1310066 +1310886 1310884 +1310886 1979478 +1310886 2192498 +1310906 838190 +1310963 718200 +1311027 1313762 +13111 14 +13111 20556 +13111 23333 +1311272 2958873 +1311788 1311789 +1311789 621179 +131181 135057 +1312048 1312047 +1312123 6397 +1312328 23366 +1312328 4813 +1312366 1030364 +1312375 1262335 +1312375 27519 +1312375 388185 +1312375 809856 +1312375 832989 +1312508 1371573 +1312508 1371575 +131278 121812 +131278 131279 +131278 214957 +131278 368702 +131278 482792 +131279 121812 +131280 93384 +1312822 2332131 +1312957 2458017 +1313014 411737 +1313014 439653 +1313268 801233 +1313279 415725 +1313279 700443 +1313279 851590 +1313279 855761 +1313284 260744 +1313284 283122 +1313284 850906 +131332 1126707 +1313438 650433 +1313589 342257 +1313590 1313589 +1313590 342257 +131367 219964 +1313817 1613189 +131389 1907846 +1313931 1597604 +131395 26454 +1313957 1416450 +1313980 2073929 +1313980 2260153 +1313980 28568 +13141 24557 +1314144 3022452 +131427 40388 +131427 6425 +1314273 1467707 +1314273 333558 +1314273 908058 +131455 1230834 +131455 805055 +131461 111646 +131461 121813 +131461 600387 +131466 131465 +131466 131469 +131469 131465 +1314764 7028 +1314805 2864751 +1315168 117541 +13152 222220 +1315224 1434706 +1315514 1315513 +13159 6987 +131618 197069 +131618 98305 +1316270 435555 +1316270 931948 +13165 217095 +13165 66261 +13165 68277 +131666 209613 +1316845 8456 +13170 8620 +131731 201178 +131754 42554 +131759 220832 +1317632 141039 +1317735 1492650 +131775 1065010 +131775 41687 +1317817 461887 +1317817 515401 +1317880 647526 +1317880 778532 +1317880 786693 +1318016 647464 +131837 538141 +1318492 833687 +1318492 891202 +131851 1737 +131851 273161 +131851 372118 +131874 131875 +131878 2051330 +131878 542397 +1319 1291 +1319 1323 +1319 96151 +13190 2682 +13190 31957 +13195 27929 +1319541 1319538 +131960 62144 +131978 187377 +131987 29808 +131987 36202 +131992 1884995 +131992 296872 +131998 52147 +1320007 21916 +13201 248732 +132012 378524 +132019 110599 +1320220 260744 +1320220 646857 +132032 211774 +132032 258082 +1320469 3122366 +1320722 1041368 +1320722 1041371 +132084 100756 +132084 1065010 +132084 109832 +132084 113497 +132084 115941 +132084 1201678 +132084 127836 +132084 132084 +132084 145858 +132084 157311 +132084 173081 +132084 173374 +132084 173399 +132084 173401 +132084 175380 +132084 35848 +132084 36527 +132084 37913 +132084 472329 +132084 66154 +132084 78349 +132084 90037 +132084 9741 +132100 132101 +132101 132101 +132105 150844 +132148 129663 +1321741 1503647 +1321741 1503649 +1321911 261276 +1321921 1298434 +1321921 13100 +132194 7871 +1322041 2231006 +1322099 827890 +1322136 140885 +1322136 1793083 +132231 118628 +1322495 1312796 +132252 132252 +132252 1904008 +132264 220669 +1322663 2169970 +1322663 2260585 +1322663 2549088 +1322663 979622 +132280 233810 +1322975 3356192 +1323 1291 +1323045 1018517 +132321 111502 +132321 164363 +132321 1998744 +132321 22506 +132321 266643 +132321 513046 +132321 59769 +132321 61920 +132321 76026 +1323332 2139868 +1323410 189456 +1323483 2359709 +132360 39089 +1323653 93564 +1323930 1512138 +1324076 63132 +1324137 1352151 +1324268 763276 +1324299 1365750 +1324299 2517140 +1324301 1388290 +1324365 1109391 +1324365 845154 +1324534 1226988 +13247 4091 +1325376 1046133 +1325376 504537 +1325376 73815 +1325535 1553420 +1325671 870324 +13259 313243 +13259 73044 +13259 90659 +132591 5980 +132591 9796 +1325919 754974 +1325919 833787 +132592 129744 +132592 132591 +132592 132592 +132592 151311 +132592 1599042 +132592 183741 +132592 36174 +132592 505029 +132592 644288 +132592 644291 +132592 822684 +1326 16623 +1326 56945 +1326028 1242903 +1326044 1051616 +1326044 115469 +1326044 454981 +1326044 838953 +1326044 970416 +132607 165056 +132607 305605 +1326114 456926 +1326114 502809 +1326114 598601 +1326122 907144 +1326421 2271375 +1326574 1728372 +1326574 2982835 +1326574 397620 +1326574 754974 +1326574 844418 +1326574 978254 +1326618 1735329 +1326618 775490 +132666 1616786 +132692 132693 +1327245 1055111 +132725 124603 +132759 850050 +1327597 885455 +1327809 2076251 +1328 1031 +1328 1463 +1328 3057 +1328 835 +1328225 623870 +1328225 988751 +1328635 1539763 +1328635 553267 +1328764 1259762 +1328764 833550 +1328919 95544 +1328965 845453 +132906 132907 +132906 176601 +132907 176601 +1329205 1199688 +1329281 1096693 +1329281 841803 +1329281 842307 +1329281 891601 +1329336 1234866 +1329336 1328725 +1329336 1902968 +1329336 696188 +1329336 833071 +1329336 857318 +1329379 364257 +132944 1663901 +1329714 1329715 +132992 904680 +1330106 1340235 +13302 48374 +1330365 2272363 +1330486 339663 +1330488 1685461 +1330554 1046946 +1330554 1849894 +1330554 696165 +1330554 995210 +133057 1628325 +133057 2347980 +133057 3094231 +133075 1397472 +1330863 1280169 +1330863 2466083 +1331 36267 +1331073 871121 +1331121 1372559 +1331121 658891 +1332083 2977338 +133222 138076 +1332235 1332231 +1332351 933488 +133237 214118 +133237 51978 +133256 130476 +133256 62226 +133256 77999 +1332624 2406259 +1332737 92885 +1332775 1345699 +133278 126927 +133283 409869 +133284 95544 +133314 157538 +133314 886483 +133314 886484 +13332 9327 +133327 399405 +1333326 10994 +1333326 59268 +1333331 3454911 +1333378 802875 +133338 154358 +1333474 1040710 +1333485 652819 +1333500 3564955 +1333797 1250480 +1333883 31715 +1333883 5682 +1334 10405 +1334023 3184805 +133442 130787 +1334420 1476956 +133456 139777 +1334560 663736 +133477 241140 +1335 10103 +1335086 1192282 +1335086 1454794 +1335086 3123629 +1335225 1235358 +1335225 1469594 +1335344 100617 +13354 100316 +13354 122694 +13354 21139 +133545 33573 +1335787 1684645 +1335787 271461 +13358 17448 +13358 54788 +133594 131465 +133594 133594 +133594 157972 +13360 1607 +133602 389375 +1336527 1336526 +1337281 1418465 +1337504 407126 +133768 210318 +133768 51988 +133772 171685 +1337779 1588331 +133782 133781 +133815 358203 +133815 395928 +1338525 443359 +133857 46886 +133866 133866 +133866 136840 +133866 184282 +133866 48604 +133866 60978 +133866 823874 +133869 172894 +133869 177931 +133869 239488 +133876 259401 +133877 133869 +133877 239488 +133878 35993 +13388 1269315 +133881 98456 +1339322 1134784 +133972 36377 +1339725 1339729 +133988 3554947 +13403 13403 +13403 2320 +13403 3503 +134030 204524 +134030 616212 +134030 91898 +1340310 1340309 +1340349 1091665 +1340360 1718409 +1340360 833553 +134038 23096 +134038 245972 +134038 3163 +13406 43378 +13406 94674 +13407 3953 +134073 355 +134073 467940 +1340935 2532296 +1340979 12869 +134098 284967 +134101 13837 +134101 164705 +134104 316524 +13411 104469 +134120 2128201 +1341214 311523 +134139 1098227 +134139 134140 +134139 200670 +1341603 1040777 +1341603 1066447 +1341603 1229978 +1341603 1300808 +1341603 1341604 +1341603 1415872 +1341603 1430196 +1341603 1652194 +1341603 1728371 +1341603 1919176 +1341603 1931864 +1341603 1931865 +1341603 1971583 +1341603 2012073 +1341603 526591 +1341603 577808 +1341603 703271 +1341603 841593 +1341603 855072 +1341603 859046 +1341603 868929 +1341603 870173 +1341603 896995 +1341603 900979 +1341604 1040777 +1341604 1430196 +1341604 1450542 +1341604 1478674 +1341604 1478676 +1341604 1931865 +1341604 1971571 +1341604 283122 +1341604 577808 +1341604 833698 +1341604 841593 +1341604 896995 +1341604 900979 +1341604 973042 +1341647 1283944 +1341670 265417 +1341670 53889 +134181 1105307 +13420 2204670 +134214 134215 +134214 481768 +134215 481768 +1342152 2351230 +1342411 761591 +134248 194490 +134248 243126 +134251 48670 +134275 67770 +1343074 1936871 +1343074 255801 +1343074 310172 +1343074 508131 +134312 223854 +1343260 1077175 +1343260 1098128 +1343260 1151374 +1343260 1427885 +134333 349670 +134343 8317 +1343604 2512969 +1343604 511220 +134369 77703 +134372 203968 +134372 5595 +134389 2070 +13439 10144 +13439 13440 +13439 13441 +13439 1665 +13439 2135513 +1344 7505 +1344 75563 +1344131 1344132 +1344131 1726080 +1344131 283122 +1344131 283127 +1344131 454293 +1344131 696253 +1344131 754974 +1344131 833071 +1344131 833169 +1344131 833554 +1344131 838400 +1344131 850897 +1344131 855072 +1344131 973042 +1344132 283127 +1344132 454293 +1344132 833071 +1344132 833169 +134459 18628 +1344626 239781 +134475 31215 +134490 362556 +134509 29207 +134516 227475 +1345544 22946 +1345544 2410390 +1345544 2410391 +1345546 1345545 +134559 4003 +134559 407657 +1345771 1843350 +1345894 257966 +1345894 44937 +134603 230646 +134603 75815 +134607 133284 +134607 95544 +134624 15975 +1346320 1320007 +1346320 21916 +1346396 1346395 +13464 12967 +13464 154746 +13464 158575 +13464 683097 +1346429 1269513 +1346429 1270472 +1346429 424276 +1346483 1395738 +1346687 299702 +1346687 388185 +1346687 838169 +1346687 855065 +1346742 2477289 +1346754 1346404 +134681 1074137 +1347023 233911 +1347147 1056181 +1347287 1154202 +1347287 1347288 +1347287 800822 +1347374 1505245 +1347374 1653029 +134741 1468247 +134742 2519703 +1347463 2395507 +13476 1740 +134789 225094 +134797 211067 +134797 247759 +1348114 1067157 +1348114 3905012 +134821 194996 +134821 39740 +134830 61880 +134851 190920 +1348590 91898 +1348607 1269266 +1348768 257199 +1348829 796454 +134908 472725 +134920 1398071 +134920 2065241 +134920 270301 +1349250 982396 +1349250 982397 +1349250 982399 +1349693 1349695 +134987 210793 +134987 22028 +1350224 1447917 +135044 23739 +135052 135053 +135054 125226 +135054 63839 +13506 220599 +1350757 1350756 +1350960 1515763 +1350960 987776 +13511 13469 +135148 582500 +1351612 96400 +1351694 1234805 +1351876 1398530 +1351876 1400270 +1351876 1419981 +1351876 1731804 +1351876 2013704 +1351876 3139504 +1351876 342543 +1351876 832992 +1351876 833798 +1351877 1950815 +1351877 269254 +1351877 696215 +1351877 834577 +1351877 841590 +1352346 177047 +135245 1420778 +135246 10533 +135246 225403 +1352682 1642459 +1352682 2503748 +1352682 3871051 +1352682 3871052 +1352682 3871053 +1352682 925944 +1352757 449765 +1353050 1394462 +1353050 168659 +1353050 1788760 +1353050 2427919 +1353050 2998282 +1353050 849098 +1353073 1015406 +1353073 324481 +1353073 759896 +1353073 833179 +1353169 283469 +1353208 3430309 +1353208 451534 +1353208 495010 +1353208 646866 +1353208 653372 +1353208 833687 +1353208 834071 +13533 1284 +13533 289196 +13533 67347 +1353354 1602745 +135343 802415 +1353487 538835 +13535 17467 +13535 8265 +1353620 304968 +1353620 96123 +1353787 1395383 +1353787 1499372 +1354562 1994524 +1354604 1959883 +1354604 26955 +1354604 296745 +1354604 698927 +1354604 925650 +1354730 1531265 +1354730 3506857 +1354730 604396 +1354730 859446 +1354730 859998 +135478 242613 +13548 11050 +135493 24419 +1354961 664954 +1355202 1153375 +1355202 1301946 +1355202 1355202 +1355202 532684 +13555 465864 +1355530 1466366 +1355530 898476 +1355649 1355648 +135575 289089 +135575 347570 +1356 27 +135600 99918 +1356055 836665 +1356055 837875 +1356055 844160 +1356055 845160 +1356055 960940 +1356337 304975 +135635 96379 +1356494 2116503 +1356526 3550 +1356526 549 +135657 188997 +1356669 934199 +1356670 1891372 +1356670 779781 +1356670 833539 +1356670 837442 +1356737 1607137 +1356779 1356780 +1356839 1356844 +1356892 1841308 +1356892 2440449 +1356892 983824 +1357167 1023848 +13572 139111 +1357225 27012 +135731 97455 +1357384 1357385 +1357386 1357384 +1357386 1357385 +135739 311121 +1357413 1915697 +1357413 1915699 +1357413 394796 +1357413 896804 +1357467 570566 +135759 209391 +135759 7870 +1357834 240537 +1357841 109335 +135788 79752 +135797 647720 +13581 357667 +135810 34427 +1358566 926814 +1358651 12850 +1358671 1639288 +1358671 751375 +135873 135871 +135873 256091 +135873 271155 +135873 271898 +135873 273883 +135874 473211 +135874 74210 +135885 257308 +135885 263441 +135887 255279 +135887 48397 +135909 74212 +135909 95088 +135912 339220 +135912 376558 +135912 84236 +135914 328181 +1359263 1359262 +135930 145256 +135930 145264 +135930 253063 +135930 262128 +135930 267186 +135930 27990 +135930 290874 +135930 29977 +135946 229194 +135946 249449 +135946 251877 +135946 262943 +135946 263206 +135946 333516 +135946 333517 +1359553 1712752 +135968 799120 +1359704 976529 +135998 681279 +1360 10902 +1360 1897 +1360 239 +1360 26 +1360 27 +1360 27156 +1360 421761 +1360 447159 +1360 491 +1360 52000 +1360 676 +1360 790612 +1360 800522 +1360090 1360089 +1360090 835088 +13601 429741 +136056 168304 +136056 278472 +13608 3909 +13608 8485 +1360987 2835443 +136123 257008 +136131 152684 +136131 325649 +136131 325650 +136133 254394 +136133 254769 +136133 258689 +136133 312997 +136133 95459 +1361354 250678 +1361561 673291 +1361563 524099 +1361606 137880 +1361606 1513560 +1361606 994633 +1361691 1361690 +136179 572152 +136179 70826 +136179 79340 +136188 281068 +136198 317143 +1362 205 +136220 202255 +136227 116201 +136227 1342935 +1362287 1362287 +1362287 1406392 +1362287 1424606 +1362287 1516797 +1362287 1516820 +1362287 880605 +1362287 899900 +1362292 6722 +136261 469520 +1362617 932932 +1362644 2215956 +136271 1382520 +1362751 261052 +1362751 380838 +1362823 291812 +13630 89678 +136314 249460 +136314 301935 +1363277 1120225 +1363277 306987 +136416 146010 +13642 9865 +1364294 192134 +1364371 519934 +1364371 700443 +1364371 822410 +1364371 822517 +1364371 877524 +136455 1239109 +1364656 953352 +136481 16509 +1365017 2309867 +136513 173945 +136513 178310 +1365179 1365178 +13652 101289 +136536 109214 +13663 208690 +13663 39561 +1366344 1138301 +1366406 1620265 +1366430 1330826 +13665 436519 +136665 66852 +13667 103238 +13667 1196411 +13667 127075 +13667 1420408 +13667 2643820 +13667 539198 +13667 566709 +13667 63182 +13667 897034 +1366709 1366748 +136688 157686 +136689 43779 +136689 89673 +13669 163078 +13670 13670 +13670 1474921 +136704 146979 +1367111 1532462 +1367190 55126 +1367250 283127 +1367250 754974 +13674 95861 +1367480 870833 +136764 731 +1367716 587140 +1367836 1420383 +1368030 192322 +13682 2025981 +13682 707193 +1368230 1062715 +1368292 2391751 +136840 38561 +136840 77859 +1368455 1825039 +1368463 1215999 +1368463 1825047 +13686 57967 +13687 1241417 +13687 226585 +13687 7247 +13687 901200 +136875 105357 +136875 16409 +1368909 836534 +1368909 885103 +1369 240881 +13690 16963 +13690 2319905 +13690 51816 +13692 29325 +13692 80237 +136931 1621024 +137 65010 +137 682 +1370 1616 +1370 2596 +1370 65692 +1370094 1102148 +137015 22915 +1370243 3175784 +13705 116387 +13705 8459 +137055 7056 +137078 243455 +1370819 1370820 +1370833 748170 +1370946 1340656 +1370946 3149322 +1370946 833185 +137105 183299 +137105 3363 +1371052 1371052 +1371052 421906 +1371065 1507866 +1371065 582273 +1371065 794883 +1371431 1935648 +1371440 1421937 +1371440 1443950 +1371440 1873423 +1371573 1371575 +137166 48077 +1371749 1144392 +1371961 194 +1371971 7733 +1371992 1043208 +1371992 1371992 +1371997 1186113 +137203 5087 +137203 661 +137204 185582 +137204 90037 +1372113 92307 +1372269 118939 +1372269 218417 +137252 1094747 +137252 676679 +137252 7029 +137259 118042 +13726 548031 +13727 51988 +137273 148528 +1372753 1212484 +1372793 1533345 +1372793 832696 +1372838 1150496 +1372838 975597 +1372905 1718593 +1372974 1196117 +1372974 25718 +1373 11066 +1373 3101 +1373 414 +1373 4854 +1373 792903 +1373 950 +137309 1100698 +13732 241015 +13732 66417 +13732 69544 +137325 1276766 +137325 2035861 +137325 2035862 +1373301 1344183 +1373304 95537 +1373383 1187662 +1373383 1690934 +1373383 2193844 +1373439 46003 +137353 1956894 +137353 1956895 +1373551 1688177 +1373608 1373609 +1373779 162972 +1373813 1021942 +1373813 1360089 +1373813 1611690 +1373813 1629562 +1373813 1787676 +1373813 2085394 +1373813 2186352 +1373813 835088 +1374 1299040 +1374 194 +1374 3124750 +1374 83009 +13740 28280 +13741 35216 +137418 30552 +137418 3245568 +137418 423732 +13743 1207483 +13743 196795 +13743 25718 +13743 330340 +1374321 1300812 +1374321 2545309 +1374321 2545310 +1374321 269254 +1374321 3338724 +1374321 832917 +1374321 933757 +137433 72958 +137433 97523 +137445 219475 +1374644 1664909 +137468 56016 +1375 7456 +137510 367899 +1375143 1828092 +1375260 2368996 +137532 44392 +137534 120761 +137534 3472 +13754 5531 +137571 53515 +13758 93677 +1375901 1531856 +137592 214494 +1376 335186 +1376 430816 +137602 120307 +137602 4778 +137602 548094 +137603 174968 +137604 2155220 +1376080 1376081 +13761 10918 +1376179 216721 +1376179 220187 +1376179 2218273 +137624 580883 +137627 24804 +137627 54574 +137627 649786 +13764 719839 +1376406 1377135 +13769 12532 +13769 20228 +13769 61234 +13769 81044 +13769 9442 +137691 158456 +137694 137695 +1377315 1113594 +1377315 1572214 +1377315 1668356 +1377315 2122600 +1377315 2123557 +1377315 2452765 +1377315 986743 +137742 114865 +1377659 1003179 +1377659 1229978 +1377659 1478675 +1377659 1666389 +1377659 2645574 +1377659 577808 +1377659 841593 +1377659 851419 +1377659 855063 +1377659 861581 +1377659 900979 +1377756 1510397 +13778 104348 +13778 407809 +1377801 1652169 +137792 438262 +137792 8260 +1378029 1459859 +1378029 2636073 +137813 6274 +1378200 322918 +1378302 1671700 +1378419 1240843 +1378419 2142579 +1378464 216087 +13785 8803 +1378565 1575344 +137860 123375 +137860 12819 +137860 17146 +137860 29362 +137860 4614 +137860 72240 +137872 725538 +137878 51368 +137880 1008036 +137880 1124616 +137880 1513560 +137880 359939 +137880 9557 +137880 994633 +1378855 2869981 +1378892 195292 +1378950 1653957 +1379055 1331121 +1379055 1372559 +137906 77180 +1379100 1379100 +1379283 1147036 +137933 232888 +1379346 663736 +13794 53799 +13794 79069 +137940 200311 +137940 949482 +137942 243615 +137947 72358 +137955 178339 +1379845 142343 +137990 240290 +1379905 1114897 +1379941 2018297 +1380023 517153 +1380023 552195 +1380023 833686 +1380024 1380023 +1380024 517153 +1380024 552195 +1380024 833686 +138020 38980 +138020 394406 +138038 109832 +1380457 504486 +1380528 602861 +1380550 2988106 +1380614 20589 +1380644 304975 +1380647 299014 +13808 17934 +13808 71974 +138084 190371 +1380905 120009 +1380947 55073 +1380949 1380947 +1380949 55073 +1381 13843 +1381 641000 +138108 1146367 +138108 534318 +13811 4884 +138123 270604 +1381309 2447184 +1381332 1416281 +1381378 823146 +1381485 361608 +1381485 832995 +1381485 961746 +1381534 987778 +1381758 448007 +1381758 448010 +1381983 298850 +1382 239034 +13820 2265 +13820 4033 +1382006 805587 +138203 30144 +1382207 1312796 +1382207 1322495 +1382443 90597 +1382544 1818209 +1382611 319462 +1382611 44364 +1382611 927472 +1382611 980145 +1382652 1526487 +138301 191503 +138305 250993 +138322 37722 +1383264 2768952 +13833 1151649 +13834 2153094 +13834 3281571 +13834 38435 +13834 70732 +1383427 1383426 +13837 230441 +13837 810972 +1383927 1115371 +1384 124039 +1384029 84524 +13845 39987 +1384526 100756 +1384526 174193 +1384831 843552 +1384909 127641 +1385114 347272 +138518 63132 +1385262 1394791 +138527 47199 +1385352 1790630 +1385352 834398 +1385356 736606 +1385356 835184 +1385431 1848549 +1385431 511496 +1385473 1840299 +138556 2283911 +138556 262941 +138556 262945 +138556 2749997 +138556 571649 +1385563 394051 +1385729 1385730 +138585 1191779 +138585 193236 +138585 197667 +138585 248607 +138585 2494674 +1385924 1933252 +1385924 351666 +1385924 542501 +1385924 696267 +1385928 859447 +138604 34250 +138618 557767 +1386394 901514 +13864 13678 +13864 245232 +13864 27952 +13864 400101 +13864 566521 +13864 801431 +13864 849952 +13864 85524 +13864 971996 +1386463 252868 +1386672 837570 +1386786 1361690 +1386786 1361691 +1386787 1251682 +1386787 1361690 +1386787 1361691 +1386787 1386786 +1386787 448010 +1386787 502826 +1386787 754894 +1386787 838295 +1386787 844250 +1386787 906873 +13869 207103 +13869 28100 +13869 69200 +13869 783018 +138713 142838 +138726 357230 +138729 87652 +138739 13464 +1387493 1945306 +1387493 526416 +1387493 624749 +1387493 796211 +1387493 916314 +1387652 1387658 +138772 317203 +1387728 1387727 +13878 220090 +13878 234577 +1388010 2827544 +1388060 1097244 +1388087 1200084 +138823 15908 +138844 272805 +138880 153589 +1389020 1066057 +1389020 2451229 +1389192 1389191 +138932 2928313 +138932 356030 +138932 473169 +1389500 1151063 +1389500 914631 +1389507 1089537 +1389507 11887 +138965 315179 +138968 324837 +1389784 2561649 +13898 15165 +138993 138994 +1390047 1390048 +1390360 2129819 +1390360 696257 +1390360 837674 +1390436 226846 +1390458 1466798 +1390458 1466818 +1390693 1476918 +1390693 232956 +139091 343069 +13911 3909 +139114 69334 +139114 72358 +13914 170 +13914 29121 +1391410 1391411 +1391727 860800 +1391855 1548248 +1391932 796662 +1392 112795 +13921 786590 +13921 92536 +139260 17034 +139260 70377 +139263 275854 +139308 251657 +139308 252350 +139308 260864 +1393149 1113757 +1393149 361544 +139319 237139 +13932 114532 +13932 3140 +13932 49908 +1393582 1394370 +13936 173547 +1393630 11202 +1393867 522847 +1394026 2140503 +13941 22116 +13941 35251 +13943 221034 +13943 235225 +13943 60705 +139438 415454 +13944 37841 +139447 116789 +139447 3130205 +139447 78788 +1394600 1385784 +1394675 1394677 +139475 426530 +1394806 1450749 +1394806 1602037 +1394806 1994652 +13949 17452 +13949 246950 +13949 26801 +1395059 2302118 +139509 1977260 +139519 207748 +1395232 284099 +139527 332446 +139547 478166 +13955 5290 +139553 412591 +1395635 1738074 +1395635 3682504 +13957 17531 +1395738 194 +1395776 2437252 +139591 50605 +139591 714807 +1396 10578 +1396 29057 +1396 4848 +13961 152246 +13961 1846423 +13961 337062 +13961 353627 +13961 378229 +13961 4452 +13961 69817 +13961 701741 +13961 7987 +13961 92623 +13961 95878 +13965 150225 +13965 18434 +13965 237712 +1396605 1633468 +1396605 249271 +139669 55127 +139692 1007874 +139692 11070 +139692 205612 +139692 2187 +139692 388369 +139692 551966 +139704 545803 +139721 88744 +1397604 844782 +1397703 1397710 +1397703 1397714 +1397703 1765777 +1397703 925650 +1397707 1397703 +1397707 1397710 +1397707 1397714 +1397707 1765777 +1397707 925650 +1397710 1397714 +1397710 1765777 +1397710 925650 +1397711 1397703 +1397711 1397707 +1397711 1397710 +1397711 1397714 +1397711 1765777 +1397711 925650 +1397714 1765777 +1397741 768 +1397741 9318 +139777 1804672 +139777 1804673 +1398 128053 +1398 132545 +1398 162974 +1398 221179 +1398 2323 +1398 24059 +1398 311327 +1398 9165 +1398094 1398095 +13981 162462 +13981 237971 +139811 504486 +139811 959208 +1398127 1398126 +1398497 1899393 +1398497 249584 +139875 142578 +139875 153406 +139875 208025 +139875 236034 +139875 380376 +1399 17400 +1399 619585 +1399 651 +13991 23515 +139941 52193 +1399626 1369019 +1399657 193918 +139974 221092 +139985 292478 +1400010 283122 +1400010 754974 +1400032 804841 +1400248 19799 +140032 293219 +140032 355 +140042 108568 +140042 95546 +14006 55 +140061 17271 +140061 196449 +1400615 243564 +14008 168627 +14008 28968 +14008 61357 +14009 204220 +14009 519166 +14009 62047 +14009 69449 +1401111 1389700 +1401111 2436079 +1401111 415470 +140123 1216927 +140125 272690 +140125 3207 +14014 108618 +14014 12466 +14014 21125 +14014 35134 +1401436 1046162 +1401762 1837064 +1401769 1727626 +1402043 1896664 +1402324 1469845 +140234 1345894 +140234 257966 +140234 44937 +140234 706774 +1402551 1138996 +1402603 234515 +1402603 603596 +1402685 1927301 +1402715 397953 +1402715 512585 +140277 251715 +1402949 2500320 +1403 7169 +1403 845450 +1403014 44955 +1403341 1509801 +1403461 2428201 +1403526 230237 +1403528 51350 +140355 2948601 +1403670 1403671 +14037 14037 +14037 320879 +1403714 795180 +1403826 895999 +1403826 896000 +1404142 610 +1404275 319808 +140434 182471 +140437 674977 +1404395 1404394 +1404880 1404878 +140497 850857 +1405007 596566 +1405024 1416655 +1405024 1932292 +1405024 1998849 +1405024 1998850 +1405024 2015317 +1405024 626008 +1405224 1043441 +140538 703304 +140547 1749482 +1405514 45733 +14056 100985 +14056 13095 +1406 2735023 +1406143 472936 +14062 12206 +140631 29614 +140631 81493 +1406361 1633662 +14067 14068 +14068 88228 +1407162 62866 +1407300 1383120 +140735 1194475 +140735 1222502 +140735 134091 +140735 194080 +140735 385906 +140735 72236 +140740 3297114 +140740 799148 +1407697 26920 +1407808 1492462 +1407839 2868404 +140788 207361 +140798 776633 +14081 893821 +140833 592895 +140835 1301383 +1408412 862200 +140854 29062 +1408760 212034 +140885 1793083 +1408977 7981 +1409 1138996 +1409 13335 +1409 1402551 +1409 1496735 +1409 199648 +1409 250870 +1409 32695 +1409 7466 +1409 966213 +1409095 1924199 +1409158 3140277 +140922 61270 +140937 106075 +1409738 1030674 +1409738 490279 +1409738 846295 +14099 48245 +1410 35539 +1410067 961093 +1410101 1424747 +14102 207909 +14102 8162 +1410212 323673 +141039 924137 +14104 5363 +14104 5575 +14104 72519 +1410444 438214 +1410759 313830 +14109 13705 +14109 15763 +14109 197731 +14109 49821 +14109 620761 +1410905 94940 +141097 22546 +1411 138100 +1411 1412 +1411 1564386 +1411 1565211 +1411 219322 +1411 91296 +14111 266156 +14111 413567 +14111 734951 +1411200 385525 +1411257 1253621 +1411257 1369126 +1411257 1449807 +1411386 223869 +1411475 1448227 +1411475 407260 +1411475 99151 +1411632 150401 +1411632 1758271 +1411632 1758273 +1411632 1807455 +1411632 2593892 +1411632 2593893 +1411632 2593894 +1411632 2852192 +1411632 3180501 +1411696 2403477 +1411728 459938 +1412 1413 +14121 205709 +1412153 183427 +1412153 98308 +1412379 1540772 +1412379 1577422 +1412615 1354136 +1412742 258111 +1412846 1412850 +1412846 1412851 +1412846 170759 +1412846 836127 +1412846 905491 +1412850 1412851 +1412850 170759 +1412850 905491 +1412851 905491 +1412855 1172502 +1412855 38754 +1413 312 +14132 7856 +141326 135874 +141326 144927 +141326 152684 +141326 473211 +141326 74210 +141331 235647 +1413468 870325 +1413628 1650496 +14143 96671 +14145 159465 +1414535 1796403 +1414535 47519 +141472 474079 +14148 40030 +1414935 269254 +1414935 855059 +1415 1413 +1415135 444553 +1415135 444554 +1415262 1229464 +1415273 44955 +1415387 1415386 +1415387 1521712 +1415555 271870 +1415555 397617 +1415555 880293 +1415555 883257 +1415555 931368 +1415851 702338 +1415867 841593 +1415867 859046 +1415867 900979 +1415870 1031262 +1415870 1239660 +1415870 1415871 +1415870 1640312 +1415870 1653542 +1415870 1909874 +1415870 2358508 +1415870 3292283 +1415870 3292284 +1415870 577808 +1415870 833625 +1415870 833629 +1415870 854228 +1415870 858375 +1415871 1031262 +1415871 1653542 +1415871 577808 +1415871 833625 +1415871 854228 +1415871 858375 +1415872 896995 +141600 212142 +141604 121934 +14164 119024 +1416551 425519 +1416655 626008 +1416944 1415867 +1416944 1640320 +1416944 841593 +1416944 859046 +1416944 900979 +1416949 1424466 +1416949 1508464 +1416949 852709 +1416949 868929 +1416955 1307759 +1416959 1416960 +1417030 1346687 +1417030 1417031 +1417030 1417032 +1417030 388185 +1417030 838169 +1417030 855065 +1417031 1417032 +1417105 8277 +1417105 9680 +1417352 2118060 +1417756 382163 +141786 813991 +14179 3533 +1417926 434336 +141806 382238 +141807 70672 +1418345 2334031 +1418389 2347050 +1418465 870326 +14185 40155 +141852 342214 +1418594 1170605 +1418712 426957 +1418744 1992367 +141885 534698 +141891 292672 +1419004 1419003 +1419013 374575 +1419073 291011 +1419091 411582 +1419370 1522103 +1419370 1837513 +1419390 257306 +1419390 404532 +1419390 80529 +141948 2258747 +1419530 32180 +1419536 1282024 +1419618 1427227 +1419770 1269513 +1419770 1270472 +1419770 1340656 +1419770 1346429 +1419770 1370946 +1419770 3149322 +1419770 424276 +1419770 833185 +1419770 858834 +1419770 880947 +141980 37300 +1419822 1096877 +1419822 342154 +1419822 930088 +1419981 1400270 +1419981 342543 +142 1066884 +142 13 +142 142 +142 161487 +142 1740 +142 18424 +142 185021 +142 2265 +142 2267 +142 25284 +142 32059 +142 4884 +142 9555 +1420 13533 +142044 142045 +142045 321209 +142045 360659 +142047 3162967 +142047 877624 +142053 502787 +1420626 1420625 +1420649 832917 +142065 133116 +142065 33762 +1420722 1533401 +142081 166284 +142087 1304470 +142092 3826100 +1421006 503753 +1421088 455166 +142117 142118 +1421173 97532 +14212 18956 +14212 348490 +14212 77522 +14212 97515 +14213 40246 +1421398 1404047 +1421398 834330 +1421398 909193 +1421398 909961 +142152 256456 +14216 44766 +142169 31866 +14218 222695 +14218 87391 +1421813 1291098 +1421916 1421917 +1421916 1421919 +1421918 1421916 +1421918 1421917 +1421918 1421919 +1421919 1421917 +1422 3833 +1422085 1860617 +1422117 1508993 +1422415 2317198 +1423146 1423147 +142363 32853 +1423674 914956 +1423674 938451 +1423674 938452 +1423688 318389 +1423769 3607628 +14238 17427 +14238 18949 +14238 215559 +1424032 283469 +1424032 397616 +1424032 451535 +1424032 454293 +1424032 517158 +1424032 833697 +142440 1970788 +142440 2080905 +142440 215495 +142440 2583705 +1424464 1424466 +1424464 1424467 +1424464 895152 +1424465 1424464 +1424465 1424466 +1424465 1424467 +1424465 895152 +1424466 1092548 +1424466 1228473 +1424466 1506707 +1424466 1508464 +1424466 281455 +1424466 703271 +1424466 852709 +1424466 868929 +1424466 895152 +1424467 1424466 +1424467 895152 +1424549 1917218 +1424549 900448 +1424580 1914722 +1424606 1406392 +1424606 1516797 +1424613 1065719 +1424613 161272 +1424830 32072 +1424830 371992 +1425139 290345 +142525 31345 +142574 390338 +142574 442919 +1425756 288878 +1425824 1229978 +1425824 526591 +1425879 1569485 +1425879 1707468 +142588 170438 +1425956 29895 +1426021 1432923 +14261 87182 +142646 1791730 +1426704 1057453 +1426704 2452795 +1426704 2452796 +1426704 814478 +1426704 861489 +1426704 915657 +1426837 260744 +1426837 261451 +1426837 833698 +1426837 845360 +1426837 985088 +142706 39206 +142706 66418 +14275 506522 +142754 310513 +142755 94500 +142755 94501 +1427815 1427815 +1427815 309991 +1427885 1077175 +1427885 1098128 +142798 106825 +142798 336575 +142817 526886 +1428176 3762389 +14282 1831 +14282 92500 +1428377 1447547 +1428394 1538989 +1428400 1780043 +1428466 153980 +1428466 262940 +1428535 1904527 +1428863 669777 +1429382 834378 +1429382 885767 +14295 190317 +14295 207029 +14295 209156 +14295 27811 +1429533 587595 +1429542 1429543 +142955 90742 +142963 134184 +14297 3466 +142981 572127 +143 230354 +1430 2187 +1430 30309 +143004 127364 +143004 878782 +1430140 329064 +143017 341257 +143018 155537 +143018 92787 +1430196 1040777 +1430196 1919176 +1430196 1931864 +1430196 1931865 +1430196 577808 +1430196 841593 +1430196 896995 +1430197 1416949 +1430197 1424466 +1430197 1508464 +1430197 170759 +1430197 852709 +1430197 868929 +1430197 986112 +143024 1154060 +143024 732838 +1430648 143606 +1430826 2172655 +1430826 682739 +1431 151065 +1431 996 +143109 29060 +143109 298265 +143109 613277 +143112 229744 +1431316 1431318 +1431317 1431316 +1431317 1431318 +1431354 1137834 +1431621 1431620 +1431628 1431620 +1431628 1431621 +1431703 1427655 +1432317 1432316 +143243 180204 +143244 289198 +143244 292640 +143244 436743 +143244 66020 +143244 775821 +143244 810208 +1432541 2487359 +1432541 3195952 +1432629 1231965 +143264 50528 +143267 219604 +1432675 870450 +14328 1225837 +1432818 1432822 +1432819 1432818 +1432819 1432822 +1432820 1432818 +1432820 1432819 +1432820 1432822 +1432861 1432857 +1433 363533 +1433248 1433251 +1433248 299702 +1433248 388185 +1433251 299702 +1433251 388185 +1433292 1830309 +143335 38195 +14334 258032 +14334 467280 +1433404 236239 +1433481 1565648 +143350 338628 +143352 142665 +143352 99262 +1433562 2503760 +1433800 1433801 +1433853 1055111 +1433853 1327245 +1433854 356780 +1433861 555846 +143395 136728 +143434 17558 +143434 2309 +1434439 267686 +1434564 283122 +1434564 454293 +1434565 369053 +1434565 454293 +143457 202316 +1434585 313337 +14346 145810 +1434749 2701650 +1434762 48812 +1434766 1184022 +1434783 2133304 +1434783 2133306 +1434783 2133308 +1434783 2133309 +1434783 2133310 +1435007 1212526 +14351 606637 +1435168 1435169 +143535 182693 +1435600 898035 +1435615 870450 +1435725 708278 +1435725 778759 +14358 258767 +14360 53279 +1436031 1299845 +14361 14362 +14361 226532 +14361 766427 +1436171 1436172 +1436216 1519494 +1436267 473792 +1436384 1436385 +1436384 2091637 +1436793 1192841 +1436793 1468646 +1436793 1552022 +1436793 835518 +1436793 855061 +1436793 861690 +14368 80900 +1437206 1437207 +1437206 454293 +1437206 95546 +1437207 95546 +1437326 1190614 +1437407 305847 +1437407 558045 +143751 53116 +1437529 1733208 +143762 484 +1437686 1563120 +1437686 523070 +1437748 3138900 +1437748 696215 +1437748 849477 +1437771 1560393 +143778 113916 +143778 201470 +143795 25058 +143799 187941 +143805 246613 +1438084 532045 +14381 14382 +14382 165412 +1438210 2946357 +1438525 1920589 +143864 350329 +143894 77522 +143896 231900 +143916 239367 +143916 500606 +143916 5892 +1439192 1205848 +1439192 253245 +1439192 262940 +1439192 311048 +1439192 532273 +1439192 751505 +1439192 795171 +1439192 795195 +1439192 800264 +1439192 837534 +1439192 850893 +1439192 861489 +1439260 762742 +1439270 3678583 +14393 110704 +14393 195667 +14393 65826 +14393 8261 +1439465 1144795 +1439465 1418619 +143948 7779 +1439779 1439777 +1439900 1542529 +1439900 1975891 +1439900 28943 +1439900 296870 +1440075 1440074 +1440092 1890993 +1440242 696257 +1440242 889200 +14403 1521780 +14403 7098 +1440356 847924 +1440574 2518111 +1440574 393383 +1440574 841590 +1440574 870697 +1440950 1173666 +1440950 1173667 +1440950 393383 +1440950 832962 +1440950 835184 +1440950 835735 +1440951 1173674 +1440951 902982 +1441138 1441139 +14412 281707 +14412 3177926 +14412 39302 +14412 458560 +14412 46411 +14412 546790 +14412 66020 +14412 772876 +14412 980145 +14412 997489 +144131 12588 +144131 25406 +1441341 120307 +1441341 1213624 +1441341 183267 +1441341 335370 +1441341 3427523 +1441341 3427524 +1441341 509192 +1441341 79439 +144135 72328 +14414 24046 +1441533 16480 +1441533 1940135 +144193 48650 +144193 65636 +1441992 654531 +14420 92536 +14423 28844 +144232 1421270 +144232 3500541 +1442352 453945 +1442496 985099 +1442497 945373 +14427 209779 +144287 176639 +1443048 1381003 +144310 1252978 +144310 1496737 +144310 202093 +144310 202611 +144310 20691 +144310 22946 +144310 317584 +144310 434026 +144310 446471 +144310 649582 +144310 649584 +144310 67657 +144310 683940 +144310 798940 +144310 835739 +144310 858488 +144313 85762 +1443217 1443038 +1443272 1594257 +1443272 855758 +1443366 288549 +144357 195891 +1443950 1509007 +1444 2072638 +1444073 556385 +1444169 2104531 +144431 167665 +1444741 1277627 +144475 482238 +1444803 257423 +1444803 274979 +144485 210252 +14449 10625 +14449 218140 +1445 198108 +1445 59048 +1445 89866 +1445142 261635 +1445142 517995 +144526 144526 +144526 1639031 +1445467 2279349 +1445610 326274 +14457 14473 +14457 29236 +14457 67223 +14457 89374 +1446007 252868 +144610 31821 +144644 219886 +144644 8099 +144644 907753 +1446579 1000139 +1446579 2330456 +1446579 2523943 +1446579 938452 +14466 14473 +1446747 920459 +1446834 1446835 +1446879 1885207 +14470 78273 +1447014 392263 +14472 157387 +14472 199262 +14472 23437 +14472 31937 +14472 545663 +14472 66861 +14472 77910 +14473 157402 +144732 28312 +1447327 1503655 +144758 164246 +1447623 1447627 +1447759 1524161 +1447773 842888 +1447876 1153365 +1447876 496778 +1447938 1447939 +14480 14484 +14480 3592015 +1448069 388889 +14481 179513 +144810 346057 +1448227 407260 +144843 144844 +144843 181207 +14485 14491 +14486 46873 +144875 2986380 +1448893 15900 +1448928 1250603 +14490 168784 +14490 75072 +1449004 480227 +14492 19037 +144927 230539 +144927 307722 +144927 317259 +144927 63084 +144934 611447 +144945 194483 +144946 1945073 +1449507 2227887 +144951 759756 +144955 262940 +1449597 2527427 +14496 28160 +14496 93756 +1449807 1449807 +1449807 222523 +1449807 2659666 +1449807 769347 +1449905 1601411 +144998 253791 +1449987 1015406 +1449987 833179 +1450172 288863 +1450542 1430196 +1450542 841593 +1450542 896995 +145071 1322005 +145072 888079 +145077 319871 +1450846 1060119 +1450846 144100 +1450846 14602 +1450846 1552381 +1450846 945756 +145095 31523 +14512 102685 +145130 1665 +145173 316428 +145180 145180 +145180 21959 +1451894 81131 +1452056 52724 +1452056 593991 +1452056 7247 +145229 134254 +1452363 984921 +145244 181485 +145256 145264 +145256 145272 +145256 290874 +145256 97545 +145262 136133 +145262 2181784 +145262 239399 +145262 274433 +145262 278781 +145262 317903 +145262 38207 +145262 59405 +145263 403488 +1452633 181208 +145264 254990 +14527 1365 +14527 69449 +145272 251873 +145272 259079 +145272 271897 +145272 307298 +145272 59251 +145273 238626 +145273 254823 +145273 274429 +145273 338287 +1452805 1720343 +145288 388298 +145298 33801 +145298 8299 +1453047 326880 +145312 487822 +1453432 1466003 +1453782 1163591 +14539 1990849 +14539 22948 +14539 634951 +14539 871 +1453927 1781638 +14540 14545 +145423 643582 +1454261 1805557 +1454261 2951903 +145436 1783385 +1454393 445524 +145443 300225 +145443 35086 +1454847 1102976 +1455106 110352 +1455143 234010 +1455143 2773617 +145539 1849338 +145539 1977477 +145539 2262477 +145539 249584 +145539 2882883 +145539 3039466 +145539 3067086 +145539 3219528 +145539 670901 +145546 70426 +1455540 1568702 +145557 145558 +1455572 2737027 +1455572 649968 +145561 26862 +1455697 3517872 +145586 27657 +145587 116681 +145590 106541 +1456011 1538522 +145606 406 +1456129 212263 +1456195 1578039 +1456195 311155 +145630 2032931 +1456389 1540058 +145639 7182 +1456628 1456629 +1456642 837568 +1456642 941077 +1456652 2026007 +145691 2527813 +145721 13 +145721 234110 +145721 99026 +14573 2177 +145738 1246943 +145738 145811 +145738 294509 +1457421 870326 +145748 402640 +1457669 3361913 +145768 250644 +14577 26279 +14577 294269 +14577 555263 +14577 814873 +14577 957760 +14577 957761 +145778 145779 +145778 22720 +145779 22720 +145780 94419 +1457836 833445 +1457836 833697 +1457836 835519 +1457836 837518 +1457836 845358 +1457836 883315 +145820 1036056 +1458226 1628392 +1458226 1628393 +145828 37956 +14584 14587 +14584 20363 +145843 130367 +145843 211100 +145843 21731 +145845 173008 +145845 244341 +145845 73036 +145858 173399 +145858 367627 +1458687 1499138 +1458934 1458934 +1458934 2483417 +1458934 2786693 +1458934 331717 +1458942 2001349 +145895 673141 +145907 1254764 +145907 1539260 +145907 1614149 +145907 1654505 +145907 1659317 +145907 2039093 +145907 2139457 +145907 2553398 +145907 2621858 +145907 2728736 +145907 2751359 +145907 538924 +1459329 1464901 +1459655 1012899 +1460 19799 +1460 21852 +1460 265332 +146008 1294488 +146014 657376 +14602 144100 +14602 27951 +1460256 2458647 +14604 63298 +146047 542928 +146051 444950 +146059 30138 +146059 385627 +146059 65317 +146060 1558388 +146060 40582 +146060 711305 +146061 146062 +146061 247894 +146061 3924 +146061 528503 +146061 77811 +146062 117723 +146062 147234 +146062 166289 +146062 77813 +146063 22887 +146065 64735 +146066 1371630 +1460746 194 +1460746 87640 +146083 23345 +1461 4296 +1461 875 +1461002 182109 +1461002 27307 +1461044 1129268 +146127 229000 +1461288 1461273 +1461356 509222 +146143 240218 +146155 410643 +1461629 150554 +1461644 1461644 +1461644 2695859 +1462074 621342 +1462098 22269 +1462098 588638 +1462098 84774 +1462118 8252 +1462131 1089748 +1462131 2605787 +1462131 2737 +1462131 2741980 +1462131 336768 +1462131 773474 +1462461 363034 +1462521 735381 +146272 158907 +146286 363580 +146286 41105 +146286 80129 +1463 1249510 +1463 1890712 +1463 3057 +146310 146311 +14632 184711 +14632 924353 +1463203 1463204 +1463492 1382366 +1463492 936109 +1463517 1463518 +1463707 1822475 +1463707 2045236 +1463707 2624372 +1463723 164279 +146373 2517397 +146373 2517398 +14642 829892 +14642 829893 +14642 829894 +146420 1999857 +146420 230732 +146420 54524 +146420 81368 +1464351 578565 +14646 111502 +14646 1401484 +14646 208836 +14646 21742 +14646 229665 +14646 321128 +14646 97139 +146475 204665 +146475 274865 +1464791 133768 +1464791 210318 +146487 12884 +146487 942962 +1464903 1312796 +1464903 1322495 +1464903 1382207 +1464967 1464968 +1464967 1744350 +1464968 1744350 +1465 1459 +1465105 1465101 +14652 43739 +1465204 1030674 +1465204 1409738 +1465204 490279 +1465204 846295 +146564 1081315 +1465847 1014071 +146599 188609 +146599 2123377 +146599 452102 +1466133 1080658 +1466366 898476 +1466510 410038 +146664 16127 +146664 303754 +1466640 2729297 +146685 237899 +1466959 2049102 +1467174 339756 +1467174 754894 +1467174 784121 +14674 1132656 +14674 205253 +14674 3649 +14674 6211 +1467484 1109700 +14675 148965 +14675 75993 +14676 69095 +1467707 333558 +1467707 908058 +1467934 1054432 +14680 321946 +1468000 1316479 +14681 14685 +14683 14898 +14684 14687 +1468590 1146510 +1468590 1216464 +1468610 31109 +1468610 786318 +1468639 3635615 +1468646 1552022 +1468646 835518 +1468646 855061 +1468646 861690 +1468727 1468726 +1468741 1468740 +1468741 1923298 +1468741 29074 +1468761 2121662 +1468981 663652 +1468993 191036 +146903 112933 +146906 1233462 +146906 363557 +146906 433852 +146906 610696 +1469195 963287 +1469240 1043839 +146959 156660 +1469592 1235358 +1469592 1335225 +1469592 1469594 +14696 1987841 +146960 113901 +146960 800638 +14698 1180390 +14698 891890 +146984 11573 +146984 1322663 +146984 441261 +146995 1005259 +146995 66147 +1470078 1403341 +1470144 293378 +1470144 661000 +1470369 1712524 +1470369 2080432 +1470516 59411 +14709 1124506 +1470998 1228566 +1471046 1454393 +1471120 1158058 +1471120 813126 +1471362 821985 +1471533 119304 +1471533 1884995 +1471533 1949839 +1471533 2621213 +1471533 2984284 +1471533 676272 +1471533 978128 +14716 374220 +1471791 63132 +1471828 1471828 +1471828 418233 +1471828 66089 +1471856 836263 +1471953 1471954 +147202 144032 +147202 1618539 +147202 1823267 +147202 218140 +147202 222253 +1472021 22615 +1472269 716210 +1472399 1508349 +14724 163617 +14725 39655 +14725 39656 +147255 2378127 +147255 2378128 +1472585 108897 +1472585 1138856 +1472585 56798 +1472752 2387676 +1473 568 +147328 130180 +147328 181840 +147328 182678 +147328 54074 +147328 99026 +1473513 10020 +14736 399770 +1473741 1473740 +147379 1049791 +147379 193918 +147379 225071 +147379 37359 +147379 378011 +147379 45382 +147379 6668 +147379 87443 +147379 996604 +1473919 1473918 +1474281 1561431 +14743 6378 +1474541 1599566 +1474638 1618963 +147477 1248638 +147483 31219 +1474921 1233084 +1474921 1262427 +1474921 1343482 +1474921 387087 +1474921 523070 +1474921 865251 +147493 160700 +14753 125912 +14753 31712 +14753 31777 +14753 50513 +14753 53121 +1475566 490958 +147652 1961578 +147664 21591 +147664 545545 +147674 787641 +147679 147680 +1476835 1035341 +1477 313363 +1477 71279 +1477049 1477050 +1477073 1477072 +1477103 1050296 +1477103 227843 +1477103 873811 +1477103 938087 +1477181 1477182 +1477181 2085393 +1477181 260744 +1477181 283122 +1477181 543206 +1477181 696171 +1477181 837502 +1477181 837545 +1477181 973042 +1477182 1211021 +1477182 2129597 +1477182 260744 +1477182 283122 +1477182 543206 +1477182 696171 +1477182 833842 +1477182 837502 +1477182 837545 +1477182 852709 +1477182 861690 +1477182 92243 +1477182 931244 +1477182 944044 +1477182 997191 +1477218 256582 +1477237 1477401 +1477239 1061083 +1477239 345477 +1477341 357954 +1477343 1263534 +1477343 459674 +1477343 459676 +1477343 872584 +1477364 72328 +1477374 1461640 +1477531 946229 +147754 147754 +1478032 772128 +14781 5981 +147829 147829 +147829 6086 +147829 609618 +147829 7299 +147829 8266 +14783 63684 +14784 29903 +1478576 681200 +1478674 1430196 +1478674 1450542 +1478674 1478676 +1478674 841593 +1478674 896995 +1478675 1025834 +1478675 1032278 +1478675 1229978 +1478675 1279686 +1478675 1341604 +1478675 1430196 +1478675 1447773 +1478675 1450542 +1478675 1478674 +1478675 1478676 +1478675 1636340 +1478675 2129819 +1478675 2401903 +1478675 262940 +1478675 269254 +1478675 3519719 +1478675 441528 +1478675 526591 +1478675 577808 +1478675 696260 +1478675 833168 +1478675 835968 +1478675 837674 +1478675 841590 +1478675 841593 +1478675 842888 +1478675 851310 +1478675 851418 +1478675 882018 +1478675 896995 +1478675 900979 +1478676 1430196 +1478676 1450542 +1478676 841593 +1478676 896995 +1478695 433626 +14788 20573 +14788 7169 +1479 17218 +147902 1689444 +147902 2235302 +1479041 1402421 +1479242 863491 +1479242 882758 +1479359 1224348 +1479359 23340 +1479359 63119 +1479387 1395855 +148 247802 +148 739771 +148008 29546 +1480094 300435 +1480341 1425879 +1480341 1569485 +1480341 1707468 +148040 19145 +148040 218948 +148040 25827 +148040 291382 +148040 362652 +148040 89110 +1480424 365298 +1480724 425546 +1480724 976859 +1481008 2575373 +1481031 1775313 +1481047 2559172 +1481066 267095 +1481127 1481128 +148153 85169 +1481537 1481547 +1481537 855073 +1481537 868929 +1481540 415720 +1481540 454293 +1481540 841590 +1481547 855073 +1481548 1246887 +1481548 1307759 +148155 131283 +1481747 2680491 +1481780 912365 +1481831 1740818 +1482178 58574 +1482196 541117 +1482340 136875 +1482382 2304533 +14826 39115 +1482778 1482779 +1482969 490279 +1482969 846293 +1482969 900110 +1483036 25800 +148338 94023 +1483406 1465577 +1483406 3500578 +1483707 1054398 +1483707 273520 +1483708 1054398 +1483708 1483707 +1483708 273520 +1483709 1054398 +1483709 1483707 +1483709 1483708 +1483709 273520 +1483721 262564 +148394 1068169 +148394 127402 +148396 256145 +148401 644193 +148412 87227 +14846 32084 +14846 49491 +14846 9078 +148475 252310 +148475 254065 +148475 332796 +148475 340034 +148475 473793 +1484973 2023931 +1484998 674785 +1485 57870 +14850 163297 +14850 201559 +1485146 1071287 +1485146 744724 +1485146 858480 +1485559 940921 +1485602 1612989 +148574 283540 +148592 540847 +1485932 1825838 +1486049 915943 +1486056 1486055 +1486058 1549516 +1486111 2092023 +14862 13561 +14862 99415 +1486230 80081 +148628 152380 +1486360 840143 +148640 1494753 +148640 3193123 +148640 334031 +148640 41338 +148640 54074 +148640 973702 +148640 981490 +1486827 38770 +148704 25298 +148706 18999 +148706 74710 +1487111 1920588 +1487111 1920589 +1487111 2155036 +1487111 2155038 +1487111 24394 +1487111 493793 +1487260 1885041 +1487260 2140375 +1487337 1271647 +1487387 297988 +1487401 1930324 +148750 149727 +148750 176049 +148750 212034 +148750 3083 +148750 329773 +148750 345412 +148750 350630 +148750 365684 +148750 374522 +148750 417839 +148750 4937 +148750 624317 +148750 746194 +148750 809575 +1487531 112282 +148762 108363 +1487635 143217 +1487710 1871283 +148779 148780 +1488101 158922 +148815 3907 +148835 168466 +148856 90210 +14886 124483 +14886 40820 +1488611 1170969 +148864 1060687 +148864 510438 +148864 682822 +148864 93921 +1488744 1080247 +1488744 1488743 +1488744 415720 +1488744 573239 +1488744 814478 +1488744 841593 +1488744 855061 +1488744 858372 +1488744 900979 +1488744 998856 +14888 1110 +148889 819138 +1488949 2476 +1489 29376 +1489 3427 +1489 49476 +1489 6331 +1489044 786121 +1489194 177046 +148936 84395 +148938 1058660 +1489583 873564 +148965 75993 +148968 139974 +148968 221092 +14898 3452 +14898 36807 +148999 1523681 +148999 2006245 +149 134725 +149 204149 +149 230885 +14900 28504 +149007 63436 +1490119 2000915 +149041 312727 +149044 280639 +149072 212765 +149072 24241 +1490829 59226 +1490857 2655561 +1490865 970022 +1490888 2265 +149109 151197 +149109 399093 +149109 842355 +1491119 21875 +1491279 1491279 +1491279 2265141 +1491280 1414470 +1491280 201958 +1491405 1491404 +149162 2687330 +1491760 1141905 +1491981 24059 +1491996 390992 +1492272 1283441 +149228 32096 +14923 967747 +1492346 1796013 +1492462 2720950 +149249 508496 +149254 104673 +149254 135873 +149254 1586687 +149254 251782 +149254 253445 +149254 271155 +149255 330884 +149255 494407 +1492560 1533524 +1492560 1948403 +1492648 1492651 +149268 2187 +149278 1247 +149278 205808 +149278 3083 +149278 327234 +149305 2751 +1493088 1965234 +1493088 932064 +1494 1455143 +1494 2184 +1494 234010 +1494 4293 +149414 107270 +149414 2091706 +149420 1487966 +149423 1288920 +149436 1209862 +149439 227896 +1494546 132339 +1494847 2945428 +149487 39294 +149487 742608 +14950 14068 +1495070 191323 +1495070 2093923 +149530 56551 +14954 3990 +14954 62947 +14954 97135 +14954 996144 +149540 60436 +1495456 1495457 +14956 169524 +1495739 1553243 +1495891 254615 +1495891 326677 +1496081 2167401 +14961 18293 +149611 85653 +1496381 2419281 +14964 104278 +149642 1079035 +149642 1092691 +149642 1133698 +149642 1300061 +149642 238870 +149642 420689 +149642 947998 +1496737 434026 +1496737 835739 +1496893 318389 +1496956 1420541 +1496956 2333160 +1497 2105 +1497 218483 +149712 1066237 +149713 1896348 +149713 922709 +149719 67805 +1497259 1616764 +149727 176049 +1497332 21875 +1497349 1993553 +14974 1576867 +14974 220811 +14974 23812 +14975 107946 +14975 14977 +14975 14981 +14975 194 +14975 204518 +149754 509739 +149756 484024 +149759 894822 +14977 194 +1497745 1497744 +149784 2203734 +1498046 611 +14981 204518 +1498210 246752 +149836 1068 +1498432 1141685 +1498471 947022 +1498559 1498560 +1498559 1498562 +1498559 676367 +1498559 857611 +1498560 1498562 +1498560 676367 +1498560 857611 +1498561 1498559 +1498561 1498560 +1498561 1498562 +1498561 676367 +1498561 857611 +1498562 676367 +1498615 156088 +14987 17388 +14987 24463 +14987 65102 +14987 8608 +1498732 1922248 +14988 17391 +149910 165277 +149910 21735 +149910 298915 +149910 4492 +14993 14987 +1499360 1123426 +1499360 2360473 +1499372 1395383 +1499477 139409 +1499477 2833115 +1499477 681416 +1499530 106294 +149959 7084 +1499605 205808 +1499605 28377 +14997 19632 +14997 20427 +14997 27234 +14998 31428 +149981 7167 +149982 65559 +1500 100950 +1500037 775997 +1500156 134530 +150016 20176 +150016 21503 +1500198 1500197 +1500198 1500199 +1500198 1841994 +1500199 1500197 +1500199 1841994 +150021 192192 +1501048 1501067 +1501134 1547427 +150114 27372 +150114 6009 +150114 99246 +15012 19403 +150136 39455 +150156 308405 +150156 3636736 +150156 445229 +150167 276556 +1501948 1627281 +1501991 1040507 +1501991 860273 +1502019 1502021 +1502092 502329 +1502126 2099152 +15022 15023 +15022 15583 +150226 150227 +15023 9901 +1502317 1502316 +1502320 1595361 +1502380 323295 +1502417 2308396 +1502546 1502547 +1502556 1958169 +150275 22766 +1502937 206196 +1502937 3098415 +1503 108262 +1503 113489 +1503 237712 +1503 927123 +1503052 2407742 +1503117 15670 +1503230 1849294 +1503230 269254 +150329 150330 +1503519 864674 +1503519 867849 +15036 33006 +1503647 1503649 +1503754 1931146 +1503754 2073624 +1503754 44364 +1503754 681275 +150386 851838 +1504 28186 +1504 34554 +1504 42848 +150401 2593892 +150401 2593894 +150401 2852192 +150401 3180501 +150405 188392 +150407 19776 +150409 69621 +1504137 373556 +1504309 1504311 +1504349 1007492 +1504349 1262335 +1504349 1299987 +1504349 1787565 +1504349 1958163 +1504538 1069995 +15047 15382 +15047 3055 +15047 3978 +15047 6332 +15047 80992 +1505 1564349 +1505191 1262640 +1505245 1653029 +15055 26729 +15056 156732 +1505644 2492644 +1505833 539529 +1506193 357921 +150634 130800 +150641 874752 +150646 105862 +150646 357395 +1506526 1506527 +1506707 1092548 +1506707 281455 +1506707 703271 +1506783 1688895 +150699 5290 +1507256 2140071 +1507433 867976 +1507460 1173606 +1507460 1966189 +15075 70526 +1507907 1322422 +150801 119795 +150801 366849 +150807 212751 +150835 228928 +1508464 852709 +1508464 868929 +1508496 1030674 +1508496 736606 +1508496 895152 +1508506 772876 +150895 150896 +1509007 426333 +1509010 1720135 +1509010 336243 +1509010 574488 +15092 100668 +150920 176806 +1509278 3298970 +1509801 2462438 +15099 202652 +15099 860150 +151 2408833 +1510 322470 +1510397 2395619 +15105 84098 +15108 1335742 +15108 17119 +15108 197980 +15108 245232 +151094 515352 +1511019 2345476 +1511355 1307759 +1511355 1416955 +1511355 2129819 +1511355 406278 +1511355 833543 +1511355 833787 +1511355 837674 +1511355 861474 +1511355 912593 +1511489 1639465 +1511489 673330 +151151 23259 +1511607 531701 +151195 103455 +151195 253032 +151195 255774 +151195 503390 +1511967 1140126 +151199 1008036 +151199 137880 +1512 99757 +151205 113307 +1512261 5363 +151245 365527 +151252 229714 +151253 1261174 +151253 838935 +1512555 1515214 +151264 433047 +151311 1014245 +151311 201958 +151311 203446 +151311 36174 +151311 45866 +151311 471931 +151311 473330 +151311 4954 +151311 69589 +151311 81496 +1513141 249845 +1513560 994633 +151357 1369609 +151357 164236 +151357 2373270 +151357 62125 +151357 80105 +15137 16711 +151391 32781 +15140 15203 +15140 20660 +1514040 1850173 +1514164 474340 +15142 1267534 +15142 15140 +15142 15203 +15142 18404 +15142 18409 +15142 193075 +15142 242533 +15142 35362 +15145 15140 +15145 15203 +151458 265198 +151459 55592 +15146 15140 +15146 15145 +15146 15203 +151461 14051 +1514674 2973463 +15147 20073 +15147 20660 +15147 3027644 +1514948 1514946 +1515 105600 +1515 159950 +1515 1650972 +1515 190356 +1515 20818 +1515 243824 +1515 272690 +1515 689243 +15152 1213591 +1515256 129438 +1515496 1295680 +1515496 1523148 +1515763 2773896 +151580 180569 +1515896 1732201 +1515964 2102320 +1516004 1125579 +151607 226138 +151634 1943242 +151634 211206 +151634 300541 +15165 33528 +15166 192738 +15166 54567 +15166 71519 +15167 182269 +15167 2571 +15167 28327 +15167 5268 +15167 9544 +1516786 1031993 +1516786 1205065 +1516786 1362287 +1516786 1406392 +1516786 1424606 +1516786 1516791 +1516786 1516797 +1516786 1516820 +1516786 880605 +1516786 899900 +1516791 1362287 +1516791 1406392 +1516791 1424606 +1516791 1516797 +1516791 1516820 +1516791 880605 +1516791 899900 +1516797 1406392 +1516820 1406392 +1516820 1424606 +1516820 1516797 +1516820 880605 +1516820 899900 +15169 37048 +15169 52199 +1516901 2209128 +151691 248309 +1516953 174122 +1516953 354816 +151733 70607 +1517555 1164173 +15176 30031 +151767 1331818 +1517704 812899 +151793 180619 +151793 75559 +1517936 84839 +151810 14397 +151810 668039 +1518107 1518108 +1518123 2466089 +1518123 31418 +1518574 1425485 +1518574 467945 +1518780 912297 +1518780 912299 +1518984 1356737 +1518984 1607137 +1518984 239008 +1518984 564471 +1519090 282619 +1519210 931114 +1519230 1819131 +1519230 409252 +15193 59910 +1519525 115605 +1519786 1519785 +1519786 629020 +15199 15147 +1519985 1519984 +15200 15986 +152004 230344 +152021 3415337 +152021 36624 +152021 52227 +15203 1601559 +15203 185737 +15203 193075 +15203 242533 +15203 66208 +15204 15140 +15204 15147 +15204 17715 +15204 20073 +15204 3293 +15204 64323 +1520481 2467474 +1520589 1858685 +1520828 40998 +1520943 526047 +152096 152097 +152098 272157 +152098 304114 +152098 649836 +152098 90113 +152106 60199 +152131 795693 +1521586 949343 +1521596 1521597 +1521598 1521596 +1521598 1521597 +1521611 1521612 +152178 1112292 +1522103 1837513 +15223 11584 +15223 11625 +15223 150114 +15223 15223 +15223 15346 +15223 18353 +15223 25832 +15223 5522 +15223 563086 +15223 6070 +152237 100101 +152246 1846423 +152246 337062 +152246 353627 +152246 378229 +152246 69817 +152246 701741 +1522699 1401187 +1522699 1568321 +1522761 1636538 +152277 197572 +152277 764991 +15228 36544 +15228 53899 +1522840 599477 +1522840 816639 +1522980 754974 +152299 1150758 +152304 14572 +152304 160265 +152304 178389 +152305 321181 +152305 505238 +15231 122268 +152312 132082 +152312 328925 +1523148 1796403 +1523229 466716 +1523429 889224 +152346 107560 +152346 166955 +152346 271923 +152346 447922 +152346 52753 +152346 643847 +1523521 2719817 +1523605 1492705 +1523681 2006245 +152369 359449 +152380 182322 +152380 2304644 +152385 152380 +152385 182322 +152385 2304644 +152391 396030 +152402 153980 +1524060 111476 +1524060 7708 +15241 17422 +15241 19194 +15241 20338 +15241 48370 +1524105 950662 +152425 275420 +1524329 110387 +152435 20818 +152459 166838 +152480 1010827 +1525196 1449807 +1525196 222523 +152529 837230 +15254 146344 +15254 191016 +15254 2005836 +15254 235334 +1525449 1525444 +152560 21977 +152564 133972 +152564 20907 +152564 285420 +152564 370522 +152599 19803 +1526 237407 +15261 283192 +1526299 375279 +1526299 95537 +1526322 1197191 +1526425 802767 +1526425 802768 +1526488 2321 +152684 135874 +152684 325649 +152684 325650 +152684 473211 +152684 74210 +1526911 2154438 +152707 193583 +152707 458667 +152707 59407 +152709 1561956 +152709 1905203 +152709 374780 +152720 20800 +1527372 923308 +152752 229646 +152754 1258970 +152754 371804 +152754 503075 +152755 260727 +152755 59659 +1527592 1479204 +1528152 1202353 +1528152 1595296 +1528152 1668110 +1528152 335760 +1528152 3388491 +1528152 375279 +1528152 95537 +1528200 550341 +15285 142776 +152859 1308594 +1528780 3810607 +152886 152887 +1529 13038 +152900 365750 +1529141 562933 +152933 66261 +1529450 2855706 +1529450 4098 +152956 328 +1529742 1529745 +1529810 1246963 +1529810 27519 +1529810 809856 +1529810 835739 +153 154 +153 6347 +153 6544 +1530032 14743 +15301 40983 +15302 199360 +15302 204088 +15302 269729 +15302 89785 +153073 253708 +153073 275520 +153073 286546 +15309 207517 +1531 1067295 +1531 185 +1531 94919 +15310 103097 +15310 20215 +15310 20226 +15310 20231 +15310 207517 +15310 6124 +153106 153107 +153107 15143 +153142 464648 +1531553 29316 +1531921 1390230 +153198 395422 +1532093 1532090 +1532123 1769553 +1532371 1450181 +153241 395731 +1532696 1190449 +1533079 2264 +1533345 832696 +1533397 1420722 +1533397 1533401 +153367 449942 +1533956 13114 +1534029 218045 +153406 1136996 +153406 146420 +153406 1511809 +153406 54524 +153408 212400 +153408 91587 +1534265 1341454 +1534265 3113189 +153430 153431 +153430 168276 +153431 168276 +15346 604451 +1534777 337613 +15348 129798 +15348 45593 +153486 14185 +153486 29819 +153486 40155 +1535009 113071 +1535009 1236112 +1535009 1322663 +1535009 4000564 +1535052 1724370 +1535052 959446 +1535052 995553 +15352 36733 +153534 216729 +153534 444879 +153541 1021034 +153541 617625 +153550 248600 +1535518 222384 +1535518 344166 +1535518 413127 +1535518 869054 +1535518 985935 +1535599 268496 +1535655 3572685 +1535716 19098 +153600 1586501 +1536084 1603609 +1536084 724168 +1536138 111676 +1536171 2077734 +153626 115864 +153626 3850 +153626 498171 +15363 9183 +153641 1407519 +153641 225212 +1536492 1168678 +15366 15364 +1536924 165135 +1536924 62148 +1536956 1561067 +1537215 60850 +1537217 629020 +1537533 700491 +153759 154390 +153765 55369 +1537725 2923123 +1537732 200603 +1538 70622 +153814 6465 +1538184 1538183 +153833 452097 +153840 2563 +153840 26687 +153861 136056 +153887 206099 +1539162 697975 +1539183 457235 +1539260 1254764 +1539260 1614149 +1539260 175568 +1539260 2581725 +1539260 2621858 +1539260 400575 +153940 59421 +153954 500736 +153956 60910 +1539603 430279 +153980 1012862 +153980 1028502 +153980 1037718 +153980 1042460 +153980 1042892 +153980 1053431 +153980 1261307 +153980 1264237 +153980 1300550 +153980 18666 +153980 2268127 +153980 2323597 +153980 271877 +153980 310343 +153980 397616 +153980 432960 +153980 446471 +153980 452030 +153980 454293 +153980 526591 +153980 538646 +153980 555458 +153980 577716 +153980 613949 +153980 696160 +153980 696200 +153980 832688 +153980 832951 +153980 833317 +153980 833462 +153980 834378 +153980 835066 +153980 835518 +153980 837503 +153980 840548 +153980 851310 +153980 851418 +153980 851589 +153980 852701 +153980 855761 +153980 884545 +153980 887610 +153980 900110 +153980 950082 +153980 950106 +153980 953905 +153980 953928 +153980 954643 +1539851 834088 +1539851 835650 +1539851 835927 +154 1471 +154 192 +154 4449 +154 6347 +154 8152 +154004 188280 +1540192 594074 +1540353 84676 +154059 723587 +154059 748731 +15407 1163931 +15407 79265 +1541162 1098583 +154127 112466 +1541489 2610502 +1541603 1308012 +1541603 1787012 +1541603 283127 +154174 1340656 +154174 1370946 +154174 1419770 +154174 267134 +154174 3149322 +154174 356317 +154174 415725 +154174 716084 +154174 743704 +154174 743705 +154174 833185 +154174 834703 +154174 835060 +154174 836106 +154174 836185 +154174 842641 +154174 842645 +154174 844189 +154174 844443 +154174 844675 +154174 845760 +154174 845763 +154174 848756 +154174 858834 +154174 875353 +154174 875368 +154174 875370 +154174 880947 +154174 909198 +154174 960912 +154174 963656 +154174 998855 +1541992 2867878 +1542373 1014584 +1542373 504263 +15424 115018 +15424 15629 +154242 154243 +154260 154268 +1542787 948344 +154285 359068 +154285 395913 +154285 539272 +154285 834611 +154287 154286 +154287 262940 +154287 2971546 +154287 359067 +154287 359068 +154287 532434 +154287 834577 +154287 842134 +154287 848261 +154287 880236 +1542969 1297580 +1543 191782 +1543 42815 +1543113 2097970 +1543188 90243 +154340 59161 +154340 7731 +1543425 631436 +154348 131472 +154352 516516 +154352 70171 +154352 83715 +154356 178108 +154359 69737 +15438 159998 +15438 354147 +15438 40152 +154381 63302 +154390 357645 +154390 36937 +1543919 95544 +1544 212363 +1544 214669 +1544 40353 +1544 4401 +1544 6272 +1544 8047 +1544 835 +154418 200645 +154418 200646 +154418 200650 +154418 24532 +154418 341534 +154434 114996 +15444 51797 +1544913 1481747 +1544943 1060662 +1545 1857 +1545 230723 +1545293 2918254 +1545410 1089301 +1545410 1272024 +1545410 1307759 +1545410 1416955 +1545410 1511355 +1545410 952583 +1545451 308107 +15455 17139 +15455 17919 +15455 281617 +154550 1145958 +154553 1149412 +154553 1651573 +154553 220054 +154553 365913 +154565 542382 +1545697 1087230 +1545697 79684 +15462 194625 +1546210 3095159 +1546214 1088251 +1546217 1546219 +154622 1075304 +154622 202595 +154622 230058 +154622 300440 +154622 686071 +154622 688281 +15464 16573 +1546597 1029398 +15466 1936041 +1546670 329570 +15467 77950 +15467 93112 +1546718 1751938 +1546718 39713 +1546718 607358 +1546718 715813 +154673 478757 +1546882 1456449 +1546882 703269 +1546934 2855706 +1546934 9504 +154711 1144058 +154711 388432 +1547175 861499 +1547175 933312 +154747 365144 +15475 104896 +15475 2727110 +15475 40953 +15475 43841 +1547839 367947 +1548096 2055201 +154849 1151139 +154849 117419 +154849 546790 +154852 117419 +154852 1243887 +154852 1882717 +154852 453973 +154862 288956 +154862 661 +1548879 304973 +1548879 832962 +1548879 835735 +154919 215559 +15493 209049 +15493 231889 +15493 32888 +154935 58808 +154935 65694 +154935 75321 +1549408 1549407 +1549409 1549407 +1549409 1549408 +1549410 1549407 +1549410 1549408 +1549410 1549409 +154944 404878 +154951 154952 +1549776 1549777 +1549776 1549778 +1549777 1549778 +1549914 1191463 +1550010 1079561 +1550010 303060 +1550010 517158 +1550010 704150 +1550010 833073 +15501 15507 +15501 353179 +15503 15501 +15503 15506 +1550695 801233 +1550794 505 +1550794 7734 +1550840 196527 +15509 135377 +15509 22185 +15509 325484 +15509 876699 +15510 1007097 +1551275 870792 +1551417 1769031 +1551463 2706648 +155154 409950 +1551592 1145501 +1551592 2606049 +1551592 915552 +1551592 92184 +15517 439278 +155184 191995 +1552 15052 +1552 397774 +1552 67226 +1552 693 +155201 272604 +1552022 835518 +1552022 855061 +155209 79813 +15521 15520 +155229 30816 +155230 1361750 +1552307 12551 +1552307 2636184 +1552381 1195410 +1552381 1353787 +1552381 1395383 +1552381 1499372 +1552381 1730063 +15525 20721 +15528 350741 +15528 72765 +1552881 783028 +15530 3041 +15530 606332 +155302 1049907 +155302 135121 +155302 1373215 +155302 2187 +155302 328065 +155302 44018 +155302 640246 +155302 809748 +1553106 1565317 +155327 20952 +155327 97073 +155335 113798 +1553419 1325535 +1553419 1553420 +155342 629020 +155350 503190 +1553884 120236 +1553884 193064 +155390 233796 +155399 186528 +1553991 1553990 +155417 51617 +1554173 1100650 +1554211 1209194 +1554211 1554733 +1554211 1632526 +1554211 1642158 +1554211 578737 +1554211 959411 +155428 1370819 +155428 1370820 +1554376 1015240 +155439 343998 +1554554 1554553 +155494 204334 +1555106 1373551 +1555106 1688177 +1555177 2309316 +155537 117094 +155537 1831755 +155537 829288 +15554 9755 +1555497 57730 +15555 1291 +15556 21802 +15556 233245 +1555632 1923335 +155569 44421 +1555786 2797317 +1555937 2422182 +1556 145895 +1556 536272 +15560 101284 +15560 115018 +15560 15424 +15560 15629 +15560 214350 +15560 499328 +15560 49982 +15560 539 +15560 58247 +15560 91596 +15561 6619 +1556199 2339462 +155623 23285 +155623 276465 +15563 130230 +15563 283311 +155662 114979 +1556801 1556796 +1557003 284321 +155715 1280495 +155742 1212671 +155747 131992 +155747 237133 +155747 280623 +15576 73672 +155773 198960 +155773 332708 +1557916 147756 +155798 146063 +155798 22887 +1558 31615 +1558087 3156935 +1558181 1429365 +1558190 627128 +1558190 833179 +15582 10363 +15582 80356 +1558211 1046945 +1558211 922551 +15583 234130 +15584 104307 +1558482 6681 +15585 258350 +15585 841097 +1558923 1572716 +155906 25532 +15593 144864 +15596 37028 +15596 747088 +1559715 2309083 +155981 204665 +155981 377186 +1559814 212514 +1559814 231953 +1559852 1759727 +155997 1229069 +1560 1413 +1560 21340 +1560086 3226712 +156016 134 +1560179 775292 +1560397 1557298 +156041 108556 +156046 32859 +15606 1645 +156066 591628 +156066 92583 +156086 167557 +156086 2749296 +156086 3040690 +156114 1802 +1561295 1120034 +1561295 1153967 +1561295 1520641 +1561295 1618090 +1561295 7278 +1561296 288549 +156152 156153 +1561605 1159725 +1561956 1905203 +156201 76656 +1562432 891069 +1562443 164263 +156255 493724 +156255 54518 +15626 205270 +15626 334426 +1562792 1099718 +1562792 2078114 +1562792 2153922 +1562822 1843982 +15629 115018 +15629 276792 +1563120 3587540 +1563156 1202348 +156337 31 +1563461 1357037 +1563493 53980 +1563543 80569 +1563568 660187 +156382 486770 +156391 2966413 +1564084 1564083 +1564084 89749 +1564165 1564164 +15643 1222573 +15643 15241 +15643 194625 +15643 6123 +15643 6244 +156435 297965 +1564396 2437593 +156508 4288 +156513 212531 +1565188 653252 +1565211 91296 +1565297 2166221 +156544 124641 +15655 353583 +156554 72358 +156599 218194 +156602 2608368 +156602 671430 +1566245 1613228 +1566299 1583001 +1566299 1829027 +1566372 1014112 +1566373 1628390 +1566373 988605 +15666 11804 +15666 13949 +15666 17428 +15666 196886 +156687 118882 +156689 29887 +156694 48644 +1567071 407260 +156712 329638 +1567149 1542787 +1567149 948344 +156719 237509 +156719 410512 +156719 449634 +1567485 1421948 +1567485 1567502 +1567585 1567584 +1567585 1737402 +1567605 183922 +156788 461772 +1567939 1567929 +1568 13170 +1568321 1401187 +1568347 1076878 +1568347 1886955 +156840 109247 +156840 507353 +1568521 1200275 +156856 212054 +1568631 2075931 +15687 90037 +1568702 1105197 +156883 334088 +156887 100313 +156887 5595 +1568910 1568909 +1568935 1568936 +156903 40360 +1569239 1601116 +15694 1015812 +15694 500206 +1569485 1707468 +1569521 1569520 +156955 555800 +1569594 220342 +1569679 1616764 +1569767 1351876 +1569767 1398530 +1569767 1569768 +1569768 1351876 +1569768 1398530 +1569768 1400270 +1569768 1419981 +156987 156988 +1570 209668 +1570 3365 +1570 396645 +1570 71870 +157017 134073 +157018 257884 +1570360 27657 +157040 83170 +157075 2398935 +1570765 190529 +1570864 2053491 +157143 2625669 +157146 1414168 +1571584 1168801 +1571610 2273267 +1571634 283110 +1571634 973597 +157165 217174 +1571662 1169516 +1571662 1278653 +1571662 1638137 +1571662 2551035 +1571662 2551038 +1571662 2551039 +1571662 2918308 +1571662 3248391 +1571667 1169515 +1571667 1245031 +1571667 1245033 +1571667 1245035 +1571667 1278653 +1571667 1571669 +1571667 2250166 +1571667 2385250 +1571667 3248391 +1571667 3251829 +1571667 3251830 +1571667 3251832 +1571667 3251835 +1571667 3251837 +1571667 3279815 +1571667 837527 +1571669 1169515 +1571669 1245031 +1571669 1245033 +1571669 1245035 +1571669 1278653 +1571669 2250166 +1571669 2385250 +1571669 3248391 +1571669 3251829 +1571669 3251830 +1571669 3251832 +1571669 3251835 +1571669 3251837 +1571669 3279815 +1571669 837527 +1571673 1638152 +1571673 1638154 +1571673 2250166 +1571673 3251830 +1571673 3279815 +157182 3223272 +157196 1250614 +157196 580058 +1571992 1576217 +1572 15791 +1572 360840 +1572 419 +15721 23927 +15721 56755 +157217 1789272 +1572214 1113594 +1572214 2457407 +1572214 628737 +157241 34220 +15725 201123 +15727 567089 +157277 101028 +157277 223473 +15730 1156319 +15730 122653 +15730 1269315 +15730 1312103 +15730 1685 +15730 1895682 +15730 37698 +15730 384983 +15730 756236 +1573836 1916200 +1573836 2206348 +157387 23437 +15739 229910 +157398 157399 +1574189 1125074 +157439 124524 +157450 805034 +1574582 11107 +157480 281526 +157482 928275 +1574841 505487 +157489 49121 +1575081 379809 +15751 444937 +1575285 1476708 +15753 271100 +15753 99472 +1575334 2015411 +157538 20700 +157538 237236 +157538 250971 +157538 3850 +1575413 869040 +157572 87818 +1575936 1575939 +1575938 1575936 +1575938 1575939 +157594 655778 +15760 600 +157603 66851 +1576837 2776957 +1577 151903 +1577 67118 +157707 260744 +157707 283122 +157707 308115 +157707 532086 +157707 604396 +157707 832898 +157707 833070 +157707 833071 +157707 833073 +157707 833075 +157707 833076 +157707 833686 +157707 833687 +157707 834051 +157707 842888 +157707 860731 +157707 903854 +157712 200545 +157712 200665 +157712 247731 +157712 320552 +157712 509129 +157712 515285 +157712 792540 +15778 22278 +15778 325 +1578077 1578078 +15781 3183 +15781 9571 +1578101 129830 +157813 48354 +157813 61920 +1578164 1640327 +1578164 1652196 +1578164 2068048 +1578164 2645574 +1578164 397620 +1578164 833826 +1578164 838930 +1578164 986112 +157823 181115 +1578270 1578269 +157843 26918 +157855 202812 +157855 3499 +15787 1070194 +15787 1124596 +15787 1124597 +15787 1124598 +15787 279684 +15787 320925 +15789 1525196 +15789 218857 +1579 16155 +15791 360840 +157921 29207 +157927 1156 +1579522 3033199 +158 70002 +15803 196380 +15803 228551 +15803 228552 +15803 93448 +158059 158060 +1580619 926717 +1580629 1617837 +1580767 2408530 +1580768 135053 +15810 1102 +15818 35647 +1581803 410748 +1581803 491088 +15822 112104 +15822 1659665 +15822 306706 +15822 392439 +1582252 1080851 +15823 302655 +158232 265718 +15824 233366 +158245 49633 +158247 95623 +1582740 36711 +1582888 1582889 +158290 910335 +1582977 839082 +1583171 2550018 +1583478 1823637 +1583478 1855232 +158352 41237 +158353 130185 +158373 50578 +158374 26385 +1583760 444609 +158386 158387 +1583984 665298 +1583984 842826 +1583991 30773 +158412 934165 +15843 15540 +1584466 260744 +1584466 283122 +1584642 456764 +1584747 1680612 +1584747 252998 +1584747 354659 +1584954 981429 +1585037 1132656 +1585037 407948 +158536 37780 +158556 35671 +1585956 1585957 +158604 57886 +158604 807270 +15861 4385 +1586227 1445931 +1586536 1639594 +1586536 1639604 +1586536 1670502 +1586536 448008 +1586536 696260 +1586536 754974 +1586536 833163 +1586536 855072 +1586536 861476 +1586536 861487 +1586536 970420 +158663 26712 +1586636 66089 +158676 277394 +1586786 1022025 +1586786 842238 +1586787 1022025 +1586787 1586786 +1586787 3650853 +1586787 696188 +1586787 842238 +1586787 855072 +158683 208654 +158683 258980 +158683 325214 +1586859 1262914 +158714 144946 +158714 1945073 +158714 452523 +15872 2171 +1587380 170759 +1587380 2129819 +1587380 833826 +1587380 837674 +1587380 855065 +1587549 538156 +1587555 1587559 +158775 1967268 +158787 146059 +158787 385627 +158787 42124 +158829 222155 +15885 169154 +15885 18984 +15885 229665 +15885 264475 +15885 35646 +15885 4033 +15885 41157 +15885 4507 +158856 158858 +158871 120227 +158887 1932055 +158887 285885 +15889 45607 +1589023 1378029 +1589023 1689103 +1589023 2297447 +158956 158957 +1589566 844250 +158971 158972 +158974 95762 +1589970 834088 +159 548 +1590 1237510 +15900 125379 +15900 130243 +15900 151555 +15900 268951 +15900 294760 +15900 303897 +15900 468376 +159078 176598 +1590959 1026834 +1591238 1420649 +1591238 754894 +1591238 842238 +1591313 1798643 +1591739 1424489 +159183 2659845 +1592462 3163173 +1592580 1534857 +1592580 99233 +1593110 2246229 +159350 194 +159352 38973 +1594117 1182581 +1594117 1716872 +1594117 288457 +1594117 3430871 +1594117 35400 +159422 10780 +1594223 1586536 +1594223 1670502 +1594223 448008 +1594223 861476 +1594223 970420 +159425 16711 +159425 1905735 +159425 945130 +15943 3399 +1594506 991660 +1594508 1517856 +1595027 1448227 +1595156 304973 +159526 1528758 +159531 1252729 +1595403 3221401 +159556 378181 +159556 378186 +15959 11887 +1595970 63059 +1596 670 +1596141 141326 +1596141 198935 +1596232 1089583 +1596232 1336426 +1596232 1692113 +1596232 833599 +1596232 845748 +1596232 847372 +1596232 861506 +1596232 935812 +1596232 983602 +159644 380303 +159656 228808 +159657 221179 +159662 159663 +159698 560055 +1597429 1303882 +159759 157659 +15977 43210 +1598 11066 +159815 380839 +159815 69237 +1598163 1634343 +1598163 318371 +1598163 390115 +1598163 683292 +159887 159888 +1599 4018 +1599345 1488496 +159950 243824 +15999 20195 +159996 329369 +159997 170188 +1599989 542891 +16 1391657 +16 3362 +16 3772 +16 44903 +16 56 +16 5917 +1600 14068 +1600 14950 +1600 303897 +1600010 14086 +1600030 1800264 +1600030 1976017 +1600083 2187 +1600083 33567 +1600231 380875 +160033 94739 +1600473 2292888 +1600473 531857 +1600543 2587438 +1600739 170461 +1600739 299624 +1600739 578631 +160089 80263 +1600957 2364727 +1601076 1617473 +160110 27 +1601163 1357542 +160130 255364 +160145 485526 +160178 142933 +160203 26022 +1602037 1994652 +16022 2049 +16022 315747 +16022 408185 +16022 454164 +160240 517080 +1602461 1602460 +160259 106412 +160265 259713 +160265 287495 +1602787 2037284 +1602787 36100 +1602787 97139 +1602875 1892678 +1602875 1892679 +16030 421929 +1603017 3950981 +1603031 1865441 +1603031 280662 +1603031 3115646 +1603031 331100 +1603031 480922 +1603137 168867 +1603137 272699 +1603137 393461 +1603137 95147 +1603298 3154478 +1603386 1412147 +160340 346576 +160352 653252 +160357 400187 +16036 16037 +1603697 1604550 +160382 877605 +1603822 2343856 +1604016 1824104 +1604086 1030737 +1604324 1858490 +1604324 2330060 +1604324 424983 +1604618 550827 +1604929 1102057 +1604940 1012509 +1605 12865 +1605 13070 +1605 212070 +1605 30476 +1605 318120 +1605 3947 +1605 456556 +1605 904910 +16050 227939 +1605207 583090 +1605268 2597815 +160565 24884 +1605850 2177063 +1605850 219 +1605850 3123417 +1606402 1289937 +1606455 1606456 +1606455 1606457 +1606456 1606457 +160661 101637 +1606986 1652674 +1607 15021 +1607 168597 +1607047 32791 +1607137 239008 +1607137 564471 +1607227 858210 +1607851 1607860 +16079 2632 +160828 59027 +160829 1653447 +160856 50433 +160856 74710 +1608599 1191463 +160872 105113 +160872 323154 +1608827 1608826 +1609 1570 +1609 86830 +1609253 2719263 +160941 55076 +16095 10937 +16095 137940 +16095 16095 +16095 247347 +16095 45392 +16095 505029 +16095 949482 +16095 96593 +16096 52052 +1609837 1151034 +161 11652 +161 12344 +161 65273 +1610230 1169203 +1610244 949773 +161032 4725 +161035 289522 +161035 975597 +161063 1128804 +161063 112889 +161063 146060 +161063 49803 +1610796 1521611 +1610796 1562792 +1610796 2153922 +1610796 2721494 +1610826 1610825 +1610827 1610825 +1610827 1610826 +1611 102160 +1611 2742 +1611446 3166657 +1611446 3700792 +1611690 1021942 +1611690 1360089 +1611690 1787676 +1611690 2186352 +1611690 835088 +1611716 1806542 +1611748 1715914 +1611748 183989 +1611895 25775 +16119 54721 +161194 161193 +1611970 370805 +1611970 44117 +1611970 870178 +1612 960 +1612002 50997 +161228 208267 +161228 541238 +161230 228431 +161235 385245 +161235 44530 +161235 5876 +16125 1576 +161254 104665 +161256 814136 +161258 161262 +1612638 1272939 +1612638 1458934 +1612698 3329340 +16127 109352 +16127 161487 +16127 187011 +16127 224 +16127 2264 +16127 26311 +16127 2801648 +16127 34955 +16127 843754 +16127 866641 +1612742 269254 +1612742 833120 +1612746 1737489 +1612746 2492979 +1612854 27012 +1612940 190141 +161313 1594656 +161313 1701329 +161313 17660 +161332 1063894 +1613324 1449807 +1613324 1525196 +1613324 222523 +161347 30975 +16135 4872 +1613795 1137834 +1614 1873736 +1614 47343 +1614 489743 +1614 5593 +1614 689918 +1614 73838 +1614149 1254764 +1614149 2621858 +161422 395791 +161422 4628 +161422 66186 +161422 782322 +161422 995463 +16143 76395 +161433 31885 +1614628 1427917 +1614853 1409505 +161487 13 +161487 13195 +161487 146216 +161487 157813 +161487 17597 +161487 212363 +161487 21581 +161487 227158 +161487 238835 +161487 265205 +161487 356288 +161487 3820 +161487 90564 +161498 1770232 +161498 2199242 +1615 27 +1615 89333 +161511 40772 +1615220 1084956 +1615220 1615221 +1615220 283122 +1615220 833167 +1615220 996444 +1615221 283122 +1615221 996444 +161526 318723 +1615413 1410873 +161552 161553 +16156 194243 +161576 116063 +161576 219974 +1615876 1390360 +1615876 2129819 +1615876 696257 +1615876 837674 +161593 161594 +1615988 141549 +1615988 2090482 +1615988 35646 +1616 12751 +1616 2156 +1616 436812 +161608 2535744 +161608 922079 +1616203 2395032 +1616319 2264013 +1616620 489950 +1616935 2349130 +1617 21679 +1617 2994 +1617 9427 +161709 280223 +1617138 1617150 +1617254 1015876 +1617254 1828463 +1617388 2586807 +161770 154246 +161808 791 +1618084 198067 +1618090 1520641 +16184 1493 +16184 363528 +1618429 1618428 +1618539 1823267 +1618539 222253 +1618720 1513536 +161889 317665 +1619150 1653467 +1619161 2334338 +1619482 833722 +1619482 833879 +1619482 835057 +1619482 836151 +1619482 836155 +1619482 836156 +1619482 861648 +1619482 926717 +1619683 260744 +1619683 283122 +1619683 517153 +1619683 573239 +1619683 696225 +1619683 833687 +1619683 861489 +1619683 882032 +1619683 883315 +1619683 901880 +1619683 95544 +16197 959 +1619779 3439800 +1619779 758462 +1619933 32151 +162 309638 +162 55126 +162 61351 +162 6365 +162 74 +162 76 +1620228 1158120 +1620228 373377 +1620228 455099 +1620228 547276 +1620228 721331 +16204 101940 +16204 1087387 +16204 1153377 +16204 374980 +16206 800775 +1620647 2373209 +1620943 1748212 +1620943 1798206 +1620943 2093055 +1620943 2093056 +1620943 2372096 +1620945 1016194 +162097 219319 +1620988 1032419 +1621230 1882719 +1621230 3377500 +162133 157300 +16214 4076 +162142 65233 +162150 238290 +1621560 2074282 +1621608 1621609 +16217 11819 +1622164 769562 +162230 208121 +162230 29895 +162230 82211 +16225 28994 +1622669 1809474 +162295 2070196 +162295 228551 +162295 35992 +162303 35077 +1623146 892616 +1623225 43212 +1623587 1441341 +1623587 2758801 +162359 760356 +1623653 853282 +16239 94610 +16246 3550549 +1624674 931502 +1624766 255947 +16248 808748 +1624987 231053 +162512 489994 +162512 920619 +1625188 1470098 +1625188 2444440 +1625234 21742 +16253 32059 +16253 57269 +162553 162553 +162553 166284 +162553 367104 +162564 1930140 +162586 75876 +162613 276427 +162616 288875 +162653 153086 +162667 98444 +162670 195173 +1626840 1625938 +1626911 3471380 +1626911 3490638 +1626911 446914 +16271 2561715 +162712 28377 +1627168 1627169 +16272 369619 +1627281 1111660 +162762 2187 +1627679 1616945 +162774 305194 +1628 24275 +162809 206254 +1628108 1009232 +1628108 898403 +1628349 1318493 +1628390 988605 +1628392 1628393 +1628423 210016 +162849 279940 +162853 8828 +16286 2967 +162862 101469 +162862 1377712 +1628647 1961861 +16287 64259 +1628759 1307759 +1628759 1416955 +1628759 1511355 +1628759 1545410 +1628927 1245575 +1628927 1404047 +1628927 1421398 +1628927 731416 +1628927 834330 +1628927 909193 +1628927 909198 +1628927 909961 +162896 223323 +1628991 1280720 +1629091 492930 +1629497 452030 +1629562 1021942 +1629562 1360089 +1629562 1611690 +1629562 1787676 +1629562 2186352 +1629562 835088 +1629851 1233843 +162989 107730 +162989 293772 +163039 241566 +1630619 95539 +1630633 1132557 +1630876 2008667 +16312 290868 +16312 52675 +16312 560325 +163158 156628 +16316 209666 +16317 1240 +16317 76923 +1631706 1548096 +1631706 2132583 +1631706 2284946 +16318 187440 +1631888 1026736 +1631888 845763 +1631888 870792 +1631943 2363382 +163195 163196 +163218 104943 +16322 1612 +1632255 511810 +1632484 2093703 +163253 167723 +163253 216987 +163253 218587 +16327 23086 +1632706 1632707 +1632801 1659360 +1632801 262940 +1632801 779502 +1632801 848261 +163281 378086 +163281 871401 +1632853 262940 +1632853 3248391 +1633 1184 +1633 2018 +1633 588271 +16331 101090 +16331 1220556 +16331 217887 +163345 56575 +1633885 1633885 +1634 656042 +1634019 2324426 +1634040 1221008 +1634040 1566166 +1634149 331753 +1634149 653448 +1634343 318371 +1634343 683292 +1634392 13914 +163447 164806 +1634551 560182 +163457 149732 +163457 217869 +163457 2989297 +163457 2991091 +163457 435111 +163457 807541 +163457 923267 +163490 102293 +163490 48245 +1634974 14137 +16350 4984 +163505 287990 +163505 4213 +163538 250632 +163546 163547 +163549 95295 +163553 111387 +163553 163554 +163553 163555 +163554 163555 +1635871 339843 +1636167 2425510 +16362 10994 +16362 215114 +16362 284788 +16362 307882 +1636229 539271 +1636229 539272 +1636229 704150 +1636229 832915 +1636229 835739 +1636229 849795 +1636229 973153 +1636323 1544912 +1636323 1551409 +1636340 1032278 +1636340 415720 +1636340 526591 +1636340 736606 +1636340 837657 +1636340 837660 +1636340 838984 +1636340 841593 +1636340 855057 +1636340 861690 +1636340 900979 +16364 154525 +163654 59770 +1636678 23616 +1636932 1858130 +1637106 1759362 +1637106 1979478 +163712 988239 +163736 2843570 +163737 134250 +163737 1457460 +163737 163737 +163737 2323 +163737 243126 +163737 2439559 +163737 296 +163737 345869 +163737 3533880 +16375 281992 +16375 454293 +1637596 1637597 +1637596 1799023 +163781 419097 +1638137 1169516 +1638137 1278653 +1638137 2551035 +1638137 2551038 +1638137 2551039 +1638137 2918308 +1638137 3248391 +1638142 1169513 +1638142 1245031 +1638142 1245033 +1638142 1278653 +1638142 1638153 +1638142 2551032 +1638142 2551035 +1638142 2551039 +1638142 3248391 +1638142 3370810 +1638152 1167467 +1638152 1169515 +1638152 1245031 +1638152 1245032 +1638152 1245033 +1638152 1278653 +1638152 1638154 +1638152 2134823 +1638152 2250166 +1638152 2316576 +1638152 2918310 +1638152 3248391 +1638152 3251830 +1638152 3279815 +1638152 837527 +1638152 838932 +1638153 1169513 +1638153 1245031 +1638153 1245033 +1638153 1278653 +1638153 2551032 +1638153 2551035 +1638153 2551039 +1638153 3248391 +1638153 3370810 +1638154 1167467 +1638154 1169515 +1638154 1245031 +1638154 1245032 +1638154 1245033 +1638154 1278653 +1638154 2134823 +1638154 2250166 +1638154 2316576 +1638154 2918310 +1638154 3248391 +1638154 3251830 +1638154 3279815 +1638154 837527 +1638154 838932 +1638200 16508 +163839 64194 +163850 144288 +163850 659715 +163874 62083 +1638817 153954 +16390 3773 +1639283 34955 +1639402 833722 +1639465 16795 +1639594 1639604 +1639594 696260 +1639594 754974 +1639594 833163 +1639594 855072 +1639594 861487 +1639604 696260 +1639604 754974 +1639604 833163 +1639604 855072 +1639604 861487 +1639803 1689716 +163993 2003439 +163993 2003440 +163993 805900 +163993 919326 +163993 978076 +1640293 1341603 +1640293 526591 +1640293 696193 +1640301 1720758 +1640301 1739627 +1640301 1739630 +1640301 1739632 +1640301 2129819 +1640301 2130303 +1640301 837674 +1640301 852711 +1640305 1770381 +1640305 1864552 +1640305 1864553 +1640305 1864554 +1640305 1864555 +1640305 830144 +1640312 3292283 +1640312 3292284 +1640320 1415867 +1640320 841593 +1640320 859046 +1640320 900979 +1640328 1208452 +1640328 2129819 +1640328 837674 +1640328 889836 +1640328 922015 +1640338 262940 +1640338 368137 +1640338 833824 +1640521 1608033 +164055 38141 +164062 126228 +164067 149623 +16408 140556 +16409 31752 +164098 266192 +164098 567073 +164111 103307 +164150 202709 +164179 164178 +164179 238507 +164195 12869 +164195 1960944 +164195 403102 +164195 404987 +164195 449609 +164195 468710 +164195 475551 +164195 73892 +164195 79222 +1642 2320 +1642129 2101429 +1642158 1554733 +1642247 1973659 +164225 315225 +1642459 3871051 +1642459 3871052 +1642459 3871053 +164263 299190 +164263 299191 +164263 299192 +164263 300290 +164263 516388 +164264 3734190 +164269 18983 +164269 234332 +164275 602085 +164279 153980 +164279 216140 +164279 23460 +164279 282137 +164279 341299 +164279 361807 +164279 36868 +164279 431229 +164279 497542 +164279 627128 +164279 95539 +164279 96123 +164282 254301 +1642826 1642821 +164298 178515 +164298 556113 +16431 104747 +1643183 1643184 +1643262 15467 +164328 488625 +164349 2588891 +164349 2588892 +164363 111502 +164363 59769 +164363 61920 +164376 164377 +16438 670 +1643918 275697 +1643923 1448227 +1643923 1595027 +1643923 86294 +1643923 885972 +1644 162862 +1644 37001 +164421 108896 +164423 164534 +164423 194 +164423 916574 +16443 61752 +1644381 957785 +164477 1672701 +164477 1672702 +164477 3525080 +164480 149952 +1644988 1372418 +1645 126803 +164534 506088 +16454 23807 +1645457 395188 +164548 221427 +164570 538172 +164571 1057848 +164571 145288 +164571 1503116 +164571 152707 +164571 1942373 +164571 195660 +164571 235447 +164571 289568 +164571 299951 +164571 30552 +164571 307217 +164571 307409 +164571 370725 +164571 374973 +164571 409275 +164571 439536 +164571 446637 +164571 52833 +164571 79742 +164571 869115 +164571 984442 +164571 984446 +164571 984464 +164572 1115343 +164572 145262 +164575 323767 +164575 342945 +164587 255160 +164587 322315 +1645948 1409599 +1646037 1912383 +164608 10775 +164608 70607 +164608 79935 +1646579 32301 +1646713 1388010 +1646876 505481 +1646876 538924 +16469 69837 +1647 1236 +1647 16 +1647 62119 +1647 81524 +1647608 3229639 +16479 4710 +1647952 1647950 +16480 1940135 +164808 1244753 +164808 1801211 +164808 283280 +164808 3027200 +164808 350481 +164808 595051 +164808 766937 +164808 790550 +164808 806899 +164808 865058 +164808 912385 +164808 914956 +164808 945819 +164808 947753 +164808 990604 +164808 990605 +1648094 708608 +1648143 457577 +16483 1044695 +16483 2046 +16483 229829 +16483 862287 +164853 78619 +16489 25035 +1649 1546881 +1649 1647 +1649 242492 +1649 35174 +1649 41863 +1649 62077 +1649 8028 +1649 81524 +164904 177093 +164938 430816 +1649413 441528 +164971 13961 +164971 215511 +164971 95878 +164977 158363 +164987 169381 +164994 173125 +1650216 1610836 +165028 177238 +165028 177239 +165034 270981 +1650476 1057317 +16505 14606 +16505 21032 +16505 25191 +165079 170570 +165079 186755 +16508 150554 +16508 359679 +16509 464304 +165093 142646 +165093 1791730 +165093 68704 +165098 990812 +165106 157401 +1651128 2757394 +1651128 283122 +165135 2665807 +165135 62148 +16515 6347 +165180 243475 +165180 392408 +165180 61779 +1651922 1651923 +1652 2981236 +16520 1277716 +1652194 1300808 +1652194 1728371 +1652194 526591 +1652194 855072 +16524 15868 +1652759 388920 +1652944 1652945 +1652975 48691 +1652997 1223162 +165313 36167 +16533 118835 +16533 16534 +16533 206254 +16533 2109856 +16533 227469 +16533 596524 +16534 17640 +1653520 833788 +1653593 774584 +165375 232956 +1653767 1798900 +1653767 455945 +1653770 1653767 +1653770 1798900 +1653770 455945 +165387 1600955 +16539 1795 +16539 349744 +16539 388107 +1653945 1077888 +1653945 1437686 +1654 770381 +1654058 344024 +1654058 40585 +165417 488185 +165419 48865 +165447 11197 +1654505 1659317 +1654505 538924 +1654661 2528724 +16548 43099 +1654919 957426 +1655046 1217704 +1655107 916922 +1655107 918339 +1655489 1655488 +16557 1652258 +16557 41237 +16557 8099 +1656 79265 +1656398 1405041 +1656542 304975 +1656542 578727 +165657 297696 +165668 507708 +1656817 95546 +1656903 383180 +16574 3492 +16575 11910 +165751 50168 +165786 165791 +1658206 356276 +1658206 74772 +1658423 3488202 +165846 531456 +165855 322879 +1658777 15803 +165911 173371 +165911 193235 +165911 197311 +165920 274705 +1659360 848261 +1659594 1542356 +1659594 281956 +166 3592 +166 44494 +166 5635 +166 670 +16604 167939 +16604 229784 +16604 372721 +16604 86645 +166065 184178 +166065 316432 +1660701 958583 +166072 1884193 +166072 1884194 +166072 415027 +166078 12279 +166078 381431 +166078 385229 +1660852 1890455 +166092 235547 +166095 2476931 +16615 886961 +1661783 2230108 +16619 100313 +16619 1215260 +16619 15169 +16619 16619 +16619 238962 +16619 36527 +16619 45467 +16622 121721 +16622 2417626 +16622 57393 +16622 67592 +16622 68464 +1662463 2062861 +16625 8485 +1662610 3151449 +166272 390467 +1662767 1952952 +1662767 912553 +166283 1051454 +166283 113430 +166283 117415 +166283 2635529 +166283 317009 +166283 411692 +166283 77090 +166283 828778 +166289 117723 +1663355 269081 +1663355 465608 +1663367 1897064 +1663374 2292327 +1663374 92623 +1663476 717167 +166363 178728 +166363 78788 +166396 195105 +16640 4367 +16643 339337 +16643 56446 +1664367 1664369 +166442 57533 +1664432 1199673 +166473 1264253 +166473 289198 +1664736 491206 +166481 11070 +1665 124610 +1665 1611 +166504 166505 +166504 190960 +166506 1021818 +166506 2009722 +166506 26669 +166506 618668 +166506 66261 +16651 220673 +1665116 253266 +16652 1770724 +166531 66494 +16655 41279 +16655 548189 +16658 16462 +16660 31777 +16660 72427 +1666185 1558208 +1666389 1229978 +1666389 1478675 +166685 1503519 +166685 864674 +166685 867849 +166706 1415851 +16671 80145 +166730 187360 +16675 42015 +166751 119743 +16676 128056 +16676 16676 +16676 188986 +16676 859536 +16677 13031 +16677 1405718 +16677 16677 +16677 215179 +16677 227883 +16677 23973 +16677 478443 +16677 67656 +16677 681409 +16677 821959 +16677 88314 +166774 132546 +16678 35347 +1667863 2370188 +16680 19662 +16680 43993 +1668110 335760 +1668110 375279 +1668110 95537 +1668356 1572214 +1668356 1958244 +1668356 2122600 +1668356 2452765 +1668356 2457407 +1668356 308384 +1668356 628737 +1668356 987368 +166838 113284 +166838 180195 +166847 1299349 +166857 2974635 +16687 71656 +1668782 2130201 +166885 638302 +1669 17532 +1669 9733 +1669475 1729477 +166952 107417 +1669673 1379679 +1670013 363532 +167040 5938 +167040 97521 +1670502 448008 +167055 179055 +167080 2951 +167084 363492 +1670884 1713706 +16709 16057 +16709 208296 +16709 21032 +16709 33332 +16709 407517 +16709 45206 +16709 66552 +16709 7698 +167097 5849 +1671 15169 +167108 88185 +16711 11546 +16711 16536 +1671768 1300812 +1671768 1374321 +1671768 2545309 +1671768 2545310 +1671768 269254 +1671768 832917 +1671768 838409 +1671768 841441 +1671768 933757 +1671772 703271 +1671772 858474 +1671853 564919 +167209 179335 +167209 302446 +167209 394016 +167247 167247 +167247 213991 +167247 433615 +167247 45866 +167247 474643 +167247 584423 +167260 5838 +167260 8152 +167260 8982 +1672689 1163679 +1672702 1672701 +16728 271428 +16729 16730 +167295 409884 +167295 780336 +167317 397601 +167339 437054 +167365 272920 +167366 194 +1673800 1673801 +16741 2545 +1674253 307864 +1674253 309980 +167462 1166828 +167462 1450655 +167462 193934 +167462 212264 +167462 212266 +167462 212299 +167462 212301 +167462 744724 +167462 869054 +167462 870670 +167462 92243 +16747 1098776 +16747 30614 +1674704 1176238 +1674704 1674712 +1674704 934274 +1674706 1176238 +1674706 1674704 +1674706 1674712 +1674706 934274 +167471 357563 +1674712 1176238 +167475 167476 +167476 274017 +16748 432780 +1674823 3424898 +167519 2667408 +1675223 93921 +1675283 1196411 +167543 868504 +167555 156719 +167555 157220 +167555 175704 +167555 64739 +167557 105862 +167557 1250342 +167557 1753972 +167557 2287350 +167557 287575 +167557 3039684 +167557 370771 +167557 402224 +167557 500544 +167557 500550 +167557 608005 +167557 726444 +16756 218316 +1675608 275744 +167573 816964 +1676 17399 +1676257 3603075 +167629 350072 +167629 79752 +167644 175575 +167644 180140 +167644 341733 +167646 113583 +167646 220759 +167646 79578 +1676573 2757853 +1676573 759599 +167665 66099 +1676655 1676653 +16768 144864 +16768 1520641 +167720 207479 +1677459 856847 +167748 1464371 +167748 386588 +167748 45008 +167748 514936 +16776 26634 +1677649 38661 +1677660 1727372 +1677660 38661 +1677660 57103 +167794 67539 +167823 935270 +1678548 192325 +16786 6432 +1678720 77165 +1678720 838997 +1678799 623293 +1678799 696134 +1678799 696188 +1678799 834101 +167887 9081 +167939 2366353 +16794 920358 +167946 209044 +167946 529845 +167946 57880 +1679489 696225 +16795 102318 +1679540 1679539 +16797 10463 +16798 338839 +167981 348846 +1680232 252611 +168029 121607 +168029 3476 +168029 916708 +168049 19619 +168053 552825 +1680612 252998 +1680612 354659 +1681 111 +1681 14481 +1681 35077 +1681 43105 +1681 59760 +1681068 241983 +168124 166114 +168124 182615 +168146 168146 +168146 18088 +1681744 11140 +1681744 3111 +16820 3078 +168250 168251 +1682545 3213162 +168273 2256163 +1682788 1341171 +1683090 449907 +168344 329265 +168352 89597 +1683523 2793555 +1683556 1102057 +168367 3324762 +1683687 1169887 +1683884 889139 +168391 620716 +1683935 1683934 +1683971 1722942 +168403 12551 +168404 485781 +16843 18456 +168442 26101 +1684629 27637 +1684645 271461 +1685 1156319 +1685 735582 +1685019 1251923 +1685019 2446086 +1685019 2446087 +1685019 333892 +1685019 526576 +1685019 628237 +1685019 718775 +1685105 1783849 +168523 219674 +168523 28568 +168523 317 +168523 661 +1685311 1500084 +168579 168579 +168579 218 +168579 221458 +168579 240796 +168579 69562 +168597 1599536 +168597 196815 +168597 726057 +168597 809790 +168599 1071526 +168599 1071528 +1686100 1728515 +168627 28968 +168636 183193 +168680 17583 +168684 1068751 +168684 813969 +168693 35746 +168745 1026290 +168755 224600 +1687808 1304405 +16879 29358 +1687982 1356610 +1687982 2736228 +1687982 998654 +1688 1055678 +1688 1090169 +1688 12524 +1688 12990 +1688 180226 +1688 209053 +1688 24455 +1688 39115 +1688 4335 +1688 7195 +1688 937015 +16880 21457 +16880 29356 +16880 35641 +16880 357899 +16881 33995 +16881 3507 +1688343 36738 +168853 265211 +168867 95147 +168907 589838 +1689102 1471802 +168914 120828 +168925 3348595 +168925 364257 +168925 3737202 +168925 660572 +168930 50022 +1689419 490281 +1689419 526595 +1689419 526596 +1689419 835964 +1689444 2235302 +1689826 262940 +1689826 793004 +1690 2867 +1690 54650 +1690 93375 +169016 216448 +169037 66196 +1690504 6465 +169065 179317 +169065 205276 +1690697 1623483 +16909 170393 +1690934 1187662 +1691 148243 +1691 2319 +1691 437 +1691140 1691141 +169128 1065742 +169128 12551 +169128 1622952 +1691851 66152 +169198 102638 +169198 202729 +169198 46333 +169198 681215 +1692113 1053915 +1692113 1053916 +1692113 1197745 +1692113 833599 +1692113 849153 +169235 66620 +16926 167665 +1692677 1233084 +1692677 547620 +1692762 3102280 +1692953 1725562 +16930 11438 +1693018 1693017 +169336 12803 +169336 149255 +169336 280033 +169336 305579 +169336 330884 +169336 447673 +169336 494407 +1693517 2975478 +1694 3188142 +1694049 1360068 +169412 179076 +169481 1949 +169481 272726 +169481 32695 +169481 3923626 +169481 525266 +169481 654406 +169481 701516 +169486 169488 +169495 142047 +169495 254012 +169495 267024 +169495 281213 +169495 292493 +169495 321961 +169495 325649 +1695325 3763164 +169552 644162 +169574 29810 +1695773 1820825 +1695773 2040218 +16958 268923 +1695961 173615 +1695961 199202 +1695961 340650 +1695961 466362 +1695961 724445 +1696350 1667448 +169649 122694 +169686 801 +1696955 707691 +169706 344415 +169706 78110 +1697098 1046945 +1697098 832898 +1697098 978175 +1697106 135871 +1697106 285231 +1697106 297693 +1697250 1042862 +1697250 1697254 +1697254 1042862 +1697364 899055 +1697601 1059067 +169782 386863 +169783 105862 +169783 1220498 +169783 146066 +169783 2607246 +169783 2750019 +169783 386863 +169783 734795 +169783 77076 +169787 1250480 +169787 1292550 +169787 259465 +169787 442544 +169830 103526 +169830 1043041 +169830 17271 +169830 183741 +169830 193366 +169830 228271 +169830 243564 +169830 248607 +169830 3083 +169830 372109 +169830 417839 +169830 44421 +169830 45392 +169830 462750 +1698349 1569293 +169895 103348 +169898 229094 +16990 13888 +16990 16990 +169908 3757531 +1699329 1103850 +1699329 205467 +1699366 3121327 +1699542 1699544 +17 25975 +17 505062 +17 560199 +17 675 +170 24699 +170 2503 +170 2514722 +170 2525091 +170 259804 +170 29121 +170 3352 +170 415964 +170 4182 +170 53394 +170 60797 +170010 258942 +170015 1635724 +170015 713240 +1700176 1193758 +1700208 1276950 +1700208 1311190 +1700208 2607057 +170037 99731 +17006 1354832 +1700650 1226027 +1700650 1700650 +1700650 1970694 +170134 28599 +17015 17960 +17015 51979 +1701984 2183493 +1701984 2183494 +1701984 2183495 +1702 1770707 +1702 7576 +170239 116237 +17024 2161 +1702487 1050296 +1702487 1188234 +1702487 1477103 +1702487 1627381 +1702487 1960154 +1702487 2236264 +1702487 2265605 +1702487 227843 +1702487 2300680 +1702487 364838 +1702487 837543 +1702487 842518 +1702487 862520 +1702487 873811 +1702487 938087 +1702914 1154177 +170320 628973 +170329 257025 +170329 488821 +17033 6702 +17035 18982 +17035 504402 +170355 960875 +170356 82605 +170357 271516 +170357 27892 +170365 4033 +170393 128124 +170413 15091 +170414 103734 +170417 368383 +1704424 1704423 +170461 299624 +170461 58654 +17047 194787 +1704827 1527938 +1704898 96930 +1705 2585 +1705 577470 +17050 222422 +17050 24699 +17050 426668 +17050 70426 +1705729 683750 +170575 273238 +170575 514498 +17060 17061 +170635 17332 +170635 18473 +170635 23102 +1706444 3023938 +1707126 1707129 +17074 155201 +170754 145262 +170754 27515 +170754 565234 +170755 146284 +170755 323990 +170755 595806 +1707584 1091307 +170759 1009447 +170759 1147100 +170759 1208455 +170759 1412851 +170759 2129819 +170759 2645574 +170759 526591 +170759 833317 +170759 833628 +170759 837550 +170759 837674 +170759 844418 +170759 855065 +170759 905491 +170759 986112 +170760 1080248 +170760 1208452 +170760 1220779 +170760 1239660 +170760 1341604 +170760 1385928 +170760 1390360 +170760 1481537 +170760 1481547 +170760 1615876 +170760 170759 +170760 1971571 +170760 2129819 +170760 3228250 +170760 543206 +170760 696257 +170760 837674 +170760 841593 +170760 855073 +170760 859447 +170760 889200 +170760 896995 +170760 900979 +170760 973042 +1707729 1628208 +17078 1146463 +1707838 153980 +1707838 224329 +1708 35650 +1708 51219 +170825 1076301 +170825 506682 +170827 5981 +170846 213976 +170846 631872 +170871 133752 +170882 179005 +170890 15022 +170890 15023 +1708935 2058688 +1708948 898398 +17091 17170 +17092 14954 +17092 312229 +1709638 262940 +1709639 779502 +1709658 647607 +17099 923612 +171 37998 +171 44018 +171 45946 +171 475681 +1710599 1032226 +1710599 1032277 +1710599 1032278 +1710599 833560 +17108 303653 +1711 219 +1711 321834 +1711 3947 +1711 54144 +1711 710109 +1711 823 +17112 3714 +171128 217272 +1711297 1052424 +1711297 1150819 +1711297 898855 +17113 154392 +17113 247042 +171146 35746 +17115 37013 +17115 52529 +1711660 1770485 +171187 152743 +171187 51350 +171187 52724 +1712 111118 +171241 46665 +1712511 1712510 +1712598 2004882 +171276 207289 +171276 3147575 +171280 20403 +171280 219671 +171280 245327 +171280 4066 +171292 116709 +171292 547764 +171292 58870 +1713 1215 +1713 52744 +171324 316387 +171326 116111 +17135 246041 +17135 280146 +17135 416309 +17135 43670 +17135 702792 +1713720 2140267 +1713729 145539 +1713729 1849338 +1713729 1977477 +1713729 2262477 +1713729 249584 +1713729 2585397 +1713729 2882883 +1713729 3039466 +1713729 3067086 +1713729 3219528 +17140 17531 +17140 493608 +17142 224609 +17142 60776 +17142 88701 +171423 205073 +1714457 861282 +171459 801284 +17146 2187 +171513 785683 +171521 2332 +1715244 395846 +1715288 3081338 +1715643 2855689 +1715693 1715694 +1715832 1703354 +171593 469986 +1716 108945 +1716 119663 +1716 120430 +1716 1321117 +1716 1398 +1716 143968 +1716 14784 +1716 191993 +1716 193692 +1716 204510 +1716 206444 +1716 214851 +1716 239619 +1716 26942 +1716 29903 +1716 3172 +1716 4124 +1716 421773 +1716 557815 +1716 565221 +1716 8090 +1716 817046 +1716 822274 +1716 85528 +171606 171607 +1716081 2208730 +17161 190221 +171610 171611 +1716510 3662973 +171671 190988 +1716925 2409461 +1716925 2409463 +1716925 610799 +1716925 855890 +1716925 882724 +1716925 996441 +171713 1194554 +171713 255187 +171713 67435 +171723 1949081 +171748 406862 +171748 587087 +171748 70908 +171779 171780 +1717995 1043208 +1718 1718 +1718 1760435 +1718 2332 +1718 338 +1718 38034 +1718 505061 +1718 907144 +171806 85500 +171835 13561 +171835 29777 +1718409 833553 +1718587 978174 +171861 37308 +171861 39713 +171866 315987 +171870 171871 +1718801 1729114 +1718801 1742603 +171884 110426 +171893 1039572 +171893 900988 +171893 900992 +1719 2546 +1719037 1928391 +1719085 756447 +1719160 1438525 +17199 10290 +17199 11073 +17199 125246 +17199 170357 +17199 194 +17199 27892 +17199 3550 +17199 65739 +17199 65740 +17199 92571 +172007 328893 +172007 931431 +1720120 3027600 +172014 172015 +1720758 1739627 +1720758 1739630 +1720758 1739632 +1720758 2129819 +1720758 2130303 +1720758 837674 +1720758 852711 +172097 123759 +1721009 1721010 +17212 7552 +1721513 687344 +1721576 109437 +1721576 383390 +172175 249922 +1721826 1174486 +1721826 937815 +1721867 994375 +1722220 75253 +172224 172225 +17223 854081 +172240 30207 +17227 48477 +1722754 1692953 +1722754 1725562 +17228 19332 +17228 393436 +17228 409310 +172281 1240350 +172298 184562 +172310 1296320 +172310 147666 +172310 2080717 +172310 294245 +1723326 342459 +1723390 2350996 +172362 200653 +172363 119743 +1723639 1769399 +1723639 1804375 +1723639 936873 +17240 2555846 +17240 28029 +17240 430166 +1724071 153980 +1724071 267768 +1724071 846301 +1724072 599488 +1724185 839640 +172436 250047 +172436 774584 +172437 1781 +1724370 44364 +1724417 1724418 +17245 141703 +1724761 1652169 +172490 172490 +172490 229537 +172490 323304 +172490 372873 +172490 623870 +17251 167665 +17251 194334 +17251 3876 +1725181 1725180 +1725181 451878 +17254 102781 +17254 16318 +17254 16329 +17254 36424 +17255 197576 +17255 2929 +172555 250152 +1725654 1571395 +1725654 1725654 +1725771 4476 +1726080 283122 +1726080 754974 +1726080 833554 +1726080 838400 +1726080 850897 +1726080 855072 +17261 1586 +17261 4014 +172624 610195 +17266 1396987 +172671 1254418 +172671 380613 +172671 741812 +1726873 772326 +1727 134209 +1727 39457 +17271 196449 +172719 172720 +172724 3492138 +1727369 1266139 +1727369 974520 +1727372 38661 +1727372 57103 +172763 973066 +172782 454715 +1728034 2635889 +17281 133066 +1728124 7308 +1728132 1899083 +1728132 1899084 +1728172 1002331 +172831 17228 +172831 466507 +1728371 1032278 +1728371 1300808 +1728371 1478675 +1728371 1636340 +1728371 526591 +1728371 855072 +1728372 271870 +1728372 2982835 +1728372 397620 +1728372 696193 +1728372 754974 +1728372 838930 +1728372 844418 +1728372 855065 +1728372 978254 +1728893 159889 +1728996 285231 +1728996 727951 +17291 19893 +17291 422902 +17291 8029 +1729114 1751379 +1729114 1751388 +17292 29065 +1729201 1600575 +172940 8746 +172963 484268 +172967 177211 +172967 234698 +1729728 1729727 +1729842 443454 +1729842 891317 +1730063 1195410 +173008 73036 +173011 1292452 +1730149 1980898 +1730149 444609 +1730149 948983 +173019 18390 +17302 1247 +17302 15286 +17302 18951 +17302 68394 +173032 381533 +173050 1188 +1730507 43993 +1730565 270225 +1730565 538821 +1730565 855066 +1730565 925944 +173058 61218 +173079 113498 +1730792 769850 +17308 224545 +173081 145858 +173081 173399 +1730869 1369554 +1730869 644545 +1731 337 +1731052 2507653 +173115 339220 +173115 544898 +1731187 1215260 +1731187 2103043 +17312 13533 +17312 26599 +1731261 1403714 +1731261 644140 +1731261 795180 +1731342 252996 +173141 15787 +173141 173435 +173141 61831 +1731476 704625 +17317 9928 +1731777 361603 +1731777 361625 +1731804 2013704 +1731804 3139504 +1731804 833798 +173182 126064 +1731919 395180 +17322 40992 +173249 111174 +173280 411029 +1732881 2091112 +17332 17331 +173324 173325 +173359 216097 +17338 17339 +1733909 1733910 +1733909 3367796 +1733909 529900 +1733909 960689 +1734 44669 +173406 326128 +173448 607425 +1734569 2161443 +1734585 319462 +173460 1075630 +173460 244342 +173460 61833 +1734742 1671770 +173478 299922 +173479 265417 +173479 3273144 +173479 501112 +173487 145590 +1734977 932429 +173499 173500 +1735011 2129013 +1735011 3101195 +1735011 996443 +173503 173511 +173506 127836 +1735329 1372396 +173547 785743 +1735555 1239660 +1735555 1246887 +1735555 1307759 +1735555 1481548 +173557 232986 +173558 737914 +173559 197812 +17358 57651 +173582 10645 +173582 128276 +173582 219616 +173590 657945 +1735986 116683 +173615 466362 +1736296 576624 +17364 17365 +1736472 355 +1736472 624474 +1736644 908078 +17368 124436 +17368 161422 +17368 17364 +17368 56290 +1737 273161 +1737 3721 +1737 372118 +1737 4312 +173709 170597 +173709 173708 +173709 212263 +173715 1346247 +173719 90210 +173728 196795 +17373 13030 +17373 572751 +17373 57526 +1737430 36301 +173758 137603 +17377 17364 +17377 17368 +17377 56290 +1737795 1101381 +1737795 1294310 +1738131 207517 +1738250 1951420 +1738356 1413468 +17392 112401 +17392 6905 +17392 769863 +17393 7011 +1739441 2516552 +1739573 1739574 +1739573 1739575 +1739573 262376 +1739573 646485 +1739573 71825 +1739575 1739574 +1739575 262376 +1739575 646485 +1739575 71825 +17396 1140522 +17396 135493 +17396 17396 +17396 228852 +17396 234139 +17396 36122 +17396 6601 +1739627 2129819 +1739627 837674 +1739627 852711 +1739629 1024678 +1739629 1640301 +1739629 1720758 +1739629 1739627 +1739629 1739630 +1739629 1739632 +1739629 2129819 +1739629 2130303 +1739629 837674 +1739629 852711 +1739630 1739627 +1739630 1739632 +1739630 2129819 +1739630 837674 +1739630 852711 +1739631 1024678 +1739631 1640301 +1739631 1720758 +1739631 1739627 +1739631 1739629 +1739631 1739630 +1739631 1739632 +1739631 2129819 +1739631 2130303 +1739631 837674 +1739631 852711 +1739632 1739627 +1739632 2129819 +1739632 837674 +1739632 852711 +173967 137205 +17397 10471 +1739820 1203535 +17399 75999 +17399 8760 +174 40831 +174 417986 +1740 1600 +1740 2267 +1740 37078 +17400 517974 +1740318 1617487 +17404 10592 +17405 4245 +174065 133869 +1740721 447957 +1740945 1259121 +174100 1269390 +174100 157450 +174100 26955 +174100 600882 +174100 805034 +174100 832962 +174100 835735 +1741101 136028 +174122 188975 +174122 354816 +1741235 269102 +17413 133766 +17413 15165 +17413 17959 +17413 8670 +174136 30897 +174144 163281 +174144 2909455 +174145 1140665 +174145 316028 +174145 395191 +174145 793063 +1741674 1741675 +17417 1028023 +17417 213039 +17417 2478532 +17417 91058 +17417 94841 +174193 113498 +174193 127836 +174193 173506 +174193 237350 +174218 203681 +17422 2070 +17422 2895 +17422 48370 +17422 71562 +17423 23337 +1742325 1769378 +174246 154862 +174246 177200 +174246 177201 +174246 177202 +174246 282970 +174246 78003 +174255 211290 +1742564 754189 +17426 20029 +17427 15135 +17427 20231 +17427 214821 +17427 23786 +17427 253731 +17427 43268 +1742705 1405640 +174271 146112 +174271 175743 +174271 945130 +17428 13949 +17428 17427 +17428 183809 +17428 196886 +17428 472778 +17428 6244 +174303 66154 +1743383 1940056 +174356 1929681 +1743636 1767407 +174364 203001 +1743973 415725 +1743973 843127 +1743979 224587 +1744 2825 +1744 299 +1744 88750 +174410 80325 +17443 17447 +1744336 2740665 +1744428 1744430 +1744428 534901 +1744428 778532 +1744430 534901 +1744430 778532 +174447 252964 +174447 253778 +174447 339953 +174447 471831 +174447 84213 +17446 17443 +17446 17447 +17446 961150 +17448 170635 +17448 18471 +17448 47714 +174497 225972 +17451 15043 +17451 18379 +17451 85347 +17452 31436 +17452 54756 +1745232 17135 +174568 2501738 +1745709 822684 +1745761 283280 +17460 465929 +1746110 1633080 +1746505 1009206 +1746505 3546511 +1746505 3952633 +1747274 1195176 +174748 370805 +1747628 1747630 +1747647 55774 +17477 133345 +17477 44391 +17477 45744 +17477 612360 +174771 1552030 +1747799 1428400 +1747799 1780043 +174783 2072615 +17479 361388 +174810 26918 +17482 366791 +17482 53800 +1748690 573935 +17489 336882 +17489 73409 +174890 84752 +1749 102864 +1749 185723 +1749 204 +1749 2171505 +1749 4683 +1749 7 +1749 76172 +17493 134184 +17493 142963 +17493 15917 +17493 393666 +17494 1089847 +1749593 153980 +17498 63840 +175006 22720 +175008 746299 +175008 905356 +1750401 1852394 +1750502 2354781 +1750502 953587 +175089 90013 +1751379 1751388 +175150 126905 +175154 1059062 +175180 2575449 +175184 1626519 +175184 356428 +175184 42627 +1751953 1742328 +175206 147493 +17523 216935 +175231 37246 +17525 299191 +175255 30542 +17526 171 +17526 228928 +17526 2830 +17526 56639 +1752614 82730 +1752690 451878 +17528 1327083 +17528 900039 +1752845 16048 +175297 148192 +1753036 1243887 +1753036 1789743 +1753066 1931789 +1753087 1753090 +17531 12588 +17531 26233 +17531 43421 +17531 4994 +17531 86121 +1753162 340519 +1753222 2666384 +1753222 3729520 +1753222 3741615 +1753222 640396 +17533 25720 +17533 475474 +17533 7969 +175335 609772 +1753427 51420 +175345 201450 +175365 702067 +175380 145858 +175380 173081 +175380 173399 +1753972 1250342 +175437 175438 +17545 1122117 +17545 259913 +17545 532792 +17546 17035 +17546 17546 +17546 202258 +17546 30552 +17546 367041 +17546 43745 +17546 47512 +17550 104991 +17550 21715 +17550 73142 +1755130 1526532 +17554 2076 +175540 253837 +1755506 3206390 +1755668 1683524 +1755676 1755674 +1755685 1755688 +17557 69931 +17558 69788 +175586 132084 +175587 1233836 +1755927 194910 +1756203 590972 +1756206 885153 +175660 21135 +175660 76528 +175695 184400 +175695 928180 +175703 173478 +175704 173478 +175704 330925 +175704 370771 +175704 403935 +175704 94500 +175708 175707 +175708 534184 +175718 2264 +1757732 1756673 +175775 14923 +1757924 1586787 +1757924 3650853 +1757924 696188 +1757924 855072 +1758 30677 +1758 30678 +17580 11584 +17580 232100 +1758271 1758273 +17583 1361815 +17583 616859 +17584 834461 +17587 100558 +17587 14743 +17587 20897 +17587 44958 +17588 17589 +17588 87622 +17589 66147 +17590 856861 +175909 175910 +175909 237593 +17591 119546 +17591 233061 +17591 81990 +17591 96316 +175914 372793 +17592 3155415 +175925 65048 +1759362 1979478 +1759362 2182940 +175950 195894 +176015 56249 +176024 77372 +1760435 1036154 +1760435 1540079 +17605 1679924 +176085 16994 +176093 93013 +1761 20977 +1761 7530 +176185 246232 +1761927 1761926 +176217 45557 +176233 165134 +176237 1517445 +1762615 251960 +176262 218809 +176262 340829 +176262 858116 +1763 1644 +176313 176312 +176325 1024413 +1763410 519934 +1763410 822517 +1763509 575536 +1763611 1329328 +1763938 1522467 +1763938 382400 +17640 1431865 +1764073 3018999 +1764147 1144912 +176435 94557 +176442 548667 +1764847 1247105 +1764951 76026 +1764993 2621798 +1765111 3332357 +176526 165268 +176526 88072 +176528 176529 +176560 147982 +1765870 1595934 +176598 176900 +176598 32915 +1766091 2778016 +17664 8930 +176689 188396 +176689 25449 +1766926 2216689 +1766926 2745853 +17670 51341 +17670 968112 +176701 289906 +176712 23624 +176712 58584 +176712 800252 +1767457 268618 +1767457 612709 +176751 41233 +176776 184651 +17679 29207 +17679 29777 +17679 45200 +176817 1107070 +176817 1375247 +176817 570738 +176817 669685 +176837 78405 +1768578 1660852 +1768578 1890455 +17686 1056 +17686 172638 +176866 137633 +17689 4493 +17689 4517 +1769149 1056568 +1769149 894376 +1769149 931384 +1769505 863382 +1769578 194 +1769892 2280624 +1770 17111 +177000 247825 +177000 58287 +1770114 1416983 +177031 55325 +177047 255213 +177047 290041 +177047 312063 +177047 457539 +177049 338287 +177049 35199 +1770611 1335787 +1770611 1684645 +1770611 271461 +1770722 86434 +1770724 1607136 +177074 75798 +17708 17706 +177091 216408 +177093 51368 +1771211 2738679 +1771787 1771786 +1771792 1771786 +1771792 1771787 +17719 30603 +17719 815293 +177200 282970 +177200 553402 +177200 78003 +177201 154862 +177202 154862 +177202 177201 +1772034 1302743 +177209 154862 +177209 174246 +177209 177200 +177209 177201 +177209 177202 +177209 282970 +177209 78003 +177211 234698 +177235 971718 +177238 177239 +1772417 1083609 +177242 177244 +1772759 1776435 +177308 103640 +177308 77923 +177335 97072 +177339 177344 +177339 26955 +177340 264223 +177340 434336 +177340 456210 +177342 490279 +177342 490290 +177344 26955 +17740 257032 +17740 29207 +17740 64703 +177421 369493 +17743 18984 +17743 77229 +1774492 115463 +1774492 534822 +1774492 641164 +1774492 844416 +1774762 2255748 +1774797 1774796 +1774846 3033732 +177497 11769 +177497 395900 +177497 523446 +177497 678387 +1775 257937 +17751 1926093 +1775226 1048940 +177582 253451 +177584 115798 +177584 177581 +177586 144310 +177586 67657 +1776044 604071 +1776385 190370 +1776385 192325 +1776385 226461 +1776385 521381 +177639 58563 +177660 188946 +1776932 3428050 +177713 113789 +177713 113945 +177713 175914 +177713 372797 +177719 121827 +1777307 1294869 +1777307 688716 +1777307 833217 +1777307 912702 +1777392 1341476 +177742 1067806 +1777422 349997 +177779 15268 +1778 9708 +1778114 1778165 +177817 255129 +177817 259092 +177869 183544 +1778768 2986779 +1778789 2075829 +177921 499885 +17794 273763 +17794 56360 +1779441 1400615 +1779441 1779441 +1779441 243564 +1779472 1780433 +177974 10355 +177974 488720 +17799 134402 +17799 2759 +17799 297408 +17799 33522 +17799 503648 +17799 8230 +17799 9680 +1779910 2513599 +1779910 405150 +1779949 1780375 +1779949 2217943 +1779949 2217944 +1780113 1468969 +1780113 1734341 +1780113 175568 +17803 72979 +178054 1372712 +178054 150520 +1780607 1804731 +178083 1893417 +1781351 168453 +1781351 2381133 +1781351 252985 +1781351 256168 +17815 30439 +17815 455520 +17815 71521 +17815 9236 +178176 112323 +17819 2617998 +17819 49833 +1781956 1781957 +178199 178200 +1782263 1730149 +1782263 1980898 +1782263 444609 +1782263 948983 +1782473 878788 +178252 26339 +178262 424227 +178264 222692 +17827 110252 +17827 180585 +17827 194 +17827 258118 +17827 281551 +17827 29058 +17827 44120 +17827 44944 +17827 49624 +178301 52834 +178304 303115 +178310 173945 +178381 64367 +178389 14572 +178477 2317456 +1784907 1606412 +178502 25912 +178515 1550420 +17852 269646 +17852 290786 +1785458 1785459 +178557 224157 +1785886 2506336 +1785886 362230 +1785992 2522984 +178620 178621 +178659 156382 +178698 192718 +178698 297092 +178698 297093 +178698 6197 +178698 885103 +178698 885972 +178741 950874 +178746 49673 +178746 873954 +1787565 1262335 +1787565 1299987 +1787599 978851 +1787621 44387 +1787676 1360089 +1787676 835088 +1788026 1788027 +1788046 1446581 +178806 44101 +1788100 304975 +1788100 578727 +1788518 1018517 +1788518 977889 +17889 8349 +178892 73587 +1789 1604 +178908 1012233 +178908 1012234 +178915 1158975 +178915 1160955 +178915 1162546 +178915 1851324 +178915 269706 +178915 3741946 +178916 436257 +1789265 1789244 +178935 130180 +17896 6272 +1789767 45707 +1789919 1322663 +1789919 2549088 +1789919 979622 +178999 462542 +1790 1240479 +1790 32845 +1790 790612 +17900 113470 +17900 14488 +179005 870928 +1790128 3042703 +179036 216140 +179036 96123 +17905 18684 +17905 5649 +179055 10079 +179055 1763938 +179056 1059752 +179056 1691261 +179056 351805 +1790582 1790583 +1790630 834398 +1790872 594754 +179095 147666 +179095 276590 +179095 276591 +179095 360053 +1791 1797 +179117 84413 +179135 415702 +179142 2330733 +179180 128046 +179180 218608 +17919 281617 +1792064 869715 +179207 127989 +1792424 938452 +17926 103256 +17926 18011 +17926 235939 +17926 95946 +17926 97978 +179269 24050 +1792816 1792819 +1792816 1792822 +1792816 235636 +1792819 1792822 +1792819 235636 +1793080 353789 +1793143 2067920 +1793144 1794103 +1793489 2691924 +1793489 469572 +179354 1381441 +179354 233700 +179386 65707 +1793901 1977241 +179409 213589 +1794505 1617837 +1795469 1435021 +1795469 1556782 +179557 507279 +1795673 479982 +17957 122287 +17957 67036 +1795741 88386 +17958 17031 +17960 51979 +179607 169366 +1796082 1419530 +1796082 32180 +17961 255473 +17961 269087 +17961 286316 +179614 1418683 +17962 229180 +17962 25260 +179622 315177 +17963 518553 +179650 1381534 +179650 40932 +17966 1557003 +17966 28332 +17966 284321 +17966 47742 +1796688 1796687 +1796783 2301073 +17969 128264 +17970 180227 +179709 1009447 +179709 1147100 +179709 2021875 +17971 59556 +1797331 2271322 +1797442 2615079 +179747 10718 +179749 252641 +179762 132591 +179762 132592 +179762 151311 +179762 179762 +179762 243564 +179762 45392 +179762 644291 +179762 724499 +179762 7830 +179826 349341 +1798268 1199553 +179850 107707 +1798623 1055630 +1798623 526416 +1798623 851414 +1798623 978211 +1798899 1653767 +1798899 1653770 +1798899 1798900 +1798899 455945 +1798900 455945 +1799314 4851 +1799396 1805040 +1799447 2365896 +179947 215335 +179948 260650 +1799558 3975474 +1799681 1240466 +1799827 1449180 +1799849 702474 +1799928 464582 +1800 1075584 +180025 180026 +1800264 1976017 +1800454 1740971 +18007 10554 +18007 94610 +18007 94622 +1800739 3006096 +180076 906554 +1801 2548 +180101 663067 +1801107 1364371 +1801107 822410 +1801107 834703 +1801107 834707 +1801196 483845 +1801196 504753 +1801196 565775 +1801196 714903 +1801211 1458942 +1801296 1609513 +1801341 1801344 +180140 1065010 +180140 137880 +180140 175575 +180140 180818 +180140 341733 +180140 383281 +1801439 61813 +1801598 2291890 +180182 3980 +1802056 1553788 +1802078 1802079 +1802107 1982778 +1802107 2024990 +1802107 379691 +1802107 774481 +1802107 833018 +1802107 862699 +1802107 870832 +1802107 870833 +180218 180219 +180241 1688111 +180252 11853 +180252 12051 +180252 134395 +180270 822473 +180275 2733158 +180275 347445 +1803091 1499475 +1803197 29977 +180353 206442 +180356 274516 +180356 48077 +180383 230520 +180383 891561 +180386 423142 +1804197 1774051 +1804375 936873 +180456 126113 +1804672 1804673 +180470 367897 +180477 198660 +1804938 454630 +18052 80270 +180525 180526 +180531 104618 +180554 241822 +180554 242054 +180585 180586 +180585 194 +180585 262691 +180585 287849 +180585 30185 +180609 234138 +18063 239151 +18063 244314 +18063 244654 +18063 2509825 +18063 29539 +18063 641849 +18063 846662 +1806381 688704 +1806671 1910883 +1806754 1806755 +180689 3191092 +1807120 1120885 +180721 342751 +180721 73101 +1807214 220187 +1807214 3230392 +1807214 3521164 +1807455 150401 +1807455 2593892 +1807455 2593893 +1807455 2593894 +1807455 284099 +1807455 2852192 +1807455 3180501 +1807455 347268 +180752 504301 +180785 42380 +180818 1008036 +180818 137880 +180818 151199 +18085 1781 +18085 753531 +1808535 220489 +180882 233163 +1809 216847 +180901 117419 +180914 1161413 +180914 1547604 +180914 446905 +1809258 3271913 +180927 134516 +180930 364596 +180932 489143 +180933 810472 +180935 627590 +180953 470932 +1809738 2605579 +1809835 1625185 +181 5366 +1810003 832942 +181010 212524 +181016 181017 +181019 310803 +181036 188619 +181039 495127 +181061 196196 +1810702 1038209 +181081 80586 +1811 22430 +181115 233432 +181115 247410 +181129 11074 +181142 59144 +1811439 1886732 +1811439 2071561 +181189 27751 +1812 27587 +1812 30556 +1812 31877 +181208 10095 +181213 314301 +181223 1679850 +181225 109014 +18123 1335830 +18123 28579 +1812321 362703 +18128 865450 +1813309 1668831 +181339 63978 +1813431 1483957 +1813495 1813493 +1813495 2088979 +1813599 2122035 +1813599 2122036 +1814187 2461162 +181427 5682 +18144 1287268 +1814470 2517942 +1814826 1391169 +181485 115701 +181492 299856 +1815468 1441341 +1815468 953813 +18155 739771 +1815910 394051 +181644 162438 +18171 345606 +18171 89520 +181778 224640 +1817949 439369 +1818209 3777966 +18185 462786 +18185 46691 +18185 8755 +18187 15640 +18187 62955 +18188 157122 +181885 22421 +181885 646 +1819 1263784 +1819074 1385356 +1819155 448007 +1819287 704679 +18194 267 +1819526 1819525 +1819526 1819526 +1819584 1304667 +1819846 7133 +1819920 2387670 +1819920 244417 +1820 857792 +18201 114790 +18201 339033 +18201 339766 +182063 17897 +1820808 1461 +1820808 581661 +1820825 1940617 +1820825 2040218 +1820825 2309389 +1820825 2585428 +1820950 271508 +1821 21136 +1821133 1177051 +18212 113902 +1821569 2754275 +1821719 1821718 +182199 5064 +182199 82211 +182207 73667 +18222 103826 +1822268 237156 +1822268 924732 +182246 44657 +1822475 2624372 +1822718 943307 +1823055 1719085 +182309 1122616 +182309 260328 +182322 2304644 +1823267 222253 +1823417 1823418 +1823581 373037 +1824160 846624 +18244 3621935 +182441 25872 +1825 10504 +1825 1139 +1825 12053 +1825 1754 +1825 3449 +1825 37598 +1825 42018 +1825 772897 +1825 940921 +1825132 646859 +1825132 866595 +182566 191753 +182566 203219 +182566 213913 +182566 629037 +1825777 17428 +1825777 88174 +1825898 1057453 +1825898 435555 +1825898 835113 +1825983 2873325 +1825983 2873326 +1825983 2873327 +182615 108975 +182615 166114 +182615 234010 +182628 1378029 +182628 194 +182628 983463 +182642 170888 +182642 182643 +182642 662226 +182643 170888 +182673 13732 +182673 1635332 +182673 231098 +182673 26245 +182673 36100 +182673 37913 +182673 45095 +182673 51352 +182673 51988 +182673 95003 +182673 97139 +182687 228555 +182687 723844 +182687 74772 +182727 192275 +182738 170365 +182784 91024 +182791 26 +1827993 707920 +182842 297300 +182846 2367059 +182846 241662 +1828466 2370730 +182848 501166 +182854 626377 +1829103 90210 +182929 289567 +182929 301381 +182998 798229 +183 168634 +183009 138493 +18301 155178 +18301 199184 +1830103 388830 +183017 208283 +1830531 1279806 +183069 223172 +1830722 2120670 +183092 258946 +183092 67356 +1831 623584 +1831 92500 +183145 255 +18316 316088 +1831675 704150 +18317 1298296 +18317 1416551 +18317 154490 +18317 425519 +1831755 1713695 +1831755 185390 +1832 37998 +1832023 2756033 +1832023 3283328 +1832023 457708 +18324 308458 +18324 735854 +183267 101715 +183267 1280 +183267 27472 +183267 313768 +183267 3231659 +183267 492441 +183271 30081 +18329 51271 +18336 11624 +183360 83667 +1833723 1021948 +1833723 1021949 +1833723 864674 +1833723 896804 +183374 220446 +1833771 116366 +183396 79830 +1834247 835090 +183427 98308 +18344 24059 +183484 227979 +183484 7099 +183488 250833 +183523 18984 +183523 2242673 +183523 2254859 +1835233 242200 +1835233 629036 +18353 15256 +18353 64575 +183553 1012243 +1835598 2334532 +18360 63496 +183611 356495 +18365 18472 +1836741 1836744 +1836741 451534 +1836741 845760 +1837081 1244201 +183729 183730 +1837294 1837292 +1837313 2299584 +18374 162075 +183741 10937 +183741 183741 +183741 210389 +183741 829288 +1837505 2873909 +183761 19799 +1837841 1064118 +1838079 378586 +183809 91024 +1838163 1082633 +1838163 1109894 +18382 111582 +18382 111650 +18382 113945 +18382 118025 +18382 121782 +18382 124396 +18382 166405 +18382 186773 +18382 198427 +18382 20419 +18382 20431 +18382 21503 +18382 216448 +18382 25009 +18382 31418 +18382 31516 +18382 31535 +18382 60399 +18382 6123 +18382 93386 +183821 57475 +1838368 3471187 +18384 104195 +183869 463239 +183886 1215544 +183886 85061 +1839 20801 +18390 460 +1839064 154315 +183915 99415 +183922 453814 +183922 553222 +183942 183944 +183960 1515 +183969 790714 +183989 1715914 +1839963 1839962 +184 664367 +184003 2535980 +184003 2587394 +184003 2587430 +184003 2587431 +184003 573029 +1840272 2080118 +184029 425735 +1840325 1904902 +1840325 252868 +184037 249994 +18404 100457 +18404 613407 +18404 6178 +1840714 283127 +1840714 754974 +1840754 3098688 +1840862 1435753 +1841308 983824 +184131 237393 +1841441 1954767 +1841443 2665678 +1841443 506494 +1841563 162564 +184160 1792772 +18417 54640 +184236 2168 +184236 2517944 +184258 184256 +184258 246846 +184258 262492 +184258 281211 +184258 297269 +184258 321043 +184258 321956 +1842693 73431 +18428 92834 +184287 278238 +18430 11434 +18430 6123 +18431 112401 +18431 17392 +18431 25999 +18432 31423 +18433 10435 +18434 1242824 +18434 31215 +18435 202114 +18435 20958 +18435 3489575 +18435 8349 +184358 341244 +18436 27564 +18436 43859 +1843608 2425833 +18437 114963 +18437 20427 +18437 95293 +184375 278 +184375 3266818 +1843884 1713496 +1843969 1843969 +1843990 353791 +1844 1606075 +1844 805522 +18440 38588 +18440 42870 +184400 3547765 +184400 442284 +184400 655514 +184430 184432 +1844419 169099 +1844419 429888 +1844790 2208730 +184491 173377 +1845 1531 +1845030 1845031 +1845249 2282044 +184535 184534 +184603 184604 +184622 134343 +184622 184622 +184622 190251 +184622 2925821 +184622 490958 +184622 613277 +184622 637608 +184622 8317 +1846410 1776289 +1846423 337062 +1846423 701741 +18466 108074 +18466 119938 +18466 221412 +18466 342562 +18466 431537 +18466 43988 +18466 67261 +184660 232380 +184685 874383 +1847087 1333990 +18471 135788 +18471 170635 +18471 17446 +18471 18473 +18471 28209 +18471 46845 +184712 1897205 +18473 364257 +18473 46845 +18473 47706 +18473 54787 +1847365 3916168 +184746 1498743 +1847668 1847667 +184778 202075 +184812 187471 +184816 764895 +184816 764896 +184852 10916 +184852 1285871 +184852 14972 +184852 226992 +184855 1054362 +184855 1195410 +184855 14412 +184855 162345 +184855 2217709 +184855 242319 +184855 320099 +184855 3409422 +184855 421739 +184855 436743 +184855 522847 +184855 572782 +184855 640396 +184855 729860 +184855 817642 +184855 877201 +184877 3692491 +184902 1044753 +1849128 2230586 +1849128 2571847 +1849338 3039466 +1849338 3219528 +1849484 270336 +1849607 1823283 +1849894 1046946 +1849970 1638553 +1849970 2395046 +185 132854 +185 1911 +185 69249 +185 7517 +1850 809 +18500 63257 +185006 153980 +185008 308159 +1850462 1850461 +1850560 1850559 +1850690 2338408 +1850758 1021989 +1850758 1292320 +185090 537894 +1850994 2683663 +185118 144193 +185118 48650 +185118 65636 +185120 117420 +185120 555565 +185120 789359 +185137 95998 +185152 993687 +1851580 405125 +1851705 89892 +1851705 972281 +185178 22078 +185178 228068 +185219 1168159 +185219 144454 +1852394 2819469 +18528 51629 +18530 49606 +185300 185301 +185323 493609 +1853836 845450 +1853898 1853899 +185398 21517 +1854043 359803 +185407 292256 +1854131 1367929 +1854144 1543113 +1854174 1854173 +1854374 232877 +185446 93607 +185489 21757 +185489 422231 +185489 601787 +185492 64028 +1855 49308 +185500 321003 +1855232 1823637 +18553 989082 +185545 237577 +185549 102934 +185549 236900 +185580 173557 +185580 195945 +185580 214301 +185582 182673 +185582 185580 +185582 197812 +185582 90037 +185587 137603 +185587 48604 +18562 212632 +1856507 1106205 +1856507 247477 +1856559 1136538 +1856786 313993 +185689 1362644 +185689 2215956 +1857 134249 +1857 1537533 +1857 180837 +1857 226705 +1857 32635 +1857 33542 +1857 3533 +1857 400128 +1857 5486 +1857 700491 +1857 7007 +1857 70095 +1857 8459 +1857 99406 +185729 185730 +185737 242867 +185741 251742 +185751 17827 +185751 246205 +185751 258118 +185751 267099 +185751 281551 +185751 282240 +185751 29058 +185751 307059 +185751 44120 +185751 44944 +185751 79989 +185752 262127 +185753 44771 +185755 2677700 +1857621 117026 +185807 558136 +185839 1277604 +185839 31916 +185839 37718 +185839 59945 +185840 79763 +1858439 1858440 +1858490 1016090 +1858490 424983 +18585 145698 +18585 253834 +18585 28891 +18585 72240 +18588 30389 +185889 88760 +185896 1086274 +185899 192765 +1858990 2890492 +1859 4952 +18593 74157 +18594 22748 +1859453 240890 +1859526 1734 +185957 116010 +185982 50077 +185992 1603137 +185992 168867 +185992 272699 +185992 393461 +185992 95147 +1860331 2083494 +18604 24346 +18604 43498 +18604 55008 +1860474 2977430 +18605 18473 +186149 2023862 +1861594 1051393 +186182 354506 +1861955 1593994 +18620 152459 +1862134 2006989 +18623 48028 +186235 1003686 +186235 186236 +186235 228213 +186236 2265 +186237 429888 +1862676 276337 +186307 167643 +186307 63199 +186307 72657 +1863220 355 +1863220 807855 +186349 401366 +186360 4614 +18639 10072 +186406 4136 +18641 2788204 +1864137 863279 +186450 151038 +186453 18417 +1864552 1770381 +1864552 1864554 +1864552 1864555 +1864553 1770381 +1864553 1864552 +1864553 1864554 +1864553 1864555 +1864553 830144 +1864554 1770381 +1864554 1864555 +1864555 1770381 +18646 41509 +1864661 1249728 +1864661 1516830 +1864661 1950863 +1864661 2150668 +1864661 2406747 +186469 508483 +1864726 1751813 +186491 10003 +186533 76447 +1865631 1865632 +186568 180784 +186584 75409 +186590 502345 +1866 17531 +1866 3101 +1866 40586 +1866 5979 +1866111 1419817 +1866120 256729 +186621 170393 +1866329 10985 +1866373 1392750 +18666 1456077 +18666 260764 +18666 5049 +18666 5083 +18666 55902 +18666 60742 +18666 77224 +18666 84684 +18666 91291 +1866756 1331643 +18668 36428 +1866814 2265291 +186708 3385 +1867105 1639465 +1867105 2795505 +1867204 1077818 +1867204 1450166 +1867204 296959 +1867204 354659 +18674 149999 +1867445 42757 +186755 170570 +1867658 1867659 +186773 1481614 +186773 21059 +186773 6123 +186773 93386 +186773 94855 +186837 93616 +18684 176098 +18684 31715 +18684 5649 +186846 44691 +186846 63977 +1868486 1868485 +1868577 252310 +1868577 253478 +186868 1059288 +1868764 238626 +1868764 272929 +1868784 246536 +1868794 870852 +186883 202114 +186883 292418 +18690 6917 +186902 257898 +186910 186911 +18692 15588 +18692 54918 +18692 878093 +1869316 1978958 +18698 18698 +18698 216764 +18700 180664 +18700 328677 +18700 421263 +18700 8699 +18700 915075 +187066 179366 +18710 11430 +18710 115773 +187134 292491 +187134 53818 +187150 127745 +187150 534550 +187150 676343 +187183 188054 +187183 649617 +187198 8666 +187204 117239 +1872288 1182300 +18726 137210 +1872844 310484 +1872904 2187 +1873219 1402814 +187358 825375 +18737 16362 +187373 3360374 +187373 363164 +187373 743845 +1873739 1872647 +1873739 3154167 +1873771 519697 +187413 1391282 +187413 19111 +187413 223795 +187425 1373551 +187425 1555106 +187425 1688177 +187444 38312 +187444 544422 +187457 656397 +1874747 1874746 +1874747 820460 +18748 765624 +18748 7899 +1875260 358318 +1875384 3605204 +187546 171423 +187558 30145 +1876241 177581 +1876243 177581 +1876243 1876241 +1876243 841350 +1876275 344658 +187629 231465 +187629 232277 +1876518 1876517 +187676 11254 +187676 124429 +1876948 1117934 +1876948 1584642 +1876948 1876949 +1876948 456764 +1876949 1584642 +1876949 456764 +1876974 262358 +1876974 502814 +1877 371965 +187701 187702 +1877324 932864 +187740 75542 +1877412 1877411 +1877421 1014245 +1877421 1924932 +187769 6428 +187774 764485 +1877809 1510798 +1878429 283122 +18787 394924 +1878757 466552 +1878789 1713695 +1879176 149162 +1879176 2687330 +187919 591631 +1879577 2493724 +187964 22910 +187964 32446 +187964 40445 +1879660 11593 +1879660 5965 +1879805 3326647 +187981 84768 +187983 187984 +18799 2014298 +18799 2014300 +18799 2536561 +18799 352262 +18802 339679 +18803 351770 +1880353 1945357 +1880353 3500864 +188038 180271 +1880900 1144752 +188116 75331 +18813 195811 +18813 319251 +18813 515289 +1881329 2760167 +1881470 253521 +18817 50598 +18818 860357 +1881856 3227242 +1882417 1479226 +18825 30991 +188250 1175622 +188250 21338 +188251 993328 +188261 1211789 +1882719 3377500 +188315 77755 +188330 371699 +1883636 1883637 +18837 1138856 +18837 1472585 +188382 188386 +18839 106802 +18839 262691 +18839 317584 +18839 490610 +18839 85885 +188393 269090 +1883935 2187 +1883935 455520 +1884033 152709 +1884193 1884194 +188449 80027 +18845 289116 +18845 85889 +1884656 11539 +188466 555774 +1884700 3530089 +18850 61792 +1885009 2493716 +188502 1180987 +188515 91350 +1885206 1536956 +188532 224250 +1885609 136131 +1885609 1885609 +188581 183360 +188581 83667 +188591 329285 +188591 374549 +188591 374958 +1886097 711106 +188628 188627 +188632 3876458 +1886354 2085820 +188690 60650 +188746 229809 +18878 1214313 +188781 1828276 +18880 49746 +188822 188823 +1888624 885816 +188880 178235 +1888826 1888818 +188886 266646 +1889889 1831755 +1889889 185390 +1889889 2440228 +188997 10504 +188997 482193 +1889999 335370 +189 1399 +189 189 +189 2321 +189 25227 +189 5184 +18901 13758 +1890127 1890128 +1891014 1385924 +1891014 1933252 +1891014 351666 +1891014 542501 +1891014 696267 +18911 465864 +189119 32771 +189124 189123 +1891384 39167 +1891464 1145679 +1891464 942337 +1891995 2697025 +18924 270502 +18924 28565 +1892678 1892679 +1892739 2794067 +189293 324420 +1893326 857096 +18934 208376 +189343 855937 +1893724 51454 +189377 189378 +18940 56722 +189400 1290029 +189400 1504449 +189400 1567811 +189400 42262 +1894040 183889 +1894943 1894941 +18956 348490 +1895863 327742 +189621 518640 +189621 84400 +189635 100558 +189635 25495 +1896873 824901 +1897155 1735082 +189724 3286327 +189750 90382 +189751 195221 +18977 258749 +18977 260898 +18977 272756 +18977 342874 +18977 74210 +18978 164269 +18978 18983 +18978 331409 +1898059 2152767 +189821 66136 +189821 869435 +189827 15687 +18983 29827 +18983 9557 +18984 100591 +18984 18956 +18984 4119 +18984 64664 +18984 80124 +18984 86094 +18985 1091590 +18985 231606 +18985 285633 +1898666 261451 +1898666 375279 +1898666 526592 +1899084 1899083 +189913 1512772 +189920 20124 +189920 269254 +1899278 95546 +1899484 526184 +1899606 5876 +18997 37980 +18999 5166 +18999 74710 +19004 158887 +1900486 349514 +1900487 1900486 +1900487 349514 +190052 166838 +190052 180195 +190052 394752 +1900632 653535 +190070 229236 +190070 694010 +1900746 103339 +1900746 1364240 +1900784 910767 +190092 320098 +190101 148308 +190101 681677 +1901092 751375 +190137 188758 +190146 184510 +190146 266253 +190146 996474 +1901503 1420649 +1901503 754894 +1901503 832917 +190163 520193 +190200 69036 +1902102 1902103 +1902174 2416903 +190251 28568 +190251 398677 +1902741 134977 +190275 2764617 +1902968 1328725 +1902968 696188 +1902968 833071 +1902968 857318 +190328 186449 +19036 19783 +1903613 128367 +19037 267743 +19037 47993 +190370 1099152 +190370 1806381 +190370 184712 +190370 1897205 +190370 212000 +190370 212299 +190370 227875 +190370 262357 +190370 282639 +190370 282644 +190370 294480 +190370 339754 +190370 339755 +190370 339756 +190370 395913 +190370 441322 +190370 470260 +190370 479033 +190370 493464 +190370 567502 +190370 567511 +190370 633161 +190370 633162 +190370 655270 +190370 688704 +190370 688706 +190370 754978 +190370 772759 +190370 92243 +190371 1454465 +190371 164758 +190371 2157792 +190371 2355959 +190371 273481 +190371 361513 +190374 1153800 +190376 219258 +1904322 3275739 +19044 1074667 +19044 134751 +1904424 1850 +1904424 397651 +19049 45199 +1904914 7870 +1905 106753 +1905 208853 +1905141 1462139 +1905141 916544 +1905203 1267623 +1905203 1460256 +1905203 227454 +1905203 2458647 +1905203 423619 +1905203 778590 +190536 809421 +1905449 1905440 +190551 633078 +1905521 100313 +1905521 1738706 +1905521 2210728 +1905567 1255566 +19056 29158 +19056 31109 +19056 4059 +19056 4060 +1905627 363673 +1905735 945130 +1905761 51067 +1905870 3062124 +1905919 367149 +190597 197076 +190623 296874 +1906651 1906690 +1906651 192247 +190680 1563970 +19069 5968 +1907475 191071 +19075 123954 +190754 231482 +190754 4155 +190768 499390 +19078 7679 +1908562 836546 +1908562 836547 +1908726 2518110 +1908726 282137 +1908726 883123 +1908726 961426 +1908726 982123 +19088 5545 +1908876 696169 +1909 466833 +1909 53988 +1909251 2907262 +1909423 1909424 +190959 106541 +190959 1578339 +190959 25872 +1909679 1909672 +1909874 1031262 +1909874 1415871 +1909874 1653542 +1909874 577808 +1909874 833625 +1909874 854228 +1909874 858375 +191 178828 +191 223233 +19100 159425 +191016 2005836 +191016 67073 +1910341 756117 +191036 1546073 +191036 2763047 +191036 319781 +191036 510349 +1910537 40632 +1910564 1910565 +1910564 858200 +191071 200516 +1910965 1350960 +1910965 1515763 +1910965 987776 +191099 51669 +1911 772612 +19110 45127 +191103 7444 +191109 538274 +19111 1336814 +19111 33932 +19111 3852 +19111 40538 +1911510 196759 +19116 2666257 +191242 120307 +191242 1491576 +191242 2667626 +191242 2765127 +191242 466983 +191242 477716 +191242 933374 +191242 9686 +191294 72068 +19132 263095 +19132 287209 +19132 661 +191323 2093923 +191323 289991 +191323 310353 +1913339 12974 +1913955 2058179 +1913955 215605 +1913955 3144058 +19140 12033 +19140 18404 +19140 19140 +19143 13272 +19144 553093 +19146 11476 +19146 295 +19146 776719 +191471 29062 +191476 978962 +1914947 1914948 +19151 915629 +1915113 1668408 +191518 1137166 +1915254 12803 +1915254 169336 +1915254 305579 +1915320 380377 +1915380 696188 +1915380 864674 +1915674 1054060 +1915674 1548002 +191569 286867 +1915697 1915699 +191608 642865 +19161 19163 +1916200 2206348 +19169 50308 +1917117 1215224 +1917193 2565133 +1917193 3088988 +1917194 1213373 +1917194 1753884 +1917557 2623969 +1917642 1733023 +191782 4281 +191782 7771 +191788 13811 +1918122 1956896 +191863 179917 +191870 25483 +191870 49121 +191878 144644 +191879 656289 +191902 1905592 +191902 247444 +191902 522711 +1919104 454167 +1919104 455008 +1919176 1040777 +1919176 1341604 +1919176 1931865 +1919176 577808 +1919359 1040777 +1919359 1066447 +1919359 1341603 +1919359 1341604 +1919359 1377659 +1919359 1430196 +1919359 1919176 +1919359 1931864 +1919359 1931865 +1919359 1956383 +1919359 1971580 +1919359 1971583 +1919359 577808 +1919359 696181 +1919359 854227 +1919359 855063 +1919359 870173 +1919662 2361118 +1919662 2381403 +19198 11449 +19198 12617 +19198 176837 +19198 78405 +191990 1241777 +191993 473097 +192 1471 +192 22255 +192029 789181 +19203 48766 +1920518 2387833 +192054 2008476 +192065 930951 +1920651 1999103 +192069 1004709 +192076 137778 +192095 1391184 +1921025 931575 +19213 231070 +192134 1495657 +19215 195425 +192151 321128 +192151 614963 +192155 1032953 +192160 20952 +192160 290122 +192160 901891 +192202 435619 +1922119 1922121 +192225 735339 +1922348 1046945 +1922348 978175 +1922395 1922394 +1922395 253592 +1922395 268361 +192242 82224 +1922612 128832 +1922612 2541155 +1922612 87020 +1922991 1970387 +192311 192313 +192319 472112 +192322 1022039 +192322 1516778 +192322 229547 +192322 341147 +192322 704150 +192322 829980 +192322 842269 +192322 842271 +192322 842272 +192322 842663 +192322 880957 +192322 912384 +192325 1030523 +192325 1030674 +192325 108568 +192325 1173665 +192325 1202945 +192325 1213123 +192325 1214103 +192325 1259101 +192325 1263566 +192325 1280050 +192325 1303395 +192325 1326044 +192325 1376703 +192325 1393151 +192325 1507433 +192325 1508496 +192325 1659927 +192325 190370 +192325 216140 +192325 226461 +192325 2455825 +192325 2455827 +192325 260744 +192325 262940 +192325 269254 +192325 273804 +192325 283122 +192325 304975 +192325 308115 +192325 3174982 +192325 3312827 +192325 368137 +192325 388185 +192325 395913 +192325 406281 +192325 448007 +192325 448008 +192325 448009 +192325 448010 +192325 452918 +192325 454293 +192325 454981 +192325 521381 +192325 538821 +192325 552196 +192325 561054 +192325 627442 +192325 696165 +192325 696188 +192325 703271 +192325 730306 +192325 730309 +192325 736606 +192325 762632 +192325 809856 +192325 824202 +192325 832905 +192325 832915 +192325 833240 +192325 833560 +192325 833686 +192325 833794 +192325 834395 +192325 834577 +192325 835066 +192325 835190 +192325 837009 +192325 837573 +192325 837575 +192325 838953 +192325 841533 +192325 842078 +192325 842108 +192325 843527 +192325 849690 +192325 861499 +192325 861951 +192325 864672 +192325 864674 +192325 867976 +192325 869796 +192325 871277 +192325 874562 +192325 893590 +192325 895161 +192325 899565 +192325 910130 +192325 913209 +192325 915941 +192325 926730 +192325 931316 +192325 940128 +192325 944143 +192325 959744 +192325 96123 +192325 970420 +192325 972023 +192325 986694 +192325 999914 +192327 1009447 +192327 1024678 +192327 1031262 +192327 1032225 +192327 1032226 +192327 1032231 +192327 1032277 +192327 1032278 +192327 1040749 +192327 1040777 +192327 1046517 +192327 1066447 +192327 1070145 +192327 1080246 +192327 1080247 +192327 1121948 +192327 1133130 +192327 1141795 +192327 1147100 +192327 1165556 +192327 1165562 +192327 1182783 +192327 1183639 +192327 1208452 +192327 1239660 +192327 1283944 +192327 1294345 +192327 1300808 +192327 1313284 +192327 1330365 +192327 1341603 +192327 1341604 +192327 1341647 +192327 1344131 +192327 1377659 +192327 1412846 +192327 1412850 +192327 1412851 +192327 1415867 +192327 1415870 +192327 1415871 +192327 1416944 +192327 1430196 +192327 1430197 +192327 1447773 +192327 1478675 +192327 1481537 +192327 1481547 +192327 1488744 +192327 153980 +192327 1578164 +192327 1587380 +192327 1640301 +192327 1640312 +192327 1640320 +192327 1652194 +192327 1652196 +192327 1653542 +192327 170759 +192327 170760 +192327 1710599 +192327 1720758 +192327 1726080 +192327 1728371 +192327 1739627 +192327 1739629 +192327 1739630 +192327 1739631 +192327 1739632 +192327 179709 +192327 1908726 +192327 1909874 +192327 1919176 +192327 1919359 +192327 1931864 +192327 1931865 +192327 1956383 +192327 1971580 +192327 1971583 +192327 2129819 +192327 2130303 +192327 2165400 +192327 2219913 +192327 2272363 +192327 2336902 +192327 2358508 +192327 2410878 +192327 2517927 +192327 2518110 +192327 253133 +192327 2532965 +192327 2542688 +192327 260744 +192327 269254 +192327 270225 +192327 279614 +192327 282137 +192327 283122 +192327 290601 +192327 299702 +192327 3292283 +192327 3292284 +192327 341084 +192327 349296 +192327 3496517 +192327 3519719 +192327 368137 +192327 369053 +192327 397620 +192327 406283 +192327 415720 +192327 442174 +192327 451535 +192327 454293 +192327 462603 +192327 499563 +192327 526591 +192327 532270 +192327 538646 +192327 538821 +192327 55683 +192327 577808 +192327 656869 +192327 667503 +192327 696169 +192327 696181 +192327 696188 +192327 696192 +192327 696193 +192327 696200 +192327 696220 +192327 696253 +192327 754974 +192327 759186 +192327 762632 +192327 826840 +192327 832951 +192327 833075 +192327 833098 +192327 833155 +192327 833163 +192327 833164 +192327 833168 +192327 833169 +192327 833317 +192327 833446 +192327 833554 +192327 833560 +192327 833625 +192327 833628 +192327 833629 +192327 833667 +192327 833697 +192327 833826 +192327 833827 +192327 833829 +192327 835733 +192327 836125 +192327 836127 +192327 837060 +192327 837503 +192327 837512 +192327 837529 +192327 837532 +192327 837533 +192327 837534 +192327 837545 +192327 837548 +192327 837674 +192327 838400 +192327 838930 +192327 840438 +192327 841436 +192327 841593 +192327 842132 +192327 842222 +192327 842223 +192327 842888 +192327 846970 +192327 849435 +192327 849441 +192327 849443 +192327 849445 +192327 849446 +192327 850897 +192327 850899 +192327 850906 +192327 850909 +192327 851310 +192327 851418 +192327 851419 +192327 852711 +192327 853477 +192327 854227 +192327 854228 +192327 854230 +192327 855063 +192327 855065 +192327 855072 +192327 855170 +192327 858371 +192327 858372 +192327 858375 +192327 858380 +192327 859036 +192327 859046 +192327 859877 +192327 861483 +192327 861487 +192327 861489 +192327 862694 +192327 865659 +192327 867992 +192327 868929 +192327 870173 +192327 882018 +192327 882023 +192327 882024 +192327 882025 +192327 882141 +192327 883123 +192327 883315 +192327 887610 +192327 888414 +192327 888854 +192327 889200 +192327 889836 +192327 893051 +192327 899898 +192327 900979 +192327 905491 +192327 915657 +192327 921168 +192327 925944 +192327 925945 +192327 961426 +192327 973041 +192327 973042 +192327 974483 +192327 978302 +192327 982123 +192327 982225 +192327 986112 +192327 998856 +192333 10927 +192336 145229 +19235 30878 +19235 47140 +19235 53438 +192351 13561 +19236 282419 +19236 584769 +19236 620718 +192367 192368 +1923805 1175839 +192423 23985 +192443 243126 +192495 11584 +1925 11245 +192509 213326 +192509 296359 +192511 507769 +192511 7870 +192551 2738628 +192557 259636 +192570 374793 +192570 87251 +1925876 3068399 +19259 53492 +1926 194803 +1926 49582 +1926169 2743806 +1926389 265280 +1927026 2428251 +1927026 2720538 +1927726 1295435 +1927726 223545 +1927726 410990 +1927726 5164 +1927726 680514 +1927726 963610 +1927981 79672 +1928 118195 +1928 16304 +1928 244892 +1928 4158 +1928 465179 +1928057 870833 +19285 51406 +1928545 336749 +192867 39838 +19288 14412 +192926 192925 +1929501 2850596 +192959 197113 +19298 97664 +1929911 2716384 +1929911 551084 +193 795611 +1930057 1505973 +19302 204927 +19302 244426 +1930226 1997006 +1930226 206281 +1930226 442174 +1930226 847372 +1930226 935812 +19303 94778 +19304 1795658 +1930455 10582 +1930456 10582 +1930456 1930455 +193060 419323 +193064 227583 +193065 251106 +193070 1434325 +1930740 560912 +193117 1035281 +193117 1035282 +193117 140735 +193117 1468726 +193117 1612940 +193117 1730464 +193117 190141 +193117 193117 +193117 1949 +193117 482638 +19312 194211 +19312 42964 +19312 82431 +1931393 1931395 +193160 1091167 +193160 1204535 +193160 96708 +193167 193168 +1931864 1040777 +1931864 1341604 +1931864 1919176 +1931864 1931865 +1931864 577808 +1931865 1040777 +1931865 577808 +1931910 82740 +1932013 2468635 +1932202 1723639 +1932202 1804375 +1932202 936873 +193222 9040 +1932250 1571508 +1932292 1416655 +1932292 626008 +193235 1141651 +193235 173371 +193235 197311 +193235 227234 +193244 65629 +193244 8718 +193258 192192 +1932821 2670586 +193296 908514 +193314 505738 +1933250 2270071 +1933252 351666 +1933252 451535 +1933252 459665 +1933252 696215 +1933252 696267 +1933252 837498 +1933252 859024 +19333 940384 +193363 148750 +193363 166728 +193363 212034 +193363 45650 +193363 492163 +193363 878036 +1933849 1632066 +1933849 2406287 +19341 422175 +193470 3858 +1934713 1751813 +1934787 1079561 +1934787 704150 +193491 373882 +193496 624452 +1934985 3062379 +193503 2676554 +193503 434854 +1935092 1079116 +19351 272611 +1935128 833686 +1935128 932064 +193521 97916 +193528 338406 +193528 898427 +1935328 1604940 +193549 1236717 +193549 2087414 +193549 323961 +1935591 47309 +19357 203742 +19357 776157 +193583 265382 +193583 265422 +193583 61587 +1936000 1448227 +1936000 3585401 +19362 329643 +19362 35077 +19362 358000 +19362 43554 +19362 44358 +193631 235032 +1936453 1137586 +1936453 855494 +1936464 105185 +1936464 35086 +1936464 4687 +1936490 809499 +1936566 2294752 +19367 18500 +1936871 255801 +1936871 310172 +1936871 508131 +1937153 181909 +1937294 266636 +193735 193732 +1937493 1202712 +1937944 3724065 +1938163 1776289 +1938163 1846410 +19388 11718 +1939 2438 +19390 59651 +19390 72809 +193920 1793489 +193920 1828463 +193920 1854079 +193920 2362445 +193920 469572 +193934 212264 +193934 212266 +193934 212299 +193934 212301 +193934 2662538 +193934 502814 +193934 645741 +193934 92243 +193952 1920491 +193952 212433 +193952 2621213 +193952 2811424 +193952 320727 +193952 883812 +193952 914708 +1939536 1144912 +1939536 1764147 +1939536 1939542 +1939542 1144912 +1939542 1764147 +193963 10916 +193963 234198 +1939635 839002 +1939635 844160 +1939635 898392 +194 1042132 +194 1070145 +194 10898 +194 1104 +194 1152498 +194 115466 +194 1391855 +194 1475657 +194 1495914 +194 1548248 +194 15583 +194 170759 +194 1708750 +194 1828407 +194 192327 +194 2228087 +194 260948 +194 2645574 +194 2683015 +194 271870 +194 271874 +194 3260668 +194 355916 +194 397617 +194 426668 +194 42907 +194 44568 +194 45317 +194 526591 +194 64399 +194 64735 +194 7309 +194 77172 +194 791299 +194 838932 +194 843127 +194 844418 +194 92623 +194 944234 +1940 1626 +1940 36046 +1940318 1463707 +1940318 1822475 +1940318 2045236 +1940318 2624372 +19406 11983 +19406 250152 +19406 629134 +19406 801 +194080 967417 +194092 682820 +1941022 2616129 +194154 107945 +194154 268325 +194154 99472 +194167 56233 +194176 377296 +194176 44853 +1941871 1169408 +1941871 3056308 +194195 281706 +19420 219335 +194211 82431 +1942373 52833 +1942527 1942529 +19431 76567 +1943390 912386 +1943390 912404 +19435 173600 +19435 418512 +19435 842921 +194355 738266 +194395 31995 +194395 345216 +194395 99172 +1944 1383 +1944 155472 +19442 33891 +19442 36621 +194447 230753 +194450 494714 +194450 903050 +194457 122576 +194490 156255 +194490 288 +1945306 624749 +1945306 796211 +1945357 3500864 +1945434 12786 +1946280 2020467 +1946330 2427638 +194652 1580725 +194652 3287432 +194652 52818 +194667 2751 +194667 2755 +194667 27628 +194667 293019 +194667 45054 +194675 189821 +194675 194675 +194675 462816 +194675 66136 +194675 669685 +1946951 1946952 +194701 188330 +194714 165370 +1947294 781552 +194802 195011 +1948063 17329 +19484 19487 +1948403 1533524 +19485 4751 +1948812 1948804 +1949 114252 +1949 1183 +1949 1313980 +1949 1730464 +1949 32695 +1949 449473 +1949 972413 +194905 194906 +194905 94485 +1949084 1836939 +1949191 2670360 +1949315 252868 +1949371 2300565 +1949449 1929713 +194955 331352 +19499 19501 +1949929 1280897 +195013 69211 +19502 1340545 +19502 153980 +19502 293170 +19502 295028 +19503 84980 +19504 3236892 +19504 425658 +19504 434342 +19504 559739 +19504 84041 +1950605 2479738 +195076 20836 +1950815 269254 +1950815 834577 +1950815 841590 +1950887 1167875 +195105 149303 +195105 1898134 +195105 59651 +195106 195105 +195106 228874 +195106 54518 +1951093 623114 +195154 376028 +195164 1140638 +1951772 1409738 +1951772 490279 +1951773 1251923 +1951773 1409738 +1951773 1685019 +1951773 1951772 +1951773 2446086 +1951773 2446087 +1951773 333892 +1951773 490279 +1951773 526576 +1951773 628237 +1951773 718775 +1951773 931685 +195188 93927 +195215 203713 +1952402 2111718 +195258 196269 +195258 2331 +195292 2096808 +1952976 1264819 +1953513 2499318 +1953513 2511761 +1953617 842913 +195376 1615116 +19539 247716 +1953931 1016656 +1953940 215244 +1954046 1954086 +19541 19535 +195415 67618 +195425 10788 +195426 195427 +19543 2929 +195444 634731 +195469 22115 +1954767 586054 +1954767 658057 +19549 12246 +1954909 1054293 +1954909 210862 +195526 225690 +19554 1236112 +19554 1322663 +19554 146984 +19554 1789919 +19554 2549088 +19554 3641220 +19554 979622 +1955510 1034853 +1955510 2043981 +1955510 602946 +1955510 743753 +1955593 1955592 +1955654 2247603 +195602 119743 +195602 195602 +195602 228084 +1956061 1092204 +19561 15254 +1956222 105862 +195631 108573 +195631 25774 +195631 38472 +195631 67772 +1956383 1377659 +1956383 854227 +1956383 855063 +1956397 840069 +195661 275575 +195661 612452 +195667 8261 +1956894 1956895 +1957117 3203544 +195812 332794 +195813 236601 +195813 253447 +195813 312072 +195813 343389 +1958163 1007492 +1958163 1262335 +1958163 1299987 +1958163 1787565 +1958163 1958967 +1958163 1960760 +1958163 834227 +1958244 1572214 +1958244 2457407 +1958244 628737 +1958244 986613 +195831 210046 +195868 288358 +19590 775389 +19590 89693 +19590 962060 +1959267 3563532 +1959357 1217324 +1959385 1120497 +19594 1740 +19594 37078 +19594 430773 +19594 629380 +195945 173557 +19595 2422844 +1959809 3288015 +1959883 26955 +1959883 296745 +1959883 698927 +1959883 925650 +19599 407548 +195995 29806 +1960154 1050296 +1960154 1477103 +1960154 2236264 +1960154 227843 +1960154 842518 +1960154 873811 +1960154 938087 +1960478 2108971 +1960478 2563624 +19605 1603222 +19605 424 +19605 6092 +1960760 1958967 +1960760 834227 +1960978 417259 +1961 207118 +19611 28275 +196117 1479206 +196156 140061 +19616 353398 +19616 486152 +1961762 793064 +1961762 840462 +1961762 870793 +196189 335066 +196210 778318 +196269 2331 +19627 106698 +19632 121805 +19632 216448 +19638 3605 +196380 93448 +1963802 1498095 +1964161 1061521 +1964161 1964162 +1964161 696225 +1964161 833073 +1964161 833445 +1964161 869589 +1964162 1061521 +1964162 696225 +1964162 833073 +1964301 1353208 +1964301 3430309 +1964301 836184 +196444 119895 +196464 32491 +19647 109137 +19647 329808 +196475 26918 +1965234 932064 +196557 939866 +1966152 661411 +1966189 1173606 +19662 43993 +1966380 2230342 +196698 196697 +196713 196714 +1967142 1746490 +196758 275319 +196758 72881 +196759 975283 +1967949 2616778 +196795 347315 +196795 629020 +196800 1405062 +196808 1613493 +196808 220832 +196808 385486 +196808 38733 +196808 433047 +196811 196812 +196812 387137 +196814 1099339 +1968278 1410444 +1968278 438214 +1968278 467427 +196886 13949 +196886 15241 +1969037 1900234 +1969037 651504 +196910 103545 +196910 150080 +196910 61779 +19693 5314 +196930 196931 +196949 16557 +196949 62376 +19699 269323 +19699 39293 +19699 8993 +19700 451019 +19701 21918 +19701 82784 +1970139 1541140 +1970520 2643027 +197060 160240 +197060 517080 +197067 66847 +197069 98305 +1970694 1226027 +19707 77780 +197076 187629 +197076 231465 +197076 232277 +1970825 1970828 +197094 26912 +197112 570882 +1971566 1353796 +1971571 841593 +1971571 896995 +1971571 900979 +1971580 1040777 +1971580 1066447 +1971580 1341603 +1971580 1341604 +1971580 1430196 +1971580 1919176 +1971580 1931864 +1971580 1931865 +1971580 1971583 +1971580 577808 +1971580 870173 +1971583 1040777 +1971583 1066447 +1971583 1341604 +1971583 1430196 +1971583 1919176 +1971583 1931864 +1971583 1931865 +1971583 577808 +1971583 870173 +197168 86495 +1971843 252638 +197185 134703 +197215 195645 +1972356 156337 +197242 427867 +197255 1402292 +197311 173371 +197311 3227496 +197311 39279 +197311 43123 +197325 14974 +197325 198788 +197358 58686 +197376 371580 +197376 371583 +197384 4687 +197384 56518 +197411 188193 +197419 53760 +1974493 216140 +1974493 96123 +1974847 747014 +1975102 373377 +197560 64720 +197572 764991 +197576 2929 +19758 838 +1975828 2254255 +19761 118070 +19761 171448 +19762 36247 +19763 31757 +197634 181485 +1976428 2059949 +1976428 2196416 +197656 58962 +1976572 1153800 +1976572 904909 +19768 98603 +1976980 264998 +1977093 1053916 +1977093 2356605 +1977241 2483908 +1977281 1199457 +1977334 1219756 +19774 213590 +1977477 1849338 +1977477 2262477 +1977477 249584 +1977477 3039466 +1977477 3067086 +1977477 3219528 +1977637 1442729 +1977649 866337 +197790 3657491 +197812 126433 +197812 182673 +197816 195172 +19783 1075857 +197830 295614 +197830 426915 +197830 527475 +197830 944610 +197897 11572 +197897 12488 +1979057 1040169 +1979334 585781 +197939 197940 +197949 99384 +1979591 1822718 +1979591 943307 +19799 19799 +1980 72230 +1980140 1678910 +1980260 103038 +198041 252439 +198047 208442 +1980770 868 +1980898 444609 +198102 17971 +198113 286622 +19812 19812 +19812 219243 +19812 224273 +19812 2265 +19812 273534 +19812 639889 +1981322 1006066 +198167 505887 +19817 1671409 +1981853 1981855 +1981890 1645783 +1982 1123685 +1982173 1031522 +1982183 154862 +1982183 174246 +1982183 177201 +1982183 177202 +1982183 177209 +198223 509595 +198223 604144 +198228 1468741 +198228 1923298 +198228 589319 +1982526 326934 +1982778 862699 +1983 289 +1983 46893 +198319 291338 +1983471 1983470 +1983613 280029 +1983793 113047 +198427 105228 +198427 241617 +198427 99375 +198428 114258 +198479 139875 +198479 140556 +198479 1409541 +198479 153626 +198479 20703 +198479 288657 +198479 29895 +198479 401197 +198479 620841 +198479 77091 +198479 9373 +19849 177591 +19851 164748 +198512 8520 +198518 207006 +1985279 3087664 +198532 383432 +1985328 1374165 +198543 799390 +198544 206695 +198545 331219 +1985532 2163003 +198567 178698 +198567 297092 +198567 297093 +1986523 21147 +198662 117105 +198662 811686 +198663 794594 +198667 279813 +198683 368279 +1986913 545875 +19870 20580 +198705 74045 +198726 247832 +1987301 833765 +1987301 985192 +1987448 1987457 +19875 6508 +1987730 2931852 +19881 1273286 +19881 251355 +1988298 17396 +1988340 1988339 +198859 77522 +1988840 1503052 +1989 310 +19893 116217 +19893 257083 +19893 347301 +198935 141326 +198936 214408 +19895 142755 +19895 54523 +19895 96395 +19897 177071 +1990133 688034 +19902 1004072 +19902 223654 +199024 199023 +199025 1270619 +199025 1637989 +199032 144978 +199039 1200615 +1990492 1990493 +1990571 1654642 +19910 48474 +199101 773151 +1991091 106457 +19912 23595 +199154 772350 +19918 17428 +19918 196886 +199202 173615 +199202 177342 +199202 245741 +199202 260604 +199202 294410 +199202 296709 +199202 340650 +199202 466362 +199202 724445 +1992077 2727999 +199228 288457 +199228 622694 +199228 769995 +1992546 2045369 +1992956 2829770 +1993559 108566 +1993729 17035 +1993975 1339848 +19942 6814 +1994550 1841539 +199459 135829 +199459 1619318 +1994591 19619 +19946 135357 +199461 4681 +19953 182459 +19954 76974 +19954 83227 +19957 65794 +1995739 151421 +199631 245120 +199638 314807 +199638 314808 +1996426 1769257 +1996449 60028 +199648 132584 +199648 13332 +199648 166728 +199648 250870 +199648 32695 +19966 385698 +19966 59507 +1996755 977889 +1996867 2834011 +199690 2059586 +199690 499803 +1997006 847372 +1997006 935812 +1997008 1930226 +1997008 1997006 +1997008 847372 +1997008 935812 +199721 28327 +199752 249039 +199752 832189 +1997579 1997580 +1997741 1997740 +199781 4179 +199792 187134 +199792 214402 +199792 215650 +199792 292491 +199792 53818 +199818 199818 +199819 398223 +1998500 767484 +19988 236484 +1998849 1416655 +1998849 1932292 +1998849 1998850 +1998849 2015317 +1998849 626008 +1998850 1416655 +1998850 1932292 +1998850 626008 +1999 102457 +1999 244130 +19990 14238 +1999101 1999103 +1999264 397616 +1999264 869694 +199944 140788 +199944 207361 +1999445 626175 +1999445 833128 +20 447900 +2000049 961441 +200009 825022 +200009 989372 +200046 26205 +20006 35897 +2000629 2000632 +2000641 848873 +200101 231129 +200101 292389 +2001094 314733 +200133 43011 +200133 71565 +200146 200147 +200151 23657 +200151 293854 +200151 463275 +200151 52504 +200151 808629 +20016 224749 +20016 37126 +200167 1043941 +200167 1913339 +200167 220743 +2001670 192325 +2001670 226461 +200172 61066 +2001802 676458 +2001859 392158 +20019 267486 +200218 11787 +2002519 24059 +2002519 286 +200278 13778 +200278 1594168 +200278 179095 +200278 208460 +200278 2657651 +200278 2711183 +200278 365745 +200278 579765 +200278 707927 +200278 94789 +20029 5736 +2002940 1283928 +2003 55634 +200301 15787 +200301 203125 +200301 23624 +200301 342668 +200323 37722 +2003439 805900 +2003440 2003439 +2003440 805900 +200349 11433 +200349 200349 +200349 21503 +2003560 1604742 +2003560 2003562 +2003560 867835 +2003562 1604742 +2003562 867835 +2003570 696238 +2003657 1022025 +2003657 573239 +2003818 285484 +200384 295754 +200384 295755 +200402 951228 +200423 56419 +200451 311919 +200451 318789 +200452 360575 +2004540 454293 +200473 318485 +2004746 1595296 +2004746 2395978 +2004746 792683 +2004746 841357 +2004798 835113 +200545 234399 +200545 792540 +200566 250492 +20057 95738 +2005962 961093 +200603 1747628 +200603 1747630 +2006248 2006247 +2006344 1138898 +200645 200646 +200646 1047860 +200646 2629111 +200665 200665 +200665 240391 +200665 509129 +200670 1098227 +200670 1925274 +2007060 2656857 +20073 15462 +20073 166034 +20073 20226 +20073 3027644 +20073 48472 +200737 200738 +200737 200739 +200738 200739 +200742 285063 +200753 1342829 +2007581 2007580 +2007939 674068 +20080 212070 +200813 162564 +200813 1841563 +200813 471201 +200813 529726 +200813 716139 +200814 26955 +200814 32194 +200814 600882 +200815 145256 +200815 145272 +200815 64694 +200815 97545 +200817 1146034 +200817 2284146 +200817 832934 +200818 177582 +200818 254755 +200818 276970 +200818 282232 +200818 312163 +200818 314873 +200818 377693 +200819 455933 +200823 262623 +200823 28278 +200823 69508 +20085 243280 +200861 72358 +2008692 138932 +2008692 2928313 +2008692 356030 +20089 10876 +20089 206145 +20089 500736 +2009 128058 +2009 2111 +2009 9820 +200904 344484 +200905 1344518 +200908 351363 +2009408 1458934 +2009490 836349 +2009490 842641 +200955 12588 +200970 95384 +201 5288 +201 9976 +201020 31418 +201020 79211 +20104 11333 +201042 21494 +201071 197965 +2010753 166507 +201081 204606 +201111 301304 +201111 351033 +2011206 1085770 +201126 234362 +201162 27723 +201162 94794 +201185 11136 +201185 2149753 +201185 23825 +201185 478864 +20119 15654 +20119 178470 +20119 329601 +20119 550889 +20119 554810 +20119 7638 +2012 300342 +201206 168737 +2012073 1415872 +2012073 896995 +201228 332908 +20124 48275 +201288 209900 +201321 228347 +2013308 471592 +2013432 2013431 +2013443 2022670 +201351 13070 +2013781 1043922 +2013781 1097417 +2013781 696225 +2013781 728361 +2013781 871496 +2013781 890414 +2014141 1438525 +2014143 1438525 +2014143 2014141 +2014298 352262 +2014300 2014298 +2014300 2536561 +2014300 352262 +2014346 2014345 +2014432 1961762 +2014432 793064 +2014432 840462 +2014432 870793 +2014487 1091175 +20146 217972 +20146 48670 +20146 72965 +20147 292088 +2015 9166 +201505 15560 +201505 58247 +20151 1293050 +20151 1313556 +20151 1515964 +20151 2102320 +201520 5243 +201528 167557 +201531 105878 +201531 116683 +201531 375953 +2015317 1416655 +2015317 1932292 +2015317 1998850 +2015317 626008 +2015411 2015332 +201559 163297 +201571 11879 +201584 29207 +2016083 407748 +20161 20179 +20161 69139 +201625 596004 +2016294 2464719 +201632 268290 +201632 494377 +201633 201632 +201633 268290 +201633 494377 +201633 96266 +20165 5522 +2017092 1469804 +20172 124158 +20172 62464 +2017249 2337494 +2017249 2747311 +2017249 3523762 +201729 201728 +20176 122399 +20176 122400 +20176 12764 +201762 1392750 +201762 21139 +201762 238501 +201762 259299 +201762 322233 +201762 403038 +201762 5485 +201762 629020 +201762 701547 +201762 70622 +201762 942756 +201762 982087 +2017701 2001802 +2017884 29961 +20179 6422 +2017924 281957 +2018 148029 +2018 2169 +201806 236681 +20184 300977 +20185 222583 +20185 224506 +2018721 1943390 +2018721 2913543 +2018721 912386 +2018721 912404 +201878 24221 +201886 36528 +201894 924111 +20195 11321 +20195 24856 +201958 1414470 +201958 1757646 +201958 201958 +201958 2351299 +201958 3292174 +201958 365527 +201958 516516 +2019580 2412954 +20200 20199 +20200 20266 +2020464 1940617 +202071 3553524 +202071 3916617 +202071 703094 +202079 202087 +202092 1005267 +202092 11696 +202092 1269390 +202092 174100 +202092 1971332 +202092 253245 +202092 262940 +202092 26955 +202092 27519 +202092 336629 +202092 339755 +202092 472213 +202092 494994 +202092 535204 +202092 567502 +202092 617370 +202092 754894 +202092 767788 +202092 775295 +202092 809856 +202092 832962 +202092 835735 +202092 837570 +202092 848555 +202092 858384 +202092 912007 +202092 956250 +202093 649582 +202093 798940 +202094 134066 +202094 190370 +202094 214409 +202094 336629 +202094 366773 +202094 403639 +202094 446295 +202094 52786 +202094 539642 +202094 576617 +202094 978076 +202097 1822027 +202097 246387 +202097 333335 +202097 425028 +202097 458073 +2021033 2578785 +202113 154390 +202113 357645 +202113 36937 +202114 1481614 +202114 152564 +202114 220886 +202114 292418 +202114 370522 +2021261 2051160 +2021371 960038 +20215 104621 +20215 107940 +20215 15147 +202151 146373 +202151 531649 +202157 95995 +202179 629020 +202179 877201 +2021897 2450057 +202250 194 +202252 266389 +202255 2422119 +202258 415655 +202258 891868 +202258 891869 +20226 148337 +20226 20231 +20226 4071 +20226 48472 +202261 202262 +202262 1483950 +202262 54524 +202264 356089 +202275 3050219 +202275 3574506 +20228 201577 +202280 207243 +202298 342506 +202309 253093 +202309 255129 +202309 42757 +20231 20650 +20231 776306 +2023231 1063172 +202325 38034 +202332 202333 +202376 189613 +202421 58574 +202428 1096791 +202428 232956 +202428 316142 +202461 200052 +202461 213881 +202461 93249 +2024984 2286905 +2024984 2808573 +2024990 870832 +2024990 870833 +2025291 260744 +2025291 283122 +2025291 688716 +2025291 833697 +2025291 836585 +202562 12856 +202562 41121 +202562 45866 +202562 8459 +202574 202575 +2025747 1622797 +2025981 3576454 +202605 12887 +202605 95416 +202632 43948 +202700 52858 +202715 34502 +20272 196886 +20272 20283 +202729 681215 +2027433 1057453 +2027433 1346687 +2027433 839233 +2027433 859446 +2027433 926723 +2027497 841370 +2027537 2027536 +202812 103307 +202812 164111 +2028196 295598 +2028196 778856 +2028366 424754 +202906 31121 +202908 202362 +202917 35534 +2029707 1832858 +203079 1241777 +203079 191990 +20311 12537 +20311 292756 +203125 15787 +203125 23624 +203125 342668 +2031497 235146 +2031670 1210573 +2031686 95089 +2031713 2031712 +203214 3836 +2032163 1359438 +203235 92777 +20324 20272 +203294 195108 +203294 995787 +203326 895540 +203351 35086 +203351 63177 +2033710 2033709 +20338 154919 +20338 215559 +2033933 262940 +2033933 462603 +2033933 841590 +2033933 847489 +203394 811085 +203398 1411691 +2034239 2877709 +203446 471931 +2034707 2089823 +2034708 2034707 +2034708 2089823 +2034864 2381665 +2034868 2405200 +2035 107753 +2035 175741 +203509 207974 +203509 214748 +203514 1660359 +203553 3164541 +203554 134201 +203554 203696 +2035635 1969037 +203575 4232 +203584 594841 +2035861 2035862 +203602 1593120 +20361 459 +20361 6314 +2036172 171123 +20363 14587 +2036358 1204535 +2036358 193160 +20364 51596 +2036606 839500 +2036606 861507 +2036606 966252 +203662 448571 +203673 38201 +203696 134201 +203700 10355 +203700 844372 +2037228 1376377 +2037228 1485495 +203724 106892 +203735 284667 +2037437 2037438 +203749 14014 +2037502 864674 +203827 1477075 +203827 47023 +203899 267772 +203906 239223 +2039093 1654505 +2039093 1659317 +2039093 538924 +2039099 1478576 +2039099 2141433 +2039099 681200 +203917 203918 +203925 106387 +203944 1889999 +203944 284693 +203944 32216 +203944 335370 +203944 456717 +203957 191442 +204 185723 +204 21361 +204 670 +20400 15241 +20400 35217 +20400 7400 +204003 101966 +20401 15655 +20401 20276 +20401 20337 +20401 20403 +20401 25958 +20401 353583 +20403 113059 +20403 219671 +20403 508886 +20403 7678 +20404 20276 +20404 20401 +204050 3638 +204050 9385 +204063 1037518 +204063 224669 +204076 30439 +204076 322233 +204078 420686 +204086 275562 +204088 2717022 +204088 3539 +204097 469 +20412 10697 +20412 18692 +204132 33100 +204161 68069 +2041741 2041740 +204189 109437 +204189 143243 +204189 1603031 +204189 1721576 +204189 191278 +204189 241449 +204189 289120 +204189 383390 +204189 519215 +204189 700477 +20419 111582 +20419 118025 +20419 123867 +20419 1509010 +20419 237084 +20419 336243 +2042023 2042026 +204223 167440 +20427 113775 +20427 113778 +20427 113945 +20427 114963 +20427 122690 +20427 124396 +20427 1388380 +20427 153055 +20427 18382 +20427 20419 +20427 20427 +20427 20431 +20427 207722 +20427 208854 +20427 21504 +20427 216448 +20427 250146 +20427 279253 +20427 31535 +20427 357645 +20427 88071 +20431 124396 +20431 250146 +20431 88066 +20431 88071 +20431 88072 +204331 210853 +204331 222209 +20436 784933 +2044038 1261948 +2044359 1281957 +20448 258591 +2045025 2045026 +204513 71077 +204513 866974 +2045151 2776918 +2045236 1822475 +2045236 2624372 +204554 229761 +204554 479200 +2045659 1047947 +2045659 214410 +2045659 260081 +2045659 271691 +2045659 905213 +20457 11574 +20457 205538 +2045829 862648 +2046 22419 +20461 20457 +20461 251196 +20461 34671 +204617 60978 +204634 201020 +204634 79211 +204664 111437 +204664 210568 +204665 274865 +204686 44551 +20469 20467 +204691 137603 +2047034 1179182 +2047034 1481471 +2047034 3272744 +2047135 1475914 +20475 215559 +2047631 2047634 +204818 191337 +204818 93996 +20483 4982 +204834 195496 +204841 171146 +204846 1599 +2048827 180140 +2048827 181022 +2048827 2044778 +2048827 65049 +204891 250776 +204898 10916 +204898 1638553 +204898 1756015 +204898 27952 +204898 564162 +204898 869704 +2048984 582748 +2049 315747 +2049 8637 +20490 456985 +2049434 980145 +204944 2137890 +2049691 1869487 +205000 331351 +205002 149038 +2050318 83906 +205037 641520 +20505 20511 +205050 85125 +2050581 139777 +2050581 1804672 +2050581 1804673 +205109 3046011 +205127 473207 +205127 499946 +2051319 2329818 +205132 192473 +205154 31366 +2051697 340034 +205191 79085 +205201 126073 +205201 181011 +205201 92281 +205221 1313321 +205228 555709 +205253 33928 +2052858 1976704 +2052955 2037385 +2053 13572 +2053 15485 +2053 1705 +2053 19050 +2053 219 +2053 237663 +2053 4021715 +2053 565888 +2053 74298 +2053 7624 +2053 7939 +2053 92920 +20531 39379 +20531 93870 +205467 1103850 +205479 218086 +2054875 2869168 +2055225 1492705 +2055225 1523605 +205524 516289 +205524 575499 +205545 207088 +20558 26434 +205587 2035349 +205587 262940 +20560 30277 +20560 44128 +20561 163451 +2056108 1098227 +2056109 34955 +205612 263972 +20564 3483 +2056471 2051319 +205659 723689 +2056734 3530766 +205686 241224 +205687 70564 +20571 23298 +205725 405465 +205733 1229193 +205733 499708 +205733 606892 +205734 1167590 +2057828 1251923 +2057828 1685019 +2057828 1951773 +2057828 2446086 +2057828 2446087 +2057828 333892 +2057828 526576 +2057828 628237 +2057828 718775 +2057828 931685 +205808 148750 +205808 996496 +20581 2789689 +205812 1271812 +205812 1414535 +205812 1618848 +205812 203899 +205812 393662 +2058206 2614959 +2058286 224085 +20583 82226 +2058395 2058394 +20585 18977 +20585 258749 +20585 260898 +20585 272756 +20585 342874 +20585 542448 +20585 74210 +20589 13843 +20590 20592 +205907 2264 +20593 20590 +20593 424998 +2059379 1271344 +205993 573804 +2059949 2196416 +205996 147960 +205996 99636 +206018 255675 +206044 137602 +206049 2772256 +20606 46467 +206129 204513 +206129 256255 +206129 866974 +206133 475300 +2061801 1921596 +206199 2200276 +2062 92285 +20621 536002 +20621 696 +206215 1534772 +206254 1199492 +206254 227469 +206281 1046946 +206281 108566 +206281 1209009 +206281 1353073 +206281 1441830 +206281 1819155 +206281 262940 +206281 269254 +206281 324481 +206281 377139 +206281 406271 +206281 406285 +206281 442174 +206281 448007 +206281 454293 +206281 456926 +206281 523553 +206281 532086 +206281 532418 +206281 532425 +206281 539272 +206281 620186 +206281 630844 +206281 688716 +206281 703271 +206281 712270 +206281 715381 +206281 736606 +206281 809856 +206281 836165 +206281 838588 +206281 842233 +206281 843127 +206281 846180 +206281 855059 +206281 859448 +206281 946199 +206281 95537 +206281 95544 +206281 95546 +206281 981904 +2063 176016 +2063 199600 +2063 8277 +206325 170358 +2063319 388830 +2063727 13111 +206415 383281 +206427 613034 +206444 421773 +2064509 1843969 +2064584 1265172 +206473 24415 +2065241 3335654 +2065466 2063058 +2065570 2065589 +2065589 247176 +2065639 252820 +20657 13358 +2065847 2336696 +206655 156726 +206655 43391 +206688 1679534 +2067392 15475 +2067392 2673764 +2067392 43841 +2067403 1139590 +2067403 2067404 +2067404 1139590 +2068048 1233375 +2068048 262940 +2068048 397620 +2068048 527161 +2068048 700443 +2068048 837661 +2068048 844418 +2068072 192325 +2068143 575612 +2068346 522209 +2068346 522210 +2068737 2714862 +20691 1044792 +20691 1044803 +20691 202611 +20691 224854 +20691 22946 +20691 290134 +20691 33726 +20691 567208 +20691 567209 +20691 759896 +20700 375225 +20701 925588 +2070196 2697058 +20703 131998 +20703 235146 +20703 2403850 +20703 25874 +20703 2730899 +20703 3329880 +20703 485047 +20703 52818 +20703 54520 +20703 65317 +20703 91590 +20703 93921 +2070422 486432 +2070745 1140595 +20710 130593 +207103 28100 +207103 69200 +207103 783018 +207125 207130 +207137 60294 +20717 118127 +207173 20188 +207177 13029 +207189 126035 +207191 350933 +2072 25854 +2072078 212363 +2072181 1331872 +2072405 192192 +2072405 289089 +207297 1123685 +207297 1982 +207300 5531 +207310 555263 +207310 828277 +207315 170527 +207315 61867 +207341 1346907 +207355 104447 +2073624 681275 +2073625 791826 +2074 10001 +2074 10032 +2074 101534 +2074 148 +2074 17080 +2074 2075 +2074 2096 +2074 320 +2074 33037 +2074 37355 +2074 37359 +2074 5467 +2074 5486 +2074 6753 +207433 361539 +207437 234014 +207449 333534 +207470 106187 +207470 2176041 +207470 380858 +207470 410333 +207470 503075 +2075 1135192 +207505 915613 +207517 103097 +207517 1125781 +207517 1302921 +207517 140923 +207517 15147 +207517 15241 +207517 15473 +207517 194625 +207517 19912 +207517 20226 +207517 20660 +207517 215559 +207517 23595 +207517 32241 +207517 3293 +207517 35217 +207517 48370 +207517 48473 +207524 231033 +20757 54360 +207574 1376509 +207574 18802 +207574 2091302 +207574 2138124 +207592 216239 +2076 562331 +207615 620820 +20762 31645 +2076251 2238752 +2076276 2095467 +2076276 2949944 +207643 255954 +207654 301256 +2077 121231 +2077 12387 +2077 1381639 +2077 39507 +207714 751 +207719 34568 +207722 216448 +207722 88071 +2077325 2351183 +2077382 2776105 +20774 85580 +207744 89746 +2077458 891202 +207757 230619 +207757 362084 +20777 105594 +20777 28560 +207809 207808 +20784 38544 +2078470 1759378 +207864 207863 +207905 251434 +207909 8162 +2079156 1022025 +2079156 1300812 +2079156 1374321 +2079156 1671768 +2079156 2545309 +2079156 2545310 +2079156 269254 +2079156 299702 +2079156 473837 +2079156 832917 +2079156 837535 +2079156 933757 +2079161 115469 +2079161 258078 +2079161 567511 +207945 1009232 +207945 1160362 +207945 1290645 +207945 1381485 +207945 1825132 +207945 212299 +207945 2483583 +207945 361608 +207945 393383 +207945 406423 +207945 415725 +207945 446471 +207945 610802 +207945 646859 +207945 754958 +207945 826720 +207945 832962 +207945 832995 +207945 834397 +207945 834640 +207945 834643 +207945 841441 +207945 861274 +207945 866595 +207945 909598 +207945 914150 +207945 92243 +207945 961746 +207945 966368 +207946 55368 +2079492 703271 +2079577 998085 +207964 31215 +207968 1535518 +207968 222384 +207968 344166 +207968 413127 +207968 869054 +207968 985935 +207982 292005 +207982 61083 +2079893 2110386 +20801 1163926 +20801 3079028 +20801 3767199 +208025 3158427 +208025 581640 +20803 54789 +20803 56752 +208043 179016 +208043 403019 +208043 493854 +20805 267783 +20805 329028 +20805 363164 +20805 487291 +20805 799 +20805 942756 +20805 95623 +208051 75305 +208076 133869 +208076 174065 +208095 1090778 +2081054 2701044 +208121 82211 +208130 1241563 +208130 1283618 +208130 12929 +208130 327234 +208130 622822 +2081587 508798 +208179 41237 +208220 1126779 +208220 95861 +2082254 1658185 +208255 108748 +208267 125379 +208267 282137 +208298 857234 +2083140 2173270 +208329 14943 +2083888 773262 +20846 50561 +20846 50562 +20848 384575 +20848 515751 +208484 94999 +208539 110656 +2085393 260744 +2085393 283122 +2085394 1021942 +2085394 1360089 +2085394 1611690 +2085394 1629562 +2085394 1787676 +2085394 2186352 +2085394 835088 +208561 208560 +208564 3385 +208579 1559913 +208633 234422 +208633 26955 +208633 849474 +208684 201307 +208684 224312 +208684 277716 +208684 395643 +2087306 2753858 +208750 328543 +208751 68402 +208759 433083 +208759 9179 +208784 386094 +208834 87038 +208854 216448 +208864 1004729 +208864 230223 +208864 77703 +2088979 1813493 +2089 25974 +20890 206853 +208918 295434 +208936 165442 +208959 208958 +20897 45052 +2089744 1717018 +2089744 2837958 +2089744 2975387 +2089744 3649997 +2089744 567073 +209015 390022 +2090319 1930477 +2090319 2387746 +2090431 374231 +209045 849365 +209054 335734 +209060 30991 +209060 93159 +20907 215254 +209085 268963 +209085 310367 +2091 219675 +2091 3511 +2091 497979 +209132 133531 +209136 1070194 +209136 1124596 +209136 1124597 +209136 1124598 +209136 15787 +209136 279684 +209136 320925 +209161 23083 +20917 166728 +209173 11015 +209173 1348475 +209173 14337 +209173 166506 +209173 1799477 +209173 2009722 +209173 2187 +209173 26609 +209173 75711 +209181 150927 +209214 683743 +209222 224159 +2092459 68410 +209246 1456712 +2092634 2092635 +2092690 1886171 +209277 829052 +209286 181022 +209294 109397 +209294 132084 +209294 194 +209294 212524 +209294 383281 +209294 722712 +2093 238001 +2093 80883 +209301 209302 +2093055 2093056 +2093218 360575 +2093291 1041969 +2093291 1064108 +2093291 435555 +2093291 517158 +2093291 573239 +2093291 696192 +2093291 833667 +2093291 833886 +2093291 839514 +2093291 854161 +2093291 855072 +2093291 858964 +20933 31009 +2093361 674840 +2093723 746147 +2093921 254937 +209415 17965 +209417 11651 +20942 53341 +209469 112977 +209469 165262 +20947 114297 +20947 11433 +20947 1147 +20947 18382 +20947 31545 +209479 120307 +20951 16968 +2095232 268361 +209529 44675 +20953 1910959 +2095470 1000280 +2095488 359928 +2095488 641874 +2095488 804789 +20956 1371065 +20956 582273 +20956 794883 +2095693 821231 +20957 101096 +20957 16534 +20957 17594 +20957 231785 +20957 28795 +20957 4096 +20957 86094 +20958 101853 +20958 113663 +20958 202318 +20958 20958 +20958 214271 +20958 227276 +20958 232913 +20958 285416 +20958 30636 +20958 5521 +20958 63579 +20958 64590 +20958 8349 +209598 209595 +209598 310881 +2096 10472 +2096 13667 +2096 17080 +2096 2096 +2096 33037 +2096 37355 +2096 377449 +2096 46667 +2096 5467 +2096 57841 +209614 106576 +209614 119743 +2096496 411620 +209662 575062 +209690 2106209 +209690 21742 +209690 331528 +209695 16680 +209695 19662 +209695 43993 +209696 4063 +209696 42138 +2097054 2097055 +2097054 911484 +2097055 911484 +209748 90037 +2097539 2659464 +2097895 2914538 +209808 364124 +209808 84675 +209819 795272 +20982 178790 +2098343 941864 +20985 181638 +20985 680514 +209874 10780 +209874 541114 +209884 1077495 +2098907 2098908 +20991 429640 +20991 49624 +20991 56800 +2099356 448007 +2099356 448010 +2099356 956952 +209976 21474 +2100015 333519 +210011 36931 +210054 895561 +2101535 52866 +2101599 1949309 +2101599 282591 +210166 75156 +210170 1365178 +210170 1365179 +2101804 1179845 +2101804 3821904 +21019 4146 +210204 244955 +210219 301067 +210244 1200381 +210258 51224 +210262 16795 +2102752 106452 +2102860 2102859 +210316 110844 +210316 211211 +21032 25262 +21032 264439 +2103348 1751813 +210363 87420 +210389 137942 +210389 151311 +210389 201958 +210389 365527 +210389 516516 +210389 547183 +210389 848328 +21039 450498 +210391 3639 +210413 99151 +210416 119743 +210420 230641 +2104312 262358 +2104312 776673 +2104312 835070 +2104312 957152 +210432 3098078 +210432 375953 +2104675 49742 +2105051 189193 +210545 1539315 +210545 25406 +210545 319191 +210545 38503 +210545 511851 +210555 42015 +210559 243748 +210559 32697 +210559 62922 +21056 388819 +21058 18382 +21058 20427 +21058 228852 +21058 234138 +21058 31535 +21059 108159 +21059 15346 +21059 18435 +21059 8339 +21059 8352 +210596 210608 +210604 85597 +210605 193544 +210605 210604 +210605 85597 +210617 767891 +2106209 21742 +210623 318192 +210632 357923 +21068 49644 +21068 5081 +21070 218700 +21070 46324 +2107387 242200 +210741 1100 +210741 17533 +210741 45802 +2107466 1953513 +2107466 2511761 +210757 49719 +210757 499176 +210757 982819 +2107647 1551503 +2107675 3668198 +21078 31704 +210784 2515260 +210793 14646 +210793 22028 +210793 231095 +2107930 2982688 +210799 1065010 +2108 12869 +2108 218565 +2108 255665 +2108 3550 +2108 42708 +2108 527838 +2108 65625 +210850 122439 +210853 222209 +210854 204331 +210854 210853 +210854 222209 +210862 181022 +210862 210878 +210862 232956 +210875 36100 +210892 108209 +2109 2110 +2109 263118 +21093 1340185 +2109485 1370653 +2109485 256972 +21097 39940 +2109867 739284 +2109906 1548282 +2110188 2914902 +211036 143024 +2110432 410873 +2110612 2110613 +2110612 2110614 +2110614 2110613 +211065 232065 +211065 248661 +211068 256332 +2111 276757 +211101 127037 +211101 551980 +211102 85597 +211103 27754 +2111140 2646200 +211123 10472 +211123 61593 +2111261 796454 +2111321 2111320 +211140 211139 +211141 7167 +211155 553340 +2111735 1816650 +211211 37906 +211245 255665 +211245 505650 +211245 505651 +211245 768934 +21125 231460 +21125 69210 +211262 122603 +2112736 1642954 +21128 192632 +21128 5682 +2113 2114 +2113 2172 +2113 2295 +2113 275094 +2113 3074 +2113 474643 +2113 483196 +2113001 359504 +21137 52638 +21137 744486 +21137 85061 +21142 21139 +21142 81792 +2114604 2114691 +211461 1161789 +211461 1226706 +211461 1876268 +211461 291641 +211461 47464 +2114629 919455 +211465 1422804 +21147 1076551 +21147 70870 +2114791 1350164 +21148 23715 +2115 304 +2115 3497 +2115 6667 +2115263 2375619 +211529 13732 +2115681 2402068 +21157 3028 +2115800 1022025 +2115800 1064107 +2115800 1300812 +2115800 1374321 +2115800 1671768 +2115800 2079156 +2115800 2545309 +2115800 2545310 +2115800 269254 +2115800 696253 +2115800 744723 +2115800 832917 +2115800 861805 +2115800 933757 +211583 211439 +211593 3550 +2116 10937 +2116 119661 +2116 1395764 +2116 16677 +2116 1732865 +2116 1831755 +2116 202099 +2116 2116 +2116 213991 +2116 23973 +2116 285 +2116 4742 +2116 845450 +2116 909972 +211605 253876 +2116123 52911 +211619 2607537 +211676 1498822 +211684 30998 +211689 113001 +21169 57466 +2117211 420686 +21173 45071 +2117615 2108499 +211774 258082 +211790 861586 +211810 217831 +211810 217832 +2118175 1625479 +211828 184855 +211828 45835 +2118314 1228955 +211835 1090 +211835 409899 +211835 87774 +2118351 929395 +211845 362684 +2118542 2329208 +2118677 2179272 +2118677 2179274 +2118677 776858 +2118677 835392 +2118677 835396 +211882 15629 +2119273 1473319 +2119626 3261894 +2119813 288826 +211996 223793 +211996 896118 +212000 1099152 +212000 212001 +212000 2363984 +212000 394776 +212001 177342 +212001 2363984 +212001 394776 +212001 490279 +212001 490290 +212002 163953 +212002 258079 +2120022 2572700 +212034 581512 +21207 3479 +212070 241931 +212070 242072 +212070 35705 +212070 3947 +212070 4401 +212070 56129 +212070 6264 +212076 1417496 +2120807 1117906 +212084 26847 +2120876 2133464 +21209 9972 +212092 1036076 +212092 624825 +21210 1781 +212142 239305 +2122035 2122036 +2122149 2122150 +212255 2862019 +212255 3376298 +212255 466390 +2122600 628737 +212263 170597 +212264 212266 +212264 212299 +212264 212301 +212264 2662538 +212264 502814 +212264 92243 +212266 212299 +212266 212301 +212266 92243 +2122925 2053808 +212295 344166 +212295 361595 +212295 626175 +212295 869054 +212295 890223 +212299 1004477 +212299 212000 +212299 212001 +212299 212301 +212299 2363984 +212299 32180 +212299 394776 +212299 610798 +212299 663387 +212299 814407 +212299 92243 +212300 1311998 +212300 292493 +212300 293022 +212300 323246 +212301 1015406 +212301 1450655 +212301 65807 +212301 744724 +212301 95544 +2123220 308384 +2123220 985811 +2123355 922565 +212337 21059 +2123557 1113594 +2123557 1572214 +212361 1080471 +212361 212364 +212363 205916 +2123715 1864205 +212372 365714 +212397 116830 +212397 212403 +212397 212405 +212400 91587 +212403 116830 +212411 212410 +2124113 834057 +2124113 838200 +2124113 838203 +212433 1089536 +212433 289198 +2124691 48997 +212478 6562 +2124984 1315847 +2125 2067 +2125 2184 +2125 2364 +2125 857 +2125 866 +212524 80402 +2125331 1380528 +2125331 602861 +2125425 326677 +2126398 1201210 +2126398 78659 +2126431 1071242 +21267 80122 +2127418 2290526 +212743 169898 +212743 229094 +212777 16713 +212786 1750013 +212786 2673854 +212786 461862 +2128032 436165 +2128032 704625 +212809 13837 +2129013 3101195 +2129013 996443 +21292 31431 +2129325 2129329 +2129597 1211021 +2129597 852709 +2129597 861690 +2129597 92243 +2129597 944044 +2129597 997191 +2129819 1183639 +2129819 1239660 +2129819 1430197 +2129819 2129819 +2129819 538821 +2129819 577808 +2129819 837550 +2129819 837674 +2129819 852711 +2129819 855065 +2129819 882018 +2129819 882019 +2129819 889836 +212995 22428 +212995 224983 +212995 578379 +213017 848271 +2130303 1739627 +2130303 1739630 +2130303 1739632 +2130303 2129819 +2130303 837674 +2130303 852711 +2130401 2130402 +213059 139735 +2130988 641400 +213108 505366 +2131142 759160 +213143 33752 +21315 802977 +2131661 1048497 +2131661 309514 +21317 21326 +213198 213199 +2132017 1934200 +213211 1273284 +213211 43405 +2132260 2128757 +213285 100405 +2132881 1533682 +2133 188196 +2133 241461 +2133 248538 +2133 251394 +2133 26580 +2133 4243 +21330 85514 +2133232 2513120 +213326 296359 +2133304 2133308 +2133304 2133309 +2133304 2133310 +2133306 2133304 +2133306 2133308 +2133306 2133309 +2133306 2133310 +2133309 2133308 +213331 29784 +2133310 2133308 +2133310 2133309 +2133357 2133358 +2133464 2634687 +21338 1175622 +21338 756437 +2133832 22910 +213385 213386 +21340 17364 +213422 214578 +213422 350605 +213451 101500 +213451 239446 +2134823 1169515 +2134823 1245031 +2134823 1245033 +2134823 1278653 +2134823 3248391 +2134823 838932 +2135 13439 +2135 1665 +2135 2365 +213512 238777 +2135202 59656 +2135202 711893 +213532 475487 +213533 106331 +213551 67207 +21358 12751 +21358 21357 +21358 323401 +2135906 2135904 +2136017 3432705 +213608 138067 +213608 768329 +213608 92787 +213614 757924 +2136205 125260 +2136205 125261 +2136363 1031800 +2136477 2065847 +2136477 2336696 +21369 759369 +2136973 1116650 +2137165 2064006 +2137413 2137412 +213753 1100480 +213753 1486500 +213753 2166243 +213753 236948 +213753 310013 +2138 1125827 +2138 26395 +2138 34092 +2138 428544 +2138 43359 +2138 560791 +2138 807622 +2138 8558 +2138 98025 +213813 207317 +2138226 134019 +2138226 2507004 +2138781 2075615 +213881 230453 +213886 78776 +2138988 2138990 +2139063 3784992 +2139063 3790857 +2139063 3913012 +213913 203219 +213918 29821 +213918 82211 +213929 61671 +21393 62382 +213972 213971 +2139734 1947607 +213974 149846 +214 1263 +214021 17262 +2140268 1713720 +2140268 2140267 +2140268 2140269 +2140269 1713720 +2140269 2140267 +214033 234852 +214040 1176344 +214040 668949 +2140758 2140757 +2140848 381500 +2140848 60023 +214088 523681 +214104 152098 +214104 272157 +214104 304114 +214104 649836 +214104 90113 +2141129 2469062 +214140 190370 +214140 202094 +2141433 1478576 +2141433 681200 +214163 212255 +214163 3275388 +214163 865304 +2141820 2141821 +2141820 289323 +2141820 445532 +2141820 446105 +2141820 696215 +2141820 796211 +2141821 289323 +2141821 445532 +2141821 446105 +2141821 696215 +2141821 796211 +21419 41964 +2141902 1678787 +2142 89107 +214233 2063319 +214233 388830 +214236 1837292 +214236 1837294 +214236 2527295 +214242 258407 +214271 232913 +2142756 835518 +2142756 855061 +2142756 855066 +2142756 862697 +2142756 937077 +214299 192683 +214333 914216 +214405 1187662 +214409 366773 +21441 24304 +214410 260081 +214410 271691 +214410 284206 +21445 14821 +21445 151787 +21445 163474 +214459 145488 +2145259 132084 +214535 630161 +214595 953414 +2146 28308 +2146 56095 +2146 8239 +214625 29230 +214625 32009 +2146482 2981971 +2146482 3173143 +2146536 2146535 +214656 80194 +2146674 896913 +214668 1561558 +214669 1387602 +214669 14361 +214669 1538 +214669 16768 +214669 781488 +214669 95429 +2147198 223233 +214748 240680 +214748 240681 +214748 344779 +214748 803465 +214751 76952 +214797 1934636 +214797 655077 +214821 253731 +2148290 466777 +2148650 54963 +214913 1094052 +21494 113895 +21494 21494 +21494 25003 +21494 44834 +21494 970650 +214943 1389500 +214943 18440 +214943 28008 +214943 355443 +215021 215020 +215033 136131 +215033 152684 +215033 325649 +215033 325650 +21504 113778 +21504 114297 +21504 131283 +21504 421089 +21504 47256 +21504 60405 +21504 662341 +21505 762307 +21509 88995 +215092 50997 +215092 76894 +21513 180609 +215145 16388 +21517 125511 +21517 62083 +21517 85276 +21517 93610 +215179 194080 +215179 2116 +215179 330313 +215179 344215 +215179 771018 +215201 626826 +21524 125388 +21524 21508 +21524 638466 +21524 995736 +215246 172763 +215246 973066 +21525 98689 +215264 215891 +2153 537213 +215301 1894027 +215301 774130 +2153438 2170393 +215374 329514 +215379 188810 +21538 109676 +215380 263972 +2154023 2154022 +2154023 2154024 +2154024 2154022 +215411 102373 +2154247 2850556 +215495 215495 +215495 373950 +215495 373951 +215495 5825 +215495 640910 +2155036 2155038 +215505 246129 +215505 43128 +2155351 834578 +215538 32216 +215559 103097 +215559 15640 +215559 18187 +215559 18473 +215559 20635 +215559 20654 +215559 23409 +215559 28750 +215559 350901 +215559 67481 +215560 383295 +215585 37109 +215589 76211 +2156 710109 +21560 67930 +215605 2058179 +215650 187134 +215650 292491 +215650 53818 +215663 933368 +21569 109039 +21569 109040 +21569 68402 +215690 215691 +2157 696 +2157155 157956 +215720 278966 +215729 1579256 +2157349 1303811 +215766 283343 +2157904 224503 +2158 1749266 +21582 2264 +2158405 775051 +215845 27012 +215845 84265 +215848 109392 +215848 126111 +215848 180456 +215848 216703 +215848 216706 +215848 275916 +215848 278266 +215848 278267 +215848 278269 +215848 278272 +215848 799086 +215848 920559 +21587 61422 +215885 262708 +2159 651 +215900 1764951 +215900 76026 +21591 545545 +21591 92882 +2159617 339736 +215974 1265869 +215974 142981 +215974 572127 +2159874 644284 +215993 17594 +215993 40445 +215993 44958 +215993 50997 +215993 5682 +216 29358 +216 29546 +216 51669 +2160 1390230 +2160 1531921 +2160 2160 +2160 2320 +2160 344215 +2160 372109 +2160 509697 +216000 202493 +2160177 324204 +216022 93321 +216089 2189560 +2161 288457 +2161 3503 +216140 1010199 +216140 1030674 +216140 1032227 +216140 1042892 +216140 1053915 +216140 1053916 +216140 108565 +216140 115466 +216140 1192372 +216140 1263566 +216140 1490119 +216140 1508496 +216140 153980 +216140 1692113 +216140 1762555 +216140 194 +216140 2000915 +216140 2228087 +216140 260744 +216140 262940 +216140 271870 +216140 2736228 +216140 27519 +216140 279614 +216140 283122 +216140 283123 +216140 296409 +216140 342541 +216140 361074 +216140 361807 +216140 368137 +216140 375279 +216140 377139 +216140 388185 +216140 394778 +216140 395913 +216140 397617 +216140 406271 +216140 406273 +216140 406278 +216140 406281 +216140 406283 +216140 406285 +216140 415720 +216140 424576 +216140 448010 +216140 454293 +216140 454981 +216140 456926 +216140 472036 +216140 490279 +216140 495004 +216140 497542 +216140 517163 +216140 526590 +216140 538821 +216140 547969 +216140 547971 +216140 552196 +216140 598601 +216140 627442 +216140 696225 +216140 696260 +216140 703268 +216140 703271 +216140 712500 +216140 744724 +216140 754894 +216140 754974 +216140 761118 +216140 779502 +216140 809856 +216140 824202 +216140 832905 +216140 832915 +216140 832917 +216140 832934 +216140 833128 +216140 833169 +216140 833181 +216140 833560 +216140 833697 +216140 833698 +216140 833986 +216140 834226 +216140 834378 +216140 835190 +216140 837584 +216140 837615 +216140 841355 +216140 842132 +216140 842888 +216140 843529 +216140 850891 +216140 855790 +216140 859452 +216140 867946 +216140 867995 +216140 873814 +216140 882946 +216140 883808 +216140 888854 +216140 891595 +216140 895152 +216140 896978 +216140 908890 +216140 944142 +216140 95537 +216140 95543 +216140 95544 +216140 959375 +216140 961400 +216140 966985 +216140 970416 +216140 999914 +216141 1015406 +216141 1184041 +216141 1196183 +216141 1353073 +216141 1731777 +216141 274531 +216141 282641 +216141 282643 +216141 359068 +216141 361592 +216141 361595 +216141 361601 +216141 361603 +216141 361608 +216141 361625 +216141 374007 +216141 424108 +216141 480804 +216141 567208 +216141 567209 +216141 748994 +216141 749007 +216141 759868 +216141 759896 +216141 833179 +216141 865377 +216141 867199 +216141 867201 +216153 216155 +216154 216153 +216154 216155 +216156 368760 +216177 5210 +216182 106351 +2162262 2162264 +216235 254755 +2162663 267717 +216270 207191 +216270 263477 +216293 324286 +216294 1194037 +216294 1411632 +216294 1758271 +216294 1758273 +216294 353290 +216294 377934 +216294 454044 +216294 599266 +216313 24023 +2163175 1653767 +2163175 1653770 +2163175 1798899 +2163175 1798900 +2163175 455945 +216319 203351 +216319 35086 +216367 425809 +216388 2207337 +216403 44494 +216403 99767 +216420 820862 +216448 124396 +216448 155771 +216448 165268 +216448 176526 +216448 20431 +216448 222827 +216448 327880 +216448 335774 +216448 88071 +21647 17389 +21648 11432 +21648 708466 +21648 8364 +21654 30308 +2165400 1330365 +2165400 2272363 +216584 154559 +2165883 3238989 +21659 111598 +21659 111601 +216602 179363 +21661 983 +2166218 1327537 +2166484 2984899 +2166503 2048172 +21667 11804 +21667 15666 +216703 109394 +216703 126111 +216703 799086 +216706 278266 +2167189 2657910 +216721 220187 +2168 1166964 +2168 1633 +2168 172490 +2168 2018 +2168 204523 +2168 220198 +2168 281 +2168 446483 +2168 588476 +2168 594516 +2168 623870 +2168 6748 +2168 698795 +2168 765229 +2168076 1426616 +216809 218651 +216815 399040 +216847 1453083 +216861 628302 +2168852 60556 +2168852 622776 +216897 27012 +216897 413602 +216917 53006 +216919 341520 +216987 167178 +216987 218587 +216987 264377 +21699 10465 +21699 10466 +2169970 2260585 +217 16896 +217 406328 +217 4449 +217 481418 +21704 710296 +217060 217059 +2171 26404 +2171 577999 +217104 189074 +217112 129676 +217129 162870 +217129 276591 +217129 856151 +2171301 2064287 +2171347 2912570 +21714 16796 +217147 173141 +217147 61831 +21715 70351 +21715 77180 +2171553 2171465 +217158 117267 +217162 120883 +2172 13706 +2172 1545 +2172 23096 +2172 312 +2172 8410 +217253 21742 +217253 52835 +217254 1054378 +2173 2332 +21731 26918 +2173259 2772397 +21735 4492 +2173804 1169515 +2173804 1245031 +2173804 1245033 +2173804 1245035 +2173804 1278653 +2173804 1571667 +2173804 1571669 +2173804 2173805 +2173804 3248391 +2173804 837527 +2173805 1169515 +2173805 1245031 +2173805 1245033 +2173805 1245035 +2173805 1278653 +2173805 1571667 +2173805 1571669 +2173805 3248391 +2173805 837527 +217385 217384 +2174 13332 +2174 16079 +2174 163229 +2174 356793 +2174 42262 +2174 4255 +2174 57089 +21741 289798 +21741 99859 +217411 179494 +217411 252732 +217411 294222 +217419 10389 +21742 1065010 +21742 1096738 +21742 10990 +21742 11213 +21742 112751 +21742 1183829 +21742 137880 +21742 168693 +21742 180140 +21742 38661 +21742 45046 +21742 51369 +21742 52835 +21742 9965 +21743 10574 +21743 21743 +21743 6917 +217455 1581729 +217456 454293 +2174622 1196970 +21747 1538 +21747 241910 +21747 3049 +21747 3657 +21747 405 +21747 40976 +21747 647680 +21747 8260 +217487 333754 +217492 128173 +2175 460171 +217529 241801 +21753 3178 +21753 45114 +21753 8728 +2175450 2192239 +21755 104618 +21757 422231 +217588 114092 +2176041 380858 +217629 227082 +21763 115864 +21763 146052 +21763 153626 +21763 41891 +21763 498171 +21763 91898 +2176319 1677649 +2176319 38661 +21764 88495 +2176594 859024 +21767 11070 +21767 162056 +21767 2466367 +21767 398109 +21767 49312 +21767 558092 +2176711 2176712 +217672 217672 +217672 234184 +21769 115864 +21769 2637829 +21769 41891 +21769 49803 +21769 84041 +21769 91898 +2176903 779780 +2176903 836106 +217698 1369 +217702 126264 +217705 130476 +2177063 3123417 +217719 217718 +217719 254743 +217748 204371 +217777 312751 +217800 217801 +217801 218915 +217832 217831 +217844 443959 +2178814 2178817 +217884 217885 +217885 98498 +2178955 250568 +2179005 2179008 +21792 2992 +2179271 2205217 +2179272 2179274 +2179272 776858 +2179272 835392 +2179272 835396 +2179272 95537 +21794 7062 +2179962 1210098 +2179962 919915 +2179980 2137431 +218 2017 +218 251199 +218 281 +218 4954 +218016 92307 +21802 269149 +21802 269150 +218044 673401 +218057 16715 +218087 4848 +218092 3543 +218140 1618539 +218140 1823267 +218140 222253 +2181517 2107185 +218169 26101 +218169 3822 +218169 537846 +218169 54918 +218175 64575 +2181767 545306 +2181847 2807539 +218216 1179646 +21823 270893 +218235 396553 +218238 330621 +218275 219497 +218275 224931 +218275 256490 +218310 218309 +2183493 2183495 +2183494 2183493 +2183494 2183495 +218355 205922 +218386 647226 +2183925 1053619 +2183925 1426021 +2184 6004 +2184 84497 +2184 895114 +218417 113663 +218417 11791 +218417 118939 +218417 119743 +218417 20958 +218417 209614 +218417 218417 +218417 799231 +21848 36738 +21849 328376 +2185344 3637479 +218569 212034 +218569 581512 +218587 572716 +2185913 2117434 +2185913 271874 +2186 235219 +2186 2686 +2186 2782920 +2186 2951218 +2186 92264 +2186352 1360089 +2186352 1787676 +2186352 835088 +2186403 2186404 +21866 240164 +2186955 2186953 +2186956 2186953 +2186956 2186955 +2187 1497 +2187 33567 +2187 3870 +218772 261594 +218800 2103348 +218801 1497718 +218809 340829 +218836 1538794 +2188366 2623882 +2188366 3169436 +218860 1540079 +218860 218859 +218860 218860 +2188633 2227044 +218922 1537388 +218923 559497 +2189478 259338 +218951 969160 +218966 222066 +219 1705 +219 54144 +219035 621527 +21906 137750 +21910 14484 +21910 4093 +219103 265648 +2191088 2191089 +21913 41233 +219134 219136 +2191654 1510752 +219186 108249 +219186 1719904 +219186 197311 +219186 372197 +219186 467945 +21920 21921 +21920 50514 +219204 908622 +219213 11491 +219213 14481 +21923 112154 +2192410 1084800 +2192498 1979478 +2192545 1765770 +219272 28664 +219316 67572 +2193174 1599112 +2193174 2275321 +2193174 419017 +2193174 609735 +2193177 1554706 +219319 559952 +219334 534518 +219339 893216 +219353 11390 +219353 700585 +219356 410623 +219357 219356 +2193682 696188 +2193682 838929 +219369 639638 +2193844 1187662 +2193844 1690934 +219389 257166 +2194 14397 +2194 326403 +2194 350297 +2194 86435 +219412 219415 +2194365 752964 +2194365 845344 +219443 219444 +2194480 2280939 +219453 43233 +21946 20505 +21946 20511 +219485 784335 +219497 256490 +219498 219497 +21952 271245 +21952 770337 +21952 899606 +21954 1898297 +219565 394791 +219565 394796 +219565 451854 +219565 506008 +219565 645741 +219565 754978 +219565 924076 +2195943 302861 +219596 196697 +219596 196698 +2196088 3538188 +219616 128276 +21963 1236 +21963 228104 +21963 35445 +21963 4687 +21963 468986 +21963 59608 +21964 56635 +219671 4066 +219675 13667 +219675 1716872 +219675 178422 +219675 434256 +21973 58481 +21977 210258 +21977 51224 +219822 396922 +219849 321074 +219863 188082 +219868 219869 +219887 139089 +21991 19689 +21994 142944 +219986 1232702 +219986 31055 +2200294 535723 +2200294 676272 +2200569 3151449 +2200569 3183778 +22008 1065010 +22008 180140 +22009 42968 +220135 108453 +2201508 2201513 +220164 1786775 +220164 5867 +2201645 1817813 +220175 1182035 +2201848 1935988 +220187 3230392 +2202 26931 +2202 58554 +2202 97539 +2202 99172 +2202004 209995 +2202004 250152 +22024 42124 +2202553 2858206 +22028 1065010 +22028 110844 +22028 92281 +22032 81368 +220329 249966 +2203553 1548103 +2203553 979552 +220369 56840 +22038 39885 +220389 52368 +22041 628266 +220486 390056 +22054 14137 +220553 1484675 +220580 382934 +220583 216392 +220583 71081 +220607 347285 +220651 57103 +220651 62963 +220673 247176 +220673 48604 +2206741 449 +220717 846 +2207268 3284003 +22075 22076 +220759 1065010 +2207653 577808 +2207653 841593 +2207653 900979 +220767 1122649 +220778 102452 +22078 13961 +22078 533316 +2207854 2207855 +2207854 2207856 +2207854 2207857 +2207855 2207856 +2207855 2207857 +2207856 2207857 +220791 41233 +2208001 300117 +220810 60978 +22082 17803 +22082 72979 +2208204 126442 +220832 369963 +220886 224600 +220886 327619 +220887 119743 +220895 316967 +2209 91291 +220954 220953 +2209779 1032521 +220989 21801 +22101 10070 +22101 1059062 +22101 2202 +22101 26943 +22101 526404 +22101 67207 +2210246 1479204 +221038 578613 +221040 244188 +2210728 100313 +2210728 1738706 +2211062 176793 +22114 3515 +22114 43604 +22114 456548 +22115 1099 +22115 1489 +221254 80116 +2212723 195778 +2212800 665298 +22135 13943 +22135 1497 +22137 11939 +22137 33178 +22137 38603 +22137 48357 +22137 5363 +22137 61554 +22137 8254 +221387 343398 +221391 5965 +22145 1705 +22148 10780 +221489 221490 +22152 13667 +22152 507156 +221523 13325 +221523 239215 +221549 145939 +22158 66562 +2215801 2092924 +2215801 2920446 +2215953 1362644 +2215953 185689 +2215953 2215956 +2216 119952 +2216 67534 +221620 684160 +22164 37008 +22164 6376 +22164 89746 +2216689 2745853 +221737 1112341 +221737 1831642 +221737 851241 +2217943 1780375 +2217944 1780375 +2217944 2217943 +2218049 2218050 +2218121 227626 +2218590 2218592 +22187 22186 +221870 75584 +221905 181503 +221912 378297 +221934 920852 +22194 7619 +22195 30918 +22196 68913 +221967 221968 +221976 350697 +221983 32491 +2219913 55683 +2219913 837534 +2219913 841593 +2219913 842132 +2219913 900979 +2220 2256 +2220062 2357458 +2220068 1651820 +2220205 1607136 +2220205 1623204 +222027 222691 +22203 173932 +222032 220094 +22208 373976 +222158 10290 +22217 21078 +22217 31704 +222177 4686 +22219 49234 +222206 122439 +222206 210850 +22221 66181 +222210 212002 +222210 257423 +222210 41408 +22224 10554 +222263 226576 +2222687 2222688 +2223 2216 +222370 1233843 +222370 1629851 +222384 344166 +222384 985935 +222422 24699 +222425 53802 +222457 1956897 +222457 523446 +222474 4356 +2225253 459401 +222527 221965 +22255 687270 +22255 9110 +222578 1145403 +222578 1626845 +222578 2376385 +222578 2797907 +222596 271691 +2226573 1479204 +2226573 1527592 +222658 227950 +222675 458380 +222675 484739 +222675 770935 +222676 18435 +22269 84774 +222695 5592 +222726 36738 +22278 106348 +222800 922372 +2228087 271870 +2228087 397617 +222827 176526 +222832 316759 +222832 869555 +222832 9767 +222832 9768 +222856 422000 +22287 22285 +2228708 1126320 +2228708 1200943 +2228708 1968914 +222874 423012 +2229189 842110 +22294 123023 +22294 1475519 +22294 194 +222952 150080 +222952 583805 +223 15677 +2230170 10991 +2230586 2571847 +2230632 1821569 +2230632 2754275 +223083 1654652 +223083 2541344 +223083 7440 +2231054 2328635 +2231054 761873 +22312 29376 +223131 577288 +2231404 2135202 +2231404 59656 +2231404 711893 +223172 110337 +223172 225924 +223172 28517 +2231868 377574 +223200 6465 +2232194 2232195 +223233 651504 +223234 4091 +2232539 1183147 +2232539 148999 +2232539 1523681 +2232539 2006245 +2232791 3192367 +2232791 466911 +223283 1698571 +2232838 2214055 +2232910 2232937 +2232990 36201 +2233 2231 +2233048 74543 +223317 527810 +223317 84971 +223333 22495 +22334 1373063 +223365 144156 +223365 224519 +223380 55124 +223385 444623 +223436 16757 +223472 105134 +223473 2529672 +223477 1251801 +223490 345552 +223494 402514 +223499 24085 +223505 95882 +223545 214669 +223545 379636 +223560 1488494 +223592 688064 +2236264 1050296 +2236264 1477103 +2236264 227843 +2236264 842518 +2236264 873811 +2236264 938087 +2236601 2539915 +22367 13151 +22367 88879 +223679 735980 +2236844 1593411 +2237 9374 +223754 1328187 +223782 1082152 +223782 37722 +223782 9647 +223869 42124 +223886 879052 +223886 980235 +223934 223933 +223988 19549 +224 111502 +224 20146 +224 23019 +224 232956 +224 258946 +224 2762262 +224 2953 +224 302018 +224 32216 +224 591283 +224 66152 +224 67214 +224 78325 +224 828961 +224024 205919 +2240429 2240430 +224077 21081 +224077 393016 +224077 399533 +224085 1269571 +224085 176817 +224085 336543 +224127 209093 +224135 687270 +224135 978925 +2241400 2241401 +2241525 2241527 +22416 10966 +22416 141240 +22416 217095 +22416 38521 +2241984 2937302 +2241994 2241995 +2242178 526474 +22424 874616 +224263 548840 +22427 11835 +224273 219243 +224273 224273 +224273 2265 +224273 291028 +224273 427498 +22429 178892 +22429 94610 +224312 395643 +224329 1022480 +224329 1041914 +224329 153980 +224329 1582977 +224329 252998 +224329 256065 +224329 256168 +224329 257025 +224329 258462 +224329 261293 +224329 265354 +224329 273394 +224329 299702 +224329 311166 +224329 34183 +224329 37733 +224329 39874 +224329 522210 +224329 754974 +224329 754976 +224329 833840 +224329 839082 +224329 841660 +224329 857118 +224329 942019 +224334 149874 +2243363 2148322 +2243508 1292990 +224354 9179 +224363 219262 +224363 501985 +224467 212264 +224473 119981 +224488 389067 +224492 124436 +2245046 294923 +224506 262940 +224506 570543 +224506 839499 +224506 839501 +224519 1392 +224519 1647 +224519 17440 +224532 166955 +224532 950520 +224586 12619 +2246404 1768276 +2246468 1633530 +2246620 3054742 +224681 169559 +2246859 2246862 +2247168 2871450 +224753 924784 +2247603 2143547 +224777 110256 +2248141 2008694 +224884 163039 +224884 22558 +224884 241566 +224931 219497 +224931 256465 +224931 256490 +224980 66152 +224983 22428 +224990 2265 +2249932 303402 +224994 224995 +2249977 1627593 +22504 678945 +22506 139875 +22506 162052 +22506 193031 +22506 19966 +22506 333387 +22506 54518 +22506 77811 +225076 904667 +22509 17452 +22509 24399 +22509 8125 +2251445 1736225 +225164 316796 +22518 25581 +22518 4115 +225194 219325 +225233 77165 +225274 133517 +225274 670 +225290 352589 +2253450 168409 +225380 167658 +225380 233300 +225403 10533 +225403 115000 +225404 125410 +225432 282718 +225432 302952 +225432 78749 +225433 370955 +225433 992234 +22544 22545 +22548 22778 +2254840 13682 +2254859 2242673 +22549 106075 +22550 441493 +22550 92550 +22557 227496 +22558 163039 +22558 241566 +225588 1262509 +225599 725144 +225599 989687 +225603 1113605 +225615 344723 +225636 225637 +2257159 352830 +2257159 372380 +2257159 710204 +22573 297396 +225735 65325 +2257528 2003430 +2257721 1627381 +2257721 227843 +2257721 873811 +2257721 885767 +225777 1097946 +225777 1174847 +225777 1336031 +225777 145590 +225777 197272 +225777 2407497 +225777 2516547 +225777 2826503 +225777 3273144 +225777 370771 +225777 377533 +225777 64680 +225777 734795 +225777 925586 +225777 97974 +2258486 2258485 +2258762 2398475 +225888 162202 +225915 229712 +2259888 304975 +2259888 454293 +2259888 833626 +2259888 922635 +2260087 3089533 +2260153 1111660 +2260153 1627281 +2260197 1627281 +2260197 2265141 +2260331 434336 +2260871 2010828 +2261 2259 +22610 14997 +22610 22608 +22610 27234 +226141 1385729 +226141 1385730 +226144 286896 +22615 2350038 +226160 228697 +2261782 256558 +2262013 1258997 +226202 146060 +226202 40582 +22622 49776 +22622 639352 +226221 214781 +2262397 1519400 +2262477 1849338 +2262477 249584 +2262477 3039466 +2262477 3219528 +226265 997 +2262773 1492705 +2262773 1523605 +2262773 2055225 +22635 1115 +226354 1071036 +226354 306321 +226398 291641 +2264 209391 +2264 256517 +2264 57698 +2264013 2264012 +2264015 2285263 +2264015 2290101 +22642 43695 +226425 78 +2264293 236193 +22644 48509 +226461 1006985 +226461 1009447 +226461 1022480 +226461 1030523 +226461 1032262 +226461 1034981 +226461 1036751 +226461 1050534 +226461 1058540 +226461 108565 +226461 1183591 +226461 1202945 +226461 1205412 +226461 1213123 +226461 1359692 +226461 1437207 +226461 1443685 +226461 1490119 +226461 1507433 +226461 1742868 +226461 1834247 +226461 190370 +226461 1938047 +226461 2000915 +226461 216140 +226461 224329 +226461 260744 +226461 262940 +226461 268272 +226461 269254 +226461 27519 +226461 283122 +226461 299702 +226461 304975 +226461 368137 +226461 388185 +226461 394796 +226461 395913 +226461 397620 +226461 406271 +226461 406285 +226461 424576 +226461 454293 +226461 454981 +226461 465982 +226461 479036 +226461 499563 +226461 522209 +226461 522210 +226461 526594 +226461 544894 +226461 561049 +226461 578727 +226461 604396 +226461 696225 +226461 696238 +226461 705201 +226461 712500 +226461 727254 +226461 732482 +226461 775294 +226461 800996 +226461 806436 +226461 809856 +226461 832905 +226461 832917 +226461 832924 +226461 833033 +226461 833240 +226461 833315 +226461 833376 +226461 833686 +226461 833697 +226461 833698 +226461 833717 +226461 833794 +226461 834057 +226461 834399 +226461 834578 +226461 835090 +226461 836429 +226461 837573 +226461 837600 +226461 838226 +226461 838953 +226461 840538 +226461 841533 +226461 842132 +226461 843526 +226461 843897 +226461 845359 +226461 854513 +226461 855059 +226461 855971 +226461 859452 +226461 867976 +226461 867995 +226461 869796 +226461 869797 +226461 885767 +226461 892835 +226461 896804 +226461 907454 +226461 910619 +226461 912007 +226461 941848 +226461 946948 +226461 950106 +226461 95542 +226461 96123 +226461 966857 +226461 988905 +22649 953518 +2265 153470 +2265 16533 +2265 16534 +2265 281616 +2265 32059 +2265 59 +2265 9216 +226504 360377 +2265089 1441992 +2265089 45866 +2265089 880644 +2265141 921637 +2265204 2199762 +2265220 2789696 +2265605 1627381 +2265605 364838 +226584 114493 +226585 1959740 +226585 273661 +226585 316586 +226585 3833880 +226585 3833881 +226585 4013 +226585 412969 +226585 90863 +2266 135887 +2266 139696 +2266 25284 +2266 262160 +2266 268270 +2266 268271 +2266 60451 +2266 95088 +226616 586763 +2266659 297729 +2266703 834378 +2266703 883641 +2267 2264 +2267 2266 +2267 4128 +226705 5486 +226705 70095 +226750 1234383 +226750 143018 +226750 198642 +226750 36174 +226750 430778 +226754 138100 +2267766 2944673 +2268010 466983 +2268127 851589 +2268127 855761 +226819 511117 +226822 130607 +226851 1122675 +2268580 2970804 +226868 994376 +2269209 2588207 +226961 50672 +226988 102318 +227002 11382 +227036 18985 +227036 337525 +227051 692976 +227063 183604 +2270923 980145 +227104 151710 +227110 1861705 +227110 194507 +22712 2116 +227167 227168 +227198 211100 +227200 1065010 +227200 293516 +227200 76242 +227202 352453 +227202 423934 +227223 1708621 +227252 1343679 +227293 66883 +227327 288960 +227327 54517 +2273460 961313 +227408 1686320 +227431 53174 +2274346 2948496 +227438 177209 +227438 65788 +22744 162275 +227441 326650 +227449 782081 +227461 12974 +227461 98517 +227475 500490 +22748 106639 +22748 1790 +22748 2787412 +227493 280716 +227493 740538 +227518 175695 +227562 87814 +22757 105902 +22757 32416 +22757 52312 +22757 8024 +22759 63977 +227620 32717 +227633 84734 +2276373 2276375 +2276373 78003 +2276375 78003 +2276459 2279037 +22773 1017165 +22773 1030128 +22773 1174410 +22773 1303882 +22773 155569 +22773 28377 +22773 364257 +22773 44421 +22773 570671 +22773 759038 +2277658 2277657 +2277658 2277659 +2277659 2277657 +2277777 2277776 +2277860 511049 +227809 287273 +22781 105173 +22781 264749 +227813 506494 +2278229 2278228 +22783 14366 +227842 325715 +227843 837543 +227843 870853 +227843 873811 +227864 240755 +227864 273867 +227864 373346 +227867 551937 +227874 1021041 +227874 1348996 +227874 712486 +227874 754978 +227875 1012379 +227875 1012509 +227875 1027116 +227875 1083537 +227875 1114917 +227875 152377 +227875 1604940 +227875 1744428 +227875 1744430 +227875 227874 +227875 227875 +227875 262357 +227875 294480 +227875 360344 +227875 373345 +227875 42757 +227875 452918 +227875 452919 +227875 534901 +227875 538864 +227875 567511 +227875 754978 +227875 762632 +227875 778528 +227875 778532 +227875 837871 +227911 1740 +227911 19594 +227911 37078 +227947 113798 +227947 155335 +227965 1162241 +227965 293756 +227965 350792 +227965 734163 +22798 104319 +22798 3545618 +22798 86533 +2280 266264 +2280 791 +228001 77923 +228032 23431 +228032 2753 +228032 2967 +228032 314509 +228032 56167 +228032 57789 +228032 6086 +228032 609993 +228032 87810 +228066 148308 +228066 18353 +228074 285 +228074 57811 +228084 119743 +2280893 2280894 +2280893 842110 +2280894 842110 +228108 3142989 +228109 334663 +2281098 39874 +2281098 834073 +228129 366166 +228175 401786 +22818 164067 +22818 192054 +22818 56755 +228196 40853 +2282 27369 +228223 193530 +2282309 2759807 +2282309 3266950 +228262 80883 +2282684 2673261 +228271 1040609 +228271 193366 +2283166 458669 +228350 50098 +228359 348701 +228360 1098199 +228397 12646 +2285262 2264012 +2285262 2264013 +22853 273883 +2285445 2285444 +22855 824910 +228551 228552 +228551 264195 +228551 324000 +228555 723844 +228555 74772 +22857 31767 +228593 50528 +228628 237541 +228628 3180103 +2286631 2286631 +2286631 233910 +2286825 614195 +2287350 3039684 +228745 1305199 +228745 27952 +228745 799566 +228745 819385 +22877 126433 +22877 251536 +22877 50514 +22877 59736 +22877 89970 +22877 89972 +2287739 2287740 +228795 183889 +2287964 1903986 +2287964 951131 +228816 228816 +228816 243126 +228816 296 +228816 373951 +228816 5825 +228816 63828 +22882 321583 +22882 419 +22886 2967 +228874 111519 +228874 140556 +228874 16408 +228874 54517 +228876 833525 +228899 11332 +228904 12869 +228904 572127 +228904 76971 +228917 1006301 +228917 1986913 +228917 252017 +228917 280724 +228917 349282 +228917 364512 +228917 384818 +228917 41415 +228917 452558 +228917 514024 +228917 545875 +228917 89693 +228963 237711 +22898 17228 +228987 508025 +228987 927710 +229 116 +229 30782 +2290 1402 +2290 36158 +22900 78767 +229005 225290 +2290101 2285263 +22902 8260 +2290560 3091328 +229057 25009 +229057 93383 +229071 54523 +229071 58014 +229073 412218 +2291 34001 +2291 45866 +22910 1183829 +22910 21742 +229134 535617 +229180 229185 +229180 343902 +229180 656760 +229188 104766 +229194 251877 +229194 693015 +2292327 92623 +229236 310025 +229259 688403 +2292684 1448227 +2292738 64532 +2293169 189400 +229345 1671198 +22935 1116772 +22935 1128599 +22935 198518 +22935 34215 +22935 50706 +22935 78659 +22937 1333307 +2293988 2293987 +2294 2120 +2294302 2294300 +22946 202611 +22946 2410390 +22946 2410391 +22946 428428 +22946 65807 +22946 702510 +22946 859697 +22946 878387 +22946 93168 +229471 229472 +229498 10514 +229498 200818 +229498 29977 +229498 64694 +22950 57346 +229547 1022039 +229547 1032265 +229547 108565 +229547 1096780 +229547 1172316 +229547 1173665 +229547 1275956 +229547 1516778 +229547 192325 +229547 1951275 +229547 2027433 +229547 2033933 +229547 216140 +229547 262940 +229547 269254 +229547 271874 +229547 3248391 +229547 334081 +229547 342541 +229547 388185 +229547 395913 +229547 406281 +229547 406283 +229547 415720 +229547 448007 +229547 448010 +229547 462603 +229547 696225 +229547 703271 +229547 712500 +229547 736606 +229547 829980 +229547 837527 +229547 841590 +229547 842269 +229547 842271 +229547 842272 +229547 842888 +229547 847489 +229547 850067 +229547 855059 +229547 865054 +229547 880957 +229547 882946 +229547 907454 +229547 912384 +229547 92243 +229547 926723 +229566 1269513 +229566 1270472 +229566 1346429 +229566 1419770 +229566 424150 +229566 424276 +229566 833903 +229566 961751 +22958 45707 +229604 162275 +229631 514736 +229639 52833 +229647 2057747 +229663 377663 +229663 675688 +229665 1065010 +229665 132084 +229665 241531 +229665 321128 +229665 38661 +229665 982496 +2296823 1539312 +2296823 2199857 +229712 424754 +229712 524871 +22975 247333 +22976 10034 +229761 479200 +2297637 3816125 +229784 167939 +22979 1990 +22979 20717 +22979 215179 +22979 243564 +22979 31751 +22979 342217 +22979 35148 +22979 502386 +22979 50681 +22979 581265 +22979 8316 +229790 122227 +22980 318 +2298526 440371 +2298526 880218 +229864 155537 +229864 248607 +229864 31439 +229893 20977 +229902 16485 +2299170 3000433 +229930 27952 +229934 29531 +2299342 2179476 +22997 199181 +22997 846 +229991 212942 +23001 6017 +23003 35251 +230034 217483 +23004 61226 +23005 10435 +23005 2906 +2300553 482792 +2300680 227843 +2300680 837543 +2301 2291 +230140 1009447 +230140 1147100 +230140 170759 +230140 253133 +230140 270225 +230140 283122 +230140 454293 +230140 656869 +230140 832701 +230140 833164 +230140 837529 +230140 837533 +230140 838931 +230140 842132 +230140 855063 +230140 855170 +230140 862697 +230140 905491 +230140 978302 +230150 14457 +230150 7679 +230181 1240794 +230181 230182 +230181 293888 +230181 349785 +230181 365745 +230181 44364 +23019 258946 +23019 591283 +23019 67214 +23019 776 +23019 78325 +2302007 1822027 +2302007 202097 +230216 244453 +230233 145136 +230238 617293 +2302605 2302607 +2302863 282296 +2303042 2303043 +230338 604039 +230343 186579 +23035 11202 +23035 2811 +230356 76067 +23036 22799 +2303645 1935198 +230365 12553 +230365 7772 +230387 92815 +230408 476222 +230490 11069 +230490 29921 +230511 100752 +230511 65049 +230519 276555 +230520 1166964 +230520 230520 +230520 354973 +230534 1005285 +230534 144927 +230534 230539 +230534 256182 +230534 268350 +230534 333056 +230536 272701 +230550 38110 +2305951 988751 +2306 309 +230618 122524 +230621 221964 +230623 126954 +2306282 3715530 +230640 132321 +230642 19966 +230642 825322 +230644 272880 +230645 223869 +230661 669337 +2306681 1656406 +23067 124237 +23067 16295 +23067 43571 +2307144 2307145 +2307193 1251615 +230723 256255 +230723 28568 +230732 191569 +230732 286867 +230732 803593 +2307608 2307610 +2307611 2307608 +2307611 2307610 +230788 1127363 +230788 5826 +2308 17558 +2308 183741 +2308 2320 +2308 252937 +2308 33980 +2308 6771 +2308 69788 +23083 1577971 +23083 194243 +230839 259160 +230885 204149 +230885 209366 +230885 804865 +230886 248452 +230886 366849 +230886 70129 +23089 3014652 +23089 50528 +230895 1071218 +230895 1807478 +230897 45041 +2309 1199 +2309 17558 +2309 649761 +230918 41441 +230933 659455 +230933 719348 +230939 582500 +23096 102635 +23096 1182 +23096 1291624 +23096 1583520 +23096 185489 +23096 239568 +23096 28934 +23096 2904453 +23096 336 +23096 338 +23096 368895 +23096 66186 +23096 79628 +230968 49172 +23097 2760 +230976 200020 +230980 66727 +2310 1414 +2310 235665 +23100 168636 +23100 183193 +23100 44869 +2310197 2094995 +23102 166838 +231037 13705 +2310501 2310031 +231067 77609 +231080 156955 +231080 555800 +2311 478834 +231118 448993 +23112 4304 +231168 410397 +231194 4349 +2312 1077301 +2312 191759 +2312 2312 +2312 5403 +2312 800646 +2312434 696188 +231285 10207 +231287 16715 +231319 129740 +231329 342214 +231465 216448 +231465 460115 +231482 4155 +231485 95546 +231509 212376 +231509 4506 +231517 206095 +231517 229592 +231517 669915 +2315464 279614 +2315464 888854 +2315464 95544 +2316 17558 +2316 183753 +2316 2308 +2316 69788 +2316222 302675 +23165 269254 +2316599 2316600 +23168 71477 +2317127 519923 +231724 121390 +231726 13855 +23173 92474 +231749 586230 +2317686 695689 +231775 108968 +231775 171761 +231775 216149 +23178 484008 +2317871 538156 +2318 271013 +2318 6676 +2318285 2537060 +2318316 1592383 +231850 64735 +231889 32888 +2319 105134 +2319 129507 +2319 148243 +231953 212514 +231983 652190 +232 13394 +232 1399 +232 4908 +2320 10014 +2320 103237 +2320 10469 +2320 10472 +2320 16095 +2320 1726 +2320 18748 +2320 2376385 +2320 2542 +2320 26923 +2320 2817 +2320 2820 +2320 3503 +2320 35555 +2320 438264 +2320 4738 +2320 64010 +2320 651 +2320 9808 +2320 9913 +2320241 517153 +2320241 834641 +232099 1733788 +2321 62 +232122 301928 +232126 145229 +232126 5160 +232126 5965 +232164 225050 +232195 63752 +23223 12344 +232239 1998509 +2322564 2322565 +232264 262807 +2323 1545 +2323 230723 +2323 42825 +2323 6920 +2323 71592 +232313 16893 +2323242 1980081 +2323245 1420240 +2323245 2539915 +232330 54574 +2323597 271877 +23243 21667 +23243 239022 +23243 48388 +23243 924461 +232451 36100 +232451 66152 +23246 40159 +2324642 883380 +2324662 883380 +232474 19140 +232474 278201 +232474 428776 +2325 1362986 +2325 7830 +2325026 207574 +232540 98684 +2326267 1307759 +2326267 1416955 +2326267 1511355 +2326267 1545410 +2326267 1628759 +2327 325 +232741 229071 +232749 141642 +2327497 2327498 +23281 23866 +232824 12965 +232824 247945 +232824 552775 +232824 906242 +232827 206695 +23286 45895 +2328796 3219738 +232898 232899 +232956 120307 +232956 1476918 +232956 1702929 +232956 2762262 +232956 35665 +232956 357753 +232956 359939 +232956 51988 +232956 5530 +232956 66152 +232956 727590 +2329755 3387867 +2329893 190128 +2329893 629395 +2330060 1858490 +2330060 424983 +2330068 1376377 +2330068 3199555 +2330177 1929501 +2330177 2850596 +2331 122048 +2331100 2331099 +233123 301091 +233123 5628 +233143 297803 +233147 225219 +233150 45554 +2331598 2953901 +2331616 4025199 +23318 111645 +23318 236283 +23318 241221 +23318 79980 +233183 157847 +233184 120307 +233184 137602 +233184 175575 +233192 234107 +2332 183427 +2332 2074 +2332 41121 +2332 4733 +2332 5486 +2332 58723 +2332 7137 +233214 5911 +2332203 1738706 +2332203 3278967 +233300 167658 +2333160 1420541 +233387 233388 +233397 233396 +23340 17111 +23345 24 +233502 727110 +233533 659848 +233533 872051 +233544 54352 +233578 157232 +2335836 2269473 +2335836 6197 +2336 42262 +233607 1304645 +2336241 1167057 +233639 118425 +233658 293210 +23366 4813 +233700 427307 +233700 73368 +2337494 3523762 +233793 285758 +233796 624596 +2338 4956 +233802 219704 +233802 236125 +2338239 740890 +233865 140041 +23387 14643 +23387 2585338 +2338806 1728524 +2338806 9165 +23389 39112 +23389 41698 +23389 53341 +233896 71036 +2338985 100064 +2338985 1138951 +2339026 4116 +233910 101842 +233910 10971 +233910 19144 +233910 24703 +233910 247945 +233910 2643711 +233910 3588237 +233910 365527 +233910 516516 +233910 553093 +233910 980059 +2339298 33573 +233992 146233 +233992 41272 +233992 64943 +234 429654 +23404 9562 +234048 32096 +2341031 702680 +2341031 777849 +234108 137627 +234125 301924 +234125 301927 +2341409 2711471 +234143 126064 +2341869 454288 +2341869 454290 +2341892 303594 +2342076 2342079 +23421 19704 +23423 1461002 +23423 182109 +23423 20226 +23423 215559 +23423 27307 +2342899 200819 +234312 275916 +23437 545663 +23437 77910 +23438 76910 +2343871 1105189 +234399 157712 +234399 207615 +234399 247731 +234399 356748 +2344475 2754275 +234470 1237510 +234470 480973 +2344786 76038 +2345618 3071837 +234574 229080 +234577 209816 +234577 65721 +23460 341299 +234601 1101612 +234601 285728 +234608 162275 +234641 183 +234656 21332 +234725 14045 +234808 13195 +2348095 2205687 +234836 11745 +234837 11745 +234837 234836 +234846 759076 +234849 2790099 +234856 73368 +23487 2264604 +234890 113428 +234890 550701 +2349361 2953741 +2349537 2349553 +234966 1563746 +2349933 3182688 +2349933 3182689 +2350102 603403 +2350140 2350141 +235031 235033 +235031 299211 +235031 385024 +235032 1468067 +235032 44114 +235033 299211 +235033 385024 +235067 10679 +23508 25283 +23508 57640 +2351595 1179182 +2351595 1481471 +2351595 2047034 +235179 1401769 +235179 1727626 +235179 409997 +235179 81489 +23522 49778 +235220 17803 +235227 51158 +235227 86301 +2352321 2461970 +2352321 3130081 +2352368 1271286 +2352598 2352599 +23526 1066 +2352667 2352666 +2353 2355 +235304 100199 +235304 100200 +235314 213785 +235334 146344 +235363 90520 +235377 13608 +235382 703269 +235382 843912 +2354022 3018471 +2354081 2619913 +2354081 2785956 +2354081 361626 +2354081 361628 +235447 1554497 +235447 390933 +235485 1138499 +2354948 1175692 +2354948 1175736 +235517 1475160 +235517 48472 +235539 353697 +23555 60265 +2355959 2157792 +235602 201677 +235611 513444 +235611 634295 +235631 1529880 +235636 1792822 +2356435 2356436 +2356435 2985691 +2356436 2985691 +2356605 1053916 +235664 29215 +235666 30918 +235706 485047 +2357523 577808 +2357523 841593 +2357523 900979 +23579 143285 +235825 110406 +235837 288368 +235837 695004 +2358508 1640312 +2358508 3292283 +2358508 3292284 +2358508 833629 +2358763 49106 +235888 235889 +2359101 1585551 +235911 194 +2359247 114493 +235979 199591 +235979 39720 +235979 556537 +235979 7981 +23603 119795 +236033 25777 +236034 226398 +236034 291641 +236035 202258 +236035 415655 +2361 27243 +236120 858200 +23616 1298411 +23616 6574 +236167 127856 +236178 1188078 +23618 194 +236185 270225 +236185 415720 +236185 626175 +236185 850894 +236185 851310 +236185 857113 +236185 857117 +236187 65552 +236226 1137762 +236226 965350 +23624 15787 +23624 342668 +23624 473004 +23624 473005 +23624 58584 +2362445 1793489 +2362445 469572 +2362579 1193983 +2362579 1240300 +2362579 2879072 +2363133 486432 +236331 12969 +2363984 394776 +236403 19619 +236430 45774 +236442 1233304 +236442 236441 +236457 236458 +236461 4980 +236482 269254 +236482 539131 +2364915 1163931 +2364915 15407 +2364915 79265 +2364999 2528513 +2365 2377 +236525 100450 +236525 236525 +236525 236526 +23657 52504 +2365801 1216065 +2365801 2498725 +236587 1108502 +2366 19638 +2366 3605 +23660 144653 +236601 343389 +236623 142047 +236623 321956 +236623 325649 +236623 387946 +236623 877624 +2366650 2882839 +23669 112660 +236764 490021 +236770 268 +236822 186595 +236825 60596 +23686 950857 +236892 294537 +236897 83609 +236900 102934 +236900 1293405 +236900 136536 +236900 2874615 +2369047 2369046 +23694 3078424 +236945 236946 +236948 1077888 +236948 26920 +236950 10586 +236950 9557 +236966 8410 +23698 132714 +2369844 1578935 +23699 881201 +236996 1042373 +2370637 1804442 +237064 338277 +237088 73521 +237089 181695 +2370897 1394806 +237110 2081699 +23712 61746 +237133 103142 +237133 103722 +237133 45936 +237141 318642 +2371481 1053170 +2371481 1173606 +2371481 754974 +2371481 833549 +2371481 836124 +2371481 867988 +237156 120034 +237156 292438 +237156 59651 +237156 82211 +237196 139475 +237202 279535 +237211 561981 +2372282 2071476 +23725 143109 +23725 2851 +23725 29060 +23726 23727 +237320 160004 +237323 170971 +237350 113498 +237360 219844 +237367 275800 +237367 840304 +2373845 333443 +23739 7466 +237402 1265373 +237402 351651 +237402 524248 +237408 237406 +237412 103339 +237455 282349 +237457 259591 +237507 403935 +237509 410512 +237515 237510 +237516 113430 +237516 386863 +237516 643177 +237518 2516533 +237546 1397670 +23755 200815 +23755 255137 +23755 262128 +23755 59659 +23755 64694 +237554 69237 +237568 4074 +237574 1570 +237574 71870 +237593 175910 +237656 3820 +237656 756235 +237656 9555 +237664 29777 +237667 30031 +237731 237730 +237751 198512 +237781 720259 +237788 8232 +2378111 2378110 +2378127 2378128 +2378208 115605 +2378208 1519525 +2378281 1462461 +2378281 363034 +2378543 89854 +23787 60528 +237871 19619 +237890 223473 +237912 54186 +237912 95003 +2379192 2292162 +23792 18187 +23792 308038 +23792 55787 +237940 1176652 +237940 289194 +237971 278520 +238001 392046 +238001 80883 +238021 238030 +238040 1675219 +238040 502047 +2380459 2674177 +2380461 2380459 +2380461 2674177 +238107 126224 +2381133 168453 +23812 1576867 +23812 209084 +23812 218872 +2381646 69474 +2381784 252872 +2381784 424273 +23819 20437 +23819 68153 +238212 144225 +238213 24221 +238213 595384 +238213 673235 +23825 11136 +238278 253989 +2383017 1205338 +2383017 2383016 +2383451 2205305 +23836 107956 +23836 13690 +23836 27600 +23836 51816 +238361 342694 +238379 17969 +238379 270879 +23838 194 +2384129 618596 +238418 1277604 +238418 1809 +238418 185839 +238418 37718 +238418 649876 +238418 649891 +238418 935106 +238440 1005136 +23846 152459 +23846 18620 +238460 238461 +238460 313681 +238460 58861 +2384717 3640141 +238473 179144 +23850 1156977 +23850 66880 +23850 712800 +238501 63407 +238501 95623 +238501 982116 +2385250 2250166 +2385250 3251829 +2385250 3251830 +2385250 3251832 +2385250 3251835 +2385250 3251837 +2385250 3279815 +238558 21032 +238558 25262 +23859 279473 +23859 493931 +23859 62118 +23861 405493 +238624 1063743 +238637 1064913 +238675 148338 +238675 94023 +238690 367947 +238694 143244 +238694 2268175 +238694 336768 +238694 690277 +23877 204686 +23877 64344 +2387746 1418345 +238778 213512 +238778 238777 +238870 1079035 +238870 1092691 +2388826 2388825 +238929 1402603 +238929 2187 +238929 219598 +238929 257914 +238929 855097 +238959 370533 +238959 370534 +239008 119167 +2390290 1934109 +239054 310038 +239107 307496 +239109 14295 +23911 148183 +23911 329773 +2391379 2391378 +239169 28538 +239209 38863 +239222 176601 +239222 239223 +239223 1229555 +239223 176601 +239223 1915849 +239223 2428251 +239223 680513 +239223 769709 +239223 842921 +239233 39481 +239236 1021944 +239236 1022025 +239236 1037859 +239236 1041969 +239236 1057185 +239236 1057191 +239236 1092317 +239236 1094111 +239236 1173606 +239236 1211012 +239236 1354730 +239236 1420649 +239236 1507460 +239236 1522980 +239236 153980 +239236 1591238 +239236 1611690 +239236 1710606 +239236 1864137 +239236 1901503 +239236 1966189 +239236 2079655 +239236 224329 +239236 260744 +239236 262940 +239236 267134 +239236 269254 +239236 27519 +239236 283122 +239236 283127 +239236 296409 +239236 299702 +239236 301263 +239236 303060 +239236 304975 +239236 317584 +239236 3488542 +239236 368137 +239236 394791 +239236 395913 +239236 397616 +239236 397620 +239236 406281 +239236 406283 +239236 415720 +239236 424576 +239236 435555 +239236 446471 +239236 448008 +239236 454293 +239236 459776 +239236 479036 +239236 490290 +239236 502826 +239236 517144 +239236 517165 +239236 526592 +239236 532265 +239236 543206 +239236 547969 +239236 547971 +239236 564649 +239236 575045 +239236 578737 +239236 595478 +239236 604396 +239236 626175 +239236 688034 +239236 688716 +239236 696160 +239236 696188 +239236 696253 +239236 696257 +239236 704150 +239236 706861 +239236 712500 +239236 754894 +239236 754974 +239236 795171 +239236 814478 +239236 832917 +239236 832989 +239236 833071 +239236 833080 +239236 833082 +239236 833108 +239236 833167 +239236 833168 +239236 833376 +239236 833446 +239236 833486 +239236 833554 +239236 833560 +239236 833667 +239236 833785 +239236 833842 +239236 834245 +239236 835066 +239236 835112 +239236 835190 +239236 837533 +239236 837568 +239236 837661 +239236 838868 +239236 838983 +239236 838984 +239236 839087 +239236 839234 +239236 839257 +239236 839640 +239236 839679 +239236 841660 +239236 842132 +239236 842238 +239236 842888 +239236 845359 +239236 846281 +239236 846285 +239236 850889 +239236 851589 +239236 855759 +239236 859446 +239236 862836 +239236 863279 +239236 865661 +239236 865664 +239236 867835 +239236 867893 +239236 867894 +239236 867946 +239236 867995 +239236 872558 +239236 882709 +239236 883315 +239236 893904 +239236 895978 +239236 896804 +239236 900180 +239236 907452 +239236 908890 +239236 912593 +239236 92243 +239236 940128 +239236 971040 +239236 985088 +23925 23927 +23927 344 +23930 590673 +239305 120307 +239305 301471 +239316 106541 +239316 25872 +239399 136133 +239399 262816 +239415 1880420 +239446 101500 +2395046 1638553 +2395179 1792148 +2395180 1792148 +2395180 2395179 +23956 307040 +239566 1468981 +239566 663652 +2395691 2803481 +2395731 601757 +239587 545306 +2395978 1595296 +2395978 841357 +2396 19756 +239608 195631 +239608 85832 +239608 91348 +239622 947054 +239632 21946 +2396387 2493933 +2396387 8186 +2396400 2396401 +239655 29212 +239661 72448 +2396811 866594 +239682 250031 +239719 514116 +2397268 452227 +23973 1412153 +23973 210389 +239741 225106 +23980 21508 +2398014 2398048 +23983 15043 +239866 81489 +2398730 2397902 +239875 64866 +2398957 12251 +2398957 2871857 +2398957 3921758 +239921 67657 +239931 1264186 +239941 508065 +23997 80179 +239972 239971 +239980 239985 +239980 240528 +239995 67503 +24 16837 +24 36335 +2400003 419176 +2400167 1902238 +2400167 2400157 +2400402 2212683 +240058 47874 +24008 1165514 +24008 12246 +24008 19549 +2400888 68857 +2401021 2487935 +2401021 3004746 +2401431 1591710 +240151 508098 +240165 36609 +24018 12936 +240182 72717 +2401864 1572214 +2401864 1668356 +2401864 1958244 +2401864 2457407 +2401864 308384 +2401864 628737 +2401864 985811 +2401864 987368 +2401903 192327 +2401903 696215 +2401903 833071 +2401903 833073 +2401903 833554 +2401903 833824 +2401903 836487 +2401903 837520 +2401903 837529 +2401903 842223 +2401903 861476 +2401903 861487 +2401903 865055 +2401903 95546 +2402217 1008205 +24023 7624 +24023 7986 +240233 1286865 +240244 467721 +24027 2037488 +24027 224903 +24027 27472 +24027 32216 +24027 357262 +24027 722481 +24027 86716 +2402947 2402948 +2402947 842085 +2402948 842085 +2403135 2075576 +240329 240331 +240329 550425 +240345 241314 +240369 76486 +2403850 2730899 +2404 16772 +240432 16317 +24046 163772 +24046 4247 +240485 196759 +240490 100199 +240490 100200 +240490 235304 +240493 57640 +240522 1186086 +240528 239985 +240531 248275 +2405510 362089 +2405514 974878 +24056 329124 +24058 27127 +24059 62623 +240680 1395357 +240680 176817 +240680 21240 +240680 240681 +240680 241993 +2407109 1153504 +240713 73142 +24072 23909 +24072 43011 +240744 125994 +2407497 197272 +2407497 377533 +240755 373346 +24076 3206395 +240779 318052 +2407928 1099718 +240796 221458 +240811 560755 +24084 186306 +24085 150114 +24085 209614 +24085 45593 +240870 386863 +24088 3297264 +240917 284995 +240917 97127 +2409461 610799 +2409461 882724 +2409463 2409461 +2409463 610799 +2409463 882724 +240948 43937 +24095 48509 +241014 29947 +2410390 2410391 +241049 1322515 +241049 241047 +241049 303434 +241049 365745 +241049 563205 +241049 627602 +241049 752932 +241049 770935 +24106 32352 +24107 22158 +24107 43445 +24107 66562 +241078 513380 +2410878 1415870 +2410878 1640312 +2410878 2358508 +2410878 3292283 +2410878 3292284 +2410878 833629 +241119 36039 +241135 3261843 +241165 204395 +241174 241175 +241175 3858 +241176 241175 +241176 3858 +241180 2583 +2411851 2674351 +2411851 3370367 +2412 17583 +2412 616859 +241221 236283 +241221 460115 +241244 30088 +241304 203681 +241309 164363 +241309 212403 +2413096 2415058 +2413299 1192841 +2413299 1436793 +2413299 1468646 +2413299 1552022 +2413299 835518 +2413299 855061 +2413299 861690 +2413525 2413526 +241433 1386610 +2414594 2989347 +241471 1735 +2414972 2414973 +2415058 2415057 +241530 215610 +241531 137880 +241531 359939 +241534 309021 +241574 146487 +241574 694689 +2415853 1486921 +241610 241609 +241662 2367059 +24167 145849 +24167 23755 +24167 41796 +241674 160761 +241674 309524 +241681 1505 +2417092 2417093 +241735 134525 +2417443 2184451 +241755 201111 +241755 301304 +241755 351033 +241789 562180 +241794 667265 +2418185 1128599 +241828 175844 +241860 12883 +241860 76933 +24188 1750319 +24188 19078 +241894 241158 +241907 806593 +241927 275316 +241927 539669 +2419637 446105 +2419637 552195 +2419637 641250 +2419637 688716 +2419637 853359 +241966 15140 +241966 242533 +241976 79084 +241993 21240 +242007 6747 +242054 241822 +24211 35333 +24211 57979 +24212 10995 +24212 191200 +24212 24212 +242127 242134 +2421299 399714 +24214 314878 +242169 117415 +242169 1697557 +242172 242173 +242172 778706 +24220 24221 +24220 25809 +242200 1982813 +242200 242200 +242200 629036 +24221 10263 +24221 2083888 +24221 276076 +24221 283111 +24221 595384 +24221 65897 +24221 773262 +24222 268260 +2422265 2282309 +2422265 2759807 +2422265 3266950 +24227 58686 +242296 134470 +242345 2111 +242345 242345 +242345 45866 +242376 3246321 +24238 54224 +242394 242393 +242394 591216 +242394 628936 +242394 907223 +24241 186150 +24241 49857 +242415 1980 +242436 37204 +242467 1120377 +242472 347818 +242480 269844 +2424892 251779 +2424892 252742 +2424892 254079 +242533 83309 +2425331 263796 +242541 9686 +2425515 1513250 +2425555 3144185 +2425555 3676367 +24256 24257 +242594 100774 +242695 100558 +24272 162932 +24272 84200 +242722 347863 +242724 124666 +24275 94791 +2427919 265931 +2428259 1991456 +242867 1343285 +242877 395124 +242885 651718 +242949 94868 +242957 134126 +242957 9555 +24298 1093139 +24298 403483 +24298 7705 +24298 79100 +2429830 2079893 +242996 237236 +242997 91905 +243012 94594 +2430486 1790128 +243050 116118 +243058 346063 +24307 17532 +24307 50577 +24307 9707 +243086 1674580 +243106 205957 +243122 197327 +243126 156255 +243126 194490 +243126 243126 +243126 257136 +243126 296 +243126 354973 +243126 493724 +243126 54518 +243126 770381 +243161 227813 +2431643 2703663 +243166 14678 +243166 87215 +243177 230434 +243180 10754 +243180 11887 +243180 1188831 +243180 1372396 +243180 203532 +243180 271508 +243180 2833115 +243180 80654 +2431944 2431945 +2432 2157 +2432 697 +243203 374792 +243203 574573 +243208 243209 +243242 135657 +243242 9011 +2432803 3117826 +2433007 424754 +243311 2009640 +243374 117051 +243374 76828 +243376 40385 +2433785 951326 +2433785 951327 +2434400 2434399 +243449 1792680 +243455 1065321 +24347 2725 +2435518 78783 +243563 1924105 +243564 128056 +243564 132592 +243564 16676 +243564 183741 +243564 193366 +243564 199818 +243564 215179 +243564 228271 +243564 243564 +243564 45392 +243564 612348 +243564 612349 +243564 69589 +243566 24653 +24359 225525 +2436079 1389700 +2436079 415470 +243610 11368 +243613 224117 +243615 272062 +243615 296600 +243615 362652 +243615 438610 +243615 588367 +243615 697461 +243615 806508 +24362 1008892 +243675 65706 +24368 7484 +24368 78548 +243736 307576 +243738 505451 +243744 263605 +243744 706514 +243745 243753 +243748 32697 +243758 310258 +2437607 417544 +2438 240882 +2438 3042 +2438536 752473 +243872 232242 +243872 369619 +243872 62077 +243872 9076 +2438786 1375373 +243902 36251 +243916 28538 +24394 2155036 +24394 2155038 +24394 493793 +24394 806688 +243952 43442 +2439558 2439559 +2439558 584423 +2439559 345869 +2439559 3533880 +2439559 584423 +2439779 708608 +243987 116798 +243987 13358 +243987 38806 +2439966 1097313 +2439969 1764073 +2439969 3018999 +244017 244016 +24402 337829 +2440316 2505653 +2440449 1841308 +2440449 983824 +2440452 2823553 +2440516 2188633 +244078 52875 +244079 1280460 +24408 14988 +24408 29166 +24408 45587 +244096 1104767 +244096 1405024 +244096 1416655 +244096 1932292 +244096 1998849 +244096 1998850 +244096 2015317 +244096 496464 +244096 626008 +244096 768662 +244096 905783 +2440997 3319148 +2441 443880 +244134 46814 +244170 84214 +24419 11433 +24419 116010 +24419 21504 +24419 24584 +24419 30592 +24419 31524 +244191 154701 +244195 842291 +244196 1705712 +2442099 2079608 +24422 1398 +24422 1718 +24422 338 +24422 4930 +24422 5271 +24422 6416 +24422 7315 +24422 907144 +24423 26220 +244311 244310 +244342 61833 +244366 320531 +244417 2140654 +244417 2387670 +2444890 1231240 +24452 43099 +244565 655447 +2445772 503060 +244588 36766 +2446 301674 +244602 30031 +2446086 1251923 +2446086 2446087 +2446086 333892 +2446086 526576 +2446086 628237 +2446086 718775 +2446087 1251923 +2446087 333892 +2446087 526576 +2446087 628237 +2446087 718775 +244631 230644 +244631 272880 +2446484 570536 +2446484 645601 +2446484 761109 +244654 690852 +244661 80916 +2446837 1005707 +2446837 698773 +2446837 945427 +2447 1104 +2447 15169 +2447 1558482 +2447 167887 +2447 194 +2447 21266 +2447 5892 +2447 6681 +24472 42239 +24472 72071 +244725 332516 +244751 131775 +244751 1731272 +244751 992640 +2448 2034 +244861 244862 +24490 1105230 +24490 142204 +24490 532128 +2449294 3669981 +24495 22877 +24495 251536 +24495 4690 +24495 50514 +24495 59736 +24495 81951 +24495 89970 +24495 89972 +244961 673881 +2450057 2563332 +245027 113945 +245027 268541 +24503 1449076 +245038 153423 +245038 243758 +245038 310258 +245052 251519 +245068 409093 +245071 763852 +245074 1485371 +245076 595837 +2450913 1195709 +245103 400188 +24511 4690 +24511 77716 +24511 85337 +245120 1006159 +2451229 1066057 +245124 10775 +245124 278395 +24513 1193571 +2451355 402895 +24515 36643 +245155 466378 +2451812 143952 +245202 1448094 +245202 485015 +245215 685245 +245216 46596 +245220 3030483 +2452318 2346606 +245232 1009856 +245232 1399 +245232 218923 +245232 27952 +245232 546790 +245232 559497 +245236 2967 +245236 370185 +245252 837568 +2452595 1845733 +2452765 2122600 +2452765 628737 +2452796 2452795 +2452942 3363495 +245301 456556 +245308 1556199 +245308 2339462 +24532 200650 +245339 351011 +245343 11488 +2453523 194 +2454 95156 +245403 9192 +2454104 2800800 +2454552 448007 +2454552 448010 +24547 10252 +2454864 2463427 +2454864 2593437 +245512 72071 +24553 99170 +2455827 2455825 +2455827 762632 +2455911 2455910 +2456217 794536 +2456262 61104 +24564 151326 +24564 99767 +24567 298757 +245734 269671 +245734 668377 +245734 938392 +2457407 986613 +245741 177342 +245741 260604 +245741 294410 +245750 516037 +245750 699999 +24578 22824 +24578 23947 +24578 27450 +24584 24585 +24587 7899 +245971 52675 +246031 210019 +246031 270803 +246031 304114 +246031 40929 +246031 961608 +2460455 1372559 +24609 10916 +246205 17827 +246205 258118 +246205 267099 +246205 282240 +246205 29058 +246205 307059 +246205 44120 +246205 44944 +2462057 3388930 +2462209 2519536 +246241 207509 +2462438 2877817 +246259 25958 +2463 197366 +2463 200229 +2463 21142 +2463 223366 +2463 283884 +2463 329371 +2463 41441 +2463 66727 +2463 81792 +2463267 516980 +246347 712622 +2463492 2376385 +24637 24636 +2464172 15506 +246430 246431 +246432 17413 +246434 246432 +246455 28568 +2464719 2464720 +24653 2728 +246530 270805 +246536 256558 +246550 246549 +2466083 2334338 +2466083 2466089 +2466083 405120 +246618 1649673 +246618 2021040 +246618 830958 +246642 1868784 +246642 246536 +246650 1602134 +246650 17545 +246692 234200 +246693 30880 +246764 202097 +24680 21474 +24680 49797 +246880 117654 +246892 25009 +246892 425241 +24697 117660 +2469791 451534 +24698 234936 +24698 44427 +24698 447970 +24698 97986 +24699 394688 +247016 15569 +24703 101842 +2470363 2470362 +247084 2108 +247085 54224 +247091 38237 +247099 105503 +2471225 2705761 +2471724 1410067 +2471724 1882417 +2471724 961093 +247176 43281 +247180 129259 +247194 182002 +247216 146957 +247293 285910 +2472987 2352321 +2472987 2461970 +2472987 3130081 +247309 10383 +247327 395701 +247362 1655388 +247362 690355 +247379 475037 +2474 1236 +2474 1286 +2474 2474 +2474 3338 +247410 233432 +247418 1085663 +247455 7144 +247461 71172 +247471 1009490 +247471 1009492 +247473 1457628 +247528 188420 +247528 400711 +2475305 226461 +24754 32811 +247620 163218 +247641 9808 +247671 1822682 +24769 25416 +24772 1301385 +2477289 1826008 +2477289 289198 +2477289 51171 +2477289 796454 +247742 508521 +2477545 1007476 +2477545 3209204 +247822 139169 +247825 58287 +2478250 1168118 +247830 138240 +247895 101346 +247920 119792 +247920 267753 +247920 286093 +247920 969930 +2479408 1947294 +2479408 424754 +2479408 781552 +247945 19144 +247945 365527 +247945 516516 +247945 553093 +247952 2110340 +247952 235146 +247952 389546 +247952 536926 +247957 210432 +247957 52145 +247957 924732 +247974 129858 +247974 2757698 +247999 1851018 +247999 315294 +247999 85768 +24804 22660 +2480536 2494755 +2480552 922947 +248110 759083 +2481597 21139 +2481643 209672 +2481683 153954 +2481683 1638817 +24818 118313 +24818 3452 +2482 1178678 +2482 1292259 +2482 44844 +2482072 2923804 +248236 2195918 +2483098 2483099 +248332 407730 +2483364 573281 +2483417 2786693 +24845 232198 +248452 70129 +248454 26457 +2485 69674 +248505 476642 +248538 251394 +248538 4243 +2485395 1214261 +2485395 2982406 +2485395 331991 +2485395 437 +248552 51496 +248560 267709 +248560 503250 +2485933 1356669 +2485933 934199 +248607 183741 +248607 372109 +248607 44421 +248607 462750 +24862 46923 +24862 8125 +248643 218323 +2486850 656584 +24875 32904 +24875 62915 +24878 62835 +2487935 3004746 +2488155 154797 +2488645 1098966 +2489032 797489 +2489094 1828466 +248923 248924 +2489793 2195893 +249 245466 +249 52958 +2490149 1756684 +2491689 672540 +249179 28517 +249179 301157 +249179 737068 +249205 398686 +2492150 236900 +2492159 1293336 +2492159 1293338 +249231 14954 +249231 996144 +24925 123235 +249271 1633468 +2492979 1737489 +2493933 8186 +2494 81013 +249403 169099 +249403 210111 +249413 13935 +249423 61172 +24944 1253621 +24944 1369126 +24944 1411257 +24944 1933468 +249449 147031 +249449 255183 +249449 263206 +249449 311678 +249449 334507 +249449 619909 +249482 14397 +249536 94455 +249544 1651971 +249577 122227 +249584 1849338 +249584 2031229 +249584 3039466 +249584 3219528 +2496179 2496178 +2496442 190374 +249669 1734 +249673 25789 +249673 409689 +249695 237132 +2497365 2609959 +249740 33542 +249769 351342 +249787 41263 +2497969 1719087 +249829 355 +249838 251812 +249873 605710 +249879 12300 +2499017 2499016 +2499128 3948790 +2499232 1978255 +249939 2426235 +249946 255280 +2499731 1454393 +2499731 1471046 +25 226504 +2500 183821 +2500 57475 +2500093 1616106 +2500093 839080 +2500093 882022 +2500093 986111 +2500296 3580866 +2500296 492930 +2500296 867599 +250036 250037 +250058 51079 +25009 17388 +25009 249794 +25009 25008 +25009 31516 +25009 93383 +25010 147389 +25010 629045 +250149 2589334 +2501562 716084 +2501562 836185 +2501748 2228627 +250192 60901 +250202 1027076 +250202 502329 +250246 106651 +250273 253960 +250295 76597 +2503 2514722 +2503 2525091 +2503 259804 +250314 1840550 +2503240 638302 +250334 156382 +250334 486770 +250343 250344 +250359 137603 +2503748 1642459 +2503748 3871051 +2503748 3871052 +2503748 3871053 +2504176 2504168 +250420 250421 +250428 1297439 +25044 191122 +2504916 1070192 +2505 350445 +2505012 1024732 +2505012 1845805 +2505312 2606682 +2505441 3137748 +250563 238351 +250568 317024 +250568 317025 +250568 335192 +25058 187204 +250581 557087 +250582 17958 +2506128 3386129 +250635 266141 +250677 285065 +250691 1475990 +2507001 1078875 +2507001 187796 +2507001 878758 +2507004 134019 +250730 1122911 +2507356 1960103 +25077 12751 +25077 21357 +25077 21358 +250835 941710 +250870 1069137 +250870 250870 +250898 250897 +250910 1493831 +250912 547453 +250925 11938 +2509378 2509379 +250959 279656 +250963 323535 +2510942 29820 +251144 320043 +251144 87460 +251165 213813 +2511769 57886 +251196 20457 +2512105 2421931 +251239 251244 +251333 465876 +2513746 1339233 +251395 2133 +2514051 2182223 +251409 1932523 +25142 1096 +25142 22622 +25142 49776 +25142 639352 +251427 12339 +2514722 2525091 +2515075 2263498 +2515075 2536698 +251535 238001 +251535 392046 +251536 89972 +2515362 516714 +2515529 835073 +251578 1553664 +251597 227965 +251597 684677 +251607 590465 +251607 639945 +251608 251604 +251657 252350 +251657 260864 +251661 2420869 +251661 312413 +251661 927886 +25167 497986 +25167 57698 +251689 1399567 +251689 170329 +251689 488821 +251689 908932 +251698 1450204 +2517187 4721 +251725 1030490 +251725 1030495 +251725 309845 +2517398 2517397 +251762 751255 +251769 258459 +251769 258702 +251769 274978 +251769 296955 +251769 309874 +251769 312775 +251769 326820 +251778 255752 +251778 256091 +251778 859448 +251779 252742 +251779 254079 +251788 252018 +2517927 855063 +2517927 867992 +2518110 282137 +2518110 883123 +2518110 961426 +2518110 982123 +2518111 393383 +2518111 841590 +2518111 870697 +2518188 710680 +2518197 1443853 +2518653 2518652 +251871 536534 +251877 508876 +2518897 2651044 +251922 996569 +251933 2688664 +251936 297499 +2519485 1546795 +252003 83740 +252021 1142563 +252064 251595 +252080 252084 +252080 252092 +252097 487021 +252102 260458 +252134 1230979 +252139 292125 +252175 1152731 +25220 134623 +252205 29345 +252264 214410 +252264 284206 +2522654 860560 +252298 251893 +2522985 1785992 +2522985 2522984 +252299 29241 +252299 42110 +252299 510438 +252299 7137 +252303 315793 +252303 59655 +252310 10514 +252310 252308 +252310 253478 +252310 254065 +252310 257025 +252310 263796 +252310 274957 +252310 332796 +252310 41417 +252310 55745 +252314 305968 +2523244 224858 +252333 265188 +252333 356829 +252333 438165 +2523491 2462209 +2523491 2519536 +2523615 2523616 +252370 209085 +2523943 2330456 +252397 21073 +252408 94090 +252432 2145843 +2524439 1142516 +2524439 832661 +2524439 95546 +252447 321900 +25247 18628 +25247 31164 +252477 2188048 +252481 299167 +252486 265835 +252505 252524 +252524 306519 +2525396 2525397 +252584 11699 +252584 45429 +25259 41063 +2526037 25931 +252611 149325 +252611 323464 +252619 4944 +252619 538181 +252638 1218171 +252642 1155903 +252642 1468981 +252642 239566 +252642 633282 +252642 663652 +252654 277555 +2526661 3560139 +252669 362480 +252692 1003540 +252694 587595 +252725 92281 +252728 135847 +252728 252728 +252728 262940 +252728 359068 +252732 179494 +252732 217629 +252734 253705 +252734 461816 +252786 314045 +252803 226141 +2528098 1192950 +252815 455477 +252820 239399 +252820 3009628 +25283 237211 +25283 33471 +25283 400094 +25283 561981 +25283 77813 +25283 91587 +25283 91590 +25283 9373 +252838 341421 +252838 692737 +252866 1104516 +252866 1357330 +252868 1188916 +252868 1254014 +252868 1328441 +252868 1336482 +252868 1337029 +252868 1355232 +252868 1486921 +252868 1562081 +252868 1905856 +252868 1955559 +252868 2092662 +252868 255545 +252868 256988 +252868 2571020 +252868 263134 +252868 306347 +252868 313303 +252868 313312 +252868 313335 +252868 504711 +252868 572623 +252868 581626 +252868 604668 +252868 604669 +252868 650767 +252868 654414 +252868 665021 +252871 841885 +252872 532086 +2528839 1008268 +252898 194 +252940 273086 +252964 471831 +252976 626964 +252981 111815 +252985 168453 +252985 2381133 +252995 259089 +252998 104673 +252998 1243444 +252998 129805 +252998 135873 +252998 149254 +252998 253780 +252998 256065 +252998 258462 +252998 268007 +252998 271155 +252998 354659 +253 61104 +253011 258433 +253011 37732 +253031 84214 +253032 103455 +253032 255774 +253098 170011 +253098 177817 +253098 255129 +253098 259074 +253098 260604 +253098 42708 +253102 309383 +2531021 1638553 +253103 309383 +253106 545359 +253133 1025834 +253133 1260698 +253133 1373278 +253133 1478675 +253133 1481537 +253133 2401903 +253133 262940 +253133 268816 +253133 269254 +253133 273276 +253133 3101629 +253133 341084 +253133 349296 +253133 441528 +253133 696257 +253133 833560 +253133 833827 +253133 837527 +253133 841590 +253133 842132 +253133 850908 +253133 851310 +253133 851418 +253133 868929 +253133 882018 +253133 925944 +253140 1468067 +253140 235032 +2531872 3711503 +25320 50271 +25323 32883 +25323 70534 +253234 274143 +253240 306715 +253240 702275 +253245 454293 +253245 547971 +253245 624568 +253245 8284 +253245 835190 +2532541 2540435 +2532548 2812796 +253257 255060 +253257 277723 +253259 259022 +253262 253310 +253266 1066849 +2532797 828663 +25328 237707 +253282 260366 +253283 104810 +253283 137872 +253289 993071 +253290 289497 +253295 903526 +2532965 1908726 +2532965 2518110 +2532965 282137 +2532965 853477 +2532965 862694 +2532965 883123 +2532965 961426 +2532965 982123 +2533040 2533039 +2533095 939959 +253320 918990 +2533258 2974061 +253335 409989 +253367 135871 +253367 135873 +253367 256091 +253367 338201 +253412 202252 +253426 1112977 +253443 265629 +253445 251782 +253445 257025 +253445 265387 +253445 70526 +253447 236601 +253447 253462 +253447 297021 +253447 312072 +253447 343389 +253447 41904 +253447 42708 +253447 736721 +253462 254022 +253472 10589 +253476 252998 +253476 256168 +253476 265354 +253476 267089 +253476 300044 +253476 339515 +253478 322310 +253481 1952968 +253481 267089 +253481 355185 +253481 441793 +25353 123243 +25353 141646 +253542 271324 +253592 10079 +253592 1312123 +253592 1922394 +253592 20185 +253592 250037 +253592 255882 +253592 265629 +253592 271001 +253592 274605 +253592 298432 +253592 59251 +2535980 2587430 +2535980 2587431 +253632 39576 +2536393 3240662 +253641 257251 +253641 95088 +253650 1951313 +2536561 2014298 +2536561 352262 +253661 1395697 +2536696 2263498 +2536696 2515075 +2536696 2536698 +2536698 2263498 +25367 216362 +25367 268923 +25367 786 +253686 253692 +253704 273932 +253704 650767 +253705 461816 +253731 242533 +253731 328401 +2537322 793064 +2537322 833097 +2537323 2537322 +2537323 793064 +2537323 833097 +2537323 890675 +2537481 2537480 +2537481 826540 +25375 568857 +253774 135847 +253778 252964 +253778 339953 +253778 471831 +25385 24657 +253929 468931 +253949 185755 +253963 485278 +253986 3475826 +2539915 1420240 +254012 1770023 +254012 281213 +254012 292493 +254062 242657 +254065 332796 +254079 252742 +254092 254091 +254092 279398 +254092 417428 +254092 504592 +2541155 87020 +25417 17496 +2542 10020 +2542 9165 +254201 262944 +254259 333272 +2542688 1294345 +2542688 1908726 +2542688 2518110 +2542688 2532965 +2542688 282137 +2542688 835733 +2542688 853477 +2542688 862694 +2542688 883123 +2542688 961426 +2542688 982123 +2542793 2542794 +254290 387397 +2542965 2542964 +2542984 2542964 +2542984 2542965 +2543046 304396 +254322 1899334 +254335 28365 +254394 104673 +254394 145262 +254394 149254 +254394 252998 +254394 258469 +254394 285231 +254394 59402 +254394 833433 +254394 911933 +254400 1265566 +254400 1266883 +254400 312587 +254400 870181 +254404 265178 +2544235 2395781 +254441 38863 +25449 161183 +254494 634 +2545 1567554 +2545 21716 +2545 689990 +2545162 1905440 +2545309 1300812 +2545309 269254 +2545309 832917 +2545310 1300812 +2545310 2545309 +2545310 269254 +2545310 832917 +254539 92870 +254574 30185 +254578 686463 +254706 47038 +254711 254706 +2547284 3207928 +254749 294515 +254749 314301 +254755 276970 +254761 153980 +254761 735145 +254768 136133 +254768 254769 +254768 258689 +254768 311722 +254768 312997 +254768 330838 +254769 1997942 +254769 258689 +254769 312997 +2548241 179509 +2548287 2044526 +254841 1144144 +254841 1552598 +254841 1771824 +254841 1826041 +254841 504613 +254841 564263 +254841 601419 +254841 654414 +254841 844782 +254841 938507 +25485 16312 +25485 226062 +25485 59875 +254862 1438039 +25487 7705 +254881 284667 +254881 300355 +254881 300524 +254881 331687 +2549 2263 +2549 30362 +2549 7383 +254907 276034 +2549088 979622 +254945 229498 +254945 259078 +25495 168692 +25495 26245 +25495 390896 +25495 63839 +25495 74440 +25496 498135 +254990 149254 +254990 2021033 +254990 251782 +254990 253445 +254990 255947 +254990 2578785 +254990 267675 +255 271083 +255 4358 +255 61789 +255 947049 +25500 16204 +25500 203532 +25500 577370 +25501 11101 +25501 13690 +25501 16316 +25501 17240 +25501 66851 +25501 7623 +2550223 1364889 +2550223 2854717 +255027 254108 +25503 212499 +25503 218462 +25503 2290209 +25503 332446 +25503 4687 +25503 537360 +255041 249861 +255041 38256 +2550426 1335787 +255047 267030 +2550981 1026176 +2550981 2013697 +2551032 1245031 +2551032 1245032 +2551032 1245033 +2551032 1278653 +2551032 2551034 +2551032 2551038 +2551032 2551039 +2551032 3248391 +2551032 3370810 +2551034 1245033 +2551034 1278653 +2551034 2551038 +2551034 3248391 +2551035 1169516 +2551035 1245031 +2551035 1245032 +2551035 1245033 +2551035 1278653 +2551035 2551032 +2551035 2551034 +2551035 2551038 +2551035 2551039 +2551035 2918308 +2551035 3248391 +2551035 3370810 +2551038 1245033 +2551038 1278653 +2551038 2918308 +2551038 3248391 +2551039 1245033 +2551039 1278653 +2551039 2551034 +2551039 2551038 +2551039 2918308 +2551039 3248391 +255116 253395 +255116 257251 +255116 315947 +255117 135873 +255129 253093 +255129 255882 +255137 1509382 +255160 322315 +255183 953861 +255185 258121 +2551980 1930850 +2551980 2424045 +2552 235204 +255206 455744 +255212 1435725 +255212 464249 +255212 778759 +2552171 1476918 +2552301 3332947 +255253 6292 +25529 555882 +25529 71723 +255297 406101 +25532 361539 +25532 372721 +25532 41521 +2553398 1654505 +2553398 2139457 +2553398 2728736 +2553398 2751359 +2553459 2027931 +2553459 284995 +255362 263210 +255362 312126 +255362 324012 +255369 1379621 +2553697 2486850 +2553697 656584 +255437 254911 +255439 918806 +255469 150409 +255469 69621 +255556 306609 +25562 10980 +25562 11107 +25562 239568 +25562 302694 +25562 406309 +25562 64259 +25562 726307 +25562 782666 +255646 217242 +255665 120331 +255665 288448 +255665 571035 +25569 259077 +255723 219844 +255752 256091 +2557524 2557523 +255756 255758 +255757 255756 +255757 255758 +255774 103455 +255786 454893 +255801 1027989 +255801 1471362 +255801 439663 +255801 647195 +255801 714002 +255801 715301 +255801 821985 +255801 95540 +255804 1199356 +255804 1260606 +255804 153980 +255804 224329 +255804 262940 +255804 269254 +255804 27519 +255804 374006 +255804 377139 +255804 395913 +255804 397616 +255804 397620 +255804 406278 +255804 406281 +255804 424107 +255804 479033 +255804 502809 +255804 561054 +255804 567209 +255804 598601 +255804 627128 +255804 833842 +255804 835518 +255804 835735 +255804 842238 +255804 846282 +255804 846290 +255804 852701 +255804 855761 +255804 880769 +255804 903706 +255804 950106 +255872 2764765 +255880 15346 +255882 1071063 +25589 205 +255931 21875 +255942 262965 +255945 1398759 +255945 213242 +255945 265425 +255945 277683 +255947 252998 +255947 691665 +2559642 1534029 +2559642 218045 +2559711 2031386 +2559711 289198 +255995 1899334 +255995 254322 +255995 261069 +256 178629 +256021 162862 +256022 256023 +256022 260533 +256022 265273 +256033 263901 +256057 304729 +256065 265354 +256091 135871 +25612 63007 +256126 1554385 +25614 210705 +256141 1760699 +2561539 2561540 +256161 187787 +256168 168453 +256168 2006155 +256168 2381133 +256168 252985 +256168 44536 +256168 896003 +256182 144927 +256182 230539 +256182 333056 +256186 268095 +256187 303897 +256225 199605 +256225 96266 +256245 51229 +256255 1180987 +256255 1487387 +256255 1819467 +256255 297988 +256255 901332 +256257 269705 +256257 279400 +256257 699803 +256272 560327 +2563 2648718 +2563729 1466510 +2563729 410038 +2563729 880077 +2563729 920799 +2563810 224858 +256385 371399 +25642 1544 +256464 3472461 +256464 418107 +25647 28206 +25647 3772 +2565 1025795 +25654 363277 +25654 46333 +256558 120312 +256558 145273 +256558 254976 +256558 255556 +256558 267089 +256558 284204 +256558 306609 +256558 37731 +256574 6707 +2566 16687 +2566488 2681573 +2566622 2565513 +256686 161608 +25670 6142 +25670 8275 +256727 209085 +2568717 217242 +2568775 2529683 +2568775 2791440 +256884 256883 +25694 268301 +2569685 3830904 +256972 1370653 +25698 9918 +2569868 3340594 +257008 253240 +257008 257394 +257008 306715 +257008 702275 +257024 10932 +257024 42895 +257025 256168 +257025 896003 +25703 147002 +25703 25703 +25703 71844 +25703 991163 +257037 381267 +2571003 3438257 +257115 15502 +257115 254394 +257120 220594 +257138 2490808 +25718 1196117 +25718 1617096 +25718 19647 +25718 7698 +257181 1355202 +25720 7969 +2572040 1132489 +2572040 95546 +2572041 1132489 +2572041 2572040 +2572041 95546 +25721 762591 +257233 380695 +257250 253443 +257251 135885 +257267 2194 +257267 308802 +257267 46333 +257267 86435 +257306 268962 +257306 268963 +257307 289793 +257307 447940 +257307 503340 +25734 1186 +25734 25734 +25734 332855 +25734 4124 +25734 9388 +257352 148097 +257353 2147082 +257353 389753 +257357 257358 +257377 339700 +257420 1735216 +257456 234470 +257464 154207 +257464 236897 +257464 283281 +257464 322814 +257464 48398 +257464 692192 +257486 115947 +2574987 1551432 +257577 1641094 +2575932 1908393 +25764 134802 +25764 156946 +25764 885311 +25765 105504 +25765 134741 +25765 56840 +25766 78293 +25767 238952 +25768 24057 +25768 379585 +25768 81987 +257680 257679 +257684 290085 +257684 337708 +257694 1265566 +257694 1266883 +257694 254400 +257694 312587 +257694 314301 +257694 354194 +257694 423298 +257694 447940 +257694 481548 +257694 531489 +257694 870181 +2577 3485 +2577110 105873 +2577110 346303 +25774 108573 +257745 145272 +257745 251873 +257745 259079 +257745 2664783 +257745 307298 +257745 59251 +25775 125912 +25775 187475 +257761 966791 +25777 112738 +2578612 424576 +2578612 744724 +2578720 2397864 +25789 409689 +257896 252732 +257896 261426 +257896 295303 +257914 1217007 +257914 1761437 +257914 886366 +257931 57870 +257938 1600 +257938 19116 +257938 226267 +257938 47289 +257942 860574 +257966 44937 +257974 1034738 +257974 466777 +2579822 2811200 +257998 247657 +258078 1054398 +258078 1058305 +258078 1356494 +258078 1415464 +258078 2116503 +258078 304968 +258078 361808 +258078 361814 +258078 567511 +258078 677980 +258078 807450 +258078 95539 +258111 140032 +258121 3520169 +258124 397953 +258127 269228 +258129 252264 +2581725 400575 +258203 99626 +2582340 1575413 +2582340 869040 +25827 291382 +2583 125599 +2583 13583 +2583 17289 +2583 22390 +2583 47129 +2583 89458 +258309 133157 +258317 116683 +258317 258318 +258317 2818966 +258318 493400 +25832 18353 +25832 20104 +25833 63325 +258330 249060 +258372 25495 +258410 209214 +258410 683743 +258422 1411696 +258422 2403477 +258422 309979 +258433 258459 +258459 152707 +258459 258702 +258459 265641 +258459 265682 +258459 265683 +258459 3002160 +258459 306399 +258459 314412 +258460 338494 +258461 648212 +258463 258461 +258463 258698 +258463 307296 +258463 313010 +258463 313150 +258463 325854 +258463 325861 +258463 648212 +258469 1243444 +258469 252998 +258469 255646 +258469 268007 +258469 353291 +258469 911933 +258476 272568 +2585096 144850 +258518 368674 +2585397 145539 +2585397 1849338 +2585397 1977477 +2585397 2262477 +2585397 249584 +2585397 2882883 +2585397 3039466 +2585397 3067086 +2585397 3219528 +2585786 2525117 +258606 258607 +258607 1489469 +2586229 517153 +2586229 834641 +2586229 931425 +2586394 2518971 +2586394 3109423 +2586394 3290289 +25864 15887 +258687 261340 +258687 265637 +258687 270026 +258689 312997 +25869 115863 +25869 116706 +25869 1498615 +25869 156088 +25869 194 +25869 25872 +25869 90203 +258698 258461 +258698 313150 +258698 648212 +25870 116709 +25870 33471 +25870 90210 +258701 258460 +25872 106541 +25872 288656 +25872 33468 +25872 41270 +2587394 2535980 +2587394 2587430 +2587394 2587431 +2587430 2587431 +258749 260898 +258749 272756 +258749 342874 +2587586 1738356 +2587586 2874811 +258759 37730 +2587898 2587893 +258795 108203 +258816 66101 +2588318 3461614 +2588318 405858 +258839 431254 +258844 272852 +2588667 66171 +2588892 2588891 +258897 1142941 +258903 979822 +258904 310212 +258942 238626 +258942 84214 +258946 591283 +258946 78325 +258980 325214 +259 162275 +2590 112889 +2590 28644 +2590197 703758 +259074 170011 +259074 251778 +259074 859448 +259078 229498 +259079 10514 +259079 251873 +259079 252310 +259079 274957 +259079 41417 +259079 59251 +259081 193583 +259081 265382 +259081 265388 +259081 265422 +259081 326081 +259081 61587 +259081 848406 +2590905 517333 +259092 130589 +259092 212002 +259092 472588 +259096 328032 +259097 129805 +259097 252998 +2591 1735 +2591 241471 +2591 49993 +2591057 1654441 +259118 123402 +259154 238626 +259154 281957 +2591915 2713304 +259216 124436 +2593 102811 +25933 224272 +259336 165098 +259338 2035635 +259338 2482072 +259338 2923804 +259338 651504 +2593437 2463427 +259358 1386286 +2593892 2593894 +2593892 2852192 +2593892 3180501 +2593893 150401 +2593893 2593892 +2593893 2593894 +2593893 2852192 +2593893 3180501 +2593894 2852192 +2593894 3180501 +2593960 1311773 +259418 134201 +259418 203554 +259418 203696 +259459 21763 +259534 259533 +25954 258 +25955 40566 +259580 322722 +25959 215559 +2596 5159 +2596 9566 +259600 3311018 +259601 272685 +259623 306447 +259623 428224 +259699 299915 +259699 347315 +2597008 2566230 +259713 287495 +259799 272814 +259799 304416 +259799 308191 +259799 328158 +259799 447765 +259799 86720 +259802 216140 +259802 375279 +259802 415725 +259802 627442 +259802 761118 +259802 833181 +259802 833840 +259802 946188 +259802 95537 +259802 999914 +259829 3063809 +259830 264898 +2598358 1276000 +2598362 1276000 +2598362 2598358 +259843 480425 +259887 259886 +259890 263133 +2599 811978 +259913 1122117 +259913 532792 +2599174 913374 +259922 262460 +259922 263136 +2599347 2599350 +2599349 2599347 +2599349 2599350 +259951 600564 +25999 112401 +25999 17392 +25999 26000 +2599936 1701498 +26 1179 +26 1642972 +26 17 +26 4407 +26 505062 +26 675 +260 1279143 +260 54775 +260009 192557 +260079 245202 +260081 271691 +26010 10592 +2601074 460502 +26013 1408760 +26013 212034 +260136 1494537 +2601491 908931 +26020 408773 +260208 1141625 +260208 1257160 +260208 260209 +260216 75315 +260217 279405 +26022 16409 +26022 467945 +26023 198266 +26023 7771 +2602550 2387670 +260280 521356 +260293 1380528 +260293 2125331 +260293 602861 +26036 1403 +2603813 324193 +2603813 621280 +260384 24188 +2603927 776846 +260397 260390 +2604 1411691 +2604 203398 +2604 79579 +260407 294209 +2604177 397620 +2604177 754974 +2604177 832942 +26042 20977 +26042 3365 +26044 31929 +260440 353961 +26050 185982 +26050 50077 +260501 110593 +260501 254198 +2605046 2008875 +260507 263136 +260533 265273 +2605338 1672188 +260591 253098 +260591 255129 +260604 177342 +260604 294410 +2606049 92184 +260616 256186 +260616 268095 +2606345 2606344 +2606345 3068272 +2606345 793064 +2606345 837585 +260650 344779 +2607057 1311190 +260707 121549 +260707 81356 +2607098 2607097 +260727 362516 +2607337 1000280 +2607337 2095470 +260744 1060267 +260744 108568 +260744 1092492 +260744 1152498 +260744 1183591 +260744 1208600 +260744 1303395 +260744 1450896 +260744 261451 +260744 262940 +260744 269254 +260744 3185073 +260744 325672 +260744 368137 +260744 415720 +260744 448010 +260744 451535 +260744 454293 +260744 502826 +260744 517153 +260744 526592 +260744 552194 +260744 552195 +260744 604396 +260744 617133 +260744 646860 +260744 653535 +260744 688716 +260744 754974 +260744 833070 +260744 833071 +260744 833073 +260744 833074 +260744 833168 +260744 833560 +260744 833686 +260744 833687 +260744 833697 +260744 833698 +260744 833770 +260744 834534 +260744 834577 +260744 834578 +260744 834646 +260744 835518 +260744 835521 +260744 837529 +260744 837573 +260744 838190 +260744 839640 +260744 842222 +260744 842223 +260744 842888 +260744 845359 +260744 845360 +260744 845752 +260744 860731 +260744 874944 +260744 884243 +260744 92243 +260746 1058488 +260746 284939 +260746 331100 +260746 527475 +260750 112754 +260750 51988 +260760 11012 +2607756 2607757 +260800 583145 +260851 222596 +260851 271691 +260864 252350 +260868 194 +2608843 1499735 +2608845 1499735 +2608845 2608843 +260898 272756 +2609366 226461 +2609366 32180 +260958 105692 +260958 183514 +260958 269211 +260958 301667 +260963 115773 +260963 18710 +2609642 1868770 +261 102466 +261 122524 +261 12596 +261 1497 +261 218483 +261 38008 +261 5363 +26101 154274 +26101 189621 +26101 271316 +26101 3550 +26101 45135 +26101 49992 +26101 55325 +26101 58520 +26101 62507 +26101 65878 +26101 73538 +2610194 833792 +261045 28972 +261052 380838 +2610575 2610576 +261069 1899334 +261069 254322 +261077 27937 +261077 285048 +261077 455881 +261077 921518 +2610883 2452942 +2610883 3363495 +2611 1940 +2611011 3223465 +26112 363200 +261123 143017 +261123 3808022 +2611248 2927869 +261196 329904 +26120 437662 +26120 51496 +26123 108333 +261276 657254 +261279 202422 +261279 9912 +261286 265387 +261286 360222 +261290 47470 +261293 1027989 +261293 1087001 +261293 1252375 +261293 1274375 +261293 1463723 +261293 1469950 +261293 1471362 +261293 1485345 +261293 164279 +261293 253245 +261293 255801 +261293 262940 +261293 272275 +261293 27519 +261293 299946 +261293 302675 +261293 317584 +261293 366820 +261293 406281 +261293 415720 +261293 439663 +261293 446471 +261293 456764 +261293 508131 +261293 520248 +261293 524182 +261293 547971 +261293 552717 +261293 647195 +261293 647733 +261293 665970 +261293 696260 +261293 712500 +261293 714002 +261293 715301 +261293 725023 +261293 736606 +261293 758216 +261293 779502 +261293 784121 +261293 809856 +261293 821985 +261293 832655 +261293 832934 +261293 833240 +261293 834521 +261293 835190 +261293 838447 +261293 847478 +261293 854513 +261293 873546 +261293 882019 +261293 884545 +261293 897378 +261293 902344 +261293 919149 +261293 924191 +261293 991471 +2612968 835210 +2612969 1626911 +261332 199160 +2613349 3841511 +261340 270026 +261401 261403 +261401 268846 +261426 254995 +261426 264745 +261441 260139 +261451 1040506 +261451 283469 +261451 525459 +261451 552195 +261451 604396 +261451 833698 +261451 833717 +261451 835521 +261451 845360 +261451 874560 +2614588 2616846 +26147 4872 +261483 401047 +261485 367510 +261528 190141 +2615528 36100 +2615641 2848726 +2616 2615 +2616323 1542138 +261635 517995 +2616582 2556282 +26168 178049 +261717 435957 +2617407 450353 +26175 378635 +26175 737541 +26175 8090 +261801 1562443 +261801 164263 +261834 114733 +261836 332599 +2618526 2618527 +261864 273989 +261869 63854 +261878 14743 +261878 17587 +26189 249962 +261911 424928 +261930 1268519 +261930 263832 +26195 126328 +261974 228917 +2619913 2785956 +2619913 361626 +2619913 361628 +2620 7527 +2620 863391 +26202 26203 +26205 15562 +26205 15564 +26205 194 +26208 16290 +2620986 2620987 +2620986 2620988 +2620986 2620989 +2620987 2620988 +2620987 2620989 +2620988 2620989 +262108 262106 +262111 161894 +2621191 2227423 +26212 204588 +262128 135873 +262128 255117 +262128 59287 +262160 268270 +262160 268271 +262176 928471 +2621798 2138781 +2621858 1254764 +2622094 2622095 +2622094 78659 +262221 168059 +262225 184421 +2622284 2372565 +2622284 796454 +262237 1013335 +262245 262246 +2623061 3225179 +26232 12695 +262357 610798 +262357 65807 +262357 859043 +262358 115461 +262358 260744 +262358 262358 +262358 262940 +262358 514541 +262358 776673 +262358 834229 +262358 835070 +262358 837545 +262358 957152 +262359 144053 +262359 712501 +262376 1739574 +262376 646485 +262376 71825 +26238 15620 +26238 471791 +26238 530555 +26238 699597 +26238 719349 +26238 72765 +2623882 3169436 +262410 973597 +262414 135478 +2624266 2947088 +26245 1635332 +26245 200496 +2624533 2624532 +262455 170355 +262455 287849 +26246 209748 +26246 26245 +26246 51271 +262460 263136 +262492 281211 +262492 321956 +26253 171276 +262594 202763 +262626 1466709 +262691 490610 +262691 85885 +262722 283857 +262722 412630 +26274 1210231 +26274 597288 +262816 1038801 +262816 251777 +262816 253476 +262816 265634 +262816 272019 +262816 29992 +262816 300044 +262840 264541 +262864 279401 +262884 262251 +262915 262916 +26292 15598 +26293 41272 +26293 56958 +262940 1019240 +262940 1028502 +262940 1035503 +262940 1054398 +262940 1080246 +262940 1083537 +262940 1172316 +262940 1181646 +262940 1582977 +262940 1608503 +262940 192327 +262940 1951275 +262940 224329 +262940 227875 +262940 253245 +262940 258078 +262940 268272 +262940 271874 +262940 283127 +262940 3248391 +262940 333892 +262940 334081 +262940 3460300 +262940 348565 +262940 361808 +262940 368137 +262940 397616 +262940 397620 +262940 448010 +262940 453138 +262940 479033 +262940 526576 +262940 527161 +262940 538821 +262940 570543 +262940 696169 +262940 696260 +262940 730304 +262940 779502 +262940 793004 +262940 832951 +262940 833033 +262940 833079 +262940 833128 +262940 833794 +262940 834223 +262940 834378 +262940 834577 +262940 835409 +262940 835518 +262940 837450 +262940 837706 +262940 838243 +262940 838929 +262940 839082 +262940 839085 +262940 842238 +262940 843127 +262940 847489 +262940 849690 +262940 851589 +262940 855059 +262940 857118 +262940 859780 +262940 869570 +262940 880957 +262940 896978 +262940 899565 +262940 903706 +262940 95539 +262940 96123 +262940 966986 +262943 15261 +262943 323990 +262943 333516 +262943 333517 +262943 393117 +262943 83609 +262944 1486881 +262944 379742 +262945 262941 +2629950 131837 +2629950 538141 +263017 11774 +263019 19302 +2630235 2829083 +26304 143562 +263043 313850 +26310 78236 +26311 10994 +26311 17146 +26311 42015 +26311 51669 +263119 9910 +26313 81357 +263134 1366269 +263134 1486856 +263134 1608599 +263134 1784907 +263134 2263498 +263134 254841 +263134 260533 +263134 263139 +263134 263161 +263134 263162 +263134 263877 +263134 279398 +263134 316757 +263134 570361 +263134 756226 +263134 975248 +263135 1607559 +263139 2626237 +263173 263136 +263174 264465 +2632 13705 +2632047 848609 +263206 545536 +26324 21591 +263270 230572 +263274 209529 +263274 263274 +2633209 2146981 +2633301 3061318 +263346 429961 +263346 805918 +263361 334790 +2633895 2044643 +2634 121799 +2634 176531 +2634 2742 +2634 3607645 +2634 4536 +2634 69250 +2634 97059 +2634075 2634073 +263417 471592 +263441 251688 +263442 130788 +263442 2299321 +26345 381264 +263474 208470 +263485 393913 +263485 447566 +263485 580097 +263496 296343 +2635 3066 +263512 4382 +263517 266591 +263517 575089 +263532 1224245 +2635529 1051454 +2635529 117415 +263565 253704 +263574 271565 +263576 277574 +263598 1027896 +263605 546091 +263605 706514 +2636073 1589023 +2636184 12551 +263630 190073 +263667 164282 +263667 20691 +2637 11215 +2637 4649 +26370 82763 +2637829 3282031 +26379 939535 +263796 708817 +263796 97545 +263856 263133 +263857 407629 +263861 262243 +263862 314410 +263865 142092 +263865 3826100 +263877 756226 +2638777 422789 +263913 734276 +263926 260537 +263935 132339 +263937 279400 +263939 264714 +263966 2697780 +263966 3788795 +26402 36093 +264031 324134 +26404 35547 +264050 264051 +264059 541273 +264059 541280 +264059 562122 +2640779 5530 +2641 9472 +264116 202105 +2641462 3361393 +264222 1144136 +264223 434336 +264223 456210 +264243 264242 +264245 160905 +26429 207979 +264304 18984 +264311 106467 +2643232 2643233 +26434 283558 +264361 3520109 +2643711 247945 +2644032 2644031 +2644078 841441 +264436 142519 +264443 1910 +264443 264444 +264444 1910 +26445 82785 +2645 228269 +2645 2878 +2645574 1640327 +2645574 415720 +2645574 526591 +2645574 833626 +2645574 855063 +2645574 855073 +2645574 880725 +2645982 3697240 +264626 295651 +2646322 732266 +26469 51239 +264697 272381 +264703 265267 +2647320 839411 +264733 166692 +264735 676647 +264749 224903 +264766 270837 +264825 596866 +264871 1027390 +264871 307694 +264897 265489 +264897 342206 +264903 1285557 +264945 1186092 +264947 253263 +264998 1491279 +264998 2265141 +264998 285484 +264998 654531 +264998 980059 +265075 267758 +26511 997042 +26513 86057 +265130 674785 +265133 302272 +2651357 346296 +265181 202812 +265188 356829 +265188 438165 +265205 157813 +265205 41237 +265205 61250 +265211 2198152 +265215 1227548 +26522 20700 +265222 158997 +2652449 311327 +265284 315775 +26531 26532 +26531 33928 +26531 71781 +26532 25484 +26533 112611 +26533 11806 +26534 158072 +265354 252998 +265354 256168 +265354 257025 +265382 265422 +265385 1243444 +265385 252998 +265385 258469 +265385 268007 +265387 257025 +265387 360222 +265388 193583 +265388 265382 +265388 265422 +265388 61587 +265390 136013 +265390 156019 +265390 560718 +265390 876717 +2653985 3193511 +2654068 2654069 +265409 1280720 +265409 1628991 +265409 644745 +265417 3273144 +265447 34682 +26547 177783 +265488 257206 +2655 2615 +2655 2616 +26553 84192 +26554 1713 +26554 7609 +265560 317272 +265560 42708 +265566 1447583 +265570 14264 +265629 228917 +265629 252998 +265629 261974 +265629 306398 +265629 354659 +265634 1038801 +265634 251777 +265634 29992 +265634 313035 +265635 1243324 +265637 261340 +265637 270026 +265639 148132 +265639 149051 +265641 152707 +265641 265682 +265641 3002160 +265641 306399 +265641 314412 +265667 831064 +265678 307238 +265678 317854 +265682 152707 +265682 3002160 +265682 306399 +265683 258433 +265683 317503 +265683 519586 +2657 3241 +2657 733871 +265737 263166 +265773 361802 +265773 628056 +265773 628057 +2657779 2657780 +2657879 2137890 +26579 258 +26579 344614 +26580 2380950 +26580 34435 +26586 821413 +265879 259922 +265879 262460 +265879 263136 +26592 126073 +26592 14742 +26592 181011 +26592 205201 +26592 21801 +26592 26713 +26592 28738 +26592 92281 +265931 1536956 +265946 254091 +2659688 2119813 +2659688 288826 +266026 168059 +266052 1195289 +266078 1231179 +2661126 1097804 +2661126 833014 +266136 1838368 +266136 254886 +266136 3471187 +266136 406271 +266136 406285 +266136 48398 +266136 76111 +2661644 351666 +2661644 617404 +2661644 696267 +266172 1555740 +266173 453693 +266173 553691 +266215 90947 +266231 235750 +266264 141549 +2663 32216 +266345 164264 +266345 3734190 +266349 29990 +266356 251597 +2663685 901332 +2663824 143434 +26641 19784 +26641 33199 +266413 1745520 +266413 175776 +266431 231644 +2664421 643902 +266444 1333467 +2664584 2662569 +2664592 2641462 +2664592 3186179 +2664592 3361393 +26647 21991 +2664783 145272 +2664783 251873 +2664783 259079 +2664783 307298 +2664783 59251 +2664791 1706812 +266488 1866120 +266488 256729 +2665118 120734 +26653 249443 +26653 81703 +26657 8356 +2665832 2697002 +266586 68468 +2665958 3264300 +26661 514290 +26661 69090 +2666389 1990133 +2666389 688034 +266645 402431 +2666696 2666697 +26669 1127649 +26669 1137545 +266748 6169 +266789 10343 +266866 266867 +26687 339849 +2669 26042 +2669 6736 +266900 261155 +26695 251518 +26695 289089 +26695 422469 +26695 50147 +26695 84106 +26695 88733 +266996 56406 +267024 142047 +267024 321961 +267031 149809 +267031 46003 +267089 212002 +267089 311734 +267089 441793 +267089 532086 +267096 267095 +267099 17827 +267099 258118 +267099 29058 +267099 44120 +267099 44944 +2671 172004 +26713 14742 +267134 1048430 +267134 1233375 +267134 1990133 +267134 255804 +267134 262940 +267134 2644078 +267134 2666389 +267134 269254 +267134 3397762 +267134 397616 +267134 502809 +267134 532086 +267134 532089 +267134 561054 +267134 688034 +267134 833166 +267134 837568 +267134 838983 +267134 838984 +267134 841441 +267136 115863 +267136 1220498 +267136 1635871 +267136 267136 +267136 310509 +267136 3273144 +267136 339843 +267136 375953 +267136 38770 +267136 64680 +267137 1393286 +267148 12286 +267151 3507748 +267186 145256 +267186 251778 +267186 290874 +267186 29977 +2672300 2672301 +2672530 2672531 +2672547 45503 +2672547 603068 +267270 275311 +2672709 258097 +2672815 617598 +26733 3539 +267332 168634 +267338 202562 +2673764 15475 +2673764 43841 +2673854 461862 +2674165 2674166 +2674308 1441992 +2674308 654531 +267484 105728 +2675346 1051393 +2675346 1861594 +267553 267556 +2675599 2489387 +2675599 300802 +2675599 337597 +2675860 1088286 +2675860 1204773 +267593 267594 +267593 69414 +267599 527597 +2676 161313 +2676 16515 +2676 18086 +2676 29336 +2676 6347 +267648 30313 +267648 381534 +2676492 2516320 +267653 1533682 +267653 2132881 +267653 266136 +267654 92815 +267675 149254 +267675 251778 +267675 251782 +267675 253445 +267675 257025 +267675 259074 +267675 265387 +267675 70526 +267675 859448 +267686 723222 +267719 267717 +267726 375510 +267743 31418 +267743 47993 +267743 672601 +267745 2499896 +267753 286093 +267768 153980 +267768 262940 +267768 835518 +267768 846284 +267768 846301 +267768 872743 +267848 267845 +267853 266181 +267938 321988 +268007 1243444 +26812 280343 +2681401 712518 +2682046 838190 +268233 1130308 +268270 268271 +268272 1015406 +268272 1021942 +268272 1021944 +268272 1033258 +268272 1040473 +268272 1041969 +268272 1047628 +268272 1057453 +268272 1312375 +268272 1357413 +268272 1360089 +268272 1373813 +268272 153980 +268272 1541603 +268272 1611690 +268272 1629562 +268272 1656817 +268272 1679489 +268272 1690917 +268272 1787012 +268272 1787676 +268272 1825898 +268272 1831747 +268272 1915697 +268272 1915699 +268272 2085394 +268272 2093291 +268272 2186352 +268272 255804 +268272 260744 +268272 269254 +268272 2736228 +268272 27519 +268272 279614 +268272 283122 +268272 283127 +268272 299702 +268272 3009093 +268272 304975 +268272 334081 +268272 3756878 +268272 377139 +268272 379809 +268272 395913 +268272 397616 +268272 397620 +268272 406273 +268272 406281 +268272 406283 +268272 415720 +268272 424107 +268272 424576 +268272 435555 +268272 451535 +268272 454293 +268272 456926 +268272 479033 +268272 497542 +268272 517145 +268272 517158 +268272 517165 +268272 522209 +268272 522210 +268272 526580 +268272 526592 +268272 547969 +268272 547971 +268272 552195 +268272 595478 +268272 604396 +268272 617133 +268272 626175 +268272 644384 +268272 647782 +268272 696188 +268272 696192 +268272 696225 +268272 696260 +268272 704150 +268272 754894 +268272 754974 +268272 762632 +268272 775241 +268272 809856 +268272 826839 +268272 832899 +268272 832917 +268272 832924 +268272 832952 +268272 833074 +268272 833155 +268272 833179 +268272 833315 +268272 833667 +268272 833697 +268272 834101 +268272 834226 +268272 834378 +268272 834577 +268272 834578 +268272 835066 +268272 835073 +268272 835088 +268272 835112 +268272 835113 +268272 835213 +268272 835214 +268272 835518 +268272 836125 +268272 837008 +268272 837518 +268272 837570 +268272 838929 +268272 839514 +268272 842888 +268272 843127 +268272 845359 +268272 845768 +268272 848066 +268272 849690 +268272 854161 +268272 858480 +268272 858964 +268272 859452 +268272 859780 +268272 861507 +268272 864672 +268272 864674 +268272 874943 +268272 875589 +268272 880965 +268272 882784 +268272 883315 +268272 884243 +268272 888854 +268272 896978 +268272 914907 +268272 931948 +268272 944561 +268272 945593 +268272 950106 +268272 970420 +2683015 1391855 +2683015 1548248 +2683015 791299 +268350 1155903 +268350 144927 +268350 1468981 +268350 230539 +268350 239566 +268350 252642 +268350 256182 +268350 298936 +268350 333056 +268350 340652 +268350 344428 +268350 554794 +268350 633282 +268350 663652 +268358 1615436 +268361 1922394 +268361 253592 +268369 237467 +268369 297021 +2684 30906 +2684 394775 +2684 9270 +26846 9820 +2685102 180140 +26853 136409 +26853 1496 +26853 95433 +268541 113945 +26856 11645 +26857 216844 +2685745 2716291 +268581 161193 +268581 161194 +268581 31189 +268581 393874 +268583 77034 +2686001 2686000 +26863 105357 +26863 232877 +26863 3515 +268688 553039 +2686893 1111064 +268789 1972222 +2688 29855 +268816 1373278 +26883 109746 +26884 158374 +26884 228271 +26884 26385 +268846 261403 +268850 268847 +268850 480398 +268853 268850 +2688955 395913 +2688955 696257 +2688955 95537 +268897 268898 +268898 190792 +26890 86575 +2689225 2723258 +268923 216362 +268923 24775 +268923 48848 +2689557 1842682 +26896 146960 +26896 14997 +26896 31524 +26896 8364 +268962 128396 +268962 238626 +268962 268963 +268962 2691498 +268962 361028 +268962 444668 +268962 561722 +268963 12821 +268963 310367 +268963 32280 +268963 37724 +268963 396683 +26899 120457 +269 1931427 +269 3691787 +2690116 1047947 +2690116 1092492 +2690116 3011155 +2690116 495010 +2690116 867659 +2690213 1742433 +269052 11442 +269090 262455 +269090 287849 +269094 156316 +269094 500717 +269095 1082453 +269100 40915 +269138 379282 +2691464 716069 +2691464 846277 +2691464 931349 +269150 269149 +26916 26917 +26916 707755 +269165 2121 +26918 112754 +26918 21742 +26918 232451 +26918 2713 +26918 3482 +26918 66152 +2692 14646 +269207 269207 +269207 626986 +269211 183514 +269211 255469 +269211 297693 +269211 299626 +269211 455886 +269211 817294 +26923 10937 +26923 13403 +26923 155209 +26923 158665 +26923 167247 +26923 26923 +26923 2851 +26923 323 +26923 3501 +26923 79813 +26923 87251 +269253 2108 +269253 287001 +269254 1025834 +269254 1041969 +269254 1053170 +269254 1233999 +269254 1437991 +269254 164279 +269254 1849294 +269254 1864137 +269254 216140 +269254 273394 +269254 334081 +269254 361807 +269254 441528 +269254 497542 +269254 538821 +269254 539272 +269254 542122 +269254 696200 +269254 826840 +269254 832917 +269254 833075 +269254 833120 +269254 833317 +269254 834378 +269254 834577 +269254 835190 +269254 836588 +269254 841441 +269254 842238 +269254 843127 +269254 850385 +269254 853844 +269254 855059 +269254 863279 +269254 867946 +269254 883380 +269254 890223 +269254 900820 +269254 940128 +269254 95539 +269254 96123 +2692598 16794 +2693172 39115 +269321 1080619 +269323 39293 +269342 13837 +269342 212809 +26936 66817 +2693602 1379905 +2695 250934 +26952 292354 +269548 32480 +26955 104514 +26955 144053 +26955 157450 +26955 177340 +26955 205037 +26955 205127 +26955 212489 +26955 234422 +26955 262359 +26955 264223 +26955 286198 +26955 32192 +26955 32194 +26955 32197 +26955 325501 +26955 434336 +26955 456210 +26955 457732 +26955 473207 +26955 499946 +26955 550261 +26955 553950 +26955 560259 +26955 600882 +26955 653366 +26955 653368 +26955 653370 +26955 663392 +26955 712501 +26955 750532 +26955 754978 +26955 805034 +26955 853983 +26955 925650 +2695858 1461644 +2695858 2695859 +269594 270026 +269596 341395 +269596 376962 +269596 460826 +269597 350645 +2696029 2496632 +269617 79293 +26963 179076 +2696624 2002471 +269671 226144 +269671 286896 +269671 621526 +269671 939866 +269697 37820 +269697 402640 +26977 217969 +269776 157444 +269799 289089 +269799 379830 +269799 43745 +2697998 120307 +2697998 487029 +269802 1480462 +269802 272946 +269812 12965 +269812 593864 +269815 36174 +269815 7830 +269863 8699 +269868 2266703 +269868 251778 +269868 259074 +269868 267675 +269868 834378 +269868 859448 +269868 883641 +269918 262864 +2699195 2699189 +26992 104174 +269949 2010779 +269971 412337 +27 1226373 +27 34685 +27 790612 +270000 222384 +270000 32202 +270000 465884 +270000 909773 +270027 1277416 +27004 27005 +270057 272690 +27006 73121 +270073 131874 +270073 131875 +270085 271488 +270085 279916 +270085 682447 +27010 62925 +270118 919614 +270119 270120 +27012 1289343 +27012 164195 +27012 40857 +270172 289621 +270172 3182008 +270172 402341 +270172 431861 +2702042 141246 +270225 1012727 +270225 1025834 +270225 1032225 +270225 1032226 +270225 1032277 +270225 1032278 +270225 1080247 +270225 1094847 +270225 1182783 +270225 1260698 +270225 1268493 +270225 1279686 +270225 1297900 +270225 1478675 +270225 1481540 +270225 1636340 +270225 1710599 +270225 173115 +270225 2517927 +270225 253133 +270225 2578612 +270225 262940 +270225 269254 +270225 274209 +270225 282137 +270225 339220 +270225 349296 +270225 368137 +270225 397620 +270225 399868 +270225 415720 +270225 424576 +270225 441528 +270225 446750 +270225 451535 +270225 462603 +270225 47742 +270225 532265 +270225 538821 +270225 55683 +270225 59756 +270225 626175 +270225 67331 +270225 696200 +270225 696260 +270225 704150 +270225 744724 +270225 833164 +270225 833560 +270225 833667 +270225 833827 +270225 835968 +270225 837527 +270225 837663 +270225 841590 +270225 841593 +270225 842223 +270225 850894 +270225 850908 +270225 850909 +270225 851310 +270225 851413 +270225 851419 +270225 855063 +270225 855066 +270225 857113 +270225 857117 +270225 858371 +270225 858372 +270225 862697 +270225 867992 +270225 882022 +270225 900979 +270225 925944 +270225 925945 +270225 937077 +270238 269594 +270238 270026 +270288 322030 +2703 35148 +270336 154944 +270347 108652 +270347 162057 +270358 119167 +270358 239008 +2703744 2703745 +2704159 62991 +27045 105921 +2705 27963 +2705099 2705101 +27052 158426 +27052 33373 +270538 1649516 +270585 270575 +270604 57216 +270618 478143 +270674 324270 +270674 3419230 +2707 113463 +2707 2735 +270814 1189726 +270814 69021 +27084 73659 +27084 73660 +2708467 2718709 +2708467 2822440 +2708467 3019693 +270855 1580765 +270881 252314 +2709067 2709063 +27091 2443967 +27091 27952 +270969 197778 +271003 22438 +271005 2094336 +271005 220359 +271005 523084 +27103 742671 +27109 328927 +2711 279160 +2711091 56958 +2711091 996143 +271129 185187 +271154 135874 +271154 136013 +271154 141326 +271154 152684 +271154 156019 +271154 1998633 +271154 265390 +271154 336123 +271154 473211 +271154 560718 +271154 74210 +271154 902666 +271155 104673 +271166 271167 +271182 59902 +2711975 438359 +2712526 2485091 +27129 228148 +27129 468212 +27129 92167 +271295 53336 +2713 2725 +271303 122055 +271303 273367 +271370 371887 +271392 10933 +271392 15261 +271392 30093 +27140 3933 +2714048 2444146 +27145 70923 +271465 1710 +271465 92167 +271470 194 +271483 202168 +271486 313154 +271486 324537 +271488 1476252 +271488 340208 +271488 385917 +27155 15223 +27155 8339 +27156 165098 +27156 234879 +271588 290039 +2716 414271 +27161 1841777 +2716384 551084 +2717022 3539 +2717447 2972198 +2717447 3044168 +2717954 1856112 +271870 1393151 +271870 192322 +271870 3248391 +271870 397617 +271870 517158 +271870 539272 +271870 703271 +271870 829980 +271870 838929 +2718709 2800640 +2718709 2805564 +2718709 3378428 +271874 1172316 +271874 1234805 +271874 2117434 +271874 340210 +271874 843127 +2718817 2506400 +271890 607721 +271956 246387 +271962 31260 +271962 5492 +271964 31260 +271967 1777623 +272019 253476 +272019 300044 +272024 8284 +272062 1127908 +272062 153712 +272062 269207 +272062 26923 +272062 296600 +272062 336113 +272062 709198 +272062 802875 +272062 967098 +272062 999037 +2721075 2806689 +272111 276797 +272114 1031998 +272114 1306699 +272114 1676573 +272114 2757853 +272114 312456 +272114 312590 +272114 759599 +272117 272119 +2721494 333519 +27216 221065 +272217 54721 +272223 112096 +2722297 747014 +272275 15443 +272275 466179 +272275 508131 +272275 665970 +272275 758216 +2723 776158 +27233 27234 +272343 1221267 +272344 307654 +272344 693743 +272352 272350 +27242 8274 +272426 325096 +272475 293153 +272487 286334 +272499 65744 +2725 2705 +2725 4 +2725 63700 +272519 185223 +272519 200311 +272519 9994 +2725311 433425 +27254 164562 +27254 88163 +272598 796025 +272601 211536 +272601 314299 +272656 23755 +272685 281313 +272690 3207 +272693 111545 +272699 168867 +272699 393461 +272699 95147 +272706 548471 +272726 198228 +272726 396836 +272726 589319 +272726 748468 +272726 8317 +272726 901329 +27273 27 +272760 1059156 +272760 785003 +272814 20991 +272814 304416 +272814 308191 +272814 447765 +2728594 342217 +2728629 1022356 +2728629 2802599 +2728734 1387602 +2728736 2139457 +2728736 473562 +272884 272885 +272929 238626 +272952 272953 +27307 1114885 +27307 148750 +27307 149278 +27307 15203 +27307 182109 +27307 205808 +27307 22773 +27307 242533 +27307 253731 +27307 328401 +27307 365684 +27307 4937 +27307 505738 +27307 759038 +27307 847074 +273087 117236 +273087 1219094 +273087 506443 +273107 25040 +273141 770740 +273161 3719 +273161 372118 +273162 19797 +2731872 3113139 +2732385 1142504 +2732385 3805 +27324 818544 +273277 32101 +273278 36738 +2732878 37030 +273350 160895 +273350 63742 +273394 1522709 +273394 347355 +273394 406285 +273394 538821 +273394 621175 +273394 835190 +273427 260456 +273481 1454465 +273520 1054398 +273520 115461 +273520 262358 +273520 502825 +273520 514541 +273520 589892 +2735444 2601372 +273592 1056832 +273592 1587336 +2736228 1356610 +273630 7027 +273650 2107021 +2737 1399 +2737 147502 +2737 462377 +2737 467741 +2737 87185 +27372 133972 +27372 178931 +27372 34671 +27372 36377 +27372 99246 +2737209 918990 +2737229 1546774 +273738 498472 +2737571 283125 +273774 670511 +2737873 266097 +273817 188983 +273817 76040 +273847 149952 +273847 164480 +273867 240755 +273867 373346 +273871 144131 +27388 235763 +2738826 1202353 +2738826 2030478 +273883 135871 +273895 325038 +273910 152098 +273910 214104 +273910 272157 +273910 304114 +273910 649836 +273910 90113 +2739440 2987301 +2739440 3569567 +2739440 3569568 +2739440 3639788 +2740212 1459935 +274034 799788 +274034 802905 +2740869 1024263 +2740869 1264237 +2740869 446471 +274156 3234092 +2742 5720 +2742 69250 +2742 754 +274209 282489 +274209 96114 +274255 269366 +27426 13614 +274288 39740 +2743064 1000315 +274325 1307709 +274325 2141820 +274325 2141821 +274325 224329 +274325 262940 +274325 289323 +274325 445532 +274325 446105 +274325 696215 +274325 754974 +274325 796211 +274325 833162 +274349 32836 +2743680 1080851 +2743680 398264 +2744065 1268551 +274429 254823 +274429 338287 +274433 59405 +274441 260091 +274468 378138 +27451 108459 +274511 79827 +27457 259284 +274582 27103 +274623 1867153 +27467 67587 +27472 11539 +27472 1280 +27472 270057 +27472 34955 +27472 362423 +27472 402640 +274769 51369 +274810 1601476 +2748687 1724617 +274879 201123 +274879 21201 +274891 148564 +274891 832608 +2749 228032 +2749 37447 +2749 609993 +2749 864128 +274915 187864 +274919 460035 +274919 91946 +2749296 167557 +274957 10514 +274957 258118 +274957 297035 +274957 41417 +274968 77638 +27497 19828 +27497 345 +274978 309874 +274979 257423 +274993 5137 +2750019 146066 +2750733 1914862 +275094 2172 +2751 432230 +275120 1098004 +2751359 1654505 +27515 1249304 +27515 3051231 +27516 1167693 +27516 2949354 +27516 3106111 +27516 353825 +27516 353827 +27516 432782 +27516 466976 +27516 951258 +27517 1411033 +27518 251812 +27518 310211 +27518 325715 +27518 5911 +27519 108566 +27519 1126409 +27519 1137908 +27519 1205069 +27519 1246963 +27519 1417030 +27519 1417031 +27519 1417032 +27519 192325 +27519 2409926 +27519 269254 +27519 276145 +27519 283473 +27519 299702 +27519 304968 +27519 304975 +27519 32196 +27519 342543 +27519 388185 +27519 3887234 +27519 523633 +27519 578727 +27519 628237 +27519 703539 +27519 747740 +27519 832661 +27519 833240 +27519 837575 +27519 873814 +27519 882022 +27519 95544 +27519 95546 +27519 961400 +27519 986114 +275193 397962 +27521 307964 +27521 88228 +2752587 2768002 +2752901 2752900 +2753 10271 +2753 23431 +2753 2964 +2753 2967 +2753 45191 +275316 539669 +275333 67656 +275350 896656 +275359 26952 +2753636 3371595 +275371 1737159 +275371 74534 +275371 885438 +2753732 504753 +275406 271470 +275456 1608826 +275456 1608827 +275456 189919 +275456 3723 +275456 958218 +27547 46261 +2755 28802 +27550 246617 +27550 317352 +27550 45057 +2755064 1213034 +275545 285086 +27555 3722 +275554 19812 +275554 224273 +275554 2265 +275610 54997 +27568 12537 +275681 1271286 +275681 2352368 +2757394 1341603 +2757394 290601 +2757394 696181 +2757394 859046 +2757685 1881856 +2757685 3227242 +2757698 129858 +275791 255411 +275800 840304 +27582 1522 +275841 252033 +27586 12237 +27586 67545 +27589 12237 +27589 27586 +275916 162460 +275922 109395 +275922 275924 +27595 338087 +275954 275952 +275954 604918 +2759807 3266950 +2760 1104 +276006 1453 +276018 3439371 +276018 3439372 +276018 3439373 +276036 276035 +276049 276050 +276086 70151 +276145 1353620 +276145 2179272 +276145 224329 +276145 260744 +276145 262940 +276145 268272 +276145 274736 +276145 368137 +276145 3887234 +276145 405840 +276145 406281 +276145 415720 +276145 415725 +276145 502434 +276145 561465 +276145 833240 +276145 833851 +276145 836665 +276145 836666 +276145 841440 +276145 95537 +2761548 432781 +276212 276212 +276212 2967940 +276215 434085 +2762227 347626 +2762262 66152 +2763184 44120 +276336 256257 +276338 1199775 +2763425 236511 +27637 27637 +27637 314876 +276416 135657 +276416 715291 +276416 773737 +276435 585178 +2764450 3654057 +276450 262940 +276465 23285 +2764827 274993 +276513 3874188 +27652 26042 +276526 458669 +2765642 913529 +276569 533168 +27657 2652537 +27658 35025 +276590 276591 +2765955 2260276 +276643 196886 +276643 85321 +276652 276654 +276676 379951 +276676 74359 +276730 176701 +276730 289906 +276757 4937 +2768371 2778036 +2769379 1449905 +2769379 1601411 +276943 114649 +27699 28448 +277 23911 +277 31712 +277 37308 +2770 444002 +27700 241674 +27700 309524 +27703 49598 +27705 179079 +27705 780860 +277096 277095 +2771094 365447 +277129 799093 +277154 195444 +277154 634731 +2771797 2599079 +277200 265006 +277200 27012 +277226 114119 +277232 970203 +277232 970204 +277268 277284 +277300 32915 +2773261 415720 +27733 1852669 +277351 321308 +277352 284163 +27736 131978 +27737 1224084 +2773764 3272532 +277392 1075521 +2774 5926 +277423 2604177 +277423 260744 +277423 283127 +277423 397620 +277423 641250 +277423 754974 +277423 832942 +277423 833071 +277423 833549 +277423 835519 +277423 855072 +277423 912593 +2774752 787880 +2774806 108987 +277497 214455 +27751 138368 +2775179 2775178 +2775394 3338600 +27754 270925 +277541 257307 +277541 289793 +277541 447940 +277541 503340 +277560 277561 +277560 590880 +277567 193778 +27757 37338 +277600 279918 +277603 508246 +27762 12261 +277654 277394 +27769 1721801 +277718 305386 +277723 255060 +2778 27646 +2778658 1116384 +2778662 1116384 +2778662 2778658 +277879 834640 +277879 834643 +2779 101500 +2779 11433 +2779 213451 +2779 239446 +2779 25003 +2779 26896 +2779 31524 +2779 8364 +277917 277918 +2779973 1705189 +278 1409 +278 1496735 +278 199648 +278 27415 +278 2825 +278 296 +278 306473 +278 325 +278 42713 +278 652 +278 966213 +278069 194 +2781 2692 +27811 209156 +278124 278125 +278141 1835653 +278166 278165 +278266 278272 +278267 275916 +278269 180456 +278269 601919 +278270 459304 +278341 69702 +278341 722249 +278354 444614 +278381 269645 +278388 37204 +278395 10775 +2784 2585 +2784295 2784298 +27843 36738 +278520 278519 +2785956 361626 +2785956 361628 +278654 278656 +278663 463982 +2786686 1619123 +2786693 612349 +278710 434826 +27872 38579 +27873 853260 +278755 249375 +278781 274433 +278781 59405 +278786 979947 +278840 88501 +278866 212594 +278866 259699 +278866 347315 +278866 789366 +278866 918746 +278866 999452 +278871 139175 +278893 29020 +278905 10780 +278905 424227 +278917 149439 +278917 227896 +278926 425610 +278966 184136 +278966 2043159 +27899 149373 +2790071 2487608 +279017 186991 +279078 152277 +27909 6636 +27909 7707 +2791022 3142738 +279133 9703 +279142 3378193 +279144 21070 +2791440 2529683 +2791443 2529683 +2791443 2568775 +2791443 2791440 +2791855 3348123 +2791855 526596 +2791855 868929 +2791855 884633 +2791855 895152 +279186 868354 +2792217 3675675 +2792442 3557130 +2792442 3830458 +27925 1735 +279253 38916 +279253 419416 +279253 571547 +2792598 2792599 +279287 1464362 +279290 94647 +27937 1174362 +27937 12341 +27937 260790 +27937 265417 +27937 285048 +27937 455881 +27937 921518 +27938 18710 +279398 1060050 +279398 339313 +279398 501406 +279400 504613 +279402 279412 +279406 279405 +279407 254379 +279407 279413 +279407 531124 +279411 1040572 +279411 682525 +279413 417475 +2795458 90863 +279555 28330 +279580 8099 +279587 458058 +279595 44117 +279595 494995 +279595 870178 +279614 1412846 +279614 1412850 +279614 1412851 +279614 170759 +279614 342543 +279614 523633 +279614 833579 +279614 833986 +279614 836127 +279614 859452 +279614 905491 +279672 58942 +279684 1070194 +279684 1124596 +279684 1124597 +279684 1124598 +27969 10754 +27969 121471 +27969 27969 +27969 39115 +27969 45835 +27969 55500 +27969 795116 +2797291 847749 +2797506 2204671 +279761 1785512 +279762 279764 +279763 279762 +279763 279764 +2797919 1982304 +2798017 2711471 +279813 388805 +279843 279844 +27985 46980 +27986 58405 +27986 79759 +2798995 878630 +27990 328137 +27991 315789 +2799143 3241212 +279916 271488 +279921 315839 +279972 42138 +280016 360659 +280033 149255 +280033 330884 +280033 447673 +280033 494407 +2800615 2800664 +2800687 2318285 +28008 1389500 +28009 30849 +28009 4488 +2801102 283125 +280113 280111 +2801385 798749 +28014 112313 +280143 1008035 +2801458 805706 +28015 250800 +280153 224312 +28017 91428 +280177 37731 +280177 696188 +280177 716084 +280177 754894 +280177 754974 +280177 826840 +280177 864674 +280177 95546 +280200 1025710 +280200 106848 +280244 257721 +28025 79905 +2802574 2801647 +2802574 6381 +280261 69470 +280268 2018779 +28029 430166 +280341 195887 +280383 60681 +28039 1073237 +280409 57128 +2804293 2561435 +2804293 2804294 +2804294 2561435 +280436 28938 +280437 202422 +2805 76828 +2805259 194 +2806063 2806064 +280613 686316 +280623 280623 +280623 532254 +28063 21416 +28063 37849 +280631 280632 +280662 607257 +280662 669925 +2806688 2379210 +2807 15887 +2807 18700 +2807 93287 +28070 240168 +280705 84214 +280724 349282 +280724 364512 +280724 384818 +280724 514024 +2808101 1129490 +2808101 2310352 +28082 226398 +28082 236034 +28082 291641 +28082 395144 +28082 425235 +2808213 1025076 +2808213 1138217 +2808213 2000491 +2808573 2286905 +280863 364538 +280866 2422119 +28089 27834 +280916 257700 +2809194 3316810 +2809194 527475 +2809494 857828 +280988 1278303 +280988 153980 +280988 884545 +281 281 +281 35648 +281 6748 +281 88426 +281 9018 +2810 776 +281041 441821 +281041 55029 +281041 55080 +281041 636007 +281059 1258503 +28110 148996 +281120 139487 +2811293 1415043 +281133 7247 +281157 91456 +2811620 2649819 +281172 281171 +28118 125295 +28118 43290 +281184 249271 +281184 332256 +281197 164824 +281209 184258 +281209 246846 +281209 262492 +281209 281211 +281209 297269 +281209 321043 +281209 321956 +281211 321956 +281213 292493 +28122 4703 +2812449 268183 +2813 1083695 +281313 217242 +281313 29974 +281314 3456734 +281340 300031 +2813543 2813544 +281365 188649 +28141 122390 +28141 12773 +28141 242038 +2814180 2814181 +281440 22851 +281440 2545620 +28151 180461 +281519 1200078 +281527 2302581 +281531 567727 +28160 17794 +28160 273763 +28160 49719 +28160 93756 +28164 1074732 +28164 110556 +28164 20760 +28164 241255 +28164 28183 +28164 29358 +28164 46699 +28164 94159 +281649 24254 +281649 357137 +28179 261838 +28179 44543 +281865 191036 +281866 146155 +28187 320780 +2818966 258318 +2819168 869854 +2819488 1138900 +281956 1542356 +2819580 1577214 +281968 1987817 +281994 1031330 +281994 166685 +282003 169336 +282009 271214 +282010 135914 +282010 328181 +2820629 233571 +282067 282067 +282067 301357 +282086 232049 +28209 4223 +28209 465585 +28209 51188 +28209 93375 +2821069 41891 +2821262 2821254 +282137 1328919 +282137 532265 +282137 550341 +282137 696260 +282137 784121 +282137 838930 +282137 926720 +282137 982126 +28222 15824 +28222 217977 +28222 50892 +28222 64813 +28222 878166 +28222 9042 +282232 312163 +282240 17827 +282240 258118 +282240 267099 +282240 29058 +282240 44120 +282240 44944 +282287 355 +282287 531927 +2823 116177 +2823 137942 +2823 168579 +2823 2081 +2823 210389 +2823 218 +2823 285 +2823 42075 +2823 87941 +282300 290623 +282322 154356 +282322 178108 +28242 17140 +28242 19357 +28242 3446 +28242 488 +28242 73473 +282436 1830214 +2824886 1430224 +282489 648076 +2825 119661 +2825 190251 +2825 296 +2825 299 +2825 417 +2825 50514 +2825 8880 +282524 564424 +28255 10642 +28257 15861 +28257 4385 +282641 282643 +282643 1846756 +282643 888264 +282644 282639 +282644 987862 +282650 388 +282723 162617 +282723 888970 +282723 89660 +282775 374898 +282775 461787 +28278 148333 +28278 262623 +28279 73045 +2828200 2828199 +2828200 3162357 +28286 30918 +282895 1185480 +282918 283978 +282918 577400 +283 1247 +283 149278 +283 190251 +283 1961 +283 2111 +283 242345 +283 2823 +283 283 +283 327234 +283 4124 +283 45650 +283 6091 +2830 61335 +283021 276460 +28306 46000 +28308 117461 +28308 56095 +283105 844489 +283106 208267 +283106 282137 +283106 36864 +283107 1116644 +283109 282137 +283109 283106 +283109 757911 +283110 835730 +283110 973597 +283111 153980 +283122 1152498 +283122 1222912 +283122 1450896 +283122 260744 +283122 269254 +283122 2757394 +283122 304968 +283122 325672 +283122 442174 +283122 454293 +283122 575046 +283122 683885 +283122 696193 +283122 696225 +283122 696253 +283122 744724 +283122 833070 +283122 833071 +283122 833073 +283122 833163 +283122 833167 +283122 833628 +283122 833770 +283122 837529 +283122 837588 +283122 842222 +283122 842223 +283122 850889 +283122 850895 +283122 850897 +283122 850906 +283122 851344 +283122 854230 +283122 869796 +283122 874944 +283122 899693 +283125 1267800 +283125 805380 +283127 108568 +283127 260744 +283127 269254 +283127 283122 +283127 2982835 +283127 465982 +283127 754974 +283127 834073 +283127 842238 +283185 117654 +283192 390524 +2832 211569 +28324 27459 +2832406 177200 +2832406 553402 +28327 182269 +28327 43338 +283280 1244753 +283280 1801211 +283280 3027200 +283280 766937 +283280 914956 +283280 947490 +283280 990604 +283280 990605 +283300 1608826 +283300 1608827 +283300 275456 +283300 330164 +283300 958217 +283311 130230 +28332 29810 +28332 86093 +28333 838375 +283400 181073 +2834011 2961523 +2834208 162712 +28345 7444 +283455 283456 +2834576 2834575 +283469 1028377 +283469 1031891 +283469 1040749 +283469 1043205 +283469 1043208 +283469 1053170 +283469 108565 +283469 108568 +283469 1116783 +283469 1216065 +283469 1218998 +283469 1241458 +283469 1283938 +283469 1288459 +283469 1334420 +283469 1336426 +283469 1371992 +283469 1476956 +283469 1507460 +283469 1518735 +283469 153980 +283469 157707 +283469 1679539 +283469 1679540 +283469 1725072 +283469 1730499 +283469 1771431 +283469 2054086 +283469 226461 +283469 2394180 +283469 2593786 +283469 260744 +283469 262940 +283469 269254 +283469 282137 +283469 283122 +283469 283127 +283469 299702 +283469 3009093 +283469 304975 +283469 308115 +283469 3156134 +283469 3269719 +283469 349404 +283469 3520412 +283469 3542000 +283469 3736309 +283469 388185 +283469 394791 +283469 395913 +283469 397620 +283469 406273 +283469 406281 +283469 415720 +283469 424576 +283469 435555 +283469 442174 +283469 444606 +283469 454293 +283469 455839 +283469 459673 +283469 460621 +283469 465982 +283469 517144 +283469 517158 +283469 517165 +283469 521381 +283469 533488 +283469 547969 +283469 547971 +283469 573251 +283469 578727 +283469 578737 +283469 604396 +283469 617133 +283469 620726 +283469 623293 +283469 641250 +283469 646857 +283469 653372 +283469 688151 +283469 688716 +283469 696188 +283469 696225 +283469 696238 +283469 696260 +283469 706861 +283469 712270 +283469 725217 +283469 730302 +283469 754894 +283469 754974 +283469 823058 +283469 832673 +283469 832897 +283469 832898 +283469 832899 +283469 832900 +283469 832917 +283469 832924 +283469 832942 +283469 832962 +283469 832989 +283469 833155 +283469 833167 +283469 833168 +283469 833293 +283469 833317 +283469 833560 +283469 834578 +283469 835066 +283469 835073 +283469 835132 +283469 835214 +283469 835735 +283469 836429 +283469 837533 +283469 837615 +283469 837960 +283469 839412 +283469 839640 +283469 840069 +283469 842079 +283469 842134 +283469 842238 +283469 843643 +283469 844419 +283469 845919 +283469 848066 +283469 855056 +283469 855971 +283469 856008 +283469 857318 +283469 861505 +283469 861506 +283469 861507 +283469 867251 +283469 867740 +283469 873178 +283469 873272 +283469 874943 +283469 881800 +283469 882022 +283469 883808 +283469 883962 +283469 883966 +283469 883967 +283469 896804 +283469 899565 +283469 900807 +283469 903854 +283469 907454 +283469 922635 +283469 925945 +283469 946554 +283469 95537 +283469 957730 +283469 959375 +283469 973391 +283469 988905 +283469 998825 +283469 999914 +283473 1009447 +283473 1028502 +283473 1042460 +283473 1058892 +283473 1065000 +283473 1067144 +283473 108439 +283473 1117724 +283473 1126066 +283473 1146034 +283473 1165499 +283473 1205069 +283473 1208600 +283473 1264237 +283473 1337833 +283473 1360089 +283473 1360090 +283473 153980 +283473 1589566 +283473 179709 +283473 1886097 +283473 192325 +283473 216140 +283473 226461 +283473 229547 +283473 260744 +283473 262940 +283473 269254 +283473 279614 +283473 283122 +283473 299702 +283473 304975 +283473 328844 +283473 343871 +283473 3488542 +283473 349139 +283473 359260 +283473 364838 +283473 368137 +283473 374012 +283473 388185 +283473 394796 +283473 397616 +283473 406281 +283473 406283 +283473 415720 +283473 446471 +283473 448008 +283473 452918 +283473 456926 +283473 490281 +283473 490290 +283473 544894 +283473 576026 +283473 578727 +283473 617133 +283473 647526 +283473 696188 +283473 696225 +283473 696257 +283473 711106 +283473 725144 +283473 736605 +283473 754894 +283473 778532 +283473 800996 +283473 805613 +283473 809856 +283473 832661 +283473 832688 +283473 832915 +283473 832917 +283473 832934 +283473 833027 +283473 833033 +283473 834378 +283473 835088 +283473 835190 +283473 837575 +283473 837577 +283473 837960 +283473 838226 +283473 841213 +283473 841533 +283473 84236 +283473 843526 +283473 844250 +283473 846281 +283473 847818 +283473 849690 +283473 849795 +283473 859452 +283473 864674 +283473 865618 +283473 867849 +283473 869796 +283473 869797 +283473 872030 +283473 880293 +283473 883641 +283473 883777 +283473 893590 +283473 896980 +283473 899843 +283473 900448 +283473 905483 +283473 905982 +283473 926730 +283473 931368 +283473 946948 +283473 959744 +283473 967915 +283473 970754 +283473 970755 +283473 986222 +283562 394342 +2836124 1591518 +2836176 2087623 +28365 11419 +28365 356722 +28365 64601 +2836725 375279 +2836725 598601 +2836725 703539 +2836725 729646 +283720 35527 +28377 1030128 +28377 3147575 +28377 384744 +283770 75314 +283779 343949 +2837958 1717018 +283819 216181 +28384 1041347 +28384 18985 +28384 58034 +283844 391275 +283844 990048 +283852 1739439 +283857 412630 +2838785 128744 +283882 5965 +2839045 3517404 +283908 297391 +2839109 2559964 +2839115 2966197 +2839318 1169887 +2839799 169976 +284021 1498743 +284021 184746 +284056 202075 +284099 2543168 +284099 347268 +284099 838882 +284100 1321033 +2841003 837754 +284162 3128130 +284204 255556 +284204 306609 +284204 37731 +28421 66861 +284214 655270 +28425 37720 +28425 459768 +284279 200094 +284349 1207592 +284349 888250 +2843542 835350 +2843542 997629 +284369 375197 +284369 59411 +2843693 2850812 +284422 267089 +284473 928166 +284477 296438 +284477 77860 +2845 1373 +284554 403355 +2845640 2467259 +28465 36612 +284667 146487 +284667 760704 +284677 1610825 +284677 1610826 +284677 1610827 +2847174 2847175 +28477 20069 +284786 181461 +28481 490 +28481 57481 +28481 800128 +284810 218606 +284814 426333 +284814 932327 +284821 299084 +2849 169830 +2849 192570 +2849 248607 +2849 311 +2849 372109 +2849 462750 +284939 748625 +28495 96853 +28496 28496 +284994 1345894 +284994 140234 +284994 257966 +284994 44937 +284994 706774 +284995 1147623 +284995 1746505 +285 1182 +285 168579 +285 202099 +285 218 +285 2291 +285 23096 +285 285 +285 34001 +285 57811 +2850 3498 +28504 151118 +285042 520245 +285042 63158 +285048 921518 +2851 13403 +2851 215179 +2851 2320 +2851 29112 +2851 3503 +2851 96593 +2851204 1507599 +28519 64929 +2852 601787 +2852 93337 +285205 188941 +28521 194667 +28521 47336 +285211 285212 +285211 82663 +285212 82663 +2852192 3180501 +285220 185492 +285220 69003 +285231 104673 +285231 135871 +285231 297693 +285231 45102 +28525 2571203 +28525 65887 +28529 1471530 +2853417 1612497 +285394 236623 +285394 325649 +285394 387946 +285416 5521 +285416 8349 +285420 133972 +285420 277716 +28546 11816 +285463 1551692 +285463 2043409 +285469 285470 +285484 1760435 +285484 2799403 +285484 285484 +285484 290376 +285484 7830 +2855180 1159365 +2856 45583 +285616 2396811 +285616 866594 +285619 9764 +285631 14014 +285633 201497 +285642 178557 +285642 224157 +285648 11887 +285648 630262 +285648 676272 +285653 208449 +28568 101317 +28568 134249 +28568 153320 +28568 306473 +28568 311327 +28568 87442 +28568 901332 +28568 91554 +28568 996474 +285692 1571441 +2857 55648 +2857 9796 +285728 1101612 +285761 15975 +285885 1672188 +285885 24072 +285885 79 +285887 16249 +285887 387602 +285904 375659 +285904 79253 +2859358 1036751 +2859358 1036752 +286 1398 +286 1409 +286 197971 +286 24059 +286 423393 +286 52396 +286 58578 +2860 73258 +286020 2116 +286020 22712 +286042 436537 +286086 538821 +286086 835190 +2861 29921 +286135 143549 +286161 957815 +286191 129723 +286197 139845 +286198 325501 +286198 653366 +286198 653368 +286198 653370 +28621 8593 +28622 28568 +286228 397463 +28623 273283 +286271 188433 +28630 54879 +28635 196690 +286388 1183673 +2864 78482 +28644 112889 +2864746 2685745 +286496 103384 +286596 1212990 +286596 355454 +286643 792494 +286691 101552 +286806 2029611 +286807 286808 +286807 364544 +286807 65376 +286808 266389 +286808 364544 +286808 65376 +286825 98053 +286867 824637 +286868 383050 +286969 57800 +286984 19594 +287001 2108 +287066 1012357 +287066 1083537 +287066 188041 +287066 413127 +287066 446295 +287066 550261 +287066 625650 +2871 126328 +2871 26195 +28711 47621 +2871212 2829647 +2871359 2689392 +2871359 3298939 +287139 357939 +2872 8191 +2872427 124039 +2872427 2872428 +2872427 2872429 +2872427 4382 +2872427 5068 +2872428 124039 +2872428 2872429 +2872428 4382 +2872429 124039 +287259 523025 +2872662 3862747 +2872662 3870544 +28732 928337 +2873266 1381498 +2873325 2873326 +2873327 2873325 +2873327 2873326 +287369 347795 +2873693 2529197 +287375 307736 +287375 406094 +287375 52560 +287377 836526 +28738 36988 +287437 21266 +287440 1339743 +28749 1328023 +28749 232217 +28749 24376 +287519 780993 +287527 340112 +28754 151138 +287575 2287350 +287575 3039684 +2876 64166 +2876 830834 +287610 512215 +287616 1150189 +287616 268503 +287625 103546 +287631 264947 +287646 232242 +287646 243872 +2876642 2876641 +287702 1070099 +287756 903184 +287778 583803 +2878336 1220882 +287849 30185 +287849 787242 +287851 3122513 +2879 20092 +2879 71166 +287919 287918 +287928 313496 +287928 350937 +287928 76092 +28795 105134 +28795 145697 +28795 15973 +28795 23755 +28795 773267 +288 10213 +288 32695 +288 4781 +288 48849 +2880 1031522 +2880 133248 +2880 16926 +2880 245061 +2880 723894 +2880193 2880194 +28806 58002 +28806 85314 +288069 208850 +288069 65869 +288082 142045 +288082 144131 +288082 252220 +288092 145077 +2881762 2585396 +28819 675541 +28822 46640 +288268 38201 +2882883 1849338 +2882883 1977477 +2882883 2262477 +2882883 249584 +2882883 3039466 +2882883 3067086 +2882883 3219528 +288335 288334 +288366 157220 +288366 386863 +288394 327839 +288457 101324 +288457 1182581 +288457 1224221 +288457 1716872 +288457 3430871 +288457 45650 +288471 73579 +288508 438820 +28855 798568 +28857 346879 +28857 55566 +288583 844393 +288589 384744 +2886533 266992 +288657 105878 +288657 1336541 +288657 25874 +288657 33471 +288657 40582 +288657 91898 +2886723 2530017 +2887454 839640 +2887454 870172 +2887463 2887534 +2887463 816008 +2887463 838356 +2887463 838357 +2887463 838360 +28875 25395 +2887534 816008 +28880 187089 +28880 194 +28880 272994 +28880 70743 +28880 814517 +288826 288457 +2888276 343775 +288828 1176805 +288828 914700 +288861 889719 +288861 889724 +28891 137860 +28891 70605 +28891 72240 +288913 143878 +288920 103064 +288920 597220 +288929 238001 +28896 131654 +289 1989 +2890181 2183190 +28903 129738 +28906 424324 +2891027 3264301 +2891067 2891185 +289109 12584 +289116 85889 +289120 108749 +289120 1142907 +289120 1224084 +289120 227769 +289120 242557 +289120 289198 +289120 331100 +289120 450249 +289120 519215 +2891712 213918 +2891712 3184631 +2892047 2729488 +289263 166939 +2893 162035 +2893 4367 +2893 4384 +289323 445532 +289323 446105 +289323 696215 +289323 796211 +289327 289326 +28933 10152 +28933 161422 +28933 2320 +28933 395424 +28933 57809 +28933 754261 +28934 1583520 +28938 135017 +28938 2583915 +289402 289403 +289415 119782 +28943 20684 +28943 5595 +289473 250740 +2894784 1245575 +2894784 1272324 +2894784 1404047 +2894784 1421398 +2894784 1628927 +2894784 731416 +2894784 834330 +2894784 909193 +2894784 909198 +2894784 909961 +2894784 923346 +2895 71562 +289505 257353 +289519 1300812 +289519 1374321 +289519 1671768 +289519 2079156 +289519 2115800 +289519 2545309 +289519 2545310 +289519 269254 +289519 832917 +289519 933757 +289522 1112340 +289522 212299 +289522 262940 +289522 454293 +289522 835518 +289522 841301 +289522 858577 +289522 880077 +289522 880769 +289522 975597 +28953 42757 +289531 289530 +289567 23165 +289567 900110 +289568 1942373 +289568 52833 +289594 24046 +289595 26101 +289595 33801 +289595 55325 +2896013 3020600 +2896013 3020601 +289614 289613 +289619 1003349 +289621 3182008 +289621 431861 +289622 2334171 +289622 3072217 +289628 1154817 +289628 1213471 +289790 253592 +289790 255882 +289793 447940 +289793 503340 +289811 1418645 +2898255 22391 +28986 47961 +289877 249089 +289877 799773 +28992 235697 +28994 595958 +289943 164421 +289960 251623 +289960 438304 +2900 38603 +2900 43395 +290031 184818 +290036 184085 +290135 163993 +290135 2003439 +290135 2003440 +290135 805900 +290135 919326 +2901643 1377845 +2901694 2249685 +2901694 3087775 +2901920 3401076 +2901920 4845 +2902 36400 +2902 453780 +2902 63220 +2902381 317859 +290263 339646 +290281 250136 +290290 104472 +290364 1315854 +290364 86192 +2903738 3022977 +290376 505029 +29039 460054 +290433 29806 +290433 638091 +2904418 2904417 +2904418 35125 +290448 103387 +290503 862781 +290528 290530 +29057 10578 +29057 4848 +290579 290581 +29058 126771 +29058 258118 +290582 290579 +290582 290581 +290582 322293 +290582 436811 +290587 255183 +2906 10435 +2906 171 +2906 32613 +2906 3680 +2906 482954 +2906 81210 +2906 88 +290601 1031262 +290601 1040749 +290601 1040777 +290601 1165556 +290601 1208452 +290601 1229978 +290601 1239660 +290601 1341603 +290601 1341604 +290601 1377659 +290601 1415867 +290601 1415870 +290601 1415871 +290601 1416944 +290601 1430196 +290601 1450542 +290601 1478674 +290601 1478675 +290601 1478676 +290601 1640320 +290601 1640328 +290601 1651128 +290601 1653542 +290601 170760 +290601 1909874 +290601 1971571 +290601 2207653 +290601 2357523 +290601 283122 +290601 454293 +290601 577808 +290601 626175 +290601 696181 +290601 696215 +290601 696220 +290601 703271 +290601 833554 +290601 833625 +290601 833698 +290601 841593 +290601 851418 +290601 851419 +290601 854228 +290601 855065 +290601 858375 +290601 859046 +290601 868929 +290601 882024 +290601 889836 +290601 896995 +290601 900979 +290601 922015 +290601 973039 +290601 973041 +290601 973042 +290601 974483 +290615 290616 +29062 278839 +29062 388545 +29062 425236 +29062 426056 +29062 77089 +29062 93921 +290625 192541 +2906343 1536364 +290646 134742 +29065 36870 +29065 37032 +29065 62770 +2907014 2907013 +290718 972507 +290728 43274 +2907378 1029019 +29074 11733 +29074 1468740 +29074 28622 +29074 985506 +2907681 63758 +29078 38034 +290781 190269 +290785 4957 +2907890 1719022 +2907919 3213496 +2908424 2908423 +2908566 1728120 +29091 6229 +29101 14457 +2910106 3738297 +2910450 433360 +29106 754169 +29108 210415 +29112 13403 +29112 143109 +29112 215179 +29112 26923 +29112 651 +291135 518265 +2911455 2911456 +2911601 258007 +291164 708613 +29121 114414 +291231 249231 +291257 148391 +291286 135847 +29130 321184 +291316 215244 +291339 302596 +2913543 1943390 +2913543 912386 +2913543 912404 +291491 287988 +291496 1593473 +2915993 120236 +291620 276060 +291628 54775 +291653 357971 +29166 120459 +29166 120461 +291688 305283 +291688 44427 +2916983 2916967 +291730 576792 +2917315 2471724 +291743 41649 +291766 1523766 +2917759 497259 +2918308 1278653 +2918308 3248391 +2918310 1245033 +2918310 1278653 +2918310 2316576 +29184 236401 +291894 214163 +291894 3275388 +291894 865304 +2919016 2919017 +2919016 2919018 +2919017 2919018 +291987 2280 +292005 61083 +292020 256582 +292039 461570 +2920446 2092924 +292048 418099 +292099 1280897 +292126 299157 +292129 252300 +292130 180932 +29223 12217 +29225 110884 +29225 99850 +292269 197272 +292269 954680 +29227 812902 +292288 122141 +29231 14900 +2923349 1899250 +292345 1440574 +292345 2518111 +292345 292349 +292345 393383 +292345 837660 +292345 841590 +292345 844441 +292345 870697 +292345 900812 +2923482 469300 +2923618 2561435 +2923618 2804293 +2923618 2804294 +292394 296718 +29241 42110 +292438 33471 +292438 386863 +292442 169783 +292442 386863 +292443 433583 +292491 123904 +292491 396942 +292492 268373 +292492 274468 +292493 207925 +292495 366382 +2925214 1268519 +2925214 261930 +292540 476000 +292541 794536 +292541 794539 +292561 184421 +292561 269223 +2925622 950610 +292589 154559 +292589 216584 +292610 292612 +2926149 2968356 +29262 159826 +29262 29923 +29262 8887 +292633 57919 +292640 226584 +292640 266255 +292640 773474 +29268 66261 +29270 29674 +292730 29712 +29276 236169 +292762 677904 +29278 96941 +292807 240990 +2928186 2232791 +292897 1462987 +292905 1206100 +292917 303509 +293026 134636 +293039 126 +293085 1410101 +293085 1424747 +293089 111502 +293089 184678 +293089 382934 +293089 848838 +293119 310385 +29316 157459 +293170 295028 +2931931 435981 +293219 1613658 +293253 349804 +2932915 2937251 +2933321 1447757 +293335 111502 +293338 239054 +29336 32352 +29336 38763 +29336 43445 +29336 6347 +293378 661000 +29345 30133 +29349 26310 +29349 474327 +293516 1065010 +293545 291688 +293545 44427 +29363 8252 +293634 1402493 +293683 53800 +2937 3918 +293721 293723 +293756 428443 +293791 190623 +2938876 892784 +293888 201577 +293888 44364 +293932 670761 +293950 1746 +294 2160 +29402 39505 +294059 330494 +294106 359760 +294157 1635332 +294157 333565 +294163 288990 +294243 179144 +294243 238473 +294243 498371 +294244 630261 +294257 1777558 +294306 1468395 +294306 1845899 +294306 252127 +294306 312599 +294306 367920 +294306 368674 +294306 495019 +2943182 3013358 +294393 259154 +294393 271617 +294397 1191355 +294397 290063 +294410 177342 +294480 1204589 +294480 1206836 +294480 222384 +294480 2553659 +294480 260744 +294480 262357 +294480 262940 +294480 283122 +294480 368137 +294480 379809 +294480 435555 +294480 465982 +294480 490279 +294480 490290 +294480 506006 +294480 526594 +294480 547971 +294480 567511 +294480 645741 +294480 732482 +294480 754974 +294480 833079 +294480 834378 +294480 834611 +294480 848066 +294480 864674 +294480 896978 +294480 899625 +294480 933743 +294480 942019 +294481 848501 +294481 848528 +294483 191442 +294483 328795 +294515 314301 +294515 82740 +294533 1542956 +294537 299084 +294537 75293 +2946 1116877 +2946 15167 +29460 129616 +29460 152512 +29460 460694 +294630 791169 +294678 194173 +294680 194173 +294680 294678 +294687 18981 +294687 37729 +29470 29360 +29474 3190 +294746 1002403 +294746 1002404 +294746 1022025 +294746 1028082 +294746 1043208 +294746 1057453 +294746 1152266 +294746 1325918 +294746 1326574 +294746 1426704 +294746 1457836 +294746 1724185 +294746 1728372 +294746 1817323 +294746 192325 +294746 260744 +294746 262940 +294746 269254 +294746 27519 +294746 283122 +294746 283127 +294746 2887454 +294746 2982835 +294746 299702 +294746 310388 +294746 3174982 +294746 3185073 +294746 349296 +294746 388185 +294746 397619 +294746 397620 +294746 406281 +294746 415725 +294746 424576 +294746 435555 +294746 448010 +294746 454293 +294746 466144 +294746 479033 +294746 479036 +294746 517144 +294746 517158 +294746 517165 +294746 526411 +294746 526592 +294746 538821 +294746 543206 +294746 547969 +294746 547971 +294746 552195 +294746 578737 +294746 580684 +294746 696225 +294746 704150 +294746 744724 +294746 754974 +294746 809856 +294746 814478 +294746 832915 +294746 832989 +294746 833074 +294746 833076 +294746 833155 +294746 833168 +294746 833173 +294746 833445 +294746 833554 +294746 833664 +294746 833686 +294746 833687 +294746 833697 +294746 833736 +294746 833787 +294746 833838 +294746 834073 +294746 834378 +294746 835519 +294746 837502 +294746 837511 +294746 837512 +294746 837515 +294746 837518 +294746 838878 +294746 838930 +294746 839640 +294746 841431 +294746 841593 +294746 842238 +294746 842888 +294746 844418 +294746 844419 +294746 845358 +294746 846281 +294746 846285 +294746 850906 +294746 852345 +294746 855072 +294746 859036 +294746 861476 +294746 861484 +294746 861487 +294746 861489 +294746 864674 +294746 865048 +294746 865055 +294746 865654 +294746 865655 +294746 865659 +294746 882018 +294746 883315 +294746 890223 +294746 900448 +294746 900979 +294746 901880 +294746 912007 +294746 915657 +294746 92243 +294746 978211 +294746 978253 +294746 978254 +2948 2949 +2948 63640 +294839 95516 +2949367 3393547 +294966 209301 +294966 209302 +2949944 2095467 +2950239 795011 +29507 131160 +295103 141703 +295103 17245 +2951126 890593 +2951218 2782920 +2951526 3296270 +295179 532270 +295181 84236 +2952 164980 +2952 23771 +2952 69900 +295202 123159 +295213 130900 +2952803 3224384 +2953 109038 +2953 23771 +2953 2952 +295303 315973 +295304 83188 +295369 299240 +2953785 524562 +295434 829254 +295436 283005 +2954459 1216325 +2954459 2954460 +2954459 463220 +29546 51669 +29547 12340 +29547 228032 +295484 30585 +295495 759956 +295495 759957 +295495 759962 +295504 243126 +295504 354973 +295504 3560546 +295504 87442 +2955370 583471 +2955788 2535307 +2956512 3266298 +295754 295755 +295850 1157107 +295850 529823 +295850 766102 +295940 809984 +295958 272499 +2959589 1443688 +29598 80162 +29599 661 +296 102397 +296 2323 +296 52883 +296 52884 +296 5825 +296 63828 +296 7326 +296 88426 +2960166 3815751 +29603 163679 +29603 497035 +29606 221946 +29606 27150 +29613 125138 +296133 17396 +296133 1988298 +2961372 1322495 +29614 45667 +296156 1000503 +2961669 2961668 +2961669 6919 +2961793 3063993 +296210 236481 +296210 337829 +296214 1030128 +296257 258163 +2962584 73132 +296328 319535 +296351 1972222 +296351 268789 +296351 410703 +296351 410704 +296366 159630 +296386 30219 +296389 408320 +296389 466851 +296409 153980 +296409 224329 +296409 310388 +296409 311234 +296409 3702895 +296409 3702897 +296409 377139 +296409 406281 +296409 415720 +296409 454293 +296409 495004 +296409 526576 +296409 696260 +296409 754974 +296409 833169 +296409 833560 +296409 855056 +296409 855140 +296409 880605 +296409 914678 +296409 95546 +296434 47603 +296438 18324 +296438 735854 +296445 16619 +296447 390292 +296479 989059 +296489 417014 +296496 292129 +296503 10577 +2965502 1647319 +296586 308247 +2966 195084 +2966 2965 +296624 21240 +296624 836921 +2967 2965 +2967 2974 +2967 314509 +2967 4405 +296707 1062192 +296707 312587 +296710 272601 +296710 314299 +296728 210876 +296728 37909 +296739 292500 +296745 26955 +296745 925650 +296757 323622 +2968 56781 +296820 50116 +296834 194302 +296870 1143268 +296870 1446942 +296870 28943 +296870 569192 +296870 642129 +29689 177651 +29689 2265 +2969085 64307 +29691 61342 +296953 267717 +296953 29966 +296954 17591 +296955 274978 +296955 296961 +296955 309874 +296955 326820 +296959 1450166 +2970024 302498 +2970024 354650 +297018 310367 +297020 1251146 +297020 135885 +297020 256667 +297020 257308 +297020 312587 +297020 416575 +297021 212300 +297021 237467 +297021 253462 +297021 292493 +297021 41904 +297023 297018 +297023 310367 +297025 179363 +297025 216602 +297025 334966 +297037 252264 +297037 386145 +2970763 2268580 +2970763 2970804 +2970840 509359 +297092 297093 +2971 28729 +297116 1076298 +297116 1428453 +297167 92103 +2971693 2971696 +297185 838741 +297247 1766111 +297259 44992 +297269 262492 +297269 281211 +297269 321956 +297282 122206 +297284 253731 +297284 331103 +297288 297289 +2972965 3631773 +29733 2553129 +29735 1801598 +297365 1034928 +297366 1091453 +297444 499754 +29746 95607 +297479 417469 +297485 105862 +297485 167557 +2974857 2908290 +297489 1231493 +297489 1534824 +297499 67512 +2975082 2975079 +2975387 1717018 +2975387 2837958 +2975488 1108506 +297569 406271 +297569 406285 +297605 466777 +297693 1312123 +297693 135871 +297693 149325 +297693 252611 +297693 299626 +297693 6397 +2977251 328885 +29777 13561 +29780 858086 +29782 321234 +29785 278871 +2978564 4009058 +29793 239184 +297939 1416617 +297939 1428924 +297939 264745 +297939 299993 +29795 33258 +29795 69073 +2980 969993 +2980626 2980659 +29808 151615 +29809 312351 +298099 257421 +298100 255882 +298105 16776 +29812 38204 +298134 261590 +298137 81056 +298145 314873 +29815 368034 +29819 14185 +29819 21560 +29819 40155 +29819 67930 +29819 67958 +2981971 3169468 +29820 42123 +29820 450308 +29821 106541 +29821 115863 +29821 20703 +29821 288657 +29821 386863 +29821 41891 +29821 64683 +298213 32091 +29823 167730 +29823 57116 +2982349 1332498 +2982349 996986 +298266 15614 +29827 773195 +29827 836278 +298294 89598 +298310 3788145 +29836 564543 +29841 1710 +29841 31204 +2984284 2621213 +29845 284043 +298469 882248 +29848 4614 +298561 378138 +2986085 2428251 +29862 154418 +29862 42446 +298620 277505 +298648 2960 +298680 700985 +2987 134998 +2987 224525 +2987301 3569567 +2987301 3569568 +2988 2857 +298810 28525 +2988106 3159268 +298861 28529 +298861 3030516 +298861 4213 +29890 151144 +29890 66297 +298929 29820 +298930 1323466 +298930 298930 +298936 1155903 +298936 1468981 +298936 239566 +298936 252642 +298936 340652 +298936 344428 +298936 554794 +298936 633282 +298936 663652 +299 1560 +299 2075 +299010 7234 +299044 299045 +299044 754049 +299072 316485 +299084 2166210 +299084 319438 +299084 69673 +299084 99918 +299089 367245 +299089 393488 +299106 43596 +299106 43597 +2991091 2989297 +2991575 3090089 +2991575 3746335 +299191 829659 +299192 299191 +2992027 1024398 +29921 2710772 +29921 915202 +299211 385024 +299214 3860 +29923 159826 +29923 71447 +299241 20691 +299280 491152 +299280 784858 +2992972 2196948 +29932 12580 +2993574 262469 +2993574 2993576 +2993576 262469 +29942 66004 +2994320 833738 +2994320 834713 +29944 13898 +29944 204644 +299444 652564 +299483 108652 +299485 1619150 +299485 1653467 +299538 437470 +2995650 2763258 +299585 333367 +299593 332608 +299595 156958 +2996 3649 +299608 448379 +29961 2266 +29961 95088 +29962 29956 +29962 368541 +299626 256972 +299632 625638 +299632 825043 +299632 900448 +29966 267717 +29966 296961 +29966 359857 +2996682 450844 +299670 23824 +299672 1391584 +2996792 395913 +29968 10514 +29968 252310 +29968 255116 +29968 257251 +29968 259079 +29968 274957 +29968 29966 +29968 315947 +29968 41417 +299702 1003993 +299702 1057453 +299702 1092486 +299702 1092565 +299702 1192848 +299702 1205848 +299702 1246886 +299702 1354454 +299702 1439192 +299702 1486049 +299702 1710606 +299702 190370 +299702 202094 +299702 2027433 +299702 214140 +299702 216140 +299702 2409926 +299702 253245 +299702 261293 +299702 262940 +299702 267134 +299702 276145 +299702 276435 +299702 299702 +299702 311048 +299702 317584 +299702 32196 +299702 388185 +299702 462603 +299702 517144 +299702 532265 +299702 532270 +299702 532273 +299702 532276 +299702 547969 +299702 547971 +299702 550341 +299702 566541 +299702 567511 +299702 574914 +299702 578727 +299702 583138 +299702 585178 +299702 598601 +299702 604396 +299702 628237 +299702 648567 +299702 696215 +299702 712500 +299702 747740 +299702 751505 +299702 795171 +299702 795195 +299702 800264 +299702 833240 +299702 834226 +299702 835190 +299702 835733 +299702 836429 +299702 837528 +299702 837534 +299702 837535 +299702 838983 +299702 838984 +299702 839085 +299702 839233 +299702 839234 +299702 839257 +299702 859446 +299702 859452 +299702 861489 +299702 869694 +299702 896006 +299702 896007 +299702 915943 +299702 944146 +299702 982396 +299702 998666 +2997498 227471 +29977 145256 +29977 290874 +29979 83723 +29981 1007911 +29981 1697807 +299833 299834 +2998411 3497573 +299858 299857 +29986 44120 +29990 37731 +29990 841440 +29992 217242 +29992 251777 +29992 255563 +2999280 172618 +29993 27811 +299941 322312 +299944 390125 +299944 979889 +299946 293018 +299950 993736 +299951 349506 +299951 446637 +299954 604436 +2999551 1374321 +2999551 3338724 +2999551 837534 +29996 50619 +299960 1308850 +299960 299962 +299960 377050 +299962 1308850 +299962 377050 +299966 312014 +299967 2232391 +299995 46467 +299995 79732 +3 11 +3 125548 +3 36856 +3 76872 +3 789 +3000433 87032 +30005 28937 +300050 273817 +300050 341403 +300050 374920 +300050 406280 +30008 14351 +30008 606637 +300092 55244 +30011 92281 +30021 29058 +30021 9373 +3002160 152707 +30024 190363 +30028 54650 +3003250 3366850 +300345 708613 +300363 2243355 +300363 547973 +300437 123176 +300437 702530 +300439 487824 +300455 10745 +3004678 3309635 +300539 13151 +300563 885450 +300564 1480094 +300564 700728 +3006 24051 +3006 4295 +300615 300614 +3007548 1546718 +300774 1841441 +300774 417641 +300789 76357 +300792 58096 +300802 2489387 +300802 337597 +3008214 2194365 +3008214 752964 +3008214 845344 +300850 2064751 +30088 114864 +3009093 1771431 +3009093 833697 +3009093 835066 +3009205 3009204 +3009205 3009206 +3009206 3009204 +300921 253290 +30093 15261 +300967 74966 +301 845450 +3010101 1166843 +3010101 412749 +3010101 579373 +3010101 95544 +3010101 988905 +3010569 1958244 +3010569 2123220 +3010569 2457407 +3010569 308384 +3010569 985811 +3010569 986613 +3011155 1047947 +3011155 1092492 +3011155 495010 +30116 90199 +301161 322746 +301161 343058 +30117 260790 +30117 27937 +301176 280012 +301176 961608 +3012073 225780 +301232 89628 +301240 325888 +301240 69449 +3012444 2101371 +301247 358992 +301263 1092317 +301263 1353275 +301263 303060 +301263 442174 +301263 454981 +301263 620726 +301263 823061 +301263 823065 +301263 940128 +301263 95544 +3012941 2122149 +3012941 2122150 +301304 351033 +30135 18984 +30137 113430 +30137 235146 +30137 287575 +30137 375194 +30137 566525 +30138 1128804 +30138 161063 +30138 311781 +30138 49803 +30138 594616 +301381 289567 +3014 170997 +3014 546218 +301401 1759397 +301405 254091 +301405 310554 +30142 20952 +301428 310352 +3014298 2409665 +30144 336143 +30144 41105 +30148 55594 +301636 445144 +301636 75315 +301636 900813 +301667 105692 +301667 167748 +301667 45008 +301703 153470 +301724 2165470 +301724 59288 +301796 113301 +30184 253777 +301850 301848 +301877 63228 +3018790 639840 +301916 1601161 +301917 60797 +301924 301927 +3019322 2818631 +301933 136314 +301933 249460 +301933 301935 +301935 249460 +301961 170461 +301961 182870 +301961 4825 +301961 58654 +3019798 3018349 +3019798 3940847 +302 10003 +302 95521 +30201 241086 +30201 331923 +302014 218597 +302018 920017 +302046 208455 +3020600 3020601 +302078 207945 +302078 522209 +302078 522210 +302078 832962 +302078 914150 +30211 30212 +302132 224532 +302134 1187530 +302134 224532 +302134 302132 +30219 1243109 +302272 2898950 +302274 332000 +30231 2265 +30231 410629 +302319 302320 +302355 302354 +302375 46000 +302385 262485 +302388 52556 +302392 1330560 +302446 179335 +302458 13879 +302458 96155 +302464 1094052 +302464 214913 +302464 992806 +30248 1102 +30248 56922 +302488 2027769 +302498 301724 +302498 461546 +302498 59288 +3025001 3025002 +302555 271626 +3025761 3025760 +30260 54971 +302675 854513 +302684 1198451 +3027 2742 +3027 68073 +3027200 990605 +3028 297284 +302813 36303 +302833 58137 +302869 126092 +302869 18700 +302869 421263 +302869 915075 +3028738 254347 +302881 434256 +302919 569523 +302953 302950 +303 285 +303060 1053059 +303060 1079561 +303060 289522 +303060 415720 +303060 446577 +303060 517158 +303060 526409 +303060 688716 +303060 696200 +303060 704150 +303060 833446 +303060 833842 +303060 835518 +303060 837498 +303060 839080 +303060 850889 +303060 861487 +303060 872899 +303060 880609 +303060 882033 +303060 883315 +303060 931244 +303060 940128 +30309 35086 +30309 80694 +3031099 3557130 +3031290 2634005 +30317 69221 +30318 24222 +3031803 1500213 +3031803 841431 +30320 200324 +303213 236893 +303220 171459 +303220 658385 +303220 801284 +3032589 3032588 +3032591 3319343 +3033732 2907494 +3033734 2396336 +3034 279 +303413 907402 +30344 254259 +303442 303440 +303463 411139 +3034685 3034686 +303511 31655 +303558 167218 +303575 2677289 +30360 762 +30362 7408 +303639 363131 +3036397 1377382 +303725 1599989 +303725 542891 +303754 5492 +303846 332609 +303889 1461002 +303889 182109 +303889 23423 +303889 27307 +30389 824311 +303897 474199 +303897 638593 +303951 152771 +303951 844952 +3039681 26863 +3039681 3515 +304 400297 +304 45583 +304 52407 +304 52408 +304044 194 +304044 393599 +3040501 2721059 +304067 313340 +3041 16540 +3041 9800 +304114 272157 +304114 272604 +304114 649836 +304146 181427 +304146 40445 +304146 5682 +3041494 3754803 +30419 434500 +3042 2597 +304210 306093 +3042186 1233375 +3042186 267134 +3042186 415725 +3042186 833166 +3042411 558727 +3042606 847372 +3042765 51368 +30428 36738 +30428 403483 +30428 4755 +30428 99793 +30439 71521 +304396 304397 +304416 308191 +304416 447765 +3044168 2972198 +3044390 1209675 +3044997 3196522 +3045549 201531 +3045550 1387602 +30459 73811 +3046242 2621213 +304643 51067 +30470 151751 +30475 13811 +30484 115511 +30484 2149930 +30486 120312 +30486 120620 +30486 135909 +30486 135930 +30486 251778 +30486 253240 +30486 255646 +30486 255752 +30486 256091 +30486 257008 +30486 258469 +30486 30552 +30486 306715 +30486 31617 +30486 346760 +30486 353291 +30486 357704 +30486 37733 +30486 406271 +30486 406285 +30486 55906 +30486 702275 +30486 8699 +30486 988591 +3049 1538 +3049 8260 +304917 253779 +304917 29956 +304917 446627 +304968 1018978 +304968 1021032 +304968 1025033 +304968 1038546 +304968 1047420 +304968 108566 +304968 115469 +304968 119083 +304968 1192643 +304968 1357384 +304968 1357385 +304968 1357386 +304968 1357413 +304968 1433248 +304968 1433251 +304968 1518735 +304968 1605317 +304968 1622861 +304968 1636374 +304968 177342 +304968 1883012 +304968 1922829 +304968 206281 +304968 2077458 +304968 212001 +304968 224329 +304968 227843 +304968 260744 +304968 262940 +304968 289522 +304968 299702 +304968 304968 +304968 3214951 +304968 361814 +304968 364838 +304968 368137 +304968 377139 +304968 388185 +304968 394796 +304968 395913 +304968 397620 +304968 406281 +304968 410038 +304968 415720 +304968 415725 +304968 435555 +304968 465982 +304968 472036 +304968 490279 +304968 490290 +304968 532276 +304968 532425 +304968 539271 +304968 539272 +304968 547969 +304968 547971 +304968 552196 +304968 567511 +304968 627442 +304968 647733 +304968 688716 +304968 704150 +304968 712500 +304968 732482 +304968 736606 +304968 744724 +304968 754894 +304968 833168 +304968 833181 +304968 833697 +304968 833698 +304968 833851 +304968 834378 +304968 834578 +304968 834646 +304968 835073 +304968 835090 +304968 835091 +304968 835112 +304968 835518 +304968 837490 +304968 837575 +304968 837615 +304968 846277 +304968 848066 +304968 848161 +304968 848163 +304968 853359 +304968 855032 +304968 855053 +304968 866649 +304968 867236 +304968 867251 +304968 867946 +304968 870853 +304968 883641 +304968 885767 +304968 891202 +304968 896804 +304968 899356 +304968 899843 +304968 901880 +304968 917143 +304968 926596 +304968 931349 +304968 959744 +304968 96123 +304968 969700 +304973 1056568 +304973 1057146 +304973 108566 +304973 108568 +304973 1194142 +304973 154174 +304973 1769149 +304973 192325 +304973 216140 +304973 226461 +304973 267134 +304973 283469 +304973 283473 +304973 304975 +304973 415725 +304973 521381 +304973 578727 +304973 832962 +304973 833794 +304973 835735 +304973 840462 +304973 894376 +304973 926716 +304973 931384 +304973 96123 +304973 969701 +304975 1009447 +304975 1015827 +304975 1028502 +304975 1038052 +304975 1042460 +304975 1043208 +304975 1043429 +304975 1068298 +304975 1084956 +304975 1127509 +304975 1152266 +304975 1155411 +304975 1192372 +304975 1200733 +304975 1229932 +304975 1259101 +304975 1299987 +304975 1300737 +304975 1336426 +304975 1405965 +304975 1518735 +304975 153980 +304975 157707 +304975 1584466 +304975 1612742 +304975 1655107 +304975 1691140 +304975 1691141 +304975 1697098 +304975 1854071 +304975 2036606 +304975 216140 +304975 2220261 +304975 260744 +304975 261451 +304975 262940 +304975 269254 +304975 271870 +304975 276145 +304975 283122 +304975 283127 +304975 294746 +304975 296409 +304975 299702 +304975 3009093 +304975 3010101 +304975 308115 +304975 3269946 +304975 359068 +304975 3616691 +304975 368137 +304975 374006 +304975 377139 +304975 379809 +304975 388185 +304975 394778 +304975 395913 +304975 397617 +304975 397620 +304975 406271 +304975 406273 +304975 406278 +304975 406281 +304975 406283 +304975 406285 +304975 41715 +304975 418175 +304975 424576 +304975 435555 +304975 446577 +304975 448008 +304975 448009 +304975 448010 +304975 454293 +304975 465982 +304975 490290 +304975 499563 +304975 517158 +304975 517160 +304975 517163 +304975 517165 +304975 522209 +304975 522210 +304975 526590 +304975 526592 +304975 532086 +304975 532265 +304975 533488 +304975 538644 +304975 547969 +304975 547971 +304975 552196 +304975 561054 +304975 573239 +304975 577716 +304975 578727 +304975 578737 +304975 595478 +304975 626175 +304975 627442 +304975 641250 +304975 646857 +304975 670668 +304975 696188 +304975 696225 +304975 696257 +304975 696260 +304975 704150 +304975 712270 +304975 754894 +304975 754974 +304975 762355 +304975 800996 +304975 824202 +304975 826839 +304975 832898 +304975 832899 +304975 832900 +304975 832905 +304975 832915 +304975 832917 +304975 832924 +304975 832926 +304975 832942 +304975 833033 +304975 833035 +304975 833075 +304975 833076 +304975 833108 +304975 833120 +304975 833155 +304975 833162 +304975 833163 +304975 833168 +304975 833446 +304975 833554 +304975 833560 +304975 833667 +304975 833787 +304975 834051 +304975 834088 +304975 834091 +304975 834101 +304975 834223 +304975 834577 +304975 834611 +304975 834646 +304975 835066 +304975 835073 +304975 835112 +304975 835190 +304975 835265 +304975 835518 +304975 835650 +304975 835927 +304975 836429 +304975 837008 +304975 837568 +304975 837573 +304975 837575 +304975 837661 +304975 838295 +304975 838588 +304975 838929 +304975 839412 +304975 839500 +304975 839640 +304975 840069 +304975 842233 +304975 842238 +304975 843643 +304975 846285 +304975 846290 +304975 846301 +304975 846970 +304975 847180 +304975 848066 +304975 848074 +304975 848540 +304975 848554 +304975 849674 +304975 849793 +304975 850889 +304975 853360 +304975 855053 +304975 855056 +304975 855059 +304975 860273 +304975 860731 +304975 861500 +304975 861507 +304975 863122 +304975 863251 +304975 864674 +304975 867236 +304975 867946 +304975 867976 +304975 869568 +304975 869569 +304975 869570 +304975 871323 +304975 872649 +304975 874943 +304975 880605 +304975 880609 +304975 884221 +304975 888854 +304975 900180 +304975 903854 +304975 905982 +304975 907452 +304975 907454 +304975 912007 +304975 914678 +304975 914907 +304975 916922 +304975 918339 +304975 926716 +304975 926722 +304975 942019 +304975 95546 +304975 96123 +304975 966252 +304975 966986 +304975 969700 +304975 970420 +304975 985039 +304975 988905 +304975 991636 +304997 304996 +305 48843 +305001 175568 +3050019 3058620 +305003 305004 +305003 77894 +305004 77894 +30501 217161 +3050219 3574506 +305039 631017 +3050932 2972429 +3050932 450844 +3052 40094 +30522 230559 +305274 319968 +305290 50611 +305303 163881 +305303 181306 +305307 42826 +305315 305316 +3053564 2395201 +30538 1068717 +30538 137031 +30538 138322 +30538 2953 +30538 308882 +30538 37722 +30538 509739 +30538 6212 +30542 18956 +30542 22008 +30542 228461 +30542 44915 +30542 51271 +30542 61398 +30543 130740 +30552 152707 +30552 17035 +30552 263935 +30552 2649819 +30552 2811620 +30552 304917 +30552 307409 +30552 3339472 +30552 64694 +30552 833066 +305548 137826 +30556 27587 +305562 2893 +305579 12803 +305596 1237495 +305605 165056 +305644 115177 +3056588 46926 +305681 263485 +305697 14284 +3057 1145122 +3057 1166 +3057 149910 +3057 476221 +305773 780650 +3058 137957 +30580 798700 +3058119 44915 +305844 953861 +3058675 1020583 +3058675 1292167 +305896 508500 +30592 1032611 +30592 116010 +3060 6901 +306004 465126 +306081 300117 +306093 1344021 +3061 13450 +3061 2187 +3061 242586 +306100 306101 +306133 862988 +306133 92824 +306135 442405 +30614 1098776 +306157 3543 +306195 141104 +306195 1447583 +306201 55473 +306208 306207 +306213 1129199 +306225 432912 +306277 306276 +306284 17629 +306321 232694 +306321 649423 +306324 49633 +306336 218897 +306347 1466534 +306360 474434 +306395 279273 +306398 252998 +306398 354659 +306399 152707 +306399 3002160 +306450 306347 +306466 68349 +306494 355953 +306503 592219 +306519 1738209 +306519 365085 +30653 190215 +306532 246644 +3065884 19696 +3065884 361384 +306592 980276 +3066 163082 +3066 71789 +306609 37731 +3067 14297 +306706 392439 +3067086 1849338 +3067086 2262477 +3067086 249584 +3067086 3039466 +3067086 3219528 +306715 702275 +3068272 2606344 +306897 306898 +3069 50030 +306900 1067667 +306943 214225 +306943 5611 +30695 146868 +306979 12516 +306987 1120225 +3069933 958655 +30700 23478 +3070052 448566 +30703 1168371 +30703 1345894 +30703 140234 +30703 257966 +30703 27991 +30703 284994 +30703 315784 +30703 44937 +30703 486467 +30703 706774 +307059 17827 +307059 258118 +307059 267099 +307059 282240 +307059 29058 +307059 44120 +307059 44944 +307081 258942 +307081 307082 +30709 56010 +307094 211826 +307094 494813 +307094 669477 +30717 18982 +30719 34829 +307191 128576 +307191 307321 +30721 346760 +307217 152707 +307217 30552 +307217 307409 +3072381 3072380 +30724 20991 +3072441 41400 +307263 252127 +30727 9439 +307270 128576 +307270 2128035 +307270 313047 +307296 1057439 +307296 258461 +307296 258698 +307296 313150 +307296 325854 +307296 648212 +307298 251873 +307298 259079 +307298 59251 +307307 128576 +307307 307270 +307321 128576 +307357 628155 +3073803 57116 +3074 18254 +3074 2295 +3074 3074 +3074 52417 +307409 152707 +307440 1130742 +307440 1130743 +307440 367936 +307440 390665 +307440 444102 +3074567 532086 +307513 354013 +307555 128396 +307555 256666 +307571 307570 +307580 305667 +30765 13561 +30772 340634 +30775 549522 +307759 2826503 +3078236 793064 +3078236 849062 +3078236 922565 +3078329 1093579 +3078329 455272 +3078329 624416 +3078329 740303 +307864 59411 +3079 3656795 +30790 4687 +307905 1194945 +30792 180771 +30792 35445 +307922 827458 +308 1143233 +308 168579 +308 218 +308 2823 +308 285 +308 287 +308 6748 +3080 110156 +3080119 3080121 +308017 63617 +3080284 2351048 +308113 14646 +308115 1840714 +308115 260744 +308115 27519 +308115 283127 +308115 304973 +308115 406273 +308115 406281 +308115 406283 +308115 415720 +308115 454293 +308115 547969 +308115 547971 +308115 703271 +308115 704150 +308115 754974 +308115 809856 +308115 832898 +308115 834646 +308115 842238 +308115 845359 +308115 874943 +308115 895152 +308115 903854 +308115 905982 +308115 998825 +30816 21504 +308173 1887527 +308174 308173 +30818 521568 +3083 179679 +3083 22773 +3083 7960 +308329 573683 +308351 304339 +308384 1572214 +308384 1958244 +308384 2457407 +308384 628737 +308384 987368 +308385 132084 +308385 26918 +308385 35646 +3084 552 +308465 3461398 +308465 346389 +308465 401497 +308465 615682 +30849 163556 +308505 219472 +308505 224587 +308505 33469 +308547 658870 +308559 60505 +3086079 845566 +30861 123484 +30861 42069 +308645 296707 +308684 977625 +3087775 2249685 +30878 66256 +30878 83503 +308815 224312 +308815 2446762 +308815 417780 +308815 486174 +308815 733061 +30882 37356 +308828 1610105 +308828 221040 +308828 244188 +308855 308856 +308882 1068717 +308912 236764 +308983 44991 +309 1399 +309 18655 +309 229864 +309 32437 +309 347721 +309 50166 +309 92751 +30907 30908 +309136 11879 +309139 3719237 +30915 14482 +30915 29232 +30915 30212 +30915 7619 +30918 30918 +309182 2132929 +3092 3256912 +3092 3805 +3092 4601 +3092 8834 +3092214 20557 +3092437 1779692 +30926 23223 +30926 35086 +30926 613536 +30926 63394 +30926 9555 +309282 126430 +309330 59402 +309338 469310 +309516 92184 +309548 12570 +3096 378315 +309600 246130 +309678 10780 +3097498 3097497 +3098415 206196 +309867 329638 +309874 263796 +309874 708817 +309874 97545 +3099043 1367592 +3099045 382236 +309905 309906 +30992 146445 +309920 388796 +30996 137912 +30996 22854 +309965 340735 +309976 2736154 +309980 307864 +309986 251783 +310 311 +310 47563 +310 52897 +310 7907 +310013 236948 +310025 2666557 +310027 972801 +31003 214176 +310038 1213121 +310038 1250628 +310038 380036 +310038 653535 +310038 95537 +3101 225277 +3101 239223 +3101 355659 +3101 61543 +3101 67218 +3101 7211 +3101 9439 +310107 214844 +310107 295316 +310129 24205 +310172 255801 +310172 508131 +310182 1899171 +310187 1265378 +310212 1701389 +310212 173523 +310212 541686 +310213 224329 +310213 637620 +310213 778234 +310224 2168332 +310224 773806 +310249 274957 +310249 297035 +310258 280940 +310326 43695 +310343 833462 +3103442 228917 +3103442 261974 +3103442 265629 +31035 76373 +310373 289179 +310388 1023677 +310388 1092483 +310388 1136579 +310388 1288459 +310388 2068346 +310388 269254 +310388 283122 +310388 283469 +310388 349296 +310388 3702895 +310388 3702897 +310388 39874 +310388 446577 +310388 522209 +310388 522210 +310388 626175 +310388 696260 +310388 712500 +310388 754974 +310388 832701 +310388 833168 +310388 837529 +310388 839696 +310388 846285 +310388 850892 +310388 881800 +310388 881801 +31044 187347 +310491 310492 +310491 414997 +310492 1251753 +310492 169783 +310492 310492 +310492 310509 +310492 386857 +310495 1822268 +310495 237156 +310495 924732 +310501 386863 +310508 25872 +310509 1221409 +310509 169783 +310509 237516 +310509 310504 +310509 310509 +310509 419076 +310509 64680 +310512 167557 +310512 2330489 +310512 339843 +310512 64680 +310513 1337868 +31055 1232702 +310610 310611 +31066 400030 +310697 531593 +310704 105456 +310727 254933 +31073 33688 +31077 101350 +31077 124860 +31077 16539 +31077 349744 +31077 393204 +31077 5531 +310803 546223 +310831 187059 +310937 1467735 +3109423 2518971 +3109423 3290289 +311 100450 +311 145311 +311 208130 +311 2823 +311 283 +311 327234 +311 6747 +311 6891 +311035 330721 +3110406 832661 +311048 1205848 +311048 253245 +311048 262940 +311048 276450 +311048 322315 +311048 337094 +311048 532273 +311048 795195 +311048 850893 +311048 861489 +31109 4060 +311109 966354 +3111295 238626 +3111295 258942 +3111295 84214 +311154 311155 +311155 1578039 +311155 796647 +311234 1250628 +311237 68225 +3113077 1341603 +3113077 1415872 +3113077 2012073 +3113077 854227 +3113077 896995 +311309 566005 +3113189 1341454 +311327 128053 +311327 1949181 +31138 28822 +31138 46640 +31146 15169 +31147 73815 +311494 217687 +3115 3061 +3115 32861 +311515 1605384 +31157 14592 +31157 361852 +3115964 1107137 +311613 759646 +31164 18628 +311708 311707 +311708 311709 +311709 311707 +311739 320600 +311740 145288 +311742 2981006 +311742 304917 +311744 1661669 +311744 8284 +311803 511658 +311837 473189 +3119 11583 +3119 21043 +3119 78799 +311919 318789 +311946 702784 +311963 1987817 +311963 252133 +311963 281968 +311967 82005 +312 10020 +312 13667 +312 152086 +312 384965 +312 897034 +312014 123159 +312014 295202 +312014 32388 +31207 27579 +312071 2841003 +312072 236601 +312072 343389 +312106 312021 +31211 61811 +312137 484364 +312149 52687 +312163 259154 +312163 296707 +312163 312587 +312168 445927 +312169 269081 +31219 47023 +31219 54574 +312198 353729 +312208 1205755 +312255 417428 +312257 216089 +312257 312255 +31227 100113 +31227 264767 +31227 91721 +3123 236219 +3123 238206 +312307 644241 +312307 950388 +312341 114732 +312349 2159874 +3123504 113430 +312359 312342 +3123629 1454794 +3123765 3123766 +312404 312405 +312408 2378506 +312413 2420869 +312413 927886 +312417 251873 +3124487 1262335 +3124487 1312375 +3124487 832989 +312456 1306699 +312456 1676573 +312456 2757853 +312456 312590 +312456 759599 +3124887 208025 +31249 300745 +312535 253476 +312535 339515 +3125350 2099446 +312587 1266883 +312587 870181 +312590 1676573 +312590 2757853 +312590 759599 +312618 1688184 +31262 2698689 +312645 41767 +3127097 455004 +3127508 1202355 +312775 258459 +312775 258702 +312784 297441 +3128 1399 +3128 20977 +3128 26042 +3128 3365 +3128 40575 +312855 902400 +312869 13111 +3128840 1976702 +3129 42895 +3129187 312020 +3130081 2461970 +313010 258461 +313010 258698 +313010 307296 +313010 313150 +313010 325854 +313010 648212 +3130242 3587618 +31306 619884 +3130944 1446085 +313096 1613213 +313097 1042358 +313100 304917 +313112 335674 +313150 258461 +313150 648212 +31319 2187 +313198 329205 +3132 6716 +313298 75315 +3133 6716 +313301 3119690 +313305 267726 +313324 199668 +313330 2217710 +313330 264222 +313332 253704 +313337 323622 +313342 1201306 +313396 1345771 +3134 29467 +313492 172810 +3135932 25874 +313595 1721670 +3136 51939 +313603 168273 +3136259 2171301 +3136966 621280 +31370 17888 +313734 1133723 +313768 492441 +3137687 3162172 +3137759 2073943 +31379 1857 +313816 335124 +313816 632561 +313853 239866 +3139504 2013704 +3140 191474 +3140 36052 +3140 82634 +31401 1850 +31405 9944 +3141 1229202 +3141 125142 +3141 446477 +314162 314161 +314176 314175 +31418 11210 +31418 17396 +31418 229295 +31418 2466089 +31418 3713940 +31418 672601 +3142 17531 +3142 32915 +3142 36134 +3142 4096 +31423 31424 +314238 1200241 +31424 114297 +31424 234827 +31424 270346 +31424 60546 +31425 188078 +314253 110359 +314299 235032 +314299 91828 +314301 1265566 +314301 1266883 +314301 254400 +314301 266836 +314301 312587 +314301 374059 +314301 447940 +314301 481548 +314301 531489 +314301 82740 +314301 870181 +314308 10352 +314309 166885 +314309 638302 +314333 709244 +314360 1645457 +314360 395188 +314360 440981 +314360 819170 +31439 155537 +3143926 3354703 +3144058 2058179 +3144058 215605 +314412 152707 +314412 265682 +314412 3002160 +314412 306399 +31444 1718 +31444 2169 +314507 386103 +31452 350254 +314527 100317 +3145484 2751153 +314584 200566 +314584 250492 +314593 3687902 +31462 72328 +314635 145297 +31469 31467 +3147074 2708300 +314724 1223922 +314724 522847 +314724 955406 +3147575 166838 +3147575 18473 +3147575 23102 +3148 8697 +314808 314807 +314872 298145 +314911 610202 +314911 832962 +314911 835735 +314911 95546 +314915 235032 +3149322 1340656 +3149532 3193731 +315 236388 +315 236389 +315 316 +315 777892 +315 8459 +3150042 3150040 +3150167 540454 +3150211 996062 +31516 106427 +31516 11434 +31516 17388 +31516 17389 +31516 20427 +31516 6601 +31516 8364 +31516 970650 +315202 362883 +315202 633612 +31522 1455540 +315225 421761 +31524 101500 +31524 146960 +31524 213451 +31524 239446 +31524 8364 +31526 23508 +31526 25283 +31526 374757 +31526 7137 +31526 99025 +315303 6197 +315390 1110755 +31540 31541 +31545 192949 +31550 269484 +31550 985519 +3156 1036 +3156134 641250 +3156134 688716 +3156134 873272 +315640 315642 +315642 2223755 +315661 1241253 +315669 356455 +315733 381969 +315740 1105563 +315748 1214268 +315748 26920 +315771 108970 +315771 127075 +315789 23478 +31580 151144 +315805 1310963 +315805 718200 +315921 16406 +315921 693420 +315947 253395 +315947 257251 +31596 19950 +315973 368283 +316 288 +316 320 +316026 30419 +316026 434500 +316027 120034 +316028 37233 +316028 395191 +316077 1018058 +316077 1023799 +316077 691669 +316077 707379 +316100 338 +3161066 1600031 +316115 794817 +3161252 3161251 +316133 917564 +31615 120620 +31615 145257 +31615 253011 +31615 267668 +31615 30486 +31615 30552 +31615 322272 +31615 38201 +31615 64694 +31615 988591 +31617 217242 +31617 253098 +31617 2546481 +31617 29992 +31617 37733 +3162357 2828199 +3163 23096 +3163 23507 +3163 23508 +3163 245972 +31635 645160 +316367 226194 +3163728 205836 +316429 43388 +316431 166065 +316431 184178 +316431 316432 +316432 184178 +316512 1393450 +3165250 501524 +316539 1846585 +316539 316536 +316539 580068 +316586 1859021 +316661 24214 +3166656 2723334 +3166657 2723334 +3166657 3166656 +3166657 3700792 +3167351 1735082 +316739 316741 +316759 9767 +316759 9768 +3168 5055 +3168124 3168138 +3168852 1279647 +316958 393072 +317 18088 +317 2161 +317 288457 +317 4742 +317009 113430 +317009 2532880 +317009 828778 +317017 292589 +317025 317024 +31712 125912 +31712 23911 +31712 37308 +31717 134966 +31717 166060 +31717 254088 +31717 31717 +31717 56635 +31717 83492 +317173 258435 +317190 1555740 +317190 266172 +317191 478643 +3171946 780978 +3172 14148 +3172 214851 +3172 224903 +3172 24027 +3172 34955 +31721 118528 +317259 307722 +317270 678865 +317283 165417 +3173 16888 +3173143 2981971 +31740 31741 +31742 1602790 +31742 722720 +3175 28312 +317503 519586 +3175042 2923804 +3175042 7766 +31751 130964 +31751 137880 +31751 33815 +31751 41922 +31752 120826 +31752 38905 +31752 50703 +31752 77522 +31752 97072 +317527 740624 +31753 1189981 +31753 1242891 +31753 386084 +31753 563234 +31754 1249702 +31754 20606 +31757 105915 +31757 191416 +31757 904399 +317584 446471 +317584 508213 +317584 683940 +317584 712500 +317584 841660 +317584 900180 +317604 1534778 +317635 176793 +317686 783369 +317719 1539960 +317725 15125 +31777 109832 +31777 110153 +31777 32000 +31777 39838 +31777 39909 +31777 423973 +31777 72427 +3177926 458560 +3178 227965 +3178 233382 +3178 3178 +3178 4860 +3178 77058 +31780 1485602 +31780 1612989 +317808 249573 +317835 182600 +317851 58692 +317854 307238 +317855 2239692 +317879 29974 +317889 282067 +317889 301357 +317889 317889 +317907 411322 +31798 316026 +31798 59651 +31798 72809 +317986 269396 +318 1373 +3180103 237541 +31803 110358 +31809 120188 +318106 36931 +31814 149293 +318184 475809 +31820 194 +31820 208659 +31820 22294 +31820 287009 +31821 135377 +31821 15509 +31821 21903 +31821 29777 +318214 3079 +318214 3656795 +318221 219536 +318221 2220062 +318221 2357458 +318221 46060 +318243 216140 +3182529 1261307 +3182688 3182689 +318300 2645574 +318300 564649 +318300 880725 +318311 79672 +31836 286019 +31836 47033 +318371 443259 +3183778 3151449 +31838 286079 +318396 170092 +3184 44494 +318428 318427 +3184290 1793040 +31843 584553 +31844 163850 +31844 31843 +31844 584553 +3184631 213918 +318501 274468 +318501 378138 +318508 3310355 +318508 961447 +318513 1576788 +318543 1180987 +3185670 3185669 +31864 2770 +318640 408085 +318717 529686 +3187569 3199769 +3187957 355662 +3187957 703271 +318799 40096 +318815 3637489 +318825 530369 +318829 75442 +318857 592618 +318857 740558 +318861 299084 +31887 34623 +318968 318967 +318974 1123711 +318985 854044 +3190 3187 +319012 425828 +319040 230819 +319062 1409418 +319062 697035 +3191 272379 +319179 319180 +319180 1233635 +319180 1341436 +319180 833710 +3191893 1314770 +319191 1539315 +3191981 3192022 +3191981 3192081 +3192 153755 +319206 48766 +3192461 3330094 +31937 193702 +31937 339223 +3194 13017 +3194 428135 +3194 9967 +3194 9972 +319439 415725 +319439 700443 +319439 838409 +319439 839696 +319439 877520 +319439 877524 +319439 895780 +3194794 2413379 +31951 27628 +31953 28164 +31953 31977 +319535 283556 +31955 200133 +31955 71565 +3195565 237509 +31957 228032 +31957 6086 +319576 43469 +3195952 2487359 +319626 200196 +31964 149508 +319673 265755 +319682 301214 +319702 183514 +319702 410246 +319702 449130 +319713 1414434 +319761 145272 +319761 251873 +319761 257745 +319761 259079 +319761 2664783 +319761 307298 +319761 59251 +319764 22855 +319764 48398 +319766 319765 +31977 28164 +319795 53146 +319800 1023227 +319833 119963 +31992 100113 +319932 919589 +31995 106375 +31995 613 +319977 1615158 +319978 2044466 +319978 341452 +319978 345331 +319978 630531 +319978 901455 +3199948 139692 +32000 423973 +320082 782666 +320099 2050722 +320117 120430 +3201591 3201604 +3202122 3202123 +3202744 409460 +320346 320345 +320365 653590 +3203966 616212 +320406 535617 +320474 396613 +320516 201554 +320517 16406 +320517 39776 +320536 320537 +3205465 766005 +320581 62701 +320614 2879454 +320644 320643 +320708 103640 +320708 177308 +320708 77923 +32072 790612 +320803 1180360 +320803 97917 +320804 299948 +3209 108764 +3209 19504 +3209 21763 +3209 429422 +320915 573647 +32092 75269 +3209204 1007476 +320925 1070194 +320925 1124596 +320925 1124597 +320925 1124598 +320925 279684 +32095 79672 +32096 79651 +3209673 3209672 +32098 137860 +32098 29362 +32098 92693 +320987 162849 +321 10001 +321 10020 +321 2542 +321 278 +321 302 +321 63194 +321 6759 +3210 1156 +32101 12688 +321043 262492 +321043 281211 +321043 297269 +321043 321956 +32105 32110 +32106 179985 +32109 102551 +32109 88560 +321099 3711373 +321099 609280 +321099 946130 +321128 137880 +321128 21742 +321128 222578 +321128 341733 +32115 234862 +321181 505238 +321182 366736 +3211839 203532 +3211839 676272 +321189 1712865 +321211 83565 +32122 784385 +321307 2725161 +321333 281994 +321333 361544 +321333 450674 +3213359 89704 +3214 41272 +3214 437 +3214 7870 +3214 8224 +321418 158759 +32143 224797 +32143 47076 +321435 1003513 +321435 1168814 +321435 1448069 +321435 2150642 +321435 388889 +321467 136131 +321467 1885609 +32151 71515 +32152 35445 +32156 121437 +32156 28202 +32156 80120 +321579 353951 +321625 689758 +321653 321658 +32166 55804 +321661 1144036 +32167 1447375 +321746 1442646 +3217826 3217825 +32180 1058540 +32180 1066081 +32180 1174677 +32180 119484 +32180 1275070 +32180 1317880 +32180 1356402 +32180 1405206 +32180 2005054 +32180 202092 +32180 226461 +32180 252669 +32180 258078 +32180 262940 +32180 32190 +32180 32202 +32180 454293 +32180 502823 +32180 599488 +32180 604631 +32180 626175 +32180 647526 +32180 647733 +32180 653535 +32180 677980 +32180 744724 +32180 775241 +32180 778532 +32180 786693 +32180 808105 +32180 837571 +32180 853983 +32180 861272 +32180 861275 +32180 861276 +32180 880725 +32180 915121 +32180 929166 +32181 210387 +32181 7209 +321847 321846 +32186 342176 +32187 212299 +32187 222384 +32187 270000 +32187 339754 +32187 388185 +32187 406281 +32187 456764 +32187 465983 +32187 754894 +32187 784121 +32187 833010 +32187 833128 +32187 909773 +32187 92243 +32187 924191 +32189 256132 +321899 153406 +32190 1032919 +32190 1114557 +32190 1172272 +32190 119084 +32190 205037 +32190 260744 +32190 3050475 +32190 32190 +32190 333892 +32190 368137 +32190 373346 +32190 398673 +32190 41715 +32190 456211 +32190 469216 +32190 472213 +32190 495010 +32190 574791 +32190 606128 +32190 606741 +32190 606742 +32190 641520 +32190 709732 +32190 956112 +32190 956113 +32190 986427 +32192 163993 +32192 2003439 +32192 2003440 +32192 290135 +32192 805900 +32192 919326 +32194 205686 +32194 226504 +32194 241224 +32194 53815 +32194 600882 +3219528 3039466 +321956 142047 +321956 3162967 +321956 877624 +32196 2409926 +32196 531461 +32196 747740 +32196 753821 +321961 142047 +32198 1321741 +32198 1503647 +32198 1503649 +32199 205110 +32202 1150495 +32202 1150496 +32202 1372838 +32202 2055800 +32202 212000 +32202 212001 +32202 212299 +32202 227875 +32202 2363984 +32202 252669 +32202 362480 +32202 394776 +32202 465884 +32202 506006 +32202 645741 +32202 666552 +32202 673857 +32202 808105 +32202 814407 +32202 814409 +32202 92243 +32202 929166 +32202 975597 +32203 261932 +32203 378732 +322080 315838 +3221 1083443 +3221 1479852 +322108 111582 +32211 265560 +32211 42708 +32212 318 +32212 37749 +32212 49214 +32212 634 +32212 67657 +322142 1134695 +322142 1521126 +322142 1765770 +322142 2192545 +3221502 303413 +3221502 907402 +322246 252263 +322254 1346970 +322264 170571 +3222760 31163 +3222832 2331616 +3222832 4025199 +322289 311739 +322293 290579 +322293 290581 +3223055 1456097 +3223055 1951033 +322312 1271286 +322312 2352368 +322312 275681 +322315 276450 +322315 341591 +322322 156316 +322322 166684 +322322 269094 +322329 2512463 +322437 2264 +322437 4245 +322441 357442 +322441 488958 +32245 27270 +322466 1241928 +3225 1735 +322537 454293 +322537 835066 +322537 897378 +322546 952637 +322546 999051 +322558 291518 +3226 1167520 +3226 2249 +32272 12821 +32272 268963 +32272 32280 +32272 37724 +32272 396683 +322746 343058 +322784 254108 +322784 255027 +322784 95089 +322786 321956 +322791 297939 +322791 627141 +322796 930746 +32280 12821 +32280 182374 +32280 349750 +32280 37724 +32280 396683 +32280 853581 +322814 48398 +322817 1057317 +322817 1650476 +322819 1008686 +3228250 1080248 +3228250 1208452 +3228250 1220779 +3228250 1481537 +3228250 1481547 +3228250 855073 +322826 322802 +3228358 3228364 +32284 1145122 +32284 791414 +32284 8925 +32286 1428394 +32286 153534 +32286 216729 +32286 708705 +322865 245741 +322898 177243 +322918 291731 +322918 340652 +322932 271548 +322935 1197836 +322935 373566 +322943 1003381 +32296 57508 +32299 155453 +323 283 +323 561924 +3230051 256625 +323101 415470 +323139 1306704 +323139 265057 +32318 15056 +323181 855956 +323232 21517 +323246 293022 +3232556 3546497 +323283 208266 +3232844 3232845 +3233265 1104 +3233265 2045877 +323373 323372 +3234131 1446579 +3234131 1745761 +3234131 2330456 +3234131 2523943 +3234131 283280 +323422 686470 +323472 2612015 +3234907 3234902 +3234907 3234908 +3234908 3234902 +323496 3764768 +323496 3764769 +3235 63184 +323535 202097 +3235449 3060398 +323564 1444317 +323584 1959641 +323587 3264915 +323824 382606 +323907 7679 +323972 95623 +324 1171151 +324 153320 +324 159657 +324 221179 +324 28568 +324 324 +324 35148 +324 494167 +324 97986 +3240 29472 +324000 264195 +324031 324032 +324035 21742 +324035 22910 +324095 327803 +324134 272381 +324134 28375 +324134 406726 +32416 105902 +32417 72087 +324190 253779 +324193 128396 +324193 255556 +324193 37731 +324204 324203 +324210 324209 +3242313 254986 +324244 324247 +324252 34598 +32426 11573 +32426 20161 +32426 78930 +3242984 232956 +3243 12840 +3243 21358 +3243 39024 +3243 4626 +324314 1201362 +324360 1316314 +324365 198319 +324365 291338 +324407 500963 +324420 397082 +32446 22910 +32446 7686 +324481 837570 +324481 858575 +324494 12821 +324494 268963 +324494 32272 +324494 32280 +324494 37724 +324494 396683 +324494 507554 +324496 399330 +32452 306280 +324534 529766 +324537 270088 +324537 682447 +32454 55172 +324576 452699 +324576 824901 +32459 239904 +324597 324602 +324785 48822 +3248391 3251830 +3248391 703271 +32486 29130 +324883 301152 +324893 168272 +324902 291688 +32491 101707 +324944 169336 +324944 282003 +324944 552021 +324999 1295852 +324999 651104 +325 12181 +325 15776 +325 16030 +325 1718 +325 1731 +325 231648 +325 316 +325 45392 +325 4738 +325 49614 +325 6919 +325 9165 +3250030 1374321 +3250030 2999551 +3250030 3338724 +3250030 837534 +3250032 1374321 +3250032 2999551 +3250032 3250030 +3250032 3338724 +3250032 837534 +325019 279401 +325022 1186836 +3250563 3250562 +32508 164262 +325088 1905970 +32509 66239 +32509 8011 +325101 711723 +325176 1615988 +325179 238758 +3251829 2250166 +3251830 2250166 +3251830 3251829 +3251832 2250166 +3251832 3251829 +3251832 3251830 +3251832 3251837 +3251832 3279815 +3251834 1571673 +3251834 1638152 +3251834 1638154 +3251834 2250166 +3251834 3251830 +3251834 3279815 +3251835 1571673 +3251835 1638152 +3251835 1638154 +3251835 2250166 +3251835 3251829 +3251835 3251830 +3251835 3251832 +3251835 3251834 +3251835 3251837 +3251835 3279815 +3251837 2250166 +3251837 3251829 +3251837 3251830 +3251837 3279815 +3252 1402 +325231 2202390 +325232 524650 +325253 133757 +3252998 1542273 +3252998 2837862 +3252998 3964276 +3253313 0 +325334 322981 +325345 544893 +325345 963613 +325460 149623 +32551 199215 +325514 2897517 +325520 215201 +325520 626826 +3255589 3255591 +3255590 3255589 +3255590 3255591 +325649 142047 +325649 267024 +325649 321961 +325649 325650 +325649 387946 +325672 1056568 +325672 1199356 +325672 1288459 +325672 1450896 +325672 153980 +325672 1632801 +325672 1659360 +325672 200659 +325672 2179875 +325672 2599174 +325672 262940 +325672 281041 +325672 492245 +325672 539272 +325672 636007 +325672 779502 +325672 833837 +325672 848261 +325672 913374 +325672 95537 +325743 397574 +325753 1501991 +325753 276145 +3257990 2878704 +325854 258461 +325854 258698 +325854 313150 +325854 648212 +325861 258461 +325861 258698 +325861 307296 +325861 313010 +325861 313150 +325861 325854 +325861 648212 +325878 253111 +325948 158232 +325948 265718 +32597 22609 +32597 25003 +32597 2779 +325981 15694 +325990 373460 +326 26511 +32601 121176 +32603 58277 +3260783 167972 +326081 193583 +326081 265382 +326081 265388 +326081 265422 +326081 61587 +326081 848406 +32609 32605 +326091 249375 +326174 597392 +32618 250152 +3262 37718 +32620 258119 +3262214 3214241 +3263 110156 +3263 582883 +32630 27274 +326311 209332 +326320 326318 +326403 350297 +326413 403488 +3265316 466390 +326581 402567 +326589 127391 +326657 307863 +326657 317860 +326657 849079 +3266713 1755874 +326677 254615 +3267 112738 +3267 22910 +3267 25777 +3267 3267 +3267105 3214241 +3267105 3262214 +326735 321416 +326748 410659 +3267638 1371971 +3267638 1861318 +3267638 7733 +326820 274978 +326820 309874 +326911 343051 +326945 1272939 +326945 286269 +32695 1143233 +32695 308 +32695 32695 +3269862 376312 +3269862 614963 +3269862 676432 +3270141 4030619 +327034 1371065 +327034 20956 +327034 582273 +327034 794883 +3271 13667 +3271 2091 +3271 219675 +3271335 3367378 +327234 1247 +327234 17417 +327234 190251 +327234 2471724 +327234 2478532 +327234 2917315 +327234 417839 +327234 4937 +3272366 2951526 +327258 54254 +327268 90541 +327285 613536 +3272852 325345 +3272852 3272855 +3272852 544893 +3272855 325345 +3272855 544893 +3273 22805 +3273 25654 +3273 45556 +3273144 3273144 +32735 30781 +327358 1002543 +327358 3074567 +327358 532086 +327371 95534 +327459 550633 +3274649 3274648 +327472 877189 +327489 268963 +327504 426083 +327511 328446 +327513 1210231 +327513 26274 +327513 597288 +327519 354483 +327587 645741 +32777 32815 +3277900 1039605 +327798 1583001 +3278 34530 +327803 463193 +327883 398083 +327897 327896 +327903 297663 +327936 188954 +3279446 3279447 +327946 9011 +3279815 2250166 +3279815 3251829 +3279815 3251830 +328 109676 +328 121266 +328 1230 +328 21538 +328 29023 +328 55566 +328 57974 +328034 693434 +32806 36239 +32806 46957 +32806 537653 +328061 148132 +3280647 983351 +32815 1053457 +32815 576968 +328158 272814 +328158 304416 +328158 308191 +328158 447765 +328160 1152605 +328160 1696713 +328160 328160 +328160 540358 +328160 697732 +328162 278590 +328257 3323814 +328257 520769 +328326 5087 +328329 1872647 +328329 1873739 +3283328 2756033 +3283328 457708 +328335 97072 +3283376 1476306 +3283376 3552594 +3283376 3871857 +3283542 742735 +328401 242533 +328409 265121 +328447 398944 +328449 274078 +328449 359257 +32845 22748 +32845 948339 +32847 1110 +32847 1376 +32847 178828 +32847 1790 +32847 335186 +32847 54145 +32847 598434 +32847 800866 +32847 803618 +32847 870899 +328486 32433 +328543 834158 +328543 911822 +328543 936665 +32861 3061 +3286191 111582 +3286191 111650 +3286191 118025 +3286191 18382 +3286191 186773 +3286191 20419 +3286191 6123 +3286191 93386 +328643 241021 +328646 237940 +3286665 3148405 +328731 235447 +328731 364541 +3287432 1580725 +328795 191442 +328798 1060631 +3288 21702 +3288 81088 +328809 328810 +32882 1154119 +32882 94487 +328821 612162 +32883 70534 +328856 1900632 +328856 653535 +328893 11399 +328893 1209405 +328893 1863035 +328893 200670 +328893 2017572 +328893 2187 +328893 223068 +328893 5593 +328893 68364 +328908 32439 +328912 212070 +328928 93943 +328941 1090538 +328987 693188 +3290 17743 +3290 29225 +329006 1573123 +329006 20848 +329006 515751 +329008 329007 +329009 132194 +3290289 2518971 +32904 62915 +329064 1101553 +329064 2833115 +3290674 1091530 +3290674 140740 +3290674 3297114 +3290674 799148 +32908 16797 +3290871 3347464 +32915 110627 +32915 12196 +32915 289032 +32915 36147 +32915 5125 +32915 53800 +32919 235652 +32919 491321 +3292174 1757646 +3292284 3292283 +3292675 235980 +329287 24027 +329287 329288 +329287 497778 +329323 317717 +3295 1227 +3295 3386 +3295 8828 +3295 891 +3295718 3033732 +329576 2173483 +329576 2375173 +329576 389779 +329576 878197 +329610 830699 +329620 35646 +329707 543375 +3297114 799148 +329749 130476 +329772 372478 +329772 70622 +329773 148183 +329773 417839 +329775 144843 +3298177 28517 +32984 6933 +3298939 2689392 +3298939 3298943 +32990 1830 +32990 4778 +32990 57103 +32990 81013 +329978 736224 +3299999 1490676 +3300 11864 +3300 14446 +330093 3006982 +330164 1612259 +330164 1852256 +330176 48056 +330176 986164 +33026 20562 +3302642 1440092 +3302880 1150333 +3302880 1163926 +3302880 1759585 +3302880 3981191 +3302880 3981192 +330313 1502806 +330313 509697 +330313 771018 +330341 45503 +330342 320804 +330348 2460966 +3303676 2585396 +33037 17080 +330380 26918 +330476 1405491 +3304912 3263242 +330517 412305 +330703 72480 +33076 110112 +33076 239776 +33082 11652 +33082 65273 +330829 557198 +330838 311722 +3308562 1619482 +3308562 833722 +3308562 835057 +3308562 836153 +3308562 836156 +3308562 841571 +330884 494407 +330925 173478 +330932 660203 +331008 1558692 +331008 335186 +3310737 1201210 +33110 251414 +33110 647811 +331101 231573 +331149 1143655 +3311612 359317 +331194 2623067 +331205 751999 +331217 660863 +331248 333883 +331294 191665 +3312998 1210155 +331447 332354 +33145 40729 +33145 62915 +331495 344767 +331526 352243 +331526 498002 +33153 51183 +33153 63321 +331629 1065010 +331629 131775 +331642 614707 +33165 17112 +331669 1459679 +331674 1666540 +3316810 3525404 +331699 188949 +3317 256345 +331706 1245398 +331706 301161 +331706 322746 +331706 331707 +331706 343058 +331707 301161 +331707 322746 +331707 343058 +331753 653448 +3317586 1883253 +3317586 3317586 +3318 166 +331991 1214261 +332017 17558 +332017 2316 +33203 1289580 +3320762 1927301 +3321212 1006985 +3321212 2123355 +3321212 604629 +3321212 922565 +332141 138123 +332141 874551 +332173 72582 +332187 461386 +3322 223982 +3322094 3207603 +332256 249271 +33229 2662569 +33229 2664584 +33229 844849 +332290 471403 +3323039 3769698 +332333 304917 +332351 1383630 +332423 332424 +332424 1713124 +332446 418512 +3324760 168367 +3324760 3324762 +3324761 168367 +3324761 3324760 +3324761 3324762 +332485 440675 +33257 12819 +33257 209995 +33257 2202004 +33257 250152 +33257 3482 +33257 626002 +33257 6548 +33257 666300 +33258 207965 +33258 336540 +33258 510256 +33258 59312 +33258 84849 +3326142 78572 +332668 327754 +332689 231656 +33274 381146 +33281 233501 +3329 846 +3329880 131998 +332999 21073 +333 10127 +333056 144927 +333056 230539 +333082 4700 +33313 190371 +333153 1145135 +33320 144808 +333335 1851705 +333335 89892 +333335 972281 +33335 35445 +333387 1183360 +333387 278839 +333387 54518 +333412 794450 +3334352 1509278 +3334352 327112 +3334352 3298970 +333460 931123 +333473 420819 +333485 1765281 +3335 4801 +333515 161 +333516 333517 +333516 573851 +333535 1448227 +333558 333558 +333558 908058 +333565 1635332 +333615 3000 +333615 8308 +333642 307440 +333642 367936 +333642 390665 +333644 258469 +333644 938995 +333675 643133 +3337 1464339 +3337 46955 +3337 70095 +3337 929880 +3337 9571 +3337 99415 +33371 250667 +333718 218414 +33373 158426 +3337331 1823795 +3338 10644 +3338 11986 +333839 27657 +333883 1362118 +333883 776306 +333950 198113 +333950 286622 +33409 45060 +3341 56488 +3341 56489 +3341 655124 +334143 148029 +334143 31439 +33417 137538 +33417 189462 +33417 31518 +334188 334184 +334219 74347 +33422 28909 +334232 361655 +334283 603068 +334283 880741 +334291 79732 +3343070 3808583 +3343355 324707 +334387 320846 +334392 137872 +334393 334388 +3344 43982 +334426 204510 +3344312 1779130 +334481 517063 +334496 102027 +334496 167252 +334496 909858 +334507 267653 +334554 27952 +334576 1932434 +33468 1504506 +33468 41270 +33468 7870 +33468 90203 +33469 139704 +33469 219472 +33469 33471 +33469 374288 +33469 545803 +33469 64735 +33469 94504 +33471 1478318 +33471 29821 +33471 41891 +33471 545140 +33471 94500 +3347451 236187 +3347451 65552 +33476 117415 +33476 120034 +33476 19504 +33476 559739 +33476 64739 +33476 82211 +334785 334784 +3348 2601394 +3348 71603 +3348123 868929 +334815 2532196 +334815 328988 +334815 499382 +334819 27952 +334819 341073 +334819 578053 +334819 616125 +334819 806550 +334819 894843 +3348251 1169516 +3348251 1278653 +3348251 1571662 +3348251 1638137 +3348251 2551035 +3348251 2551038 +3348251 2551039 +3348251 2918308 +3348251 3248391 +334826 42941 +3348708 250494 +3348708 749777 +3349439 383625 +334966 179363 +334966 216602 +334992 369939 +335009 1057162 +335009 555263 +335045 115466 +335045 115469 +335045 153980 +335045 262940 +335045 282137 +335045 334081 +335045 374006 +335045 377139 +335045 3774129 +335045 406271 +335045 406285 +335045 435555 +335045 538821 +335045 555458 +335045 690972 +335045 833986 +335045 835409 +335045 837568 +335045 867991 +335045 883777 +335045 95543 +335045 999914 +335052 131992 +335065 15092 +335066 376847 +335066 572751 +335067 237064 +335067 264998 +335067 335067 +335067 338277 +335067 342985 +335067 442205 +335067 572751 +335067 6919 +335086 180134 +335124 208568 +335124 214037 +335124 534732 +335124 546152 +335150 2643949 +335172 685620 +3351905 3808724 +335195 4452 +3352 10780 +3352 122695 +3352 142885 +3352 144984 +3352 224797 +3352 32143 +3352 3870 +3352 401893 +3352 4244 +3352 438783 +3352 65484 +3352 9708 +33522 184573 +33522 297408 +335241 1616 +335241 2156 +335241 383308 +33528 30552 +3352862 148 +33534 130964 +33534 30542 +33534 80325 +33534 95032 +335352 1032396 +33536 27887 +33536 45041 +335417 335418 +33542 1560 +33542 251012 +3355251 173478 +335565 335584 +335565 374399 +335584 374399 +335681 2058302 +335681 564078 +335681 767890 +33573 236410 +335741 150206 +335760 1028502 +335760 1037730 +335760 1048430 +335760 1057076 +335760 1181646 +335760 1233375 +335760 190370 +335760 224329 +335760 255804 +335760 260744 +335760 262940 +335760 267134 +335760 269254 +335760 273394 +335760 283122 +335760 289522 +335760 3042186 +335760 374006 +335760 375279 +335760 395913 +335760 397616 +335760 397620 +335760 415720 +335760 415725 +335760 479033 +335760 538821 +335760 587167 +335760 617133 +335760 626175 +335760 627128 +335760 696188 +335760 696260 +335760 754974 +335760 832917 +335760 832951 +335760 833166 +335760 835190 +335760 835518 +335760 835739 +335760 841301 +335760 842238 +335760 843127 +335760 844422 +335760 863122 +335760 872098 +335760 894188 +335760 95537 +335760 973597 +335760 980526 +33578 157073 +335780 509192 +3358 32216 +3358608 5363 +33587 17546 +3358891 3358890 +33589 2050184 +33589 254769 +33589 357656 +33589 38201 +33597 13100 +336 14179 +336 14743 +336 1530032 +336 296 +336 3533 +336 3862 +336 40347 +336 50662 +336 54813 +336002 40797 +3360552 681736 +336071 12516 +3361 823934 +33612 347823 +336123 135874 +336123 141326 +336123 152684 +336123 264492 +336123 272598 +336123 473211 +336123 74210 +336152 265057 +336152 323139 +33617 1359418 +336190 1652975 +336190 48691 +3362 195313 +3362 22158 +3362 816806 +336216 1236926 +336216 222785 +336216 336217 +336216 634 +336217 1236926 +336217 222785 +336217 634 +336248 308713 +33629 13869 +33629 207103 +33629 28100 +3363 9678 +3363028 3836440 +336320 375618 +336377 1031351 +336377 362312 +336377 408613 +336401 310027 +336402 289613 +336402 289614 +336418 3253066 +3365 1280 +3365 1821569 +3365 20977 +3365 2230632 +3365 224534 +3365 23005 +3365 2754275 +3365 2906 +3365 5867 +3365 67218 +3365 672703 +3365 861607 +336551 1295432 +336551 701295 +336564 21767 +336579 3519618 +336629 535204 +336629 956250 +33663 122286 +33670 3285675 +3367513 3587618 +336768 2737 +336768 289495 +336768 397172 +336768 546934 +3367694 918339 +3367796 960689 +3368403 3368404 +336875 555956 +33688 1310026 +33693 661 +336944 758640 +33699 15584 +337 2323 +3370 4117 +337015 8317 +33708 326473 +3370810 1245031 +3370810 1245033 +3370810 1278653 +3370810 2551034 +3370810 2551038 +3370810 2551039 +3370810 3248391 +3370827 1571673 +3370827 1638152 +3370827 1638154 +3370827 2250166 +3370827 3251830 +3370827 3251834 +3370827 3251835 +3370827 3279815 +337094 375279 +337094 521659 +337094 832962 +337094 833097 +337094 841452 +337094 843631 +337094 850543 +337094 914150 +337094 95537 +337099 278168 +337324 162275 +337324 42138 +337332 255383 +337341 378293 +33737 227461 +337430 231983 +337430 38649 +3374826 152246 +337525 18985 +337525 383353 +337535 609753 +337597 2489387 +3376 3260496 +3376061 3376060 +33762 33762 +33762 42907 +3376298 2862019 +3376298 466390 +33766 303036 +337703 1611748 +337703 1715914 +337703 183989 +33779 109664 +3378 9864 +3378 9865 +337817 109004 +337829 8990 +33783 72004 +337854 10199 +337854 1130508 +337923 13349 +338 316 +338 37905 +338 7315 +338 907144 +33801 134073 +33801 153271 +33801 177031 +33801 185134 +33801 236599 +33801 26101 +33801 355 +33801 39344 +33801 441728 +33801 535319 +33801 55325 +33801 72186 +33801 83340 +33801 90622 +33801 907196 +338072 194 +338074 2397209 +33808 96 +338107 242952 +3381437 1134414 +338203 478575 +338273 1390230 +338273 147379 +338273 1491279 +338273 325 +338273 342985 +338273 806508 +3382769 1604538 +338279 1109127 +338279 378013 +338279 441493 +338279 87442 +338287 254823 +338287 314301 +338383 2238 +338383 831675 +33843 112154 +33843 21923 +33843 407719 +338446 30602 +338446 647524 +338460 199257 +3385 10788 +3385 31752 +3385 355522 +3386 14987 +3386 232877 +3386 24463 +3386 3868 +3386 6086 +3386 7609 +3386 891 +338628 1974415 +33863 424652 +338669 1614443 +338705 967762 +338772 279398 +338772 562021 +3387785 3387786 +338947 406706 +3390027 1839396 +33905 21057 +339153 489255 +339211 105862 +339211 386488 +339211 763850 +33922 1626911 +33922 484035 +339220 156406 +339220 84648 +339248 113916 +339248 446205 +339250 191756 +339250 775313 +339250 78243 +339250 796326 +339283 220164 +33930 33932 +339330 254990 +339330 626175 +339330 92243 +339337 1750319 +339337 56446 +33938 413164 +339390 765254 +339442 218860 +339442 578405 +339442 99177 +339515 252998 +339515 265629 +339515 306398 +339515 354659 +339516 251688 +339516 263441 +339563 427738 +339564 92885 +339679 18799 +33970 230693 +3397204 45060 +339729 327883 +339729 398083 +339736 567934 +339754 282639 +339754 282644 +339754 784121 +339755 1099152 +339755 212000 +339755 212299 +339755 282639 +339755 282644 +339755 339754 +339755 339756 +339755 909599 +339755 92243 +339756 282639 +339756 282644 +339756 339754 +339756 754894 +339756 784121 +33976 61755 +339765 260744 +339765 703271 +339765 895152 +33977 1040528 +3397762 502809 +339777 137990 +339777 240290 +33979 138100 +33979 1411 +3397922 3397923 +339809 19588 +339815 702368 +339843 2330489 +33990 30636 +33990 467245 +339910 1350595 +339953 252964 +339953 471831 +34 1239182 +34 31715 +34 504402 +34 56476 +34 670 +34 73202 +34 83 +340 2282 +34001 100457 +34001 1291624 +34001 1333378 +34001 168146 +34001 168579 +34001 1718 +34001 1724836 +34001 1760435 +34001 18088 +34001 2009408 +34001 202099 +34001 278 +34001 584423 +340032 105024 +340032 1579340 +340032 551878 +340034 296709 +340034 473793 +3400595 2630235 +3400595 2829083 +340087 257306 +340087 268962 +340087 268963 +340087 720200 +340090 340091 +340090 711722 +340098 409972 +34011 193760 +34011 43208 +34011 4517 +34017 113471 +34017 135148 +34017 582500 +340172 334815 +3402 1250026 +3402 2155 +3402 521135 +340204 500717 +340208 385917 +340209 364825 +340209 439534 +340209 518157 +340234 230902 +340293 938507 +3403158 3984582 +340351 362057 +340373 255206 +340382 255206 +340382 395841 +340382 395842 +340517 59411 +34061 10431 +34061 51171 +34064 11099 +34064 6373 +340650 173615 +340650 466362 +340652 1155903 +340652 1468981 +340652 239566 +340652 252642 +340652 291731 +340652 344428 +340652 554794 +340652 633282 +340652 663652 +340675 523937 +340680 2831549 +340682 386603 +34074 29237 +340826 290801 +3408368 1263630 +3408368 3033732 +340847 220114 +340865 264626 +340865 295651 +340881 455886 +340881 6397 +340892 7863 +34092 807622 +340927 9933 +3409421 3409419 +341064 341062 +341073 27952 +341073 284939 +341073 788044 +341073 999378 +341084 270225 +341084 349296 +341084 368137 +341084 833560 +341084 833827 +341084 841593 +341084 842223 +341084 855170 +341084 900979 +341084 925944 +3411266 424754 +341127 122048 +341127 296624 +341127 569172 +3411323 916889 +341147 1053916 +341147 1096780 +341147 1275956 +341147 1977093 +341147 2098343 +341147 229547 +341147 2356605 +341147 3248391 +341147 454293 +341147 847489 +341147 913039 +341147 963375 +341147 963376 +341158 516577 +34120 1225323 +34120 1273187 +34120 1693045 +34120 4854 +34120 62809 +34120 92209 +341259 81347 +3412889 3526130 +341351 102519 +3414 44663 +341417 416188 +341432 1310066 +341432 1310073 +34145 629684 +341526 42757 +3415358 228917 +3415415 3415418 +34155 29539 +34157 31800 +34157 384512 +341573 47333 +341575 2654 +3416152 208168 +3416153 942359 +341627 984695 +34169 162097 +341733 175575 +341735 132084 +341770 365248 +341770 803904 +341780 16293 +341824 463687 +34183 2774440 +341973 341968 +342008 1561902 +3420408 1470145 +3420408 507299 +342091 105904 +3421 266231 +3421 3421 +3421 373344 +3421 48848 +3421322 3554575 +34214 6714 +3421481 3601769 +3421481 3601770 +34215 102819 +342185 459367 +342217 184622 +342309 346530 +342346 106412 +342346 160259 +342346 208732 +3423481 1775958 +342362 150836 +342363 131298 +342392 119661 +34240 1460 +3424095 69422 +342453 219568 +342457 844449 +342474 311968 +3425 4 +3425 7602 +34252 340098 +34252 409972 +342537 249247 +342541 1028020 +342541 1030674 +342541 115466 +342541 1393151 +342541 271870 +342541 395913 +342541 397617 +342541 456926 +342541 490279 +342541 626175 +342541 696225 +342541 712500 +342541 865412 +342541 882946 +342543 1012862 +342543 1023677 +342543 1053431 +342543 1105192 +342543 115461 +342543 1192372 +342543 1241315 +342543 1259762 +342543 1328764 +342543 1424464 +342543 1424465 +342543 1424466 +342543 1424467 +342543 1503519 +342543 153980 +342543 166685 +342543 1709639 +342543 1728372 +342543 216140 +342543 236185 +342543 260744 +342543 262940 +342543 270225 +342543 271870 +342543 283122 +342543 299702 +342543 310388 +342543 349296 +342543 368137 +342543 386761 +342543 388185 +342543 394778 +342543 397617 +342543 397620 +342543 39874 +342543 406281 +342543 415720 +342543 432960 +342543 454293 +342543 459673 +342543 459676 +342543 472036 +342543 517144 +342543 526596 +342543 532265 +342543 532276 +342543 573239 +342543 626175 +342543 696165 +342543 696193 +342543 711200 +342543 712500 +342543 725023 +342543 779502 +342543 823065 +342543 826840 +342543 832962 +342543 833128 +342543 833444 +342543 833445 +342543 833550 +342543 833554 +342543 833579 +342543 833686 +342543 833687 +342543 835735 +342543 837518 +342543 837529 +342543 837545 +342543 837548 +342543 838930 +342543 840548 +342543 843529 +342543 844418 +342543 846301 +342543 850894 +342543 850906 +342543 851310 +342543 855065 +342543 857113 +342543 857117 +342543 858480 +342543 861475 +342543 864674 +342543 867835 +342543 867849 +342543 882021 +342543 895152 +342543 932630 +342543 933318 +342543 95542 +342543 95543 +342543 95546 +342543 999914 +342566 882702 +342572 392341 +34265 149999 +34265 18674 +342668 15787 +34267 955009 +3426756 3906843 +3427523 534451 +3427524 3427523 +3427524 3647682 +3427524 534451 +34278 170355 +34278 180586 +34278 6520 +3428575 1165433 +342874 260898 +342874 272756 +342906 971723 +3429181 1655089 +342985 124436 +342985 243615 +342985 362652 +342985 798533 +342986 124436 +342986 1269484 +342986 276757 +342986 342985 +342986 370680 +342986 787880 +342986 798533 +342987 342987 +342987 76974 +34300 3480 +343028 343027 +3430309 3430308 +343032 264655 +343046 328591 +3430871 1716872 +3431341 1231845 +34316 166289 +34316 38776 +34316 54520 +343178 470932 +343266 1671409 +343266 19817 +343268 343269 +34336 8565 +34341 1073248 +343511 42868 +343511 772876 +3435215 1143621 +343573 272722 +3436355 3358023 +343647 270085 +343725 464793 +343725 612644 +343730 156086 +343734 1561897 +343734 279401 +343734 673902 +343766 214163 +343766 291894 +343766 3275388 +343766 865304 +343774 343775 +343780 910455 +343832 343833 +343871 833038 +343871 846281 +343902 1243323 +343902 229185 +343902 656760 +343905 836744 +343905 837588 +343905 837589 +343905 858579 +3439371 3439372 +3439371 3439373 +3439373 3439372 +343957 410783 +343957 89410 +343962 343961 +343990 166531 +343990 66494 +344065 109437 +344065 1399 +344065 1495753 +344065 224312 +344065 27952 +3440832 1659037 +344098 349671 +344166 361595 +344166 890223 +34419 59144 +344215 129083 +344215 1502806 +344215 233910 +344215 330313 +344215 344899 +344215 372109 +344215 4927 +344215 509697 +344270 28503 +344275 47336 +3443002 648057 +34432 40667 +344324 873196 +344324 958125 +344344 3203903 +3443493 1224467 +34435 232935 +344415 78110 +344428 1155903 +344428 1468981 +344428 239566 +344428 252642 +344428 518192 +344428 633282 +344428 663652 +3444643 3879668 +344488 236223 +34453 529992 +34457 3695 +3445938 3965886 +34465 75834 +34465 75835 +344651 2022 +344679 66089 +3448 162275 +3448 234608 +34481 189505 +3448384 3766818 +3448384 3887416 +344847 329189 +344864 181658 +344958 119795 +344969 33469 +344980 328425 +344986 226144 +344986 372719 +344986 372721 +344996 2351674 +345126 36373 +345126 58045 +345126 66730 +345126 762 +345127 345126 +345127 36373 +345127 58045 +345127 66730 +345127 762 +345128 345126 +345128 345127 +345128 36373 +345128 58045 +345128 66730 +345128 762 +345171 54846 +3452 36807 +345218 194284 +345267 345266 +345295 124429 +345295 369026 +34531 145127 +345331 341452 +345331 630531 +345331 901455 +3453378 964663 +345401 345405 +345403 2383444 +345412 134091 +345412 354003 +345412 585616 +34545 14904 +34545 42894 +34545 7849 +345477 461222 +345568 345567 +3455772 885096 +345623 46494 +345632 345631 +345645 345647 +345646 345645 +345646 345647 +345662 364547 +345662 902551 +34568 69386 +3457 3458 +3457587 259092 +3458 64246 +34583 1279 +34583 981 +345844 74322 +345844 815854 +345869 3533880 +3460113 220236 +346045 148734 +3461 219487 +3461 37046 +3461614 3461614 +3461614 405858 +346185 112402 +34622 107444 +34622 115018 +34622 76461 +3462230 224 +346247 345268 +346261 350473 +3462799 3462768 +346294 346293 +346294 746713 +346296 343730 +346296 386863 +34630 539 +346303 105873 +34635 199181 +346444 146487 +346444 284667 +346477 3827821 +3465161 92790 +346550 1047371 +346557 72846 +34656 958899 +34671 43937 +346760 27991 +346760 465367 +346760 83724 +346760 83763 +3468 213541 +34682 25500 +346823 1562435 +346868 189913 +346868 573731 +346868 613166 +346868 928815 +346879 55566 +346913 373077 +346923 251830 +34694 14226 +3470 120233 +3470 17413 +3470 99511 +347026 393429 +347068 1434130 +347068 365767 +34711 30918 +347166 1015254 +347166 652212 +3472 120761 +3472 16968 +347216 507831 +347216 520053 +347268 867979 +34729 26100 +347355 1522709 +347355 534319 +347355 806436 +347368 404713 +3473785 3473786 +347398 347399 +3474 359939 +3474 36628 +3474 658286 +3474162 129633 +3474162 1603013 +347445 2733158 +34745 34746 +34745 8001 +34746 70377 +34749 34750 +3475 42895 +347517 45707 +347521 1286004 +347521 314579 +347570 1482236 +347570 2606387 +347570 289089 +347570 3552446 +347576 205031 +347576 227475 +347576 260370 +3476 119296 +3476 1602737 +3476 241311 +3476 254314 +3476 277902 +3476 3480 +3476 40813 +3476 48582 +3476 661 +347629 83073 +347777 262940 +347817 347818 +3478263 393383 +3478263 832962 +3478263 926325 +3478411 145639 +347856 347857 +347868 347869 +3478783 3478784 +3479 22008 +347902 1584747 +347902 1680612 +347902 252998 +347902 354659 +347927 997017 +347959 347958 +347965 1200419 +347965 397107 +347965 708197 +3480 13533 +3480 178021 +348049 95705 +348086 265198 +3482 6548 +34828 90863 +34829 1201287 +34829 543681 +34829 96397 +348313 348315 +348433 257181 +348434 348433 +348565 1028502 +348565 1035503 +348565 153980 +348640 348639 +348755 348669 +348817 2170522 +3488542 448008 +3488542 795017 +3488542 833785 +348892 1464662 +34896 52215 +349023 1845740 +349023 35877 +349026 804252 +34903 33339 +349046 307094 +3490638 3471380 +349126 349123 +349139 328844 +349147 3127680 +349149 1086491 +3492 19106 +3492 20764 +3492173 3492173 +3492173 4029530 +349225 198958 +349231 209173 +349248 364512 +349248 514024 +34929 1347793 +349293 1539540 +349296 1022025 +349296 1899278 +349296 455839 +349296 578737 +349296 626175 +349296 712500 +349296 833560 +349296 835518 +349296 95546 +34932 1240852 +34932 1246943 +34932 145738 +34932 1934985 +34932 3062379 +34932 3780 +34932 505054 +34932 6284 +34932 810205 +349348 194 +349360 667486 +34937 2030570 +34937 22467 +34937 313637 +349373 1739315 +349373 821071 +349404 832673 +349405 26955 +349428 622976 +34946 138863 +3494804 599253 +349513 1948483 +34952 338309 +349524 1702717 +349524 349524 +34953 39509 +349577 253855 +3495917 64677 +3496 232877 +34964 259725 +34964 27821 +34964 362519 +3496517 759186 +3496517 849435 +3496517 849441 +3496517 849443 +3496517 849445 +3496517 849446 +3496517 982225 +349673 349672 +34968 494261 +349785 522847 +349785 972905 +3499 202812 +3499 265181 +3499 292621 +3499 36297 +3499 7966 +34991 28587 +3499915 2502306 +3500578 3500577 +350061 17531 +350073 166078 +350073 385229 +350099 672659 +350099 672661 +350112 546052 +35013 141 +35013 150088 +35013 30880 +35022 275002 +3503 2160 +3503 4742 +350310 159036 +350310 351935 +35033 35878 +35033 53133 +350350 33737 +35037 28363 +350383 419999 +3504 421987 +35043 24398 +350481 1244753 +350481 1409158 +350481 283280 +350481 3140277 +350481 497080 +350481 990604 +350483 1117934 +350483 1584642 +350483 1876948 +350483 1876949 +350483 456764 +3505 60102 +3505363 3505362 +3505363 921435 +35055 220048 +350573 116433 +350599 57680 +350605 214578 +350617 350616 +350630 4937 +350630 687232 +350630 746194 +350630 809575 +350642 350643 +35069 265315 +35069 2913 +3507 9559 +350701 644216 +350727 519419 +350727 677343 +35074 402895 +350755 779952 +350781 21764 +350782 59226 +350786 57116 +3507955 1347549 +35082 1116 +350831 350833 +35086 242037 +35086 250202 +35086 255163 +35086 286235 +35086 4687 +3509 234200 +3509 9526 +35090 260438 +35090 289121 +35090 40734 +35090 57754 +350933 1434130 +350933 347068 +350933 353791 +350933 474439 +350947 1750058 +351 215222 +351002 443138 +351002 720420 +351036 201111 +351036 241755 +351036 301304 +351036 351033 +35111 172914 +35111 21361 +351139 828072 +3511736 832942 +35125 188432 +35125 241531 +35125 2904417 +35135 113470 +35135 180585 +35135 51271 +35135 67039 +35135 97658 +35136 23624 +35136 473004 +35136 473005 +35136 578784 +351396 3241037 +351396 5048 +35143 10300 +35143 2561715 +35143 3989791 +35143 90739 +35144 124372 +35146 10055 +35146 99026 +35148 1009267 +35148 20717 +35148 338 +35148 529058 +35148 6509 +35148 71844 +35148 844014 +35148 85528 +351496 1783270 +351496 504786 +3515 299106 +3515 33038 +3515 43596 +3515 43597 +3515 43604 +3515 456548 +3515115 59268 +351621 1235715 +351674 16715 +351708 735309 +351709 224273 +351709 291028 +35174 242492 +351833 47874 +351935 159036 +351960 122667 +3519719 2129819 +3519719 577808 +3519719 837674 +351977 205329 +35199 150409 +35199 255469 +35199 69621 +3520483 2373155 +3520485 2373155 +3520485 3520483 +352058 1558894 +352058 702912 +35208 173059 +35208 227724 +35208 2291544 +352127 529058 +35217 103097 +35217 15204 +35217 194625 +35217 20073 +35217 3293 +35217 67481 +35220 460750 +352243 498002 +352267 66089 +352300 248333 +352374 1230834 +352387 1464901 +352388 1259393 +352388 560320 +3525078 164477 +3525078 3525080 +3525079 164477 +3525079 3525078 +3525079 3525080 +35251 22116 +352525 356956 +352542 117415 +352613 14975 +352647 146052 +352676 561421 +3527329 2782920 +352874 352872 +352964 1328706 +3529691 2736869 +352979 148758 +35301 1001084 +35301 15885 +35317 6314 +353179 212002 +353205 537780 +353205 553817 +353205 78788 +35323 62321 +353266 612072 +35328 892420 +353291 23165 +353291 255646 +3533 12182 +3533 8459 +353321 766162 +35333 57979 +3534 2115 +3534 6667 +353424 217653 +35344 955621 +35344 955622 +35346 1141640 +35346 29806 +35351 45199 +35361 35360 +353611 37906 +353627 1846423 +353627 337062 +353627 378229 +353627 69817 +353627 701741 +353733 42157 +3537344 3718587 +353753 353751 +3537693 878776 +35377 1218 +353791 1434095 +3538598 2760307 +353974 516624 +353974 663736 +35400 55479 +354003 134091 +35406 307654 +35406 631589 +3541 162889 +3541139 2538781 +354147 40152 +354194 1265566 +354194 1266883 +354194 1356096 +354194 254400 +354194 312587 +354194 314301 +354194 423298 +354194 447940 +354194 481548 +354194 531489 +354194 870181 +35428 180642 +35428 22008 +35428 30542 +35428 35428 +35442 1053400 +35442 40632 +3545088 1229928 +3545088 1956397 +3545088 840069 +3545213 194 +354650 302498 +354659 1450166 +354659 296959 +3547372 1480409 +354760 314139 +354789 2868404 +354816 1564600 +3549 41654 +35491 278963 +3549226 1025832 +3549280 56308 +354973 1166964 +354973 2544878 +354973 373101 +354973 891347 +3549919 879717 +355 1259101 +355 1289 +355 1326079 +355 1354265 +355 19140 +355 2187 +355 624474 +355 68377 +355 807855 +355 928653 +3550 255665 +3550 549 +3550 60079 +355013 62621 +355013 655795 +3550140 3550139 +3550141 3550139 +3550141 3550140 +355043 1720120 +355043 3027600 +355045 1783790 +355105 1197321 +355105 282805 +3551653 72186 +35518 228274 +355185 267089 +355185 441793 +355236 848275 +3552594 1476306 +355289 110634 +355289 308815 +3553 20119 +3553524 3916617 +3554403 2331616 +3554403 3222832 +3554403 4025199 +355457 562860 +35547 152480 +35548 297 +355488 106541 +35551 79753 +355512 1433861 +355512 340112 +355512 555846 +355535 395066 +355535 458006 +355535 458008 +35555 199668 +35555 2160 +35555 313324 +3555697 2376324 +355586 167763 +355586 61342 +355653 598606 +355653 740534 +355659 122539 +355659 289089 +355659 3227501 +355659 335370 +355659 942756 +35566 31916 +355687 234812 +3556918 3556917 +355715 5253 +355737 10363 +355737 2753696 +3557840 1353208 +3557840 3557841 +3557840 451534 +3557840 646866 +3557840 844419 +3557840 845760 +3557841 1353208 +3557841 451534 +3557841 646866 +3557841 844419 +3557841 845760 +3558 31820 +3558108 424754 +355829 1236304 +355829 491005 +355859 61483 +355942 188078 +355942 31425 +3560 30767 +356030 2928313 +3560546 87442 +3561 17115 +3561 2834714 +3561 38008 +35611 167786 +35611 30786 +35611 33762 +35611 42898 +356131 368213 +356132 214943 +356132 289198 +3561370 2396336 +356276 176684 +356288 10053 +356288 157139 +356288 1603492 +356288 193610 +356288 3344 +356288 5722 +356288 701 +356288 7708 +356288 887654 +356306 286900 +356317 779780 +356317 836105 +356317 897153 +356368 10436 +356368 348483 +35641 29356 +356418 527475 +356428 28738 +356428 39015 +35646 1602787 +35646 3888027 +35646 51984 +35646 676432 +35646 90541 +35648 768855 +356533 14975 +35658 355 +35658 42158 +35665 51988 +3566516 1162738 +3566516 674785 +3567131 887155 +3567275 3567276 +35679 4120 +35679 424117 +356801 207923 +356829 438165 +356846 132084 +356881 797171 +356901 356899 +3569567 3569568 +35699 101597 +357050 303413 +357050 3221502 +357050 907402 +357122 618382 +357135 113131 +357135 130471 +357148 1361677 +357148 514284 +357255 1271960 +357262 1927026 +357262 2720538 +357262 342214 +357262 343469 +357262 99793 +3573192 130230 +357395 105862 +35740 1475800 +35740 3857 +357422 21447 +35746 17587 +35746 225315 +35746 316225 +35746 39600 +35746 56838 +35746 75542 +3575 5303 +357510 339905 +357519 417175 +357537 357538 +357537 43154 +357540 134861 +35755 62206 +357616 864147 +357645 20419 +357645 36937 +357646 89784 +357646 993566 +3576577 3390944 +357753 93375 +357953 258904 +35797 1425230 +357982 16406 +357982 334507 +357982 444580 +357982 447581 +357982 716201 +3581 31613 +3581531 1559715 +3581531 2309083 +3582535 1789767 +3582535 45707 +358306 350606 +358309 14235 +358324 793280 +35833 1005 +35836 19435 +35847 13222 +3584756 2592554 +35848 25666 +35848 37906 +35848 53164 +35848 90233 +3586 1844534 +3586 2194 +3586 25056 +3586 31262 +3586 3586 +3586 923252 +3586 9858 +3586619 1588452 +358689 2946427 +35869 14238 +358746 118217 +358746 213055 +358746 48945 +3587618 1343490 +3587618 2872662 +3587618 3123890 +3587618 3363028 +3587618 3463574 +3587618 3616835 +3587618 3784986 +3587618 3784993 +3587618 3786251 +3587618 3786276 +3587618 3787591 +3587618 3790857 +3587618 3836440 +3587618 3862747 +3587618 3870544 +3587618 3887416 +35878 53133 +358781 1515566 +358882 149439 +358882 227896 +358882 278917 +358897 698 +359010 10472 +359019 299214 +359019 3860 +359026 289600 +359032 346604 +359067 842134 +359067 848261 +359067 880236 +359068 1501991 +359068 1731777 +359068 260744 +359068 262940 +359068 276145 +359068 2971546 +359068 299702 +359068 325753 +359068 359067 +359068 361601 +359068 361603 +359068 361608 +359068 361625 +359068 368137 +359068 395913 +359068 415720 +359068 532434 +359068 539272 +359068 550880 +359068 670668 +359068 716084 +359068 754974 +359068 832962 +359068 834577 +359068 842134 +359068 844250 +359068 848261 +359068 880236 +3592 2513 +3592006 3784789 +3592015 14484 +35921 79004 +359246 1113081 +359246 1169330 +359246 469912 +359246 752152 +359246 845246 +359246 92890 +359257 274078 +359260 27519 +359260 809856 +35928 91555 +359286 359282 +3594 188278 +3594 3793 +35942 4382 +35942 44663 +3594531 283658 +35954 1396 +359607 180134 +359607 335086 +359686 27952 +359686 464264 +359707 56677 +359746 131455 +359756 390053 +359799 728042 +3598 400901 +35985 65224 +35985 810674 +35985 8185 +359852 617888 +359928 641874 +359928 804789 +359939 1702929 +359939 658286 +359939 727590 +359983 355289 +3601770 3601769 +36018 141714 +36019 1335138 +360226 320075 +360315 417538 +360376 360377 +360401 360394 +360489 360488 +36052 220565 +360575 1141651 +360575 193235 +360575 227234 +360575 924137 +3606 328 +360620 184622 +360620 190251 +360620 219675 +360620 434256 +360675 104871 +360675 573935 +360675 622806 +3608 71422 +36080 86092 +3608369 174193 +360863 603433 +360884 716488 +360901 229097 +360901 50137 +36099 110359 +36099 112754 +36099 26918 +36100 1123390 +36100 13732 +36100 1635332 +36100 211036 +36100 26245 +36100 35746 +36100 51352 +36100 75542 +36100 97139 +3610237 78791 +361028 2691498 +361028 561722 +361057 23478 +361057 315789 +361057 319978 +361074 883808 +3611 13981 +36112 13879 +36112 181073 +36112 283400 +36112 302458 +36112 618095 +36112 96155 +361187 228533 +3612023 3612022 +361217 330340 +36122 228852 +361222 3180447 +361279 135579 +361293 29039 +361293 460054 +361293 506051 +361293 778281 +361344 1296321 +361344 366605 +36136 1460569 +36136 214254 +36136 245059 +361384 19696 +361418 2042570 +36142 105669 +361424 789042 +36143 36144 +361435 466985 +361463 470073 +361463 701579 +361513 1454465 +361513 273481 +361529 24027 +361545 365767 +361545 538156 +36158 120826 +36158 79759 +361592 1731777 +361592 267135 +361592 359068 +361592 361595 +361592 361601 +361592 361603 +361592 361608 +361592 361625 +361592 836895 +361595 890223 +361601 1731777 +361601 361603 +361601 361608 +361601 361625 +361608 1731777 +361608 361603 +361608 361625 +361608 961746 +361621 1424580 +361625 361603 +361628 361626 +361656 551789 +3616835 3766818 +3616835 3862747 +3616835 3886638 +3616835 3887416 +3616835 3923793 +361720 310579 +36174 10937 +36174 162516 +36174 164298 +36174 1661592 +36174 183741 +36174 198642 +36174 210389 +36174 348433 +36174 45866 +36174 4954 +36174 556113 +36180 23508 +361802 628057 +361805 356317 +361805 835060 +361805 883952 +361807 1001654 +361807 1169887 +361807 1314144 +361807 260744 +361807 283122 +361807 2839318 +361807 3022452 +361807 435555 +361807 539272 +361807 599488 +361807 604396 +361807 626175 +361807 854161 +361808 95539 +36181 138731 +361814 11696 +361814 1356494 +361814 2116503 +361814 27519 +361814 2791855 +361814 299702 +361814 388185 +361814 526596 +361814 809856 +361814 833362 +361814 852709 +361814 858480 +361814 870631 +361814 884633 +361814 895152 +361848 361849 +361862 550710 +3619262 3619261 +361963 1832810 +36197 19770 +361997 1972494 +361997 404010 +36202 29808 +36214 45450 +362230 2506336 +362290 260252 +362290 363457 +362290 410346 +362290 500828 +362298 36859 +362312 1031351 +362312 408613 +362345 205032 +36240 125216 +3624111 3712790 +36244 36240 +362504 174968 +36251 1325921 +362554 14648 +362592 1266469 +362592 517415 +362596 113042 +362596 191753 +362596 234138 +3626143 2768574 +362651 178515 +362651 184622 +362651 362652 +362651 373101 +362652 1182579 +362652 124436 +362652 162975 +362652 178515 +362652 593533 +362664 370458 +362664 882703 +362725 407328 +362763 43641 +362802 23850 +362802 66880 +36282 4049 +362838 250691 +36297 405575 +36297 44422 +3629774 3629779 +362986 362987 +363042 32595 +363044 270311 +363046 2345803 +3630605 999295 +3631 15346 +3631 20907 +36314 130185 +36314 18956 +36314 84842 +363156 273283 +363277 46333 +363376 10589 +363376 11649 +363414 1141805 +363528 1493 +363557 250678 +363557 35406 +363673 90203 +363728 2545 +36373 58045 +36373 66730 +36373 762 +36377 150114 +36377 151075 +36377 154381 +36377 8358 +3637771 2102021 +36378 129797 +36378 170309 +3638 141854 +3638 39987 +36381 191759 +36381 2312 +36389 17414 +3639 218449 +36390 27929 +36390 60697 +363973 990685 +36398 10504 +36398 9818 +36400 11590 +364042 118196 +364045 50301 +3641220 1322663 +3641220 1789919 +3641220 2549088 +3641220 979622 +364124 84675 +364176 364175 +364205 261079 +36421 25774 +364256 2308248 +364256 364256 +364256 600306 +364257 1030128 +364257 158822 +364257 28377 +364257 847074 +3642578 459370 +36431 44946 +364311 50997 +36434 319635 +36434 65918 +364422 272003 +364460 424492 +364481 257896 +364512 349282 +364512 384818 +364535 661185 +364544 65376 +364546 1200241 +364546 1200242 +364550 116329 +3645614 1022236 +3646712 1167590 +3646712 205734 +3648 28823 +3648 28824 +364838 1117543 +364838 1627381 +364838 899843 +36484 23232 +364881 87884 +3649 1538 +3649 4564 +3649 72727 +3649 879 +3649 8798 +364979 364978 +3649997 1717018 +3649997 2837958 +3649997 2975387 +365020 87398 +365020 99293 +36506 919 +36507 355522 +365085 702795 +3650853 696188 +365094 298432 +365145 261834 +365212 140977 +365230 1194311 +365230 236339 +365239 343204 +365248 24211 +365248 622822 +36527 10263 +36527 1229202 +36527 1229555 +36527 1615988 +36527 165412 +36527 169686 +36527 2187 +36527 21991 +36527 229665 +36527 36100 +36527 36528 +36527 566501 +36527 678149 +36527 7991 +36527 885103 +36527 97139 +36528 1229202 +36528 169686 +36528 566501 +36528 7991 +365343 1933562 +36543 772492 +36543 891993 +36544 18063 +36544 381710 +36544 47458 +36544 610427 +36544 636714 +36544 827420 +36544 8501 +36544 922770 +3654648 3654649 +3655036 343502 +3655036 605817 +365527 1281653 +365527 19144 +365527 553093 +3655502 741653 +36560 33959 +36563 31009 +365662 134516 +365684 1003471 +365684 4937 +365684 658479 +365684 658480 +3657 256487 +3657 293698 +36571 65367 +36571 65368 +36572 264851 +365745 1382611 +365745 1564440 +365745 184855 +365745 25532 +365745 94789 +365745 980145 +365913 476123 +365914 673121 +365914 689960 +365980 353291 +365980 561053 +36603 262944 +36603 9081 +366060 179904 +36607 16691 +366111 198937 +366111 78003 +3661440 947054 +3661893 622067 +36621 239983 +36624 48255 +36624 52227 +36628 165272 +36628 86464 +36631 799358 +36646 51862 +366484 272690 +366546 17591 +366551 1731432 +366602 205808 +3666254 2802772 +36663 154588 +3666457 690245 +36665 154588 +36665 3434326 +36665 36663 +36668 36669 +3667289 3667290 +36676 458215 +366773 336629 +366813 482956 +366820 1463723 +366820 164279 +366820 2504839 +366820 340210 +366820 730308 +366820 897378 +366820 913525 +366828 33591 +3669 58048 +36701 199487 +367077 401200 +367077 401207 +367078 1927051 +367090 367088 +367090 80568 +367129 367125 +367133 161785 +367226 1926 +367297 444902 +36733 249739 +367408 974381 +367630 198102 +3676367 3144185 +3676548 1213373 +3676548 1753884 +3676548 1917194 +3677 35126 +367809 2327663 +367886 367885 +367936 406271 +367936 406285 +36794 36802 +367959 520248 +368 523 +3680 56016 +368043 297515 +368043 66144 +368045 2109745 +368046 350558 +3680613 3085875 +368063 289089 +368081 12751 +368081 329610 +368081 4345 +36810 127864 +3681168 140390 +368137 1031230 +368137 1064108 +368137 2093291 +368137 578737 +368137 795171 +368137 833076 +368137 833886 +368137 837498 +368137 855072 +368160 94503 +368161 1211691 +368161 668096 +368163 237236 +368163 430156 +3682 173709 +3682 212263 +3682 36628 +368233 1090184 +368233 211067 +368233 440528 +368390 366592 +3684 70922 +3684179 3683300 +36842 36843 +368471 324534 +368471 529766 +368508 1086958 +368508 1490523 +368508 1912830 +368508 321183 +368508 394896 +368508 422165 +368508 536839 +368508 57087 +368508 782590 +36856 101832 +36856 37229 +36856 76872 +36856 76874 +3685788 575604 +36858 1802543 +36858 38379 +36858 678149 +3686 13195 +3686 138994 +3686 18585 +3686 253834 +3686 49502 +36863 1281446 +36863 36864 +36866 432780 +368672 58575 +368672 77372 +36868 153980 +368696 493247 +3687 126188 +3687 2925302 +3687 37824 +368702 214957 +368738 45966 +368738 95404 +368751 368752 +3688275 1963216 +368895 185489 +368997 205808 +368997 492163 +369026 124429 +369053 1003179 +369053 1032277 +369053 1032278 +369053 1080248 +369053 1165562 +369053 1208452 +369053 1220779 +369053 1229978 +369053 1239660 +369053 1246887 +369053 1307759 +369053 1341603 +369053 1341604 +369053 1344131 +369053 1377659 +369053 1390360 +369053 1400010 +369053 1415872 +369053 1425824 +369053 1440242 +369053 1477181 +369053 1481537 +369053 1481540 +369053 1481547 +369053 1481548 +369053 1488743 +369053 1488744 +369053 1578164 +369053 1615876 +369053 1640327 +369053 1640328 +369053 1651128 +369053 170760 +369053 1730565 +369053 1735555 +369053 1971571 +369053 2012073 +369053 2085393 +369053 2129819 +369053 2142756 +369053 2357523 +369053 253133 +369053 260744 +369053 2645574 +369053 269254 +369053 270225 +369053 2757394 +369053 283122 +369053 290601 +369053 299702 +369053 3113077 +369053 3228250 +369053 397620 +369053 415720 +369053 442174 +369053 454293 +369053 525469 +369053 526591 +369053 532270 +369053 538821 +369053 55683 +369053 561054 +369053 573239 +369053 577808 +369053 656869 +369053 696181 +369053 696193 +369053 696200 +369053 696215 +369053 696257 +369053 703271 +369053 704150 +369053 754974 +369053 814478 +369053 833014 +369053 833554 +369053 833626 +369053 833628 +369053 833826 +369053 835518 +369053 837527 +369053 837529 +369053 837533 +369053 837663 +369053 837674 +369053 838168 +369053 841590 +369053 841593 +369053 842223 +369053 850899 +369053 850908 +369053 851310 +369053 851413 +369053 851418 +369053 851419 +369053 854227 +369053 855061 +369053 855066 +369053 855073 +369053 858380 +369053 859855 +369053 861581 +369053 862697 +369053 865655 +369053 865659 +369053 867985 +369053 868929 +369053 882019 +369053 882022 +369053 889200 +369053 889836 +369053 896995 +369053 898855 +369053 900979 +369053 925944 +369053 925945 +369053 926979 +369053 937077 +369053 960902 +369053 973039 +369053 973042 +369053 978302 +369053 986112 +369115 53492 +369115 8090 +369144 1325401 +369144 64739 +369146 310508 +369196 369197 +369206 67041 +36925 206853 +36932 217788 +36932 2709 +36932 280200 +36937 121471 +3694 10053 +3694 1480780 +3694 436537 +3694 5363 +3694 58011 +3694 670121 +36941 88522 +36942 162275 +36942 170461 +36942 205916 +36942 212363 +36942 238235 +36942 337324 +36942 42138 +36942 52584 +36942 59554 +369489 1998654 +369500 65081 +36951 294978 +36954 1386360 +369578 347268 +369581 17963 +3696 1399 +3696327 1174313 +3696327 1821628 +36972 36973 +369876 439687 +36988 213484 +369963 79086 +369963 9427 +370 182748 +3700243 10686 +3700243 45529 +3700243 45530 +3700243 459 +3700243 513617 +37004 322619 +37004 341332 +37008 161487 +37008 17597 +37008 228376 +3701 232474 +3701 278201 +3701 523111 +370145 197272 +370145 292269 +370145 954680 +370148 133314 +370148 157538 +37015 202822 +37015 44030 +37015 586830 +37015 92870 +370196 58533 +37026 232194 +37027 50096 +37028 132084 +3702895 3702897 +3702895 696260 +3702897 696260 +37032 36870 +37032 62770 +37037 132257 +370453 1819467 +37046 117541 +37046 2535488 +37048 52199 +370492 1387602 +370522 229663 +370522 377663 +370522 675688 +370534 370533 +37058 37059 +370594 585930 +370612 1437407 +370612 305847 +370612 558045 +370612 942483 +370715 418708 +370752 194 +370754 1124075 +370754 1182853 +370763 1636742 +370763 444952 +370763 66297 +370763 90203 +370771 500544 +370805 870178 +370807 253096 +37081 37082 +37088 346822 +37088 45309 +370955 992234 +3710 16410 +371120 28164 +37120 344499 +371298 27952 +371298 371320 +371360 2736988 +37137 483450 +37137 754105 +371536 34236 +371580 371583 +37166 72649 +371663 371664 +371712 174727 +371724 1439392 +371724 749473 +371741 12770 +3718000 470355 +371804 1258970 +371843 589440 +37197 80040 +37198 492745 +37198 80040 +37199 37194 +371992 32072 +371992 939678 +37202 37204 +372037 3865 +372037 48397 +3720418 145539 +3720418 1713729 +3720418 1849338 +3720418 1977477 +3720418 2262477 +3720418 249584 +3720418 2585397 +3720418 2882883 +3720418 3039466 +3720418 3067086 +3720418 3219528 +372109 462750 +372147 395324 +37217 69674 +372197 397119 +3722 828694 +3722 92547 +37222 101902 +37222 7669 +372299 1685956 +372312 1176201 +372312 127076 +372312 143352 +372312 99262 +372321 216897 +372321 413602 +37234 139875 +37234 14488 +37234 149303 +37234 357186 +37234 380376 +37234 411737 +37234 43020 +37234 79104 +37234 81368 +37236 3070052 +37236 336551 +37236 448566 +372380 352830 +37243 10147 +37243 5595 +37243 797919 +37247 42872 +37247 43731 +37247 86144 +372525 153429 +372541 426529 +372549 130593 +372625 62887 +372720 918939 +372754 285231 +372799 155773 +372799 332708 +372799 519116 +372874 233910 +372874 980059 +372878 319968 +372878 410333 +372883 255129 +372883 255882 +372883 7321 +372974 192160 +372976 3144903 +373 552703 +373 575818 +373 606380 +373 95623 +37304 450228 +37304 4810 +37304 50896 +37304 50918 +37304 74752 +373075 373074 +37308 23911 +373100 373101 +373101 311327 +373101 737719 +373107 613277 +373144 136091 +373144 147202 +373144 856158 +373159 17413 +373165 269799 +373196 79733 +373229 373230 +373236 52724 +37329 49719 +37330 62157 +373347 359068 +37338 2028105 +373385 855552 +37343 229334 +37343 429986 +37343 54192 +37355 5467 +37356 10003 +37356 1413 +37356 1415 +37356 19145 +37356 306473 +37356 37359 +37356 42713 +37356 5467 +373566 1197836 +373568 2266189 +373587 128317 +37359 2096 +37359 5467 +37365 249873 +3737041 3737040 +373747 1041403 +373747 391058 +3738 33339 +373805 341505 +37382 46827 +3738296 2910106 +3738296 3738297 +373850 1386672 +373850 576420 +373850 837570 +373892 313151 +373923 560282 +373950 373951 +373951 770381 +373967 277346 +374006 1428466 +374006 262940 +374006 863122 +374007 424108 +374007 480804 +374007 759868 +374012 1028502 +374012 153980 +3740167 833686 +374022 142453 +374062 357983 +374062 520761 +374085 2100376 +37414 294682 +374231 374236 +374233 1326940 +374233 374231 +374233 374236 +37428 197076 +374286 1822268 +374286 237156 +374286 310495 +374286 924732 +3742879 1163926 +3742879 20801 +3742879 3079028 +3742879 3767199 +37429 467254 +374304 1989529 +374376 101847 +37440 1214566 +374401 92693 +37446 60179 +374464 243724 +374494 604802 +3745021 1826008 +374519 284166 +374519 3108574 +374519 383692 +374522 1832511 +374522 45392 +374522 57811 +374522 60864 +374522 699163 +374570 126146 +374632 313151 +374632 373892 +3746335 3090089 +37469 15310 +374717 793290 +374757 272726 +374757 603596 +374777 521381 +374777 837549 +374777 999914 +374780 2172 +374780 52010 +374788 1562951 +374788 231726 +374788 364935 +374789 289089 +374793 1131721 +374805 391186 +374805 683731 +374814 243203 +3748453 441872 +374898 461787 +3749 7137 +374955 2482400 +374955 519596 +374955 528372 +374958 374549 +3749882 3822609 +3750 10590 +3750 34183 +37505 40818 +37506 287009 +37506 31820 +37511 149428 +375221 943960 +375221 967525 +37526 34257 +375279 1021215 +375279 1022025 +375279 1028502 +375279 1029398 +375279 1037716 +375279 1039625 +375279 1046943 +375279 1046946 +375279 1048110 +375279 1053915 +375279 1053916 +375279 1059959 +375279 1059960 +375279 1092524 +375279 1155414 +375279 1157619 +375279 1236553 +375279 1246886 +375279 1252375 +375279 1269513 +375279 1270472 +375279 1346429 +375279 1354730 +375279 1368030 +375279 1380023 +375279 1380024 +375279 1419770 +375279 1443272 +375279 153980 +375279 1594257 +375279 1619482 +375279 1636340 +375279 1639402 +375279 1692113 +375279 1823637 +375279 1855232 +375279 192322 +375279 1999264 +375279 2066290 +375279 207945 +375279 2212800 +375279 229566 +375279 2501562 +375279 252872 +375279 2586229 +375279 260744 +375279 262940 +375279 2640719 +375279 267134 +375279 269254 +375279 271870 +375279 27519 +375279 283122 +375279 3296871 +375279 3308562 +375279 349296 +375279 3506857 +375279 379816 +375279 397616 +375279 397617 +375279 415725 +375279 424276 +375279 441528 +375279 470931 +375279 497542 +375279 517153 +375279 522269 +375279 532086 +375279 547969 +375279 552195 +375279 583138 +375279 641164 +375279 65796 +375279 665298 +375279 671328 +375279 696169 +375279 713519 +375279 716084 +375279 740149 +375279 754894 +375279 761118 +375279 762355 +375279 795184 +375279 809856 +375279 832655 +375279 832661 +375279 832951 +375279 832952 +375279 832962 +375279 833076 +375279 833217 +375279 833686 +375279 833722 +375279 833879 +375279 834378 +375279 834516 +375279 834641 +375279 834647 +375279 835057 +375279 835088 +375279 835090 +375279 835518 +375279 835735 +375279 836151 +375279 836152 +375279 836153 +375279 836154 +375279 836155 +375279 836156 +375279 836185 +375279 836665 +375279 836666 +375279 837520 +375279 837527 +375279 837582 +375279 837585 +375279 837588 +375279 837589 +375279 837657 +375279 837660 +375279 837661 +375279 838930 +375279 838984 +375279 841439 +375279 841441 +375279 841571 +375279 842212 +375279 844249 +375279 844416 +375279 844450 +375279 845760 +375279 846125 +375279 846301 +375279 850224 +375279 850543 +375279 855758 +375279 859446 +375279 859998 +375279 861476 +375279 861648 +375279 861690 +375279 867946 +375279 867974 +375279 870631 +375279 870694 +375279 881488 +375279 883315 +375279 896029 +375279 896248 +375279 899625 +375279 899898 +375279 900180 +375279 900378 +375279 905491 +375279 914150 +375279 917033 +375279 917554 +375279 92243 +375279 926716 +375279 926722 +375279 931244 +375279 931425 +375279 95546 +375279 961426 +375279 970420 +375279 973130 +375279 973597 +375279 978174 +375279 978177 +375279 987860 +375279 987866 +3753 58169 +375380 252998 +375380 253780 +375405 26421 +375460 1315139 +375528 1508172 +375573 1879756 +375573 3356849 +375574 1420621 +375576 157220 +3756 226425 +3756 242952 +3756 78 +375600 25874 +375600 338074 +375601 1468794 +375615 375623 +37565 1258015 +37565 326718 +3756878 406281 +3756878 406283 +375771 167427 +375953 1209283 +375953 375953 +375969 370752 +375969 375968 +37598 42018 +37601 136519 +376031 836894 +376031 962497 +37604 785581 +376087 3675 +376157 145858 +376157 367627 +37619 1199790 +3762 1321801 +3762 75979 +3763 108184 +3763 38661 +3763 40792 +3764 22652 +37645 28630 +3764769 3764768 +3766818 3587618 +3766818 3784985 +3766818 3784992 +3766818 3787582 +3766818 3830135 +3766818 3846097 +3766818 3862747 +3766818 3913012 +3766818 3944892 +3767199 1163926 +3767199 3079028 +376764 1354525 +376764 950635 +376847 200311 +376847 25703 +376847 570882 +376847 572751 +37686 61061 +376870 84522 +376962 408668 +37698 115099 +37698 187413 +37707 573715 +37711 298991 +377114 1729114 +377114 1751379 +377114 1751388 +377127 44163 +377139 1437991 +377139 1960103 +377139 224329 +377139 256168 +377139 257025 +377139 262940 +377139 265354 +377139 269254 +377139 27519 +377139 289522 +377139 395913 +377139 406281 +377139 415725 +377139 424576 +377139 454293 +377139 479036 +377139 526576 +377139 538821 +377139 620186 +377139 623293 +377139 696260 +377139 704150 +377139 712500 +377139 754894 +377139 754974 +377139 809856 +377139 832917 +377139 833128 +377139 833560 +377139 833840 +377139 834101 +377139 834389 +377139 837568 +377139 843643 +377139 853844 +377139 855140 +37717 58286 +377176 476096 +37718 1277604 +37718 5064 +3772 679328 +37720 72358 +37724 12821 +37724 2730 +37724 396683 +37724 661 +37726 8289 +37729 17827 +3773 11209 +3773 1857 +3773 21443 +3773 33542 +3773 45697 +3773 50310 +3773 84774 +37730 37731 +37730 37735 +37730 450733 +37730 69621 +37731 1117719 +37731 1257446 +37731 128396 +37731 255117 +37731 255556 +37731 40235 +37731 41893 +37731 450733 +37731 69621 +37731 74210 +37731 841440 +37731 84214 +37731 87519 +37732 145262 +37732 876717 +37733 145256 +37733 162564 +37733 217242 +37733 255646 +37733 257115 +37733 258469 +37733 296961 +37733 29992 +37733 34183 +37733 353291 +37735 257674 +37735 37731 +37735 450733 +37735 69621 +377358 357920 +37737 1222021 +37737 170329 +3774129 435555 +377430 206548 +377449 46666 +37749 102834 +37749 194447 +37749 22882 +37749 230753 +37749 419 +37749 634 +37749 65181 +37749 67657 +37749 86533 +3775 11879 +3775 201571 +37752 112586 +377533 197272 +377590 387851 +377626 1054025 +377626 295915 +37763 172253 +377663 675688 +377693 97532 +37784 20942 +377843 45963 +377844 270805 +37789 171214 +3779 17184 +3779 306133 +3779 34798 +3779 36995 +3779 7858 +3779 88390 +377935 269596 +377935 376962 +377937 1658185 +377937 2082254 +377937 2198545 +377937 470931 +377941 598385 +3780 12751 +3780 780742 +37800 31215 +378045 99319 +378054 449609 +37806 252914 +378086 1161116 +378089 951466 +3781158 2168358 +378128 216897 +378138 1130829 +378138 130715 +378138 421547 +378138 44779 +378229 1846423 +378229 337062 +378229 701741 +37823 126188 +37823 37824 +378232 310148 +37824 126188 +3783 27991 +3783 3196177 +378313 59015 +3783300 918332 +378421 929663 +378426 378427 +378436 1519283 +378492 587448 +3784985 3887416 +3784992 3862747 +3784992 3866087 +3784992 3913012 +3784994 3913013 +3784994 3939393 +3784995 3862747 +3785007 3587618 +3785007 3886638 +3785007 3933988 +378514 180754 +378586 1262828 +378586 181437 +3786051 2159031 +3786144 3830135 +3786144 3937418 +3786384 3587618 +3786384 3787582 +3786443 3448384 +3786443 3587618 +3786443 3766818 +3786443 3891874 +3786480 3786478 +378655 573349 +37868 265931 +37870 70095 +37870 76808 +3787516 3587618 +3787578 3887416 +3787582 3587618 +3787582 3784985 +3788 520 +378852 3336165 +378852 445457 +3789180 3789179 +3789771 2139063 +3789771 3790857 +37905 108897 +37905 603542 +37905 6952 +3790535 3587618 +37906 10991 +37906 111502 +37906 172962 +37906 17587 +37906 20957 +37906 324866 +37906 35746 +37906 3728683 +37906 90037 +37907 173359 +37907 175587 +37907 216097 +37907 86495 +37908 109832 +37908 293487 +37909 210876 +37909 383281 +37910 1065010 +37910 181339 +37910 63978 +37913 173374 +37913 211211 +37913 234316 +37913 37906 +37913 590009 +37913 95003 +37916 2606 +379184 406916 +379276 1000020 +3793961 3464785 +3794 218140 +3794 63742 +3794 7875 +3794 81957 +37940 79621 +379503 44792 +379576 285204 +379585 379586 +379636 477205 +379691 2024990 +379691 774481 +379691 833018 +379691 870832 +379691 870833 +37972 43577 +379724 254864 +379726 2551255 +379727 379735 +379760 892060 +379808 137203 +379808 863918 +379809 1014466 +379809 1312375 +379809 153980 +379809 262940 +379809 27519 +379809 276145 +379809 299702 +379809 368137 +379809 377139 +379809 388185 +379809 406281 +379809 415725 +379809 424576 +379809 538821 +379809 567511 +379809 809856 +379809 833079 +379809 833851 +379809 837568 +379809 837584 +379809 846301 +379809 848066 +379809 882784 +379809 890675 +379809 896978 +379809 95537 +379809 95544 +379812 379808 +379814 379808 +379814 379812 +379816 1029398 +379816 1039625 +379816 1367480 +379816 194 +379816 2370104 +379816 434124 +379816 793064 +379816 828590 +379816 84237 +379816 848467 +379816 870832 +379816 95537 +379816 986222 +379816 988605 +3798798 856940 +37997 511117 +38003 5081 +380036 653535 +380036 898730 +38005 1388469 +380109 155335 +3801856 728331 +380215 464240 +380270 1125579 +380270 396663 +380270 938507 +380280 10628 +38034 1041801 +38034 5465 +38034 62947 +38034 862914 +38037 295951 +380376 433341 +380377 258815 +38039 48891 +38040 13815 +3805 1142504 +3805 3567329 +380510 20956 +380510 97545 +38054 230493 +380583 170825 +380583 506682 +380613 1254418 +380613 741812 +380660 218140 +3807 34108 +380704 1861476 +38073 120945 +38075 15438 +3808022 143017 +380824 2155676 +380825 339800 +380858 503075 +380875 382454 +380875 531794 +380926 481866 +380982 3016236 +381 165627 +381 3619 +3810 572736 +381028 752501 +381029 102318 +38106 104348 +38106 13778 +38111 38112 +38111 41348 +38112 41348 +3811268 37120 +3811268 90037 +381166 140603 +381181 857652 +38119 117523 +38119 333415 +3812 1531 +3812 3511 +3812 907821 +381206 519027 +381227 64692 +3814 918506 +38141 250967 +381413 112881 +381431 12279 +3815 239655 +3815 28822 +3815 29212 +3815 68760 +381500 60023 +381566 287416 +381590 309283 +381605 3191863 +381674 1995931 +381686 1107154 +381710 25800 +381710 8501 +381764 43442 +38186 118363 +381876 119538 +3819 1542822 +381912 284939 +381969 452021 +381997 381998 +382008 695766 +38201 145257 +38201 149130 +38201 2288100 +38201 257353 +38201 258459 +38201 2684115 +38201 309966 +38201 325858 +38201 338989 +38201 368674 +38201 36985 +38201 757908 +38204 201554 +38204 320516 +38207 148475 +38209 271548 +3821 548 +382110 1706693 +382110 1714695 +382110 385643 +3821270 312408 +382157 18628 +382168 1104 +382168 797402 +3821973 2444707 +3821974 2444707 +3821974 3821973 +3822 537846 +3822 54918 +38222 1003274 +38222 146767 +38222 16909 +38222 170393 +38222 438240 +38222 51876 +38222 92778 +38222 97449 +382254 946954 +38229 116010 +38229 36377 +382294 1221519 +382294 734795 +382294 925586 +3823 401 +382316 194 +382323 1530385 +38238 18123 +382400 1522467 +382411 382401 +382414 1030107 +382414 1309971 +382414 1309972 +382414 1309975 +382414 1309977 +382414 522210 +382414 873294 +382454 531794 +3824561 3581007 +382513 475329 +3825428 3825429 +38256 249861 +382721 38312 +382754 655094 +382754 774584 +382754 791786 +382799 166396 +382799 29062 +382799 415412 +382934 1043043 +382934 1065010 +382934 1119694 +382934 494714 +3830135 3787578 +3830135 3887416 +3830135 3937418 +383182 856827 +3832 46988 +383221 426929 +38327 132994 +383281 132084 +383281 722712 +383308 1616 +383308 2156 +3833228 2516209 +3833228 690594 +383328 892164 +383330 383349 +383332 1742961 +383353 712125 +383366 383375 +38337 715361 +3833880 90863 +3833881 3833880 +3833881 90863 +383390 109437 +383399 39709 +383444 696349 +383488 102318 +38350 1528 +3835327 3835329 +3835330 3835327 +3835330 3835329 +38360 102091 +38360 110964 +38360 1190631 +38360 79352 +383642 1098204 +383642 383643 +383692 284166 +3837 11126 +3837 3550 +3837 545 +3837 60079 +3837 94502 +38374 134490 +38374 136640 +38374 228148 +38374 403003 +383771 217907 +38379 109184 +38379 21295 +383904 1960131 +383912 636606 +38399 11706 +38399 163457 +3840 1115232 +38400 371400 +38400 601419 +384024 669540 +38406 38407 +384104 416225 +384105 384106 +3841442 3841441 +384201 1024403 +384201 1030574 +384203 1024403 +384203 1030574 +384203 384201 +384208 48472 +384231 472275 +38424 546790 +38424 899893 +384256 73036 +384294 384295 +38432 22125 +384491 1162831 +3846097 3587618 +3846097 3912938 +3846097 3912939 +3846097 3913012 +384658 733226 +38472 67772 +384770 61114 +3848173 3513711 +384818 185752 +384818 262127 +384818 349282 +384887 34054 +3850 106541 +3850 1312723 +3850 2188653 +3850 247957 +3850 25872 +3850 391332 +3850 397679 +3850 41891 +3850 510438 +3850 52145 +3850 532 +3850 58870 +3850 7870 +38506 37191 +385069 207191 +38511 80040 +38512 38519 +38514 221653 +385189 1557003 +385189 17966 +385189 284321 +385189 874619 +3852 137399 +3852 157635 +3852 958 +38521 10966 +38521 141240 +38526 127037 +385298 242575 +3854006 3842644 +3854006 519229 +38544 34199 +385464 227416 +385486 220832 +385486 433047 +38561 1065010 +38561 132084 +38561 57770 +38561 9741 +38562 115461 +38562 95543 +385624 334984 +385698 124592 +385698 216367 +385698 425809 +3857 1475800 +3857 35155 +3858 1179182 +3858 1206273 +3858 122999 +3858 1312328 +3858 149278 +3858 229044 +3858 23366 +3858 4813 +38588 130629 +38588 130630 +38588 1422157 +38588 144532 +38588 212443 +38588 250678 +38588 36738 +38588 49422 +385905 964213 +385906 1241474 +38594 249451 +3859667 3862747 +3860 2532 +38601 693912 +386015 384700 +3860627 357853 +386077 952395 +386103 338705 +386103 850691 +386153 1385249 +386179 212187 +386179 91898 +3862 16412 +3862 17040 +3862 54813 +3862 55726 +3862747 3123890 +3862747 3174979 +3862747 3790857 +3862747 3824085 +3862747 3830135 +3862747 3846097 +3862747 3866087 +3862747 3870544 +3862747 3882720 +3862747 3887416 +3863 1141 +3864 32439 +386410 1260663 +386410 2084487 +386410 52145 +386441 161234 +386463 62770 +386466 386863 +386488 2318575 +386488 287575 +386488 350781 +38649 231983 +38649 3734962 +386493 1078726 +3865 261295 +3865 265198 +3865 29979 +3865 37731 +3865 48397 +3865788 3616835 +3865788 3886638 +386596 295792 +38661 1065010 +38661 108184 +38661 2044778 +38661 204817 +38661 353608 +38661 40792 +38661 57103 +38661 79578 +386635 2145289 +386635 651901 +38664 38663 +386660 1395354 +386660 681738 +386687 3774523 +386690 2243153 +3867 1733788 +3867 232099 +386761 115461 +3868 3393 +386822 79574 +386854 105862 +386854 1251753 +386854 167557 +386854 169783 +386854 310492 +386854 310509 +386855 565856 +386857 53890 +386857 82211 +386860 145585 +386860 375953 +386860 386860 +386860 734795 +386862 115863 +386862 116712 +386862 386863 +386863 386863 +387 115722 +387 344305 +387 489 +387 49719 +387 560125 +387 92497 +3870 51787 +3870 5592 +387033 387034 +3870544 3123890 +3870544 3448384 +3870544 3784992 +3870544 3846097 +3870544 3887416 +3870544 3913012 +387087 1233084 +387087 865251 +3871051 3871052 +3871051 3871053 +3871052 3871053 +38712 16965 +38713 3870 +38717 1194786 +3871857 1476306 +3871857 3552594 +3872142 229498 +387229 14975 +387229 352613 +387229 426147 +387229 481950 +387229 482173 +387255 574911 +38733 1613493 +387370 310493 +387370 375953 +387375 387377 +38744 113926 +38744 160610 +387465 112800 +38754 1172502 +38758 329028 +38758 8685 +38766 38597 +387661 832220 +387667 1535111 +387685 2760136 +387695 1290484 +3877 2082262 +38770 1336031 +38770 375953 +38770 411366 +38770 64680 +387721 79842 +387758 387757 +387759 205836 +387760 205836 +387760 387759 +3878 7627 +387912 64735 +38792 217 +38792 38655 +38792 696645 +38792 89607 +387994 208633 +387994 234422 +387994 26955 +388 233836 +388 26101 +388 68349 +388 68350 +388 70669 +388018 1196448 +38806 13358 +38813 124669 +388170 1996793 +388170 40633 +388170 865111 +388174 234684 +388185 1014466 +388185 1057453 +388185 1092486 +388185 1094111 +388185 1246886 +388185 1354454 +388185 190370 +388185 202094 +388185 2027433 +388185 214140 +388185 239236 +388185 2409926 +388185 262940 +388185 267134 +388185 276145 +388185 289522 +388185 3124487 +388185 32196 +388185 465983 +388185 517144 +388185 517160 +388185 522209 +388185 538821 +388185 547969 +388185 547971 +388185 567511 +388185 583138 +388185 598601 +388185 628237 +388185 648567 +388185 732482 +388185 747740 +388185 838983 +388185 838984 +388185 839233 +388185 839234 +388185 839257 +388185 855065 +388185 859446 +388185 859448 +388185 883315 +388185 896006 +388185 896007 +388185 92243 +388185 982396 +3882 194 +3882 39574 +3882 39954 +388272 136140 +3882720 3766818 +3882720 3944892 +388326 1692064 +388327 1221410 +388328 1517635 +388432 1144058 +388432 212400 +38845 26469 +388457 824699 +388514 415036 +388548 25874 +38863 12596 +38863 299682 +38863 38258 +3886638 3784992 +3886638 3790857 +3886638 3862747 +388690 348364 +3887 4486 +3887234 153980 +3887234 900110 +3887234 944146 +388737 271154 +3887416 3766818 +388805 267726 +388836 90203 +38885 152993 +38885 199253 +38885 7698 +38887 43651 +388961 388962 +38905 120826 +38905 97139 +3891 5290 +38914 269842 +38915 34791 +38916 419416 +38917 42732 +3891873 2872662 +3891873 3870544 +38921 34563 +389239 64683 +3893 110272 +3893 5593 +3893 8247 +3893459 3900227 +389477 389476 +38948 1706 +389508 4859 +389525 185580 +389525 214301 +389546 235146 +389546 389548 +389546 536926 +3896165 3862747 +3896165 3882720 +38962 3351030 +38962 4073 +3896245 3784992 +3896245 3870544 +38963 529132 +38965 12796 +38965 5595 +38965 71284 +3897689 1696921 +389779 878197 +38980 230356 +38980 394406 +38980 585843 +38980 76067 +38984 217529 +38984 238286 +38984 66561 +389864 212433 +3899223 353835 +39003 446760 +39008 40182 +390115 1634343 +390115 318371 +390115 683292 +39015 28738 +39015 399677 +3902 16368 +39033 193369 +39033 20562 +39033 5686 +390338 442919 +39038 1731 +39039 12710 +39039 1338443 +39039 200078 +39039 39352 +39039 73086 +39047 88218 +390557 508386 +390558 455298 +390562 512048 +390590 1005916 +390665 2148268 +390665 283290 +390665 367936 +39068 1620858 +390829 137880 +3909 8485 +390930 1682644 +390933 323989 +390933 415507 +390933 458667 +390961 906010 +390992 61350 +391 65145 +391 700504 +391 99731 +391058 1041403 +39112 53341 +39120 1032 +39120 16768 +39120 205812 +39120 25421 +39120 3045789 +39120 4401 +39120 70622 +39120 7532 +39120 8047 +39120 9826 +391239 57344 +391275 990048 +3912939 3866087 +3912939 3912938 +3912939 3918504 +3913012 3786480 +3913012 3830135 +3913012 3862747 +3913012 3891873 +3913013 3913012 +3913044 2069572 +39141 106639 +39141 22748 +391420 1127897 +391590 1518143 +391684 348049 +391684 92798 +391684 95705 +3918 357843 +3918 634 +3918 78659 +3918 849853 +3918394 2198557 +3918504 3784992 +3918504 3866087 +391909 48347 +3919257 3919258 +39196 38749 +39204 2056432 +39204 248755 +39206 449906 +39219 27731 +392263 387851 +392303 43388 +392341 253295 +392358 1661949 +392358 70622 +3923626 525266 +3923793 3766818 +3923793 3887416 +3924 1183315 +3924 29895 +3924 5064 +3924 66147 +3924 77811 +392407 257423 +392407 355880 +392439 17166 +3925 156045 +392528 1237395 +39262 141469 +39271 629020 +39271 68124 +392717 1022039 +392717 1516778 +392717 192322 +392717 229547 +392717 341147 +392717 829980 +392717 842269 +392717 842271 +392717 842272 +392717 912384 +392725 523642 +392725 623293 +392725 691665 +392725 841452 +392725 95537 +39274 7123 +3927959 1784609 +3928 512105 +39284 715021 +392904 251812 +39295 11818 +39295 28271 +39295 7281 +393 210595 +393 31980 +3930095 3786480 +3930095 3913012 +39302 298861 +3931013 3786443 +3931013 3891874 +393175 9382 +393176 800715 +3932683 3846097 +3932683 3912938 +393288 399334 +393288 624596 +393297 1354525 +393297 376764 +393297 950635 +3933692 3784992 +3933692 3913012 +3933988 3886638 +39342 73086 +393426 1389756 +393426 28517 +39344 137090 +39344 184279 +39344 224302 +39344 49845 +393461 168867 +393461 95147 +393485 393483 +39351 108644 +39351 55364 +39351 90993 +393599 194 +393673 476846 +393687 1571395 +393687 163281 +393687 1725654 +393688 294680 +393748 59420 +393748 634095 +39376 1048595 +39376 81052 +393784 393785 +393879 1054974 +393913 683298 +3939393 3913013 +3940681 4021013 +3940847 3018349 +3941 37681 +394124 394123 +394151 394150 +394171 387757 +394196 69150 +3942356 3891873 +3942356 3913012 +394325 362821 +394406 2398044 +39450 39445 +394537 612143 +394537 908662 +39454 26918 +39455 13936 +394643 90210 +394648 116515 +39469 167911 +3947 1026 +3947 1477 +3947 1479 +3947 1735 +3947 25516 +3947 459 +3947 6007 +3947 6008 +3947 8702 +394791 283130 +394791 712270 +394791 832942 +394791 835066 +394796 1146034 +394796 394791 +394796 725144 +394796 832934 +394844 13961 +394844 328326 +394845 394843 +394879 203532 +394879 25500 +394879 66733 +394879 690277 +394879 82568 +394898 37078 +394910 394912 +394923 48446 +3951 1437310 +3951 2027467 +3951 2507466 +3951 4374 +3951 482833 +395171 401160 +395176 277024 +395242 60179 +3952547 1858990 +395255 104612 +395405 395404 +39544 220717 +395441 48350 +3954565 2384510 +3956 430994 +3956 48347 +39573 370045 +39573 63617 +39574 153980 +39574 310343 +39574 833462 +39574 94487 +395744 244076 +39575 846949 +395793 699713 +395841 255206 +395841 395842 +395842 255206 +395859 378013 +395899 523446 +395913 119484 +395913 1868841 +395913 253245 +395913 260744 +395913 262940 +395913 368137 +395913 406273 +395913 406278 +395913 406283 +395913 415720 +395913 479033 +395913 539272 +395913 578743 +395913 712500 +395913 762680 +395913 835518 +395913 836429 +395913 842233 +395913 842238 +395913 944142 +395913 966985 +39595 2264 +395993 167247 +39600 225315 +39600 56838 +396050 396058 +39607 3780 +39607 40380 +396098 32186 +396169 2764617 +39617 21139 +396178 2805 +396178 76828 +396241 170399 +3962589 3940681 +3962589 4021013 +39634 1102827 +39634 341019 +3964 52958 +39640 101715 +396459 21517 +396473 43828 +396497 1092074 +396497 1092075 +39655 66143 +396586 252109 +396638 1570135 +39664 1070194 +39664 1124596 +39664 1124597 +39664 1124598 +39664 15787 +39664 209136 +39664 211121 +39664 279684 +39664 320531 +39664 320925 +39664 413695 +39664 93425 +396645 209668 +39666 1435159 +396664 396663 +396675 1125649 +396675 125642 +396675 1815910 +39670 754136 +396751 32507 +396762 1195579 +39677 12367 +3968 11593 +3968 1344 +3968 6345 +396813 396800 +39687 101601 +3968921 1485997 +3969 272217 +3969 54721 +396939 1072839 +396939 291339 +396942 123904 +396950 120430 +396950 421544 +396999 2264 +39705 91981 +397107 1200419 +397107 825201 +39711 237429 +39713 37308 +397172 289495 +39720 1570898 +397230 270172 +397250 627811 +397303 57261 +3973170 3618387 +397333 267857 +397336 397335 +39740 194996 +397496 397495 +39754 3286003 +39760 1603785 +397605 1164987 +397616 1028502 +397616 1653520 +397616 269254 +397616 517158 +397616 517165 +397616 662168 +397616 696188 +397616 703271 +397616 833788 +397616 844422 +397616 869694 +397616 880957 +397616 908890 +397617 192322 +397617 829980 +397618 283127 +397618 754974 +397618 95544 +397619 1724185 +397619 262940 +397619 3460300 +397619 466144 +397619 814478 +397619 833168 +397619 833554 +397619 833736 +397619 838930 +397619 839640 +397619 845358 +397619 852345 +397619 859036 +397619 861484 +397619 865048 +397619 865055 +397619 865654 +397619 865655 +397619 865659 +397620 1430197 +397620 1481537 +397620 1481547 +397620 170759 +397620 2129819 +397620 269254 +397620 273394 +397620 2982835 +397620 397619 +397620 406281 +397620 466144 +397620 538821 +397620 703271 +397620 754974 +397620 814478 +397620 833168 +397620 833554 +397620 833736 +397620 833842 +397620 835190 +397620 837568 +397620 838930 +397620 838932 +397620 844249 +397620 845358 +397620 848261 +397620 851589 +397620 852345 +397620 855056 +397620 855061 +397620 859036 +397620 861484 +397620 861487 +397620 865048 +397620 865055 +397620 865654 +397620 865655 +397620 880605 +397620 880609 +397620 882018 +397620 882019 +397620 986112 +397651 1850 +397651 329287 +39766 11879 +39766 158676 +397676 375603 +39769 17957 +397736 397737 +39774 40152 +39775 104312 +39776 16406 +39776 249449 +39776 262943 +39776 83609 +39776 86094 +3978394 319329 +3978510 3978509 +397946 6381 +39797 428533 +397977 234181 +3980 162772 +3980 173582 +398047 145263 +398047 403488 +3981 14361 +3981 16934 +3981 318221 +3981 5208 +3981191 1163926 +3981191 1759585 +3981191 3981192 +3981192 1759585 +398203 334659 +398206 18628 +398211 280940 +398271 302676 +398271 993736 +39829 11213 +39833 10991 +398337 900024 +39834 105456 +39834 107386 +39834 212995 +39834 22428 +39834 224983 +39837 109832 +39837 54186 +39837 60978 +39838 110153 +39838 14743 +39838 75542 +398541 398542 +398664 398663 +398666 266824 +398673 205037 +398673 641520 +398677 28568 +398677 434256 +398677 75956 +39868 1005919 +398700 199723 +39874 262940 +39874 368137 +39874 454293 +39874 835735 +39874 842132 +398748 1145355 +39878 81308 +398781 1065010 +398781 35135 +398785 346721 +398830 1358473 +39885 1100648 +39885 96123 +39889 237572 +398944 140861 +39898 2408984 +39899 4614 +3990 183937 +39903 10573 +39903 39904 +39904 10573 +399047 497305 +39908 10995 +39908 126114 +39908 16508 +39908 39909 +39908 4778 +39908 73255 +3990814 125291 +39909 10995 +39909 32000 +39909 423973 +39909 73255 +399105 1236078 +399184 1517947 +399232 393995 +399275 399276 +399334 624596 +39946 110156 +39946 57770 +39947 122088 +399475 280623 +399475 335352 +399475 368643 +39954 19414 +39954 39955 +399568 882304 +399673 383182 +3997220 3820315 +39981 194511 +399868 1094847 +399868 1297900 +399868 250149 +399868 2589334 +399868 449043 +399868 696225 +39987 1016605 +39987 102507 +39987 1055679 +39987 12261 +39987 141854 +39987 176073 +39987 39987 +399941 18620 +4 1081048 +4 169157 +4 219536 +4 23333 +4 318221 +400096 362652 +400096 438610 +4001 3586 +400105 1473541 +400107 1115343 +400297 45583 +4003 309422 +4003 407657 +4003 458982 +4003 818356 +40030 21032 +4003524 450886 +400575 1033055 +400575 1037360 +400575 170 +400575 400574 +400575 53394 +400575 842110 +40069 43804 +400690 400689 +400711 234616 +400711 2878704 +400711 3257990 +400811 2695777 +400811 347809 +400811 711307 +40083 54965 +400856 819970 +400992 1373 +401032 401031 +40105 75895 +4011 10780 +4011 167665 +4011 21139 +4011 66099 +4011 9179 +401175 401176 +401197 29895 +4012 191665 +4012 331294 +401200 401207 +401272 401271 +401272 683437 +4013 121471 +4013 45835 +4013 5410 +4013 79505 +4013 8339 +4013 8364 +40130 761103 +40130 86168 +401389 401387 +4014 12517 +4014 14603 +4014 403536 +4014 5414 +401460 178822 +401497 346389 +4015 132273 +4015 2449670 +4015 38258 +40152 63019 +40152 7708 +4016 191782 +401639 28896 +40164 294978 +40164 36951 +40164 86908 +401737 2576918 +401773 1054362 +401773 1853047 +401773 363188 +401773 37722 +4018 14742 +4018 76714 +401802 335565 +401862 823674 +401878 7991 +401878 922770 +40191 31283 +401936 360999 +402062 620632 +40218 91947 +402217 603082 +402233 10001 +402233 17080 +402233 1727125 +402233 2074 +40226 247757 +40226 634 +40228 40520 +4023 15889 +4023 244664 +40233 91551 +40234 383061 +40235 255117 +402392 1271720 +4024 43020 +4024496 3862747 +40246 2704 +40247 10290 +40252 2587856 +402523 1202892 +402523 13667 +402566 477429 +402594 648713 +40260 2145850 +402609 677706 +402640 37820 +4027 493939 +402713 402712 +402826 402825 +402925 1612259 +402925 330164 +403003 1403419 +403003 176601 +403003 249872 +403003 503631 +403003 504918 +403090 297037 +403090 386145 +403178 284160 +4033 264475 +403340 1876740 +403367 811947 +403394 128255 +403434 406173 +403483 1093139 +403483 36147 +403529 212002 +403529 353179 +403633 264998 +403633 305295 +403633 335067 +403633 804768 +403639 1204849 +403639 1204851 +403639 416808 +403639 66310 +403639 750194 +40372 184605 +40372 30615 +403774 403773 +4038 136452 +403915 192192 +403960 403959 +403970 192081 +40399 3268 +404028 150807 +404028 212751 +40403 921833 +404044 899136 +40407 80916 +40409 21767 +404137 404136 +404147 181221 +404201 836534 +404276 244096 +4043 103590 +4043 3283039 +40433 188244 +404414 581297 +40445 181427 +40445 22910 +40445 32446 +40445 5682 +404454 404453 +404532 257306 +404532 80529 +40467 28443 +404704 243242 +404704 9011 +404795 404791 +404841 1739541 +404878 1280959 +404987 449609 +404987 475551 +405053 103577 +405053 10933 +405053 109437 +405053 27950 +40508 235221 +40508 239184 +40508 27324 +40508 29793 +40508 818544 +405362 299489 +40538 33932 +4054 296366 +40544 1523 +40550 404689 +4056 19056 +4056 31109 +4056 349398 +4056 4059 +4056 4060 +4056 92009 +405692 387448 +405735 870279 +40582 1231703 +40582 212187 +40582 64735 +405840 502434 +405840 561465 +40585 285707 +40585 344024 +4059 31109 +4059 4060 +406 11598 +406101 419786 +406156 1858482 +406165 211211 +406165 35746 +406165 37906 +406165 37913 +406230 406230 +406271 1058892 +406271 1246886 +406271 283473 +406271 395913 +406271 696257 +406271 712500 +406271 775294 +406271 832661 +406271 973802 +406273 1868841 +406273 192325 +406273 626175 +406273 704150 +406273 744724 +406273 842233 +406273 944142 +406273 966985 +406278 2129819 +406278 262940 +406278 317584 +406278 406281 +406278 499563 +406278 703268 +406278 703271 +406278 754894 +406278 754974 +406278 837674 +406278 843647 +406278 903706 +406281 1009447 +406281 115469 +406281 226461 +406281 2333550 +406281 368137 +406281 395913 +406281 406273 +406281 424576 +406281 550341 +406281 552196 +406281 833128 +406281 833794 +406281 833842 +406281 837584 +406281 838932 +406281 844249 +406281 855056 +406281 861487 +406281 912593 +406281 92243 +406281 931384 +406281 946948 +406281 959952 +406283 1009447 +406283 226461 +406283 2333550 +406283 294746 +406283 406273 +406283 406281 +406283 479036 +406283 754974 +406283 912593 +406283 931384 +406283 946948 +406284 254891 +406285 1058892 +406285 1246886 +406285 283473 +406285 406271 +406285 775294 +406285 832661 +406285 973802 +406286 406287 +406352 1102976 +4064 491818 +406423 1009232 +406423 1381485 +406423 2483583 +406423 361608 +406423 754958 +406423 832995 +406423 961746 +4065 518219 +406579 257306 +4066 18412 +4066 20403 +406673 309844 +406686 1522857 +4067 125330 +4067 198924 +4067 47994 +4067 5980 +4067 9521 +406711 11357 +40672 952284 +40675 3504 +406831 295202 +406840 1475342 +406862 192192 +406862 587087 +407111 1117934 +407111 1159365 +407111 1254803 +407111 1584642 +407111 1876948 +407111 1876949 +407111 274325 +407111 2855180 +407111 350483 +407111 407120 +407111 410380 +407111 428883 +407111 434336 +407111 456764 +407111 456827 +407111 457141 +407111 458266 +407111 55104 +407111 598812 +407111 836085 +407111 997840 +407120 328731 +407120 997840 +407125 114899 +407171 960507 +407190 156562 +407260 3393777 +40729 200006 +4073 1738706 +4073 25532 +4073 361539 +4073 747014 +407305 1153375 +407384 1695313 +4074 175297 +407485 267225 +4075 1676 +4075 17399 +407517 231329 +407517 262000 +407517 342214 +407517 43695 +407517 7698 +407517 805014 +4076 26772 +407630 768934 +407707 63822 +407719 112154 +407719 21923 +407727 581435 +407747 407748 +407748 132882 +407763 190930 +407880 753561 +4079 14397 +4079 480252 +4079 7162 +407914 575129 +407948 1132656 +40808 670 +40810 1636932 +40810 19849 +40813 226531 +408185 2603521 +4083 41470 +408402 137880 +408439 1166944 +408439 898038 +408439 978661 +408506 1692684 +40853 470810 +40857 298561 +408589 2727251 +408612 361790 +408613 1031351 +408668 1034535 +408851 79489 +408929 797555 +40899 254416 +4091 14743 +4091 149162 +4091 17035 +4091 1879176 +4091 2687330 +4091 50581 +40915 66153 +40916 263929 +409240 1197247 +409244 1409627 +409252 409246 +40927 48363 +409287 47109 +40932 1133778 +40932 1381534 +40932 95623 +40953 2727110 +409536 214188 +4096 17594 +40968 40969 +4097 7298 +409815 1326028 +40986 256159 +409863 1165336 +40987 37382 +409891 1121888 +409891 1250614 +409899 302401 +409899 87774 +40998 84030 +41 62507 +410038 153980 +410038 361814 +410091 195791 +410260 98563 +410333 176185 +410333 503126 +410342 275319 +410344 103064 +410344 477402 +410346 260252 +410375 410387 +410380 428883 +410387 579188 +410449 611732 +410515 1122733 +410555 391953 +41058 247972 +410629 2265 +410703 1972222 +410703 268789 +410703 410704 +410704 1972222 +410704 268789 +410748 491088 +410748 89322 +41077 239905 +410869 110836 +41094 525060 +410990 957692 +410991 101867 +41107 2266 +41118 2012236 +41118 21947 +4112 29101 +41121 58723 +41123 248739 +411234 476499 +411333 1636104 +41134 48142 +411356 411355 +4114 138774 +411435 1251690 +411447 510485 +4115 1493781 +4115 5823 +411516 1409886 +411541 1435954 +411541 1877421 +411541 411541 +41157 33937 +4116 161487 +4116 21582 +4116 2264 +4116 24556 +4116 24566 +4116 24568 +4116 356288 +4116 7658 +411631 1061141 +411631 1061142 +411631 1179820 +411631 1304576 +411631 362652 +411631 411631 +411631 4948 +411631 5980 +411631 61048 +411645 150433 +411692 1051454 +411692 117415 +411692 2635529 +411692 304190 +411692 700793 +4117 338 +411737 1128804 +411737 161063 +411737 30138 +411737 49803 +411780 1109953 +411780 158419 +41180 563758 +41189 110599 +41189 132019 +411977 761591 +41201 179059 +41201 413920 +41233 112470 +4124 10469 +4124 1166964 +4124 130180 +4124 189821 +4124 31444 +4124 4124 +4124 5470 +4124 557815 +4124 85528 +4124 9388 +41249 257123 +412612 41815 +41265 604205 +41269 115131 +41270 119546 +41270 3924 +41270 5064 +41270 587078 +41270 65317 +41272 146233 +41272 194 +41272 20212 +41272 25872 +41272 3175988 +41272 368160 +41272 46176 +41272 56958 +41272 5759 +41272 64735 +41272 64943 +41272 7871 +41272 892961 +41279 32358 +412824 118935 +41294 5975 +412969 316586 +412969 371714 +412969 430354 +412969 75559 +413127 188041 +413127 222384 +413127 344166 +413127 985935 +413132 391207 +413164 1337940 +413164 73121 +41319 117449 +41320 180474 +413268 413269 +413350 72186 +413365 3600041 +413365 4716 +4134 42822 +413423 355659 +413608 413611 +413608 56194 +413618 41232 +413851 301690 +413878 625001 +41388 2335593 +41389 54567 +413955 1065010 +413955 1093094 +413955 131775 +413955 331629 +41396 59411 +41396 657259 +41396 96398 +41400 299156 +414053 23333 +41408 252611 +41414 153941 +41415 1006301 +414159 17396 +41417 245741 +41417 828562 +414229 19954 +41425 136224 +41425 61402 +414270 1901700 +414382 252097 +414392 78546 +41441 49908 +41443 175900 +41443 467945 +41453 37243 +41453 797919 +41457 970535 +414643 1557003 +414643 17966 +414643 284321 +414643 385189 +414643 874619 +41471 4083 +414718 414726 +414853 549164 +414895 31802 +414895 35445 +414895 36738 +414895 84774 +414895 93153 +414957 2526635 +414996 1858990 +414996 3952547 +414997 310492 +415 95953 +41500 18628 +415016 1336839 +415027 1043041 +415027 1884193 +415027 1884194 +41520 58078 +41520 914143 +415211 2322003 +415243 1235958 +41525 2454 +41525 95156 +415253 1586312 +415269 264169 +415412 166396 +415470 1251682 +415470 1386786 +415470 1386787 +415470 1389700 +415470 838295 +415470 906873 +415720 1032265 +415720 1463723 +415720 164279 +415720 262940 +415720 304975 +415720 366820 +415720 462603 +415720 520248 +415720 547971 +415720 626175 +415720 627442 +415720 696225 +415720 704150 +415720 754974 +415720 832917 +415720 833697 +415720 842888 +415720 850894 +415720 851589 +415720 857117 +415720 897378 +415720 926979 +415725 1048430 +415725 1233375 +415725 1636340 +415725 1732861 +415725 224329 +415725 262940 +415725 267134 +415725 3397762 +415725 502809 +415725 532276 +415725 532414 +415725 570542 +415725 598601 +415725 659953 +415725 832915 +415725 833166 +415725 836588 +415725 837657 +415725 837660 +415725 838984 +415725 841441 +415725 842233 +415725 842308 +415725 843127 +415725 846282 +415725 861690 +415725 877524 +415725 882784 +415725 914150 +415725 987866 +415751 31750 +4158 254301 +4158 32010 +4158 3909 +4158 70867 +415859 338446 +415957 41270 +415964 1478685 +415964 2009193 +415964 2665832 +415964 467965 +415964 572097 +415964 580827 +415964 689243 +415965 196189 +415987 173932 +415987 22203 +415995 415999 +416 52501 +416009 134402 +416009 17799 +416009 19616 +416009 42872 +416009 7679 +416009 89641 +416104 270742 +416305 416306 +416399 257353 +416399 289505 +41644 9271 +41650 1214280 +416575 256667 +416578 276970 +41658 263416 +416620 193276 +416620 721137 +416748 283562 +4168 1882903 +416808 1204849 +416808 1204851 +416808 750194 +416866 137602 +416910 337738 +41698 202423 +417 1036056 +417 145820 +417 1718 +417 22979 +417 24422 +417057 220884 +417068 755575 +41707 347777 +417070 417068 +41715 283127 +41715 469216 +41715 754974 +417312 1196196 +417428 1433621 +417428 163042 +417428 1871562 +417428 255421 +417441 3638897 +41755 356089 +417581 712540 +417604 1430975 +417652 506494 +41767 53077 +41769 207095 +417696 1078740 +417839 1043041 +41798 5391 +41798 72965 +41798 8099 +418 148593 +41801 62991 +41815 2336504 +41815 851207 +418174 264481 +418175 1299987 +418175 1443207 +418175 2004798 +418175 835113 +418175 835406 +418175 95543 +418240 219403 +418348 256582 +418479 647608 +418639 10824 +41873 20968 +418737 264821 +418768 83536 +418852 1092252 +418852 1202325 +418852 273394 +418852 369576 +418852 418853 +418853 1092252 +418854 1092252 +418854 1202325 +418854 273394 +418854 369576 +418854 418852 +418854 418853 +418854 418854 +4189 4605 +41891 154702 +41891 214840 +41891 288656 +41891 350782 +41891 389546 +41891 389548 +41891 59226 +41898 35486 +418982 193682 +419 11203 +419 79878 +419017 1599112 +419019 386863 +41904 141326 +41904 212012 +41904 252062 +41904 253462 +41904 42708 +41904 451933 +41904 458047 +41904 99207 +41904 99731 +419065 701496 +419076 3273144 +419143 887885 +41922 37906 +41922 470620 +41933 677755 +419365 589055 +419413 1115620 +419440 860333 +419677 2282960 +4197 1864113 +4197 9056 +419904 60797 +419976 705663 +420011 157017 +420012 1535553 +420179 1438084 +420179 532045 +420349 36100 +42035 12929 +420353 122418 +420353 95080 +42042 770508 +4205 101847 +4205 114483 +4205 210705 +4205 336175 +4205 33844 +4205 5886 +4205 6274 +420558 2387670 +420651 624491 +42069 123484 +42075 210389 +42084 106959 +42084 4865 +42089 101840 +4209 677676 +4209 90086 +42099 23223 +4210 1014 +42103 110309 +42103 343268 +42103 343269 +42104 42105 +42109 42123 +42110 288960 +42123 44860 +42124 1161789 +42124 116601 +42124 117723 +42124 139875 +42124 198269 +42124 19895 +42124 211461 +42124 433341 +42124 546661 +4213 1731191 +4213 287990 +4213 9435 +4213 997489 +4214 114493 +42148 61316 +4215 30425 +421503 353656 +4217 12726 +421761 158778 +421761 278354 +421761 294172 +421761 308684 +421761 312762 +421761 413132 +421761 41734 +421761 564553 +421761 625355 +421761 6644 +42182 84641 +421827 2422048 +421866 1751713 +421866 621175 +421866 715301 +42189 215585 +42189 37109 +42189 60316 +42191 78710 +421956 1411168 +421956 730445 +422068 422068 +422068 465889 +422068 696225 +422068 867995 +422082 32792 +422165 15108 +422165 2335220 +422165 321183 +422282 186449 +4223 1265373 +4223 2223526 +4223 2596568 +4223 296950 +4223 66020 +4223 68181 +4223 9070 +42232 60479 +4224 11072 +422415 623721 +422469 361539 +42262 190146 +42262 200603 +42265 25571 +4227 19480 +4227 6865 +4227 6866 +422735 97545 +42276 1457081 +42276 1861407 +42276 21043 +42276 919142 +422878 3330571 +422984 959215 +4230 312717 +4230 441578 +4230 8463 +4230 9706 +42306 63938 +423081 985408 +423099 120312 +423099 254976 +423099 256558 +423298 1265566 +423298 1266883 +423298 254400 +423298 312587 +423298 314301 +423298 447940 +423298 481548 +423298 531489 +423298 870181 +423436 253245 +423436 472611 +42346 61750 +4235 66883 +4235 77022 +42357 11336 +42360 98684 +423650 284386 +423679 280948 +42370 2053 +423703 63033 +423703 744837 +423732 3245568 +423743 2154831 +423924 127095 +423938 11136 +423938 201185 +423938 23825 +424 34008 +4240 1174858 +4240 135121 +4240 180846 +4240 2218984 +4240 2264 +4240 65347 +4240 669426 +4240 70745 +424043 509299 +424107 153980 +424107 950106 +424108 880769 +424117 11450 +424117 1227 +424117 165662 +424117 4071 +424117 76444 +424117 79505 +424150 833903 +424150 961751 +4242 1455563 +4242 26198 +4242 662574 +4242 764431 +4242 772177 +4242 984483 +424276 1269513 +424276 1270472 +424305 249584 +424389 1051822 +424389 320310 +424389 336768 +424389 70622 +424415 235382 +424415 980417 +4245 872771 +424576 108568 +424576 1546670 +424576 164477 +424576 255804 +424576 260744 +424576 269254 +424576 27519 +424576 304968 +424576 329570 +424576 3525078 +424576 3525079 +424576 3525080 +424576 415725 +424576 517165 +424576 704150 +424576 833097 +424576 833446 +424576 833554 +424576 838983 +424576 838984 +424576 890675 +424576 92243 +424576 957098 +42469 1051574 +42469 42473 +42469 70436 +424754 1947294 +424754 2803229 +424754 781552 +4248 948229 +42482 334646 +42485 410409 +424973 413164 +424973 535617 +425124 304975 +425124 425125 +425124 95546 +425125 304975 +425125 95546 +42522 83516 +425221 32212 +425221 453619 +425231 90203 +425235 166289 +425235 397513 +425238 387717 +425241 25009 +425285 1008036 +425285 353608 +425421 357078 +4255 13332 +4255 17265 +4256 7966 +42562 42563 +42565 6981 +42577 366192 +42577 5914 +425805 499766 +425858 37649 +4259 651 +425907 1726 +42597 613232 +42599 1448964 +42599 288124 +42599 3815208 +42599 91810 +42601 2500 +42602 120215 +42602 3237903 +42602 3238104 +426147 14975 +426147 352613 +426147 481950 +426147 482173 +426163 1932586 +426224 651028 +426224 670847 +426224 860331 +42626 42627 +426368 2150496 +426488 293773 +4265 13311 +4265 1369478 +4265 334837 +4265 367006 +4266 21137 +4266 52638 +4266 52835 +4266 629020 +426668 106562 +426668 10898 +426668 28943 +426668 32843 +426668 63678 +426668 8099 +42669 106260 +42669 59214 +426840 17591 +426840 9373 +426849 11433 +426940 396613 +427040 236713 +42708 141326 +42708 212300 +42708 253462 +42708 260604 +42708 292493 +42708 297021 +42708 65625 +42708 736721 +42713 306473 +42715 38916 +42726 143778 +42726 247715 +42737 107822 +427515 159506 +42754 305209 +42757 1048557 +42757 253093 +42757 255129 +42757 257307 +42757 277541 +42757 289793 +42757 360344 +42757 377049 +42757 447940 +42757 503340 +427589 312020 +427638 117420 +42771 64940 +427749 338452 +427948 156086 +427948 237509 +427985 427984 +427992 361356 +42805 10122 +428084 425658 +4281 50406 +4282 15910 +428219 699803 +42822 15747 +42826 16853 +42826 40550 +42829 10686 +42829 3700243 +42829 45529 +42829 45530 +42829 459 +42829 513617 +428382 2454 +428382 41525 +428382 95156 +428505 562700 +42868 59578 +4288 521920 +4288 98827 +428849 778075 +42885 202714 +42885 52081 +42885 88741 +42885 99028 +428898 53143 +42894 7849 +42895 11072 +428970 1229592 +42907 17142 +42907 35611 +429103 2258823 +42912 245720 +429193 90659 +429240 2356797 +429264 931832 +4293 1174 +4293 229835 +429339 405856 +429364 1170046 +429364 679280 +429422 512545 +42945 725159 +429535 962462 +429549 960002 +42968 173847 +42977 32497 +42984 1609796 +429888 169099 +42991 11050 +429936 429935 +4300 10064 +430106 145843 +430106 822140 +43011 50595 +43011 62919 +430169 56575 +4302 31645 +4302 59683 +43020 108939 +43020 79104 +43020 99965 +430217 111545 +430217 223782 +430284 430283 +430479 530619 +430488 7278 +430561 160696 +430561 55069 +430752 430739 +430752 816895 +430774 179509 +430778 1234383 +430816 655514 +430816 847749 +43082 398654 +430829 349801 +430876 427933 +430876 463051 +430885 369206 +430885 490139 +430885 490140 +430914 832661 +430914 95537 +43104 637494 +431058 406251 +431058 433779 +431081 10355 +431081 18160 +431181 1680532 +431181 2024987 +431186 1680532 +431186 1999588 +431186 2024987 +431186 431181 +431186 577415 +4312 224699 +431229 282137 +431229 627128 +43128 246129 +4313 2996 +4313 4288 +43143 186794 +431432 431254 +431432 431447 +431432 431757 +431485 841296 +4315 57179 +43151 252318 +43151 2840565 +43154 1528 +43154 357538 +43154 38350 +431652 431440 +431652 435141 +43174 151854 +43174 169601 +431748 431056 +431757 431254 +431861 3182008 +431927 44930 +43208 193760 +43208 214023 +43208 4493 +432090 432091 +43211 1623225 +43211 43212 +432137 103256 +432137 17926 +432137 193630 +432137 223649 +432231 728171 +432231 783902 +432253 457250 +432265 759040 +432324 513748 +432324 652190 +432368 1615116 +432368 195376 +432368 959331 +43246 75775 +43246 81945 +432500 1034911 +432500 1520617 +432500 1726981 +432500 836153 +432500 918927 +43251 51116 +432589 366820 +432660 122975 +432674 253986 +432674 3475826 +43268 350630 +432737 1432290 +432737 1451766 +43281 679189 +432941 649027 +432960 1055111 +432960 1327245 +432960 1433853 +432987 359822 +433083 1431768 +433083 994569 +433085 851257 +433107 2910034 +43315 193354 +433153 106348 +433153 22278 +433153 817743 +433179 577623 +4332 11034 +4332 41063 +433254 504168 +4333 187382 +4333 27969 +4333 331589 +4333 45835 +4333 919119 +433312 132759 +433312 850050 +433341 410290 +433349 31715 +4334 11691 +4334 124158 +4334 1990356 +4334 3556918 +4334 369068 +4334 48671 +433583 27657 +433626 529058 +433627 1113556 +433630 434365 +433641 1116650 +433641 2136973 +433641 431654 +433641 512427 +433641 820846 +433666 2219775 +433779 406251 +433852 1233462 +433911 280965 +433979 1770632 +433983 71081 +433990 242433 +43412 403003 +43412 44533 +434183 795127 +43428 917379 +434285 260165 +434333 3586217 +434336 456210 +434347 650140 +434393 434396 +434393 434401 +434396 434401 +43442 875327 +43445 32352 +434469 1435119 +4345 12751 +434634 1718743 +434656 1028502 +4347 1252891 +4347 43234 +434929 75026 +43493 72358 +434952 2547157 +434960 434959 +434960 434962 +434962 434959 +435 15286 +435 8362 +43502 61844 +435111 445634 +435140 915714 +435141 431440 +435258 120656 +435373 2014288 +435388 704150 +435388 836111 +435432 366056 +43552 156316 +43554 241309 +43554 44358 +43554 823352 +435555 1021211 +435555 1028082 +435555 1044334 +435555 1120029 +435555 1314144 +435555 1611690 +435555 1690917 +435555 1831747 +435555 2004798 +435555 3022452 +435555 418175 +435555 448010 +435555 517158 +435555 595478 +435555 599488 +435555 696192 +435555 696225 +435555 706861 +435555 826839 +435555 832661 +435555 833667 +435555 835066 +435555 835090 +435555 835112 +435555 835132 +435555 835184 +435555 835187 +435555 838243 +435555 842085 +435555 843513 +435555 855140 +435555 864674 +435555 904645 +435555 931948 +435555 96123 +435555 984958 +435613 192054 +435645 617851 +435659 134275 +435659 67770 +435661 90883 +43570 38588 +435758 2649806 +435760 528372 +435760 921348 +435792 270245 +435813 97746 +43589 264268 +43589 5372 +43589 63144 +435956 633748 +43597 43596 +435996 612777 +43604 456548 +43605 782235 +436088 263832 +436165 704625 +436197 1267800 +436197 283125 +436197 805380 +436197 826542 +436200 735380 +436369 596335 +43637 312708 +43638 92357 +436474 227843 +43649 174795 +4367 3 +43672 191103 +43672 56469 +43674 789427 +436891 2766849 +43690 465864 +43695 12705 +43695 30322 +43695 30325 +437 1214261 +43728 683539 +43731 42872 +43746 142195 +437529 140575 +437659 1009586 +437659 270172 +437659 289621 +437659 3182008 +437659 431861 +43766 150520 +437677 1608826 +437677 1608827 +437677 275456 +437677 283300 +437677 437677 +437677 905674 +437677 958217 +437685 644141 +437685 832962 +437685 835735 +437689 445596 +437734 145698 +43779 89673 +43783 59523 +437970 1001775 +437970 1486572 +437970 1882116 +438 212837 +438007 330856 +43806 37972 +43806 43577 +43806 45773 +43812 2232397 +43813 42138 +438153 354923 +43818 309906 +4382 2872429 +4382 44663 +438264 1402603 +438264 193470 +438264 234515 +438264 32695 +438264 3858 +438264 433615 +438264 467945 +438264 901332 +43828 397366 +43828 7710 +438304 251623 +43832 159878 +43832 85918 +43832 85919 +4384 66158 +43844 62722 +438548 498115 +438558 1753467 +438610 147379 +438610 362652 +438610 438610 +438610 540613 +43865 88762 +438711 588461 +43874 109479 +43878 3092 +43878 4601 +438783 120307 +438783 129676 +438783 1441341 +438783 146906 +438783 1546881 +438783 1623587 +438783 1637304 +438783 1689694 +438783 1815468 +438783 1934985 +438783 2365887 +438783 2723334 +438783 2758801 +438783 300542 +438783 3062379 +438783 34932 +438783 577623 +4389 10876 +4389 28521 +4389 71789 +4389 8254 +439006 2785627 +439178 439179 +439192 237518 +439278 139535 +439369 756621 +43937 115091 +43937 16909 +43937 18440 +439406 546568 +43945 102452 +43945 108825 +43945 132315 +43945 220778 +43945 62085 +43945 6286 +43945 6326 +43945 7530 +43945 8463 +43946 146678 +43946 630802 +439533 2827226 +439533 341656 +439533 572858 +439534 364825 +439536 299951 +439536 38201 +439536 446637 +439536 79742 +439540 1228955 +439540 2118314 +439542 1115343 +439542 1611868 +439542 2843514 +439542 970740 +439545 1191890 +439545 257353 +43957 59060 +43962 148016 +439663 1471362 +439663 262940 +439663 714002 +439663 821985 +439664 1511355 +439664 683885 +439664 833543 +439664 833787 +439664 865655 +439698 269683 +43978 62992 +439793 624312 +439815 1824549 +43982 365258 +439821 52146 +4399 328837 +440066 33332 +44013 152616 +44018 640246 +44018 99793 +4403 1065109 +44033 141080 +440386 134250 +440420 1147231 +440420 266768 +440529 475071 +440556 15821 +440614 355145 +440675 399868 +4407 3565583 +4407 4384 +4407 66158 +4407 9534 +44082 65947 +44085 7991 +440896 2876641 +440896 2876642 +440896 298861 +440896 915630 +440978 312337 +440981 1645457 +440981 395188 +440981 819170 +44101 1060 +44101 1702124 +44111 128718 +44111 77001 +44114 317203 +44117 370805 +44117 870178 +44118 222596 +44118 260851 +44118 271691 +44120 258118 +44120 29058 +441207 1343074 +441207 1936871 +441207 255801 +441207 310172 +441207 460176 +441207 508131 +441207 775065 +441207 845123 +44123 1998426 +44126 257623 +44126 341422 +44126 41249 +44128 239566 +44128 261196 +44128 329904 +44130 175703 +44130 252998 +44130 256065 +44130 26478 +44130 285231 +44130 45102 +44131 27990 +44131 310762 +44131 357709 +44133 145262 +44133 255947 +44133 3069573 +44133 34183 +44134 41401 +441400 459835 +441475 229466 +441493 1109127 +441528 1636340 +441528 415725 +441528 837657 +441528 837660 +441528 838984 +441528 861690 +441528 987866 +44163 750131 +44165 1981452 +441657 178990 +441676 2446278 +4417 10819 +4417 227102 +4417 661 +441791 312610 +441821 55029 +441824 335447 +44205 382110 +44205 398937 +44208 44644 +442174 1022025 +442174 1064107 +442174 1129949 +442174 1245031 +442174 1259101 +442174 1291352 +442174 1420541 +442174 1496956 +442174 153980 +442174 1640338 +442174 2115800 +442174 2333160 +442174 262940 +442174 269254 +442174 282137 +442174 304975 +442174 368137 +442174 397620 +442174 454293 +442174 525469 +442174 526594 +442174 573239 +442174 617133 +442174 620726 +442174 696253 +442174 696257 +442174 744723 +442174 784121 +442174 832962 +442174 832992 +442174 833821 +442174 833824 +442174 833986 +442174 834378 +442174 835518 +442174 835735 +442174 837527 +442174 837548 +442174 837568 +442174 842223 +442174 843127 +442174 858575 +442174 861581 +442174 861805 +442174 869570 +442174 883641 +442174 899565 +442174 982126 +442174 988711 +442174 988713 +442257 5385 +442271 1155649 +442312 776081 +442505 1677225 +442544 432758 +442544 77076 +442545 596999 +442553 925586 +44266 144978 +442685 257459 +44269 44270 +44270 413867 +442799 361293 +442815 1191921 +442816 2816873 +442816 857404 +442922 442919 +443 501308 +44300 813949 +44313 3228332 +443138 720420 +443144 51229 +44323 440371 +443257 318371 +443257 443259 +443257 835731 +44327 18563 +443452 891317 +443460 14643 +443487 583012 +443507 723041 +443521 228758 +44360 157232 +443770 14709 +443770 1484346 +443770 1535052 +443770 284995 +443770 525138 +443770 938392 +443838 1716577 +443887 135829 +44391 133345 +44392 13873 +44399 145878 +444081 425658 +444216 4778 +44422 117660 +44422 1274085 +44422 1402662 +44422 228158 +44423 7137 +44423 9521 +44427 3858 +44429 117660 +44429 243203 +44429 283 +4443 11682 +4443 63129 +44440 139025 +44444 411580 +4445 15694 +4445 8056 +444554 444553 +444577 2023284 +444580 447581 +444606 696134 +444606 704150 +444606 835968 +444606 881800 +444623 280181 +444623 444619 +444623 848543 +444632 988369 +444808 444809 +44487 736078 +44488 288656 +4449 218576 +444927 138018 +444937 66727 +44494 11245 +444952 90203 +4450 124833 +44503 577744 +44504 135121 +445075 2058394 +445075 2058395 +4451 34341 +445144 1270278 +445144 1538023 +445144 445143 +44517 155701 +4452 152246 +4452 1846423 +4452 337062 +4452 353627 +4452 378229 +4452 69817 +4452 701741 +44520 126446 +44522 50528 +445357 7137 +44543 261838 +445457 3336165 +44552 242309 +44558 240506 +4456 326748 +445645 99731 +445675 40046 +44589 55456 +44592 72353 +446098 349923 +446105 1063282 +446105 283469 +446105 425125 +446105 445532 +446105 552195 +446105 624749 +446105 796211 +446105 838040 +446105 854918 +446105 95544 +446165 1618714 +446199 1454 +446205 113916 +446212 360979 +44640 243546 +44640 262245 +44640 262246 +44640 697355 +446455 287575 +446455 610194 +44647 253526 +446471 841660 +446471 900180 +446471 919149 +446483 45392 +446485 58654 +446489 17857 +44649 44650 +446577 1092483 +446577 1541603 +446577 1933252 +446577 260744 +446577 283122 +446577 283127 +446577 451535 +446577 455839 +446577 517158 +446577 526409 +446577 526411 +446577 532276 +446577 538646 +446577 578737 +446577 696225 +446577 712500 +446577 754974 +446577 833071 +446577 833075 +446577 833163 +446577 833446 +446577 834073 +446577 838040 +446577 839257 +446577 855060 +446577 861487 +446577 880609 +446577 882033 +446577 907452 +446577 973042 +44661 1043981 +446748 715274 +44675 857542 +446750 1094847 +446750 1297900 +446750 399868 +446750 525466 +446750 696225 +44679 267911 +446821 1055622 +446821 515946 +446905 1161413 +44691 56863 +44691 56864 +44691 63977 +44697 12182 +44697 80576 +447 697674 +447032 341770 +447047 1215200 +447096 538771 +4472 67889 +447253 314884 +447296 327946 +447412 877951 +447444 447443 +447516 106892 +447516 278 +447529 52939 +447529 59225 +447597 1536364 +447597 2906343 +447597 613861 +4476 42380 +447620 291653 +447625 77371 +447625 995574 +44766 2105 +447671 238116 +447671 291688 +447671 305283 +447671 531484 +447671 996474 +447673 149255 +447673 330884 +447673 494407 +44772 24587 +44772 606332 +44772 785708 +447765 308191 +44779 75584 +4478 202105 +4478 234647 +4478 25666 +4478 261590 +4478 2725 +4478 298134 +4478 35848 +4478 4478 +4478 5455 +4478 996 +447905 875309 +447922 107560 +447922 119743 +447922 172363 +447922 207681 +447940 1265566 +447940 1266883 +447940 254400 +447940 266836 +447940 312587 +447940 481548 +447940 531489 +447940 870181 +44795 9197 +447955 363160 +44796 70923 +4480 2541 +4480 306157 +4480 5648 +4480 7870 +448007 1173665 +448007 1337833 +448007 1376703 +448007 406273 +448007 448010 +448008 696225 +448008 833785 +448008 843527 +448009 262940 +448009 448008 +448009 696225 +448009 835518 +448009 838953 +448009 970420 +448009 988713 +448010 1152266 +448010 1326114 +448010 406278 +448010 456926 +448010 502809 +448010 502826 +448010 598601 +448010 703268 +448010 847180 +448040 1121191 +44805 52931 +448063 483352 +448063 801531 +44808 3303173 +448196 155747 +448196 284995 +448196 465992 +448196 677545 +448196 691401 +44820 22387 +4483 60028 +44834 201042 +44834 44834 +44834 970650 +448342 1074970 +44835 201042 +44835 21494 +44835 266383 +44835 44834 +44835 44835 +44844 1178678 +44844 1292259 +448481 382011 +44852 59268 +44853 377296 +44859 113916 +44860 116830 +44860 164363 +44860 389636 +448651 1776113 +44869 168636 +44869 183193 +44870 111 +448792 448790 +4489 30678 +44894 40984 +449 450 +449130 918502 +44914 167108 +44914 589942 +44915 192867 +4492 83001 +449204 1000596 +449289 51360 +449291 10649 +449297 429264 +449297 449298 +449297 593664 +449297 862982 +4493 214023 +4493 31770 +4493 47248 +44939 386923 +449405 388514 +449405 415036 +44944 258118 +44944 29058 +44944 44120 +4495 105173 +4495 1362292 +4495 15626 +4495 225071 +4495 3172 +4495 6722 +44958 100558 +44958 1611895 +449609 475551 +44967 52681 +44969 106467 +449827 1330863 +449827 1917836 +449827 2466083 +449827 2466089 +44983 83826 +449900 125381 +450074 328784 +4501 70877 +45011 1076551 +45011 21147 +450203 282208 +45023 985213 +450244 61081 +450352 450353 +45042 64907 +45044 46281 +45046 19036 +4505 56798 +450505 89630 +450506 290319 +4506 196766 +4506 212376 +450674 1014071 +450686 3446156 +450733 37729 +450733 69621 +45080 328275 +45080 909231 +45090 92281 +45095 181339 +45095 231098 +45095 37910 +45095 63978 +450986 1332524 +450986 209085 +450986 339736 +450986 567934 +450986 74213 +450992 3387957 +45102 301101 +45102 979822 +45107 135930 +45107 145263 +45107 27990 +45114 3178 +45114 8728 +45120 52252 +451219 456909 +45127 10069 +45127 256187 +451329 256190 +451448 1191474 +451534 1274505 +451534 1836744 +451534 646866 +451534 653372 +451534 833687 +451534 845760 +451535 1004365 +451535 459665 +451535 696215 +451535 833697 +451535 837498 +451535 859024 +451666 12828 +451666 3777312 +451666 753872 +45169 10994 +4517 90486 +451731 2791022 +451731 3142738 +451854 645741 +451878 1725180 +45200 109649 +452030 262940 +452097 21201 +452097 216520 +45230 99532 +452391 515338 +452440 232689 +452440 52687 +452440 757837 +452442 188768 +452446 1189174 +45254 184852 +452558 1006301 +452558 41415 +452558 89693 +452714 318829 +452917 458804 +452918 1218161 +452918 538864 +452918 849690 +452918 915651 +452919 452918 +452919 538864 +453026 113504 +45309 48766 +453101 1382560 +45317 134921 +45317 258184 +453251 189621 +45332 1142907 +453414 431952 +453468 1322370 +453480 704613 +4535 15228 +453619 32212 +453664 110089 +453693 553691 +453814 596501 +45382 38897 +453917 1111147 +45392 137940 +45392 193366 +45392 199818 +45392 2093 +45392 228271 +45392 332855 +45392 438610 +45392 45392 +45392 584423 +45392 690277 +45392 91012 +45392 949482 +45397 116879 +453973 329345 +453973 839524 +454004 6390 +45403 26120 +454087 93602 +454257 548698 +45429 11699 +454290 454288 +454293 1028502 +454293 1129949 +454293 1203230 +454293 1220779 +454293 1239190 +454293 1326114 +454293 1353403 +454293 1428466 +454293 1437207 +454293 255709 +454293 262940 +454293 270225 +454293 281992 +454293 283127 +454293 303060 +454293 304968 +454293 333892 +454293 397616 +454293 415720 +454293 448010 +454293 502809 +454293 517158 +454293 522210 +454293 539131 +454293 561054 +454293 575046 +454293 577808 +454293 598601 +454293 653535 +454293 683885 +454293 696165 +454293 696215 +454293 696260 +454293 704150 +454293 833164 +454293 833167 +454293 833168 +454293 833554 +454293 833560 +454293 833626 +454293 833787 +454293 835066 +454293 835735 +454293 838243 +454293 838929 +454293 838930 +454293 839640 +454293 847180 +454293 847489 +454293 851344 +454293 855059 +454293 858577 +454293 859780 +454293 861690 +454293 864672 +454293 867991 +454293 870853 +454293 871278 +454293 908890 +454293 937077 +45432 106559 +454420 939656 +45450 929065 +454639 1145355 +454639 398748 +45467 1280 +45467 178489 +454821 395807 +45484 171707 +454962 3445554 +454979 200819 +454979 455933 +454981 115469 +454981 1192372 +454981 1259101 +454981 1608503 +454981 262940 +454981 3010101 +454981 394778 +454981 835413 +454981 95543 +454992 454993 +455004 1094273 +455004 291446 +455004 8162 +455004 904737 +455008 454167 +455014 17963 +455097 739771 +455099 373377 +455099 459695 +455272 1093579 +455272 624416 +45529 45530 +45529 459 +45530 459 +455379 76573 +4554 7025 +455482 347551 +455482 38733 +455482 5775 +455482 6198 +455482 94995 +455482 95005 +455482 95684 +455497 31752 +4556 225126 +4556 71562 +45566 335273 +455753 41957 +455805 455804 +455839 283127 +455839 425124 +455839 425125 +455839 446105 +455839 508213 +455839 517158 +455839 578737 +455839 696238 +455839 833108 +455839 835518 +455839 854918 +455839 925945 +45587 14988 +45588 230156 +45588 26899 +45588 38469 +455881 285048 +455881 921518 +455886 354194 +455886 455885 +455886 491480 +4559 11357 +4559 406711 +45593 129798 +45593 170111 +45593 209421 +45593 209614 +45593 907220 +45604 1999 +45607 60707 +45607 68297 +456131 1738154 +456211 456210 +456229 2593897 +456258 58170 +45626 298240 +456439 2442622 +456439 377590 +45646 1456077 +45646 18666 +45646 5049 +45646 60742 +45646 84684 +456465 1476306 +456465 3283376 +456465 3552594 +456465 3871857 +456466 907162 +45650 103526 +45650 1222502 +45650 1224221 +45650 12965 +45650 1354039 +45650 137633 +45650 172490 +45650 176866 +45650 194080 +45650 212034 +45650 232824 +45650 247945 +45650 403633 +45650 6662 +45650 9796 +456548 3810 +456548 572736 +456556 16881 +456556 713112 +456610 350933 +45663 505738 +45663 759038 +4567 152707 +456739 456740 +456764 524182 +456764 924191 +456827 582965 +45686 3836164 +45686 393377 +456926 1024263 +456926 1028502 +456926 1030674 +456926 1053431 +456926 1080246 +456926 108565 +456926 1117724 +456926 1152498 +456926 115461 +456926 115469 +456926 1197745 +456926 1199356 +456926 1250112 +456926 1353620 +456926 1354454 +456926 1376703 +456926 153980 +456926 1636229 +456926 1868841 +456926 2578612 +456926 260744 +456926 270225 +456926 2736228 +456926 27519 +456926 276145 +456926 283122 +456926 283127 +456926 299702 +456926 301263 +456926 304968 +456926 3334638 +456926 335045 +456926 342543 +456926 3488542 +456926 361074 +456926 361814 +456926 377139 +456926 388185 +456926 395913 +456926 397616 +456926 406271 +456926 406273 +456926 406285 +456926 410038 +456926 41715 +456926 424576 +456926 432960 +456926 435555 +456926 446471 +456926 448007 +456926 454293 +456926 472036 +456926 490279 +456926 491150 +456926 538644 +456926 539271 +456926 539272 +456926 552196 +456926 558106 +456926 558625 +456926 595478 +456926 626175 +456926 690972 +456926 696168 +456926 704150 +456926 708144 +456926 712500 +456926 736606 +456926 744724 +456926 754974 +456926 759182 +456926 795017 +456926 806436 +456926 809856 +456926 832661 +456926 833128 +456926 833240 +456926 833986 +456926 834577 +456926 835548 +456926 838588 +456926 841355 +456926 842077 +456926 842253 +456926 845768 +456926 846290 +456926 847484 +456926 858371 +456926 858967 +456926 859448 +456926 859780 +456926 882946 +456926 883808 +456926 937077 +456926 940128 +456926 95542 +456926 95543 +456926 96123 +456926 973153 +456926 976044 +456955 266344 +45697 941102 +45697 97378 +456972 18647 +457 526714 +45705 49997 +45707 43276 +45707 60039 +457126 3200289 +457141 1254803 +457141 200819 +457141 410380 +457141 428883 +457141 454979 +457141 456827 +457141 458266 +457141 55104 +457141 598812 +457185 385698 +4572 95623 +45722 18846 +45722 65877 +45727 43965 +457281 459676 +457281 500828 +457281 542505 +457281 573235 +457290 366659 +457331 260733 +457331 357656 +457374 27 +45744 133345 +45744 44391 +45746 17040 +45765 45766 +45768 1670034 +4577 8923 +457708 2756033 +45771 153360 +45771 15803 +45771 215110 +45771 84054 +45771 84055 +457732 1011986 +457732 1031993 +457732 1205065 +457732 1362287 +457732 1406392 +457732 1424606 +457732 1516786 +457732 1516791 +457732 1516797 +457732 1516820 +457732 1718587 +457732 240779 +457732 318052 +457732 880605 +457732 899900 +457864 49112 +457865 457864 +457865 49112 +457961 122418 +457961 233184 +458006 395066 +458008 395066 +458008 458006 +45801 2092459 +45801 558474 +45801 68410 +45802 2512 +458047 268373 +458047 292492 +458054 1211661 +458183 19761 +458194 1837313 +458194 1896225 +458194 2299584 +45825 32101 +458259 3416283 +458266 456827 +458268 4736 +45835 1056488 +45835 184855 +45835 320099 +45835 52687 +458487 636855 +45866 1224223 +45866 12856 +45866 1291624 +45866 2111 +45866 283 +45866 366602 +45866 437507 +45866 45866 +45866 699163 +45866 786645 +45866 880644 +458702 53799 +458730 158185 +45887 131801 +458994 10514 +459 1098916 +459 1108506 +459 1175 +459 1376 +459 14934 +459 1914722 +459 2975488 +459 33599 +459 35317 +459 364819 +459 430816 +459 49518 +459 5099 +459 6314 +4590 28517 +45912 32216 +45912 351006 +45912 44018 +45912 629020 +45912 7278 +459136 1173214 +459136 365914 +459136 673121 +459203 591041 +45924 319482 +45924 54918 +459263 18509 +4593 58906 +4593 70129 +4594 1137101 +4594 234611 +4594 483742 +4594 574551 +459446 270288 +45946 25699 +45950 100029 +459542 27952 +459542 507001 +459572 1093094 +459572 1308430 +459572 18212 +459572 210764 +459572 67597 +45963 81951 +459649 466355 +45966 1309958 +45966 175838 +45966 5210 +459665 446577 +459665 526411 +459665 696215 +459665 833071 +459665 837498 +459673 1005207 +459673 459674 +459673 646857 +459673 826840 +459673 837063 +459673 845359 +459674 696225 +459676 1263534 +459676 459673 +459676 459674 +459676 551147 +459676 573239 +459676 725023 +459676 826840 +459676 833444 +459676 833445 +459676 837545 +459676 859036 +459676 872584 +459676 873546 +459676 932630 +459676 948628 +459693 2974759 +459762 348342 +459762 839164 +459762 91912 +459772 6171 +459776 547971 +459824 1080096 +459824 67992 +45991 45 +459940 580636 +460 127527 +460 283658 +460 3594531 +4600 8098 +460023 265767 +460035 91946 +460056 535617 +460097 902666 +460099 949843 +460115 111646 +460115 216448 +460152 460149 +460176 775065 +46024 285611 +460361 141039 +460361 924137 +460621 108439 +460621 833168 +460621 834578 +460656 964486 +46071 145626 +460826 1134705 +460826 376962 +46097 159657 +46097 393623 +46097 632347 +461241 402364 +461241 7870 +46132 46134 +461370 599276 +461370 96893 +461546 301724 +461546 59288 +461603 5956 +461718 341309 +46176 20212 +461887 515401 +46190 498135 +46190 91273 +46193 78348 +46197 46173 +462173 462174 +462220 144310 +462220 202611 +462220 20691 +462220 22946 +462257 255129 +462257 258118 +462257 274957 +462257 384579 +46235 49931 +462411 547015 +46258 299457 +46258 304880 +46258 47687 +4626 217043 +462603 1260698 +462603 12686 +462603 1374321 +462603 2142756 +462603 230140 +462603 253133 +462603 262940 +462603 283122 +462603 2999551 +462603 3250030 +462603 3250032 +462603 3338724 +462603 368137 +462603 369053 +462603 442174 +462603 454293 +462603 462603 +462603 525469 +462603 532270 +462603 532273 +462603 532276 +462603 538821 +462603 55683 +462603 59756 +462603 696192 +462603 696260 +462603 754974 +462603 795171 +462603 833163 +462603 833164 +462603 833827 +462603 835518 +462603 837527 +462603 837534 +462603 841590 +462603 841593 +462603 842132 +462603 842223 +462603 847489 +462603 84839 +462603 850899 +462603 850908 +462603 851310 +462603 855061 +462603 855066 +462603 855072 +462603 862697 +462603 888414 +462603 900979 +462603 926979 +462603 937077 +462603 960757 +46277 113453 +4628 2187 +4628 47781 +4628 6151 +46280 10677 +46280 4967 +462816 228928 +46282 149094 +46282 46283 +46284 157538 +4629 38222 +462949 62919 +463111 733 +463122 215369 +463191 327803 +463191 463193 +463220 1216325 +463220 2954460 +463275 23657 +463275 52504 +463275 808629 +4633 1545927 +4633 4493 +463339 129822 +463414 431254 +463558 236725 +463633 146420 +463633 153626 +463647 2116 +46373 264096 +4638 32922 +46383 272178 +463854 325816 +464024 464023 +46406 54475 +46411 980145 +464142 673022 +464143 464142 +464143 673022 +464214 464215 +464214 833639 +464215 833639 +464274 90210 +464302 464303 +464334 940066 +464336 464334 +464336 464337 +464336 464338 +464336 940066 +464337 464334 +464337 940066 +464338 464334 +464338 464337 +464338 940066 +464486 966650 +46451 1568203 +46466 120960 +46467 1128549 +46467 1852669 +46467 27733 +46467 30428 +46467 36738 +46467 46466 +46467 7028 +46467 79732 +46467 89902 +464681 60316 +464759 464758 +46478 199228 +46478 4937 +46481 256190 +465022 18839 +465052 43128 +465053 1112839 +4651 12751 +465126 1296498 +465126 237409 +465126 968300 +4653 1781 +4653 28164 +4653 91844 +465350 465348 +4654 218951 +4654 22061 +4654 37601 +4654 39727 +4654 49294 +4654 50570 +465584 1425956 +465584 29895 +465585 229259 +465585 688403 +4656 207744 +4656 2655 +465608 269081 +46566 11004 +46566 236625 +465820 29546 +465843 126996 +465856 1652159 +465856 393748 +465865 11136 +465869 70429 +465884 1089590 +465937 366267 +465982 192325 +465982 368137 +465982 406281 +465982 454293 +465982 835066 +465983 1004477 +465983 1032240 +465983 1051393 +465983 1058170 +465983 1092564 +465983 1092565 +465983 1204589 +465983 1206836 +465983 1245808 +465983 1250175 +465983 1325919 +465983 1861594 +465983 1990133 +465983 2042826 +465983 212299 +465983 2553659 +465983 260744 +465983 262940 +465983 2666389 +465983 267134 +465983 2675346 +465983 27519 +465983 282639 +465983 282644 +465983 283122 +465983 289522 +465983 294480 +465983 294746 +465983 310038 +465983 368137 +465983 380036 +465983 394791 +465983 397620 +465983 415725 +465983 425125 +465983 435555 +465983 454293 +465983 465982 +465983 490279 +465983 490290 +465983 497542 +465983 506006 +465983 538646 +465983 538821 +465983 547971 +465983 561054 +465983 604396 +465983 617133 +465983 627442 +465983 653535 +465983 662168 +465983 688034 +465983 732482 +465983 754128 +465983 754974 +465983 762703 +465983 775366 +465983 832915 +465983 832924 +465983 834229 +465983 834378 +465983 834523 +465983 835090 +465983 842233 +465983 842888 +465983 848066 +465983 851590 +465983 859448 +465983 861489 +465983 864674 +465983 867995 +465983 870941 +465983 899356 +465983 899625 +465983 919539 +465983 92243 +465983 933743 +465983 95539 +465983 987862 +465992 229224 +465992 751051 +466006 99026 +466022 979330 +46616 9554 +466231 578197 +4663 841490 +466390 2862019 +466597 37722 +466633 233897 +466636 210409 +466636 762182 +46666 2096 +466683 1384909 +466695 1056393 +466701 841370 +46674 56447 +46683 151 +466872 754311 +466976 1167693 +466976 432782 +46707 265198 +46707 3865 +467259 451878 +467287 280935 +467287 547 +467287 865732 +46740 35361 +46740 411631 +467427 1410444 +467427 438214 +46752 259802 +467546 402609 +467546 582244 +467546 677706 +46764 169950 +46768 28953 +46768 42757 +46768 878223 +467721 1227320 +467721 20977 +467735 539346 +467741 287135 +467741 461570 +467804 192609 +468083 823311 +468101 2710148 +468148 168523 +46829 79940 +468451 911150 +468451 945332 +468478 468479 +468478 566488 +46852 67257 +468570 612755 +468587 218797 +468611 1051 +4687 35445 +468710 285904 +468710 528726 +468931 512078 +468986 58906 +469019 469018 +469050 770748 +46909 413398 +46912 4179 +46926 141714 +46926 343427 +46926 36018 +469332 547719 +469332 583016 +469559 1015876 +469559 1617254 +469559 17080 +469559 1828463 +469559 370680 +46959 50619 +469688 125349 +469689 1535924 +470163 10355 +47023 1477075 +470260 1099152 +470260 212000 +470260 339755 +470264 212299 +4703 146371 +4703 4693 +470372 472401 +470450 134797 +470450 247759 +470595 986593 +470619 1910341 +470619 756117 +47074 282228 +470838 453253 +47088 619356 +47091 17125 +47091 361359 +47093 134804 +470931 1999264 +470931 397616 +470931 869694 +470931 899898 +47101 271923 +471033 498653 +471033 793027 +471091 361293 +471201 162564 +471201 1841563 +471201 529726 +471201 716139 +471201 882764 +471201 882811 +471201 882822 +471236 297828 +47126 137827 +471342 165816 +47139 2583 +471456 45802 +47146 25955 +471567 1879468 +4716 645 +47161 27307 +47161 81126 +471665 175984 +4717 50334 +471791 2575620 +471821 105246 +47188 488943 +4719 1000 +4719 182841 +4719 31204 +4719 3352 +4719 4718 +4719 4809 +4719 5470 +4719 801 +4719 8462 +4719 85907 +4719 9708 +47195 1061207 +472 5030 +472036 294746 +472036 834378 +472036 999914 +472073 29362 +47214 35910 +4722 14954 +4722 38047 +4722 62947 +4722 97135 +472213 617370 +47231 29933 +472366 1343737 +472391 277716 +47246 168432 +472460 342668 +472460 8729 +472488 472489 +4725 21747 +4725 462326 +472514 40880 +472588 130589 +472611 253245 +472649 2501973 +47265 8096 +4727 3338 +4727 388 +4727 65740 +47283 35086 +472936 1841441 +472936 1954767 +472959 392360 +47296 39812 +473 3038044 +473 32388 +473003 109475 +473003 137149 +473005 473004 +473069 114271 +47309 70571 +473097 10472 +473207 499946 +47333 76045 +473330 1153375 +473330 183741 +473330 247945 +473330 36174 +473330 394627 +473330 407305 +473330 505029 +473330 653899 +473330 987256 +47336 1164311 +47336 168909 +47336 211096 +47336 758702 +4734 9808 +47343 442337 +47343 95685 +47349 134475 +47349 31215 +473562 2796800 +4736 119663 +4736 29074 +4736 985506 +473693 17590 +4738 13030 +4738 17364 +4738 17373 +4738 2376385 +4738 57526 +473837 1022025 +473837 299702 +473842 270577 +473912 806469 +474186 166208 +474194 1244962 +474194 474183 +4742 108571 +4742 18748 +4742 316430 +4742 325 +4742 4742 +4742 6151 +4742 6919 +4742 7899 +474319 615924 +47433 82994 +474340 2254189 +47436 180461 +47438 25869 +474399 334153 +47442 115863 +47442 1182855 +47446 31288 +474478 384539 +47458 62209 +474643 2114 +474643 2116 +474643 213991 +47470 1538 +47470 21747 +47470 3049 +47470 8260 +47471 46959 +474884 1562169 +474884 227842 +474884 229194 +474884 693015 +474884 891105 +474994 349923 +474994 442919 +474994 442922 +474994 446098 +475000 1028028 +475044 460582 +4751 4769 +47512 110593 +47512 144910 +47512 182854 +47512 2422119 +47512 280866 +47512 418174 +47512 626377 +47513 13344 +475160 4725 +475449 840958 +475563 543206 +47558 27 +475582 2410562 +475613 563095 +475677 57886 +475678 475677 +475678 57886 +47572 119007 +47572 245778 +47578 47573 +475782 430103 +47579 12890 +47579 216597 +47579 3550 +47579 75589 +475810 764646 +47592 92000 +47594 183732 +47594 574226 +47594 66757 +476096 369576 +476207 478750 +476221 1424 +476229 1040531 +47623 18404 +476356 354974 +476379 2651274 +476414 186449 +476414 186837 +47660 1769751 +476640 112117 +476640 476641 +476641 112117 +476950 15251 +476976 478473 +47711 176793 +477118 471304 +47714 15203 +47714 160797 +47714 17446 +47714 181040 +47714 20226 +47714 38806 +47714 39143 +47714 74631 +47714 961150 +47715 1647092 +477361 896676 +477400 726063 +477401 1616620 +477401 489950 +477401 670983 +477401 704936 +47742 1557003 +47742 15875 +47742 18956 +47742 18984 +47742 284321 +47742 385189 +47742 414643 +47742 462603 +47742 50581 +47742 64664 +47742 7702 +47742 86094 +47742 874619 +47747 130987 +47747 92187 +47752 103394 +47752 45847 +477562 192065 +477562 930951 +4777 21849 +4777 328376 +4778 108856 +4778 151199 +4778 5648 +4778 97684 +47780 47784 +47781 130180 +47781 1807214 +47781 47781 +477822 619423 +4779 26592 +4779 91534 +47792 509363 +47792 568394 +47796 1149515 +47796 47174 +4780 4781 +4780 6151 +478047 509664 +478052 394804 +47806 30880 +4781 714752 +478284 545359 +478284 822208 +4783 431777 +4783 68069 +478417 1163110 +478425 478424 +478427 963610 +478535 280181 +478535 444623 +478535 532800 +47864 708946 +478663 1139157 +4788 1087230 +478866 1152610 +478988 56072 +479031 102648 +479033 283469 +479033 406271 +479033 479036 +479033 696257 +479033 712500 +479033 842238 +479036 1022480 +479036 108439 +479036 224329 +479036 841660 +479037 1057453 +479037 1092492 +479037 1330554 +479037 1471860 +479037 1591238 +479037 1660701 +479037 239236 +479037 260744 +479037 261451 +479037 27519 +479037 283122 +479037 283125 +479037 283127 +479037 299702 +479037 301263 +479037 3488542 +479037 388185 +479037 394791 +479037 395913 +479037 397620 +479037 406281 +479037 415720 +479037 424576 +479037 451535 +479037 454293 +479037 479033 +479037 479036 +479037 502826 +479037 517144 +479037 517158 +479037 517165 +479037 522209 +479037 526592 +479037 595051 +479037 604396 +479037 653372 +479037 663504 +479037 688716 +479037 696165 +479037 704150 +479037 754894 +479037 754974 +479037 784121 +479037 809856 +479037 823061 +479037 832700 +479037 832917 +479037 832926 +479037 832989 +479037 833686 +479037 836125 +479037 838190 +479037 839640 +479037 842238 +479037 842888 +479037 865657 +479037 883315 +479037 912385 +479037 940128 +479037 978211 +4792 75755 +479276 97384 +479319 40583 +47941 13794 +47952 24222 +47952 384019 +47952 637432 +47957 195444 +47957 365192 +479598 493102 +47963 32439 +47982 135731 +47982 18585 +47982 97455 +479851 479852 +479865 966521 +47993 11745 +47998 165646 +47998 17027 +47998 248861 +47998 32635 +47998 6919 +47998 8528 +48020 354049 +4803 209134 +48031 116656 +48031 35486 +480310 867456 +480401 559237 +480425 1651820 +480425 2220068 +48056 986164 +48057 14954 +48077 274516 +48077 74866 +480783 433615 +480804 424108 +480864 417333 +4810 74752 +48110 592968 +481295 1219993 +481299 279398 +4813 407736 +481402 474438 +481481 173497 +48152 109437 +48152 200612 +48153 1618722 +481548 1265566 +481548 1266883 +481548 254400 +481548 312587 +481548 870181 +481601 2540008 +48163 475677 +48163 475678 +48163 485563 +481630 1622797 +481630 2025747 +481682 449392 +481766 481767 +481890 196811 +48195 112916 +48195 308134 +481950 14975 +481950 352613 +48211 334223 +482173 14975 +482173 352613 +482173 481950 +482193 2230881 +482193 874551 +4825 58654 +482566 482558 +482583 1156888 +482585 128119 +482585 291743 +4826 115011 +482638 737607 +48270 17392 +48270 769863 +48270 89676 +48275 246639 +48275 863372 +48284 44138 +482922 68225 +482954 1033055 +4830 1363922 +4830 29855 +4831 214114 +4831 3018998 +4831 90154 +483112 59123 +483352 1361557 +483384 189231 +4834 93580 +483450 754105 +48347 202796 +48351 45120 +48354 21128 +48354 5682 +483697 798282 +48370 835555 +483757 478423 +483765 224822 +48385 36147 +483878 483881 +483878 856233 +483881 856233 +4839 41239 +4839 47603 +48390 49719 +483916 63758 +48392 166630 +483952 626826 +484 51675 +484020 1711057 +484020 530687 +484020 758256 +48417 2503240 +48417 638302 +484204 484205 +48425 29923 +48431 12596 +48431 621904 +48432 76115 +4844 255257 +4844 39243 +4844 3981 +48441 466760 +484422 1035947 +48443 18428 +4845 218172 +4845 3401076 +4845 961 +484739 582500 +48475 18187 +48477 29316 +4848 772340 +484860 125927 +4850 2108756 +485047 485047 +485047 734860 +485047 751939 +485059 21525 +48508 67664 +48511 4013 +48511 5410 +48512 500475 +485142 568472 +485160 1428523 +485177 7537 +48536 354112 +48538 173302 +485384 1009890 +485404 446123 +485445 270438 +485445 485445 +485563 475677 +485563 475678 +485623 111545 +48564 103339 +48564 237412 +4857 119661 +4857 130180 +4857 226459 +485701 485699 +48573 119425 +48573 24272 +48573 63938 +48574 158261 +485781 925799 +485782 485783 +485782 678716 +485782 965528 +485783 678716 +485783 965528 +4858 21474 +48582 3480 +48582 40813 +485932 267849 +485952 199591 +485963 428437 +4860 233382 +4860 95898 +486033 84101 +48604 137603 +48604 247176 +48611 384278 +486137 948478 +486258 1030008 +486318 1036767 +48637 12516 +48639 222528 +48644 109137 +48644 802368 +4865 106959 +4865 19441 +4865 60921 +4865 866 +4865 91938 +48650 65636 +486522 486523 +486522 69493 +486523 69493 +486633 997 +48667 48666 +48671 690258 +486745 2265524 +48675 31009 +48675 36563 +48675 391577 +48675 5592 +48675 56016 +486820 510296 +48686 3288 +486966 1259282 +486992 262485 +486992 302385 +487 6736 +487025 487025 +487029 120307 +4872 856 +487204 492031 +487219 252264 +487219 297037 +487219 35328 +48729 38787 +487291 596407 +487291 699160 +48734 23406 +487461 1374993 +48755 76576 +487559 546614 +487727 1784780 +487822 18088 +487822 219322 +487822 222523 +487822 34001 +487822 373101 +487822 433626 +487822 487822 +487822 697461 +487822 777554 +48786 102784 +487983 2862152 +488 14954 +488 28209 +488 8456 +488128 1603658 +488150 115134 +48816 1409988 +48816 167108 +4882 385004 +4882 40516 +4882 59618 +488209 106101 +488362 269254 +488362 334081 +488362 406271 +488362 406285 +488362 833317 +488362 833579 +488362 855061 +488363 1025834 +488363 1341604 +488363 1430196 +488363 1450542 +488363 1478674 +488363 1478675 +488363 1478676 +488363 2207653 +488363 2212800 +488363 253133 +488363 269254 +488363 270225 +488363 290601 +488363 375279 +488363 441528 +488363 442174 +488363 525469 +488363 577808 +488363 665298 +488363 696220 +488363 703539 +488363 767642 +488363 833554 +488363 841590 +488363 841593 +488363 851310 +488363 896995 +488363 900979 +488426 778608 +4885 223225 +488518 693436 +488584 579373 +48863 41266 +48865 111555 +48865 41725 +48875 1830062 +488818 855988 +488892 293529 +488944 488943 +489085 280623 +489085 489086 +489085 532254 +489086 280623 +489086 532254 +489112 180270 +489112 446471 +489112 822473 +489256 273808 +489295 84588 +4894 2744 +48948 41696 +489510 489513 +489590 1223005 +489590 224990 +489694 1599906 +489698 489697 +489808 14961 +489808 18293 +489812 400352 +48996 273071 +489994 920619 +4900 31501 +490007 1240371 +490007 577022 +490007 594278 +490007 623974 +490027 165937 +49009 151751 +49009 30470 +490102 272706 +490139 369206 +490139 490140 +490140 369206 +490217 416225 +490247 1106271 +490279 1030674 +490279 490290 +490279 551084 +490279 900110 +490281 1042460 +490290 1409738 +490290 1802107 +490290 1951772 +490290 1951773 +490290 1982778 +490290 260744 +490290 862699 +490290 900807 +490290 934732 +49030 2583 +490353 18005 +490442 1678010 +490442 3099045 +490460 139091 +490460 343069 +490460 681727 +49054 9457 +49074 40065 +490777 1259101 +490777 1337833 +490777 1428466 +490777 1689419 +490777 192325 +490777 260744 +490777 27519 +490777 283122 +490777 395913 +490777 406278 +490777 448007 +490777 454293 +490777 490281 +490777 526593 +490777 526595 +490777 526596 +490777 532086 +490777 627442 +490777 696169 +490777 703271 +490777 704150 +490777 809856 +490777 835964 +490777 899565 +490777 910130 +490777 913209 +490777 999914 +4908 333 +49085 46220 +490861 104636 +490945 504689 +490975 263989 +491005 1236304 +491036 1459999 +491088 89322 +491098 125318 +491150 283127 +491150 41715 +491150 538644 +491150 558106 +491150 754974 +491152 784858 +491165 386636 +491199 534926 +49120 1509797 +49120 191870 +49120 209657 +49120 246910 +49120 366791 +49120 49121 +491273 491274 +491273 491275 +491275 491274 +491294 826830 +491294 837551 +491321 152564 +491364 2176470 +49137 27579 +49142 529498 +49145 97633 +491502 1221527 +491502 755281 +491529 425028 +49155 11333 +49155 20104 +49155 229663 +49155 36378 +49155 563086 +49155 68702 +491558 64385 +49160 355105 +491650 491649 +491674 29777 +491701 3577866 +491972 758198 +492043 262927 +492043 271565 +492098 535371 +492173 339277 +492232 370290 +492232 638654 +492245 95537 +492431 93808 +49244 107084 +49244 70622 +492553 1343438 +492554 29810 +492681 3196177 +492681 3783 +492716 2682191 +492720 201047 +492747 1089769 +492747 948091 +492859 335706 +492930 1823420 +492930 3580866 +492982 353321 +493012 668029 +493012 748468 +493070 2286631 +49309 49311 +49311 220984 +49311 49312 +49312 162056 +49312 39505 +49312 80228 +493153 493152 +49323 122524 +49323 16409 +49323 209657 +49323 21988 +49323 2352 +49323 5826 +49323 58373 +493292 1381332 +493292 1416281 +49342 454630 +493464 441322 +493515 14678 +49353 33977 +493551 1415408 +493607 133860 +493608 17531 +493609 292589 +493644 1937665 +493644 1959267 +493667 1520656 +4937 1003471 +4937 135788 +4937 149278 +4937 1499605 +4937 1600815 +4937 28308 +4937 44421 +4937 658480 +4937 759038 +4937 769995 +49376 101667 +49376 69501 +493793 2155036 +493793 2155038 +49385 202355 +493854 403019 +493880 1085577 +49397 37238 +4940 707436 +494065 426448 +494117 77025 +494167 238116 +494167 447671 +494241 767319 +49436 144544 +494377 268290 +49438 766950 +494416 410387 +494416 579188 +49443 49444 +494513 761677 +494609 236140 +494669 504753 +49470 17870 +494714 903050 +4948 12856 +4948 1333372 +4948 155537 +4948 1831755 +4948 19144 +4948 22975 +4948 233910 +4948 247945 +4948 2643711 +4948 2857 +4948 29112 +4948 344215 +4948 365527 +4948 372109 +4948 4948 +4948 516516 +4948 553093 +4948 62886 +4948 654531 +4948 9820 +49491 15889 +49491 30031 +49491 434163 +49491 5575 +494965 384085 +494968 183977 +494994 190370 +494995 44117 +494995 870178 +495001 1337940 +495001 413164 +495004 454293 +495004 833169 +495004 833560 +495010 1047947 +495010 1092492 +495010 451534 +495010 456211 +495010 653372 +495010 833687 +495019 312599 +49502 138994 +495163 565854 +4952 10628 +4952 380280 +49529 40583 +495311 726057 +4954 2017 +4954 2081 +4954 26923 +4954 2823 +4954 4954 +495471 174688 +49549 2332 +495517 453144 +495517 952284 +49571 17140 +49571 17531 +495728 1267794 +495728 135657 +495728 245301 +495728 456556 +495728 851402 +495841 854235 +495855 893542 +49594 13548 +49594 202554 +49594 220196 +496031 770458 +496069 720775 +496086 113599 +49609 53259 +49624 10643 +49624 11012 +49624 180585 +496265 496264 +49633 386549 +49633 482591 +496373 594978 +49638 11084 +49638 1307387 +49639 29855 +49643 49643 +49644 29855 +49644 49639 +496460 47780 +496703 490279 +496703 551084 +49673 873954 +496777 496776 +496778 1529190 +496778 1874550 +496778 250870 +496778 817743 +496783 148123 +4968 15865 +4968 32659 +496818 1227329 +49688 71294 +4969 462816 +4970 17802 +4970 17803 +497008 1050296 +497008 425125 +497008 446105 +497008 455839 +497008 854918 +497036 508219 +49706 49707 +497115 157538 +497115 46284 +4975 91777 +497522 936486 +497542 1030674 +497542 1097804 +497542 1226748 +497542 1261428 +497542 1337833 +497542 1356610 +497542 1368030 +497542 1409738 +497542 1465204 +497542 1680148 +497542 1687982 +497542 1724072 +497542 1831675 +497542 192322 +497542 1974493 +497542 2661126 +497542 2736228 +497542 296409 +497542 318371 +497542 319439 +497542 349296 +497542 361807 +497542 415725 +497542 424150 +497542 424576 +497542 443257 +497542 443259 +497542 448007 +497542 454293 +497542 455839 +497542 490279 +497542 495004 +497542 527161 +497542 538821 +497542 578737 +497542 599488 +497542 649000 +497542 700443 +497542 703271 +497542 704150 +497542 744724 +497542 832962 +497542 833014 +497542 833097 +497542 833168 +497542 833169 +497542 833560 +497542 833903 +497542 835518 +497542 835735 +497542 838409 +497542 838983 +497542 838984 +497542 839696 +497542 846295 +497542 857659 +497542 857661 +497542 858380 +497542 860230 +497542 864672 +497542 865661 +497542 877520 +497542 877524 +497542 877777 +497542 877779 +497542 895152 +497542 895780 +497542 912317 +497542 938083 +497542 944143 +497542 945174 +497542 998654 +497542 999914 +49759 259154 +49759 312163 +49770 12337 +497721 47594 +497721 574226 +497722 782666 +49776 639352 +497761 324 +497778 329288 +4978 3133 +497902 780745 +49794 1076617 +497986 57698 +4980 239959 +4980 275045 +49803 1128804 +49803 31306 +49803 378086 +49803 455379 +49803 57640 +49803 619884 +49803 76573 +498173 29895 +498173 91898 +4982 2202 +498274 28568 +498274 498275 +498275 28568 +498341 498343 +498364 1137451 +498371 179144 +498371 238473 +49838 244722 +49838 529832 +4984 185492 +49845 27963 +498538 1076139 +498569 27952 +49857 137090 +498600 311696 +498743 1319672 +498745 175760 +498793 646231 +49884 42124 +49884 63338 +498866 96345 +4989 532896 +4989 864796 +498928 6170 +498965 935117 +499 2256 +49908 170358 +49908 241825 +499176 49719 +499176 982819 +49918 716488 +499212 788355 +499257 620830 +499306 1894941 +499306 1894943 +499306 596407 +499306 637603 +499382 168925 +499382 2532196 +499382 3737202 +499382 54787 +49948 14987 +499563 1055630 +499563 1133130 +499563 1202945 +499563 1798623 +499563 526416 +499563 725023 +499563 836125 +499563 837533 +499563 851414 +499563 883315 +499563 978211 +499563 988905 +499716 196189 +49976 42980 +499764 999378 +499766 2967 +499803 476221 +499861 424754 +49988 682634 +499926 499803 +499976 2814801 +499976 598066 +5 1617 +5 266516 +5 4 +5 42584 +5 5208 +50 1386 +50 675 +50 84692 +50 9468 +50003 156533 +50003 335370 +50003 355659 +50003 44852 +500190 31044 +500206 1015812 +500231 1135228 +500231 649585 +500231 834088 +500231 835650 +500231 845155 +500231 845160 +500253 1348329 +5004 25650 +500413 454979 +500413 905983 +500506 391970 +5006 2597161 +500606 239367 +50061 1224084 +50061 740444 +50061 935914 +500717 300597 +500717 745064 +500736 497778 +500769 1642512 +50077 112428 +50077 88124 +50077 963456 +50077 97542 +50079 50079 +500897 285904 +500897 79253 +50101 10293 +501041 39833 +501111 370771 +501112 3273144 +501147 567866 +501166 231968 +501168 225559 +50137 229097 +501468 19893 +501471 501472 +501531 386934 +501531 616469 +501531 616483 +501552 2524962 +50159 51341 +501615 340341 +501788 308119 +501998 608657 +50200 1065010 +50200 175184 +50200 198545 +50200 229665 +50200 331219 +50200 982496 +502040 1281756 +502047 676272 +502047 946752 +502160 547721 +50217 709332 +50227 49148 +502381 214871 +502544 7971 +502591 502590 +50263 3850033 +502809 1284573 +502809 456926 +502809 573239 +502809 575045 +502809 641164 +502809 833842 +502809 844416 +502809 844418 +502809 844421 +502809 855761 +502814 207945 +502814 212299 +502814 262358 +502814 2662538 +502814 327587 +502814 400266 +502814 645741 +502814 826720 +502814 833079 +502814 848066 +502814 909598 +502814 92243 +502814 966368 +502819 154287 +502819 403638 +502823 1066081 +502823 212299 +502823 604631 +502823 880725 +502825 115461 +502825 262358 +502825 514541 +502825 604396 +502825 842888 +502825 857108 +502826 394791 +50288 131153 +50301 71988 +503075 1258970 +503075 2176041 +503075 371804 +503097 1113219 +503126 176185 +50327 69237 +503334 375968 +503340 447940 +503351 1743970 +503383 37085 +503390 103455 +503390 253032 +503390 255774 +503409 500828 +503475 269093 +503614 22061 +503619 44126 +503688 220598 +50371 48573 +503824 1084863 +503824 592264 +50384 315159 +504 498 +504036 1422384 +50406 19733 +504146 250698 +504147 101597 +504147 1734585 +504147 319462 +504173 118654 +504263 1014584 +504263 1072839 +504263 109458 +504263 1454754 +504263 291339 +504263 396939 +504263 86472 +504389 106015 +504418 562072 +504537 73815 +5047 37309 +50473 51157 +504754 92750 +5048 3241037 +5049 1456077 +5049 60742 +5049 84684 +504904 462370 +504918 176601 +505029 653899 +505061 491362 +50513 112738 +50513 132084 +50513 2044778 +50513 2807479 +50513 38661 +50513 4970 +50513 62571 +50513 79578 +50514 13873 +50514 172841 +50514 21921 +50514 223614 +50514 251536 +50514 25654 +50514 29058 +50514 363277 +50514 46333 +50514 48423 +50514 59736 +50514 7708 +50514 89970 +50514 89972 +50514 93616 +50514 93780 +505228 540767 +50528 96440 +505452 262940 +505454 1443468 +505454 1909768 +505456 788254 +505481 538924 +505558 457 +505558 526714 +50561 50562 +505639 114493 +505651 255665 +505652 577207 +50568 246975 +505736 475551 +505738 900526 +50576 50722 +50577 187602 +50577 53438 +50581 67039 +505900 507908 +505937 230047 +505937 834354 +50595 62919 +505963 1136577 +505963 626185 +506006 645741 +506008 451854 +506008 645741 +50601 10780 +50601 157165 +50601 610955 +506051 29039 +506051 460054 +506051 778281 +50613 8090 +506130 2380459 +506130 2380461 +506130 2674177 +506145 1337043 +506145 283122 +506145 454293 +506166 349615 +50625 578647 +5063 142 +5064 195106 +5064 25872 +5064 485047 +5064 7870 +5064 82211 +506494 2665678 +506546 3241037 +506546 351396 +506546 5048 +506546 744920 +50662 218950 +506668 506666 +506674 1790030 +50669 217 +50677 223696 +5068 124039 +5068 1737 +5068 2872428 +5068 2872429 +5068 4382 +50681 502386 +506915 420879 +506917 550011 +506928 1207008 +506931 1207008 +506931 506928 +507001 1272169 +507001 27952 +507001 555263 +507001 579635 +507008 27952 +50706 198518 +507127 255439 +507127 918806 +507184 2302343 +50722 28044 +507299 1470145 +5073 15780 +5073 8899 +507353 109247 +507353 12516 +507353 306979 +507416 507415 +507607 217519 +507610 1052201 +507610 1052202 +50764 4563 +507649 304885 +5077 28468 +5077 9387 +507784 149278 +507784 507785 +507784 652149 +508 136580 +508034 424754 +508098 12751 +508098 1830210 +508098 225076 +508098 509643 +508131 164571 +508131 255801 +508131 439536 +508131 665970 +508131 79742 +508213 479037 +508213 578737 +50829 76373 +50838 327165 +5084 79 +508472 3458283 +508472 721351 +50855 2707 +50855 2735 +5087 119483 +5087 1301538 +5087 30285 +5087 3918 +5087 548 +5087 96221 +50872 1905 +50875 400186 +508757 347268 +508798 310705 +508798 915929 +508798 982947 +50887 30212 +50887 88196 +50888 152721 +50888 380352 +50901 50902 +509025 448487 +50911 6170 +50913 120011 +50915 163861 +509192 335370 +509192 497926 +509288 10898 +509288 657474 +509288 78659 +509294 2065589 +509299 90203 +5094 3384 +50940 28091 +50948 33430 +509534 1037360 +509534 217455 +509534 543584 +509595 604144 +50963 1004729 +50963 207946 +50963 208864 +50963 304114 +50963 639510 +50963 77703 +509697 1390230 +509697 1502806 +509697 1531921 +509697 2265141 +509697 509697 +509697 654531 +50970 50971 +50972 140313 +50972 505545 +509739 1068717 +509739 308882 +509739 797106 +509739 92834 +50975 124760 +50978 40036 +5099 10980 +5099 16539 +5099 1795 +5099 69328 +509956 235254 +50997 191616 +50997 209748 +510013 269254 +510013 836588 +51007 796452 +51016 148146 +5102 58330 +5102 65120 +51039 12640 +51039 137779 +51039 241825 +51039 276380 +51039 285220 +51039 49908 +51039 69003 +51039 72950 +51039 9902 +5104 39020 +510409 37233 +510458 1641081 +51051 1407121 +510545 232104 +51064 51065 +51065 191373 +51065 33852 +5107 84675 +510713 1247 +51073 51065 +510901 89525 +511038 510492 +51106 153407 +51106 158787 +51106 42124 +511091 511087 +511116 55358 +511116 953230 +51117 2699324 +511193 292898 +511193 294222 +51122 23102 +511220 1990982 +51123 46601 +511347 207866 +51137 5355 +5114 129737 +5114 1360061 +5114 2730 +5114 37724 +5114 37749 +5114 661 +511471 511476 +511496 1848549 +51158 86301 +51158 98207 +511581 511937 +5116 11136 +5116 787205 +511610 1059752 +511610 179056 +511610 351805 +511610 511613 +511613 1059752 +511613 179056 +51168 203979 +51171 1510397 +511729 2540743 +511838 1865704 +511851 25406 +511862 28295 +51192 549554 +51196 182600 +512 7331 +5121 22960 +512167 202258 +512167 236035 +512167 415655 +51219 35650 +5122 105151 +51223 31013 +512259 496920 +512404 41232 +512404 413618 +512461 563672 +51247 98000 +5125 181359 +512540 512538 +512585 397953 +51262 57619 +51265 28521 +51271 113470 +51271 54813 +51271 61398 +51271 67039 +512743 441605 +512743 62839 +512764 314742 +512818 363211 +512861 856032 +5129 16832 +51290 120896 +512999 430773 +513023 1015392 +513175 212187 +513210 1458518 +513237 153980 +51324 31526 +51336 194372 +51352 1635332 +51352 26245 +51352 35135 +513617 2155 +513617 45529 +513617 45530 +513617 459 +51368 18324 +51368 98498 +513680 394146 +51369 11213 +51369 1783757 +5137 846 +5137 85707 +51371 50577 +51371 697233 +51371 84309 +513748 652190 +51377 63790 +5138 21474 +51393 263667 +5140 111907 +5140 1538794 +5140 218836 +5140 612 +514024 349282 +514024 364512 +514024 384818 +51406 224994 +51406 224995 +514096 88916 +514136 298704 +514269 1089748 +514269 1326421 +514269 1583001 +514269 1959267 +514269 2271375 +514269 2332203 +514269 3235936 +514269 3278967 +514269 630262 +514269 630265 +514314 2606113 +514541 115461 +514558 522681 +514558 795854 +514801 276671 +51485 1048795 +514936 1464371 +514936 287929 +514971 8119 +515 607 +515 617 +5151 105087 +51526 201544 +515285 200665 +515285 509129 +515289 195811 +51545 111646 +51545 347642 +51545 505715 +515538 340677 +51556 17228 +51556 19332 +51562 251414 +51564 11804 +51564 40672 +51564 952284 +51567 1602956 +51567 2428251 +51567 2986085 +51567 3461453 +51567 764475 +515702 62538 +515769 310212 +515879 108566 +515879 341147 +515879 842265 +515879 872577 +515879 963376 +5159 63239 +5160 11625 +5160 134254 +5160 145229 +5160 231919 +5160 29199 +516037 699999 +516047 1376367 +516080 1793781 +516129 1111147 +516129 453917 +516159 1495753 +516187 681506 +516289 575499 +51629 754 +5164 194 +5164 40679 +5164 44290 +5164 841920 +5164 8693 +516421 707834 +516438 1371065 +516438 1998633 +516438 20956 +516438 271154 +516438 327034 +516438 582273 +516438 794883 +516507 340211 +516516 19144 +516516 365527 +516516 553093 +51653 1408569 +516681 1783360 +51669 193258 +516755 763081 +516806 153980 +516806 270225 +51686 194 +516979 516589 +51698 228928 +517042 1027180 +517042 1057111 +517042 1318493 +517042 1628349 +517042 691885 +517042 823465 +517042 833073 +517042 833549 +517042 833787 +517042 855889 +517042 867607 +517144 115461 +517144 216140 +517144 268272 +517144 27519 +517144 304975 +517144 333892 +517144 547971 +517144 809856 +517144 855065 +517144 95546 +517145 216140 +517145 95544 +517145 96123 +517153 283122 +517153 552195 +517153 573239 +517153 696225 +517153 833687 +517153 834641 +517153 861489 +517153 882032 +517153 883315 +517153 901880 +517153 931425 +517153 95544 +517158 1325918 +517158 1933252 +517158 451535 +517158 459665 +517158 620726 +517158 696192 +517158 696215 +517158 837498 +517160 108568 +517160 229566 +517160 299702 +517160 342543 +517160 3518409 +517160 374777 +517160 375279 +517160 381298 +517160 517144 +517160 617133 +517160 765352 +517160 859452 +517160 95537 +517160 95542 +517160 95544 +517160 95546 +517163 1061521 +517163 1135199 +517163 1155411 +517163 1422857 +517163 206281 +517163 207945 +517163 406278 +517163 446471 +517163 448010 +517163 454293 +517163 630844 +517163 696225 +517163 703268 +517163 704150 +517163 736606 +517163 754894 +517163 832917 +517163 834396 +517163 835518 +517163 862155 +517163 862158 +517163 867946 +517163 869570 +517163 871278 +517163 895582 +517163 95546 +517165 1141795 +517165 2401903 +517165 454293 +517165 534822 +517165 620726 +517165 623293 +517165 626175 +517165 704150 +517165 833073 +517165 833167 +517165 833824 +517165 836487 +517165 837520 +517165 837529 +517165 842223 +517165 855709 +517165 861487 +517165 865055 +5172 124638 +5172 15480 +5172 6901 +517221 517220 +517375 873207 +517375 920664 +517414 558104 +51746 43458 +51755 144922 +51757 5593 +517623 1410312 +517711 374955 +517711 528372 +517766 18984 +517766 47742 +5178 280348 +5178 70841 +5178 76493 +51786 22915 +517918 164067 +51799 28933 +51799 4857 +51799 754261 +517991 173032 +5180 1908 +518103 1025795 +518103 2565 +518142 757267 +518235 518242 +51824 73018 +518265 825997 +51827 210705 +51827 612990 +51831 583821 +51833 137273 +51833 148528 +518391 695323 +51863 82243 +518640 91866 +51876 92778 +518902 635935 +519123 37726 +519229 3842644 +51945 242744 +519766 294480 +519766 526594 +519766 834611 +519766 942019 +51984 133768 +51984 1527592 +51984 232956 +51984 51988 +51984 90541 +51988 231098 +51988 45095 +51993 1623377 +519934 822517 +520028 266722 +520053 507831 +520245 63158 +520248 1463723 +520248 164279 +520248 2504839 +520248 269254 +520248 3323814 +520248 366820 +520248 897378 +5203 17302 +5203 68394 +520366 520374 +52049 24730 +520612 723368 +520612 913732 +52062 5363 +520761 1098755 +520761 274745 +520761 357983 +520769 1528152 +520769 1595296 +520798 1114897 +520798 1379905 +5208 16934 +5208 1794147 +520801 1212504 +520841 1810968 +52103 145443 +52103 300225 +52112 196472 +52118 543589 +5213 9534 +521381 190370 +521381 226461 +521381 805380 +521381 832992 +521381 833794 +521381 957562 +521465 898890 +521546 516080 +521632 357971 +52172 173141 +52172 173435 +52176 217455 +521810 1192829 +521810 1219756 +521810 1977334 +521810 521810 +521810 766373 +521927 920810 +521964 1072420 +522067 346625 +52216 642578 +522172 522171 +522209 224329 +522209 454293 +522209 552196 +522209 833840 +522209 999914 +522210 448010 +522210 522209 +522210 526410 +522210 595478 +522210 826839 +522210 833108 +522210 873294 +52224 143464 +522269 2066290 +522338 60556 +52252 710786 +52264 167260 +522681 1824009 +522681 61245 +52272 45041 +522781 594764 +52282 328 +522846 1823418 +522866 205073 +522866 210862 +522866 214535 +522866 232956 +522866 630161 +52289 10508 +523070 130210 +523070 727590 +52310 18647 +52310 456972 +523101 523100 +523111 232474 +523111 278201 +52312 15501 +52317 30092 +523178 156602 +52318 1431865 +52318 17640 +523194 74213 +523221 363126 +523282 120236 +523282 62148 +52336 191044 +523368 523367 +523428 1170261 +523553 269254 +523553 539272 +523572 1285433 +523572 1569285 +5236 7731 +523633 1015406 +523633 115461 +523633 115466 +523633 115469 +523633 1192372 +523633 1351876 +523633 1398530 +523633 1400270 +523633 1419981 +523633 1569767 +523633 1569768 +523633 216140 +523633 2324662 +523633 236482 +523633 260744 +523633 262940 +523633 269254 +523633 271870 +523633 283122 +523633 283473 +523633 299702 +523633 304973 +523633 308115 +523633 335045 +523633 368137 +523633 374006 +523633 388185 +523633 394778 +523633 397617 +523633 397620 +523633 406271 +523633 406281 +523633 406283 +523633 406285 +523633 415720 +523633 448010 +523633 452918 +523633 454293 +523633 454981 +523633 456926 +523633 522210 +523633 538821 +523633 539131 +523633 547969 +523633 547971 +523633 550341 +523633 598601 +523633 617133 +523633 690972 +523633 696225 +523633 703271 +523633 712500 +523633 754894 +523633 832915 +523633 832924 +523633 833179 +523633 833986 +523633 834226 +523633 834378 +523633 834578 +523633 835190 +523633 835518 +523633 837960 +523633 838380 +523633 842888 +523633 847818 +523633 849690 +523633 855072 +523633 867835 +523633 867991 +523633 869796 +523633 883380 +523633 895152 +523633 899246 +523633 899248 +523633 905483 +523633 908890 +523633 95543 +523633 970416 +523633 978211 +523633 987109 +523642 1022039 +523642 108566 +523642 1096780 +523642 1275956 +523642 1385356 +523642 1440950 +523642 192322 +523642 2098343 +523642 229547 +523642 260744 +523642 324481 +523642 3248391 +523642 341147 +523642 392717 +523642 454293 +523642 515879 +523642 644726 +523642 691665 +523642 736606 +523642 832962 +523642 834534 +523642 835184 +523642 835735 +523642 837570 +523642 841452 +523642 842265 +523642 842269 +523642 842271 +523642 842272 +523642 843323 +523642 843325 +523642 847489 +523642 872577 +523642 885845 +523642 902982 +523642 912384 +523642 913039 +523642 941864 +523642 963375 +523642 963376 +523697 368137 +523786 514653 +52392 50249 +52396 309804 +523982 849793 +52407 52408 +524099 313849 +524152 117660 +524152 44422 +524182 153980 +524182 27519 +524182 299702 +524182 302675 +524182 366820 +524182 388185 +524182 520248 +524182 809856 +524182 834522 +524182 838447 +52446 93540 +52448 249062 +524563 202065 +52460 6229 +524754 524755 +52483 1515 +524871 424754 +525049 119929 +525093 106892 +525093 1178894 +525093 77090 +525093 77811 +525138 1734583 +525138 27952 +525185 5770 +525266 198228 +5253 1157984 +52532 17115 +52532 52529 +525353 386350 +525413 525412 +525428 116897 +525459 1010527 +525459 1234866 +525459 1329336 +525459 1477181 +525459 1477182 +525459 1640305 +525459 1770381 +525459 1864552 +525459 1864553 +525459 1864554 +525459 1864555 +525459 1987301 +525459 260744 +525459 2661644 +525459 283122 +525459 351666 +525459 459673 +525459 459674 +525459 459676 +525459 543206 +525459 560804 +525459 573235 +525459 576228 +525459 617404 +525459 654451 +525459 654453 +525459 683885 +525459 696171 +525459 696188 +525459 696215 +525459 696237 +525459 696266 +525459 696267 +525459 830144 +525459 833457 +525459 833765 +525459 837063 +525459 837502 +525459 837545 +525459 842585 +525459 850906 +525459 985192 +525460 1009447 +525460 1070145 +525460 170759 +525460 194 +525460 230140 +525460 253133 +525460 2645574 +525460 283122 +525460 462603 +525460 526591 +525460 832701 +525460 837529 +525460 837548 +525460 838931 +525460 838932 +525460 842132 +525460 844418 +525460 851419 +525460 855057 +525460 855063 +525460 855170 +525460 862697 +525460 905491 +525469 1040749 +525469 1220779 +525469 1229978 +525469 1341603 +525469 1341604 +525469 1908876 +525469 192327 +525469 2193682 +525469 2464761 +525469 253133 +525469 283122 +525469 290601 +525469 3740167 +525469 577808 +525469 696181 +525469 696188 +525469 832962 +525469 833686 +525469 833698 +525469 835735 +525469 837532 +525469 838929 +525469 839514 +525469 844418 +525469 857122 +525469 861581 +525469 900812 +525469 900979 +525469 973042 +525469 998855 +525476 1939478 +525476 525477 +525477 1939478 +525512 978393 +52560 3666767 +525683 169686 +525683 21139 +525683 223365 +525683 224519 +525683 24680 +525683 44030 +5258 417959 +525839 585244 +52584 144644 +526047 47711 +52613 44847 +526150 1568 +526150 170 +526150 627412 +526150 751175 +52626 368859 +52629 19870 +526409 833446 +526409 880609 +526409 882033 +526411 1933252 +526411 451535 +526411 517158 +526411 833074 +526411 838040 +526411 841431 +526412 624749 +526412 796211 +526412 916314 +526416 1945306 +526416 624749 +526416 796211 +526416 916314 +526416 978211 +526418 526412 +526418 624749 +526418 796211 +526418 916314 +526574 941075 +526574 941077 +526575 1493088 +526575 1965234 +526575 932064 +526575 979552 +526576 253245 +526576 333892 +526576 855140 +526579 1014466 +526579 1041164 +526579 1491036 +526579 153980 +526579 379809 +526579 388185 +526579 3887234 +526579 397616 +526579 526580 +526579 834101 +526579 838244 +526579 873814 +526579 900110 +526579 944146 +52658 290162 +52658 43082 +526580 1021949 +526580 1041164 +526580 1071276 +526580 1284343 +526580 1655036 +526580 479033 +526580 703271 +526580 834101 +526580 834534 +526580 835406 +526580 855971 +526580 871323 +526580 914907 +526580 918338 +526580 942359 +526580 953014 +526581 260744 +526581 283122 +526589 153980 +526589 1630688 +526589 1862785 +526589 283130 +526589 2843542 +526589 394791 +526589 435555 +526589 52786 +526589 647526 +526589 688716 +526589 762632 +526589 778529 +526589 778532 +526589 835350 +526589 855140 +526589 904645 +526589 953905 +526589 953928 +526589 997629 +526590 1028502 +526590 1262335 +526590 1861950 +526590 262940 +526590 271874 +526590 279614 +526590 395913 +526590 406273 +526590 406281 +526590 406283 +526590 454293 +526590 526580 +526590 834101 +526590 864672 +526590 888854 +526590 896978 +526590 976868 +526591 1488744 +526591 538646 +526591 837503 +526591 851310 +526591 851418 +526591 855061 +526591 880609 +526592 153980 +526592 261451 +526592 3185073 +526592 454293 +526592 833168 +526592 839640 +526592 874560 +526593 1071287 +526593 1485146 +526593 1689419 +526593 490281 +526593 526595 +526593 526596 +526593 744724 +526593 835964 +526593 858480 +526593 882021 +526594 108439 +526594 108565 +526594 115466 +526594 260744 +526594 262940 +526594 27519 +526594 279614 +526594 283122 +526594 397620 +526594 415720 +526594 454293 +526594 523633 +526594 538821 +526594 539271 +526594 539272 +526594 809856 +526594 833986 +526594 834378 +526594 834611 +526594 835190 +526594 837568 +526594 869570 +526594 888854 +526594 942019 +526595 1071287 +526595 1485146 +526595 490281 +526595 526596 +526595 744724 +526595 858480 +526595 882021 +526596 490281 +526596 895152 +526623 28377 +526677 36282 +526677 4050 +526739 1042095 +526739 408230 +52675 209672 +52675 2481643 +52675 2651324 +526770 16388 +52687 1132655 +52687 1341239 +52687 184855 +52687 232689 +52687 320099 +52687 82310 +526871 617155 +526989 232684 +527084 780993 +52710 44030 +527106 41443 +527106 467945 +52714 346540 +527161 1831675 +527161 415725 +527161 527161 +527161 649000 +527161 700443 +527161 704150 +527161 855761 +527161 877523 +527161 877779 +527237 649131 +52724 593991 +527287 527288 +527326 546853 +527475 1326618 +527489 4085 +527508 170037 +52753 271923 +52753 643849 +52758 17226 +52758 3909 +527609 19800 +527612 535857 +52762 92512 +52762 92513 +52763 63445 +527736 898967 +527810 84971 +52782 371663 +52782 371664 +52782 94090 +52786 154287 +52786 162564 +52786 20691 +52786 250109 +52786 276143 +52786 2813 +52786 32198 +52786 446295 +52786 56675 +52786 65640 +52786 853983 +527886 990926 +527919 527912 +52794 50566 +528 39919 +528017 661 +52815 455292 +52816 113497 +52816 13732 +52816 144828 +52816 66417 +52818 116683 +52818 145436 +52818 162553 +52818 237146 +52818 30138 +52818 380376 +52818 395191 +52818 398724 +52818 45387 +52818 5064 +52818 601569 +52818 77811 +52833 10533 +52833 135246 +52833 145262 +52833 145288 +52833 253011 +52833 323989 +52833 39677 +52833 44133 +52833 58355 +52833 698462 +52835 86716 +528362 379714 +528372 688821 +528406 336128 +5285 3496 +528657 1907454 +5287 137978 +52875 102433 +52875 137353 +52875 138116 +52875 146305 +52875 21057 +52875 33905 +52875 357242 +5288 2318 +5288 271013 +5288 9976 +528815 1147583 +528815 915638 +52884 52883 +528868 3061415 +528881 1222695 +528881 938392 +529 1379263 +529 484 +5290 1520518 +529094 133739 +52912 282190 +52925 400167 +52932 63195 +529326 529327 +529330 904668 +52958 1462131 +529608 1012183 +529722 1257152 +529723 40017 +529726 162564 +529726 1841563 +529726 716139 +529823 1157107 +529823 766102 +529832 319013 +529900 3367796 +529900 960689 +530005 17065 +53006 80694 +530078 530079 +53010 164586 +53010 45200 +53026 53027 +53039 93258 +530390 1094118 +530390 1625938 +530390 1626840 +530390 532270 +53045 127350 +53045 223935 +530468 1864834 +530493 1163303 +5306 1665 +5306 178432 +530687 1711057 +530812 125989 +530853 2658665 +5309 136357 +5309 1470066 +5309 19619 +5309 298695 +5309 629020 +5309 997791 +530972 2105718 +530972 2616133 +53105 1016594 +531070 121026 +531089 27952 +531089 578565 +531089 780493 +53112 61267 +531124 735562 +53117 217759 +53119 10991 +53119 17587 +53119 35746 +53119 37906 +53120 626136 +53121 31777 +53127 137602 +53127 90037 +531297 407693 +531322 1120377 +531322 1169313 +531322 242467 +531322 678079 +53133 15310 +5314 137860 +5314 18318 +5314 29690 +5314 47471 +531489 1265566 +531489 1266883 +531489 254400 +531489 312587 +531489 481548 +531489 870181 +531613 235838 +531701 2218112 +531701 457 +531701 505558 +531701 526714 +531701 85627 +53175 2997625 +5318 44290 +5318 817198 +531927 355 +53193 44397 +532 477834 +532086 1138961 +532086 1200733 +532086 1347376 +532086 1428466 +532086 153980 +532086 2268127 +532086 260744 +532086 262940 +532086 2640719 +532086 2836725 +532086 322517 +532086 397616 +532086 454293 +532086 517165 +532086 526592 +532086 532088 +532086 532089 +532086 598601 +532086 627442 +532086 703539 +532086 704150 +532086 729646 +532086 754974 +532086 835066 +532086 835518 +532086 839640 +532086 843513 +532086 852384 +532086 855059 +532086 857132 +532086 880957 +532086 917033 +532089 1347376 +532089 832962 +532089 835735 +532176 657102 +53223 347316 +532244 1131373 +532244 407260 +532265 1040507 +532265 1200910 +532265 216140 +532265 224329 +532265 252998 +532265 258462 +532265 318371 +532265 323990 +532265 397620 +532265 406281 +532265 415725 +532265 462603 +532265 532270 +532265 532273 +532265 532276 +532265 659953 +532265 683292 +532265 696200 +532265 704150 +532265 833317 +532265 837535 +532265 838930 +532265 841441 +532265 844419 +532265 849477 +532265 851419 +532265 855790 +532265 880605 +532265 880609 +532265 925945 +532265 926720 +532265 978176 +532270 1094118 +532270 2492982 +532270 375279 +532270 397620 +532270 415720 +532270 415725 +532270 55683 +532270 754974 +532270 795184 +532270 855072 +532270 861487 +532270 925945 +532270 95537 +532273 1205848 +532273 253245 +532273 262940 +532273 532270 +532273 839085 +532273 850893 +532273 861489 +532276 1732861 +532276 270225 +532276 283127 +532276 289522 +532276 397620 +532276 532270 +532276 532273 +532276 834073 +532276 837660 +532276 841431 +532276 850906 +532276 855032 +532306 532307 +532418 1441830 +532418 688716 +532425 368137 +532425 627442 +532425 712500 +532425 848261 +532425 999914 +532434 262940 +532434 2971546 +532434 834577 +53248 1135363 +53248 1439175 +53248 168907 +53248 259648 +53248 303575 +53248 6270 +53259 888250 +532684 1301946 +532684 57811 +53269 310799 +532701 532702 +532711 271222 +532792 1122117 +532800 280181 +532800 444623 +532828 978461 +532856 888023 +532896 864796 +533073 379499 +53326 53327 +53336 100261 +53337 2715181 +533429 620213 +533488 2011057 +533488 270225 +533488 696225 +533488 716084 +533488 754926 +533488 833161 +533488 836185 +533540 617271 +53360 111502 +53360 132321 +53360 164363 +53360 59769 +53360 61920 +533673 978733 +5340 169113 +534048 369309 +53417 155494 +53417 204334 +53419 271295 +53419 53336 +5342 508965 +534213 252914 +534293 1206445 +534451 1626845 +534470 285904 +534737 179014 +534737 202202 +534737 57471 +534784 534783 +534822 108568 +534822 115463 +534822 1426837 +534822 1511355 +534822 2129819 +534822 260744 +534822 261451 +534822 294746 +534822 406278 +534822 517153 +534822 575046 +534822 641164 +534822 683885 +534822 832962 +534822 833168 +534822 833698 +534822 834641 +534822 835735 +534822 837674 +534822 844416 +534822 845360 +534822 861474 +534822 899898 +534822 912593 +534822 931425 +534822 941850 +534822 95546 +534822 985088 +534877 697691 +53492 1537533 +53492 1857 +53492 197971 +53492 286 +53492 700491 +534955 359598 +53501 702 +53509 109214 +53509 136536 +535122 539155 +535167 901751 +53529 408490 +53529 4478 +53529 47076 +535408 155747 +535408 840384 +535617 107436 +535617 413164 +5357 58373 +535709 211196 +535723 1703326 +535723 3409422 +535723 3844408 +535723 3944114 +535723 527475 +53589 27459 +535975 230338 +535975 604560 +535975 9847 +53617 36289 +5362 4116 +536239 696631 +536239 696632 +5363 4179 +536409 1597942 +536424 292308 +536570 507735 +536837 991080 +536839 117419 +536839 1734584 +536839 1908110 +536839 2740871 +536839 3660815 +536839 514269 +536839 535723 +536839 908627 +536884 536885 +536926 235146 +53696 51122 +53714 10770 +53732 239189 +53732 402183 +53736 16880 +53736 21457 +537375 983521 +537450 537454 +5375 330340 +5375 52299 +537528 284821 +537528 69673 +537553 137978 +537556 12588 +53760 162284 +537604 722826 +537951 98541 +537954 2148860 +537954 666208 +537956 126149 +537957 427217 +53807 175006 +538094 301679 +5381 74647 +538117 251385 +538133 538132 +538156 365767 +53818 292491 +53821 229790 +53821 53728 +53824 202097 +53824 333335 +53826 2024 +5383 21201 +538428 464168 +538601 55325 +538639 260720 +538644 283127 +538644 41715 +538644 754974 +538646 1541603 +538646 1990133 +538646 2666389 +538646 267134 +538646 283127 +538646 688034 +538646 837503 +538646 839257 +538646 851310 +538646 851590 +538646 855060 +538646 861487 +53865 26454 +538821 115469 +538821 239236 +538821 304975 +538821 832951 +538821 835190 +538821 837568 +53883 105125 +53888 208457 +53889 265417 +53889 53889 +53890 146059 +53890 167557 +53890 274993 +53890 2764827 +53892 1066587 +538924 1659317 +538924 482193 +538989 1464967 +538989 1464968 +538989 1744350 +539018 51157 +539083 50165 +5391 244929 +5391 72965 +539131 269254 +539197 12339 +539197 23387 +539272 153980 +539272 539271 +5394 101090 +5394 1079206 +5394 16237 +5394 180204 +5394 2126345 +5394 23884 +5394 27103 +5394 274582 +5394 2920097 +5394 57087 +5394 6286 +5394 9171 +5394 9447 +539428 112977 +539428 165262 +539428 209469 +539428 322546 +539452 649506 +53976 45395 +539790 50079 +539797 15825 +5398 1377990 +5398 1625271 +53980 397475 +53980 425028 +53980 56735 +539866 1611151 +53988 466833 +539991 2416922 +539991 368907 +539991 556172 +5401 1602 +540163 482517 +540264 556975 +540277 27106 +5403 1077301 +5403 210889 +5403 27952 +5403 80916 +540358 1152605 +540358 1696713 +54042 11649 +5406 48780 +540634 545606 +54070 176374 +540780 491601 +5408 8339 +540891 540892 +540894 1093015 +540948 84971 +541114 10780 +541116 701547 +54122 22051 +541238 208267 +541273 562122 +541280 541273 +541280 562122 +541370 979783 +5414 60081 +54144 12810 +54144 54145 +5416 24204 +5416 2482307 +5416 73959 +5416 9003 +54163 176712 +54163 23624 +54163 35136 +54163 37032 +54163 473004 +54163 473005 +54163 58584 +54163 79732 +54163 800252 +541667 222691 +541803 277195 +54187 203681 +54187 401878 +54187 922770 +54191 153086 +542 233696 +542 452148 +542115 72117 +54212 1282493 +542122 282137 +542122 532265 +542122 838930 +542122 926720 +54224 282569 +54224 282590 +54224 282592 +542412 306207 +542448 338058 +542501 1933252 +542501 351666 +542501 696267 +542505 459676 +542505 573235 +542507 1671772 +542507 703271 +542507 858474 +542688 260744 +542688 283122 +54286 41272 +54286 659 +542894 338229 +54304 167786 +54304 35611 +543098 1648272 +54312 78892 +543206 1002404 +543206 1385928 +543206 260744 +543206 283122 +543206 397620 +543206 754974 +543206 833168 +543206 833554 +543206 837502 +543206 837545 +543206 844419 +543206 859036 +543206 859447 +543206 861484 +543206 861487 +543206 912007 +543250 1138366 +54335 454836 +54336 232609 +543388 208267 +5434 10263 +543428 333892 +543428 517144 +543681 1201287 +543768 1549806 +543768 444101 +54382 1975274 +54382 81666 +54398 54399 +543988 274470 +54401 60427 +54409 50308 +544139 544140 +5442 19277 +54440 60742 +544422 38312 +544452 1630523 +54455 14577 +54455 76567 +544608 244096 +544759 544758 +544765 140632 +544890 1036751 +544890 1036752 +544890 1270492 +544894 1036751 +544894 1208600 +544894 260744 +544894 840538 +544894 849795 +544894 900448 +545 60079 +545 94502 +54505 681119 +54517 140556 +54517 1621425 +54517 16408 +54517 223869 +54517 439814 +54517 989716 +54518 106892 +54518 1133195 +54518 1675087 +54518 195105 +54518 418806 +54518 485047 +54518 696404 +54518 769639 +54520 276060 +54520 411737 +54520 77089 +54520 93921 +54523 355 +54523 76299 +54524 230732 +54524 306324 +545359 120331 +545362 263 +545362 589814 +545431 778759 +545489 447096 +545489 509646 +5455 37863 +545623 777542 +545667 343362 +54567 43485 +545688 1115757 +54571 20818 +54571 58577 +545713 573273 +545716 3395699 +54574 114252 +54574 126193 +54574 158668 +54574 21443 +54574 278 +54574 29130 +54574 421949 +54574 47023 +54574 67456 +54575 676473 +54591 690431 +54596 171857 +54597 97320 +54608 67325 +546152 214037 +54616 45938 +546162 238591 +54619 183879 +546203 410344 +546203 785680 +546218 867581 +546262 1215654 +546262 1264262 +54641 279651 +5465 1041801 +5465 10472 +5465 2671448 +5465 6753 +5465 71346 +54650 139985 +54650 292478 +54650 3140 +546506 1883636 +546506 1883637 +546596 1043576 +546596 1098916 +546596 1404981 +546596 447296 +546596 459 +546596 553239 +5466 2306 +546633 1152459 +546635 28517 +546635 954953 +5467 10032 +5467 33980 +5467 499137 +546790 39302 +546791 643241 +546816 267648 +546819 1978164 +546819 267648 +546819 546816 +546838 400101 +546962 345256 +546971 781329 +547 261911 +547 74839 +5470 1244 +5470 15791 +5470 417 +547004 435667 +547193 431731 +5472 442257 +5472 5385 +547276 1158120 +547276 373377 +547276 455099 +547276 721331 +547453 125739 +54755 346835 +547712 59411 +547719 583016 +54776 54775 +5478 2731920 +54787 334815 +54787 38652 +54788 50840 +547962 456793 +547969 262940 +547969 27519 +547969 459776 +547969 517144 +547969 627442 +547969 688716 +547969 754894 +547969 809856 +547969 834578 +547969 855065 +547969 867946 +547971 1463723 +547971 164279 +547971 27519 +547971 366820 +547971 520248 +547971 547969 +547971 784121 +547971 809856 +547971 834578 +547971 897378 +547971 92243 +547972 1446763 +547972 1593899 +547973 2243355 +548 109179 +548 1936338 +548 56536 +54813 35746 +548143 17399 +548189 1356888 +5482 201584 +5482 29207 +548225 16375 +548225 281992 +548225 454293 +54832 54833 +548361 873551 +5485 21139 +5485 50016 +5485 629020 +5486 180837 +5486 70095 +548608 2117434 +548608 2185913 +548608 271874 +548608 340210 +54874 54875 +54879 14185 +54879 210195 +54879 89005 +549 2275453 +549 231189 +549 3837 +549 545 +549 60079 +549 94502 +54904 241894 +54906 234577 +54906 65721 +54910 541242 +54918 537846 +5492 1394217 +5492 222261 +5492 269081 +5492 31260 +5492 323990 +5492 465608 +5492 564649 +5492 90005 +549274 549277 +549367 532164 +54953 474630 +549619 1029388 +54962 358875 +54962 54963 +549796 285065 +5498 17594 +5498 206559 +5498 77923 +55 33601 +55 34 +55 7627 +550039 776810 +550073 244065 +550090 369309 +550090 43874 +550090 534048 +550116 985448 +550261 286198 +550261 325501 +550261 653366 +550261 653368 +550261 653370 +55029 253245 +55029 262940 +55029 355145 +550415 293069 +550425 240331 +55048 177651 +550548 365215 +55065 1171 +550680 57180 +55069 160696 +550701 113428 +550705 169412 +55074 198269 +55074 42124 +550750 186458 +550889 45966 +55104 1254803 +55104 410380 +55104 428883 +551071 1037730 +551071 1297439 +551147 873546 +551160 551161 +5512 50277 +55125 8102 +551275 812195 +5513 11070 +5513 120532 +5513 14362 +5513 252433 +551325 428776 +551325 551324 +55133 113526 +55133 2497873 +551561 551560 +55175 17827 +551789 1310220 +55181 21743 +551863 280034 +551956 1488497 +551967 50141 +551967 980145 +551968 211067 +551968 61227 +552 225872 +552 26511 +552021 169336 +552021 282003 +552063 2460926 +55207 32883 +5521 63220 +552117 1545928 +55213 324677 +552195 1022025 +552195 1234289 +552195 552194 +552195 865050 +552196 1014466 +552196 1053431 +552196 1080246 +552196 108568 +552196 1172316 +552196 1199356 +552196 1222912 +552196 1267800 +552196 1306527 +552196 1346687 +552196 1362829 +552196 1376703 +552196 1417030 +552196 1428466 +552196 153980 +552196 1707838 +552196 2102021 +552196 224329 +552196 226461 +552196 2324642 +552196 260744 +552196 262940 +552196 271870 +552196 2736228 +552196 2737571 +552196 27519 +552196 283122 +552196 283125 +552196 283127 +552196 283473 +552196 289522 +552196 2924017 +552196 294480 +552196 2977692 +552196 299702 +552196 317584 +552196 3187957 +552196 342543 +552196 343871 +552196 355662 +552196 361814 +552196 3637771 +552196 368137 +552196 377139 +552196 388185 +552196 397617 +552196 397620 +552196 410038 +552196 415720 +552196 41715 +552196 432960 +552196 435555 +552196 436197 +552196 448007 +552196 454293 +552196 465982 +552196 491150 +552196 519766 +552196 522210 +552196 523633 +552196 526594 +552196 538644 +552196 547969 +552196 547971 +552196 552194 +552196 552195 +552196 558106 +552196 558625 +552196 598601 +552196 627128 +552196 653535 +552196 683885 +552196 703271 +552196 708144 +552196 712500 +552196 744724 +552196 751499 +552196 754894 +552196 754974 +552196 762355 +552196 805380 +552196 806436 +552196 809856 +552196 822473 +552196 832661 +552196 832905 +552196 832915 +552196 833033 +552196 833038 +552196 833179 +552196 833697 +552196 833698 +552196 834226 +552196 834378 +552196 834577 +552196 834611 +552196 834646 +552196 835112 +552196 835186 +552196 837584 +552196 838169 +552196 838295 +552196 842132 +552196 843324 +552196 844250 +552196 847484 +552196 855065 +552196 858967 +552196 867995 +552196 869570 +552196 882946 +552196 883380 +552196 883641 +552196 905982 +552196 915968 +552196 92243 +552196 942019 +552196 96123 +552196 976044 +5522 106458 +5522 11574 +5522 13855 +5522 153055 +5522 20427 +5522 231726 +5522 36378 +5522 39336 +5522 6070 +5522 63260 +5522 63263 +5522 70697 +552252 2410679 +5523 232793 +55234 63137 +55240 518810 +552480 5512 +552509 492550 +552703 575818 +552717 272275 +552717 508131 +552717 665970 +552717 758216 +552829 59588 +552831 552830 +552836 552838 +552885 165933 +5530 1057079 +553093 303726 +5531 109535 +5531 68702 +553223 25758 +55326 110104 +55326 741755 +553302 20710 +55338 294537 +553397 2444196 +553397 546596 +553397 809123 +55364 75584 +553843 48670 +553951 2066369 +553974 310013 +553982 151357 +554046 2232717 +55413 55414 +554278 2018901 +55428 69258 +55428 8913 +554314 667830 +554346 1552895 +554346 605226 +554360 12546 +5545 109649 +5545 42822 +5545 45200 +5545 5545 +554513 1066383 +554513 1071682 +554513 1238018 +554513 28517 +554513 3108574 +554513 374519 +554513 393426 +554513 648440 +554528 154207 +554530 308329 +554530 573683 +554585 294233 +5547 5432 +55475 13354 +554793 415847 +554794 1155903 +554794 1468981 +554794 239566 +554794 252642 +554794 344428 +554794 633282 +554794 663652 +554810 7638 +554921 230238 +554921 617293 +55495 61267 +555275 808379 +55538 456556 +555389 362918 +555462 1671772 +555462 2451936 +555462 260744 +555462 269254 +555462 283122 +555462 397620 +555462 488362 +555462 542507 +555462 703271 +555462 833317 +555462 833579 +555462 838932 +555462 852709 +555462 855061 +555462 858474 +555462 895152 +555462 95536 +55548 41646 +55554 32301 +555588 1512772 +555588 189913 +555610 138067 +555610 205808 +555610 250386 +555610 581512 +555610 623870 +555610 913323 +55566 28847 +55567 132756 +555739 491950 +555758 3170073 +55577 55578 +555775 555776 +555831 192202 +555846 1255566 +555846 1905567 +555846 2571460 +555846 556172 +555846 564909 +555846 728874 +555928 1627312 +556 526739 +556002 20563 +556113 15301 +556117 1371724 +55614 323300 +556172 2314968 +556172 728874 +556242 5618 +556260 2220792 +556260 556385 +55630 100910 +55630 19490 +5564 92536 +55642 9708 +55644 51227 +55648 12965 +55668 245451 +55676 62722 +55683 1080247 +55683 1294345 +55683 1400010 +55683 1477181 +55683 1488744 +55683 1908726 +55683 1908876 +55683 2085393 +55683 230140 +55683 2492982 +55683 2518110 +55683 2532965 +55683 2542688 +55683 260744 +55683 282137 +55683 283122 +55683 368137 +55683 397620 +55683 415720 +55683 525460 +55683 525469 +55683 538821 +55683 696169 +55683 696260 +55683 727253 +55683 754974 +55683 832701 +55683 833554 +55683 835733 +55683 837529 +55683 837534 +55683 838931 +55683 841593 +55683 842132 +55683 842223 +55683 853477 +55683 855063 +55683 855072 +55683 855170 +55683 858372 +55683 861487 +55683 862694 +55683 862697 +55683 883123 +55683 900979 +55683 925944 +55683 961426 +55683 973042 +55683 982123 +55683 982126 +55683 998856 +556928 557506 +556943 556942 +5572 46764 +557341 557339 +55738 22164 +55738 251777 +55738 97917 +55745 16794 +55745 263796 +55745 29974 +557511 469050 +55753 225433 +55753 76894 +55760 126092 +55760 18700 +55760 302869 +55760 421263 +55760 915075 +557625 1175745 +55766 684531 +55766 692646 +55768 90390 +55772 7137 +55774 107097 +55804 251578 +558045 262944 +558045 305847 +558058 1768890 +558092 2466367 +558106 283127 +558106 41715 +558106 538644 +558106 754974 +55817 5342 +55838 598297 +5584 1240 +558474 2092459 +558474 68410 +558625 1376703 +558625 448007 +558625 708144 +558784 2638117 +558784 542 +558784 615829 +558792 636753 +558803 69987 +558845 558846 +55896 42933 +55902 10263 +55906 253240 +55906 257008 +55906 306715 +55906 597705 +55906 702275 +55911 101680 +559173 219849 +559173 321074 +55921 189819 +559443 993186 +559456 217965 +5595 10422 +5595 122445 +5595 142764 +5595 1873527 +5595 20684 +5595 211218 +5595 228032 +5595 26313 +5595 280875 +5595 320098 +5595 4159 +5595 52304 +5595 65180 +5595 65533 +5595 71284 +5595 72412 +5595 882155 +559567 1417841 +559681 85141 +55972 747504 +559783 84839 +559875 199690 +559875 843618 +559880 1875896 +559955 2400888 +559955 68857 +560029 49070 +560142 28164 +560142 836254 +560188 494117 +560317 255212 +560519 560518 +56052 415725 +56052 836588 +56052 920799 +56052 954705 +56053 414275 +560540 560541 +560575 2078280 +560687 1433861 +560687 349766 +5607 22599 +560755 668326 +560798 456827 +560798 582965 +560804 855889 +560865 2266189 +560865 373568 +560935 790919 +56095 12485 +560977 1774278 +561049 1359692 +561054 1428466 +561054 1478675 +561054 192327 +561054 239236 +561054 2401903 +561054 253133 +561054 260744 +561054 262940 +561054 374006 +561054 754974 +561054 851310 +561054 882018 +561054 95542 +5611 214225 +561196 1246853 +561247 333459 +56129 5848 +561465 274736 +561465 502434 +5615 223375 +5615 239436 +5615 40 +5615 5073 +5615 59215 +56150 13195 +561521 354816 +561521 948160 +5616 49775 +561621 1719022 +561621 2907890 +561712 561711 +561722 2691498 +561783 120312 +561831 512461 +561831 563672 +561869 565720 +5619 29921 +561924 1264631 +561924 23096 +56194 176262 +56194 413611 +561944 989795 +56195 511590 +562068 65684 +562192 1124862 +562192 2371638 +562322 176175 +56290 80417 +562915 1445467 +562915 2279349 +563057 284667 +5632 83 +563202 2058941 +563205 563204 +563205 8145 +5633 263 +5633 383851 +5633 92947 +56347 56348 +56349 122595 +563501 825069 +56372 414692 +563758 613357 +56403 43151 +564162 1638553 +564162 1756015 +564162 2531021 +564162 769998 +564162 875796 +5643 5634 +564456 9463 +56449 17589 +564513 1116668 +564513 1173870 +564513 85768 +5646 415442 +5646 459 +5646 49518 +5646 6676 +564649 1394217 +564649 260744 +564649 2645574 +564649 368137 +564649 454293 +564649 639480 +564649 837533 +564649 840014 +564649 880725 +564649 898730 +564673 564672 +56469 191103 +56469 7444 +564794 952 +5648 109832 +5648 110153 +5648 12470 +5648 25777 +5648 27555 +5648 31777 +5648 35848 +5648 3722 +5648 39838 +5648 39908 +5648 53164 +564909 2571460 +564910 735827 +564913 361545 +56494 341876 +565071 1226669 +565149 336094 +56518 430488 +56518 7278 +565205 361539 +565221 193692 +56527 275111 +565297 720391 +565335 1928784 +56536 5087 +56546 143151 +56546 6362 +56560 45023 +565710 251607 +565710 590465 +565710 628237 +565710 828564 +56575 177603 +565775 504753 +56585 1112072 +565984 565985 +565992 1781621 +566010 651190 +56624 13222 +56626 80694 +566273 24742 +56635 337902 +5664 1606075 +566488 468479 +566501 1229202 +566502 408192 +566541 1192848 +566541 276435 +566541 585178 +566541 998666 +5666 149249 +56674 111858 +56674 521402 +56674 983017 +56680 1345424 +566828 1068722 +566828 1068723 +566966 566961 +567073 739964 +567073 889347 +567163 34574 +567169 567171 +567169 567172 +567172 567171 +56718 2125776 +567208 1184041 +567208 274531 +567209 1184041 +567209 274531 +567209 567208 +567209 850385 +56722 381146 +567249 1753162 +567249 340519 +56728 859534 +567288 304114 +56735 10632 +567355 293440 +567376 712640 +567420 954247 +56743 23446 +567502 119084 +567502 494994 +567502 655270 +567502 754978 +567511 1047947 +567511 1092492 +567511 1135260 +567511 1518735 +567511 1822718 +567511 1979591 +567511 260744 +567511 262357 +567511 262940 +567511 2690116 +567511 2694364 +567511 27519 +567511 283122 +567511 3011155 +567511 368137 +567511 495010 +567511 517160 +567511 526412 +567511 526418 +567511 547969 +567511 547971 +567511 624749 +567511 796211 +567511 799352 +567511 809856 +567511 822473 +567511 833010 +567511 833168 +567511 835730 +567511 867659 +567511 916314 +567511 943307 +56755 108385 +56755 255093 +567653 385132 +567693 1034034 +567741 1154418 +567941 1026513 +56797 196897 +56798 260501 +56799 6376 +568 40030 +56800 1583634 +568035 395263 +5682 239109 +5682 31715 +5682 455234 +5682 53249 +56824 16484 +568324 696296 +56838 225315 +56864 56863 +568984 3608550 +569028 9965 +56907 23860 +569172 296624 +56919 1010312 +56925 58556 +569294 156794 +569294 4300 +569308 122003 +569375 203446 +569375 361223 +569429 1636340 +569429 2887454 +569429 696193 +569429 736606 +569429 833628 +569429 855057 +569429 855170 +569429 870172 +56953 521724 +569572 569573 +56960 299635 +569645 542115 +569645 72117 +569776 570183 +56978 17413 +56978 77855 +569851 305152 +57 622252 +570484 829837 +570536 1269369 +570536 645601 +570536 836801 +570536 974269 +570542 1732861 +570542 532276 +570542 837660 +570603 1715775 +570615 23825 +570738 1107070 +570738 1548265 +570738 460120 +570738 669685 +570739 207974 +570751 402991 +57085 701611 +570882 414788 +570891 349409 +57090 189922 +57090 210252 +570918 23102 +570919 498780 +57103 107701 +57103 24221 +57103 255183 +57103 267648 +57103 62963 +57103 706795 +57103 94928 +57103 9549 +57106 9830 +57116 29820 +57116 406831 +57116 956768 +571178 571172 +571540 93386 +57160 34120 +571798 235019 +571799 235019 +571799 571798 +57180 51468 +571862 1356610 +571862 356317 +571862 774481 +571862 835060 +571862 870833 +571862 998654 +57205 57204 +572072 572068 +572072 67657 +572127 166847 +572127 283188 +572127 674257 +572153 572154 +57216 253 +572485 1271720 +572623 3114066 +572623 561812 +572751 190251 +572751 205808 +572751 257914 +572751 296718 +572751 442205 +572759 85061 +572782 13682 +572782 1550720 +572782 3316810 +572782 522846 +572782 588638 +572782 984353 +57279 5 +57279 91938 +572858 2836610 +572858 320517 +572858 341656 +572869 2143700 +573029 1076237 +573029 2535980 +573029 2587394 +573029 2587430 +573029 2587431 +573029 2827828 +573029 948478 +573032 573033 +57307 25262 +5731 1845 +573116 190370 +573116 227875 +573116 262357 +573116 294480 +573116 567511 +573232 457281 +573232 459676 +573232 542505 +573232 573235 +573235 1010527 +573235 260744 +573235 459676 +573235 573239 +573235 593620 +573235 646860 +573235 833168 +573235 833553 +573235 837062 +573235 842238 +573235 883315 +573239 1004365 +573239 1022025 +573239 1040506 +573239 1129949 +573239 1284573 +573239 1488743 +573239 1640338 +573239 260744 +573239 261451 +573239 262940 +573239 283127 +573239 283469 +573239 368137 +573239 397617 +573239 446577 +573239 451535 +573239 459673 +573239 532276 +573239 542501 +573239 641164 +573239 646860 +573239 826840 +573239 833076 +573239 833168 +573239 833553 +573239 833824 +573239 834073 +573239 834641 +573239 837527 +573239 841431 +573239 844416 +573239 844418 +573239 850889 +573239 850906 +573239 855072 +573239 882032 +573239 907452 +573239 931425 +573239 973042 +573251 832898 +573251 833168 +573366 1032419 +573576 1459999 +573576 455109 +573576 491036 +573731 189913 +573731 928815 +573816 1088241 +57393 67592 +574063 575536 +574093 1214435 +57415 1612 +574298 1109241 +57430 316 +574367 2718468 +574367 819206 +57441 57442 +574477 1197950 +574477 1223983 +574477 574478 +574478 1197950 +574573 374792 +574750 574738 +57477 104370 +57477 11073 +57477 16655 +57481 800128 +57481 896118 +574914 262940 +574914 532273 +574914 696215 +574914 835733 +574914 839085 +57492 327827 +57496 55839 +575045 1016009 +575045 1138898 +575045 1138901 +575045 1284573 +575045 2006344 +575045 260744 +575045 283122 +575045 283127 +575045 454293 +575045 517153 +575045 517165 +575045 573239 +575045 641164 +575045 704150 +575045 833071 +575045 833075 +575045 834641 +575045 844416 +575045 844418 +575045 931425 +575046 1426837 +575046 260744 +575046 261451 +575046 283127 +575046 542501 +575046 573239 +575046 578737 +575046 833168 +575046 833553 +575046 833698 +575046 845360 +575046 851344 +575046 985088 +575058 1673212 +57508 103257 +57508 507205 +575089 266591 +57509 103268 +57509 157232 +57509 175252 +57509 301152 +57509 3782412 +57509 40444 +57509 44360 +57509 57800 +57509 64774 +57510 99384 +57521 292670 +57526 13030 +575297 104514 +575297 465983 +575536 134101 +575536 1602875 +575536 1892678 +575536 1892679 +575604 13100 +575612 1105286 +575675 796144 +575704 341157 +5758 22334 +5758 36142 +5758 59697 +5759 234200 +5759 67058 +575941 906658 +576008 53308 +576092 576093 +5762 1246162 +5762 1690 +5762 23555 +5762 320098 +5762 3338 +5762 39115 +5762 8349 +57620 136133 +576228 459676 +576228 837063 +576237 425124 +576237 425125 +576237 455839 +576237 906298 +57626 951125 +576270 1166650 +576270 1264004 +576270 1396476 +576270 2522704 +576270 254841 +576270 3116751 +57628 1987430 +57628 446637 +57628 520798 +57640 7875 +576420 1386672 +576420 837570 +576539 2116208 +576719 69218 +576784 10780 +576784 209874 +576784 541114 +5769 62821 +5769 8052 +576906 576905 +577101 1424549 +577101 287928 +577197 528354 +57726 351500 +577278 8456 +577434 251144 +577454 1166964 +5775 782666 +57754 260438 +57755 479598 +57755 493102 +577653 1267623 +577653 31418 +577653 433615 +577653 480783 +57770 122418 +57770 180140 +577773 340408 +577808 1040777 +577808 1229978 +577808 1653542 +577808 696181 +577808 837674 +577812 1341603 +577812 1377659 +577812 1640293 +577812 2645574 +577812 526591 +577812 696193 +577812 833628 +577812 855063 +578053 1103641 +578053 616125 +57809 907144 +57811 1186 +57811 1410757 +57811 16095 +57811 232824 +57811 26923 +57811 4954 +57811 57811 +57817 103097 +57817 333473 +57817 67303 +5783 42565 +5783 6981 +578324 10377 +578324 10431 +57838 42380 +57838 4476 +578405 1491279 +578405 218860 +57841 377449 +57841 46666 +57844 10628 +57844 108969 +57844 135575 +57844 226971 +57844 266132 +57844 315171 +57844 315503 +57844 880065 +578460 2177866 +578565 1138302 +578565 27952 +578565 751051 +578583 70828 +578624 356137 +578631 170461 +578631 299624 +578719 836608 +578719 849128 +578726 842832 +578726 867835 +578726 950106 +578727 1015827 +578727 108439 +578727 1142516 +578727 1279344 +578727 1424032 +578727 157707 +578727 1680148 +578727 192325 +578727 216140 +578727 260744 +578727 262940 +578727 269254 +578727 283122 +578727 308115 +578727 334081 +578727 368137 +578727 388185 +578727 395913 +578727 397616 +578727 406273 +578727 406281 +578727 406283 +578727 424576 +578727 435555 +578727 454293 +578727 456926 +578727 465982 +578727 472036 +578727 488362 +578727 521381 +578727 522209 +578727 522210 +578727 538821 +578727 552195 +578727 595478 +578727 604396 +578727 610799 +578727 620726 +578727 623293 +578727 626175 +578727 688716 +578727 696188 +578727 704150 +578727 754894 +578727 754974 +578727 784121 +578727 800996 +578727 823059 +578727 823061 +578727 823063 +578727 824202 +578727 832898 +578727 832905 +578727 832915 +578727 832924 +578727 832942 +578727 833035 +578727 833168 +578727 833560 +578727 833698 +578727 834229 +578727 834577 +578727 834578 +578727 834611 +578727 835190 +578727 835518 +578727 835548 +578727 835892 +578727 836430 +578727 837549 +578727 837568 +578727 837573 +578727 838929 +578727 839412 +578727 839640 +578727 842108 +578727 842888 +578727 843529 +578727 845768 +578727 846290 +578727 855061 +578727 859780 +578727 867976 +578727 869570 +578727 871323 +578727 884221 +578727 892835 +578727 898854 +578727 898855 +578727 903854 +578727 915941 +578727 926721 +578727 940128 +578727 944146 +578727 944561 +578727 95542 +578730 1053915 +578734 1046945 +578734 108566 +578734 260744 +578734 283122 +578734 793064 +578734 840034 +578734 842308 +578734 844147 +578734 869650 +578734 870833 +578737 157707 +578737 1632526 +578737 224329 +578737 283127 +578737 446471 +578737 479037 +578737 517158 +578737 526592 +578737 696238 +578737 716084 +578737 826839 +578737 833108 +578737 833155 +578737 834646 +578737 835518 +578737 835735 +578737 840489 +578737 842085 +578737 842238 +578737 845359 +578737 849793 +578737 865054 +578737 867985 +578737 925945 +578737 985088 +5788 3133 +5788 4835 +57886 125196 +57886 2091 +57886 308927 +57886 434256 +57886 9970 +579069 5633 +579069 92947 +579114 1523813 +579162 302684 +579173 312154 +579173 367959 +579173 635936 +579277 341656 +5793 354816 +579373 1166843 +579373 412749 +579395 1162316 +57946 286465 +579635 555263 +5797 2193174 +5797 2219820 +5797 2789800 +5797 63407 +5797 930381 +579778 383325 +57979 1564600 +57979 342593 +57979 354816 +57979 638651 +579843 248304 +579862 1070586 +579862 579862 +579907 3252051 +5800 15721 +580055 156041 +580058 229013 +580058 29332 +58009 58010 +58014 138038 +58014 164363 +58014 230644 +58014 241309 +58014 3728683 +58014 37906 +58014 50200 +580166 1437991 +580166 262940 +580166 269254 +580166 2773261 +580166 415720 +58018 1080983 +58018 236945 +58018 236946 +580242 4594 +580342 1798995 +580432 26918 +58045 66730 +58045 762 +58052 183788 +5807 3133 +5807 4978 +5810 313921 +58101 217848 +58130 61342 +581512 250386 +581512 623870 +58161 144360 +581661 1461 +58173 5951 +58178 68579 +58194 1335306 +582 107750 +582002 582002 +5821 171326 +5821 203294 +58214 233188 +582244 402609 +582244 677706 +5823 42404 +582339 188432 +582339 35125 +58248 11163 +5825 459622 +58256 155747 +5826 29831 +5826 56471 +5826 765699 +58280 149175 +5829 24374 +5829 69247 +583010 130588 +583010 355 +583044 355659 +58305 58841 +58306 15626 +583138 1003993 +583138 1126409 +583138 1349250 +583138 1417030 +583138 1417031 +583138 1417032 +583138 27519 +583138 517144 +583138 809856 +583138 982396 +583138 982397 +583138 982399 +583138 986114 +583138 999914 +583248 18324 +583248 308458 +583252 3137617 +583252 849774 +5833 36559 +583309 2228392 +58339 60187 +583394 445910 +583397 449770 +583397 583395 +58349 1237 +583521 2755176 +58359 839411 +583750 1246484 +583750 594752 +5838 44527 +583942 280557 +583969 583968 +58397 61543 +58397 818624 +583987 57103 +583987 952625 +584 13238 +584 152004 +584 230344 +5840 335370 +5840 5825 +5840 629020 +5840 706957 +584092 257938 +584119 102644 +584119 14464 +584166 584165 +584211 715255 +584243 124429 +58426 214236 +5843 73815 +58435 62130 +584423 137940 +584423 374522 +584423 949482 +584636 1048973 +58469 179413 +584769 282419 +5848 65105 +58481 31799 +58483 232780 +58483 688281 +584835 425125 +584835 854918 +584835 866958 +584835 900056 +5849 33928 +585092 1080984 +585092 2058302 +585092 8095 +585285 692943 +585309 2100851 +58533 33200 +585358 635166 +585368 1314589 +585419 211068 +585419 256332 +585419 285206 +58549 5531 +585505 357395 +58554 1435159 +58554 186837 +58554 26931 +58554 39666 +58554 99172 +585553 4003 +585579 115467 +585579 227870 +585579 712500 +585616 471931 +58566 1288920 +58566 1417156 +58566 149423 +58566 1534778 +58566 2303246 +58566 347694 +58566 58566 +58566 915105 +58566 948370 +58575 100014 +58575 20700 +58575 230060 +58577 20818 +58578 423393 +585782 1783476 +585783 1490094 +585837 322233 +58589 2311 +586054 658057 +586194 476207 +58624 5825 +586321 2485087 +58654 17610 +58654 1781 +58654 250011 +58654 26916 +58654 31009 +58654 3631 +58654 6520 +58654 857 +5866 244921 +5866 425116 +586636 721433 +5867 221965 +5867 222527 +5867 26414 +5867 28422 +5867 3338 +5867 43695 +5867 5762 +586740 862058 +5868 4459 +5868 65181 +586830 202822 +58690 224993 +58691 262822 +587026 681416 +58708 125912 +58708 14753 +58708 31712 +58712 194 +587140 73291 +587167 1709635 +587167 268272 +587167 454293 +587278 54524 +587278 587278 +587281 824715 +5873 17963 +5873 37717 +5873 858 +587389 409728 +587435 1769257 +587435 1996426 +58764 57466 +587662 2111320 +587662 2111321 +5877 269036 +58802 1256865 +58807 230356 +58807 38980 +58807 76067 +58808 87270 +5881 6013 +588329 304371 +588367 438610 +588367 540613 +588451 1114835 +588451 524152 +588476 1166964 +588476 446483 +588476 588476 +588476 698795 +588483 1481387 +5886 2710772 +5886 29921 +5886 5873 +5886 745336 +5886 915202 +58860 58861 +588638 1016605 +5887 10631 +5887 163556 +5887 17126 +5887 5899 +58870 113430 +58870 142758 +58870 25870 +58870 77811 +58891 58491 +588945 572498 +58902 5363 +58908 22759 +5892 13195 +5892 142375 +5892 2187 +5892 23909 +5892 32836 +5892 3870 +5892 63487 +589287 214748 +589287 441493 +58929 27952 +589315 1028493 +589315 156602 +589315 1589023 +589315 1858645 +589315 1865477 +589315 460077 +589315 963287 +5894 1113188 +5894 287156 +589501 123904 +589501 292491 +589501 396942 +589501 914962 +589601 1264004 +589602 811375 +589603 794645 +589709 257421 +589709 298099 +589756 287377 +589759 194 +589881 454980 +589892 115461 +589892 262358 +589892 502825 +589892 514541 +5899 192509 +5899 677755 +589939 77222 +589964 590123 +589971 355 +589971 593457 +59 13140 +59 13195 +59 137839 +59 33567 +59 3694 +59 43246 +59 44030 +59 716 +59 75775 +59 81945 +59 99026 +590032 94996 +590083 1902070 +5901 204996 +590164 210559 +590164 240282 +59036 936369 +59037 82679 +590408 312774 +590408 70867 +590592 492567 +590626 1304318 +590880 277561 +591041 455839 +591041 508213 +591041 578737 +591041 884344 +5911 1108500 +5911 194 +5911 21073 +5911 58350 +5911 70887 +5911 88495 +5911 934501 +591127 565710 +591127 628237 +591127 828564 +591130 196946 +59128 21447 +591298 1869714 +5914 244467 +5914 24946 +5914 62742 +5914 718977 +59154 225810 +59172 41971 +59172 69992 +59176 1165250 +591783 1210259 +59181 471909 +591923 647374 +59194 3567 +5920 36738 +59214 13196 +59215 426677 +5922 133108 +592239 1421088 +592239 455166 +59225 52939 +59225 826431 +59226 216388 +592272 472213 +592272 592273 +592272 592274 +592272 662254 +592272 702591 +592272 749581 +592272 756847 +592273 592273 +592273 592274 +59246 20991 +59246 322322 +59246 389992 +59246 598247 +59250 120763 +59250 63994 +59251 212002 +59251 251873 +59251 253476 +59251 256168 +59251 265354 +592557 106541 +592557 355488 +592639 1443366 +592639 288549 +59266 65469 +592998 19390 +593084 584165 +593084 584166 +59312 336540 +593323 691598 +593337 810809 +59340 63177 +593457 355 +593599 298836 +593613 108343 +593613 2701234 +593613 593617 +593613 636636 +593613 833332 +593617 108343 +593617 2701234 +593617 636636 +593664 429264 +5937 212573 +5937 66040 +5938 35541 +593911 593912 +593991 975576 +59405 195812 +59405 257353 +59405 289505 +59405 416399 +59406 315789 +59406 573428 +594064 203097 +59410 455885 +59410 455886 +59411 1467615 +59411 38207 +59420 634095 +594278 577022 +594375 774827 +5944 108525 +5944 79352 +594478 111174 +594485 241617 +594517 594516 +59464 53 +594659 361848 +594707 1302208 +594760 459401 +594765 283857 +59484 14068 +59485 98460 +594979 496373 +594979 594978 +595039 191608 +595039 320555 +595050 355 +595050 589971 +595050 593457 +595051 526421 +595051 826829 +595051 912385 +59507 33476 +59507 387752 +5951 52312 +5951 90539 +59522 255047 +59522 89854 +5953 12627 +5953 69273 +59532 16112 +59532 379569 +59532 41513 +595362 588552 +595478 1611690 +59549 369800 +59549 40725 +59551 237717 +59551 245330 +59595 25678 +5960 44290 +5960 87524 +5960 95535 +596024 596023 +596024 596025 +596024 596026 +596025 596023 +596026 596023 +596026 596025 +596113 355 +59618 385004 +596210 363473 +5963 24495 +596407 637603 +596407 714502 +596409 596410 +59645 1057232 +59645 672822 +596501 2280040 +59651 149303 +59656 23812 +59656 239054 +59656 293773 +59656 37120 +59656 3811268 +59656 426488 +59656 711893 +59656 90037 +596566 1505301 +59659 253777 +59659 255109 +59659 30184 +5966 242433 +5966 257486 +596727 577036 +59673 1551414 +5968 91348 +5969 1055472 +5969 134505 +5969 230979 +5969 5521 +5969 63220 +5969 81232 +5969 971453 +596988 250058 +596988 51079 +596989 250058 +596989 51079 +596989 596988 +596997 1351988 +596999 450319 +597121 1082881 +597144 135189 +59719 18424 +597210 282777 +597288 1210231 +59736 251536 +59736 89970 +59736 89972 +597385 1935988 +597385 2201848 +59742 235790 +59742 66727 +59744 63752 +597557 310212 +59756 1094847 +59756 1297900 +59756 194266 +59756 262940 +59756 399868 +59756 415723 +59756 446750 +59756 453138 +59756 5797 +59756 598015 +59756 696028 +59756 696225 +59756 84839 +59769 111502 +59769 61920 +59770 11612 +59792 151634 +59792 194 +59792 254199 +59792 49908 +598 67156 +5980 14781 +5980 2108293 +5980 5980 +5980 5981 +5980 5982 +5980 62649 +598015 84839 +598017 1348114 +598017 1484528 +598066 2814801 +598080 1096150 +598084 2510349 +598124 252868 +5982 240159 +5982 5981 +598250 847666 +598273 136875 +598273 42138 +598302 113916 +598334 21731 +598550 1165907 +598601 1048430 +598601 108568 +598601 262940 +598601 267134 +598601 3397762 +598601 456926 +598601 502809 +598601 527161 +598601 598601 +598601 700443 +598601 703539 +598601 712500 +598601 729646 +598601 806436 +598601 809856 +598601 834577 +598601 835518 +598601 843127 +598601 847484 +598601 855061 +598601 855066 +598601 858967 +598601 877523 +598601 882018 +598601 976044 +598606 740534 +5988 8793 +598812 1254803 +598812 410380 +598812 428883 +598812 55104 +59903 208043 +59903 403019 +59903 421761 +59903 551161 +59903 5866 +59909 249669 +59909 251070 +59909 2577486 +59909 4344 +59909 75815 +59910 340172 +59910 59909 +599101 1901299 +599270 412316 +5993 14483 +5993 241189 +599477 1082561 +599488 1314144 +599488 3022452 +599488 96123 +59963 207714 +59967 22766 +599708 584795 +59971 55248 +599819 179144 +599819 238473 +60 1611376 +60 21474 +600 1727 +600 1949 +600 353911 +600 7731 +600167 159264 +600174 180804 +600240 174776 +600306 2308248 +60039 43276 +60050 250152 +600618 51851 +6007 6008 +60079 94502 +600795 121065 +6008 1510247 +60082 11072 +60082 42895 +600839 308023 +60086 57726 +60088 31540 +600882 157450 +600882 805034 +600952 1369642 +60096 60093 +600970 600973 +6010 546790 +6010 57715 +601137 805153 +601180 177899 +601180 545431 +601180 778759 +6013 182716 +6013 5284 +601419 371400 +6017 2070 +6017 67613 +601751 204190 +601787 309 +601787 31444 +601873 6698 +601918 282777 +601918 597210 +601960 423619 +602 2243 +60205 4513 +602057 551276 +6023 5539 +602401 1718 +602401 31444 +602422 375196 +602505 274894 +60263 1008919 +60263 164532 +60264 229155 +60265 31077 +60265 5531 +602797 17146 +6029 13407 +6029 3953 +602946 2043981 +602946 743753 +603 2089 +603068 426957 +603068 45503 +603068 880741 +603082 247972 +603134 1942744 +603134 376346 +60316 215585 +60316 37109 +603188 1770 +60329 204167 +603338 219565 +60338 45071 +60342 184421 +60342 292561 +60347 60348 +603542 108897 +603542 505061 +603569 366596 +603596 1552844 +603596 32695 +603603 993281 +60364 107444 +60364 115018 +60364 294537 +60364 34622 +60364 69673 +60364 76461 +60364 83832 +60364 93112 +603655 367899 +603660 626595 +60399 113945 +60399 60405 +604039 469029 +60405 177708 +604071 15501 +604071 52312 +604087 29210 +604103 1464125 +604156 1314079 +604156 2229189 +604156 842110 +604171 1022781 +604171 1888624 +604171 764732 +604171 885816 +6043 58193 +6043 8199 +6043 931502 +604310 272062 +60434 363938 +604396 1917218 +604396 283127 +604396 446577 +604396 532276 +604396 539272 +604396 552195 +604396 573239 +604396 623293 +604396 823061 +604396 832917 +604396 833033 +604396 833076 +604396 833168 +604396 833687 +604396 834073 +604396 835518 +604396 836429 +604396 842135 +604396 865050 +604396 95542 +60450 124497 +60451 211633 +60451 252998 +60451 265354 +604560 230338 +604629 1006985 +604629 2123355 +604629 828583 +604629 828588 +604629 922565 +604631 1066081 +604631 880725 +604669 604668 +60501 91946 +6054 142 +60546 234827 +605503 43099 +60556 622776 +605579 257306 +605579 406579 +60559 480949 +605607 605608 +605648 308329 +605648 554530 +605648 573683 +60567 79155 +605770 696447 +60580 1001576 +60580 21130 +60580 454858 +60580 57160 +605817 343502 +60584 255188 +60584 5705 +606027 1517502 +60606 21364 +606096 286517 +606128 956112 +606128 956113 +60615 10933 +606159 133866 +606175 479043 +606228 518265 +606332 24587 +60636 184001 +60636 691827 +60636 865784 +606388 1485495 +606388 3234342 +60644 1096 +606458 851319 +606593 626028 +60670 30031 +606742 606741 +606751 304114 +60678 146466 +60678 19515 +60678 25954 +606892 499708 +6070 72940 +607153 364256 +60719 33573 +607257 209053 +607257 2306710 +607257 3211839 +607257 3664403 +607358 715813 +607359 205808 +607404 1714225 +60742 1456077 +60742 237467 +60742 268369 +60742 297021 +60742 327863 +60742 718264 +6075 7511 +60753 177497 +607636 92999 +60776 88699 +6078 29921 +608005 450315 +608263 608262 +608482 833422 +608509 1795554 +6086 3868 +60864 1832511 +60864 366592 +60864 368390 +608657 1115338 +608657 2989950 +60872 159384 +60872 98671 +60877 251182 +60897 209173 +60901 35251 +60901 6520 +60903 122447 +6091 242007 +6091 372109 +6091 6747 +60916 106526 +60916 60917 +60917 577744 +6092 10147 +6092 109884 +6092 1499564 +6092 1603222 +6092 17203 +6092 22915 +6092 22958 +6092 45707 +6092 546203 +6092 5873 +6092 6648 +60921 416264 +609280 3711373 +60929 11438 +60947 8353 +609499 169989 +609735 2275321 +60978 109832 +60978 41767 +60978 48604 +60978 50997 +60978 53077 +60996 4348 +609975 227408 +609975 3901892 +610 1237083 +610044 713211 +610062 229527 +610347 2684 +610409 459824 +610409 918672 +610409 973168 +61048 219598 +61048 237795 +61048 238929 +61048 37356 +61048 61048 +61066 1150340 +61066 1399 +61066 160130 +61066 289089 +61066 333519 +61066 39507 +61066 4066 +61066 826081 +6107 128826 +6107 39428 +610718 1170269 +610733 63839 +610795 320276 +610798 844615 +610799 823061 +610799 882724 +6108 85462 +610802 1009232 +610802 1160362 +610802 2483583 +610802 406423 +610802 754958 +610814 365527 +61082 61083 +610874 144843 +610874 181207 +610877 1382085 +61088 1487111 +61088 2155036 +61088 2155038 +61088 24394 +61088 493793 +61089 15268 +61089 24394 +610983 1062085 +611121 611120 +611146 612349 +611146 628541 +61117 44314 +6112 23223 +6112 67097 +611233 82162 +61131 180785 +61131 42380 +61153 138859 +611675 119484 +611748 370606 +612 3361276 +612143 908662 +6122 20010 +61225 3909 +612256 697637 +61227 211067 +6123 14997 +6123 191755 +6123 191756 +6123 198427 +6123 20427 +6123 207517 +6123 25009 +6123 279253 +6123 31538 +6123 453144 +6123 48442 +6123 55539 +6123 58469 +6123 6244 +6123 8364 +6123 93386 +6123 95296 +612345 1583171 +612345 252868 +612348 612349 +612349 2728594 +612349 342217 +6124 15204 +6124 18187 +6124 20073 +6124 3293 +6124 37469 +61240 47841 +612452 1066948 +612452 194080 +612452 275575 +612452 612349 +612452 967417 +61250 41237 +612687 512763 +61270 23259 +61270 76656 +612709 268618 +61285 72565 +61296 61297 +61303 2807 +61303 93287 +6131 36624 +613166 189913 +613166 573731 +613166 928815 +613211 811092 +61323 553397 +61323 809123 +613247 75559 +613247 911494 +613277 2040848 +613277 2925821 +61338 568401 +61338 58584 +61339 143185 +613407 100457 +61342 167763 +61350 261971 +61350 382499 +613701 615794 +613711 571500 +613713 236425 +613750 1722522 +61386 317176 +61402 12596 +61402 194 +614195 1106816 +614195 527475 +614195 789941 +614195 995101 +6142 8275 +614222 1118166 +614222 733133 +61459 324921 +614613 834522 +614613 838776 +6148 15525 +61482 289263 +614963 376312 +6151 286486 +6151 47781 +61513 664376 +615181 7209 +615181 911372 +6152 338 +6152 45650 +6152 48385 +6152 6152 +6152 7220 +615351 1141597 +61543 403003 +615463 709175 +61556 104723 +61556 255163 +61556 35086 +6157 44402 +615829 542 +615837 84750 +61585 129805 +61585 142453 +61585 252308 +61585 252310 +61585 252998 +61585 259097 +61585 374022 +61587 265382 +61587 265422 +61588 29986 +61588 348049 +61588 3849015 +61588 391684 +61588 92798 +61588 95705 +61593 10472 +616 34008 +616 424 +616264 1604338 +61627 235223 +616271 475678 +61634 61724 +616468 1469058 +616468 2670978 +616469 616483 +616473 1281756 +61671 194802 +61671 195011 +616876 607191 +6169 147379 +6169 22540 +6169 4424 +616966 308022 +61701 20506 +6171 2111 +6171 2113 +6171 406490 +6171 551009 +6171 67661 +61710 568606 +617133 108565 +617133 1443685 +617133 153980 +617133 1543919 +617133 192325 +617133 202092 +617133 216140 +617133 226461 +617133 2323597 +617133 262940 +617133 269254 +617133 271877 +617133 27519 +617133 282137 +617133 294746 +617133 3174982 +617133 32180 +617133 374777 +617133 375279 +617133 435555 +617133 521381 +617133 696200 +617133 704150 +617133 833315 +617133 835190 +617133 837549 +617133 838226 +617133 839411 +617133 96123 +6172 420819 +6172 699308 +61730 829961 +61737 385106 +617404 351666 +617404 552195 +617404 604396 +617404 696267 +617404 832917 +617404 842888 +617404 865050 +617606 298561 +61768 564516 +61775 257572 +61779 150080 +6178 18410 +617888 417092 +617911 1053847 +6180 148674 +6180 57383 +618095 13879 +618095 302458 +618095 96155 +6181 25009 +6181 31548 +618227 91401 +61824 1600955 +61824 25718 +61824 2967 +61824 451168 +61825 1340143 +61825 334283 +61825 46467 +61825 4687 +618266 36122 +618266 372790 +61842 61843 +618429 1202712 +618429 342362 +61848 307882 +61852 61853 +618529 235179 +618543 1938588 +61860 36239 +61863 1725 +618655 184481 +61867 170527 +618728 1442016 +61873 50731 +61879 59168 +6189 27442 +618989 2187 +619076 244096 +61920 17862 +61920 19895 +61920 230642 +61920 446079 +61920 48354 +61920 96395 +61923 7991 +619297 9680 +6193 182870 +6193 56277 +61939 285423 +6194 165417 +6194 996640 +619426 66146 +619441 9040 +6197 1063698 +6197 1274002 +6197 13921 +6197 1399 +6197 1586788 +6197 16966 +6197 18964 +6197 191242 +6197 20490 +6197 21731 +6197 2269473 +6197 2428251 +6197 2737 +6197 29257 +6197 29358 +6197 308450 +6197 34465 +6197 402640 +6197 438783 +6197 456985 +6197 5911 +6197 713046 +6197 786590 +6197 804540 +6197 885103 +6197 885972 +6197 9070 +61972 20826 +6199 38852 +619946 506364 +62 1618158 +62 197327 +62 2035635 +62 61 +620186 108566 +620186 1960103 +620186 620186 +620186 95544 +620186 95546 +620186 981904 +620377 817146 +620547 665217 +620550 620551 +62056 712625 +620635 65603 +620726 1046942 +620726 108568 +620726 1259101 +620726 1933252 +620726 2394180 +620726 262940 +620726 283122 +620726 294746 +620726 304975 +620726 368137 +620726 451535 +620726 459665 +620726 534822 +620726 547969 +620726 547971 +620726 696188 +620726 696215 +620726 696225 +620726 759178 +620726 759182 +620726 823059 +620726 823063 +620726 832924 +620726 833686 +620726 833687 +620726 837498 +620726 842238 +620726 855709 +620726 864674 +620726 912555 +620726 958583 +620734 3430308 +620734 3430309 +620734 845760 +620763 620764 +62077 1546881 +62077 192192 +62077 24023 +62077 369619 +62083 21512 +62085 132315 +62085 174797 +62085 502843 +62086 166095 +62086 2476931 +620915 620916 +620939 33587 +620989 439312 +6210 20859 +621038 1239558 +621039 1954267 +621051 86702 +621175 1522709 +621175 1751713 +621175 2377022 +621175 347355 +621175 715301 +6212 13949 +6212 246950 +621227 139692 +621227 2608619 +62123 126320 +62125 1369609 +621262 1059249 +621262 817260 +621280 324193 +62130 319272 +62134 75187 +62139 373344 +621418 504263 +621441 388920 +62148 62148 +621483 806899 +62165 38337 +62165 715361 +622291 10079 +622365 1083141 +622365 637268 +62245 87717 +62265 22430 +622694 769995 +622822 1455923 +622822 546971 +622822 567073 +622822 781329 +622822 836647 +62286 223265 +6229 17392 +6229 1933184 +6229 24459 +6229 33870 +6229 414596 +6229 793291 +62292 602997 +623225 260010 +623293 1014466 +623293 1021948 +623293 1021949 +623293 1057191 +623293 1079561 +623293 1081196 +623293 1109393 +623293 1122328 +623293 1141685 +623293 1142516 +623293 1246887 +623293 1498432 +623293 1550010 +623293 1582977 +623293 1671768 +623293 1709638 +623293 1733209 +623293 1833723 +623293 192325 +623293 224329 +623293 2383328 +623293 2433785 +623293 260744 +623293 262940 +623293 269254 +623293 27519 +623293 283122 +623293 299702 +623293 303060 +623293 366820 +623293 368137 +623293 379809 +623293 388185 +623293 395913 +623293 397616 +623293 39874 +623293 406273 +623293 406281 +623293 424576 +623293 435555 +623293 442174 +623293 454293 +623293 472036 +623293 479033 +623293 479036 +623293 497542 +623293 510013 +623293 517144 +623293 517158 +623293 517163 +623293 522209 +623293 522210 +623293 523642 +623293 526579 +623293 526590 +623293 532086 +623293 547969 +623293 547971 +623293 617404 +623293 620726 +623293 659779 +623293 688716 +623293 691665 +623293 696188 +623293 696225 +623293 696257 +623293 696260 +623293 704150 +623293 754894 +623293 754974 +623293 759182 +623293 784121 +623293 809856 +623293 823061 +623293 832661 +623293 832900 +623293 832917 +623293 832962 +623293 832992 +623293 833073 +623293 833097 +623293 833293 +623293 833376 +623293 833686 +623293 833687 +623293 833697 +623293 833710 +623293 833840 +623293 834088 +623293 834227 +623293 834229 +623293 834611 +623293 835073 +623293 835112 +623293 835518 +623293 835650 +623293 835735 +623293 835927 +623293 836084 +623293 836588 +623293 837450 +623293 837533 +623293 837568 +623293 838409 +623293 838588 +623293 839082 +623293 841441 +623293 842233 +623293 842888 +623293 843513 +623293 843529 +623293 844606 +623293 855056 +623293 855065 +623293 857118 +623293 859452 +623293 861499 +623293 864672 +623293 864674 +623293 871278 +623293 871323 +623293 880957 +623293 881437 +623293 882022 +623293 882946 +623293 883257 +623293 883689 +623293 883777 +623293 896804 +623293 899625 +623293 900807 +623293 913525 +623293 914907 +623293 951326 +623293 951327 +623293 958583 +623293 984186 +623293 990454 +623293 999914 +623295 227630 +623555 623554 +6236 307738 +623870 243615 +623870 250386 +623870 623870 +623870 988751 +623956 124884 +623974 577022 +623974 594278 +624129 120331 +624129 545359 +624129 638662 +624317 1163478 +6244 140923 +6244 347731 +6244 366060 +6244 57817 +624416 1093579 +624467 867459 +624564 340834 +62462 140937 +62462 20762 +624682 1270165 +6247 18854 +624749 283469 +624805 696473 +624825 1036076 +625039 625040 +62507 414001 +62507 72186 +62507 84023 +625125 1512075 +625638 825043 +625638 900448 +625650 1012357 +625650 1083537 +62568 1200017 +62571 2807479 +6259 162779 +625997 282137 +625997 532265 +625997 542122 +625997 696169 +625997 838930 +625997 926720 +62616 16577 +626175 1092565 +626175 1393151 +626175 216140 +626175 252669 +626175 299702 +626175 318243 +626175 344166 +626175 361595 +626175 388185 +626175 539272 +626175 703268 +626175 715381 +626175 796660 +626175 833128 +626175 835066 +626175 846301 +626175 850894 +626175 857117 +626175 868929 +626175 869054 +626175 890223 +626175 895152 +626175 92243 +62621 655795 +62623 12921 +6264 3368403 +6264 3368404 +6264 602291 +62649 190278 +62649 5981 +626500 17448 +626571 1536171 +626571 2077734 +626749 12764 +626853 1335388 +626853 46003 +626853 670247 +626853 825245 +626853 964255 +626853 964282 +626941 1117265 +627 1562243 +627 56925 +627 58556 +6270 3753336 +6270 7552 +627128 1157491 +627128 1183157 +627128 397616 +627128 833179 +627128 843127 +627165 416443 +62735 1166641 +62735 159515 +62735 7620 +6274 16794 +627442 1001725 +627442 1010199 +627442 1015406 +627442 1028502 +627442 1041164 +627442 1053192 +627442 1114048 +627442 1251615 +627442 1259101 +627442 1262335 +627442 1284343 +627442 1476577 +627442 153980 +627442 1547175 +627442 1605317 +627442 1908562 +627442 206281 +627442 2168635 +627442 224329 +627442 2307193 +627442 260744 +627442 262940 +627442 271870 +627442 27519 +627442 283122 +627442 289522 +627442 299702 +627442 310038 +627442 361074 +627442 374006 +627442 377139 +627442 379809 +627442 380036 +627442 388185 +627442 395913 +627442 397617 +627442 406281 +627442 454293 +627442 479036 +627442 497542 +627442 502826 +627442 523982 +627442 526590 +627442 538821 +627442 561054 +627442 578737 +627442 653535 +627442 657113 +627442 696225 +627442 704150 +627442 712500 +627442 754974 +627442 809856 +627442 829984 +627442 832915 +627442 832962 +627442 833179 +627442 834101 +627442 834611 +627442 834646 +627442 835518 +627442 835735 +627442 835739 +627442 836487 +627442 836546 +627442 836547 +627442 838447 +627442 841356 +627442 844418 +627442 846180 +627442 846301 +627442 849674 +627442 849793 +627442 849795 +627442 867852 +627442 867946 +627442 882022 +627442 883689 +627442 933312 +627442 999914 +627536 207520 +627536 8503 +627678 390961 +627678 906010 +627699 2186403 +627699 2186404 +62770 36870 +62775 75937 +627773 639531 +628016 877202 +62804 63839 +628056 361802 +628056 628057 +6282 16480 +62821 8052 +628237 1385352 +628237 1790630 +628237 2409926 +628237 32196 +628237 333892 +628237 526576 +628237 747740 +628237 828564 +628237 834398 +628363 237888 +62839 441605 +6284 39115 +6284 5762 +6285 69536 +628541 612349 +6286 1147294 +6286 1147295 +6286 13778 +6286 163457 +6286 180204 +6286 217869 +6286 497448 +62865 1299 +62865 54919 +62865 62866 +628737 1377315 +628737 2457407 +628826 84557 +628936 907223 +628944 9179 +629080 3268921 +62919 580244 +6292 105 +62927 79684 +629395 190128 +62947 97135 +62950 62947 +629545 212299 +6296 194 +6296 235911 +62964 68852 +629726 884799 +629745 1211550 +62977 9457 +629772 887641 +629779 629780 +629810 213344 +62991 18063 +62991 417613 +629911 722965 +62999 7278 +6300 59312 +63005 347506 +63005 8222 +630056 282524 +63011 10890 +63015 56016 +63019 1788992 +63019 44021 +63023 365243 +630262 1534734 +630262 1703326 +630262 1731191 +63032 63033 +630344 183523 +630512 1484434 +630531 341452 +630531 901455 +630636 3232965 +630765 1202353 +630765 1528152 +63078 394092 +630837 3137617 +630837 583252 +630837 849774 +630844 736606 +630850 225076 +630857 645331 +630876 381181 +63119 1224348 +63126 63128 +631436 1039407 +63145 14468 +631450 491799 +631458 1308419 +631458 514541 +631488 314212 +631582 631583 +631586 832962 +631586 838972 +631586 877525 +631637 2754252 +631647 753999 +63168 547157 +631742 201677 +63182 103238 +63183 1399 +63183 185223 +63183 189 +631959 1540042 +63199 167643 +63199 72657 +63205 106427 +63205 16614 +63211 232309 +63213 14894 +63220 11575 +63220 225223 +63220 24532 +63227 1060184 +63227 169412 +63227 211297 +63227 64259 +63227 82343 +63230 107560 +63230 115089 +63230 444808 +63230 444809 +63230 63658 +632334 455230 +63234 202318 +63234 20958 +632347 159657 +63239 271667 +63239 615460 +632429 238501 +63257 212598 +6326 130152 +6326 6286 +63260 1274864 +63262 62423 +632633 926040 +63268 208805 +63268 39207 +632706 143217 +632706 1487635 +632830 50890 +6329 4296 +633077 74543 +633161 212299 +633161 339755 +633161 470264 +633161 633162 +633162 212299 +633162 339755 +633282 1468981 +633282 239566 +633282 663652 +63331 63434 +63332 21742 +63332 38561 +63332 42875 +633447 579926 +633461 360255 +63347 88690 +63349 1105056 +63366 29105 +63379 165627 +63379 381 +633966 935098 +633986 214236 +633986 58426 +634 1096231 +634 222785 +634 2259816 +634 24056 +634 253144 +634 329124 +634 385924 +634 483740 +634 66358 +63407 2789800 +6341 342648 +634102 1337025 +63436 15728 +6344 337535 +6344 609753 +6344 74359 +6344 930886 +6344 960582 +63447 134626 +6347 23070 +6348 63758 +634808 175228 +634965 988323 +634996 1178444 +635174 635173 +635342 635347 +6354 320082 +63579 133830 +635801 138038 +635801 58014 +63603 26120 +63603 437662 +6361 56546 +63617 328094 +63617 370045 +6362 135657 +6362 188997 +6362 230338 +6362 52000 +6362 561261 +6362 65950 +6362 73456 +63626 798366 +636298 376075 +636299 376075 +636299 636298 +636316 180252 +63636 134401 +63639 72540 +6365 10628 +6365 5168 +6365 57844 +636633 636632 +636636 2701234 +636649 72846 +6367 27350 +636714 922770 +6370 134510 +63700 3909 +63700 61225 +63700 85929 +63708 63701 +63717 33528 +637191 306466 +637197 237156 +6372 36187 +63729 63730 +6373 11099 +63738 194438 +637417 197123 +63742 1942531 +637469 187052 +637494 901810 +637520 1151662 +63758 1004075 +6376 1672188 +6376 2541 +6376 303594 +6376 410990 +6376 42917 +6376 47174 +6376 507625 +6376 74543 +637603 1308580 +637603 921271 +637608 1399 +637609 637608 +637623 196795 +637623 629020 +63768 426142 +63768 74930 +63768 84065 +63771 63771 +63771 81368 +63771 9746 +63774 62571 +637760 597757 +6378 204817 +637804 271667 +637804 3805 +637804 53980 +637804 63239 +63788 80916 +638058 1795305 +6381 2801647 +638212 234200 +63835 574360 +63839 125226 +63839 162849 +63839 186871 +63839 86464 +638392 1644729 +63840 83520 +638466 126166 +638466 430816 +638466 44364 +638466 856680 +63854 73783 +638593 1309382 +638654 370290 +638707 73083 +638707 911467 +638732 1933252 +638732 283122 +638732 451535 +638732 696215 +638732 703271 +638732 754974 +638732 833128 +638732 859024 +638732 859045 +638732 861476 +638732 941850 +63879 60166 +63882 7841 +638918 96303 +639286 873561 +639351 3091107 +639355 331103 +639379 1914722 +63938 315897 +6394 169764 +6394 25737 +639480 840014 +6395 199228 +6395 288457 +63961 63962 +6397 455886 +63977 116601 +63977 1876517 +63977 1876518 +63977 191569 +63977 2202673 +63977 223869 +63977 230645 +639808 1432818 +639808 1432819 +639808 1432820 +639808 1432822 +639808 576683 +639840 1565297 +639840 2166221 +639840 847372 +639840 935812 +639890 266408 +63991 43077 +639960 261451 +639960 835521 +639992 327863 +640070 2635482 +640098 775968 +64010 1057809 +64010 1088982 +64010 183427 +64010 394909 +64010 597094 +640398 887157 +64059 118974 +640632 1335787 +640632 253297 +64064 118958 +64064 160688 +64064 17443 +64064 64066 +64064 91761 +64066 1005136 +64066 238440 +64066 50840 +640762 310369 +640853 640854 +640855 787057 +64094 10504 +641164 108439 +641164 460621 +641164 835073 +641164 844416 +641164 882809 +641198 3209 +6412 10511 +6412 215985 +641234 1194870 +641250 260744 +641250 2610194 +641250 283127 +641250 446105 +641250 459673 +641250 526592 +641250 552195 +641250 646857 +641250 688716 +641250 833792 +641250 873272 +641250 899626 +641350 996926 +641466 261801 +64152 71583 +641563 2458626 +641654 3376124 +64171 646224 +641778 264998 +641793 37246 +641874 804789 +641936 749752 +64194 11887 +642129 1111611 +642129 341073 +64216 117350 +64229 193060 +64229 419323 +64238 64613 +6425 130971 +6425 17398 +6425 382464 +642510 2164420 +642532 1369554 +642532 806902 +64259 302694 +64259 3296945 +64259 3649 +64259 72727 +6428 20188 +64309 209467 +643153 205808 +6433 982558 +643319 309844 +643319 406673 +64344 204686 +64344 237539 +643485 299702 +643485 388185 +643509 199023 +64351 198702 +643584 3152981 +643613 1129490 +643613 1196088 +643613 2310352 +643613 2808101 +643613 72922 +643621 1654441 +643621 559497 +643847 271923 +643847 52753 +64403 167557 +64403 370771 +644101 144131 +644101 288082 +644112 27952 +644140 1403714 +644140 795180 +644141 832962 +644141 835735 +644271 100313 +644271 9967 +644288 31439 +644288 334143 +64429 213258 +644291 31439 +644291 334143 +644291 45392 +644291 644288 +64431 51721 +644384 517145 +644470 604563 +644470 826584 +644545 1369554 +644576 1443299 +644625 2919007 +64469 4810 +644726 843323 +644726 843325 +6449 1110 +64495 373583 +645 10994 +645 17597 +645 2175841 +645 50885 +645 859227 +645106 2876796 +645106 806256 +645127 113916 +645144 1395201 +645208 361539 +645279 1063696 +645669 260727 +64568 3990 +645709 571086 +645709 658995 +645741 1114557 +645741 154285 +645741 853983 +64579 113663 +64590 16318 +64590 187440 +646 22421 +64613 1539603 +64613 430279 +64628 617359 +64634 15611 +646367 719077 +64646 218175 +646485 1739574 +646485 71825 +6465 216503 +646579 3180930 +64664 151458 +64669 134674 +64671 421761 +64674 117723 +64674 161063 +64674 1675223 +64674 296055 +64674 70851 +64674 90210 +64674 93921 +64680 106541 +64680 1336031 +64680 1349880 +64680 3273144 +64680 419076 +64680 459762 +64680 500546 +64680 88496 +64680 91912 +64683 29895 +64683 82211 +646857 260744 +646857 526592 +646860 833697 +646860 833698 +646860 838145 +646882 1282905 +6469 244211 +64692 5491 +64694 1056903 +64694 135930 +64694 145256 +64694 145264 +64694 1667027 +64694 267186 +64694 268552 +64694 290874 +64694 29977 +64694 303209 +64694 30486 +64694 311734 +64695 2345555 +64695 434393 +64695 434396 +64695 434401 +646981 22291 +647 5168 +647 6365 +647025 647024 +64706 15885 +64715 192030 +647195 1027989 +647195 1471362 +647195 2976204 +647195 439663 +647195 714002 +647195 821985 +647195 833814 +647195 854513 +647294 626175 +647294 715381 +647295 956329 +64734 64735 +64735 411692 +64735 94504 +64737 208455 +64737 302046 +64737 64735 +64739 106651 +64739 115863 +64739 194 +64739 237516 +64739 25870 +64739 288366 +64739 29821 +64739 386863 +64739 64739 +64739 77811 +647464 122418 +64748 86618 +647526 896980 +647624 647626 +647673 38744 +647680 3657 +647733 177342 +647733 212001 +647733 252669 +647733 490279 +647733 490290 +647733 547971 +647733 626175 +647733 784121 +64774 53529 +64775 85490 +6478 172927 +6478 44752 +6478 71736 +647839 398361 +647843 1056488 +647843 1138200 +64791 37412 +64798 41222 +648030 448007 +648030 448010 +648030 956952 +648053 299191 +648053 829659 +648081 1025076 +648081 1138217 +648081 2000491 +648081 2808213 +648086 445910 +648086 583394 +64813 878166 +648314 436292 +648350 1245897 +64836 1330438 +648364 541957 +648375 905458 +648439 2816869 +648567 1223177 +648567 1277801 +648567 27519 +648567 517144 +648567 691665 +648567 809856 +64858 64859 +648775 301733 +648811 1007085 +648817 229104 +648861 941690 +64890 5314 +648964 1484827 +649 131517 +649000 1831675 +649000 704150 +649043 649044 +649368 113411 +64943 146233 +64943 64735 +64943 734865 +64946 19669 +649501 22497 +649584 649582 +649585 834088 +649585 835650 +649617 188054 +649661 649666 +649836 272157 +649877 113798 +649877 155335 +649877 227947 +64988 174233 +649891 649876 +649968 2737027 +650137 1022367 +650343 55745 +65048 124892 +65048 21128 +65048 217039 +65048 29059 +65049 31715 +65059 424131 +650601 517156 +650716 870326 +650767 191013 +650767 668913 +65081 14017 +65086 7166 +650960 152369 +650960 359449 +650975 650977 +65099 10937 +65099 130180 +65099 16677 +65099 305 +65099 65099 +65099 733736 +651 109688 +651 117094 +651 1176201 +651 127076 +651 142665 +651 143352 +651 152279 +651 18404 +651 194782 +651 2160 +651 2308 +651 372312 +651 651 +651 78507 +651 952798 +651 99262 +6510 2320 +651011 24056 +65104 112615 +65104 11573 +65104 167892 +65104 220884 +65104 32921 +65104 417057 +65104 58549 +65104 72540 +65112 87990 +651190 33752 +65120 501552 +65122 75775 +651255 3637547 +651255 99821 +651407 651412 +651504 2035635 +651504 3699319 +651512 651513 +651790 334787 +651790 651792 +651792 334787 +65181 102834 +65181 86533 +65182 3012919 +6520 39677 +6520 52833 +6521 224903 +6521 34955 +652120 1409447 +652120 953560 +652175 619441 +652175 9040 +652190 348307 +652190 866973 +65224 810674 +65224 8185 +65228 1926 +65238 10682 +652664 307970 +652773 492059 +6530 9064 +65303 205908 +653095 262940 +653095 769508 +653149 240056 +65317 105862 +65317 119546 +65317 17591 +65317 233061 +65317 28082 +65317 30138 +65317 314100 +65317 3924 +65317 43485 +65317 5064 +65317 77086 +65317 77813 +65317 87300 +653252 504950 +653252 800128 +65331 75920 +65331 79095 +653366 325501 +653366 653368 +653368 325501 +653370 325501 +653370 653366 +653370 653368 +653372 832926 +653372 833687 +653372 846277 +65347 180846 +6536 199567 +6536 3184 +65362 1615037 +653628 207191 +653629 169481 +653629 654406 +653629 701516 +65367 256868 +65367 65368 +65368 256868 +65370 1186 +65370 154352 +65370 516516 +65370 65370 +65370 70171 +65370 83715 +65377 10780 +65384 29546 +653899 1140208 +653899 374522 +653899 45392 +6540 10377 +6540 152529 +6540 1759362 +6540 2182940 +6540 2285615 +6540 245229 +6540 338586 +6540 797904 +65407 1068 +654149 1172962 +654181 233499 +65421 326902 +654249 972801 +654249 982794 +65427 244961 +65429 51168 +6544 77787 +654409 1334353 +654451 1234866 +654451 1987301 +654451 696188 +654451 696237 +654451 833765 +654451 985192 +654453 1385924 +654453 1891014 +654453 1933252 +654453 351666 +654453 459676 +654453 542501 +654453 683885 +654453 696215 +654453 696266 +654453 696267 +654531 1014245 +654531 1179182 +654531 2047034 +654531 3272744 +654531 584423 +654531 876050 +654659 314742 +654659 512764 +65479 1194528 +65479 55124 +6548 85863 +65486 23469 +655064 1232494 +655077 1934636 +65508 39573 +65516 2751101 +65516 71419 +655270 1055630 +655270 1798623 +655270 499563 +655270 526416 +655270 851414 +655270 978211 +65536 5595 +655514 1300661 +655616 1353403 +655616 454293 +65565 74647 +65565 77638 +655695 655697 +65591 65592 +655928 364529 +655962 459530 +65611 1362597 +656111 534074 +65623 2805 +65626 258392 +65629 32434 +65629 8718 +656335 278654 +6564 79684 +65640 250109 +65642 594801 +65645 3956 +65645 48347 +656650 58870 +656760 229185 +65677 24775 +65677 268923 +656770 1107867 +656785 178908 +656829 274874 +656869 1009447 +656869 1147100 +656869 1165562 +656869 1208452 +656869 1208455 +656869 1640328 +656869 170759 +656869 179709 +656869 2129819 +656869 406283 +656869 696257 +656869 754974 +656869 833628 +656869 837550 +656869 837674 +656869 889836 +656869 905491 +656869 973041 +656869 986112 +65694 65703 +65695 541895 +65696 87901 +65696 90993 +65705 341417 +65710 261932 +65710 32203 +657106 1259725 +657259 272114 +65726 689140 +65726 689141 +65739 65740 +65740 198937 +65740 3299232 +657473 215380 +65749 338616 +657574 95544 +657574 95546 +6577 2737 +6578 740538 +65784 127828 +65784 604435 +65788 177209 +65788 41910 +65795 837442 +65795 960900 +65796 108568 +65796 1157619 +65796 1269513 +65796 1270472 +65796 1346429 +65796 1419770 +65796 1732861 +65796 1788026 +65796 1788027 +65796 2176903 +65796 229566 +65796 252872 +65796 356317 +65796 376031 +65796 415725 +65796 424276 +65796 517156 +65796 532276 +65796 570542 +65796 650601 +65796 671328 +65796 700443 +65796 740149 +65796 779780 +65796 779781 +65796 832962 +65796 833722 +65796 835731 +65796 836063 +65796 836105 +65796 836106 +65796 836114 +65796 836115 +65796 836151 +65796 836156 +65796 836379 +65796 836894 +65796 836895 +65796 837442 +65796 837589 +65796 837660 +65796 842641 +65796 844443 +65796 875353 +65796 875368 +65796 877523 +65796 879156 +65796 897150 +65796 897153 +65796 960912 +65796 960940 +65796 962497 +65796 998335 +658056 1920569 +65807 610798 +65809 35980 +65824 66963 +6583 168925 +65839 336136 +65839 44205 +658480 1003471 +658543 306954 +658545 1458942 +658545 1801211 +658545 938452 +658660 1098484 +65876 55325 +65877 368845 +65880 165082 +658891 506503 +65891 1820598 +658942 237220 +65906 2264 +65907 203219 +65907 629037 +65907 80357 +65918 319635 +659202 127789 +659202 659204 +659204 127789 +659329 17199 +65939 193299 +65939 34746 +65939 36231 +65939 70377 +65939 82248 +65950 606901 +659588 1395153 +659646 803803 +659779 834088 +659848 872051 +659911 279922 +659976 659984 +660 134073 +660 33801 +660 355 +66008 926686 +6601 111582 +6601 11434 +6601 14998 +6601 17389 +6601 25009 +6601 279253 +6601 31428 +6601 571547 +6601 58108 +6601 60399 +6601 66882 +6601 8364 +66020 448196 +660202 1568110 +660203 1759832 +660203 26 +660365 94850 +660455 1455774 +660617 2644568 +660620 2516209 +660620 3833228 +660620 690594 +660669 276336 +66074 66070 +66089 1661125 +66089 247495 +66089 418233 +66089 631194 +66089 695636 +660927 355659 +660927 62245 +660927 87717 +660939 578802 +660989 208801 +661 117041 +661 2730 +661 288956 +661 5087 +661 5113 +661 86975 +66106 364191 +6611 677698 +661121 1612259 +661121 330164 +661121 402925 +661121 661122 +661122 1612259 +661122 330164 +661122 402925 +661223 328159 +66128 400233 +66136 3173573 +66136 669685 +661378 451506 +661389 108566 +661389 716084 +661389 836185 +661389 855218 +661389 864379 +661389 915271 +6614 51908 +66144 1552032 +66144 297515 +66144 487132 +66146 1545071 +66146 1580725 +66146 1873178 +66146 194652 +66146 3287432 +66146 8666 +66147 1005259 +66147 13869 +66147 207103 +661484 661485 +66152 4030 +66153 12466 +66153 14014 +66153 81419 +66154 100756 +66154 109832 +66154 145858 +66154 173081 +66154 173399 +66154 175380 +66154 31777 +66156 56073 +66162 183323 +66186 338 +662 160680 +66208 66209 +66209 115886 +66209 154919 +662168 1216065 +662168 2042826 +662168 224329 +662168 2365801 +662168 2498725 +662168 262940 +662168 269254 +662168 374006 +662168 415725 +662168 424576 +662168 454293 +662168 496703 +662168 527161 +662168 550341 +662168 561054 +662168 700443 +662168 738843 +662168 833235 +662168 833851 +662168 834226 +662168 834389 +662168 835730 +662168 837661 +662168 850385 +662168 855761 +662168 859448 +662168 867974 +662168 95543 +66219 28630 +66219 54879 +662226 1666151 +662226 228411 +6625 209173 +6625 258218 +6625 60897 +66261 35055 +6627 101876 +6627 266134 +6627 29345 +6627 30133 +66277 127932 +66282 357411 +66297 1636742 +66310 1204849 +66310 1204851 +66310 416808 +66310 750194 +663288 596766 +663496 2681401 +663496 712518 +663504 1471860 +663504 538821 +663504 754974 +663531 965424 +66358 261932 +66358 32203 +66358 65710 +66358 91947 +6636 15707 +66373 60316 +663736 516624 +663736 903637 +663807 976122 +663821 1172547 +663821 773474 +66385 101096 +66388 89261 +66394 93391 +6641 1660 +66417 31777 +66417 32000 +66417 39909 +66417 423973 +6644 1108480 +664489 637195 +664496 1960042 +664499 476366 +664508 664507 +66452 32388 +664685 1023 +664685 1672478 +664685 2187 +664685 513794 +664896 2780795 +6650 1596 +6650 8971 +665037 299084 +66509 57393 +66510 239875 +66510 64866 +665298 842826 +6653 19408 +66541 141638 +66541 41964 +66552 13087 +66552 1607925 +66552 223986 +66552 2282006 +66552 357054 +66552 568679 +66552 654697 +66552 8982 +665527 524248 +66607 143509 +6662 11085 +666208 2148860 +666481 666480 +666508 2241400 +666508 2241401 +666508 990584 +666552 95537 +666566 1130607 +66661 237665 +666667 1986303 +6667 1294033 +6667 178822 +6667 8412 +66670 17551 +666728 1133490 +6669 310 +6669 743073 +66694 103211 +6671 230788 +6671 9979 +667265 300673 +66727 52834 +667284 1416607 +667284 1416610 +667284 1695075 +66730 762 +66733 1054362 +66733 10754 +66733 11785 +66733 124158 +66733 1471533 +66733 1949839 +66733 298861 +66733 436743 +66733 73336 +66733 810205 +667486 1585055 +667495 977700 +667503 833098 +667503 833446 +667503 859036 +667503 921168 +667579 48766 +6676 6677 +66764 535865 +66764 54719 +667684 194 +6678 2318 +6678 6676 +66781 120233 +66781 3470 +66781 99511 +66792 394067 +6681 103387 +6681 70908 +6681 72025 +66810 190328 +668144 324595 +66817 58593 +66824 35125 +66824 52835 +66834 66823 +66839 66385 +66851 21946 +66851 236447 +66851 261 +66851 82028 +66852 11538 +66852 5873 +668802 400679 +66882 14987 +66882 60399 +66883 10425 +66883 113284 +66883 166838 +66883 382935 +668917 1441992 +668917 2674308 +668917 57811 +668917 654531 +6691 22720 +669210 1731720 +669413 260980 +669418 260980 +669418 669413 +66955 70669 +66963 58483 +669685 1081790 +669730 299702 +669730 388185 +669777 199908 +669777 2421931 +669777 2512105 +669907 570566 +66993 308054 +669957 19799 +669958 2090164 +67003 417696 +670246 942953 +670307 8201 +6706 2823436 +670668 299702 +670668 744723 +670668 744724 +670668 754974 +670668 832905 +670785 4614 +6708 142962 +6708 142970 +6708 2787987 +6709 286952 +6709 3137 +670944 1039313 +670944 1100690 +670944 1266573 +670944 1269737 +670944 1344857 +670944 676272 +67097 23223 +671093 69237 +671327 1029398 +671327 1356055 +671327 356317 +671327 65796 +671327 671328 +671327 836105 +671327 836445 +671327 836622 +671327 836665 +671327 837582 +671327 837875 +671327 842641 +671327 844160 +671327 845160 +671327 897153 +671327 960940 +671328 1029398 +671328 1283441 +671328 1492272 +671328 1551275 +671328 356317 +671328 834088 +671328 835060 +671328 835927 +671328 837583 +671328 841787 +671328 870792 +671328 900884 +671328 95537 +671331 1109391 +671331 1324365 +671331 1539851 +671331 356317 +671331 361805 +671331 834088 +671331 835060 +671331 835650 +671331 835927 +671331 836063 +671331 836065 +671331 845154 +671331 845156 +671331 845160 +671331 883952 +67136 114879 +6714 32394 +671422 281042 +671430 1517635 +671430 388328 +67144 502962 +671495 667603 +67154 302811 +67154 491601 +67156 1658226 +67194 87771 +6720 6274 +672090 1069138 +672090 1399657 +672090 147379 +672090 193918 +672090 21340 +672090 672090 +672090 87443 +672090 9166 +67218 24023 +67218 2532 +67218 2816801 +67218 462261 +67218 4825 +67218 75129 +67218 90037 +67226 3219 +67226 7554 +672508 462603 +672565 1150441 +67264 512042 +672659 672661 +672822 1057232 +672887 346130 +673003 1364203 +673012 158604 +673012 410921 +673014 471003 +67303 103097 +67304 3293 +6731 6501 +6731 6818 +673106 1348062 +673106 1358232 +673121 933569 +673141 1193845 +673141 854722 +673266 424754 +673330 1949337 +67346 232000 +67347 289196 +67352 12887 +67352 164195 +67352 526739 +67356 1399 +6736 178539 +6736 340 +67369 91708 +673789 92011 +673820 54918 +673820 672102 +673857 666552 +673902 1144196 +673902 1417089 +673902 2107493 +673902 870314 +673902 870324 +673962 77593 +674 1 +674257 1409382 +674310 399093 +674310 8990 +674310 933581 +674330 2503337 +67435 36402 +674429 801554 +67449 2394 +674503 198011 +674531 171298 +67456 145312 +67456 487822 +6747 128056 +6747 16095 +6747 16676 +6747 241248 +6747 56442 +6747 6747 +6747 6891 +6748 6748 +6748 736132 +6748 9165 +67481 15204 +67481 20231 +67481 350901 +67489 4954 +6749 2328 +6749 243126 +6749 3536626 +6749 6749 +674941 1224088 +67498 391745 +675 1143621 +675 1503050 +675 1732204 +675 32603 +675 3435215 +675 366360 +675 58277 +675 65950 +675 675 +675033 1197033 +67512 3065886 +67526 237151 +675270 338450 +675270 925226 +6753 10472 +6753 13667 +6753 2096 +6753 37359 +6753 46667 +67536 82480 +675498 1602833 +675561 336069 +67567 187709 +675683 484917 +675921 494669 +675921 504753 +675921 565770 +675921 714903 +67597 1308430 +676 1356 +676012 14427 +67618 144074 +676265 502047 +676265 758172 +676265 946752 +676266 298469 +676271 2014345 +676271 2014346 +676421 658288 +676421 676422 +676422 658288 +676432 376312 +676432 614963 +676433 696150 +676433 837765 +67656 2111 +67657 267135 +67657 361592 +67657 572068 +67657 82294 +676647 76395 +676679 7029 +676872 899834 +676877 768934 +67691 67692 +67703 511658 +67745 298577 +67749 210555 +67749 42015 +677545 883310 +67770 99024 +67783 41077 +677959 9845 +678149 232956 +678149 36100 +678163 678171 +678177 15569 +678182 400202 +678236 508219 +678387 395900 +678408 314520 +67856 1212610 +6787 580903 +678716 965528 +67905 65983 +679203 631701 +67931 913889 +67942 21742 +679490 1473723 +67951 87622 +67959 21560 +67959 29819 +67959 67930 +679614 1221488 +679673 679674 +679723 185176 +67979 59756 +68002 255665 +68003 2929 +68003 516701 +680046 768546 +680111 1640967 +680149 617606 +680218 86163 +6804 15205 +680514 223545 +680514 450442 +680514 870899 +6806 150454 +68076 132225 +6808 6605 +680977 765967 +681015 681014 +68108 39503 +68108 57640 +6811 25639 +6811 74848 +68116 619123 +681200 1470268 +681226 1539360 +68133 551482 +68137 47317 +68137 5949 +68140 388288 +681409 10937 +681409 16095 +681520 341324 +68153 105791 +68166 362251 +681677 148308 +681724 327877 +681724 612345 +68174 75094 +6818 6501 +68181 32915 +68181 9070 +681935 21763 +682132 1181067 +682132 785726 +68225 132231 +68225 453805 +68225 5732 +68225 92172 +68241 181527 +682447 270088 +682695 794468 +682739 1631706 +682822 1060687 +68297 140369 +68297 60707 +683052 13187 +683078 972831 +683136 836948 +683151 17640 +683277 1462004 +683292 318371 +68332 111851 +68349 115680 +68349 14361 +68349 68350 +683750 674531 +68377 1051496 +68382 50249 +683841 1226497 +683870 3078 +683885 1004365 +683885 1010527 +683885 1092492 +683885 1385924 +683885 1511355 +683885 1891014 +683885 1933252 +683885 2661644 +683885 351666 +683885 446577 +683885 451535 +683885 459665 +683885 517158 +683885 526411 +683885 542501 +683885 573235 +683885 573239 +683885 617404 +683885 696215 +683885 696267 +683885 833071 +683885 833168 +683885 833543 +683885 833667 +683885 833787 +683885 837063 +683885 837498 +683885 842585 +683885 941850 +683940 446471 +68405 456694 +68405 68334 +68406 109746 +684263 2951126 +684263 890593 +68430 189913 +68430 346868 +68430 573731 +68430 613166 +68430 928815 +684313 684314 +684531 692646 +684583 506382 +68461 20099 +68464 121721 +684678 321494 +684690 98165 +6847 1100148 +6847 110428 +6847 1376532 +6847 247924 +6847 30264 +6847 33332 +6847 52052 +6847 52221 +6847 68465 +6847 7230 +6847 72532 +6847 98332 +68487 276635 +685055 1615988 +685055 2090482 +685056 105802 +68506 7969 +68525 33918 +6853 16926 +6853 1997976 +6853 234200 +6853 35146 +6853 43653 +685360 1232228 +685411 156406 +685620 1168037 +68571 154738 +686012 1324268 +686012 1324299 +686012 2920559 +686012 629483 +686030 114493 +68607 425 +686071 1453290 +686084 1116868 +686084 774957 +686173 251752 +68627 177713 +68635 68633 +686626 942710 +68674 23446 +686746 39388 +686906 47101 +68704 142646 +68704 1791730 +687089 786587 +6872 27731 +6872 39219 +68720 236427 +687220 1144390 +687270 110995 +687270 476221 +68730 76322 +687399 1405007 +687399 596566 +687400 2074951 +687454 3584037 +687533 687534 +687832 1631648 +687865 230238 +6879 3394 +687942 687945 +688 1859453 +688 20464 +688 234383 +688 240890 +688002 1559800 +688034 2439150 +688034 688034 +688034 754974 +688034 832989 +688042 1385928 +688042 170760 +688042 269254 +688042 406271 +688042 406285 +688042 543206 +688042 578737 +688042 833108 +688042 835735 +688042 859447 +688051 82048 +68807 80134 +68812 68813 +68817 52567 +688231 29956 +68851 167495 +688706 1806381 +688706 688704 +688716 1294869 +688716 1441830 +688716 1630688 +688716 262940 +688716 304975 +688716 415720 +688716 446105 +688716 552195 +688716 784121 +688716 833686 +688716 833687 +688716 833697 +688716 834051 +688716 844606 +688716 845359 +688716 851589 +688716 873272 +688716 939230 +68898 103223 +689082 149569 +689099 261568 +689140 689141 +689243 898894 +689319 689320 +689524 209846 +689607 1153378 +68961 249964 +68969 2017 +689705 278198 +689816 825898 +689818 566502 +689818 772187 +68996 6959 +690028 1068721 +690028 1391155 +6901 118999 +6901 2153 +69014 10994 +69023 75592 +690277 438610 +690355 1655388 +69047 242236 +6905 54479 +690545 87460 +690594 2516209 +690825 2111866 +69088 44018 +69088 99793 +690972 1110063 +690972 153980 +690972 2688955 +690972 395913 +690972 406271 +690972 406285 +690972 696257 +690972 841357 +6910 25647 +69107 1720857 +69117 16677 +69117 44429 +691181 25718 +691345 533610 +691352 816488 +69143 2327332 +691539 768080 +69158 69157 +69163 2323 +691665 1049945 +691665 1110062 +691665 1110063 +691665 153980 +691665 1547175 +691665 1636229 +691665 1921649 +691665 1928057 +691665 324481 +691665 341147 +691665 644726 +691665 690972 +691665 704150 +691665 735032 +691665 832915 +691665 837570 +691665 843323 +691665 843325 +691665 861499 +691665 870833 +691665 885845 +69170 14135 +69170 31955 +69170 45503 +6918 199 +691827 184001 +691885 1057111 +6919 1412153 +6919 183427 +6919 2961668 +6919 6919 +6919 98308 +692 3114209 +692006 559220 +69205 134908 +69205 472725 +69205 977533 +69205 977534 +692063 697237 +69209 272461 +6921 14461 +692192 692193 +69225 5705 +692330 1132659 +692330 555263 +69235 17392 +69235 19632 +69235 31425 +69235 48270 +692423 2383885 +69248 179989 +692587 758953 +69269 135635 +69269 189905 +69269 43095 +69269 96379 +69273 12627 +692755 369576 +692755 418852 +692755 418854 +69284 7382 +693 182014 +693 2187 +693 3805 +693 397774 +693 694 +6930 4982 +6930 6952 +693015 1277895 +693188 2311165 +693188 546809 +69319 6212 +693239 372478 +693240 411550 +69330 34551 +693420 607538 +693434 693423 +693437 716206 +693536 2836610 +693537 570296 +693671 9373 +693681 426224 +69375 17970 +69375 635399 +69387 17897 +69387 182063 +69387 24778 +693912 247522 +694 44300 +694 813949 +69414 22076 +694189 298851 +69422 112933 +69422 2211510 +69422 42852 +69430 13811 +69433 51368 +694377 545489 +694454 1095405 +69449 325888 +6945 10686 +6946 5593 +694685 1119078 +694685 1299163 +69471 258006 +69482 41957 +69487 69488 +695 371006 +695003 1183147 +695003 148999 +695003 1523681 +695003 2006245 +695003 2232539 +69501 257383 +69501 31843 +69501 31844 +69508 262623 +69508 28278 +69526 1319 +6953 48354 +695322 518391 +695322 695323 +695344 18967 +69539 400196 +69549 20195 +6955 5276 +695537 1803233 +695689 962052 +695706 916462 +69576 104459 +69576 35833 +69576 694070 +695772 280875 +695772 5595 +69589 69589 +69589 91014 +69589 9796 +6959 650 +6959 8099 +696 1097433 +696 195157 +696 2087 +696 2432 +696 403202 +696 45191 +696 697 +696 9104 +696 92264 +696039 71500 +696126 984438 +696134 623293 +696134 834101 +696139 1027810 +696165 517163 +696165 704150 +696165 833686 +696165 95546 +696168 3488542 +696168 795017 +696169 1294345 +696169 1908726 +696169 2492982 +696169 2518110 +696169 2532965 +696169 2542688 +696169 282137 +696169 525469 +696169 532265 +696169 532270 +696169 542122 +696169 704150 +696169 835733 +696169 853477 +696169 862694 +696169 883123 +696169 926720 +696169 961426 +696169 982123 +696171 1899278 +696171 260744 +696171 283122 +696171 349296 +696171 543206 +696171 836184 +696171 837502 +696171 837545 +696171 837660 +696171 838400 +696171 838407 +696171 850906 +696171 861690 +696171 95546 +696181 1040777 +696181 1066447 +696181 1229978 +696181 1341603 +696181 1341604 +696181 1344131 +696181 1377659 +696181 1430196 +696181 170760 +696181 1728368 +696181 1919176 +696181 1931864 +696181 1931865 +696181 1971571 +696181 1971580 +696181 1971583 +696181 2357523 +696181 283122 +696181 761898 +696181 833698 +696181 841593 +696181 859046 +696181 870173 +696181 896995 +696181 900979 +696181 973041 +696181 973042 +696181 988712 +696182 573235 +696182 593620 +696182 833553 +696182 837062 +696188 1051616 +696188 1146034 +696188 1173606 +696188 1234866 +696188 1259101 +696188 1300808 +696188 1328725 +696188 1341603 +696188 1507460 +696188 1511355 +696188 1652194 +696188 1728371 +696188 1966189 +696188 1987301 +696188 394796 +696188 439664 +696188 456764 +696188 526591 +696188 683885 +696188 696134 +696188 696150 +696188 696165 +696188 706861 +696188 725144 +696188 823061 +696188 823063 +696188 832934 +696188 833376 +696188 833543 +696188 833765 +696188 833787 +696188 834101 +696188 837060 +696188 838929 +696188 841436 +696188 844422 +696188 850067 +696188 855072 +696188 864674 +696188 865655 +696188 95546 +696188 980515 +696188 985192 +696192 283122 +696192 754974 +696192 839514 +696192 855072 +696193 1341603 +696193 1377659 +696193 1578164 +696193 1636340 +696193 1640327 +696193 2645574 +696193 271870 +696193 403890 +696193 526591 +696193 736606 +696193 754974 +696193 833626 +696193 833826 +696193 838930 +696193 844418 +696193 854230 +696193 855057 +696193 855063 +696193 855065 +696193 855073 +696193 855170 +696193 865655 +696193 986112 +696199 454293 +696199 833376 +696200 2323597 +696200 271877 +696200 289522 +696200 397620 +696200 704150 +696200 835518 +696200 841441 +696200 887610 +696206 1004365 +696206 451535 +696206 573239 +696206 683885 +696206 696215 +696206 833667 +69621 415336 +696211 1055630 +696211 1426704 +696211 1798623 +696211 2452795 +696211 2452796 +696211 303060 +696211 446577 +696211 499563 +696211 526409 +696211 526416 +696211 655270 +696211 833446 +696211 833686 +696211 837498 +696211 850889 +696211 851414 +696211 880609 +696211 882033 +696211 931244 +696211 978211 +696215 1004365 +696215 1010527 +696215 1236436 +696215 1385924 +696215 1651128 +696215 1891014 +696215 1898666 +696215 1950815 +696215 261451 +696215 262940 +696215 2661644 +696215 269254 +696215 2757394 +696215 283122 +696215 3138900 +696215 351666 +696215 444606 +696215 445532 +696215 446105 +696215 517165 +696215 526592 +696215 532273 +696215 542501 +696215 573235 +696215 573239 +696215 575046 +696215 617404 +696215 696134 +696215 696267 +696215 704150 +696215 774485 +696215 796211 +696215 833071 +696215 833076 +696215 833173 +696215 833553 +696215 833664 +696215 833666 +696215 833824 +696215 834577 +696215 835518 +696215 835733 +696215 835968 +696215 837063 +696215 837498 +696215 837520 +696215 837529 +696215 839085 +696215 841590 +696215 842585 +696215 849477 +696215 851344 +696215 858380 +696215 858475 +696215 859024 +696215 859036 +696215 859045 +696215 861476 +696215 865655 +696215 865661 +696215 869694 +696215 882026 +696215 895152 +696215 899898 +696215 933757 +696215 941850 +696215 948628 +696215 973039 +696220 1587380 +696220 170759 +696220 2129819 +696220 2207653 +696220 538821 +696220 577808 +696220 833554 +696220 833826 +696220 837674 +696220 841593 +696220 855065 +696220 899898 +696220 900979 +696224 1259101 +696224 355 +696225 1061521 +696225 1094847 +696225 1337833 +696225 1376703 +696225 192325 +696225 1938047 +696225 2460882 +696225 260744 +696225 270225 +696225 283123 +696225 283125 +696225 283127 +696225 394796 +696225 448007 +696225 465889 +696225 517158 +696225 517165 +696225 706861 +696225 833161 +696225 833560 +696225 833687 +696225 833697 +696225 842238 +696225 846296 +696225 855072 +696225 857318 +696225 858577 +696225 864674 +696225 872743 +696225 890414 +696225 973391 +696237 1234866 +696237 1987301 +696237 696188 +696237 833765 +696237 985192 +696238 1043208 +696238 1336426 +696238 3247926 +696238 3269719 +696238 730302 +696238 846292 +696238 855971 +696253 1022025 +696253 1064107 +696253 1726080 +696253 260744 +696253 744723 +696253 754974 +696253 833163 +696253 833554 +696253 833560 +696253 838400 +696253 850906 +696253 855072 +696253 899693 +696257 1291352 +696257 2129819 +696257 262940 +696257 395913 +696257 712500 +696257 837674 +696257 982126 +696257 999914 +696260 192327 +696260 239236 +696260 27519 +696260 406281 +696260 696260 +696260 837548 +696266 459673 +696266 459674 +696266 459676 +696267 351666 +696341 2911050 +69646 64837 +696575 1181067 +696575 682132 +696575 785726 +696581 82702 +696632 696631 +69673 2454 +69673 2485676 +69673 284821 +69673 294537 +69673 59906 +696761 236484 +696848 1094720 +697 26579 +697 437471 +69702 722249 +697035 1409418 +697136 2153273 +697233 2771094 +697233 365447 +69737 153085 +69737 153106 +69737 154358 +69737 154381 +69737 192978 +69737 64646 +697453 1562443 +697453 164263 +697453 261801 +697467 702265 +697682 1147583 +697691 843883 +697718 51171 +697732 1152605 +697732 1696713 +697732 540358 +69778 69348 +69788 23739 +697980 1068751 +697980 168684 +698 24432 +69817 1846423 +69817 337062 +69817 378229 +69817 701741 +698298 698299 +698605 698702 +698606 1621054 +69875 69866 +69877 131837 +69877 2629950 +69877 538141 +698795 446483 +69890 17413 +698927 1039625 +698927 1143318 +698927 26955 +698927 296745 +698927 567511 +698927 799352 +698927 925650 +6990 15027 +699031 208130 +699109 699104 +699161 134080 +699163 1832511 +699163 60864 +69922 176527 +699430 1688840 +69953 190551 +699597 541242 +699597 54910 +699806 1604929 +69989 856 +7 4683 +700 230888 +700 459984 +700 99415 +700038 700037 +7001 49888 +70018 44808 +700247 283407 +70028 77660 +700429 699781 +700443 1831675 +700443 262940 +700443 415725 +700443 649000 +700443 704150 +700443 832962 +700443 835731 +700443 838409 +700443 839696 +700443 855761 +700443 877520 +700443 877523 +700443 877524 +700443 877779 +700443 895780 +700477 1603031 +700477 1797331 +700477 2271322 +700521 1314971 +700540 1990239 +700585 11390 +7007 180837 +7007 5486 +70078 48134 +700820 427749 +70087 209923 +70087 90245 +700902 80916 +70091 2594698 +700941 746947 +701 13094 +701 153276 +701 32022 +701 701 +701 887654 +7010 14988 +7010 17392 +7010 53865 +7010 60399 +7010 6229 +701009 2330584 +70103 1136154 +70106 459516 +70124 196579 +701295 1295432 +70152 112052 +70156 35650 +7016 380714 +7016 49036 +701608 690012 +701741 337062 +70176 69778 +70199 246971 +702 2511 +702 303027 +702 37718 +702 5243 +702013 57627 +702310 1295103 +702316 702315 +70234 2051909 +70236 10788 +70236 1619611 +70236 40583 +702379 496776 +702379 496777 +702578 660126 +702591 472213 +702591 662254 +702591 749581 +702591 756847 +7027 37416 +7027 37717 +702795 2051086 +70281 2924899 +70284 120331 +702844 288358 +7029 209093 +7029 2433602 +703094 1265892 +70325 20 +703268 1751436 +703268 192325 +703268 260744 +703268 283122 +703268 490777 +703268 913209 +703269 1456449 +703269 146216 +703269 843912 +703269 900110 +703269 99438 +703271 108566 +703271 281455 +703271 355662 +703271 361814 +703271 397617 +703271 715381 +703271 823061 +703271 833168 +703271 840391 +703271 841436 +703271 843513 +703271 858380 +703271 868929 +703271 880957 +703271 908890 +703271 999914 +7035 147707 +7035 172240 +7035 2749 +7035 30207 +7035 7028 +70351 17550 +70351 19701 +70351 75127 +70351 77180 +70351 82784 +703539 1021215 +703539 115463 +703539 1205712 +703539 1218161 +703539 1368030 +703539 1774492 +703539 192322 +703539 2212800 +703539 375279 +703539 452918 +703539 497542 +703539 534822 +703539 623293 +703539 641164 +703539 665298 +703539 734491 +703539 832962 +703539 835735 +703539 844416 +703539 884530 +703543 752152 +70359 221201 +703690 166504 +703690 909410 +703720 2528642 +703723 1760968 +70379 217441 +703849 703758 +703861 1809083 +70392 427984 +70392 427985 +704042 486627 +704042 555263 +704150 1249311 +704150 1437991 +704150 2281098 +704150 397616 +704150 39874 +704150 517158 +704150 538821 +704150 696134 +704150 754894 +704150 832915 +704150 832917 +704150 834073 +704150 835518 +704150 836487 +704150 839080 +704150 841441 +704150 842233 +704150 869570 +704150 92243 +704157 1383097 +70428 70429 +704310 472940 +7044 31215 +704596 805336 +704599 298561 +704599 633801 +704602 704603 +704749 25872 +704749 288656 +70486 28009 +70486 4488 +704936 670983 +70509 1971255 +70509 243738 +70518 252082 +70518 278928 +70518 391909 +70518 48347 +70518 609518 +705188 500270 +70519 268963 +70519 327489 +705201 1359692 +705201 561049 +70526 120312 +70526 257025 +70526 265387 +7059 4911 +705928 2938387 +706063 778097 +706071 421370 +706258 349489 +7066 15064 +706601 1202355 +706601 3127508 +70668 2364661 +70669 652998 +706774 1345894 +706774 257966 +706774 44937 +706861 262940 +70697 13855 +70697 231726 +706982 583339 +70704 116129 +70730 162018 +707379 1023799 +70745 2264 +7075 31215 +70757 82499 +70766 68431 +70768 146465 +70774 70775 +707931 36080 +70802 289110 +708025 1140522 +708064 84907 +708144 1376703 +708144 448007 +70829 223473 +708290 556172 +708316 468738 +7084 7089 +708460 1037835 +708460 2019666 +708460 931403 +708508 12819 +70851 117723 +70851 166289 +70851 77813 +708608 244096 +708613 1218036 +708613 1384411 +708613 605648 +708613 916936 +70864 31938 +70867 18123 +70867 312774 +70871 37165 +708817 97545 +708895 312358 +7090 10916 +70900 36400 +70909 15824 +70909 233366 +70915 235664 +70915 29215 +709198 45650 +709329 367670 +709478 168597 +709478 263 +709478 5633 +709478 688821 +709478 92947 +709594 1655278 +7098 1087230 +7098 318234 +7098 619950 +7098 6562 +7098 74531 +7098 75305 +7098 91384 +709876 147389 +709876 377663 +7099 227979 +71 25320 +7100 2825 +7100 8880 +71004 119782 +710109 1151551 +710109 1616 +710109 200642 +710109 224115 +710109 3055 +710109 610718 +710204 352830 +710204 372380 +71042 108557 +71042 1105842 +71042 1910747 +71042 71041 +710480 135121 +710790 2733213 +71100 32486 +71100 80706 +71104 115743 +711106 115461 +71117 2332 +711307 2695777 +71137 60987 +7116 125203 +71171 170825 +71171 197878 +71171 32216 +71171 380583 +71171 506682 +71171 5616 +711724 1172628 +7118 120307 +71187 18231 +711924 711923 +712 153406 +712132 1265292 +712132 293990 +712270 1046946 +712270 442174 +712270 448008 +712270 823065 +712270 832942 +712270 835066 +712270 988713 +71237 2053 +71237 42370 +71238 9177 +712469 21517 +712469 787939 +712486 1348996 +712500 115467 +712500 119484 +712500 1249311 +712500 227870 +712500 2281098 +712500 260744 +712500 39874 +712500 406281 +712500 415720 +712500 578743 +712500 626175 +712500 704150 +712500 744724 +712500 762680 +712500 834073 +712500 839080 +712500 872098 +712501 144053 +712504 658079 +712518 1204949 +712518 960547 +712540 264649 +71266 1540042 +71266 631959 +712683 456898 +712753 928089 +71280 34574 +712800 1156977 +712800 855494 +71294 250933 +71294 72649 +713186 1475965 +713240 1635724 +71326 67940 +7133 33891 +713338 982122 +713343 397676 +713448 11579 +71346 316410 +71346 71346 +713503 713499 +713519 1236553 +713519 2066290 +713519 522269 +713519 833217 +713519 836666 +713639 174771 +7137 194 +71386 10969 +713989 1395637 +714002 1471362 +714002 821985 +714074 1037403 +714074 254091 +714074 254841 +714074 870314 +714466 47188 +71447 159826 +71447 29262 +71447 97069 +714502 1047248 +714502 333535 +714502 7278 +714502 924623 +71473 193578 +714752 238929 +71480 163939 +714903 504753 +714903 565775 +714942 201185 +71499 57839 +715021 86252 +715094 521766 +71518 71519 +71519 20610 +71521 232888 +71521 593963 +715243 135912 +715243 339220 +715274 29809 +715274 871139 +715301 1027989 +715301 1274375 +715301 1471362 +715301 1751713 +715301 406271 +715301 406285 +715301 439663 +715301 647195 +715301 714002 +715301 725023 +715301 821985 +715301 848470 +715301 873546 +715301 884545 +715301 973802 +715724 715721 +715813 1143103 +715821 285160 +715831 715832 +716 673106 +716 7862 +71606 145048 +716069 1415599 +716069 283473 +716069 523633 +716069 846277 +716069 905483 +716069 931349 +71608 226341 +716084 1899278 +716084 349296 +716084 696171 +716084 838400 +716084 861690 +716097 1576518 +716139 162564 +716139 1841563 +7162 688275 +716206 339107 +716313 2088451 +716316 679880 +716316 929298 +716361 2303607 +716373 1085256 +71643 71644 +71651 82947 +71668 267077 +7168 35738 +716831 712132 +716987 1163242 +71701 144413 +717072 1299107 +717163 1011793 +717163 263854 +717167 263 +717213 1252894 +717213 37028 +717283 27515 +717288 1284343 +717288 1284345 +717288 216140 +717288 27519 +717288 342543 +717288 456926 +717288 696188 +717288 706861 +717288 809856 +717288 95542 +717288 95543 +717614 1289580 +717614 33203 +717762 717761 +71789 2027 +71789 24564 +71789 250926 +71789 2967 +71789 3363 +71789 45191 +71825 1739574 +718264 237467 +718264 268369 +718264 297021 +718340 1394577 +71844 199818 +71844 622365 +718775 333892 +718775 526576 +718775 628237 +718786 131998 +71881 176943 +71881 5914 +718833 110156 +718833 1143663 +718833 1484953 +718833 2083189 +718897 5114 +719020 624805 +719020 696473 +719348 659455 +719349 530555 +719501 191993 +719501 473097 +719588 1995593 +71979 161183 +71979 25449 +71979 512580 +7198 39300 +720 2648 +720 3788 +720 520 +720045 843851 +720330 720329 +720364 220770 +7204 115715 +7204 27044 +72068 420761 +72071 102027 +7209 265767 +7209 460023 +7209 52312 +7209 784725 +7209 784727 +7209 911372 +7209 94901 +720966 340525 +720977 1568356 +7211 3322 +72111 1831 +72111 39635 +721137 193276 +7212 14954 +7212 334659 +7212 398203 +7212 3990 +7212 46860 +721225 379503 +721225 44792 +721228 32491 +721228 410869 +721228 908004 +7213 10197 +7213 1284 +7213 13533 +7213 2893 +7213 3243 +7213 52655 +7213 78105 +7213 86788 +7213 86877 +7213 87014 +721331 373377 +721331 455099 +72134 109146 +72134 23508 +72134 36180 +721420 795 +721499 2103864 +721841 600601 +72186 113696 +72186 185137 +72186 318863 +72186 73368 +722046 531464 +722105 101289 +722105 24422 +72236 35551 +72236 79754 +72240 70605 +722422 890202 +722712 132084 +722712 209748 +722712 26246 +72277 72278 +72277 72279 +72278 72279 +722803 4296 +722882 152096 +7230 72532 +72306 122153 +72306 137860 +72306 1497 +72306 907753 +72308 58349 +723244 434744 +723245 434744 +723245 723244 +723436 26828 +723451 884182 +723468 2229924 +72348 302803 +72353 4476 +72358 42454 +723595 34364 +723915 723916 +72401 93207 +724097 2951126 +724097 684263 +724097 890593 +72412 145201 +72412 83807 +72435 176881 +724418 623418 +724445 173615 +724445 296709 +724445 340650 +724445 466362 +72458 7321 +72461 44944 +7247 19762 +7247 36247 +724823 724822 +725 11017 +725 474434 +725042 115467 +725133 573701 +725144 1146034 +725144 832934 +725144 912553 +725144 986222 +725217 832673 +72525 21139 +72526 332424 +7253 185613 +7253 797983 +7253 9070 +725310 1226706 +725310 211461 +725310 47464 +72532 51175 +72535 23223 +72535 42099 +725526 3326876 +7256 7035 +7256 8254 +7256 93056 +7257 4116 +7257 42994 +72579 85524 +725884 2208854 +72589 499635 +725940 1170915 +725940 13785 +725940 1813397 +725940 2411981 +725940 361214 +725940 783873 +725952 209173 +725952 349231 +725980 2293943 +726 2839 +72614 196904 +72619 97039 +726259 854575 +726307 108020 +726311 675629 +72637 108387 +726468 23223 +72657 11575 +72657 167643 +72657 18382 +72657 20427 +72657 213721 +72657 216448 +72657 38225 +72657 72657 +7266 37850 +72671 18085 +72671 194652 +72672 34316 +72672 54520 +726742 948064 +726794 1181868 +726794 3477 +726834 1546133 +72702 72703 +727038 3730174 +72713 119012 +72713 57857 +72735 527571 +727416 59775 +727416 670 +727427 731262 +72758 307882 +72758 61848 +727590 1392750 +727590 1564753 +727590 1702929 +727590 2365887 +727590 357753 +727590 438783 +72765 15620 +72765 350741 +72765 541242 +72765 54910 +72765 699597 +7278 49209 +727921 727922 +727951 285231 +727988 2264293 +727988 236193 +727988 303594 +7280 413087 +7280 67309 +728026 757006 +72806 11787 +728069 745855 +728069 745856 +728087 931818 +72809 229071 +72809 59651 +72810 25501 +728361 1043922 +728361 1097417 +728361 696225 +728361 871496 +728361 890414 +728484 590200 +728564 84839 +728668 560755 +728668 668326 +728699 1328316 +728731 2878702 +72881 45127 +728828 122381 +728828 397479 +728874 1745542 +7289 40754 +729169 1295466 +7292 20977 +7292 4683 +72922 1196088 +72922 388410 +72936 12344 +72936 23223 +7294 233316 +7294 426971 +7294 98041 +729605 833811 +729646 1192841 +729646 1436793 +729646 1468646 +729646 1552022 +729646 1619482 +729646 1827219 +729646 2413299 +729646 262940 +729646 397620 +729646 406281 +729646 703539 +729646 833842 +729646 835518 +729646 855061 +729646 861690 +729646 926717 +7297 1139 +7297 36012 +72988 28942 +7299 8266 +72994 19944 +72994 39039 +72998 10937 +72998 1635 +72998 72998 +730 3280368 +730 89660 +730004 108439 +7301 42124 +73014 104559 +73014 75616 +73014 91823 +730184 223491 +730302 1336426 +730302 3247926 +730306 842078 +730309 730306 +730309 834521 +730309 842078 +730309 931316 +730309 95544 +73035 61830 +73037 73146 +73038 54312 +730426 1997041 +73044 14403 +73044 384330 +730570 170037 +73075 82508 +730767 2430631 +73083 73044 +73083 911467 +73086 149441 +73086 1665910 +73086 437609 +7309 6740 +73092 73093 +731 16478 +73108 232592 +731100 257585 +731131 48370 +731131 835555 +73121 280681 +73128 132088 +73128 626273 +73128 672102 +73139 12883 +73139 1883401 +7314 4844 +73140 73365 +731416 1404047 +731416 1421398 +731416 834330 +731416 909193 +731416 909961 +73142 104991 +731512 587006 +731774 433360 +73185 16700 +731853 1496564 +731853 754998 +73187 108652 +73187 1507277 +73187 3162408 +73187 36506 +73194 151145 +73202 110089 +73202 215585 +73202 37109 +73202 42189 +73202 60316 +73202 73202 +7321 255129 +7321 255882 +732215 1676585 +732324 1035864 +732324 624129 +732482 1032262 +732482 1044334 +732482 1058170 +732482 1092467 +732482 115469 +732482 1204589 +732482 1206836 +732482 1211021 +732482 1325919 +732482 1336426 +732482 1477182 +732482 2129597 +732482 2553659 +732482 262940 +732482 283122 +732482 283127 +732482 333892 +732482 368137 +732482 377139 +732482 395913 +732482 435555 +732482 490279 +732482 490290 +732482 502825 +732482 517144 +732482 547971 +732482 604396 +732482 645741 +732482 712500 +732482 754974 +732482 822473 +732482 832924 +732482 833787 +732482 833842 +732482 834229 +732482 834378 +732482 835073 +732482 835112 +732482 835187 +732482 842233 +732482 842888 +732482 848066 +732482 852709 +732482 854161 +732482 857108 +732482 861690 +732482 899356 +732482 899625 +732482 900180 +732482 917611 +732482 92243 +732482 931244 +732482 933743 +732482 944044 +732482 95537 +732482 997191 +73258 52958 +73279 572127 +73283 19179 +733 167108 +733 3337 +733 44914 +733 929880 +7331 241134 +73313 70365 +733150 1458 +73319 113713 +73329 915199 +733345 274753 +733546 798933 +73368 218800 +73368 428594 +734082 1722154 +734088 1378200 +734088 322918 +734116 1181833 +734132 108023 +734163 290063 +734171 149759 +734171 894822 +73423 576439 +734276 1387873 +734276 1999103 +734276 2357923 +73438 189933 +73441 195852 +73445 156079 +734491 1026736 +734491 1032225 +734491 1631888 +734491 2108156 +734491 2354081 +734491 2619913 +734491 262940 +734491 2691464 +734491 2785956 +734491 361626 +734491 361628 +734491 368137 +734491 716069 +734491 779781 +734491 833217 +734491 836115 +734491 837442 +734491 842641 +734491 842643 +734491 842645 +734491 844416 +734491 845763 +734491 846277 +734491 849062 +734491 870792 +734491 896249 +734491 931349 +734504 472936 +734504 820025 +73456 123954 +73456 135657 +73456 175695 +73456 184400 +73456 188997 +73456 526150 +73456 689818 +73463 73368 +734669 271903 +734700 218601 +734815 445144 +734815 569650 +73490 198113 +73490 286092 +73490 333950 +73490 54312 +734935 1056207 +735032 1110062 +735032 1110063 +735032 153980 +735032 690972 +73538 12879 +73538 92801 +735380 517414 +735380 558104 +73564 253031 +73564 84214 +735741 1770911 +736 19733 +736221 97992 +736338 938666 +736468 754360 +73659 73660 +736604 339765 +736605 262940 +736606 119083 +736606 1393151 +736606 2027433 +736606 446471 +736606 703268 +736606 834395 +736606 835184 +736606 850067 +736606 855057 +736606 882946 +736606 919149 +736606 926723 +736665 89493 +736695 924392 +736721 253462 +736721 297021 +736721 41904 +736820 514367 +7369 140632 +7369 49853 +7369 544765 +736924 1574456 +736932 1932404 +736982 352964 +73701 116103 +737070 56799 +73722 73723 +73738 810618 +7374 204819 +7374 29163 +7374 83333 +73754 84192 +73754 90882 +737541 378635 +737541 8090 +737573 3571298 +737607 877125 +73764 982 +737719 311327 +737798 457062 +737802 362271 +73785 429860 +7379 111423 +7379 117816 +7379 76045 +737925 1031230 +737925 1409738 +737925 1951772 +737925 1951773 +737925 2124113 +737925 472036 +737925 490279 +737925 490290 +737925 834057 +737925 834378 +737925 838200 +737925 838203 +737925 900807 +737925 934732 +7383 30362 +7383 7408 +73842 440281 +73842 610902 +73842 62209 +738499 66144 +7387 30362 +7387 7383 +738767 261483 +738784 2363636 +738784 738784 +738843 867974 +739 22798 +7390 25699 +7390 99946 +73920 74158 +73920 98521 +73920 98524 +739211 1223456 +739211 1899171 +739211 310182 +739240 18142 +739364 3779584 +739364 739366 +739366 3779584 +73937 22759 +73937 63977 +73959 24204 +73959 9003 +7396 216971 +739729 2503864 +739941 318371 +739941 532265 +739941 683292 +739941 836116 +739941 960926 +739949 301733 +739949 648775 +74 177156 +74 309638 +7400 13358 +7400 20401 +7400 20657 +7400 20660 +7400 37469 +7400 99294 +740067 2285752 +74010 121059 +740149 1269513 +740149 1270472 +740149 1346429 +740149 1419770 +740149 229566 +740149 424276 +740303 1093579 +740303 455272 +740303 624416 +740534 1162891 +740538 280716 +74073 48865 +74079 40550 +74120 103307 +74120 164111 +74120 202812 +741377 1032769 +741473 1420240 +741473 2323245 +741473 2539915 +74153 146475 +741665 2156973 +74174 330932 +74197 1380092 +74197 249799 +74204 78271 +74210 258749 +74210 260898 +74210 272756 +74210 342874 +74210 473211 +74213 200369 +74213 274429 +74213 339736 +74213 567934 +74213 73251 +742152 310509 +742152 64680 +742154 115863 +74231 242467 +742569 43470 +74304 16824 +743063 1027989 +743063 180634 +743063 224329 +74322 815854 +74326 92264 +743289 582002 +743340 528372 +74359 1616 +74359 2156 +74359 335241 +74359 379951 +74359 383308 +74359 930886 +743613 266349 +743613 29990 +743643 58774 +743697 427094 +743697 797729 +743704 1340656 +743704 1370946 +743704 1419770 +743704 3149322 +743704 712268 +743704 833185 +743704 844450 +743704 850224 +743704 858834 +743704 880947 +743704 960926 +743705 1340656 +743705 1370946 +743705 1419770 +743705 3149322 +743705 361592 +743705 519934 +743705 743704 +743705 833185 +743705 834088 +743705 834703 +743705 835927 +743705 844675 +743705 858834 +743705 880947 +74374 38362 +743753 2043981 +743826 498438 +743941 743938 +7440 18692 +7440 358430 +744146 49742 +74417 294533 +7442 1189804 +744263 274208 +744355 1291459 +744368 1053523 +7444 18424 +7444 28525 +74440 5455 +74455 50249 +744723 260744 +744724 1450655 +744724 164477 +744724 226461 +744724 262940 +744724 304975 +744724 3525078 +744724 3525079 +744724 3525080 +744724 377139 +744724 415720 +744724 424576 +744724 599488 +744724 744723 +744724 833128 +744724 833554 +744724 835066 +744724 858480 +74481 278726 +744837 63033 +7449 5648 +744968 32915 +74516 96051 +74521 281063 +74531 2124395 +74531 2372015 +74531 318234 +74543 944717 +745507 539440 +74564 1100 +745695 745694 +745855 745856 +74589 38870 +74599 289800 +7461 1299251 +746194 809575 +746370 746374 +746374 832429 +746564 888701 +74672 74392 +74672 80130 +746944 5087 +747 120532 +747 672770 +747070 286 +74726 74727 +747260 747263 +7473 125642 +7473 1319 +747400 275371 +747472 820886 +74755 3555983 +747560 2649154 +747560 870326 +74772 356276 +74772 723844 +74772 74772 +747740 1523149 +747740 2409926 +747767 1123728 +747767 324866 +747767 37906 +747927 245423 +748051 1606986 +748132 1223880 +748211 155521 +748263 1949191 +748399 1289005 +748468 81896 +748478 1046015 +74856 26420 +748582 56948 +74863 27011 +74871 85976 +748731 723587 +74874 14813 +748951 378086 +749007 748994 +749007 976242 +749252 1344180 +74937 100430 +74937 224268 +749473 1439392 +74960 1162365 +74960 363087 +74974 176943 +749771 409891 +749777 250494 +749792 97498 +7498 32388 +74981 56426 +75 22219 +750 20195 +750 57796 +750 774 +750 871 +75001 6009 +750093 1089748 +750093 1151343 +750093 436743 +750153 746370 +750194 1204849 +750194 1204851 +75026 306321 +750444 378091 +75062 95823 +750661 14956 +750709 53179 +7508 7505 +75099 75100 +751 834 +751025 1879338 +751051 763402 +7511 185 +7511 3363 +7511 87227 +751197 16375 +751197 281992 +751197 454293 +751197 548225 +751201 1609513 +751201 1801296 +751263 759544 +75127 19701 +75127 82784 +7514 3517515 +751499 2324642 +751499 883380 +751505 1205848 +751505 253245 +751505 262940 +751505 311048 +751505 532273 +751505 716084 +751505 754894 +751505 795195 +751505 837534 +751505 838401 +751505 843433 +751505 848263 +751505 850892 +751505 850893 +751505 861489 +751505 862836 +751505 862837 +751505 862840 +7518 39159 +75184 341355 +75187 2045467 +75187 21574 +75187 2273460 +75187 961313 +7519 137519 +751999 1159325 +752 327243 +752067 1040122 +752125 406251 +7522 34435 +752250 260958 +7525 210998 +752589 238001 +7527 60166 +75280 194 +75280 706160 +7530 57193 +75301 78093 +75305 318234 +75305 74531 +75312 1256150 +75312 75409 +75312 763687 +75315 1208686 +75315 267596 +75315 275499 +75315 316217 +75315 504613 +75315 630512 +75315 652406 +75315 801432 +75315 910228 +75316 1287320 +75316 756978 +75320 1608845 +75320 301627 +75331 55364 +75331 75584 +75336 42757 +75345 320770 +753549 843285 +753634 1099725 +753821 531461 +753865 899779 +753880 753884 +753949 485897 +753949 769522 +754 170635 +754 17317 +754 17422 +754 18471 +754 20635 +754 213936 +754 215559 +754 21667 +754 29105 +754 5720 +754 78966 +754150 228272 +754485 841439 +754485 900378 +7545 31109 +754547 984042 +754732 837881 +754732 917612 +754732 974043 +75474 353835 +75474 3899223 +754781 111645 +754894 1037859 +754894 1053170 +754894 1420649 +754894 1710606 +754894 253245 +754894 260744 +754894 269254 +754894 283127 +754894 299702 +754894 339754 +754894 397620 +754894 448010 +754894 502826 +754894 517158 +754894 627442 +754894 716084 +754894 784121 +754894 832915 +754894 832917 +754894 833315 +754894 834229 +754894 834378 +754894 835518 +754894 837568 +754894 841660 +754894 842238 +754894 842888 +754894 846970 +754894 855759 +754926 2011057 +754929 551147 +754958 1009232 +754958 2483583 +754969 754977 +754974 1057191 +754974 1064108 +754974 1173606 +754974 1569389 +754974 2093291 +754974 262940 +754974 283122 +754974 299702 +754974 368137 +754974 397619 +754974 465982 +754974 466144 +754974 517165 +754974 526592 +754974 538821 +754974 573239 +754974 696238 +754974 696260 +754974 716084 +754974 754974 +754974 795171 +754974 814478 +754974 823061 +754974 826840 +754974 832768 +754974 832942 +754974 832951 +754974 832989 +754974 833033 +754974 833128 +754974 833155 +754974 833168 +754974 833549 +754974 833554 +754974 833560 +754974 833736 +754974 833886 +754974 834229 +754974 836124 +754974 838930 +754974 842888 +754974 843513 +754974 845358 +754974 846970 +754974 852345 +754974 855072 +754974 859036 +754974 861484 +754974 865048 +754974 865055 +754974 865654 +754974 865655 +754974 865659 +754974 867988 +754974 882724 +754974 92243 +754978 1092564 +754978 1092565 +754978 294480 +754978 465983 +754978 655270 +754978 732482 +75499 1193029 +754998 1645625 +7550 82606 +755046 284099 +755046 883256 +7551 302413 +7551 457980 +7552 17142 +7552 525178 +7552 79949 +7552 88701 +755268 1202885 +75542 14743 +755586 1018182 +75559 1019344 +75559 1227835 +75559 134727 +75559 1461538 +75559 334984 +75559 385624 +75559 620303 +755592 755594 +7556 827971 +755637 48391 +755644 271923 +75584 74531 +75584 75305 +75590 73136 +75590 75305 +75592 310585 +75592 75331 +75594 75584 +755989 288861 +755989 889719 +755989 889724 +75606 163032 +75606 424754 +75608 191608 +75616 428382 +75617 229498 +75617 23755 +75617 254945 +75617 258460 +75617 258701 +75617 259078 +75617 64694 +756208 23391 +756237 976565 +756272 177049 +756272 35199 +75630 134275 +75630 3218935 +756447 1642344 +756451 3150040 +756451 3150042 +75651 846 +756830 140216 +75701 134810 +75701 36951 +75718 177218 +757203 1036154 +757203 1179821 +757203 1257632 +757203 201958 +757203 365527 +757203 757203 +75729 188542 +75733 583968 +75733 583969 +757367 689818 +757367 772187 +757434 757435 +757481 19056 +757481 29158 +75757 103897 +75757 172004 +7576 806129 +7576 8199 +7576 854223 +75760 181461 +75760 48477 +75775 81945 +757809 264431 +757837 114493 +757837 1239506 +757837 82782 +757837 847324 +757911 282137 +758044 758045 +758172 482792 +758216 508131 +758216 665970 +758306 48996 +75834 75835 +758462 2961668 +758462 2961669 +758462 3439800 +758462 6919 +758503 1027902 +75852 2630415 +75854 999945 +758571 408958 +75862 327471 +75862 77593 +758669 758668 +758796 1371427 +759 80933 +759038 505738 +75912 197443 +759182 1025832 +759182 2383328 +759182 3331684 +759182 3334638 +759182 759178 +759182 843513 +759183 3137617 +759183 583252 +759183 630837 +759183 849774 +759186 849441 +75920 79095 +759287 1204354 +759369 144436 +759425 838655 +759450 2499016 +759450 2499017 +759536 564095 +75956 126745 +759564 13734 +759599 2757853 +759735 120828 +759753 759752 +759868 424108 +759868 480804 +759892 759893 +759896 1015406 +759896 567208 +759896 567209 +759896 833179 +759957 759962 +76 466227 +76 6365 +760142 318132 +76017 110595 +76017 82690 +76026 118218 +76026 3086559 +76026 327446 +76026 42124 +76026 58014 +76026 9373 +76028 104514 +76028 119083 +76028 1510591 +76028 177339 +76028 177340 +76028 177344 +76028 222384 +76028 264223 +76028 26955 +76028 270000 +76028 294480 +76028 304968 +76028 32180 +76028 32187 +76028 32190 +76028 339330 +76028 434336 +76028 456210 +76028 456211 +76028 506006 +76028 626175 +76028 709732 +76028 909773 +76028 92243 +76040 1781 +76040 1855666 +76043 142955 +76043 90742 +760489 1141089 +760489 200670 +760548 447940 +7606 1015 +7606 243480 +76062 168738 +7607 72950 +76073 110154 +76073 162426 +76073 209748 +760734 45191 +760810 460445 +760896 937158 +7609 232877 +7609 2655 +76092 217749 +76092 350937 +760940 1746647 +761 760 +7611 113522 +7611 5485 +7611 76531 +761109 1269369 +761109 570536 +761109 645601 +761109 836801 +761109 974269 +761118 1036751 +761118 1036752 +761118 1186813 +761118 2859358 +761119 1036751 +761119 1036752 +761119 544890 +761133 1954840 +761145 178728 +76115 17960 +76115 83740 +7612 146798 +7612 2922 +7612 49355 +76122 76122 +76122 96452 +76124 140234 +761398 356574 +76155 2058961 +761651 1231941 +761794 87251 +7618 102733 +7618 1064586 +7618 51881 +76181 337237 +761873 2328635 +761961 184 +762182 210409 +762355 262940 +762355 523633 +762355 834378 +762355 966986 +762355 973130 +7624 162995 +7624 1708 +7624 24298 +7624 2447 +7624 35650 +7624 455520 +7624 469300 +7624 51219 +7624 7705 +76242 109513 +76242 109832 +76242 182673 +76242 185582 +76242 197812 +76242 382819 +76253 170961 +762632 1012379 +762632 1021944 +762632 1027116 +762632 1057453 +762632 1630688 +762632 1825898 +762632 2455825 +762632 283130 +762632 394791 +762632 435555 +762632 452918 +762632 452919 +762632 538864 +762632 688716 +762632 833168 +762632 835113 +762686 777926 +7627 11233 +7627 3567 +762703 754128 +762757 498647 +762870 1299730 +7631 207845 +763250 1133674 +76357 200264 +763685 376305 +763687 1256150 +763802 763921 +763850 386488 +763988 1295680 +7640 142192 +7640 31009 +764192 1188375 +764226 1548139 +764428 1095165 +764431 662574 +764475 1587633 +76461 107444 +764732 1022781 +764732 1888624 +764732 885816 +76484 240369 +76484 76486 +764895 764896 +76501 490958 +765229 172490 +765229 623870 +76534 56971 +765352 229566 +765352 361592 +765352 519934 +765352 527161 +765352 700443 +765352 822517 +765352 836895 +765621 765623 +76567 541117 +76573 455394 +76575 76576 +765884 269487 +7659 413191 +766134 46602 +766136 1381892 +766165 364654 +7662 14676 +7662 58533 +7662 77307 +7662 90520 +766373 1192829 +766373 1219756 +766373 1977334 +766373 766373 +766553 161982 +766553 1680802 +766563 766553 +766565 1137774 +76677 14342 +76677 29546 +76677 49499 +766856 43213 +7669 17413 +76690 71643 +76690 71644 +766937 1124484 +766937 2470688 +766937 865058 +766937 914956 +76742 1776175 +76742 488971 +767484 1140464 +767484 1808868 +767484 935819 +76760 11573 +76761 11573 +76764 484799 +76764 820719 +767642 207945 +767642 2212800 +767642 302078 +767642 375279 +767642 665298 +767642 703539 +767642 832962 +767642 890675 +767642 914150 +767642 995188 +767643 229566 +767643 65796 +7677 49598 +767788 1011986 +767788 1018019 +767788 1031993 +767788 1146034 +767788 1205065 +767788 1269390 +767788 1362287 +767788 1406392 +767788 1424606 +767788 1516786 +767788 1516791 +767788 1516797 +767788 1516820 +767788 174100 +767788 2500093 +767788 261293 +767788 262940 +767788 299702 +767788 388185 +767788 395913 +767788 457732 +767788 669730 +767788 767788 +767788 832934 +767788 832962 +767788 834378 +767788 835190 +767788 835735 +767788 861690 +767788 864672 +767788 877523 +767788 880605 +767788 883641 +767788 884545 +767788 899900 +7678 23421 +767890 2058302 +767890 99490 +768 9318 +7681 155450 +7681 236169 +7681 43778 +7681 909698 +768175 92750 +768256 458158 +768564 251762 +768564 751255 +768662 1405024 +768662 1416655 +768662 1932292 +768662 1998849 +768662 1998850 +768662 2015317 +768662 626008 +768692 80285 +76894 10995 +7690 43589 +7690 61459 +769002 94789 +76912 28517 +76912 82979 +7692 2264 +76923 1240 +769374 242476 +769374 412929 +769374 998484 +76938 283310 +76938 76939 +76939 283310 +7694 42488 +7694 89628 +769508 262940 +76952 1314152 +769522 485897 +76971 12879 +76971 2108 +76971 223818 +76971 3550 +76971 413164 +76971 526739 +76971 535617 +76971 65997 +76971 672102 +76971 73538 +76971 76933 +76971 76971 +76974 76974 +7698 108652 +7698 12781 +7698 299483 +7698 58266 +7698 59767 +7698 59768 +7698 80433 +76982 1462461 +769904 238278 +76991 650380 +76992 17969 +76992 238379 +76999 49628 +769998 769997 +769998 875796 +770043 1680 +77007 587516 +770106 920769 +770112 751538 +77019 40152 +77022 478535 +770336 21952 +770336 770337 +770336 899606 +770337 899606 +770425 952206 +77055 325925 +77055 37247 +77056 77062 +77066 530481 +770691 246781 +77076 1251753 +77076 167557 +77076 310492 +77076 386854 +77076 53890 +7708 1157791 +7708 211787 +7708 229665 +7708 29058 +7708 51216 +7708 93780 +77080 19814 +77082 22506 +77082 397513 +77086 116685 +77086 120034 +77086 219982 +77086 241135 +77086 2582378 +77086 310509 +77086 386863 +77086 41891 +77088 112778 +77088 116683 +77088 1343679 +77088 227252 +77088 33471 +77088 52147 +77088 79840 +77088 970184 +77089 82211 +7709 310495 +77090 1051454 +77090 117415 +77090 2635529 +77090 411692 +770933 1495753 +770933 1557812 +770933 1676738 +770933 3316810 +770933 3525404 +770933 503824 +770935 1130699 +770935 2369083 +77104 10207 +77104 231285 +77104 491972 +77104 758198 +7711 2264 +771286 63758 +7713 111519 +7713 228874 +771419 771420 +771547 771548 +7716 2532 +7717 1172502 +7717 1412855 +7717 38754 +771725 1574125 +771746 771745 +77180 196988 +77180 82784 +771976 1968752 +772128 1677459 +772128 2350057 +772128 856847 +772151 1054398 +772151 115461 +772151 115469 +772151 304968 +772151 361814 +772151 410038 +772151 456926 +772151 552196 +772151 835730 +77226 347490 +77231 63835 +772350 428776 +772413 49767 +772492 372877 +772759 212299 +772759 339755 +772759 92243 +77277 41815 +77284 564456 +77284 9463 +772882 1022327 +772897 940921 +772914 124436 +772914 772913 +77307 58533 +7731 35315 +7731 59688 +773200 1043686 +773259 1119800 +77326 77328 +773271 202097 +773271 425028 +773271 843618 +773271 98481 +773298 2640650 +773474 1172547 +773474 1884995 +773474 54211 +77372 9373 +77374 166506 +773740 364256 +773740 600306 +773740 804768 +77379 117415 +77379 33476 +77380 172224 +77380 172225 +773818 352749 +774146 873960 +774160 192192 +774160 282986 +774264 774265 +774302 2176594 +774302 841797 +774302 859024 +774449 214748 +774449 344779 +774458 227461 +774458 33737 +774481 2024990 +774481 833018 +774481 870832 +774481 870833 +774485 835518 +774485 869694 +774485 933757 +774486 774478 +774579 1763158 +774605 774606 +77475 77476 +774782 652665 +77522 305038 +77522 37909 +775237 119484 +775237 395913 +775237 578743 +775237 712500 +77524 50867 +775241 1047628 +775241 119484 +775241 647782 +775241 837008 +775241 882784 +775266 456764 +775266 924191 +775313 78243 +775313 796326 +775389 962060 +775396 272929 +775408 712236 +775490 1495753 +775490 2372565 +775490 2829484 +775490 527475 +775490 578565 +775603 779022 +775634 137940 +775754 687306 +775797 1062192 +775797 296707 +775821 527475 +775886 953774 +775889 1047641 +77593 889139 +775992 2801458 +775992 805706 +775999 121936 +776 1559 +776 51395 +776011 336791 +77621 132084 +77621 16242 +77621 176601 +77621 2145259 +77621 289240 +77621 290846 +77621 333535 +77636 2259 +77636 2261 +77638 80706 +7766 2923804 +776668 212299 +776668 610798 +776668 835724 +776668 835726 +776673 835070 +776673 957152 +7768 161980 +776852 1580619 +776852 926717 +776858 2179274 +776878 805398 +776883 1161762 +77703 1004729 +77703 261117 +77703 639510 +777089 1206451 +777089 1480536 +777089 877201 +7771 202097 +777148 1532131 +7772 12553 +777277 268257 +777421 217705 +777431 243647 +77755 216708 +777587 995465 +77761 238064 +777756 271903 +777756 734669 +777774 1076447 +777831 36018 +777849 702680 +777892 236388 +777915 1176340 +777951 1933706 +77811 110436 +77811 115863 +77811 116683 +77811 142758 +77811 146062 +77811 146420 +77811 1753909 +77811 1939093 +77811 20700 +77811 25874 +77811 27657 +77811 29062 +77811 296229 +77811 29895 +77811 333839 +77811 33476 +77811 37233 +77811 3766094 +77811 385698 +77811 530481 +77811 719077 +77811 77082 +77811 9373 +77811 94500 +77813 117723 +77813 166289 +77813 314100 +77813 90203 +778196 34682 +778204 853336 +778248 382341 +77827 298783 +778281 29039 +778281 460054 +778416 1326761 +778416 1514548 +778416 656890 +778495 3409418 +778495 674330 +778496 10988 +778520 169235 +778528 1744428 +778528 1744430 +778528 534901 +778528 778532 +778529 647526 +778529 778532 +778532 1012509 +778532 1083537 +778532 262940 +778532 534901 +778532 647526 +778532 896980 +77855 114823 +77855 28738 +77855 36988 +778590 1267623 +77860 261278 +77860 296438 +778613 594242 +778673 2659273 +77870 46909 +778716 1102400 +778761 1228566 +778856 295598 +77907 89641 +779277 49767 +7793 1012226 +7793 7827 +77935 207263 +7794 208636 +779459 402640 +779502 832934 +779626 445411 +77974 8099 +779771 208220 +779780 836106 +779865 225403 +77989 1512772 +77989 189913 +77989 555588 +77999 167440 +77999 204223 +77999 292099 +77999 62226 +78003 132535 +78003 143457 +78003 198937 +78003 202316 +78003 282970 +78003 509991 +780336 409884 +78045 119217 +78045 175097 +780493 101597 +780493 27952 +780493 578565 +780575 182682 +780587 1545807 +7806 204395 +780724 937954 +780742 1790 +780742 790612 +780764 1182580 +780764 1309591 +780764 881379 +78093 310585 +78093 75592 +781030 781033 +781149 1325622 +781170 3555006 +781266 29207 +781266 89719 +781369 754299 +781591 1908717 +78169 822514 +781770 26863 +781770 3039681 +781770 3515 +781857 1901700 +781857 414270 +781956 184421 +782 179850 +782005 747558 +782088 1144299 +782088 1389707 +782088 782292 +782206 242129 +782292 1389707 +78231 28521 +78232 78233 +78236 123375 +78236 137860 +78236 366770 +78236 39555 +78236 42015 +78236 427449 +78236 8695 +78243 796326 +78246 318874 +782562 1546881 +782563 772876 +78276 1069915 +78276 194 +78276 2911456 +7828 120884 +783 51242 +7830 1186 +7830 151311 +7830 183741 +7830 3083 +7830 36174 +7830 403615 +7830 473330 +7830 57811 +7830 65099 +7830 67489 +7830 7830 +7830 829287 +7830 829288 +783018 69200 +78306 47195 +78325 2639423 +78325 591283 +783287 168853 +78330 266174 +78349 127836 +783608 1023189 +783645 188886 +783645 266646 +783656 190374 +78390 30950 +783915 37246 +783978 1517502 +783978 606027 +784032 1052045 +784154 37908 +784413 784412 +7845 180252 +7845 636316 +784725 784727 +784739 1205755 +784739 312208 +784776 1301166 +78487 165431 +78488 75584 +78498 143860 +785 10045 +785 21340 +785 33542 +78513 85445 +78513 89001 +78513 91748 +785147 1366050 +785147 1866398 +78533 131257 +785442 830834 +785448 306885 +78554 150128 +785680 410344 +785934 3984367 +786 216362 +786 268923 +78601 7400 +786210 1253683 +786210 1719156 +786215 786216 +7863 148 +786318 233499 +786318 435008 +78632 48670 +78659 1128599 +78659 1201210 +78659 185580 +78659 185582 +78659 2622095 +78659 3352 +786590 1049 +786590 728005 +78660 92068 +786645 1114885 +786693 647526 +786693 778532 +7868 7886 +78686 790071 +7870 1279038 +7870 140556 +7870 157538 +7870 20212 +7870 209391 +7870 22078 +7870 402364 +7870 41272 +7870 46176 +7870 485047 +7871 358719 +7871 40541 +7871 9866 +787422 154521 +78749 282718 +7875 63742 +7875 702880 +7875 81957 +787880 1700650 +787880 654531 +787880 787880 +78792 250306 +788010 2399044 +788033 798037 +788066 557612 +788254 1443539 +788289 170358 +7883 7870 +788501 2313040 +7886 166078 +7886 350073 +7886 385229 +78872 12684 +78873 11814 +78877 78878 +788782 630480 +78890 142204 +788936 1043458 +78896 18360 +78896 92967 +78899 78897 +789 13686 +78900 81493 +789008 67326 +78906 93943 +78914 163717 +78930 11573 +78930 36733 +78930 6070 +78933 147739 +78933 184603 +78933 184604 +789427 41441 +78958 401444 +789733 789732 +789733 789733 +789776 798940 +789776 833722 +789776 836151 +789776 836156 +789776 862837 +789776 979554 +7899 151245 +7899 218860 +7899 2320 +7899 487822 +7899 765624 +7899 812586 +790 4475 +790 4477 +7900 224525 +7900 2320 +7900 2987 +7900 49385 +7900 765624 +7900 7899 +79019 33533 +79022 169481 +79022 653629 +79022 701516 +79024 79094 +790319 366191 +790319 921113 +790536 188747 +790550 180913 +790550 20184 +790550 938452 +790717 1695017 +79089 3753336 +79089 6270 +791 266264 +791 659671 +791018 140123 +791138 2139419 +791169 909150 +79118 51350 +79118 52724 +791227 1726973 +791299 1391855 +791299 1548248 +791299 1874746 +791299 1874747 +791299 791299 +791299 820460 +7913 7926 +79132 79133 +79158 79159 +791685 312255 +791786 774584 +791789 522210 +791789 526410 +791789 595051 +791789 826829 +79185 84875 +792 138872 +7921 119024 +7921 287918 +7921 287919 +7921 59470 +7921 935268 +79211 498017 +79220 243900 +79222 1960944 +792382 807272 +792382 807273 +79245 580306 +79253 12869 +792540 234399 +792540 792540 +7926 1275252 +792633 792636 +79265 1163931 +79265 1727783 +79265 56238 +792683 1595296 +792683 2395978 +792683 841357 +79295 12223 +79295 91791 +792955 137603 +792955 329424 +792972 3101967 +793022 793015 +793027 498653 +793063 335198 +793064 1009232 +793064 1046945 +793064 1155414 +793064 1236438 +793064 1353208 +793064 1919644 +793064 1922348 +793064 1964301 +793064 207945 +793064 2145238 +793064 2178814 +793064 2178817 +793064 2402947 +793064 2402948 +793064 2606344 +793064 260744 +793064 283122 +793064 3068272 +793064 325672 +793064 3430309 +793064 3478263 +793064 375279 +793064 393383 +793064 517163 +793064 65796 +793064 671328 +793064 716084 +793064 828590 +793064 832962 +793064 833837 +793064 835642 +793064 836124 +793064 836184 +793064 836185 +793064 837582 +793064 837588 +793064 837589 +793064 841660 +793064 842085 +793064 842308 +793064 845760 +793064 845763 +793064 846277 +793064 861476 +793064 869650 +793064 870792 +793064 870833 +793064 898403 +793064 922565 +793064 926325 +793064 931349 +793064 941855 +793064 978175 +793064 988605 +793189 2749752 +793283 1248419 +79342 194 +793444 793443 +79352 315230 +793575 2365522 +793816 2931310 +7939 92920 +794111 250813 +79424 1490559 +79425 92822 +79433 19594 +79433 286984 +79439 120307 +79439 1300055 +79439 3407397 +79439 57857 +79439 803259 +794536 794539 +794560 3979160 +79461 75864 +79470 2086654 +794753 811383 +794755 2050826 +794806 739007 +794817 1441678 +794856 361217 +794883 582273 +79489 626449 +795 106331 +795 44844 +7950 1041425 +7950 1041426 +79505 1227 +79505 1552418 +795052 171290 +795171 1031230 +795171 1032225 +795171 108565 +795171 1129949 +795171 1205848 +795171 1374321 +795171 253245 +795171 262940 +795171 269254 +795171 2999551 +795171 311048 +795171 3250030 +795171 3250032 +795171 3338724 +795171 488362 +795171 532273 +795171 555462 +795171 696134 +795171 751505 +795171 795195 +795171 833317 +795171 833579 +795171 837498 +795171 837534 +795171 850893 +795171 861489 +795171 95536 +795171 95540 +795184 153980 +795195 1205848 +795195 253245 +795195 262940 +795195 532273 +795195 850893 +795195 861489 +795451 1660852 +795451 1768578 +795451 1890455 +79574 22038 +79578 17900 +79578 31751 +79578 35125 +79578 353608 +79578 41922 +79578 66824 +79579 1411691 +79579 203398 +795799 149249 +795913 283164 +7960 22773 +7961 12588 +796117 61588 +7962 15036 +7962 33006 +7962 42518 +796210 1015406 +796210 1449987 +796210 833179 +796210 844081 +796211 1063282 +796211 1788100 +796211 2258485 +796211 2258486 +796211 283469 +796211 304975 +796211 445532 +796211 578727 +796211 624749 +796211 836011 +796211 838040 +7963 145180 +796366 1328529 +7964 24580 +796563 808223 +796626 1285557 +796626 264903 +796821 785147 +79684 1087230 +79684 213257 +79684 245837 +79684 294537 +79684 60364 +79684 69673 +7969 15059 +79695 197488 +79695 24452 +797029 1397911 +79704 123987 +797094 938666 +797149 795937 +797149 838338 +797171 1133674 +79721 497932 +797286 1674572 +797297 1555056 +79732 23624 +797328 1834928 +797402 31121 +79742 1125380 +79742 368674 +79742 59407 +79752 350072 +79759 21787 +797697 1115338 +797697 2989950 +797697 608657 +797700 1272541 +79776 29654 +797781 111067 +797781 378421 +797781 929663 +797801 71503 +797817 872709 +797904 2285615 +79791 69702 +7980 1510 +7980 322470 +798058 798059 +798091 62701 +7981 11736 +7981 12787 +7981 2837515 +7981 43828 +79814 45866 +798143 371810 +798304 1329702 +79840 106541 +79849 89259 +7986 187769 +7986 6428 +798628 995553 +798677 360999 +798677 401936 +798728 34955 +798940 649582 +798940 833722 +798940 836151 +798940 836156 +799086 126111 +799174 1176387 +799231 11791 +799267 1049669 +79929 62992 +799358 730185 +79942 214415 +79946 51745 +799489 722088 +79949 253133 +799495 282107 +79952 59588 +79952 89940 +799607 724108 +799788 802905 +799800 799797 +799817 920958 +799855 1764254 +799859 224948 +799873 1636167 +799873 2425510 +79989 146216 +79989 17827 +79989 246205 +79989 258118 +79989 267099 +79989 282240 +79989 29058 +79989 307059 +79989 44120 +79989 44944 +79989 703269 +79989 99438 +799987 143242 +8 225855 +8 29362 +8 3986259 +8 4085 +8 40927 +8 856860 +8 904822 +800128 896118 +800252 23624 +800252 58584 +800264 1205848 +800264 253245 +800264 262940 +800264 311048 +800264 532273 +800264 751505 +800264 795171 +800264 795195 +800264 837534 +800264 850893 +800264 861489 +80027 618241 +80028 660 +80040 492745 +8005 11269 +8005 119518 +8005 119775 +8005 15730 +8005 201874 +8005 4312 +8005 455437 +8005 46465 +8005 73838 +8005 94853 +800561 64294 +800609 1227981 +8008 4614 +80081 139431 +800822 1154202 +800822 1347288 +80091 339974 +80091 57566 +80098 56739 +800996 262940 +800996 835073 +800996 837450 +800996 837568 +800996 838929 +800996 839085 +800996 859780 +801 120307 +801 120960 +801 1441341 +801 1546881 +801 169880 +801 183267 +801 2583 +801 3187569 +801 3199769 +801 394123 +801 394124 +801 438783 +801 44915 +801 487291 +801 489089 +801 596407 +801 66727 +801 8462 +801 929880 +80105 221030 +8011 66239 +8011 86895 +80117 31929 +80120 83170 +80121 116926 +80121 15165 +80122 112961 +80122 188627 +80122 188628 +80122 31546 +80128 349306 +80129 41105 +80130 144537 +80130 2264 +80130 533567 +80134 268583 +80134 28365 +80134 77034 +801344 359755 +8014 11944 +8014 929880 +801432 1515997 +801578 1662767 +801578 912553 +801623 194 +801793 194 +80194 156602 +80194 329287 +801985 3220814 +8021 4349 +80211 16536 +802149 175575 +802208 854552 +802242 2199762 +80228 39505 +80228 61920 +802368 10927 +8024 105902 +8024 32416 +8024 35848 +8024 51368 +8024 90233 +80263 221703 +80265 191521 +8027 18628 +80270 588271 +802757 2144887 +802757 922787 +802768 183523 +802768 802767 +8029 4778 +8030 47766 +8031 132707 +8031 39120 +803209 905075 +80325 130964 +803272 162995 +80333 101966 +80333 204003 +80362 22636 +80366 441824 +80366 45301 +80366 811669 +803755 165098 +80382 74412 +803904 365248 +80398 160352 +804 328447 +80450 80451 +804540 1902111 +804540 238239 +804540 2428251 +804540 2624266 +804540 2947088 +804540 418512 +804540 818624 +8046 162895 +8046 28624 +804734 3092 +804734 3805 +805077 900497 +805177 805176 +805222 1023585 +80529 257306 +805293 1297580 +805296 716097 +805380 1267800 +805380 832992 +805380 917373 +8054 43772 +8055 1482877 +805584 805281 +80559 11438 +805590 704157 +805611 2293987 +805611 2293988 +805611 415725 +805611 532265 +805611 659953 +805655 8055 +80569 148058 +80570 1713124 +805832 805833 +805918 429961 +805918 866979 +806 817 +80613 1415565 +806256 2876796 +80630 23406 +806436 1604742 +806436 534319 +806436 835350 +806436 835548 +806436 842077 +806436 843324 +806436 843897 +806436 858967 +80644 51946 +806463 806461 +806469 301298 +806508 71844 +80654 459622 +806563 806564 +806565 221184 +806628 301724 +806628 302498 +806628 461546 +806628 59288 +806672 1152266 +806672 617133 +806688 75876 +806697 806698 +8068 1849649 +806899 283280 +806899 3027200 +806899 790550 +806899 990605 +806900 806902 +806902 1369554 +806997 536424 +80705 80706 +807128 1222352 +807273 807272 +807322 1026736 +807322 1155414 +807322 1631888 +807322 375279 +807322 734491 +807322 793064 +807322 845763 +807322 870792 +807450 1110062 +807450 304968 +807450 614613 +807450 834522 +807450 838776 +80748 1449765 +807519 80569 +807623 10677 +807814 807810 +807968 1040366 +80799 150565 +808105 929166 +808167 814400 +808199 58015 +80842 279523 +808629 23657 +808629 52504 +808734 1256063 +80895 131731 +80895 201178 +80895 459546 +809 1477 +809 3734962 +809 38649 +8090 688280 +80902 34574 +809194 809195 +80924 670 +809365 1178464 +809454 2027284 +809570 848602 +809841 412945 +809855 779004 +809856 1003993 +809856 1126409 +809856 1205069 +809856 1246963 +809856 1417030 +809856 1417031 +809856 1417032 +809856 239236 +809856 2409926 +809856 27519 +809856 276145 +809856 299702 +809856 304968 +809856 304975 +809856 32196 +809856 342543 +809856 388185 +809856 3887234 +809856 523633 +809856 578727 +809856 617133 +809856 628237 +809856 703539 +809856 747740 +809856 832661 +809856 833240 +809856 837575 +809856 859448 +809856 873814 +809856 882022 +809856 95544 +809856 95546 +809856 961400 +809856 986114 +8099 15824 +8099 5391 +8099 72965 +809983 386093 +81 524153 +810040 810042 +81013 10263 +81013 1830 +81013 227475 +81013 675884 +81019 111843 +810218 28517 +810218 84264 +810424 754894 +810424 784121 +810474 810473 +810474 810475 +810475 810473 +81056 100756 +81056 1738245 +81056 174883 +810562 1406897 +810616 2175907 +81063 1509265 +810674 8185 +811028 243647 +811028 398944 +81109 217629 +81109 227082 +81109 28209 +811092 106892 +81110 220791 +81110 41233 +811231 526871 +81126 216087 +81126 242533 +81126 253731 +81126 27307 +81126 328401 +81131 847031 +81139 375953 +81139 51216 +81139 7708 +81144 56273 +811461 408173 +81147 31546 +8115 231651 +811741 3265907 +811747 805656 +812041 818461 +81206 132084 +81206 166190 +8121 10932 +8121 1618691 +8121 192149 +8121 4223 +8121 48766 +8121 48885 +8121 51039 +8121 91083 +81210 46532 +81210 95433 +812116 809842 +812164 1196344 +812164 123377 +812164 1234951 +812164 1317632 +812164 141039 +812164 317983 +812164 812164 +812164 924137 +812164 941706 +81218 122843 +81218 232280 +81222 35086 +812254 422165 +81232 15753 +812586 4742 +812596 1439777 +812596 1439779 +812653 3290209 +812748 13128 +81278 539458 +81282 194 +812866 812867 +813035 1879720 +813108 2044596 +813116 813117 +813427 854043 +813427 854044 +813566 813568 +813643 2847174 +813643 2847175 +81368 168242 +81368 328412 +81368 52584 +81371 54479 +81383 17139 +81384 2340717 +813939 10774 +813939 4810 +813991 1099197 +81419 114823 +81419 222457 +81419 523446 +81419 53438 +81419 66144 +814396 3639807 +814407 212000 +814407 212001 +814407 2363984 +814407 394776 +814407 92243 +814409 1150495 +814409 1150496 +814409 975597 +814460 684685 +814478 1057453 +814478 1488743 +814478 299702 +814478 573239 +814478 833076 +814478 833168 +814478 833664 +814478 834073 +814478 837512 +814478 838930 +814478 842888 +814478 845358 +814478 852345 +814478 859036 +814478 861476 +814478 861484 +814478 865055 +814478 915657 +814478 92243 +814517 123495 +814517 497722 +814517 800505 +81453 119283 +814534 152815 +814588 814589 +814592 1104183 +81465 15044 +814737 814738 +81475 131697 +81483 124261 +814873 555263 +81489 155816 +81489 409997 +81490 169947 +81493 12765 +81496 218570 +81496 45382 +81496 71844 +815068 3685819 +81510 24085 +815148 1882768 +8152 4449 +815264 705861 +81527 307491 +815286 341157 +815329 651280 +815446 233802 +8156 194 +8156 637804 +8156 66196 +815682 1471856 +815682 836263 +815777 1529262 +8158 2586 +815921 497200 +815932 840570 +8162 1600 +8162 1958011 +816256 1556249 +81645 329186 +816571 364551 +816590 816589 +8166 6490 +816639 328329 +816639 870899 +8167 10262 +8168 246428 +8168 6029 +81684 73805 +81687 53715 +8169 168047 +817 300726 +817 435632 +817 506214 +817 5383 +817146 391970 +817274 1141395 +817274 1499477 +817274 681416 +817317 1764775 +81736 973295 +817379 317527 +817422 387 +817422 49719 +817480 269254 +817480 966987 +817480 975145 +817642 1681604 +817642 763518 +817743 106348 +817743 22278 +817743 978461 +818004 831982 +8182 155714 +818315 8521 +818624 1462098 +818624 588638 +818624 61543 +818703 12716 +818848 1581501 +818891 1546540 +81900 22819 +819170 1645457 +819170 395188 +819206 2718468 +819299 2515001 +819385 27952 +81944 533567 +81944 80130 +81951 22877 +81951 251536 +81951 50514 +81951 59736 +81951 89970 +81951 89972 +819669 790190 +819672 1521153 +819672 1543771 +819672 2841003 +819672 442922 +819672 837754 +8197 8196 +819810 819808 +819825 819826 +81986 255267 +81986 299044 +81986 299045 +81986 754049 +819862 15900 +819897 1306060 +81990 27657 +81990 390737 +820025 423060 +8201 19799 +8201 3221 +8201 868 +82010 522367 +8202 379636 +8202 477205 +820386 1871338 +820411 1565780 +820411 72465 +820460 1874746 +82048 239448 +820598 1003474 +82068 27658 +82068 35025 +82079 239415 +82082 347863 +820846 512427 +821197 181523 +82124 540781 +82125 717470 +82128 1690 +821305 269081 +821305 312169 +821959 681409 +822048 5087 +8221 1369367 +8221 1462131 +8221 27616 +8221 427638 +8221 457440 +8221 52958 +8221 627536 +8221 6286 +82211 317009 +822140 145843 +822292 1594062 +822292 2508281 +822410 1220882 +822410 1850559 +822410 1850560 +822410 2381784 +822410 252872 +822410 2610194 +822410 2878336 +822410 519934 +822410 641250 +822410 700443 +822410 822517 +822410 833792 +822410 834088 +822410 834703 +822410 834707 +822410 835927 +822410 877523 +822410 877524 +822410 918924 +822410 918932 +822473 1024263 +822473 1248603 +822473 1289417 +822473 1308012 +822473 1362829 +822473 1524027 +822473 1541603 +822473 1935198 +822473 2303645 +822473 262940 +822473 304968 +822473 368137 +822473 435555 +822473 502825 +822473 547969 +822473 547971 +822473 604396 +822473 647295 +822473 754974 +822473 832951 +822473 834646 +822473 835070 +822473 835085 +822473 835112 +822473 835204 +822473 835210 +822473 842888 +822473 857108 +822473 866651 +822473 883315 +822473 956329 +822512 395631 +82279 399065 +8228 1500 +8228 34955 +8228 6521 +8228 7716 +8228 8228 +8228 82675 +8228 95699 +82294 280034 +823 1082403 +823 1360 +823 297964 +8230 115796 +8230 217 +8230 406328 +8230 481418 +8230 99468 +823058 3010101 +823058 988905 +823059 395913 +823059 406278 +823059 696188 +823059 823063 +823059 988713 +823061 1259101 +823061 1353275 +823061 304975 +823061 3488542 +823061 849674 +823061 852709 +823061 95537 +823065 1241315 +823065 1259762 +823065 1328764 +823065 442174 +823065 620726 +823065 833550 +82308 488229 +82310 72175 +823352 241309 +823465 1318493 +823465 1628349 +823465 552195 +823465 604396 +823465 617404 +823465 835519 +823465 865050 +823559 823560 +82356 361915 +82358 2774075 +82375 239110 +823874 184282 +8239 57475 +823920 723368 +824202 1009447 +824202 1152266 +824202 226461 +824202 229547 +824202 262940 +824202 27519 +824202 279614 +824202 283469 +824202 283473 +824202 395913 +824202 406281 +824202 406283 +824202 456926 +824202 526590 +824202 538821 +824202 561054 +824202 696257 +824202 809856 +824202 832661 +824202 832942 +824202 833560 +824202 837568 +824202 842233 +824202 859452 +824202 896978 +824202 946948 +824202 95542 +824202 95546 +824202 999914 +8245 31146 +82455 14393 +824550 1452918 +824550 1583001 +824550 1826008 +824550 2266155 +824551 1255433 +824551 59946 +824803 824804 +824892 3806 +824901 1277834 +824901 1769092 +82519 82520 +8254 20684 +8254 223714 +8254 259299 +8254 293932 +8254 329753 +8254 61554 +8254 648635 +8254 670761 +825537 690592 +825720 78628 +8258 21139 +8258 2187 +8258 316679 +8258 33332 +8258 39617 +8258 54074 +8258 645 +8258 859227 +8260 1538 +8260 438262 +8260 54887 +826081 114493 +826081 115099 +826081 1249087 +826081 160130 +826081 289089 +8261 26954 +826240 1020377 +826240 319968 +826240 372878 +826247 120214 +826247 258476 +82632 1949 +82632 449473 +82642 58287 +826517 839081 +826517 855761 +826517 869694 +826517 92243 +826540 2537480 +826584 604563 +826680 3292990 +826720 212299 +826720 909598 +826720 92243 +826720 966368 +82674 272873 +82674 50270 +82674 71482 +826830 837551 +826833 833786 +826833 837511 +826833 837515 +826833 839640 +826833 978253 +826839 157707 +826839 834646 +826840 283469 +826840 833686 +826879 156544 +82690 110595 +82693 73255 +826992 331217 +827068 56887 +827070 146371 +827070 637804 +827070 651504 +8272 3470 +82730 121112 +82730 1362751 +82730 261052 +82730 415656 +82730 82730 +82740 374059 +827420 636714 +827420 922770 +827475 421348 +82758 212452 +827608 1169330 +827608 1462868 +8277 9562 +827746 348832 +827747 824460 +82775 64582 +8278 109 +8278 1648955 +8278 67717 +82788 82789 +8279 345352 +827918 1794298 +827918 2362141 +827971 1059249 +827971 621262 +82834 35611 +828361 546012 +8284 145262 +8284 1661669 +8284 200815 +8284 23755 +8284 297999 +8284 376962 +8284 377046 +8284 64694 +8284 835190 +8285 170365 +8285 175365 +8285 4033 +8285 702067 +82851 59485 +828588 828583 +828590 988605 +828694 1741205 +82886 123829 +828896 2139225 +828896 230238 +828896 2497796 +8289 149910 +829 585316 +82902 11887 +82902 64194 +829061 900990 +82909 216420 +82926 227202 +829287 829288 +829447 829444 +82946 234570 +82947 53529 +82947 64774 +82948 86303 +829866 857625 +82988 1726 +8299 104029 +829980 341147 +829980 526590 +829980 896978 +829982 1056568 +829982 108566 +829982 1769149 +829982 304973 +829982 841456 +829982 894376 +829982 913040 +829982 931384 +829984 224329 +829984 377139 +829984 479036 +83 166 +83 1860668 +83 2187 +830017 69986 +830055 1138301 +830060 1237 +830077 434352 +83009 1299040 +830144 1770381 +830144 1864552 +830144 1864554 +830144 1864555 +830228 284693 +83057 138089 +83057 86420 +830671 830672 +830699 3234510 +83074 346530 +83080 92577 +83081 323673 +83082 1065935 +83082 816286 +83084 261401 +83084 261403 +83084 268846 +830907 111907 +830907 1538794 +830907 218836 +830907 3027 +830907 5140 +830958 1649673 +830984 830983 +83107 19587 +83126 95623 +83143 38379 +831492 114493 +831492 1234386 +831492 1602745 +831492 1621130 +831492 990733 +831594 150520 +8316 1166964 +8316 1254914 +8316 313803 +8316 759038 +8316 8316 +8317 3503 +8317 395789 +8317 396836 +8317 423310 +8317 767713 +8317 7731 +8317 8317 +831896 254126 +832217 832218 +83224 156902 +83232 472394 +83234 10290 +83238 7552 +83241 206254 +83242 102984 +832583 281857 +832608 148564 +832623 175568 +832655 1440574 +832655 2518111 +832655 292345 +832655 393383 +832655 647733 +832655 833164 +832655 833722 +832655 836151 +832655 836152 +832655 836156 +832655 837660 +832655 841590 +832655 844441 +832655 851310 +832655 865661 +832655 870697 +832655 900812 +832661 1032227 +832661 1058892 +832661 115469 +832661 1239616 +832661 1337833 +832661 153980 +832661 1873860 +832661 2004798 +832661 216140 +832661 2383328 +832661 260744 +832661 279614 +832661 283122 +832661 2977692 +832661 299702 +832661 304975 +832661 377139 +832661 388185 +832661 395913 +832661 406278 +832661 406281 +832661 415720 +832661 418175 +832661 424576 +832661 448007 +832661 497542 +832661 522209 +832661 578737 +832661 688716 +832661 703271 +832661 744724 +832661 754894 +832661 759182 +832661 784121 +832661 832915 +832661 833554 +832661 834226 +832661 834611 +832661 835113 +832661 837575 +832661 837584 +832661 838295 +832661 841441 +832661 842146 +832661 843643 +832661 849793 +832661 859452 +832661 863254 +832661 892835 +832661 895152 +832661 896029 +832661 942019 +832661 944143 +832661 95546 +832661 958583 +832661 96123 +832699 1502316 +832699 1502317 +832700 1502316 +832700 1502317 +832700 1660701 +832700 832699 +832700 958583 +832701 1136579 +832701 2068346 +832701 522209 +832701 522210 +832701 833168 +832701 838931 +832701 839696 +832701 855063 +832701 855170 +832701 862697 +832770 696193 +832770 833628 +832770 833826 +832841 221269 +832897 832899 +832897 832900 +832897 874943 +832898 657574 +832898 832897 +832898 832899 +832898 832900 +832898 874943 +832898 903854 +832899 1854071 +832900 260744 +832900 688716 +832900 832899 +832900 833686 +832900 833687 +832900 833697 +832900 834640 +832900 834643 +832900 839640 +832900 846970 +832900 859780 +832900 860731 +832905 153980 +832905 368137 +832905 454293 +832905 539272 +832905 604396 +832905 833033 +832905 834577 +832905 837533 +832905 869796 +832905 874560 +832905 915941 +832915 224329 +832915 255709 +832915 262940 +832915 283469 +832915 377139 +832915 397620 +832915 406281 +832915 415720 +832915 454293 +832915 538821 +832915 547971 +832915 754974 +832915 832915 +832915 833840 +832915 835190 +832915 836487 +832915 838929 +832915 843643 +832917 1591238 +832917 260744 +832917 406278 +832917 448007 +832917 448010 +832917 703268 +832917 754974 +832917 832915 +832917 834378 +832917 841660 +832917 842233 +832917 855759 +832924 1056568 +832924 1058170 +832924 1245808 +832924 262940 +832924 269254 +832924 368137 +832924 394796 +832924 406281 +832924 538821 +832924 604396 +832924 696165 +832924 696260 +832924 754894 +832924 832899 +832924 832917 +832924 832962 +832924 835735 +832924 842233 +832924 842888 +832924 846970 +832924 896804 +832924 931384 +832924 978175 +832926 499563 +832934 1146034 +832934 2284146 +832942 1009447 +832942 262940 +832942 268272 +832942 837568 +832951 1092524 +832951 269254 +832952 1041310 +832952 1336922 +832952 832951 +832952 835073 +832952 899843 +832962 1017619 +832962 1440574 +832962 2518111 +832962 253934 +832962 292345 +832962 393383 +832962 39874 +832962 729646 +832962 832655 +832962 833163 +832962 833164 +832962 834389 +832962 835073 +832962 837660 +832962 838972 +832962 841590 +832962 843643 +832962 844441 +832962 851310 +832962 865661 +832962 870697 +832962 883762 +832962 900812 +832962 914150 +832989 108568 +832989 1094111 +832989 1522980 +832989 268272 +832989 304975 +832989 388185 +832989 517144 +832989 547969 +832989 547971 +832989 838868 +832989 883315 +832989 95546 +832995 361608 +832995 961746 +833010 1822718 +833010 1979591 +833010 406281 +833010 833128 +833010 943307 +833012 192325 +833014 898855 +833014 960902 +833018 2024990 +833018 870832 +833018 870833 +833027 576026 +833031 1132489 +833031 192325 +833031 216140 +833031 226461 +833031 2572040 +833031 2572041 +833031 283473 +833031 304975 +833031 380036 +833031 578727 +833031 653535 +833031 898730 +833031 95546 +833033 1435431 +833033 844250 +833033 883257 +833035 192325 +833035 27519 +833035 395913 +833035 406281 +833035 406283 +833035 696257 +833035 809856 +833035 95546 +833066 2649819 +833066 2811620 +833068 1428247 +833068 304975 +833068 522210 +833068 526579 +833068 623293 +833068 826839 +833068 838295 +833068 844250 +833068 883257 +833070 1586787 +833070 1757924 +833070 3650853 +833070 696188 +833070 833071 +833070 833073 +833070 833075 +833070 855072 +833071 1061521 +833071 1220778 +833071 1220779 +833071 1328725 +833071 1586787 +833071 1591238 +833071 1757924 +833071 1933252 +833071 2604177 +833071 283127 +833071 299702 +833071 3650853 +833071 388185 +833071 451535 +833071 454293 +833071 517158 +833071 517165 +833071 526411 +833071 696171 +833071 696188 +833071 696225 +833071 754894 +833071 754974 +833071 832942 +833071 833075 +833071 833167 +833071 833169 +833071 833173 +833071 833549 +833071 833824 +833071 837498 +833071 837529 +833071 842238 +833071 850906 +833071 851590 +833071 855072 +833071 857318 +833071 859036 +833071 861476 +833071 865661 +833071 941850 +833071 948628 +833073 1057111 +833073 1061521 +833073 1079561 +833073 1586787 +833073 1757924 +833073 303060 +833073 3650853 +833073 517158 +833073 691885 +833073 696188 +833073 696225 +833073 704150 +833073 833071 +833073 833075 +833073 833787 +833073 855072 +833073 861487 +833075 260744 +833075 283122 +833075 283127 +833075 696225 +833075 754974 +833075 842222 +833075 842223 +833075 849674 +833076 1031230 +833076 2586229 +833076 260744 +833076 283122 +833076 283127 +833076 446577 +833076 454293 +833076 517153 +833076 517165 +833076 532276 +833076 575045 +833076 696171 +833076 696225 +833076 754974 +833076 795171 +833076 833070 +833076 833071 +833076 833073 +833076 833075 +833076 833167 +833076 833168 +833076 833169 +833076 833173 +833076 833554 +833076 833667 +833076 833787 +833076 834073 +833076 834641 +833076 837498 +833076 837512 +833076 837520 +833076 839257 +833076 841431 +833076 842888 +833076 849674 +833076 850906 +833076 859036 +833076 861476 +833076 861487 +833076 865654 +833076 865661 +833076 882018 +833076 883315 +833076 915657 +833076 931425 +833076 941850 +833076 948628 +833076 973042 +833082 833080 +833097 1006977 +833097 1046945 +833097 1076878 +833097 1109391 +833097 1324365 +833097 1568347 +833097 1604940 +833097 1662767 +833097 1697098 +833097 1708948 +833097 1714457 +833097 1886955 +833097 1916320 +833097 1935328 +833097 1939635 +833097 1952952 +833097 2130976 +833097 276145 +833097 415725 +833097 454293 +833097 521659 +833097 534822 +833097 671331 +833097 793064 +833097 832962 +833097 833560 +833097 833851 +833097 834577 +833097 835735 +833097 837875 +833097 839002 +833097 840730 +833097 841440 +833097 842307 +833097 844160 +833097 845154 +833097 845155 +833097 845156 +833097 845160 +833097 858469 +833097 858577 +833097 858578 +833097 861282 +833097 898392 +833097 898398 +833097 898403 +833097 940156 +833097 978175 +833097 999914 +833128 703271 +833128 796660 +833155 270225 +833155 451535 +833155 834578 +833155 925944 +833155 925945 +833160 1284343 +833160 1284345 +833160 717288 +833161 270225 +833162 1307709 +833162 2141820 +833162 2141821 +833162 260744 +833162 283122 +833162 289323 +833162 445532 +833162 446105 +833162 446577 +833162 696215 +833162 754974 +833162 796211 +833162 833075 +833162 833163 +833162 833164 +833162 835518 +833162 837498 +833162 844419 +833162 850897 +833162 861689 +833162 861690 +833162 861691 +833162 869694 +833162 937077 +833162 998849 +833162 998855 +833162 998856 +833163 1440574 +833163 2518111 +833163 260744 +833163 292345 +833163 368137 +833163 393383 +833163 696192 +833163 696260 +833163 754974 +833163 832655 +833163 833075 +833163 833827 +833163 837660 +833163 841590 +833163 841593 +833163 844441 +833163 850899 +833163 850906 +833163 855072 +833163 861487 +833163 865661 +833163 870697 +833163 888414 +833163 900812 +833163 900979 +833164 1440574 +833164 2518111 +833164 260744 +833164 283122 +833164 292345 +833164 393383 +833164 446577 +833164 696192 +833164 754974 +833164 833075 +833164 833163 +833164 837498 +833164 837660 +833164 841590 +833164 844419 +833164 844441 +833164 850897 +833164 850899 +833164 851310 +833164 855072 +833164 855170 +833164 870697 +833164 900812 +833167 1129949 +833167 1220779 +833167 1344131 +833167 1344132 +833167 1615221 +833167 262940 +833167 283127 +833167 547969 +833167 575046 +833167 688716 +833167 696215 +833167 826833 +833167 833173 +833167 833554 +833167 833786 +833167 833787 +833167 835520 +833167 837511 +833167 837515 +833167 837520 +833167 839640 +833167 840349 +833167 851344 +833167 858380 +833167 858475 +833167 859036 +833167 861476 +833167 865655 +833167 882024 +833167 882026 +833167 895152 +833167 922635 +833167 941850 +833167 978253 +833167 996444 +833168 1022025 +833168 1046945 +833168 1047947 +833168 1084955 +833168 1092492 +833168 1183590 +833168 1282730 +833168 1320220 +833168 1447773 +833168 1541603 +833168 1558211 +833168 1566373 +833168 1628390 +833168 2068346 +833168 229566 +833168 2419637 +833168 2690116 +833168 283127 +833168 299702 +833168 3011155 +833168 424576 +833168 446105 +833168 446577 +833168 495010 +833168 517153 +833168 517158 +833168 522209 +833168 522210 +833168 526411 +833168 532276 +833168 538646 +833168 552195 +833168 561054 +833168 575045 +833168 578737 +833168 641250 +833168 646857 +833168 646860 +833168 65796 +833168 688716 +833168 744724 +833168 767643 +833168 832898 +833168 833074 +833168 833553 +833168 833687 +833168 833697 +833168 833716 +833168 834073 +833168 834578 +833168 834641 +833168 836125 +833168 837502 +833168 838983 +833168 839257 +833168 839679 +833168 841431 +833168 841593 +833168 842223 +833168 842238 +833168 842888 +833168 845919 +833168 850906 +833168 853359 +833168 855060 +833168 858375 +833168 861485 +833168 861487 +833168 867659 +833168 868798 +833168 899898 +833168 900979 +833168 901880 +833168 907452 +833168 922551 +833168 931425 +833168 988605 +833169 283122 +833169 283127 +833169 303060 +833169 454293 +833169 517165 +833169 575046 +833169 696215 +833169 833167 +833169 833173 +833169 833554 +833169 833560 +833169 842132 +833169 851344 +833169 861690 +833169 887456 +833169 937077 +833173 1325918 +833173 454293 +833173 517158 +833173 517165 +833179 262940 +833179 304975 +833179 578727 +833179 842888 +833181 1429382 +833181 227843 +833181 375279 +833181 406281 +833181 415720 +833181 547969 +833181 547971 +833181 552196 +833181 712500 +833181 761118 +833181 833697 +833181 834378 +833181 835090 +833181 885767 +833181 95537 +833181 997277 +833185 1340656 +833185 3149322 +833198 361592 +833198 845760 +833198 971041 +833201 1116384 +833201 2778658 +833201 2778662 +833205 836115 +833205 836152 +833205 836379 +833215 1669475 +833215 1729477 +833217 1294869 +833217 2066290 +833217 522269 +833217 688716 +833217 779781 +833217 837442 +833217 837588 +833217 870694 +833217 912702 +833217 961426 +833233 1177729 +833233 261293 +833235 1028502 +833235 153980 +833235 1711902 +833235 2268127 +833235 348565 +833235 374006 +833235 415725 +833235 424108 +833235 424576 +833235 532086 +833235 561054 +833235 567209 +833235 833851 +833235 834389 +833235 835730 +833235 846290 +833235 846301 +833235 850385 +833235 851589 +833235 852384 +833235 855761 +833235 868334 +833235 880769 +833235 890469 +833240 1353620 +833240 283473 +833240 388185 +833240 454981 +833240 838953 +833293 1283938 +833293 1334420 +833293 1476956 +833293 1655223 +833293 915941 +8333 10645 +8333 118637 +833315 1033258 +833315 1679489 +833315 1690917 +833315 216140 +833315 260744 +833315 262940 +833315 271870 +833315 283122 +833315 283469 +833315 3756878 +833315 406281 +833315 406283 +833315 415720 +833315 435555 +833315 454981 +833315 517158 +833315 522210 +833315 552195 +833315 595478 +833315 604396 +833315 617404 +833315 627442 +833315 696188 +833315 696225 +833315 706861 +833315 754974 +833315 822473 +833315 823465 +833315 832917 +833315 833383 +833315 833697 +833315 835112 +833315 835113 +833315 835204 +833315 835519 +833315 842888 +833315 848066 +833315 865050 +833315 931948 +833315 985088 +833317 216140 +833317 696225 +833317 826840 +833317 855790 +833317 872743 +833332 108343 +833332 2701234 +833332 593617 +833332 636636 +833362 852709 +833362 858480 +833376 1173606 +833376 1507460 +833376 1823420 +833376 1966189 +833376 454293 +833376 492930 +833376 855059 +833376 859452 +833376 864674 +833383 1120029 +833383 435555 +833435 1197033 +833435 675033 +833444 459673 +833444 573239 +833444 826840 +833444 850906 +833445 1061521 +833445 1084956 +833445 1615220 +833445 1615221 +833445 1964162 +833445 283122 +833445 696225 +833445 725023 +833445 833073 +833445 833167 +833445 833697 +833445 835519 +833445 837545 +833445 861475 +833445 869589 +833445 932630 +833445 996444 +833446 833098 +833446 833108 +833446 882033 +833452 1033674 +833452 1110103 +833452 538821 +833452 837568 +833452 921170 +833457 1234866 +833457 1329336 +833457 696188 +833486 1149753 +833486 1420649 +833486 1901503 +833486 395913 +833486 406273 +833486 406281 +833486 406283 +833486 754894 +833486 832917 +833486 859446 +833486 966985 +833486 986112 +833539 1891372 +833547 283127 +833547 754974 +833547 833071 +833547 833550 +833547 833553 +833547 855072 +833547 872558 +833549 1003177 +833549 1003179 +833549 1053170 +833549 1057111 +833549 1173606 +833549 2604177 +833549 283127 +833549 397620 +833549 691885 +833549 832942 +833549 833073 +833549 833547 +833549 833550 +833549 833787 +833549 855072 +833549 861581 +833549 865655 +833549 872558 +833549 912593 +833550 1259762 +833550 283127 +833550 754974 +833550 833071 +833550 833553 +833550 855072 +833553 1003177 +833553 2604177 +833553 277423 +833553 283127 +833553 542501 +833553 578737 +833553 593620 +833553 754974 +833553 832942 +833553 833071 +833553 833549 +833553 855072 +833553 912593 +833554 1031230 +833554 1344132 +833554 1400010 +833554 2207653 +833554 260744 +833554 262940 +833554 283122 +833554 283127 +833554 299702 +833554 303060 +833554 388185 +833554 397616 +833554 459673 +833554 459676 +833554 517153 +833554 517165 +833554 532273 +833554 573239 +833554 574914 +833554 575045 +833554 577808 +833554 696215 +833554 704150 +833554 814478 +833554 826840 +833554 833071 +833554 833075 +833554 833168 +833554 833173 +833554 833444 +833554 833787 +833554 833824 +833554 834641 +833554 835733 +833554 837502 +833554 837520 +833554 838400 +833554 838930 +833554 839085 +833554 841593 +833554 842222 +833554 842223 +833554 845358 +833554 850906 +833554 852345 +833554 855072 +833554 859036 +833554 861476 +833554 861484 +833554 861487 +833554 861690 +833554 865055 +833554 882024 +833554 900979 +833554 908890 +833554 931425 +833554 941850 +833560 1129949 +833560 1220779 +833560 268272 +833560 303060 +833560 406281 +833560 456926 +833560 523633 +833560 552196 +833560 598601 +833560 704150 +833560 754894 +833560 833167 +833560 833554 +833560 833787 +833560 838930 +833560 861690 +833560 937077 +833579 269254 +833579 833317 +833599 1718587 +833599 457732 +8336 185238 +8336 322201 +83362 18726 +833625 1031262 +833625 1653542 +833625 577808 +833626 1032277 +833626 1032278 +833628 1003179 +833628 1229978 +833628 1377659 +833628 1425824 +833628 1578164 +833628 1636340 +833628 1640327 +833628 2129819 +833628 2645574 +833628 397620 +833628 526591 +833628 577808 +833628 696193 +833628 696257 +833628 736606 +833628 754974 +833628 833168 +833628 833626 +833628 833826 +833628 837674 +833628 838168 +833628 842223 +833628 851418 +833628 854230 +833628 855057 +833628 855063 +833628 855073 +833628 855170 +833628 859855 +833628 861581 +833628 865655 +833628 899898 +833628 986112 +833629 1640312 +833629 3292283 +833629 3292284 +833651 51341 +833655 51946 +833662 1898666 +833662 375279 +833663 1898666 +833663 261451 +833663 526592 +833663 696215 +833663 833664 +833663 833666 +833663 833667 +833664 1898666 +833664 261451 +833664 526592 +833664 833666 +833664 92243 +833666 1898666 +833666 261451 +833666 526592 +833667 1004365 +833667 1022025 +833667 1032226 +833667 1032277 +833667 1032278 +833667 1710599 +833667 1898666 +833667 2003657 +833667 260744 +833667 261451 +833667 283127 +833667 299702 +833667 446577 +833667 451535 +833667 517158 +833667 526592 +833667 573239 +833667 696192 +833667 696215 +833667 696253 +833667 754974 +833667 833168 +833667 833560 +833667 833664 +833667 833666 +833667 839257 +833667 839514 +833667 849477 +833667 899624 +833667 907452 +833667 973042 +833686 1092492 +833686 1426704 +833686 2452795 +833686 2452796 +833686 268272 +833686 517153 +833686 552195 +833686 833108 +833686 833687 +833686 838190 +833686 932064 +833686 941848 +833686 978211 +833687 1046945 +833687 1315847 +833687 261451 +833687 283122 +833687 835521 +833687 838878 +833687 845358 +833687 891202 +833687 901880 +833697 1259101 +833697 304975 +833697 833686 +833697 833687 +833697 834051 +833697 836125 +833697 858375 +833697 869605 +833698 283122 +833698 552195 +833698 833697 +833698 845360 +833698 873272 +833710 833376 +833710 859452 +833716 1022025 +833716 1183590 +833716 1586786 +833716 1586787 +833716 2419637 +833716 446105 +833716 552195 +833716 641250 +833716 688716 +833716 842238 +833716 853359 +833716 865050 +833717 525459 +833717 604396 +833718 304975 +833718 833721 +833718 833722 +833718 836151 +833720 304975 +833720 833718 +833720 833721 +833720 833722 +833720 836151 +833721 304975 +833721 833722 +833722 304975 +833722 833205 +833722 836115 +833722 836156 +833722 836379 +833722 836380 +833736 814478 +833736 833168 +833736 833554 +833736 838930 +833736 845358 +833736 852345 +833736 859036 +833736 861484 +833736 865055 +833736 865654 +833736 865659 +833738 834713 +833765 985192 +833785 1586787 +833785 1757924 +833785 3650853 +833785 696188 +833785 833070 +833785 833071 +833785 833073 +833785 855072 +833786 837511 +833786 837515 +833786 839640 +833786 978253 +833787 1057111 +833787 260744 +833787 283122 +833787 283127 +833787 691885 +833787 754974 +833787 833075 +833787 833543 +833787 849674 +833788 282137 +833794 368137 +833798 2013704 +833798 3139504 +833814 2976204 +833821 1245031 +833821 1420541 +833821 1496956 +833821 2333160 +833824 262940 +833824 368137 +833824 95546 +833826 1229978 +833826 1425824 +833826 170759 +833826 2068048 +833826 2129819 +833826 397620 +833826 526591 +833826 837674 +833826 855065 +833827 349296 +833827 368137 +833827 833560 +833827 841593 +833827 888414 +833827 900979 +833829 526591 +833838 1002404 +833838 397620 +833838 543206 +833838 844419 +833838 861487 +833838 912007 +833840 216140 +833840 262940 +833840 268272 +833840 375279 +833840 522210 +833840 696260 +833840 761118 +833840 833181 +833840 95537 +833840 95544 +833842 1053059 +833842 1192841 +833842 1211021 +833842 1436793 +833842 1468646 +833842 1552022 +833842 2129597 +833842 2413299 +833842 289522 +833842 598601 +833842 696200 +833842 835518 +833842 844249 +833842 852709 +833842 855061 +833842 855761 +833842 861487 +833842 861690 +833842 872899 +833842 92243 +833842 931244 +833842 944044 +833842 997191 +833851 115463 +833851 1312375 +833851 153980 +833851 1636374 +833851 255804 +833851 262940 +833851 269254 +833851 375279 +833851 377139 +833851 3887234 +833851 415725 +833851 424576 +833851 526579 +833851 538821 +833851 65796 +833851 671328 +833851 793064 +833851 832951 +833851 834389 +833851 835190 +833851 837568 +833851 837584 +833851 846290 +833851 890675 +833851 900110 +833851 944146 +833879 833722 +833879 836151 +833879 836155 +833879 836156 +833886 1064108 +833886 394791 +833886 394796 +833886 573239 +833886 855072 +833886 966366 +833886 966367 +833887 833108 +833887 833446 +833891 1060267 +833891 1060268 +833891 260744 +833891 898730 +833891 926720 +8339 12765 +8339 15223 +8339 230766 +8339 81493 +8339 8364 +833903 961751 +833904 1192643 +833904 835106 +833904 835107 +833904 848756 +833931 835474 +833931 835479 +833986 1030674 +833986 115469 +833986 1393151 +833986 269254 +833986 271870 +833986 342541 +833986 395913 +833986 397620 +833986 406271 +833986 406273 +833986 406285 +833986 435555 +833986 454293 +833986 472036 +833986 490279 +833986 690972 +833986 696188 +833986 696225 +833986 706861 +833986 736606 +833986 835184 +833986 837568 +833986 841355 +833986 857659 +833986 860230 +833986 869570 +833986 882946 +833986 900820 +833986 95539 +834 14521 +834000 833240 +834050 1802107 +834050 2024990 +834050 356317 +834050 361805 +834050 379691 +834050 671331 +834050 774481 +834050 833018 +834050 835060 +834050 870832 +834050 870833 +834050 883952 +834050 924333 +834050 967387 +834051 1028502 +834051 108568 +834051 454293 +834051 517144 +834051 832900 +834051 832989 +834051 834640 +834051 834643 +834051 847180 +834051 869570 +834057 838200 +834071 451534 +834071 495010 +834071 653372 +834071 833687 +834073 39874 +834073 833664 +834073 842888 +834073 915657 +834073 92243 +834090 1045530 +834090 1135228 +834090 500231 +834090 649585 +834090 834088 +834090 834094 +834090 835650 +834091 834088 +834094 1135228 +834094 500231 +834094 649585 +834094 834088 +834094 835650 +834101 1014466 +834101 1028502 +834101 1306131 +834101 1437991 +834101 1655036 +834101 1655223 +834101 206281 +834101 224329 +834101 262940 +834101 271874 +834101 27519 +834101 3488542 +834101 379809 +834101 388185 +834101 397616 +834101 406281 +834101 435555 +834101 454293 +834101 479033 +834101 479036 +834101 517144 +834101 517163 +834101 522209 +834101 522210 +834101 532086 +834101 538821 +834101 547969 +834101 550341 +834101 623293 +834101 688716 +834101 696165 +834101 704150 +834101 754894 +834101 784121 +834101 809856 +834101 832900 +834101 832917 +834101 832951 +834101 833068 +834101 833293 +834101 833686 +834101 833687 +834101 833697 +834101 833851 +834101 834378 +834101 835073 +834101 835112 +834101 835190 +834101 836443 +834101 838243 +834101 838244 +834101 838588 +834101 846180 +834101 855065 +834101 859780 +834101 864672 +834101 867946 +834101 880957 +834101 914907 +834101 915941 +834101 918338 +834101 942359 +834101 954795 +834101 95544 +834158 836464 +834223 108439 +834223 1283938 +834223 1334420 +834223 1346687 +834223 1476956 +834223 1679539 +834223 1679540 +834223 27519 +834223 283469 +834223 299702 +834223 368137 +834223 388185 +834223 517144 +834223 547969 +834223 547971 +834223 578727 +834223 623293 +834223 809856 +834223 833293 +834223 95544 +834224 834227 +834224 978126 +834226 1528200 +834226 335760 +834226 550341 +834226 859452 +834226 864672 +834226 882946 +834227 1246887 +834227 1958967 +834229 1325919 +834229 833787 +834235 32194 +834235 680111 +834240 260744 +834240 368137 +834240 564649 +834240 834245 +834240 837386 +834240 898730 +834240 989683 +834241 260744 +834241 368137 +834241 564649 +834241 834240 +834241 834245 +834241 898730 +834245 260744 +834245 368137 +834245 564649 +834245 754974 +834245 898730 +834245 92243 +834293 1482969 +834293 490279 +834293 846293 +834293 900110 +83432 221917 +834324 834322 +834329 834322 +834329 834324 +834330 1248409 +834330 1404047 +834354 230047 +834378 1032225 +834378 1054398 +834378 1129949 +834378 115469 +834378 258078 +834378 3119866 +834378 361808 +834378 704150 +834378 795171 +834378 833315 +834378 833686 +834378 846970 +834378 925945 +834378 95539 +834378 95543 +834378 970420 +834380 834379 +834389 415725 +834389 424576 +834389 95546 +834395 1393151 +834395 368137 +834395 754974 +834396 207945 +834396 406423 +834396 834397 +834396 841441 +834396 842233 +834396 843658 +834396 844245 +834396 849148 +834396 860952 +834396 95537 +834397 1381485 +834397 361608 +834397 406423 +834397 832995 +834397 834398 +834397 838040 +834397 961746 +834399 260744 +834399 833686 +834399 833687 +834399 845359 +834488 326620 +834516 595478 +834516 846125 +834518 595478 +834518 832952 +834518 834516 +834518 899843 +834521 95544 +834522 153980 +834522 838776 +834534 1021949 +834534 1284343 +834534 953014 +834577 1028502 +834577 153980 +834577 27519 +834577 283122 +834577 2924017 +834577 2971546 +834577 299702 +834577 393383 +834577 397616 +834577 415725 +834577 454293 +834577 547969 +834577 547971 +834577 626175 +834577 744724 +834577 809856 +834577 832962 +834577 833560 +834577 834223 +834577 834578 +834577 858577 +834577 858578 +834577 915941 +834577 944146 +834578 108568 +834578 192325 +834578 216140 +834578 262940 +834578 283122 +834578 283473 +834578 2954287 +834578 304973 +834578 304975 +834578 308115 +834578 395913 +834578 406273 +834578 415720 +834578 435555 +834578 451535 +834578 552196 +834578 696225 +834578 744724 +834578 832661 +834578 833033 +834578 834713 +834578 835112 +834578 842132 +834578 95544 +834578 96123 +8346 78900 +834606 834602 +834611 1041914 +834611 1584466 +834611 224329 +834611 260744 +834611 262940 +834611 274325 +834611 283122 +834611 289522 +834611 299702 +834611 388185 +834611 415725 +834611 454293 +834611 522209 +834611 522210 +834611 578737 +834611 626175 +834611 712500 +834611 754974 +834611 833840 +834611 837575 +834611 842132 +834611 846180 +834611 858577 +834611 942019 +834641 931425 +834643 834640 +834646 1028502 +834646 1251615 +834646 1328919 +834646 1362829 +834646 1428247 +834646 2307193 +834646 262940 +834646 27519 +834646 282137 +834646 283122 +834646 283125 +834646 343871 +834646 379809 +834646 448007 +834646 454293 +834646 517165 +834646 522210 +834646 547969 +834646 547971 +834646 626175 +834646 809856 +834646 832661 +834646 832917 +834646 833038 +834646 833068 +834646 833128 +834646 834051 +834646 834101 +834646 834577 +834646 834578 +834646 838243 +834646 838295 +834646 844250 +834646 869568 +834646 869569 +834646 869570 +834646 883257 +834646 895152 +834646 95546 +834647 1380023 +834647 1380024 +834647 517153 +834647 552195 +834647 833686 +834703 1274505 +834703 1340656 +834703 1364371 +834703 1370946 +834703 1419770 +834703 1589970 +834703 3149322 +834703 361592 +834703 451534 +834703 743704 +834703 833185 +834703 834088 +834703 844675 +834703 858834 +834703 880947 +834703 971041 +834707 1364371 +834707 834703 +834713 2954287 +834827 412218 +8349 11584 +8349 1173306 +8349 140631 +8349 150114 +8349 15346 +8349 16614 +8349 21059 +8349 226585 +8349 29614 +8349 4013 +8349 476827 +8349 5521 +8349 64 +8349 78900 +8349 8346 +8349 960293 +83492 1477394 +834969 860586 +83497 1055 +835 184778 +835 202075 +835057 833722 +835057 836156 +835060 356317 +835061 356317 +835061 361805 +835061 835060 +835062 356317 +835062 361805 +835062 835060 +835062 835061 +835066 832942 +835070 1336922 +835070 1861476 +835070 2135132 +835070 2667956 +835070 380704 +835070 435555 +835070 595478 +835070 647295 +835070 832952 +835070 835073 +835070 835088 +835070 835187 +835070 956329 +835071 2612968 +835071 835073 +835071 835210 +835073 1041310 +835073 1044334 +835073 108439 +835073 2612968 +835073 397616 +835073 435555 +835073 460621 +835073 595478 +835073 704150 +835073 826839 +835073 835112 +835073 835187 +835073 835208 +835073 835210 +835073 835213 +835073 842085 +835073 854161 +835073 859780 +835073 863251 +835085 578727 +835085 95537 +835085 95546 +835088 1360089 +835088 2135132 +835088 835090 +835090 1032240 +835090 1250175 +835090 1990133 +835090 227843 +835090 2666389 +835090 267134 +835090 538646 +835090 688034 +835090 851590 +835091 1322911 +835091 1622861 +835091 1883012 +835091 435555 +835091 835073 +835091 835112 +835102 1455146 +835106 1233376 +835106 844675 +835107 1233376 +835107 835106 +835107 844675 +835112 1376703 +835112 1679489 +835112 192325 +835112 448007 +835112 696225 +835112 835187 +835113 435555 +835113 835406 +835113 95543 +835128 262940 +835128 397620 +835128 523633 +835132 696225 +835132 706861 +83516 134839 +83516 83517 +83517 134839 +835184 514691 +835190 224329 +835190 262940 +835190 490290 +835190 696257 +835190 832951 +835190 833560 +835190 837573 +8352 33670 +835204 2004798 +835208 435555 +835208 842085 +835212 835073 +835212 835213 +835213 1831747 +835213 435555 +835213 595478 +835248 218414 +835265 1718587 +835265 457732 +835265 833599 +835265 836441 +835265 868370 +83529 375749 +8353 205253 +8353 5762 +8353 66733 +835350 997629 +835392 2179274 +835392 776858 +835396 2179274 +835396 776858 +835396 835392 +835409 282137 +835415 454981 +835415 823059 +835415 908890 +835415 988713 +835474 835479 +835518 836429 +835519 1492922 +835519 260744 +835519 283127 +835519 552195 +835519 604396 +835519 617404 +835519 641250 +835519 833697 +835519 865050 +835520 826833 +835520 833786 +835520 837511 +835520 837515 +835520 839640 +835520 978253 +835529 858436 +835529 858437 +835548 842077 +835550 582509 +83559 43128 +835626 1539851 +835626 834088 +835626 835646 +835626 835650 +83563 96395 +835642 1539851 +835642 671331 +835642 834088 +835642 835626 +835642 835646 +835642 835650 +835642 835927 +835642 836063 +835642 836065 +835642 836153 +835642 837582 +835642 837585 +835646 1539851 +835646 834088 +835646 835650 +835650 1109393 +835650 659779 +835650 834088 +835650 834091 +835724 212299 +835724 610798 +835726 212299 +835726 610798 +835726 835724 +835730 1054398 +835730 115461 +835730 115469 +835730 1653520 +835730 269254 +835730 27519 +835730 304968 +835730 361814 +835730 395913 +835730 397616 +835730 406273 +835730 410038 +835730 415725 +835730 424576 +835730 456926 +835730 547969 +835730 547971 +835730 552196 +835730 809856 +835730 833788 +835730 833851 +835730 834389 +835730 855059 +835730 855061 +835730 896978 +835730 944146 +835730 998416 +835731 294746 +835731 318371 +835731 443259 +835731 580684 +835731 832962 +835733 1294345 +835733 1908726 +835733 2518110 +835733 2532965 +835733 262940 +835733 282137 +835733 532273 +835733 839085 +835733 853477 +835733 862694 +835733 883123 +835733 961426 +835733 982123 +835735 1440574 +835735 2518111 +835735 269254 +835735 292345 +835735 393383 +835735 729646 +835735 832655 +835735 832962 +835735 833163 +835735 833164 +835735 835073 +835735 835184 +835735 837660 +835735 841590 +835735 843643 +835735 844441 +835735 851310 +835735 870697 +835735 900812 +835739 1037730 +835739 434026 +835739 843513 +835739 849795 +8358 151075 +835892 1279344 +835892 454293 +835892 895152 +835927 1109393 +835927 659779 +835927 834088 +835927 834091 +835927 835650 +835964 490281 +835964 526595 +835964 526596 +835968 192327 +835968 262940 +835968 696134 +835968 696260 +835968 704150 +836011 283469 +83606 20718 +836063 1539851 +836063 1788026 +836063 1788027 +836063 834088 +836063 835650 +836063 835927 +836065 1539851 +836065 834088 +836065 835650 +836065 835927 +836065 836063 +836065 960909 +836065 960943 +836084 688716 +836084 844606 +836085 434336 +83609 1764454 +83609 447620 +836105 779780 +836105 897153 +836106 356317 +836106 836105 +836106 844445 +836106 850222 +836111 704150 +836114 779781 +836114 900433 +836114 960940 +836114 998335 +836115 779781 +836115 833217 +836115 837442 +836115 875353 +836115 875368 +836115 897150 +836115 960912 +836116 960926 +836124 1053170 +836124 1173606 +836124 1236438 +836124 1735011 +836124 2129013 +836124 2402947 +836124 2402948 +836124 3101195 +836124 833549 +836124 842085 +836124 861476 +836124 941855 +836124 996443 +836125 1030558 +836125 1057451 +836125 1057453 +836125 1133130 +836125 1586536 +836125 1594223 +836125 1670502 +836125 260744 +836125 277423 +836125 283127 +836125 435555 +836125 448007 +836125 448008 +836125 448010 +836125 641250 +836125 648030 +836125 688716 +836125 833698 +836125 835112 +836125 835519 +836125 837518 +836125 842238 +836125 858375 +836125 861476 +836125 865657 +836125 869605 +836125 883315 +836125 901880 +836125 956952 +836125 970420 +836127 1412850 +836127 1412851 +836127 170759 +836127 848609 +836127 905491 +83614 89768 +836151 1639402 +836151 304975 +836151 833205 +836151 833721 +836151 833722 +836151 836115 +836151 836156 +836151 836379 +836151 836380 +836152 2501562 +836152 716084 +836152 833217 +836152 833722 +836152 836115 +836152 836151 +836152 836156 +836152 836185 +836152 836379 +836152 837588 +836152 870694 +836152 896248 +836152 899625 +836152 961426 +836153 1034911 +836153 1539851 +836153 1619482 +836153 1726981 +836153 833722 +836153 834088 +836153 835057 +836153 835650 +836153 836063 +836153 836156 +836153 918927 +836154 1619482 +836154 3308562 +836154 832655 +836154 833205 +836154 833722 +836154 835057 +836154 836115 +836154 836151 +836154 836152 +836154 836153 +836154 836156 +836154 836379 +836154 836380 +836154 841571 +836155 833722 +836155 836151 +836155 836156 +836156 833205 +836156 836115 +836156 836379 +836156 836380 +836165 108566 +836165 3078236 +836165 517153 +836165 623293 +836165 703271 +836165 715381 +836165 793064 +836165 833033 +836165 834101 +836165 840391 +836165 843513 +836165 849062 +836165 883257 +836165 908890 +836165 922565 +836165 999914 +836184 1353208 +836184 1899278 +836184 3430309 +836184 349296 +836184 533488 +836184 716084 +836184 836185 +836184 844189 +836184 848263 +836184 855072 +836184 861690 +836185 716084 +836191 836190 +83634 22882 +83634 321583 +836349 842641 +836379 836115 +836379 875353 +836379 875368 +836379 960912 +836380 833205 +836380 836115 +836380 836152 +836380 836379 +8364 14997 +8364 15223 +8364 15256 +8364 17392 +8364 18353 +8364 22610 +8364 27234 +8364 31425 +8364 6070 +8364 64594 +8364 6905 +8364 69235 +8364 8364 +83641 32915 +83641 53800 +836429 192325 +836429 269254 +836429 27519 +836429 454293 +836429 578727 +836429 754894 +836429 809856 +836429 832917 +836429 833560 +836429 834229 +836429 869570 +836429 940128 +836429 95542 +836439 1053915 +836439 1053916 +836439 873185 +836441 1718587 +836441 457732 +836441 833599 +836441 95537 +836442 1046946 +836442 206281 +836442 712270 +836442 842265 +836442 946199 +836442 95541 +836443 406281 +836443 550341 +836445 356317 +836445 65796 +836445 836105 +836445 842641 +836445 897153 +83646 1812587 +83646 76865 +836487 833073 +836487 837520 +836487 861487 +836488 1900632 +836488 328856 +836488 653535 +836488 836490 +836488 863507 +836534 229665 +836546 836547 +836585 260744 +836585 283122 +836585 415720 +836585 754974 +836603 1157481 +836603 1157491 +836603 627128 +836647 2324863 +836665 1236553 +836665 2066290 +836665 522269 +836665 713519 +836665 833217 +836665 836666 +836665 842644 +836665 844160 +836666 1236553 +836666 2066290 +836666 522269 +836666 833217 +83667 67113 +836725 285148 +836725 689895 +836744 837588 +836744 837589 +836744 858579 +836755 712268 +836774 1058304 +836774 779781 +836774 837442 +836774 839007 +836895 836894 +836897 837588 +836897 837589 +837 457864 +837 457865 +837 49112 +837008 647782 +837008 834223 +837009 578727 +837009 809856 +83701 1779108 +837024 283844 +837060 1511355 +837060 439664 +837060 683885 +837060 826840 +837060 833543 +837060 833787 +837060 861487 +837060 865655 +837060 915657 +837062 2241400 +837062 2241401 +837062 593620 +837062 666508 +837062 833553 +837062 990584 +837063 2661644 +837063 351666 +837063 459676 +837063 617404 +837063 696267 +837063 842585 +837115 836665 +837115 842644 +837197 1162254 +837221 1251026 +83723 1009568 +83723 1009570 +83723 2900206 +83723 300160 +83724 30700 +83724 465367 +83740 14068 +83740 17960 +83740 3332803 +837407 1046945 +837407 1122169 +837407 1236438 +837407 1558211 +837407 833168 +837407 922551 +837432 779781 +837432 837442 +837442 779781 +837442 836897 +837442 861282 +837442 960900 +837450 368137 +837450 871323 +837453 1053915 +837453 1053916 +837453 356317 +837453 835060 +837453 836439 +837453 873185 +837490 1297439 +837490 260744 +837490 833697 +837490 978333 +837495 283127 +837495 455839 +837495 578737 +837498 283122 +837498 446577 +837498 526409 +837498 526411 +837498 754974 +837498 833446 +837498 835518 +837498 869694 +837498 880609 +837498 882033 +837502 260744 +837502 283122 +837502 397620 +837502 754974 +837502 837545 +837511 814478 +837511 833664 +837511 834073 +837511 837512 +837511 861476 +837511 915657 +837511 92243 +837512 1032278 +837512 1478675 +837512 1636340 +837512 1728371 +837512 526591 +837512 561054 +837512 833168 +837512 833664 +837512 834073 +837512 838932 +837512 842888 +837512 861476 +837512 915657 +837512 92243 +837515 814478 +837515 833664 +837515 834073 +837515 837511 +837515 837512 +837515 861476 +837515 915657 +837515 92243 +837518 1057453 +837518 435555 +837518 459676 +837518 725023 +837518 833445 +837518 833697 +837518 835112 +837518 835519 +837518 837545 +837518 845358 +837518 861475 +837518 883315 +837518 932630 +837520 1284573 +837520 1591238 +837520 2586229 +837520 454293 +837520 502809 +837520 517153 +837520 573239 +837520 575045 +837520 641164 +837520 754894 +837520 833071 +837520 833073 +837520 833169 +837520 833173 +837520 834641 +837520 842238 +837520 844416 +837520 844418 +837520 851590 +837520 859036 +837520 861476 +837520 861487 +837520 883315 +837520 931425 +837527 1079561 +837527 1129949 +837527 1169515 +837527 1224766 +837527 1245031 +837527 1245032 +837527 1245033 +837527 1278653 +837527 1420541 +837527 1496956 +837527 1640338 +837527 1934787 +837527 2033933 +837527 2316576 +837527 2333160 +837527 262940 +837527 2674068 +837527 2918310 +837527 3248391 +837527 368137 +837527 395913 +837527 454293 +837527 696169 +837527 704150 +837527 712500 +837527 833821 +837527 833824 +837527 841590 +837527 842223 +837527 843127 +837527 847489 +837527 850908 +837527 861581 +837528 262940 +837528 532273 +837528 574914 +837528 696215 +837528 696260 +837528 833554 +837528 835733 +837528 839085 +837528 880607 +837528 880609 +837528 912007 +837529 1023677 +837529 1313284 +837529 1400010 +837529 1477181 +837529 2085393 +837529 349296 +837529 368137 +837529 454293 +837529 462603 +837529 526591 +837529 626175 +837529 696192 +837529 712500 +837529 754974 +837529 832701 +837529 833075 +837529 833163 +837529 833164 +837529 833554 +837529 833824 +837529 833827 +837529 833829 +837529 837527 +837529 838931 +837529 841590 +837529 841593 +837529 842222 +837529 842223 +837529 850899 +837529 850906 +837529 850908 +837529 851310 +837529 855063 +837529 855072 +837529 855170 +837529 862697 +837529 882023 +837529 888414 +837529 896995 +837529 900979 +837529 95546 +837529 973042 +837530 1528200 +837530 550341 +837530 834226 +837530 914678 +837530 965144 +837532 2219913 +837532 3740167 +837532 55683 +837532 833686 +837532 837534 +837532 839514 +837532 841593 +837532 842132 +837532 857122 +837532 900812 +837532 900979 +837532 998855 +837533 270225 +837533 454293 +837533 462603 +837533 833164 +837533 837527 +837533 837529 +837533 841590 +837533 850908 +837534 1205848 +837534 1374321 +837534 253245 +837534 262940 +837534 311048 +837534 3338724 +837534 532273 +837534 795195 +837534 841593 +837534 842132 +837534 850893 +837534 861489 +837534 900979 +837535 1022025 +837535 262940 +837535 473837 +837535 532273 +837535 574914 +837535 696215 +837535 833554 +837535 835733 +837535 837528 +837535 839085 +837543 1356337 +837543 304975 +837545 1032225 +837545 1032226 +837545 260744 +837545 270225 +837545 283122 +837545 725023 +837545 834229 +837545 839990 +837545 855170 +837545 858372 +837548 1291352 +837548 696257 +837548 855057 +837548 982126 +837549 192325 +837549 517165 +837549 696225 +837550 833686 +837568 299702 +837568 388185 +837568 838929 +837568 842888 +837568 941077 +837573 283122 +837573 299702 +837573 395913 +837573 490290 +837573 712500 +837573 754974 +837573 833560 +837575 260744 +837575 283122 +837575 696225 +837575 744724 +837575 833560 +837577 1589566 +837577 454293 +837577 842132 +837577 844250 +837582 837585 +837583 837589 +837583 95537 +837584 1032227 +837584 368137 +837584 377139 +837584 538821 +837584 837568 +837585 2606344 +837585 3068272 +837585 793064 +837585 837588 +837588 837583 +837588 837589 +837588 858579 +837589 252872 +837589 858579 +837599 429264 +837600 744724 +837600 997585 +837615 154287 +837615 502819 +837615 842134 +837626 837627 +83763 1759682 +83763 312060 +83763 3918 +83763 465367 +83763 83724 +83763 83770 +83766 965186 +837660 1440574 +837660 1732861 +837660 1899278 +837660 2501562 +837660 2518111 +837660 349296 +837660 393383 +837660 700443 +837660 716084 +837660 836152 +837660 836184 +837660 836185 +837660 837657 +837660 837661 +837660 841590 +837660 844441 +837660 870697 +837660 877523 +837660 900812 +837660 912702 +837661 1017619 +837661 1233375 +837661 262940 +837661 397617 +837661 397620 +837661 415725 +837661 502809 +837661 527161 +837661 533488 +837661 573239 +837661 641164 +837661 700443 +837661 716084 +837661 832962 +837661 835735 +837661 836184 +837661 836185 +837661 841441 +837661 844189 +837661 844416 +837661 844418 +837661 844421 +837661 855761 +837661 861690 +837661 877523 +837661 912702 +837663 1481540 +837663 415720 +837663 454293 +837663 841590 +837673 1224766 +837673 2674068 +837673 837527 +837674 1183639 +837674 1239660 +837674 454981 +837674 538821 +837674 837550 +837674 852711 +837674 855065 +837674 889836 +83769 1881329 +83769 225161 +83769 2760167 +83770 83724 +837720 173728 +83775 977 +837765 696150 +837871 1862785 +837871 373345 +837871 526589 +837875 1006977 +837875 1076878 +837875 1568347 +837875 1886955 +837875 836665 +837875 840730 +837875 844160 +837881 1109417 +837881 1127509 +837881 1646875 +837881 395913 +837881 406273 +837881 833097 +837881 834577 +837881 842233 +837881 858577 +837881 858578 +837881 861942 +837881 861945 +837881 917612 +837881 974043 +837960 364838 +837960 899843 +8380 349895 +8380 7987 +838014 1555085 +838040 2258485 +838040 2258486 +838040 283469 +838040 624749 +838040 834398 +838040 95544 +838145 833697 +838145 833698 +83816 261971 +838168 2645574 +838168 833626 +838168 859855 +838169 388185 +838169 855065 +838178 2093054 +838190 1092492 +838203 834057 +838203 838200 +838226 1265313 +838226 2499852 +838226 27519 +838226 3265316 +838226 466390 +838226 759178 +838226 759182 +838226 809856 +838226 833315 +838226 833376 +838226 842108 +838226 843513 +838226 844423 +838226 855059 +838226 859452 +838226 864674 +838226 867849 +838226 918338 +838244 397616 +838295 1032521 +838295 1328919 +838295 2209779 +838295 283125 +838295 2977692 +838295 833033 +838295 883257 +838295 95544 +83832 1232695 +83832 93112 +838356 838357 +838360 838356 +838360 838357 +838380 153980 +838380 832924 +838380 837960 +838384 711106 +838400 1899278 +838400 283122 +838400 349296 +838400 754974 +838400 836184 +838400 837660 +838400 838407 +838400 855072 +838400 861690 +838400 95546 +838401 716084 +838401 754894 +838401 848263 +838407 1041969 +838407 1899278 +838407 349296 +838407 716084 +838407 836184 +838407 836185 +838407 837660 +838407 848263 +838407 855072 +838407 861690 +838409 212299 +838409 269254 +838409 39874 +838409 415725 +838409 454293 +838409 835735 +838409 841441 +838409 855761 +838409 861690 +838409 877520 +838409 877524 +838409 895780 +838409 92243 +838447 1114048 +838447 302675 +838447 647195 +838447 854513 +83846 142866 +83846 246649 +838588 1263034 +838588 27519 +838588 277879 +838588 299702 +838588 388185 +838588 517144 +838588 547969 +838588 620186 +838588 809856 +838588 832989 +838588 834051 +838588 834640 +838588 834643 +838588 855065 +838588 859448 +838588 868372 +838588 873814 +838588 95544 +838588 95546 +838588 961400 +838650 1030107 +838650 1309971 +838650 1309972 +838650 1309975 +838650 1309977 +838650 144051 +838650 382414 +838650 522210 +838650 873294 +838654 759425 +838654 838655 +838747 839127 +838821 1624864 +838868 1522980 +838868 754974 +838878 833686 +838878 845358 +838878 901880 +838882 2543168 +838929 754974 +838930 1129949 +838930 1220779 +838930 1294345 +838930 1652196 +838930 170759 +838930 1908726 +838930 1908876 +838930 1999264 +838930 2492982 +838930 2518110 +838930 2532965 +838930 2542688 +838930 262940 +838930 271870 +838930 397616 +838930 470931 +838930 525469 +838930 532270 +838930 55683 +838930 696169 +838930 703271 +838930 704150 +838930 833167 +838930 833168 +838930 833317 +838930 833787 +838930 835733 +838930 837527 +838930 841436 +838930 842223 +838930 844418 +838930 851418 +838930 853477 +838930 855065 +838930 855072 +838930 861487 +838930 862694 +838930 865055 +838930 869694 +838930 883123 +838930 899898 +838930 925944 +838930 961426 +838930 982123 +838931 855063 +838932 1032278 +838932 1169515 +838932 1245031 +838932 1245033 +838932 1278653 +838932 1478675 +838932 1636340 +838932 1671772 +838932 170759 +838932 1728371 +838932 2645574 +838932 3248391 +838932 526591 +838932 542507 +838932 703271 +838932 833842 +838932 844249 +838932 844418 +838932 858474 +838932 861487 +838953 1259101 +838953 454981 +838953 988713 +838983 262940 +838983 744724 +838984 262940 +838984 744724 +838984 833168 +838984 837657 +838984 837660 +838984 838983 +838984 861690 +838997 77165 +839002 844160 +839007 779781 +839007 837442 +83904 262940 +839043 839041 +839080 1616106 +839080 2281098 +839080 39874 +839080 415720 +839080 688716 +839080 834073 +839080 861487 +839080 883315 +839081 855761 +839081 869694 +839081 92243 +839085 683292 +839085 837450 +839087 1022025 +839087 842888 +839091 1283928 +839091 2002940 +839091 3488542 +839091 448008 +8391 188709 +839117 1438353 +839164 91912 +839233 1346687 +839234 95540 +839257 1541603 +839257 283127 +839257 573239 +839257 754974 +839257 855060 +839257 973042 +839411 192325 +839411 294746 +839411 3174982 +839412 1290374 +839412 260744 +839412 269254 +839412 283122 +839412 395913 +839412 712500 +839412 817480 +839412 861506 +839412 883962 +839412 883966 +839412 883967 +839412 966987 +839412 975145 +839500 861507 +839500 966252 +839501 839499 +839514 3740167 +839514 435555 +839514 517158 +839514 833686 +839514 854161 +839514 857122 +839544 839542 +839640 1229928 +839640 1259101 +839640 442174 +839640 620726 +839640 754974 +839640 833168 +839640 837511 +839640 837515 +839640 841593 +839640 900979 +839640 95546 +839640 978253 +839679 907452 +839696 2068346 +839696 415725 +839696 522209 +839696 522210 +839696 833168 +839696 838409 +839696 877520 +839696 877524 +839696 895780 +8398 16443 +8398 260 +8398 61752 +8400 196222 +8400 326937 +84000 180271 +84000 188038 +84000 237679 +84000 612213 +840033 2176594 +840033 774302 +840033 841797 +840033 842308 +840033 859024 +840033 869650 +840034 1197745 +840034 1692113 +840034 3042606 +840034 793064 +840034 842308 +840034 847372 +840034 849153 +840034 867925 +840034 870833 +840036 970416 +84009 167723 +8402 888250 +84023 414780 +84023 72186 +84024 439960 +84025 76764 +8403 8405 +84030 638775 +84033 263524 +84033 413271 +84033 55326 +84033 72186 +840346 1598183 +840349 283122 +840349 454293 +840349 96123 +840386 1259101 +840386 855971 +840391 836665 +840391 837115 +840391 842644 +840437 1387493 +840437 1945306 +840437 526416 +840437 624749 +840437 796211 +840437 916314 +840438 1032231 +840438 667503 +840438 833098 +840438 833446 +840438 859036 +840438 921168 +840462 1194142 +840462 154174 +840462 267134 +840462 415725 +840462 793064 +840462 836125 +840462 926716 +840557 1326028 +840557 840554 +840662 544758 +840662 544759 +84067 44086 +840730 1076878 +840730 1568347 +840730 1886955 +840815 2642371 +840952 206129 +840952 230723 +840952 454836 +840952 54335 +840981 1125825 +840981 1235882 +841 177156 +841 74 +8410 13706 +8410 31706 +84106 289089 +84106 34955 +841091 276578 +841154 7870 +841213 3488542 +841213 448008 +841294 262940 +841294 454293 +841332 194 +841332 2286030 +841350 177581 +841350 1876241 +841351 836547 +841351 867852 +841355 1868841 +841355 395913 +841355 406273 +841356 1019240 +841356 1021443 +841356 1032262 +841356 1284343 +841356 1297439 +841356 2414157 +841356 262940 +841356 299702 +841356 302078 +841356 317584 +841356 361074 +841356 374006 +841356 388185 +841356 508213 +841356 522209 +841356 522210 +841356 561054 +841356 837490 +841356 894398 +841356 900934 +841356 978333 +841356 990454 +841357 1595296 +841431 1500213 +841431 283127 +841431 833074 +841440 108566 +841440 115463 +841440 375279 +841440 65796 +841440 671328 +841440 793064 +841440 833851 +841441 153980 +841441 842233 +841441 849148 +841441 860952 +841441 914150 +841451 279474 +841452 1022039 +841452 192322 +841452 229547 +841452 341147 +841452 392717 +841452 623293 +841452 691665 +841452 842269 +841452 842271 +841452 842272 +841452 912384 +841453 192322 +841453 392717 +841456 1056568 +841456 108566 +841456 1769149 +841456 304973 +841456 894376 +841456 931384 +841533 1303395 +841533 260744 +841533 262940 +841533 736605 +841556 200967 +841565 2171726 +841567 1097419 +841571 1619482 +841571 833722 +841571 835057 +841571 836153 +841571 836156 +841590 262940 +841590 269254 +841590 393383 +841590 415720 +841590 441528 +841590 454293 +841590 696260 +841590 834577 +841590 847489 +841593 1040777 +841593 1447773 +841593 283122 +841593 368137 +841593 415720 +841593 577808 +841593 833560 +841593 842132 +841593 842888 +841593 859046 +841593 888414 +841602 1566351 +841660 1022025 +841660 1284573 +841660 1353208 +841660 1591238 +841660 1964301 +841660 2003657 +841660 3430309 +841660 415725 +841660 502809 +841660 573239 +841660 575045 +841660 641164 +841660 833667 +841660 836184 +841660 837520 +841660 837661 +841660 841441 +841660 844416 +841660 844418 +841660 844421 +841660 845763 +841660 845769 +841660 855759 +8417 8409 +841797 2176594 +841797 859024 +841803 164477 +841803 1672701 +841803 1672702 +841803 379816 +841803 434124 +841803 517153 +841803 700443 +841803 832962 +841803 834641 +841803 836897 +841803 837588 +841803 837589 +841803 837660 +841803 837661 +841803 842307 +841803 845760 +841803 861690 +841803 877523 +841803 891597 +841803 891601 +841803 912702 +841881 1805635 +84200 1349807 +84200 162932 +84200 245447 +84200 272040 +84200 348439 +842079 856008 +842080 730308 +842085 108566 +842085 1152498 +842085 578734 +842085 646859 +842085 845769 +842085 866595 +8421 62947 +842108 1502316 +842108 1502317 +842108 283122 +842108 454293 +842108 832699 +842108 832700 +842108 869570 +842108 95542 +842132 1060266 +842132 1060267 +842132 1060268 +842132 1079561 +842132 1137908 +842132 1569389 +842132 1934787 +842132 260744 +842132 27519 +842132 454293 +842132 704150 +842132 754974 +842132 833891 +842132 837527 +842132 841590 +842132 898730 +842132 926720 +842134 522209 +842134 522210 +842134 604396 +842134 842135 +842135 262940 +84214 238626 +84214 255117 +84214 40235 +842146 279614 +842146 3124487 +842146 388185 +842146 454293 +842146 95544 +842211 153980 +842212 846301 +842223 1245031 +842223 1420541 +842223 1477181 +842223 1496956 +842223 1908876 +842223 2085393 +842223 2333160 +842223 262940 +842223 368137 +842223 397620 +842223 39874 +842223 525469 +842223 696169 +842223 696215 +842223 833071 +842223 833163 +842223 833164 +842223 833821 +842223 833824 +842223 833827 +842223 841593 +842223 842222 +842223 851310 +842223 852703 +842223 861476 +842223 861581 +842223 865055 +842223 888414 +842223 899898 +842223 900979 +842223 95546 +842223 973042 +842233 2079492 +842233 262940 +842233 283122 +842233 322517 +842233 406278 +842233 456926 +842233 604396 +842233 703271 +842233 736606 +842233 754894 +842233 842888 +842233 843127 +842233 859780 +842233 882946 +842235 842234 +842238 1420649 +842238 1817323 +842238 2003657 +842238 260744 +842238 448010 +842238 573239 +842238 604396 +842238 646860 +842238 754974 +842238 833667 +842238 841660 +842253 1636229 +842253 539271 +842253 539272 +842253 973153 +842265 1046946 +842265 206281 +842265 341147 +842265 712270 +842265 946199 +842265 963376 +842269 1022039 +842269 912384 +842271 1022039 +842271 842269 +842271 842272 +842271 912384 +842272 1022039 +842272 842269 +842272 912384 +842307 108568 +842307 1437529 +842307 1733208 +842307 276145 +842307 532089 +842307 832962 +842307 833851 +842307 835735 +842307 841440 +842307 845760 +842307 891597 +842307 891601 +842308 108568 +842308 1154796 +842308 1217668 +842308 1604742 +842308 1628868 +842308 2003560 +842308 2003562 +842308 2176594 +842308 260744 +842308 283122 +842308 3042606 +842308 434124 +842308 774302 +842308 841797 +842308 846282 +842308 847372 +842308 859024 +842308 867835 +842312 337145 +842312 792988 +842355 399093 +842355 68137 +84236 262940 +84237 1385356 +842383 2134820 +842397 9462 +842518 1050296 +842518 1477103 +842518 227843 +842518 873811 +842518 938087 +842536 1254219 +842568 1003710 +842585 2661644 +842585 351666 +842585 617404 +842585 696267 +84259 116868 +842641 1023796 +842641 1438649 +842641 356317 +842641 836105 +842641 842645 +842641 871873 +842641 897153 +842643 842641 +842643 842645 +842645 356317 +842645 836105 +842645 897150 +842645 897153 +84265 27012 +84265 73139 +84265 75305 +842663 269254 +842663 397620 +842791 488279 +842799 641164 +842799 882809 +842822 835548 +842822 842831 +842822 843897 +842827 1429269 +842829 842824 +842832 835548 +842832 842822 +842832 843897 +842832 867177 +842832 950106 +842888 1354730 +842888 283122 +842888 283127 +842888 406281 +842888 604396 +842968 842967 +84302 1399 +84302 245734 +843028 233790 +843041 212299 +843041 92243 +843041 999189 +843127 704150 +843148 2326899 +843148 983349 +84316 1147 +84316 121805 +84316 22612 +84316 26547 +8432 5489 +843221 50577 +843325 843323 +84336 54356 +84338 141410 +84340 18088 +84340 317 +843433 1015406 +843433 1053194 +843433 1092490 +843433 1449987 +843433 716084 +843433 754894 +843433 789776 +843433 796210 +843433 798940 +843433 833179 +843433 833722 +843433 836151 +843433 836156 +843433 838401 +843433 844081 +843433 848263 +843433 862837 +843433 862840 +843513 108565 +843513 2004798 +843513 268272 +843513 418175 +843513 454293 +843513 832661 +843513 835113 +843529 294746 +843529 304975 +843529 472036 +8436 143140 +843618 199690 +843618 2480608 +843618 2510433 +843618 430816 +843643 262940 +843643 835073 +843643 899565 +843647 262940 +843647 841294 +843658 2104312 +843658 262358 +843658 392569 +843658 41715 +843658 776673 +843658 835070 +843658 957152 +84366 7991 +843805 313151 +843805 373892 +843805 374632 +843911 843913 +843913 1005954 +843937 457 +84400 518640 +844014 773740 +844014 804768 +844065 226461 +844065 885403 +844065 95537 +844081 1015406 +844081 1449987 +844081 833179 +84413 241139 +844147 1046945 +844189 533488 +844189 716084 +844189 836185 +844189 845763 +844189 963656 +844237 2305161 +844245 834397 +844246 434124 +844246 517163 +844246 862155 +844246 862158 +844248 192327 +844248 269254 +844248 832951 +844249 1022025 +844249 349296 +844249 835518 +844249 861487 +844250 283125 +844250 448010 +844250 502826 +844250 754894 +8444 124864 +8444 1781 +8444 211787 +8444 3455 +8444 71315 +8444 76040 +844416 108439 +844416 460621 +844416 835073 +844418 1284573 +844418 1476577 +844418 2193682 +844418 262940 +844418 2645574 +844418 271870 +844418 2982835 +844418 397620 +844418 526591 +844418 527161 +844418 641164 +844418 696188 +844418 700443 +844418 754974 +844418 838929 +844418 844416 +844418 844421 +844418 855065 +844418 978254 +844419 1353208 +844419 260744 +844419 283122 +844419 397620 +844419 451534 +844419 646866 +844419 696200 +844419 704150 +844419 833075 +844419 833163 +844419 841441 +844419 845760 +844419 845919 +844419 849477 +844419 861487 +844419 912007 +844421 641164 +844421 844416 +844441 1440574 +844441 2518111 +844441 393383 +844441 841590 +844441 870697 +844443 2176903 +844443 779780 +844443 836106 +844443 845760 +844451 1001311 +844513 26258 +84452 1564093 +84462 54069 +844675 1340656 +844675 1370946 +844675 1419770 +844675 3149322 +844675 743704 +844675 833185 +844675 836106 +844675 844443 +844675 858834 +844675 880947 +844782 681724 +844798 1326028 +844829 1436960 +845092 1161810 +845092 1561760 +845123 508131 +845155 1109391 +845155 1324365 +845155 671331 +845155 845154 +845155 845156 +845155 845160 +845156 1109391 +845156 1324365 +845156 845154 +845160 1109391 +845160 1324365 +845160 836665 +845160 837875 +845160 844160 +845160 845154 +845160 845156 +845344 326934 +845344 752964 +845358 283127 +845358 526411 +845358 833074 +845358 833168 +845358 833445 +845358 833686 +845358 833697 +845358 833787 +845358 835519 +845358 838930 +845358 841431 +845358 852345 +845358 865055 +845358 883315 +845359 262940 +845359 454293 +845359 499563 +845359 552195 +845359 826839 +845359 833686 +845359 939230 +845359 985088 +845360 459673 +845446 1079593 +845450 1732865 +845450 189821 +845450 2492078 +845450 874067 +845573 1093169 +8456 99402 +845737 1133324 +845748 847372 +845748 935812 +845752 283122 +845754 1353208 +845754 3557840 +845754 3557841 +845754 451534 +845754 646866 +845754 844419 +845754 845760 +845756 1046945 +845756 578734 +845756 844147 +845756 869031 +845760 1353208 +845760 1836744 +845760 1964301 +845760 3430308 +845760 3430309 +845760 646866 +845760 734491 +845760 836106 +845760 836184 +845760 841660 +845760 845771 +845764 696225 +845764 890414 +845768 435555 +845768 595478 +845769 1001311 +845769 207945 +845769 302078 +845769 646859 +845769 832952 +845769 844451 +845769 845763 +845769 866595 +845771 734491 +845775 696225 +845791 835090 +845854 208959 +84587 347846 +8459 116387 +845919 1688398 +846095 926095 +84613 18677 +846158 842825 +846180 108566 +846180 1092619 +846180 262940 +846180 269254 +846180 415725 +846180 522209 +846180 522210 +846180 523553 +846180 539272 +846180 834396 +846180 835518 +8462 1710 +8462 2583 +8462 29777 +8462 29841 +8462 34955 +8462 6212 +8462 69319 +846281 262940 +846281 268272 +846282 567209 +846284 262940 +846284 835518 +846285 1041969 +846285 1864137 +846285 260744 +846285 269254 +846285 863279 +846285 865661 +846290 1028502 +846290 108568 +846290 153980 +846290 262940 +846290 267134 +846290 269254 +846290 27519 +846290 348565 +846290 415725 +846290 424576 +846290 561054 +846290 704150 +846290 833097 +846290 833168 +846290 983825 +846293 415725 +846293 490279 +846293 842308 +846293 846282 +846293 900110 +846295 1030674 +846295 490279 +846299 895152 +8463 11828 +8463 99751 +846301 1037718 +846301 153980 +846301 269254 +846301 283469 +846301 3110406 +846301 517144 +846301 832661 +846301 838380 +846301 950082 +846446 386904 +846629 846628 +846662 244654 +84675 228511 +84675 670552 +84684 1456077 +84684 1559057 +84684 184712 +84684 1897205 +84684 190370 +84684 60742 +846942 517024 +846970 1133130 +846970 262940 +846970 499563 +846970 836125 +846970 883315 +847013 1134724 +847013 131517 +847013 1375344 +847013 52724 +847074 1114885 +847074 505738 +84715 72071 +847180 1015406 +847180 1326114 +847180 260744 +847180 283122 +847180 304968 +847180 456926 +847180 502809 +847180 598601 +847180 688716 +847180 696225 +847180 832900 +847180 833179 +847180 833697 +847180 842888 +847180 843911 +847209 627128 +847209 843127 +847324 1033221 +847324 847323 +847324 959207 +847368 522209 +847368 522210 +847368 842134 +847368 865411 +847478 834521 +847484 806436 +847484 858967 +84752 18839 +84752 262691 +84752 490610 +84752 85885 +84758 753543 +847691 404591 +84774 35445 +847754 388327 +847818 1009447 +847818 192325 +847818 226461 +847818 283469 +847818 304973 +847818 388185 +847818 406283 +847818 521381 +847818 578727 +847818 809856 +847818 833560 +847818 841593 +847818 95544 +847818 95546 +847818 96123 +847857 1245450 +848066 108568 +848066 262940 +848066 326635 +848066 833079 +848066 834523 +848066 848074 +848066 861507 +848066 896978 +848074 547969 +848074 547971 +848104 818192 +848129 756117 +848163 1322776 +848163 848161 +84819 191870 +848261 368137 +848261 523697 +848261 842134 +848261 882784 +848263 716084 +848263 754894 +848263 836185 +848263 855072 +84839 194 +84839 267648 +84839 2773261 +84839 30313 +84839 381534 +84839 415720 +84839 580166 +848406 193583 +848406 265382 +848406 265388 +848406 265422 +848406 61587 +848467 1277422 +848467 848468 +848467 848470 +848470 1277422 +848470 848468 +8485 439156 +848501 848528 +848540 834088 +848540 834091 +848540 835650 +848540 835927 +848540 837545 +848540 839990 +848540 848554 +848540 866648 +848540 890814 +848554 834088 +848554 834091 +848554 835650 +848554 835927 +8486 10310 +8486 19301 +848600 1447575 +848649 840554 +848756 1170758 +84882 244192 +848913 648554 +84892 240183 +8490 1515 +8490 1650972 +8490 171596 +8490 215810 +8490 233192 +8490 234107 +8490 26716 +8490 26717 +8490 41443 +8490 467945 +8490 527106 +8490 5486 +849062 2108156 +849062 793064 +849062 922565 +84908 236587 +8491 3296 +849128 836608 +849148 842233 +849148 860952 +849153 849148 +849163 145272 +849383 21139 +84942 161 +84942 9079 +849435 759186 +849435 849441 +849435 982225 +849443 759186 +849443 849435 +849443 849441 +849443 849445 +849443 982225 +849445 759186 +849445 849435 +849445 849441 +849445 982225 +849446 759186 +849446 849435 +849446 849441 +849446 849443 +849446 849445 +849446 982225 +849477 1022025 +849477 299702 +849477 3138900 +849477 696200 +849477 704150 +849477 841441 +84951 262350 +8496 170 +849674 260744 +849674 283122 +849674 454293 +849674 623293 +849674 703271 +849674 754974 +849674 843513 +849674 908890 +849674 999914 +849774 212255 +849774 2862019 +849774 3137617 +849774 3376298 +849774 466390 +849793 852992 +849795 900448 +849803 1372793 +849803 1533345 +849803 832696 +849834 1447505 +849920 59268 +850067 2027433 +850067 926723 +8501 1046 +850216 100422 +850224 844450 +8503 38781 +850395 411977 +850395 761591 +850424 850425 +8505 111053 +8505 45764 +850543 832962 +850543 914150 +850572 616684 +850698 920102 +850857 33762 +850889 1015817 +850889 1015826 +850889 1015827 +850889 1015831 +850889 1022025 +850889 260744 +850889 283127 +850889 446577 +850889 517158 +850889 526409 +850889 526411 +850889 532276 +850889 696253 +850889 833076 +850889 833163 +850889 833168 +850889 833446 +850889 833667 +850889 837498 +850889 838040 +850889 839087 +850889 841431 +850889 842888 +850889 850895 +850889 850897 +850889 850906 +850889 880609 +850889 882033 +850889 899693 +850889 907452 +850889 931244 +85089 184349 +850891 283123 +850891 696225 +850892 1136579 +850892 2068346 +850892 522209 +850892 522210 +850892 716084 +850892 754894 +850892 832701 +850892 833168 +850892 838401 +850892 839696 +850892 843433 +850892 848263 +850892 862836 +850892 862837 +850892 862840 +850893 1022025 +850893 1205848 +850893 2079156 +850893 253245 +850893 262940 +850893 299702 +850893 473837 +850893 837535 +850894 857117 +850895 260744 +850895 696253 +850895 833163 +850895 850897 +850895 850906 +850895 899693 +850897 260744 +850897 696253 +850897 754974 +850897 833163 +850897 833554 +850897 837498 +850897 838400 +850897 850906 +850897 855072 +850897 899693 +850899 1080246 +850899 1080247 +850899 1182783 +850899 1636340 +850899 2142756 +850899 2517927 +850899 270225 +850899 283122 +850899 341084 +850899 368137 +850899 415720 +850899 696192 +850899 754974 +850899 835518 +850899 841593 +850899 842223 +850899 851310 +850899 855061 +850899 855063 +850899 855066 +850899 855072 +850899 858371 +850899 862697 +850899 867992 +850899 900979 +850899 926979 +850899 937077 +850906 260744 +850906 283127 +850906 459673 +850906 459676 +850906 826840 +850906 837063 +850906 841431 +850908 454293 +850908 841590 +850909 1032226 +850909 1032277 +850909 1032278 +850909 1710599 +850909 833560 +850909 833667 +85111 30918 +851207 554431 +851215 229621 +851241 1112341 +851241 1831642 +8513 504504 +851310 1025834 +851310 1440574 +851310 2401903 +851310 2517927 +851310 2518111 +851310 269254 +851310 283122 +851310 292345 +851310 341084 +851310 349296 +851310 368137 +851310 393383 +851310 397620 +851310 415720 +851310 441528 +851310 626175 +851310 696192 +851310 696200 +851310 754974 +851310 833163 +851310 833560 +851310 833827 +851310 837503 +851310 837660 +851310 841590 +851310 841593 +851310 844441 +851310 850894 +851310 855063 +851310 855072 +851310 857113 +851310 857117 +851310 865661 +851310 867992 +851310 870697 +851310 900812 +851310 900979 +851312 696215 +851312 774485 +851312 835518 +851312 869694 +851312 933757 +85138 125333 +851407 851408 +851413 269254 +851413 397620 +851413 696200 +851413 851310 +851414 1055630 +851414 526416 +851414 978211 +851418 1003179 +851418 1032278 +851418 1341603 +851418 1377659 +851418 1447773 +851418 1481537 +851418 1578164 +851418 170759 +851418 2068048 +851418 397620 +851418 538646 +851418 577808 +851418 703271 +851418 833168 +851418 833317 +851418 833826 +851418 837503 +851418 841593 +851418 842223 +851418 842888 +851418 851310 +851418 861581 +851418 868929 +851418 899898 +851418 900979 +851418 925944 +851419 1229978 +851419 1341603 +851419 1415872 +851419 1447773 +851419 1478675 +851419 1481540 +851419 1640328 +851419 1666389 +851419 2012073 +851419 230140 +851419 253133 +851419 282137 +851419 3113077 +851419 415720 +851419 454293 +851419 462603 +851419 532270 +851419 696260 +851419 833168 +851419 837663 +851419 841590 +851419 841593 +851419 842132 +851419 842888 +851419 851418 +851419 854227 +851419 858371 +851419 862697 +851419 896995 +851419 900979 +851419 922015 +851419 925944 +85157 101268 +851589 1313279 +851589 415725 +851589 700443 +851589 837661 +851589 851590 +851589 855761 +851590 1591238 +851590 1990133 +851590 2666389 +851590 267134 +851590 415725 +851590 688034 +851590 700443 +851590 754894 +851590 842238 +851590 855761 +851590 861476 +85161 201047 +85161 492720 +851657 5113 +851808 109110 +851847 85768 +8520 1914722 +8520 4 +8520 4407 +8520 901535 +8520 9534 +8521 23448 +85217 1127319 +852345 833168 +852345 838930 +852345 865055 +85236 59703 +852384 153980 +852384 2268127 +852709 1934207 +852709 858480 +852709 868929 +852709 895152 +852709 92243 +85277 213208 +85286 62083 +85298 82048 +852992 523982 +852992 578737 +852992 842085 +8531 1545 +85310 391362 +85310 52883 +853155 638126 +853174 115461 +853174 282639 +853174 282644 +853174 366773 +853174 833688 +85321 196886 +853286 715817 +85330 4116 +85330 855413 +85330 9311 +853359 446105 +853359 552195 +853359 641250 +853359 688716 +853359 833697 +853360 1259761 +853360 1259762 +853360 1591238 +853360 397617 +853360 573239 +853360 754894 +853360 833071 +853360 835415 +853360 837520 +853360 837661 +853360 842238 +853360 851590 +853360 859446 +853360 861476 +853360 883315 +853360 908890 +85339 17689 +85339 187796 +853477 1908726 +853477 2518110 +853477 282137 +853477 883123 +853477 961426 +853477 982123 +8535 1074034 +8535 65047 +853513 1198987 +853520 256625 +853520 3230051 +853538 1181198 +853581 349750 +85390 85382 +85390 85392 +85392 85382 +853983 1012509 +853983 1092600 +853983 1114917 +853983 115469 +853983 154285 +853983 1604940 +853983 227874 +853983 227875 +853983 260744 +853983 289522 +853983 415725 +853983 454293 +853983 56052 +853983 653535 +853983 754978 +853983 834611 +853983 836588 +853983 853983 +853983 858577 +853983 920799 +853983 954507 +853983 954705 +8540 108708 +8540 181229 +8540 29690 +854043 854044 +854161 1044334 +854161 1314144 +854161 3022452 +854161 418175 +854161 435555 +854161 517158 +854161 599488 +854161 696192 +854161 833667 +854161 835112 +854161 835113 +854161 835187 +854161 854162 +854162 418175 +854162 435555 +854162 835113 +854227 1341603 +854227 1377659 +854227 1415872 +854227 2012073 +854227 855063 +854227 896995 +854228 1031262 +854228 1653542 +854228 577808 +854228 833625 +854230 754974 +85424 338801 +85424 639510 +8543 207620 +85438 37713 +85443 6574 +85445 91748 +854513 1058892 +854513 283473 +854513 406271 +854513 406285 +854513 696257 +854513 832661 +854513 835190 +854513 95542 +854553 854552 +854722 1193845 +854779 43956 +85478 15346 +854852 21763 +854918 425125 +854918 95546 +855 17112 +855 3714 +855032 289522 +855056 696260 +855056 833842 +855056 838932 +855056 844249 +855056 861487 +855056 880605 +855057 517144 +855059 1172316 +855059 153980 +855059 271874 +855059 703271 +855060 1541603 +855060 283127 +855061 1307754 +855061 262940 +855061 334081 +855061 835518 +855061 855059 +855061 999914 +855063 867992 +855065 271870 +855066 538821 +855066 835518 +855066 855061 +855072 1511355 +855072 2604177 +855072 283122 +855072 283127 +855072 299702 +855072 3650853 +855072 397620 +855072 439664 +855072 526591 +855072 526592 +855072 683885 +855072 696165 +855072 696260 +855072 716084 +855072 727253 +855072 795171 +855072 832942 +855072 833076 +855072 833543 +855072 833787 +855072 836185 +855072 837060 +855072 837498 +855072 841436 +855072 855072 +855140 904645 +855152 1927026 +855170 1032225 +855170 1032226 +855170 1636340 +855170 2517927 +855170 270225 +855170 283122 +855170 368137 +855170 462603 +855170 696192 +855170 736606 +855170 754974 +855170 833163 +855170 833827 +855170 838931 +855170 841593 +855170 842223 +855170 850899 +855170 851310 +855170 855057 +855170 855063 +855170 855072 +855170 858372 +855170 867992 +855170 888414 +855170 900979 +855179 1334841 +855218 108566 +855218 1479242 +855218 716084 +855218 836185 +855218 863491 +855218 864379 +85524 295032 +85524 319462 +85524 522846 +85524 849952 +85524 877201 +85528 14784 +85528 204510 +85528 557815 +85528 844014 +855412 199775 +855494 1137586 +855494 1478070 +85562 43174 +855709 1084956 +855709 1615220 +855709 1615221 +855709 283122 +855709 294746 +855709 534822 +855709 833167 +855709 833445 +855709 996444 +855758 1594257 +855759 1591238 +855761 1017619 +855761 212299 +855761 415725 +855761 598601 +855761 832962 +855761 835735 +855761 869694 +855761 92243 +855790 444606 +855790 881800 +8558 43359 +85580 126160 +85580 8761 +855889 1027180 +855889 867607 +855890 2409461 +855890 2409463 +855890 459676 +855890 610799 +855890 859036 +855890 861475 +855890 882724 +855890 948628 +8559 5980 +855971 1021949 +855971 1043427 +855971 1284343 +855971 3119866 +855971 825043 +855971 834378 +855971 834534 +855971 899565 +855971 953014 +8560 20517 +8560 74359 +856105 778217 +856151 276591 +856171 1125840 +85619 118186 +856233 1063297 +856233 1478923 +856233 908938 +856266 855733 +85627 1145679 +85627 14923 +85627 2218112 +856289 441676 +85629 341211 +85635 147367 +85653 14906 +8566 4382 +85666 427857 +856760 1820598 +856760 65891 +856803 800499 +856803 987422 +856851 1402419 +857 2184 +857 748 +857 952603 +8570 5017 +857108 834225 +857113 415720 +857113 626175 +857113 850894 +857113 857117 +857118 1582977 +857118 839082 +857122 3740167 +857122 833686 +857132 322517 +857251 1478514 +857282 62922 +857318 1328725 +857318 1507460 +857318 696188 +857318 973391 +85760 5164 +857611 1498562 +857611 676367 +857659 1261428 +857659 424150 +857659 833903 +857659 860230 +857659 938083 +857659 945174 +857661 1261428 +857661 424150 +857661 833903 +857661 857659 +857661 938083 +857661 945174 +85768 3582320 +857765 950550 +858 1705 +858 23017 +858 65705 +858034 1379053 +8581 875120 +858105 629483 +858200 1910565 +858200 858200 +8583 22217 +858371 1182783 +858371 2578612 +858371 415720 +858371 424576 +858371 454293 +858371 696260 +858371 744724 +858371 841590 +858371 937077 +858372 1032225 +858372 1080247 +858372 415720 +858372 749007 +858372 841593 +858372 900979 +858372 976242 +858372 998856 +858375 1031262 +858375 1653542 +858375 577808 +858375 688716 +858375 833625 +858375 854228 +858375 901880 +858380 1208452 +858380 1640328 +858380 2129819 +858380 577808 +858380 656869 +858380 833168 +858380 837674 +858380 858475 +858380 865655 +858380 882025 +858380 882026 +858380 882141 +858380 889836 +858384 339755 +858406 731665 +858411 731665 +858411 858406 +858436 858437 +858469 1006977 +858469 1076878 +858469 1568347 +858469 1886955 +858469 837875 +858469 840730 +858474 361814 +858474 703271 +858474 868929 +858475 895152 +858480 2736228 +858480 526596 +858488 202093 +858488 649582 +858488 798940 +8585 191080 +858578 858577 +858602 202490 +858756 1102665 +858834 1340656 +858834 1370946 +858834 3149322 +858834 833185 +858835 141 +85885 490610 +85887 85888 +858964 435555 +858964 517158 +858964 839514 +858964 854161 +8590 1943030 +85900 8279 +859036 1340360 +859036 1718409 +859036 454293 +859036 517165 +859036 833098 +859036 833168 +859036 833169 +859036 833173 +859036 833446 +859036 833553 +859036 837502 +859036 838930 +859036 845358 +859036 852345 +859036 865055 +859043 610798 +859043 65807 +859045 1933252 +859045 451535 +859045 859024 +85919 159878 +85919 85918 +85928 46752 +85929 11136 +85929 8175 +859310 859312 +859446 1057453 +859446 1259762 +859446 1346687 +859446 1531265 +859446 3506857 +859446 406281 +859446 406283 +859446 835415 +859446 839233 +859446 908890 +859448 2042826 +859452 517144 +859452 696188 +859452 855059 +85976 98494 +859777 406281 +859777 959952 +859778 1187544 +859780 1059060 +859780 1405965 +859780 192325 +859780 304975 +859780 361603 +859780 497542 +859780 623293 +859780 688716 +859780 832917 +859780 833560 +859780 833697 +859780 834051 +859780 834378 +859780 834518 +859780 847180 +859780 928199 +859855 2645574 +859855 833626 +859877 1478675 +859877 2129819 +859877 3519719 +859877 577808 +859877 837674 +859998 1531265 +859998 3506857 +859998 859446 +860179 253278 +860230 1381758 +860230 1974493 +860230 406273 +860230 448007 +860230 448010 +860230 539272 +860230 626175 +860230 868929 +860272 304975 +860272 860273 +860272 872649 +860334 419440 +860334 860333 +860334 860337 +860334 860338 +860337 419440 +860337 860333 +860338 419440 +860338 860333 +860338 860337 +860374 66147 +860517 872167 +860517 974507 +860517 985118 +86069 16794 +860694 1495429 +860731 754894 +86075 105450 +86075 67958 +86092 327983 +86092 377941 +86094 18956 +86094 212118 +86094 80124 +860952 578737 +860952 842085 +860952 842233 +860952 852992 +86115 2280606 +861175 194 +861270 1005207 +861270 1315847 +861270 459673 +861270 833125 +861270 974043 +861274 834640 +861274 834643 +861275 861272 +861275 861276 +861276 861272 +861282 779781 +861381 387954 +861474 170759 +861474 2129819 +861474 260744 +861474 283127 +861474 406278 +861474 575045 +861474 656869 +861474 833168 +861474 837550 +861474 837674 +861474 861476 +861474 861484 +861474 986112 +861475 1320220 +861475 260744 +861475 283127 +861475 459676 +861475 575045 +861475 646857 +861475 725023 +861475 833168 +861475 837545 +861475 859036 +861475 861474 +861475 861476 +861475 861484 +861475 932630 +861475 948628 +861476 1591238 +861476 1670502 +861476 1933252 +861476 2402947 +861476 2402948 +861476 260744 +861476 283127 +861476 448008 +861476 451535 +861476 454293 +861476 517153 +861476 517165 +861476 575045 +861476 754894 +861476 833168 +861476 833169 +861476 833173 +861476 833664 +861476 833824 +861476 834073 +861476 834641 +861476 837529 +861476 842085 +861476 842238 +861476 859024 +861476 859036 +861476 859045 +861476 861484 +861476 865055 +861476 915657 +861476 92243 +861476 931425 +861476 970420 +861483 762632 +861483 833168 +861484 260744 +861484 283127 +861484 575045 +861484 833168 +861484 837502 +861484 838930 +861484 845358 +861484 852345 +861484 859036 +861484 865055 +861485 1022025 +861485 1084955 +861485 833687 +861485 868798 +861487 1541603 +861487 283127 +861487 415720 +861487 688716 +861487 696225 +861487 696260 +861487 754974 +861487 826840 +861487 833075 +861487 839257 +861487 855060 +861487 855072 +861487 912007 +861489 1057453 +861489 1121948 +861489 1205848 +861489 253245 +861489 260744 +861489 262940 +861489 283127 +861489 573239 +861489 575045 +861489 814478 +861489 826840 +861489 833168 +861489 834641 +861489 837060 +861489 850893 +861489 861474 +861489 861475 +861489 861476 +861489 861484 +861489 861487 +861489 882032 +861489 883315 +861489 901880 +861489 915657 +861489 931425 +861499 1046946 +861499 696188 +861499 864674 +861499 978176 +8615 9991 +861500 2222288 +861500 3616691 +861500 985039 +861505 912866 +861506 845748 +861506 847372 +861506 935812 +861507 696188 +861507 864674 +861507 966252 +861581 1053170 +861581 1220779 +861581 1245031 +861581 1420541 +861581 1496956 +861581 2193682 +861581 2333160 +861581 2604177 +861581 277423 +861581 577808 +861581 696188 +861581 754974 +861581 832942 +861581 833071 +861581 833553 +861581 833821 +861581 838929 +861581 844418 +861581 855072 +861607 1821569 +861607 2230632 +861607 2754275 +861648 833722 +861648 833879 +861648 836151 +861648 836155 +861648 836156 +861689 835518 +861689 837498 +861689 869694 +861690 1017619 +861690 1552022 +861690 1899278 +861690 212299 +861690 303060 +861690 349296 +861690 700443 +861690 832962 +861690 835518 +861690 835735 +861690 837498 +861690 837657 +861690 837660 +861690 852709 +861690 855061 +861690 855761 +861690 861689 +861690 869694 +861690 877523 +861690 912702 +861690 92243 +861690 997191 +861691 835518 +861691 837498 +861691 861689 +861691 861690 +861691 869694 +861691 937077 +861777 1478032 +861805 1000280 +861805 1022025 +861805 1064107 +861805 1200910 +861805 2095470 +861805 2607337 +861805 2645574 +861805 318300 +861805 534822 +861805 564649 +861805 696253 +861805 744723 +861805 880725 +861805 978176 +861861 1541561 +861942 1109417 +861945 1109417 +861945 861942 +861951 283469 +861951 388185 +861951 415725 +861951 538821 +861951 578727 +861951 604396 +861951 754894 +861951 832917 +861951 832962 +861951 835518 +861951 861951 +861951 95542 +861951 95546 +861999 145895 +8620 837929 +862118 1827993 +862119 17531 +862119 350061 +862155 862158 +862157 517163 +862157 836447 +862157 844246 +862157 862155 +862157 862158 +862196 289089 +862196 368063 +862287 1288930 +862287 814826 +86244 101948 +86245 757229 +862477 862478 +86252 27751 +862520 227843 +862520 2300680 +862520 837543 +862694 1260218 +862694 1908726 +862694 2518110 +862694 282137 +862694 454293 +862694 833169 +862694 842132 +862694 853477 +862694 883123 +862694 887456 +862694 961426 +862694 982123 +862697 1481540 +862697 415720 +862697 454293 +862697 835518 +862697 837663 +862697 838931 +862697 841590 +862697 855061 +862697 855063 +862697 855066 +862697 855170 +862697 937077 +862836 716084 +862836 754894 +862836 832917 +862836 838401 +862836 843433 +862836 848263 +862836 862837 +862836 862840 +862837 716084 +862837 754894 +862837 798940 +862837 833722 +862837 836151 +862837 836156 +862837 838401 +862837 848263 +862837 862840 +862840 716084 +862840 754894 +862840 838401 +862840 848263 +862913 341147 +862914 1194475 +862982 11700 +863 200354 +863125 136056 +863125 153861 +863125 368511 +863251 2004798 +863251 418175 +863251 435555 +863251 832661 +863251 835112 +863251 835113 +863251 843513 +863254 1873860 +8633 328 +86336 135947 +863380 918524 +863481 863490 +863507 1900632 +863507 328856 +863507 653535 +8638 79078 +863918 119484 +863918 137203 +863918 256667 +863918 297020 +863918 416575 +86420 138089 +86420 36214 +86420 438548 +864379 108566 +864379 716084 +864379 836185 +864379 836894 +864379 836895 +864534 1347304 +864672 1014466 +864672 262940 +864672 532086 +864672 859780 +864674 833686 +864674 95546 +86470 313251 +86472 106453 +86472 1072839 +86472 291339 +86472 396939 +86472 50722 +86473 63839 +86473 86464 +86475 86482 +86481 961608 +864863 835474 +864863 835479 +86495 173359 +86495 173377 +86495 175587 +86495 175950 +86495 184491 +86495 195894 +86495 212571 +86495 216097 +865048 814478 +865048 833168 +865048 833554 +865048 833736 +865048 838930 +865048 845358 +865048 852345 +865048 859036 +865048 861484 +865048 865055 +865048 865654 +865048 865659 +865050 1022025 +865050 1586786 +865050 1586787 +865050 842238 +865054 283127 +865054 696225 +865054 833168 +865054 882946 +865055 696215 +865055 833071 +865055 833168 +865055 833824 +865055 837529 +865055 95546 +865058 1792424 +865058 283280 +865058 790550 +865058 914956 +865058 938452 +86515 37001 +865155 222875 +865251 1233084 +86529 62060 +865304 3275388 +86533 102834 +865411 522209 +865411 522210 +865411 842134 +865412 1028020 +865412 1223397 +865412 1223398 +865412 604629 +865412 828583 +865412 828588 +865412 912297 +86545 100313 +86545 20805 +86545 44915 +86545 801 +865456 447033 +865588 1512199 +865618 153980 +865618 832688 +86564 280347 +865654 108565 +865654 1416949 +865654 1424466 +865654 1430197 +865654 1508464 +865654 216140 +865654 260744 +865654 271870 +865654 283122 +865654 361814 +865654 397617 +865654 703271 +865654 814478 +865654 833168 +865654 833554 +865654 838930 +865654 845358 +865654 852345 +865654 852709 +865654 858474 +865654 859036 +865654 861484 +865654 865055 +865654 868929 +865654 882018 +865654 915657 +865655 1061521 +865655 1220778 +865655 1220779 +865655 1511355 +865655 2604177 +865655 2645574 +865655 277423 +865655 683885 +865655 696225 +865655 814478 +865655 833071 +865655 833168 +865655 833543 +865655 833554 +865655 833736 +865655 833787 +865655 838930 +865655 845358 +865655 852345 +865655 855072 +865655 855073 +865655 858475 +865655 859036 +865655 861484 +865655 865048 +865655 865055 +865655 865654 +865655 865659 +865655 882026 +865655 895152 +865657 1057453 +865657 842238 +865657 883315 +865659 1326574 +865659 1541603 +865659 1578164 +865659 1728372 +865659 2068048 +865659 2129819 +865659 283127 +865659 2982835 +865659 397620 +865659 446577 +865659 526411 +865659 538646 +865659 538821 +865659 696220 +865659 696257 +865659 727253 +865659 814478 +865659 833074 +865659 833168 +865659 833554 +865659 833628 +865659 833787 +865659 833826 +865659 837674 +865659 838930 +865659 839257 +865659 841431 +865659 844418 +865659 845358 +865659 851418 +865659 852345 +865659 855060 +865659 859036 +865659 861484 +865659 861487 +865659 865055 +865659 865654 +865659 899898 +865659 978254 +865659 986112 +865661 1440574 +865661 2518111 +865661 269254 +865661 292345 +865661 349296 +865661 393383 +865661 39874 +865661 454293 +865661 455839 +865661 517165 +865661 578737 +865661 833164 +865661 833167 +865661 833169 +865661 833173 +865661 833554 +865661 835518 +865661 835735 +865661 837520 +865661 837660 +865661 841590 +865661 844441 +865661 859036 +865661 861476 +865661 870697 +865661 900812 +865661 941850 +865664 1211012 +865664 394791 +865664 502826 +865670 51067 +865732 280935 +865784 184001 +865791 269195 +865913 216448 +866 1649 +866 17399 +866 2184 +866 41863 +866 857 +86618 201571 +866544 975861 +866595 646859 +866646 1021211 +866646 1255713 +866646 1273314 +866646 435555 +866648 837545 +866648 839990 +866648 890814 +86666 308 +866755 288233 +86695 315727 +866958 425125 +866958 854918 +866958 900056 +866973 348307 +866975 229665 +867121 1460283 +86716 153320 +86716 28568 +86716 324 +867177 842822 +867177 843897 +8672 95537 +867201 867199 +867203 1488744 +867203 526591 +867203 855061 +867203 880609 +867236 216140 +867236 96123 +867251 2196755 +867431 3468535 +867436 944886 +867599 3580866 +867599 492930 +867607 1027180 +867655 1576 +867659 1047947 +867659 1092492 +867659 3011155 +867659 495010 +867694 10043 +867694 1143320 +867699 583750 +86773 146152 +867740 262940 +867740 322517 +867740 578727 +867740 835518 +867740 842233 +867740 849690 +867740 869570 +867835 1604742 +867835 2079655 +867835 711200 +867835 842832 +867835 950106 +867835 987109 +86784 86732 +867849 864674 +867852 1053192 +867852 836547 +867893 867894 +867925 578734 +867925 793064 +867925 870833 +867946 1037859 +867946 479037 +867946 754894 +867946 832917 +867946 95544 +867974 269254 +867974 834378 +867975 1443207 +867975 418175 +867976 260744 +867976 269254 +867976 283122 +867976 397616 +867976 459673 +867976 845359 +867985 1031467 +867985 283127 +867985 696193 +867985 833168 +867985 833626 +867985 833628 +867985 865054 +867988 1053170 +867988 1173606 +867988 833549 +867988 836124 +867991 1261307 +867991 153980 +867991 374006 +867995 262940 +867995 2736228 +867995 394791 +868 109038 +868 137860 +868 2953 +868 477948 +868 5314 +868 868 +868029 10589 +868070 868068 +868146 520482 +868155 1460283 +868155 867121 +868257 578727 +868334 153980 +868370 1046945 +868370 1315847 +868370 833687 +868372 1353620 +868372 304968 +868372 502826 +868372 517144 +868372 547969 +868372 547971 +868372 754894 +868372 867946 +868372 95544 +868372 96123 +868373 283473 +868373 368137 +868373 406281 +86839 230133 +868445 1102057 +868445 1258097 +868445 2145356 +86852 121887 +868550 136172 +868798 1022025 +868798 1084955 +868798 833687 +868929 361814 +869 870 +869 89 +869031 1046945 +869031 578734 +869031 844147 +869054 1450655 +869054 212301 +869054 222384 +869054 344166 +869054 361595 +869054 413127 +869054 744724 +869054 890223 +869054 985935 +869075 869074 +869120 864317 +869144 1823368 +869265 1103989 +869265 1215993 +869265 1798537 +869265 327416 +869265 350933 +869265 969067 +869265 969070 +869493 730308 +869493 869498 +869498 730308 +869568 1028502 +869568 454293 +869568 834051 +869568 869570 +869569 1028502 +869569 454293 +869569 834051 +869569 869568 +869569 869570 +869570 454293 +869570 754894 +869570 832917 +869570 849690 +869589 1061521 +869589 1964162 +869589 696225 +869589 833073 +869591 2500296 +869591 3580866 +869591 492930 +869591 867599 +869591 996442 +869605 260744 +869605 283127 +869605 573235 +869605 573239 +869605 575046 +869605 578737 +869605 646860 +869605 688716 +869605 833168 +869605 833553 +869605 842238 +869605 858375 +869605 883315 +869605 901880 +869605 971040 +869650 108568 +869650 2176594 +869650 260744 +869650 283122 +869650 578719 +869650 624749 +869650 774302 +869650 836608 +869650 838040 +869650 840034 +869650 841797 +869650 842308 +869650 849128 +869650 859024 +869650 867925 +869650 870833 +869694 375279 +869694 835518 +869694 92243 +869704 27952 +869704 937713 +869707 27952 +869716 801146 +86975 172490 +86975 227480 +86975 372873 +869770 869768 +869796 260744 +869796 262940 +869796 368137 +869796 521381 +869797 1337833 +869797 1938047 +869797 696225 +86984 4449 +869854 23930 +8699 15900 +8699 17546 +8699 27991 +8699 29974 +8699 3747 +87 1328 +87 2187 +87 31934 +870 857 +870 860 +8701 243692 +870173 1040777 +870173 1066447 +870173 1341604 +870173 1430196 +870173 1919176 +870173 1931864 +870173 1931865 +870173 577808 +8702 1473 +8702 2318 +8702 3286391 +870324 1436318 +870326 2063312 +870326 2205727 +87036 830528 +870450 1421376 +870620 870619 +870631 1385352 +870631 1570195 +870631 1790630 +870631 269254 +870631 27519 +870631 299702 +870631 388185 +870631 397616 +870631 628237 +870631 809856 +870631 834398 +870633 1005954 +870694 837588 +870697 393383 +870697 841590 +870792 845763 +870792 898403 +870793 793064 +870793 840462 +8708 1102643 +8708 287580 +870832 986222 +870833 1039625 +870833 1356610 +870833 375279 +870833 379816 +870833 391762 +870833 870832 +870833 998654 +870852 454293 +870852 838929 +870899 1103526 +870899 178828 +870899 2345637 +870899 372299 +871 149 +871 1706 +871 17111 +871 1990849 +871 3567329 +871 3805 +871249 746664 +87127 450242 +871277 452918 +871277 849690 +871323 1021949 +871323 1284343 +871323 206281 +871323 262940 +871323 268272 +871323 271874 +871323 368137 +871323 454293 +871323 522209 +871323 522210 +871323 834534 +871323 855971 +871323 884221 +871323 953014 +871457 341770 +871496 576026 +871496 696225 +871496 890414 +871552 125388 +871552 42917 +871617 1291421 +871617 1637596 +871617 1637597 +871617 1799023 +87178 5758 +8718 2302863 +8718 282296 +871873 1023796 +871873 1438649 +871963 2332725 +872 55572 +872030 339765 +872030 736604 +872030 931368 +872036 1482082 +872098 587167 +87215 14678 +87215 297515 +87215 87216 +87216 297515 +872218 136056 +872312 283469 +872312 832898 +87235 150275 +87239 228104 +87250 479865 +87250 966521 +87251 143017 +87251 261123 +87251 3808022 +872558 283127 +872558 454293 +872558 754974 +872558 833071 +872558 833550 +872558 833553 +872558 835066 +872558 855072 +872577 1046946 +872577 108566 +872577 206281 +872577 341147 +872577 712270 +872577 832962 +872577 835735 +872577 836442 +872577 842265 +872577 902982 +872577 946199 +872577 963376 +872584 1263534 +872584 459674 +872649 860273 +872667 9897 +872699 1190128 +872743 262940 +872743 835518 +872743 846284 +872771 1134365 +8728 3178 +87286 325700 +872899 1053059 +872899 289522 +872899 696200 +872899 835518 +8729 963610 +87297 18085 +87298 1794468 +87298 1845278 +8731 8936 +873180 108566 +873180 1152498 +873180 578734 +873180 842085 +873185 1053915 +873185 1053916 +873185 1507723 +873186 1138898 +873186 1138901 +873186 2006344 +873186 575045 +873273 837582 +873273 837585 +873346 846296 +873487 1312348 +873489 1069472 +873501 1177615 +873546 725023 +873562 873280 +87361 21581 +873812 846281 +873812 900448 +873814 1491036 +873814 361074 +873814 456926 +873814 626175 +873814 712500 +873814 834611 +873814 883808 +873814 961400 +87398 99293 +874157 1986785 +87420 176437 +87442 378013 +87443 147666 +874501 268272 +874501 846281 +874501 900448 +874551 1415713 +874551 205812 +874551 2230881 +874561 108568 +874561 216140 +874561 226461 +874561 299702 +874561 304973 +874561 304975 +874561 388185 +874561 96123 +874562 226461 +874562 27519 +874562 809856 +87461 11575 +874619 1557003 +874619 17966 +874619 284321 +874692 1175775 +87474 15626 +87474 205270 +874943 839412 +874943 882842 +874943 946554 +874944 1450896 +874944 325672 +874986 874985 +87504 87506 +875066 2706736 +87519 113463 +87519 220594 +87519 257120 +87519 74210 +8752 101487 +8752 106101 +8752 214815 +8752 21903 +8752 31821 +8752 355013 +8752 62621 +8752 655795 +8752 820748 +8752 85597 +8752 94412 +875252 875256 +875368 875353 +875368 960912 +875370 875353 +875370 875368 +875370 960912 +875421 275799 +875447 1063022 +8755 1107 +87558 215458 +87582 1065010 +87582 8285 +87582 97139 +8760 141549 +8760 1615988 +8760 164165 +8760 26918 +876050 2047034 +876050 3272744 +8761 6029 +87615 68154 +876191 1104072 +87622 114992 +876250 681724 +876288 2137562 +87637 182471 +87640 58574 +876469 210577 +8765 1375 +876507 302644 +87652 168843 +87652 486750 +87652 83081 +87653 39829 +87685 81445 +877078 192729 +87708 87716 +87717 501552 +87717 65120 +87721 56621 +877454 2670721 +877515 1203230 +877515 454293 +877515 894188 +877515 954705 +877520 415725 +877520 877524 +877523 832962 +877523 835731 +877526 1191308 +877526 2381784 +877526 252872 +877526 519934 +877526 822410 +877526 822517 +877526 877524 +877526 918924 +877614 1058540 +877614 339765 +877614 736604 +877614 872030 +877614 931339 +87767 24159 +877703 342363 +877777 1030674 +877777 1409738 +877777 1465204 +877777 490279 +877777 846295 +877779 1831675 +877779 649000 +877779 704150 +877929 239305 +877929 494714 +878093 54918 +87811 13914 +87814 177651 +878186 149278 +878186 247945 +878186 507784 +878186 878186 +87837 82248 +878393 135829 +87854 17231 +878587 962209 +878587 962210 +878587 962211 +878659 2052784 +878659 672905 +878709 259299 +8788 132192 +8788 1949549 +8788 250467 +8788 49359 +8788 52052 +87880 528676 +87883 219704 +879 1210137 +879 16827 +879 3330 +879 71773 +87906 2486850 +87906 2553697 +87906 656584 +879156 252872 +879156 837589 +87925 100145 +87925 1065010 +87925 479893 +879324 902427 +879327 72729 +879423 283913 +87944 2332 +87962 139279 +879705 1826693 +879705 188420 +879705 1992324 +879705 247528 +879705 848600 +879751 879754 +879751 879755 +879755 879754 +879953 279706 +880077 1466510 +880077 410038 +880077 439843 +880236 842134 +880236 848261 +880293 872030 +8803 1750541 +8803 208928 +8803 235979 +8803 50055 +88030 89660 +88031 35518 +880605 1406392 +880605 1424606 +880605 1516797 +880605 406281 +880605 696260 +880605 899900 +880607 696260 +880607 912007 +880609 1488744 +880609 696260 +880609 833446 +880609 855061 +880609 880605 +880609 880607 +880609 882033 +880609 912007 +880644 45650 +88066 88071 +88066 88072 +880663 23387 +88071 88072 +88072 155774 +88072 165268 +88072 216448 +880758 951228 +880758 969882 +880769 1112340 +880769 153980 +880769 880077 +880947 1340656 +880947 1370946 +880947 3149322 +880947 833185 +880947 858834 +880957 454293 +880957 704150 +880957 833169 +880965 1656817 +880965 262940 +880965 835518 +88124 97542 +881379 1182580 +881437 269254 +881437 510013 +881437 836588 +881443 260744 +881443 415720 +881488 1356669 +881488 2004748 +881488 2485933 +881488 288386 +881488 832661 +881488 896029 +881488 934199 +88153 663814 +8816 84795 +881609 252754 +88168 103067 +88174 17428 +88175 210204 +881800 39874 +881800 881801 +881801 39874 +88186 88187 +88192 36561 +882018 1313284 +882018 1430197 +882018 170759 +882018 2401903 +882018 260744 +882018 283122 +882018 835518 +882018 837529 +882018 850906 +882018 851310 +882018 855061 +882018 855066 +882018 986112 +882019 108439 +882019 108565 +882019 1149753 +882019 1239660 +882019 1252375 +882019 1279686 +882019 1344131 +882019 1430197 +882019 1440242 +882019 1478675 +882019 1541468 +882019 170759 +882019 192327 +882019 224329 +882019 229547 +882019 262940 +882019 270225 +882019 283122 +882019 395913 +882019 406273 +882019 406281 +882019 406283 +882019 538821 +882019 656869 +882019 696181 +882019 696257 +882019 696260 +882019 704150 +882019 754974 +882019 833486 +882019 835968 +882019 882018 +882019 889200 +882019 925944 +882019 966985 +882019 986112 +882021 1071276 +882021 1424464 +882021 1424465 +882021 1424466 +882021 1424467 +882021 895152 +882022 1022025 +882022 1616106 +882022 269254 +882022 299702 +882022 397620 +882022 406281 +882022 696200 +882022 696260 +882022 833667 +882022 839080 +882022 849477 +882022 851310 +882022 851413 +882022 855056 +882022 899624 +882022 900807 +882022 986111 +882023 526591 +882023 833829 +882024 1208452 +882024 1229978 +882024 1344131 +882024 1344132 +882024 1377659 +882024 1478675 +882024 1571673 +882024 1638152 +882024 1638154 +882024 1666389 +882024 2250166 +882024 283127 +882024 3251830 +882024 3251834 +882024 3251835 +882024 3279815 +882024 3370827 +882024 454293 +882024 833071 +882024 833169 +882024 851419 +882024 974483 +882025 1208452 +882025 577808 +882025 882141 +882026 858475 +882026 895152 +882032 834641 +882032 931425 +882141 577808 +88228 307964 +882349 154174 +882391 882390 +882391 882391 +8825 79078 +88250 30816 +88266 41270 +88266 587078 +88266 5980 +88266 8559 +882709 1688398 +882709 304975 +882709 688034 +882709 754974 +882709 832989 +882709 842234 +882709 845919 +882724 108439 +882758 836885 +882764 882811 +882768 260744 +882768 283127 +882784 1047628 +882784 532414 +882784 647782 +882784 837008 +882822 882764 +882822 882811 +882825 866575 +88285 2112245 +882946 1733209 +882946 696225 +883123 282137 +883123 961426 +883123 982123 +883256 1295452 +883256 284099 +883257 1028020 +883257 108565 +883257 1199356 +883257 2004798 +883257 261451 +883257 262940 +883257 271870 +883257 27519 +883257 342541 +883257 377139 +883257 379809 +883257 397617 +883257 418175 +883257 424576 +883257 435555 +883257 456926 +883257 538821 +883257 539271 +883257 539272 +883257 626175 +883257 639960 +883257 712500 +883257 744724 +883257 809856 +883257 832661 +883257 832951 +883257 833128 +883257 833376 +883257 833710 +883257 833851 +883257 834101 +883257 834611 +883257 835113 +883257 835190 +883257 835521 +883257 843513 +883257 859452 +883257 863251 +883257 865412 +883257 873814 +883257 954795 +883257 999914 +883315 1057453 +883315 1133130 +883315 1591238 +883315 2586229 +883315 260744 +883315 415720 +883315 435555 +883315 448007 +883315 448010 +883315 573239 +883315 646860 +883315 648030 +883315 688716 +883315 754894 +883315 833071 +883315 833168 +883315 833445 +883315 833697 +883315 834641 +883315 835112 +883315 835519 +883315 842238 +883315 842888 +883315 851590 +883315 861476 +883315 861487 +883315 882032 +883315 893904 +883315 931425 +883315 956952 +883380 883381 +883380 914150 +883381 914150 +8834 1285 +8834 8930 +88351 36527 +88353 2603724 +883641 115469 +883641 262940 +883641 523633 +883641 762355 +883641 834378 +883641 95543 +883689 262940 +88370 3570230 +883759 1570195 +883759 870631 +883762 779781 +883762 834389 +883762 837432 +883762 837442 +883762 926325 +883777 262940 +883777 269254 +883777 334081 +883777 397616 +883777 833317 +883777 883689 +883808 1218998 +88390 106331 +88390 114652 +88390 1153613 +88390 154537 +88390 22270 +88390 270803 +88390 276730 +883952 356317 +883952 835060 +883962 861506 +883962 873178 +883962 883966 +883962 883967 +883966 861506 +883966 873178 +883967 861506 +883967 873178 +883967 883966 +88401 482066 +884062 1102665 +884062 576026 +884081 1505474 +884081 364550 +884163 336320 +884221 454293 +884221 522209 +884221 522210 +884222 884223 +884344 455839 +884344 508213 +884344 578737 +884545 1274375 +884545 262940 +884545 406281 +884545 725023 +884545 864672 +884545 873546 +884633 526596 +884633 895152 +88480 1528758 +88480 159526 +884828 130791 +884909 3787296 +88495 145062 +88495 194 +88495 29895 +88495 52145 +88496 106541 +88496 117101 +88496 25872 +88510 838511 +885103 1546881 +885103 1615988 +885103 229665 +885103 232956 +885103 51984 +885103 836534 +88519 285757 +885403 1092492 +885403 226461 +885403 2265441 +885403 833686 +885589 920972 +885724 885725 +885766 843911 +885766 843913 +885767 1627381 +885767 834378 +885767 835090 +88583 243560 +885845 260744 +885845 644726 +885845 834534 +885845 843323 +885845 843325 +885845 963376 +88589 1144828 +885971 100752 +885971 14743 +885971 17587 +885971 261878 +885972 885103 +886113 161608 +886267 1034853 +886267 1955510 +886267 2043981 +886267 602946 +886267 743753 +886366 143109 +886366 613277 +886375 108565 +886375 361074 +886375 456926 +886375 961400 +886376 1021032 +88643 2939161 +886484 886483 +88689 125120 +8869 4312 +886937 982893 +88700 298294 +88700 89598 +88700 96408 +887052 51350 +887218 423955 +88729 138076 +88729 48686 +88733 217161 +88733 272604 +88733 5825 +887456 454293 +887456 842132 +88749 1744 +88749 88750 +887637 532164 +887637 549367 +8880 218 +8880 26923 +8880 281 +8880 2851 +8880 285484 +8880 305 +8880 43442 +8880 4954 +8880 7830 +8880 875327 +8880 8880 +88809 4948 +888092 1185752 +88813 35461 +888150 724529 +88822 6344 +888250 1207592 +888264 1846756 +888414 368137 +8885 1162938 +8885 158662 +8885 5140 +888615 1770383 +888658 375279 +8887 159826 +8887 29923 +88872 121721 +888854 1412846 +888854 1412850 +888854 1412851 +888854 170759 +888854 279614 +888854 342543 +888854 523633 +888854 623293 +888854 833579 +888854 833986 +888854 836127 +888854 905491 +888963 172724 +889103 211804 +889139 1093015 +889139 1117716 +8892 133465 +889200 1390360 +889200 1615876 +889200 2129819 +889200 406283 +889200 656869 +889200 696257 +889200 754974 +889200 837674 +889200 986112 +889297 755644 +889347 995592 +88937 183488 +88937 250833 +889549 124607 +8896 384515 +8896 648123 +8897 166784 +889719 889724 +889770 2147780 +8899 15780 +88990 9686 +89005 120594 +89005 155154 +89005 210195 +89005 409950 +8901 1219490 +8901 73352 +89012 938405 +8902 35086 +8902 4003524 +8902 450886 +890200 3002116 +890213 627811 +890414 858577 +890425 2162959 +890425 2828645 +890469 1711902 +89062 294145 +89063 235359 +890675 207945 +890675 2537322 +890675 302078 +890675 725144 +890675 793064 +890675 832962 +890675 833097 +890675 914150 +890779 2186339 +8908 10986 +890801 600134 +890814 837545 +890814 839990 +890828 1214485 +890828 3484376 +890926 833686 +890926 834378 +891 283 +891 39273 +891 50132 +89109 148040 +89109 19145 +89109 89110 +89110 19145 +89110 335067 +891105 227842 +891202 1005207 +891202 1009230 +891202 1021948 +891202 459673 +891202 861270 +8913 29869 +89142 3145198 +891561 230520 +891595 1337833 +891595 395913 +891595 406273 +891595 448007 +891595 497542 +891595 832661 +891595 944142 +891595 944143 +8916 834 +891601 891597 +891662 1276133 +89170 98541 +891845 891842 +891868 891869 +891962 432361 +891993 372877 +891993 772492 +892 37413 +892113 155432 +89217 1210175 +8925 1145122 +8925 2104 +8925 791414 +892515 1090946 +892641 2398065 +892744 458702 +892744 53799 +892835 688716 +892835 754894 +892835 784121 +892835 835190 +892952 467247 +8930 1285 +893051 1478675 +893051 2129819 +893051 3519719 +893051 577808 +893051 837674 +893051 859877 +89337 84643 +893379 34236 +893493 1936552 +893590 262940 +893590 452918 +893590 849690 +893590 864672 +893638 894200 +893904 842238 +893935 2183622 +894105 3488542 +894105 448008 +894105 696225 +89415 1384901 +89415 289530 +89415 289531 +89415 64778 +89416 9546 +894169 995177 +894188 1203230 +894188 1233375 +894188 267134 +894188 3042186 +894188 415725 +894188 454293 +894188 833166 +894188 954705 +89434 106993 +894376 1056568 +894376 931384 +894410 283125 +894410 696225 +89442 123199 +894458 13451 +894474 2712660 +89449 72881 +894690 1143164 +894690 1300485 +895114 6004 +895152 260744 +895152 703271 +895152 833168 +895152 858380 +895161 1204589 +895161 1206836 +895161 283469 +895161 304975 +8953 54224 +895582 1422857 +89568 89569 +895688 747014 +895690 1600007 +895780 415725 +895780 877520 +895780 877524 +8958 114363 +89592 145811 +895978 754974 +895978 834245 +895978 92243 +896000 895999 +896007 896006 +89604 1495685 +896116 355013 +89618 105450 +896248 833217 +896248 837588 +896248 870694 +896248 961426 +896249 1032225 +896249 262940 +896249 368137 +89660 10497 +89660 136219 +89660 162617 +89660 72308 +89660 911933 +89676 17392 +89676 769863 +89677 1052316 +896804 394796 +896804 538821 +896804 696165 +896804 857318 +896804 864674 +896804 867995 +896804 973391 +896804 978211 +8969 36012 +89693 1006301 +89693 41415 +89693 691520 +896978 395913 +896978 406273 +896978 833079 +896980 328844 +896980 349139 +896995 841593 +897150 1023796 +897150 1438649 +897150 356317 +897150 836105 +897150 836379 +897150 842641 +897150 871873 +897150 875353 +897150 875368 +897150 897153 +897150 960912 +89719 29207 +897378 1463723 +897378 164279 +89743 4312 +89749 1564083 +897548 1027682 +897548 899550 +897585 916970 +897682 187796 +89784 993566 +898038 978661 +898191 121278 +8982 1108875 +8982 113405 +8982 14218 +8982 289724 +8982 3061550 +8982 350578 +8982 82257 +89824 3864444 +89824 669988 +89824 89823 +89825 89823 +898289 34001 +898289 898289 +898392 839002 +898392 844160 +898403 1708948 +898403 1714457 +898403 1939635 +898403 839002 +898403 844160 +898403 845763 +898403 861282 +898403 898392 +898403 898398 +89854 58494 +89866 59048 +898682 4506 +898730 260744 +898730 368137 +898730 653535 +8988 28680 +898854 835548 +898854 898855 +898855 1150819 +898855 835548 +898890 2194 +898890 415964 +898890 54523 +898890 689243 +898890 898894 +89892 972281 +8990 436084 +8990 933581 +899139 194 +899246 899248 +899356 1051393 +899356 1861594 +899356 2675346 +899356 917611 +899364 2224295 +8994 100593 +89940 59588 +899550 1027682 +899561 1025804 +899565 703271 +899624 1022025 +899624 299702 +899624 849477 +899625 1260218 +899625 39874 +899625 454293 +899625 490279 +899625 490290 +899625 833169 +899625 833217 +899625 835735 +899625 837588 +899625 838409 +899625 842132 +899625 862694 +899625 870694 +899625 887456 +899625 896248 +899625 961426 +899626 833792 +899640 489191 +899693 260744 +899693 833163 +899693 850906 +89970 251536 +89970 89972 +899745 678799 +899823 956398 +899831 252263 +899831 322246 +899852 915929 +899875 899874 +899898 1999264 +899898 2129819 +899898 397616 +899898 397620 +899898 538821 +899898 542501 +899898 573239 +899898 575046 +899898 683885 +899898 833553 +899898 837674 +899898 869694 +899898 941850 +899900 1406392 +899900 1424606 +899900 1516797 +89998 89999 +90 2187 +90 3870 +90 904909 +900056 425125 +900056 854918 +900094 25758 +900097 1390870 +90010 142152 +900110 23165 +900124 1638967 +90013 175252 +90013 57509 +900180 1022025 +900180 1031230 +900180 262940 +900180 283127 +900180 349296 +900180 368137 +900180 754974 +900180 833554 +900180 835518 +900180 844249 +900180 855072 +900180 861487 +900180 931244 +900180 991636 +90021 14586 +900253 647856 +9003 24204 +90037 115941 +90037 137602 +90037 37120 +900378 841439 +90040 43469 +900448 1917218 +900448 268272 +900448 3460300 +900448 825043 +900448 846281 +900646 894965 +90065 208414 +900714 3068815 +90074 321946 +900807 1409738 +900807 1951772 +900807 1951773 +900807 406281 +900807 490279 +900807 696260 +900807 855056 +900812 1440574 +900812 2518111 +900812 3740167 +900812 393383 +900812 833686 +900812 839514 +900812 841590 +900812 844441 +900812 857122 +900812 870697 +90083 3978592 +90083 810188 +90086 677676 +90087 820950 +900883 1181940 +900884 1283441 +900884 1492272 +900891 1092557 +900934 1032262 +900934 302078 +900934 522209 +900934 522210 +900979 1040777 +900979 1447773 +900979 283122 +900979 368137 +900979 415720 +900979 577808 +900979 833698 +900979 841593 +900979 842132 +900979 842888 +900979 859046 +900979 888414 +900979 896995 +900988 1033260 +900988 1039572 +900988 900992 +900992 1039572 +901031 1065010 +901031 300542 +9011 639708 +90113 155201 +90113 272157 +90113 304114 +90113 649836 +901196 2194948 +90120 1737167 +90120 2414972 +90120 2414973 +90120 361539 +90120 361656 +90120 442896 +90120 9729 +901329 1297901 +901329 493012 +901329 748468 +901332 190141 +901332 193117 +901332 920263 +901455 341452 +901539 915355 +90154 359707 +90154 56677 +901740 281171 +901880 573239 +901880 688716 +901880 833686 +901880 833697 +901880 834641 +901880 845358 +901880 853359 +901880 882032 +901880 883315 +901880 931425 +901937 4019401 +902 42249 +902 5545 +90203 25872 +90203 358719 +90203 7871 +90210 146060 +90210 25872 +90225 491206 +902433 2219617 +902433 2292684 +9025 195157 +90251 92623 +902551 364547 +902666 156019 +902666 265390 +902746 734816 +902845 930055 +902980 1173674 +902980 1440951 +902980 902982 +902982 1173674 +902982 832962 +902982 835735 +903 22765 +903 30918 +90305 264833 +903134 252692 +90332 213862 +903537 159907 +90370 33573 +903706 1216065 +903706 2365801 +903706 2498725 +903706 662168 +903899 283857 +903899 594765 +90396 176601 +90396 77621 +90396 786215 +90396 786216 +904030 800342 +904210 1138172 +904213 904214 +904214 1169438 +90424 346146 +904253 904252 +904253 904254 +904254 904252 +90432 113878 +90432 21504 +90444 1362182 +90451 7173 +904600 2108499 +904600 2117615 +904600 372855 +904600 702282 +90472 1646649 +9050 80786 +905147 1023227 +905147 319800 +90517 21468 +90537 73161 +90540 85729 +90541 180585 +905491 1009447 +905491 1147100 +905491 179709 +905492 374777 +905492 617133 +905492 837549 +90559 408145 +9056 1864113 +90566 404136 +90566 404137 +90571 2423686 +905783 496464 +905797 905796 +905857 323533 +905982 1172316 +905982 192325 +905982 27519 +905982 299702 +905982 317584 +905982 388185 +905982 395913 +905982 406273 +905982 406281 +905982 406283 +905982 547969 +905982 547971 +905982 623293 +905982 809856 +905983 454979 +906068 3127680 +906068 349147 +90607 305560 +906104 364481 +906171 150920 +90622 39344 +906242 184001 +906242 552775 +906242 60636 +906242 865784 +906296 425124 +906296 425125 +906296 455839 +906296 576237 +906296 906298 +906298 425124 +906298 425125 +906298 455839 +906320 232186 +906335 1012592 +90640 142954 +90659 75380 +9066 30336 +906716 921873 +906798 1415408 +906798 493551 +906873 1032521 +906873 2209779 +906873 838295 +906941 241617 +906966 113916 +907 92536 +9070 1016605 +9070 1087387 +9070 10927 +9070 13303 +9070 1462131 +9070 1546073 +9070 1618691 +9070 16204 +9070 16966 +9070 185613 +9070 18963 +9070 18964 +9070 19081 +9070 213047 +9070 254737 +9070 267937 +9070 278959 +9070 294196 +9070 298861 +9070 3274044 +9070 336768 +9070 37594 +9070 41055 +9070 522847 +9070 535408 +9070 5394 +9070 584446 +9070 640396 +9070 702319 +9070 725912 +9070 786590 +9070 997489 +907144 38034 +907148 56016 +9074 145205 +9074 14894 +9074 42983 +9074 53341 +907452 517158 +907454 1043208 +907454 1172316 +907454 1336426 +907454 262940 +907454 271874 +907454 696238 +907454 730302 +907454 855059 +9075 17413 +9075 28953 +9075 42016 +907696 2017717 +9078 167665 +9079 161 +907989 1443272 +908004 410869 +908400 3753831 +9087 135657 +9087 2102554 +908789 908792 +908890 108566 +908890 517165 +908890 840391 +908890 999914 +908931 908926 +908932 1399567 +908932 37733 +908938 1239041 +908938 1478923 +908938 897153 +909092 1216065 +909092 2365801 +909092 2498725 +909092 567209 +909092 662168 +909092 846282 +909092 903706 +909156 967053 +909193 1404047 +909193 834330 +909198 1015817 +909198 1015826 +909198 1015827 +909198 1015831 +909198 1138900 +909198 1245575 +909198 1340656 +909198 1370243 +909198 1370946 +909198 1404047 +909198 1419770 +909198 1421398 +909198 2819488 +909198 3149322 +909198 3175784 +909198 526421 +909198 595051 +909198 731416 +909198 743704 +909198 743705 +909198 833185 +909198 834330 +909198 834703 +909198 844675 +909198 850889 +909198 858834 +909198 864674 +909198 880947 +909198 909193 +909198 909961 +909319 909318 +909325 1529842 +909497 35100 +90957 27527 +909598 212299 +909598 92243 +909598 966368 +909599 212299 +909667 1223137 +909773 222384 +909837 240638 +909961 1274505 +909961 1385352 +909961 1404047 +909961 1790630 +909961 180025 +909961 180026 +909961 451534 +909961 628237 +909961 754485 +909961 834330 +909961 834398 +909961 834703 +909961 841439 +909961 870631 +909961 900378 +909961 909193 +909961 971041 +91 1285 +91 23607 +91 2901920 +91 3401076 +91 4845 +91012 332855 +910122 357548 +910130 703271 +910178 954931 +910228 1080658 +910228 1125579 +910228 316485 +91024 184541 +9104 195157 +910480 3914534 +91049 28183 +910493 173190 +910663 3192480 +9107 4320 +910716 3151327 +910816 1786327 +91091 368068 +911131 2373155 +911131 3520483 +911131 3520485 +91131 163850 +91131 6378 +911494 75559 +911574 911575 +911575 1215654 +911575 546262 +911780 1710017 +911810 135885 +912007 253245 +912007 397620 +912007 532265 +912007 696260 +912007 880605 +912299 912297 +912317 1356610 +912317 1687982 +912317 2736228 +912317 998654 +912362 2814547 +912384 1022039 +912386 912404 +912446 1147583 +912451 915436 +912553 986222 +912593 1003177 +912593 1003179 +912593 1053170 +912593 1092492 +912593 1173606 +912593 2129819 +912593 2604177 +912593 397620 +912593 406278 +912593 683885 +912593 754974 +912593 832942 +912593 833071 +912593 833168 +912593 837674 +912593 855072 +912593 861474 +912593 861581 +912593 865655 +9126 546203 +91264 43388 +912702 1294869 +912702 688716 +912702 700443 +912702 832962 +912702 877523 +91288 149878 +91291 260764 +912959 24944 +91296 127075 +91296 199819 +91296 219675 +91296 248497 +91296 398223 +913039 1021215 +913039 1053915 +913039 1053916 +913039 1368030 +913039 1692113 +913039 192322 +913039 216140 +913039 375279 +913039 497542 +913039 703539 +913039 95537 +913039 96123 +913040 1056568 +913040 108566 +913040 1769149 +913040 304973 +913040 841456 +913040 894376 +913040 931384 +9131 143904 +91315 463647 +913162 1089916 +913209 1259101 +913209 260744 +913209 283122 +913209 627442 +913209 999914 +913509 352816 +913622 242588 +914017 914005 +914053 593323 +914053 691598 +914183 4839 +91428 102487 +91428 237599 +914517 27952 +914678 1528200 +914678 406281 +914678 550341 +914678 696260 +914678 834226 +914678 855056 +914678 880605 +914700 1176805 +914700 245423 +914700 747927 +91484 145095 +91487 1266806 +914898 620186 +914901 1701326 +914907 1239190 +914907 368137 +914907 454293 +914907 479033 +914907 479036 +914907 754974 +914907 842238 +914907 855059 +914907 95537 +914909 2558514 +914909 914908 +914928 914929 +914930 914928 +914930 914929 +914944 914943 +914950 1185958 +914956 938452 +914956 947753 +914962 123904 +914962 292491 +914962 396942 +915075 421263 +915202 2710772 +915271 108566 +915271 716084 +915271 836185 +915271 855218 +915271 864379 +915299 915302 +91533 217149 +91534 26592 +91534 77522 +915365 835928 +91554 1180987 +91554 1301946 +91554 532684 +915552 1145501 +915552 2606049 +915552 92184 +915630 280662 +915630 3664403 +915630 803209 +915657 1057453 +915657 260744 +915657 283122 +915657 826840 +915657 833664 +915657 842888 +915657 861487 +915657 882018 +915657 92243 +915687 34955 +9157 35994 +9157 63143 +915784 937138 +91587 316026 +91588 1098189 +91588 117723 +91590 117723 +91590 39230 +91590 52818 +91590 9373 +915917 266387 +915920 2063124 +915929 310705 +915941 1655223 +91596 241139 +91596 242949 +91596 94868 +915968 598601 +915968 809856 +915983 620377 +91623 43011 +916314 1945306 +916314 624749 +916314 796211 +9165 162974 +9165 61593 +9165 9165 +916544 1462139 +916573 164423 +916573 916574 +9166 193920 +916708 3476 +916724 1155856 +916724 1299730 +916724 762870 +916915 1048557 +916915 1909276 +917 22707 +917029 1092548 +917029 1228473 +917029 1424466 +917029 1485997 +917029 1506707 +917029 281455 +917029 3968921 +917029 703271 +917033 2640719 +917055 356259 +917163 448434 +91721 100113 +91725 91725 +9173 124855 +9173 198328 +9173 337107 +91748 89001 +9175 1690 +9175 5531 +9175 82128 +917554 271870 +917554 397617 +917612 974043 +9177 107084 +9177 1538 +918037 363073 +91825 91826 +91828 235032 +918338 1655036 +918338 844423 +918338 942359 +918339 916922 +918502 863380 +918502 918524 +91878 91874 +918838 2133586 +918924 877524 +918924 918932 +918927 1726981 +918944 1202832 +91897 106541 +91897 29895 +91898 115864 +91898 153626 +91898 2732086 +91898 29895 +91898 498171 +919 89673 +91905 257459 +919115 2021799 +919115 2125881 +91913 512553 +91913 91905 +919142 132084 +919142 1457081 +919142 2904417 +919142 2904418 +919142 35125 +919266 1418485 +919326 2003439 +919326 2003440 +919326 805900 +91938 113094 +91938 57280 +91947 226504 +91947 261932 +91947 26950 +91947 32203 +91947 65710 +919492 89628 +919492 96452 +919539 861489 +9197 320258 +919880 1088434 +919880 1088436 +919880 1088437 +919880 1108905 +919880 1117783 +919880 1117784 +919915 1210098 +91992 15889 +91993 1092096 +91993 1097988 +919937 1170033 +919937 919938 +920017 1505744 +920017 679490 +92003 99696 +92004 217483 +92004 230034 +920155 26586 +92026 59268 +920263 1611920 +920263 191993 +920313 406281 +920313 884545 +920377 1028502 +920377 1028602 +920377 1234805 +920377 1234806 +920377 1300812 +920377 1351694 +920377 153980 +920377 1731476 +920377 2128032 +920377 271874 +920377 434656 +920377 436165 +920377 704625 +920466 6152 +92050 1112691 +920610 920612 +920664 873207 +920668 920668 +920799 1466510 +920799 410038 +920799 415725 +920799 836588 +920799 880077 +920799 954705 +920812 1098583 +920812 1541162 +920987 2271616 +920987 934456 +920989 1509010 +9210 147328 +9210 181840 +9210 182678 +9210 187457 +9210 60480 +9210 656397 +9210 79175 +9210 99026 +92103 407260 +921042 1102995 +921042 3334638 +921042 456926 +921042 759182 +921042 921040 +921042 982225 +921117 163234 +921168 833098 +921168 833446 +921168 859036 +921170 1033674 +921271 1015351 +921348 406876 +921348 808542 +921367 2267166 +921435 3505362 +921463 607198 +9216 70426 +921637 1724836 +921637 724499 +921637 787880 +92172 1110 +921761 355 +921764 355 +921764 921761 +92183 1211958 +92183 92184 +92184 306955 +921867 756437 +92187 130987 +922163 920272 +92220 269211 +9224 13609 +92243 1004477 +92243 104514 +92243 1104223 +92243 212000 +92243 212001 +92243 212301 +92243 216140 +92243 2363984 +92243 262940 +92243 289522 +92243 294480 +92243 304968 +92243 32180 +92243 32190 +92243 333892 +92243 379809 +92243 394776 +92243 456210 +92243 456211 +92243 465982 +92243 470264 +92243 502823 +92243 506006 +92243 532276 +92243 575297 +92243 629545 +92243 633161 +92243 633162 +92243 663387 +92243 833079 +92243 848066 +92243 855032 +92243 896978 +92243 909599 +92243 92243 +92243 966368 +92243 970420 +92243 988781 +922635 304975 +922635 454293 +922635 839640 +92264 235219 +922787 2144887 +92281 111476 +92281 181011 +922903 659308 +922919 419365 +922919 7599 +92294 474643 +92295 5944 +92295 79352 +922987 1976788 +92309 229933 +92309 50179 +92310 467231 +923111 442205 +923267 1715774 +923346 1245575 +923346 1404047 +923346 1421398 +923346 1628927 +923346 731416 +923346 834330 +923346 909193 +923346 909198 +923346 909961 +923348 108568 +923348 578719 +923348 836608 +923348 849128 +923348 869650 +923498 1139258 +923529 41272 +923589 923590 +92361 245921 +9237 10994 +9237 435230 +9237 471478 +92378 155380 +92378 381788 +92378 403899 +92386 213319 +923885 719584 +923994 923995 +924117 533610 +924137 1141651 +924137 123377 +924137 193235 +924137 227234 +924191 524182 +924333 356317 +924333 361805 +924333 671331 +924333 835060 +924333 883952 +924402 356317 +924402 361805 +924402 833722 +924402 835060 +924402 835061 +924402 835062 +924402 836151 +924402 836156 +924461 239022 +92449 456670 +924654 2241400 +924654 2241401 +924654 666508 +924654 837062 +924654 990584 +924732 210432 +924732 237156 +92497 101324 +92512 92513 +925226 338450 +925303 1128801 +925303 1224348 +925303 1479359 +925303 63119 +92541 115551 +92541 488776 +925432 925431 +92550 441493 +925588 116711 +9256 37724 +925627 1431703 +925650 1397714 +925650 1765777 +92569 105728 +92569 275284 +92576 1075 +925770 443221 +92578 194 +92583 1222784 +925944 1279686 +925944 1478675 +925944 1481537 +925944 1642459 +925944 1908876 +925944 2503748 +925944 262940 +925944 269254 +925944 282137 +925944 349296 +925944 3871051 +925944 3871052 +925944 3871053 +925944 397620 +925944 451535 +925944 525469 +925944 538821 +925944 696169 +925944 696200 +925944 696260 +925944 704150 +925944 833560 +925944 833827 +925944 835968 +925944 842223 +925944 851310 +925944 851413 +925944 855066 +925944 868929 +925944 882022 +925945 1017619 +925945 1032225 +925945 1129949 +925945 1586536 +925945 1639594 +925945 1639604 +925945 415720 +925945 451535 +925945 696200 +925945 696238 +925945 696260 +925945 704150 +925945 754974 +925945 795171 +925945 832962 +925945 833163 +925945 835735 +925945 837661 +925945 841441 +925945 844419 +925945 849477 +925945 851419 +925945 855072 +925945 855761 +925945 861487 +925945 861690 +925945 925944 +92599 1139919 +926038 30309 +926038 35086 +926093 927423 +92623 286086 +92623 470964 +92623 538821 +92623 65807 +92623 835190 +926256 1125963 +926316 299702 +926316 379809 +926316 388185 +926316 547969 +926316 547971 +926316 776698 +926325 393383 +926325 832962 +926325 834389 +926325 95546 +926502 977798 +926659 2954161 +926659 555263 +926716 95544 +926717 833293 +926717 841441 +926720 1060267 +926720 260744 +926720 838930 +926720 898730 +926722 926716 +926722 95544 +926730 1065000 +926730 986222 +92692 4716 +92697 98300 +926979 587167 +926979 872098 +927135 825976 +927278 75315 +927320 1170349 +927383 972105 +92744 92746 +92750 100430 +92750 1036979 +92750 12551 +92750 193491 +92750 253733 +92750 572127 +92750 615463 +92750 709175 +92759 34944 +92769 21122 +9278 132584 +9278 199648 +92787 1043041 +92787 138067 +92787 192570 +92787 415027 +92787 471931 +92787 585616 +92787 87251 +927886 2420869 +92796 223201 +92798 348049 +92798 95705 +928075 1731604 +92811 218570 +92811 40764 +92811 81496 +928199 361603 +928199 991532 +92834 239223 +92834 418512 +92834 567114 +92834 769709 +92834 842921 +928519 1296573 +92861 369194 +928684 1263856 +928815 189913 +92882 433358 +92887 111502 +928876 274588 +92888 13685 +92888 150836 +92888 57216 +92890 469912 +92898 1065010 +92901 5648 +929034 252085 +92913 228917 +92913 252017 +929294 929296 +929305 510368 +92947 517711 +929472 839532 +929663 1123685 +929663 1982 +929663 207297 +92967 18360 +92973 259823 +92973 3196311 +92979 639901 +9299 13195 +929976 112614 +93002 186672 +93002 235367 +930088 1096877 +93013 43128 +93013 83559 +930237 160199 +93027 39740 +930381 1054362 +930381 1411387 +930381 14426 +930381 2193174 +930381 2621213 +930381 498647 +930381 802368 +930381 810205 +9304 1572 +9304 419 +9304 9304 +930583 191013 +93069 47572 +9311 171857 +9311 205050 +9311 643425 +9311 65498 +9311 714502 +9311 85125 +9311 9823 +931107 1147583 +931115 1395232 +93112 1232695 +931190 845446 +931244 1022025 +931244 1211021 +931244 2129597 +931244 349296 +931244 446577 +931244 526409 +931244 833446 +931244 835518 +931244 837498 +931244 844249 +931244 852709 +931244 861690 +931244 880609 +931244 882033 +931244 92243 +931244 944044 +931244 997191 +931304 931308 +931316 730306 +931316 842078 +931339 1058540 +931339 339765 +931339 736604 +931339 872030 +931349 846277 +931368 880293 +931384 2333550 +931384 3606604 +931401 283469 +931401 460621 +931416 304975 +931425 2320241 +931575 1350723 +93168 32198 +931685 1251923 +931685 1685019 +931685 2446086 +931685 2446087 +931685 333892 +931685 526576 +931685 628237 +931685 718775 +931725 1066340 +931725 1092516 +931725 712268 +931725 836755 +931827 1640483 +931928 145074 +931948 1690917 +93198 185662 +93198 49639 +932327 2079893 +932327 426333 +93234 160445 +93260 93261 +932630 725023 +932630 837545 +93269 12832 +932802 247999 +932892 797296 +933224 177640 +933249 226122 +933250 61152 +933318 115461 +933318 386761 +933345 1000280 +93337 40794 +93337 601787 +93337 93337 +933665 2533765 +93369 1222310 +93369 265537 +933743 547971 +933743 92243 +93375 10263 +93375 175365 +93375 309355 +93375 3555729 +93375 649930 +93375 702067 +93375 8285 +933757 1300812 +933757 2545309 +933757 2545310 +933757 269254 +933757 832917 +933757 835518 +933757 869694 +933833 1144860 +93386 1301338 +93386 93386 +933919 3835785 +933919 824550 +934274 1176238 +934274 1674712 +934275 571664 +93431 193258 +93431 51669 +934374 915390 +934385 1059062 +934386 1279155 +934456 2271616 +934703 226144 +934732 1409738 +934732 1951772 +934732 1951773 +934732 490279 +934732 900807 +934773 108566 +934773 836442 +934773 95541 +934993 934992 +935118 498965 +935118 935117 +93564 249584 +935707 1303811 +935707 2157349 +935812 847372 +936109 1382366 +936241 209808 +936241 364124 +936241 84675 +936248 163845 +936264 936263 +936275 1313589 +936275 1313590 +936275 342257 +936330 1244635 +936393 1663405 +93661 455234 +93661 5682 +936611 18344 +936665 26669 +936665 834158 +936686 2078280 +936686 560575 +936699 982837 +93677 15753 +936823 205154 +936983 485590 +937015 209053 +937015 934386 +937015 938666 +937077 2578612 +937077 303060 +937077 424576 +937077 744724 +937077 833554 +937077 835518 +937077 837498 +937077 855061 +937077 855066 +937077 861689 +937077 861690 +937077 869694 +937219 937220 +9373 106892 +9373 113586 +9373 116830 +9373 117718 +9373 118218 +9373 146062 +9373 164363 +9373 17591 +9373 191569 +9373 19895 +9373 212400 +9373 212403 +9373 216367 +9373 223869 +9373 229071 +9373 230642 +9373 230732 +9373 2418665 +9373 29823 +9373 329513 +9373 379184 +9373 385698 +9373 388432 +9373 39230 +9373 406916 +9373 425809 +9373 429303 +9373 44860 +9373 54517 +9373 61920 +9373 825322 +9373 96316 +9373 96395 +937619 1259619 +937623 937624 +937649 1868770 +937649 2609642 +937650 939352 +937650 939408 +93780 29058 +93780 345352 +937819 1174486 +937819 1721826 +937819 937815 +937954 1236908 +937954 937960 +937960 1236908 +9380 165872 +9380 170659 +9380 419017 +938083 1261428 +938083 424150 +938083 833903 +938083 945174 +938087 227843 +938087 873811 +93823 41957 +9384 132084 +9384 35848 +93840 162275 +938451 914956 +938451 938452 +938452 814409 +938507 1060050 +938507 1188872 +938507 1212452 +938507 1483299 +938507 576270 +938507 983305 +938576 1960768 +938667 736338 +938667 938666 +9387 26923 +9387 272062 +9387 28468 +938734 337208 +938995 258469 +939 3956 +93921 174144 +93921 594616 +93921 850352 +939230 552195 +939230 833686 +939230 891215 +939252 259154 +939252 312163 +939252 49759 +939408 916544 +939408 939352 +939410 916545 +939440 1124484 +939440 2470688 +939440 766937 +939451 939452 +93964 392451 +939807 1217357 +939838 939839 +939866 1136781 +939901 736605 +93996 191337 +940128 704150 +94013 477547 +940156 1653781 +940258 714050 +94044 546899 +94079 37413 +94079 43745 +94079 80134 +940851 29993 +940851 37696 +94090 268581 +941075 941077 +94122 134391 +94134 63835 +941352 797106 +941392 1345542 +941583 841881 +94159 1074732 +9416 821841 +941656 137872 +941681 1068552 +941684 1502780 +941770 267726 +941850 1353208 +941850 1933252 +941850 451534 +941850 451535 +941850 454293 +941850 495010 +941850 517165 +941850 653372 +941850 833169 +941850 833173 +941850 833687 +941850 834071 +941850 837520 +941850 859024 +941850 859036 +941850 859045 +941850 861476 +941850 986214 +941854 269254 +941854 95542 +941855 2402947 +941855 2402948 +941855 842085 +941855 861476 +941864 341147 +941864 913039 +941864 963375 +942139 1558222 +942359 1655036 +94240 94241 +942483 1437407 +942483 305847 +942483 558045 +942545 1225232 +942545 890109 +9427 4306 +942756 276730 +942756 701547 +942756 95623 +9428 12485 +942852 1565297 +942852 2166221 +942852 639840 +942957 1210280 +943113 1128299 +943113 3913012 +943113 3913013 +943113 857406 +943336 327676 +943426 943425 +943471 2522555 +9436 10263 +94385 1612002 +94385 50997 +943891 1084227 +9439 107836 +9439 129187 +9439 13665 +9439 225277 +9439 55033 +9439 6092 +944 939 +944007 144828 +944043 547969 +944043 547971 +944044 1211021 +944044 852709 +944044 861690 +944044 92243 +944044 997191 +944143 1337833 +944143 448007 +944145 388185 +944145 832989 +944146 1443207 +944146 1518735 +944146 153980 +944146 1560179 +944146 1822718 +944146 1979591 +944146 395913 +944146 406273 +944146 418175 +944146 454293 +944146 456764 +944146 532086 +944146 567511 +944146 626175 +944146 775292 +944146 833010 +944146 835066 +944146 867975 +944146 896978 +944146 900110 +944146 924191 +944146 943307 +94419 249796 +9442 159964 +9442 20595 +9442 501298 +944275 322201 +944366 306505 +944387 1844941 +944387 511220 +944561 260744 +944561 552195 +944561 833698 +944610 1326618 +944610 775490 +944642 320722 +944649 150345 +94485 194906 +944882 22615 +944916 281276 +94500 2963315 +94500 386863 +94501 1051454 +94502 187075 +94504 3941403 +945130 23089 +945130 3014652 +945148 26925 +945174 424150 +945174 833903 +945271 2419883 +945427 698773 +945467 1659710 +94547 26120 +945542 931080 +94557 1496381 +94557 2419281 +94557 269094 +945593 1015406 +945593 833179 +94575 1596210 +945756 1122439 +945756 209529 +945756 673009 +945756 752589 +945756 860694 +945756 994621 +945821 1462139 +945821 1905141 +945821 916544 +945867 43828 +94592 32449 +945943 5482 +945943 831949 +946 1076 +946 1431 +946 1830 +946 2187 +946 2194 +946 28711 +946 34316 +946 38776 +946 47621 +946 64522 +946 996 +9461 14043 +9461 8403 +94610 178892 +94612 248836 +946199 1046946 +946199 712270 +946285 847740 +946368 2020806 +946368 868370 +9466 4288 +9467 22637 +946727 946727 +94674 43378 +946759 246730 +946929 3193909 +946948 1009447 +946948 192325 +947049 4358 +947054 193528 +947054 2837 +947054 898427 +9472 4626 +947244 947243 +94729 75584 +947323 777892 +947361 1373608 +947361 1373609 +947361 335220 +947416 2941294 +947487 270225 +947487 462603 +947487 538821 +947487 55683 +947490 766937 +9475 54788 +9475 64066 +947613 1246211 +947613 207905 +947613 251434 +947613 563926 +94789 1087387 +94789 1583001 +94789 1823418 +94789 1826008 +94789 184855 +94789 2254840 +94789 271508 +94789 27952 +94789 298861 +94789 522846 +94789 522847 +94789 769997 +94789 769998 +94789 810207 +94789 923771 +94789 98633 +94794 27723 +947998 1300061 +947998 420689 +948091 296718 +948091 871668 +948091 879251 +948192 92885 +948370 1288920 +948370 149423 +94841 1078885 +94841 1085945 +94841 168925 +94841 23997 +94841 3998 +94841 553941 +94841 6583 +94841 80179 +94841 91058 +948450 1052075 +948450 1615351 +948478 572127 +948478 92750 +94855 21059 +948628 454293 +948628 517165 +948628 833167 +948628 833169 +948628 833173 +948628 833554 +948628 837520 +948628 859036 +948628 861476 +948628 865661 +948628 941850 +948645 948646 +9487 193064 +9487 227583 +94874 142222 +94874 18985 +94885 232536 +948983 1980898 +948983 444609 +949173 2091623 +949173 3018790 +949173 639840 +94928 48432 +949308 309355 +949361 253462 +94940 208267 +94940 41644 +94965 360537 +94980 1061 +949803 108566 +949803 623293 +949803 784121 +949803 834101 +94995 232223 +95 96 +950 1402 +950 2290 +95002 194 +95003 54186 +95005 94995 +950106 834057 +95014 12027 +95014 1298434 +95014 1321921 +950343 366274 +9504 235319 +9504 2855706 +9504 5283 +9504 597789 +9504 72507 +950409 2270139 +950512 342296 +950513 349497 +95058 202443 +950635 1354525 +950718 156088 +950742 1613131 +950768 47174 +95088 257251 +95088 261295 +95088 3865 +95088 74212 +95089 254108 +95089 255027 +951 1291 +951 78458 +951 91673 +951131 1903986 +951169 1034535 +951169 2313484 +951169 408668 +951327 951326 +9514 1066363 +95156 607079 +952 725748 +952 9786 +952239 147902 +952239 1689444 +952239 2235302 +952358 2563 +952395 991190 +952583 1089301 +9526 2091 +9526 3511 +952623 181040 +952623 47714 +952625 57103 +952637 999051 +952642 952675 +952643 1164497 +952643 958433 +952736 1328380 +952798 372312 +952815 899442 +95292 104582 +95295 241221 +953014 1021949 +953014 1284343 +95304 11767 +953047 931386 +953069 1385558 +9534 237578 +9534 249475 +9534 397737 +953540 1421250 +9538 13619 +95381 632083 +953813 2365887 +953813 2665958 +953813 3264300 +953813 3360374 +953813 3742841 +953813 469300 +953862 1258810 +95389 95390 +953905 953928 +95404 45966 +95417 280268 +95431 133108 +954322 954337 +954335 313321 +954507 1092600 +954530 148330 +954680 197272 +954705 1203230 +954705 415725 +954705 454293 +954705 836588 +95473 36381 +95473 6123 +954795 262940 +954795 377139 +954795 424576 +954795 538821 +954795 744724 +954795 832951 +954795 833851 +954795 835190 +954916 96400 +954953 1418712 +954953 28517 +954953 426957 +955 445511 +95501 6692 +955171 955173 +955171 955175 +955173 955175 +95525 1097606 +95536 1028020 +95536 1030674 +95536 1262505 +95536 1416949 +95536 1424466 +95536 1430197 +95536 1508464 +95536 269254 +95536 342541 +95536 444606 +95536 488362 +95536 490279 +95536 578492 +95536 696134 +95536 696215 +95536 704150 +95536 833317 +95536 833579 +95536 835968 +95536 852709 +95536 865412 +95536 865654 +95536 868929 +95536 883257 +95536 95540 +95537 1001311 +95537 1001319 +95537 1004027 +95537 1004477 +95537 1005954 +95537 1021215 +95537 1022025 +95537 1029398 +95537 1032219 +95537 1032262 +95537 1037716 +95537 1044259 +95537 1044334 +95537 1045530 +95537 1046943 +95537 1046945 +95537 1058540 +95537 108566 +95537 1092096 +95537 1092558 +95537 1096693 +95537 1097988 +95537 1102995 +95537 1122169 +95537 1127509 +95537 1135199 +95537 1135228 +95537 1138900 +95537 1138961 +95537 1152498 +95537 115469 +95537 1155411 +95537 1157752 +95537 1173665 +95537 1179811 +95537 1182938 +95537 1183590 +95537 1197745 +95537 1212484 +95537 1213121 +95537 1233607 +95537 1236438 +95537 1248409 +95537 1250628 +95537 1259761 +95537 1259762 +95537 1269391 +95537 1284573 +95537 1290374 +95537 1320220 +95537 1322776 +95537 1329281 +95537 1337025 +95537 1347376 +95537 1353208 +95537 1353275 +95537 1355495 +95537 1368030 +95537 1372753 +95537 1374691 +95537 1420649 +95537 1422857 +95537 1428247 +95537 1443189 +95537 1507460 +95537 1518780 +95537 1539851 +95537 154285 +95537 1554173 +95537 1558211 +95537 1566373 +95537 1575413 +95537 1591238 +95537 1619683 +95537 1628390 +95537 1653781 +95537 1788026 +95537 1788027 +95537 1825983 +95537 1836687 +95537 1878429 +95537 192322 +95537 1964301 +95537 2003657 +95537 207945 +95537 2205687 +95537 2258485 +95537 2258486 +95537 226461 +95537 229566 +95537 2320241 +95537 2348095 +95537 2419637 +95537 2469791 +95537 252872 +95537 2582340 +95537 260744 +95537 2640719 +95537 271870 +95537 27519 +95537 277879 +95537 280177 +95537 283122 +95537 2836725 +95537 2873325 +95537 2873326 +95537 2873327 +95537 296409 +95537 299702 +95537 301263 +95537 303060 +95537 304968 +95537 304975 +95537 3296871 +95537 339765 +95537 3430309 +95537 343905 +95537 359068 +95537 375279 +95537 377139 +95537 395913 +95537 397617 +95537 406273 +95537 415720 +95537 415725 +95537 424107 +95537 424576 +95537 434124 +95537 435555 +95537 446105 +95537 446471 +95537 446577 +95537 451534 +95537 454293 +95537 454981 +95537 479037 +95537 491294 +95537 497542 +95537 500231 +95537 502809 +95537 517144 +95537 517153 +95537 517163 +95537 522210 +95537 523642 +95537 523982 +95537 526410 +95537 526411 +95537 526576 +95537 526590 +95537 532086 +95537 532089 +95537 532425 +95537 533488 +95537 552195 +95537 573239 +95537 575045 +95537 578727 +95537 578730 +95537 578734 +95537 578737 +95537 595051 +95537 595478 +95537 598601 +95537 617133 +95537 620186 +95537 623293 +95537 624749 +95537 627442 +95537 634102 +95537 641164 +95537 641250 +95537 646857 +95537 646866 +95537 649585 +95537 65796 +95537 670668 +95537 671331 +95537 688716 +95537 691665 +95537 696188 +95537 700443 +95537 703539 +95537 716084 +95537 736604 +95537 754894 +95537 761118 +95537 767643 +95537 791789 +95537 793064 +95537 795184 +95537 796211 +95537 809856 +95537 817480 +95537 826828 +95537 826829 +95537 826830 +95537 826839 +95537 828590 +95537 832661 +95537 832900 +95537 832905 +95537 832924 +95537 832952 +95537 832962 +95537 832995 +95537 833068 +95537 833071 +95537 833076 +95537 833168 +95537 833205 +95537 833554 +95537 833667 +95537 833716 +95537 833722 +95537 833794 +95537 833851 +95537 834051 +95537 834088 +95537 834090 +95537 834094 +95537 834223 +95537 834389 +95537 834397 +95537 834516 +95537 834518 +95537 834577 +95537 834578 +95537 834611 +95537 834640 +95537 834641 +95537 834643 +95537 834646 +95537 835036 +95537 835073 +95537 835112 +95537 835187 +95537 835190 +95537 835415 +95537 835626 +95537 835642 +95537 835646 +95537 835650 +95537 835735 +95537 835926 +95537 835927 +95537 836005 +95537 836063 +95537 836065 +95537 836115 +95537 836151 +95537 836152 +95537 836153 +95537 836154 +95537 836156 +95537 836165 +95537 836184 +95537 836185 +95537 836379 +95537 836380 +95537 836665 +95537 836744 +95537 836885 +95537 836894 +95537 836895 +95537 837037 +95537 837407 +95537 837458 +95537 837520 +95537 837551 +95537 837575 +95537 837582 +95537 837585 +95537 837588 +95537 837589 +95537 837660 +95537 837661 +95537 838040 +95537 838588 +95537 839080 +95537 839412 +95537 841441 +95537 841452 +95537 841660 +95537 841674 +95537 841803 +95537 842085 +95537 842108 +95537 842112 +95537 842233 +95537 842234 +95537 842235 +95537 842238 +95537 842822 +95537 842832 +95537 843897 +95537 844147 +95537 844189 +95537 844245 +95537 844416 +95537 844418 +95537 844421 +95537 844451 +95537 845756 +95537 845760 +95537 845763 +95537 845769 +95537 846180 +95537 847180 +95537 848163 +95537 848467 +95537 848555 +95537 849148 +95537 849153 +95537 849793 +95537 850543 +95537 850889 +95537 851590 +95537 852384 +95537 852987 +95537 852992 +95537 853359 +95537 853360 +95537 854161 +95537 855140 +95537 857318 +95537 859446 +95537 859452 +95537 859780 +95537 860952 +95537 861270 +95537 861274 +95537 861475 +95537 861476 +95537 861487 +95537 861489 +95537 861690 +95537 861951 +95537 867177 +95537 867946 +95537 868370 +95537 869031 +95537 869040 +95537 870631 +95537 870832 +95537 870833 +95537 872030 +95537 873180 +95537 877523 +95537 877614 +95537 881488 +95537 882032 +95537 882758 +95537 883315 +95537 885403 +95537 885766 +95537 891215 +95537 894376 +95537 895582 +95537 896029 +95537 899843 +95537 901880 +95537 908890 +95537 912297 +95537 912299 +95537 912702 +95537 914150 +95537 917033 +95537 917554 +95537 91993 +95537 921040 +95537 921042 +95537 922551 +95537 922635 +95537 931339 +95537 931425 +95537 939230 +95537 940156 +95537 946368 +95537 95544 +95537 959744 +95537 962494 +95537 963656 +95537 966987 +95537 967102 +95537 970416 +95537 971039 +95537 975145 +95537 978174 +95537 978177 +95537 981904 +95537 982225 +95537 988605 +95537 991532 +955372 1884670 +95539 1016656 +95539 1030674 +95539 1071287 +95539 1485146 +95539 1589748 +95539 1953931 +95539 202092 +95539 216140 +95539 26955 +95539 273804 +95539 282639 +95539 312072 +95539 361807 +95539 456764 +95539 494994 +95539 497542 +95539 526593 +95539 526595 +95539 550368 +95539 567502 +95539 595747 +95539 604629 +95539 625070 +95539 626175 +95539 703268 +95539 736606 +95539 744724 +95539 828583 +95539 828588 +95539 833240 +95539 833462 +95539 834000 +95539 84236 +95539 846296 +95539 848815 +95539 858480 +95539 865412 +95539 912297 +95539 924191 +95539 96123 +95540 1006066 +95540 1200733 +95540 1236436 +95540 1751436 +95540 192325 +95540 1981322 +95540 260744 +95540 269254 +95540 283122 +95540 335045 +95540 397620 +95540 406271 +95540 406273 +95540 406285 +95540 488362 +95540 490777 +95540 555462 +95540 696215 +95540 703268 +95540 704150 +95540 736606 +95540 833167 +95540 833317 +95540 833579 +95540 855061 +95540 858380 +95540 858475 +95540 865655 +95540 882026 +95540 895152 +95540 913209 +955406 522847 +95541 1046943 +95541 1046946 +95541 11696 +95541 1583984 +95541 207945 +95541 2212800 +95541 260744 +95541 283122 +95541 375279 +95541 469410 +95541 488363 +95541 497542 +95541 623293 +95541 641164 +95541 65796 +95541 665298 +95541 671328 +95541 703539 +95541 754485 +95541 767642 +95541 832900 +95541 832962 +95541 833097 +95541 834396 +95541 834640 +95541 834643 +95541 835735 +95541 841439 +95541 842799 +95541 842826 +95541 882809 +95541 900378 +95541 909961 +95541 912299 +95541 95537 +95541 95546 +95541 995188 +95541 999914 +95542 1015406 +95542 1036751 +95542 1036752 +95542 1037718 +95542 1042460 +95542 1053194 +95542 1065000 +95542 108439 +95542 1092490 +95542 1140796 +95542 1172316 +95542 1186813 +95542 1186814 +95542 1200471 +95542 1246886 +95542 1270492 +95542 1279344 +95542 1424549 +95542 1428466 +95542 1449987 +95542 153980 +95542 1917218 +95542 216140 +95542 229547 +95542 260744 +95542 261451 +95542 262940 +95542 269254 +95542 271874 +95542 27519 +95542 283122 +95542 283473 +95542 299702 +95542 317584 +95542 3488542 +95542 374006 +95542 388185 +95542 397616 +95542 39874 +95542 406271 +95542 406285 +95542 415725 +95542 446471 +95542 448008 +95542 454293 +95542 454981 +95542 455839 +95542 456764 +95542 508213 +95542 522209 +95542 522210 +95542 526592 +95542 544890 +95542 544894 +95542 552196 +95542 578737 +95542 591041 +95542 627442 +95542 688716 +95542 696257 +95542 712270 +95542 754894 +95542 775266 +95542 784121 +95542 789776 +95542 796210 +95542 800996 +95542 809856 +95542 832962 +95542 833108 +95542 833179 +95542 833317 +95542 833376 +95542 833686 +95542 834229 +95542 835190 +95542 835415 +95542 835518 +95542 835735 +95542 835892 +95542 837568 +95542 837573 +95542 838929 +95542 839091 +95542 840349 +95542 840538 +95542 840548 +95542 841441 +95542 841660 +95542 842888 +95542 843433 +95542 843526 +95542 844081 +95542 846301 +95542 847180 +95542 855059 +95542 864672 +95542 864674 +95542 865661 +95542 867976 +95542 867991 +95542 869570 +95542 874560 +95542 882022 +95542 883777 +95542 884344 +95542 892835 +95542 900448 +95542 907454 +95542 924191 +95542 926730 +95542 941848 +95542 946948 +95542 950082 +95542 95543 +95542 957730 +95542 96123 +95542 979554 +95542 986222 +95542 988713 +95543 1043427 +95543 115461 +95543 115466 +95543 115469 +95543 1192372 +95543 1443685 +95543 153980 +95543 226461 +95543 2323597 +95543 262940 +95543 271877 +95543 27519 +95543 283122 +95543 374006 +95543 394778 +95543 397620 +95543 406278 +95543 499563 +95543 550341 +95543 578737 +95543 617133 +95543 696200 +95543 696225 +95543 809856 +95543 833128 +95543 834226 +95543 835128 +95543 835406 +95543 849793 +95543 855072 +95543 855971 +95543 867835 +95543 867991 +95543 978211 +95543 987109 +95544 1005207 +95544 1005954 +95544 1009230 +95544 1009447 +95544 1015406 +95544 1021032 +95544 1021948 +95544 1021949 +95544 1028502 +95544 1030558 +95544 1031230 +95544 1031891 +95544 1033674 +95544 1037730 +95544 1038546 +95544 1043208 +95544 1043429 +95544 1050295 +95544 1050296 +95544 1050297 +95544 1053170 +95544 1057453 +95544 1064108 +95544 108565 +95544 108568 +95544 1092492 +95544 1116783 +95544 1117543 +95544 1138898 +95544 1138899 +95544 1138901 +95544 1142516 +95544 1149753 +95544 1152266 +95544 1154796 +95544 1155411 +95544 1173665 +95544 1197745 +95544 1199356 +95544 1213123 +95544 1213373 +95544 1229928 +95544 1233607 +95544 1234001 +95544 1235492 +95544 1246886 +95544 1249311 +95544 1262335 +95544 1289417 +95544 1297439 +95544 1300737 +95544 1312375 +95544 1316270 +95544 1328725 +95544 1329336 +95544 1336426 +95544 1337186 +95544 1346687 +95544 1387493 +95544 1417030 +95544 1417031 +95544 1417032 +95544 1424032 +95544 1437748 +95544 1482053 +95544 1498559 +95544 1498560 +95544 1498561 +95544 1498562 +95544 1507460 +95544 153980 +95544 1571919 +95544 157707 +95544 1586536 +95544 1588554 +95544 1594223 +95544 1653520 +95544 1660701 +95544 1670502 +95544 1680148 +95544 1691141 +95544 1753884 +95544 1779132 +95544 1810003 +95544 1859550 +95544 1861950 +95544 1868794 +95544 1877411 +95544 1877412 +95544 1898666 +95544 1902968 +95544 1917194 +95544 192325 +95544 1935952 +95544 1945306 +95544 2006344 +95544 2023722 +95544 2027433 +95544 2079492 +95544 2079655 +95544 2093291 +95544 2155351 +95544 2241400 +95544 2241401 +95544 224329 +95544 226461 +95544 2281098 +95544 2401903 +95544 2454552 +95544 253245 +95544 2532797 +95544 260744 +95544 261451 +95544 262940 +95544 267134 +95544 268272 +95544 269254 +95544 271870 +95544 277423 +95544 279614 +95544 280177 +95544 282137 +95544 283122 +95544 283127 +95544 283469 +95544 2952365 +95544 2994320 +95544 299702 +95544 304975 +95544 308115 +95544 3124487 +95544 3138900 +95544 3180055 +95544 322537 +95544 339765 +95544 3488542 +95544 349404 +95544 359068 +95544 364838 +95544 3676548 +95544 368137 +95544 374777 +95544 375279 +95544 377139 +95544 379816 +95544 388185 +95544 394791 +95544 394796 +95544 395913 +95544 397616 +95544 397617 +95544 397620 +95544 39874 +95544 406273 +95544 406278 +95544 406281 +95544 406283 +95544 415720 +95544 415725 +95544 422068 +95544 424576 +95544 425125 +95544 434124 +95544 435555 +95544 442174 +95544 446577 +95544 448007 +95544 448008 +95544 448009 +95544 448010 +95544 451535 +95544 452918 +95544 454293 +95544 454981 +95544 455839 +95544 459673 +95544 465982 +95544 472036 +95544 479033 +95544 479036 +95544 479037 +95544 497008 +95544 502826 +95544 517144 +95544 517163 +95544 517165 +95544 522209 +95544 522210 +95544 526416 +95544 526576 +95544 526590 +95544 526592 +95544 532086 +95544 532089 +95544 534822 +95544 538821 +95544 542688 +95544 547969 +95544 547971 +95544 551071 +95544 573239 +95544 575045 +95544 578727 +95544 578737 +95544 583138 +95544 584835 +95544 604396 +95544 610798 +95544 617133 +95544 620726 +95544 623293 +95544 624749 +95544 626175 +95544 627128 +95544 627442 +95544 641250 +95544 644384 +95544 65807 +95544 658169 +95544 666508 +95544 670668 +95544 676367 +95544 688716 +95544 696165 +95544 696188 +95544 696215 +95544 696225 +95544 696238 +95544 696257 +95544 696260 +95544 703271 +95544 704150 +95544 712270 +95544 712500 +95544 725217 +95544 730302 +95544 730308 +95544 744724 +95544 754894 +95544 754974 +95544 754976 +95544 759178 +95544 759182 +95544 779781 +95544 796211 +95544 800996 +95544 823058 +95544 823059 +95544 823061 +95544 824202 +95544 825043 +95544 826833 +95544 826839 +95544 826840 +95544 828663 +95544 832673 +95544 832700 +95544 832898 +95544 832899 +95544 832900 +95544 832905 +95544 832915 +95544 832917 +95544 832924 +95544 832942 +95544 832962 +95544 832989 +95544 833033 +95544 833035 +95544 833068 +95544 833070 +95544 833071 +95544 833073 +95544 833075 +95544 833076 +95544 833097 +95544 833108 +95544 833155 +95544 833162 +95544 833163 +95544 833164 +95544 833167 +95544 833168 +95544 833317 +95544 833446 +95544 833452 +95544 833486 +95544 833554 +95544 833560 +95544 833663 +95544 833664 +95544 833666 +95544 833667 +95544 833686 +95544 833687 +95544 833697 +95544 833738 +95544 833786 +95544 833842 +95544 833851 +95544 833886 +95544 834051 +95544 834073 +95544 834088 +95544 834225 +95544 834378 +95544 834399 +95544 834577 +95544 834646 +95544 834713 +95544 835066 +95544 835073 +95544 835090 +95544 835190 +95544 835210 +95544 835212 +95544 835213 +95544 835214 +95544 835415 +95544 835518 +95544 835519 +95544 835520 +95544 835735 +95544 835892 +95544 836125 +95544 836165 +95544 836429 +95544 836487 +95544 837062 +95544 837442 +95544 837450 +95544 837495 +95544 837498 +95544 837511 +95544 837515 +95544 837520 +95544 837533 +95544 837549 +95544 837568 +95544 837570 +95544 837575 +95544 837615 +95544 837960 +95544 838190 +95544 838243 +95544 838929 +95544 838932 +95544 838953 +95544 839080 +95544 839085 +95544 839233 +95544 839412 +95544 839640 +95544 840349 +95544 840437 +95544 842112 +95544 842134 +95544 842233 +95544 842238 +95544 842308 +95544 842888 +95544 843127 +95544 843513 +95544 843529 +95544 843643 +95544 843913 +95544 844246 +95544 844249 +95544 844250 +95544 844423 +95544 844615 +95544 845359 +95544 845360 +95544 845760 +95544 845771 +95544 846180 +95544 846290 +95544 846970 +95544 847180 +95544 847209 +95544 847368 +95544 848074 +95544 849477 +95544 849674 +95544 849690 +95544 850067 +95544 854918 +95544 855056 +95544 855065 +95544 855072 +95544 855971 +95544 857108 +95544 857318 +95544 857611 +95544 859446 +95544 859777 +95544 859780 +95544 860731 +95544 861270 +95544 861476 +95544 861487 +95544 861500 +95544 861505 +95544 861689 +95544 861690 +95544 861691 +95544 861951 +95544 862155 +95544 862157 +95544 862158 +95544 864674 +95544 865411 +95544 866958 +95544 867236 +95544 867835 +95544 867995 +95544 869493 +95544 869498 +95544 869568 +95544 869569 +95544 869570 +95544 869694 +95544 870852 +95544 873186 +95544 874943 +95544 882019 +95544 883641 +95544 883962 +95544 886376 +95544 888854 +95544 891202 +95544 894105 +95544 894398 +95544 895152 +95544 896804 +95544 897378 +95544 900056 +95544 900180 +95544 903854 +95544 905982 +95544 907454 +95544 916314 +95544 917143 +95544 918338 +95544 921170 +95544 922635 +95544 924654 +95544 926721 +95544 931948 +95544 937077 +95544 944043 +95544 944145 +95544 947108 +95544 957680 +95544 958583 +95544 959375 +95544 959744 +95544 959952 +95544 96123 +95544 966366 +95544 966367 +95544 966368 +95544 966985 +95544 970420 +95544 976868 +95544 978211 +95544 978253 +95544 981904 +95544 982396 +95544 983657 +95544 986112 +95544 986114 +95544 988713 +95544 990584 +95544 999914 +95546 1003177 +95546 1003179 +95546 1005954 +95546 1009232 +95546 1017619 +95546 1022025 +95546 1028502 +95546 1031230 +95546 1039625 +95546 1041914 +95546 1041969 +95546 1043208 +95546 1044259 +95546 1046945 +95546 1046946 +95546 1053059 +95546 1053170 +95546 1053915 +95546 1053916 +95546 1056568 +95546 1057451 +95546 1058304 +95546 1060266 +95546 1060267 +95546 1060268 +95546 1061521 +95546 108565 +95546 1089583 +95546 1102995 +95546 1129949 +95546 1135197 +95546 115463 +95546 1160362 +95546 1163402 +95546 11696 +95546 1170033 +95546 1173606 +95546 1173665 +95546 1177811 +95546 1197745 +95546 1218998 +95546 1220778 +95546 1220779 +95546 1229928 +95546 1238738 +95546 1259101 +95546 1282730 +95546 1283928 +95546 1288455 +95546 1290374 +95546 1290645 +95546 1293805 +95546 1300812 +95546 1312375 +95546 1315847 +95546 1318492 +95546 1330554 +95546 1331664 +95546 1336426 +95546 1344131 +95546 1344132 +95546 1353208 +95546 1367250 +95546 1367480 +95546 1374321 +95546 1386672 +95546 1424032 +95546 1434564 +95546 1440574 +95546 1450896 +95546 1501991 +95546 153980 +95546 1541603 +95546 1545140 +95546 1551275 +95546 157707 +95546 1586536 +95546 1596232 +95546 1598163 +95546 1632801 +95546 1634343 +95546 1639594 +95546 1639604 +95546 1655223 +95546 1671768 +95546 1709639 +95546 1717995 +95546 1724071 +95546 1735011 +95546 1743973 +95546 1825132 +95546 1840714 +95546 1849894 +95546 1915380 +95546 1933252 +95546 1956397 +95546 2002940 +95546 2036606 +95546 2079156 +95546 207945 +95546 2115511 +95546 2115800 +95546 2124984 +95546 2129013 +95546 216140 +95546 2222288 +95546 224329 +95546 2483583 +95546 2515529 +95546 2518111 +95546 2545309 +95546 2545310 +95546 2604177 +95546 260744 +95546 262940 +95546 2640719 +95546 267768 +95546 269254 +95546 271874 +95546 276145 +95546 277423 +95546 282137 +95546 283122 +95546 283127 +95546 283469 +95546 2836725 +95546 289519 +95546 289522 +95546 292345 +95546 2954287 +95546 2982835 +95546 299702 +95546 2998066 +95546 302078 +95546 303060 +95546 308115 +95546 3101195 +95546 318371 +95546 322517 +95546 3247926 +95546 325672 +95546 325753 +95546 326620 +95546 326635 +95546 3367694 +95546 3416153 +95546 3511736 +95546 3545088 +95546 3557840 +95546 3557841 +95546 359068 +95546 368137 +95546 373850 +95546 377139 +95546 379809 +95546 379816 +95546 388185 +95546 390115 +95546 393383 +95546 395913 +95546 397616 +95546 397618 +95546 397620 +95546 406278 +95546 406423 +95546 415720 +95546 415725 +95546 424576 +95546 434124 +95546 435555 +95546 442174 +95546 443259 +95546 446471 +95546 446577 +95546 448007 +95546 448010 +95546 451534 +95546 451535 +95546 454293 +95546 454981 +95546 455839 +95546 459665 +95546 459676 +95546 465982 +95546 471201 +95546 473837 +95546 479033 +95546 479036 +95546 489112 +95546 497542 +95546 499563 +95546 517145 +95546 517158 +95546 517165 +95546 522210 +95546 526411 +95546 526590 +95546 532086 +95546 532265 +95546 532276 +95546 532414 +95546 538646 +95546 547969 +95546 547971 +95546 552195 +95546 552196 +95546 564649 +95546 573235 +95546 573239 +95546 575045 +95546 576420 +95546 578727 +95546 578730 +95546 578737 +95546 598601 +95546 604396 +95546 610802 +95546 617133 +95546 617404 +95546 620726 +95546 623293 +95546 627442 +95546 646859 +95546 646860 +95546 646866 +95546 648030 +95546 683292 +95546 683885 +95546 688716 +95546 696200 +95546 696215 +95546 696225 +95546 696238 +95546 696253 +95546 696257 +95546 696260 +95546 703271 +95546 703539 +95546 704150 +95546 712270 +95546 712500 +95546 716084 +95546 730302 +95546 730308 +95546 751505 +95546 754894 +95546 754958 +95546 754974 +95546 754976 +95546 779502 +95546 779781 +95546 789776 +95546 795171 +95546 798940 +95546 817480 +95546 823059 +95546 823061 +95546 829980 +95546 832655 +95546 832898 +95546 832899 +95546 832900 +95546 832915 +95546 832917 +95546 832924 +95546 832942 +95546 832962 +95546 833014 +95546 833071 +95546 833075 +95546 833076 +95546 833097 +95546 833108 +95546 833162 +95546 833163 +95546 833164 +95546 833167 +95546 833168 +95546 833169 +95546 833173 +95546 833293 +95546 833315 +95546 833317 +95546 833446 +95546 833547 +95546 833549 +95546 833550 +95546 833553 +95546 833554 +95546 833560 +95546 833667 +95546 833686 +95546 833687 +95546 833697 +95546 833698 +95546 833722 +95546 833787 +95546 833842 +95546 833851 +95546 833891 +95546 834101 +95546 834223 +95546 834240 +95546 834241 +95546 834245 +95546 834378 +95546 834395 +95546 834488 +95546 834578 +95546 834611 +95546 834640 +95546 834643 +95546 834713 +95546 835073 +95546 835090 +95546 835208 +95546 835413 +95546 835415 +95546 835518 +95546 835735 +95546 836124 +95546 836125 +95546 836151 +95546 836156 +95546 836184 +95546 836185 +95546 836447 +95546 836774 +95546 837432 +95546 837442 +95546 837498 +95546 837520 +95546 837535 +95546 837549 +95546 837568 +95546 837570 +95546 837575 +95546 837660 +95546 837661 +95546 838145 +95546 838243 +95546 838401 +95546 838407 +95546 838929 +95546 838930 +95546 839007 +95546 839091 +95546 839257 +95546 839412 +95546 839500 +95546 840069 +95546 840349 +95546 840462 +95546 841431 +95546 841440 +95546 841441 +95546 841590 +95546 841593 +95546 841660 +95546 842080 +95546 842085 +95546 842132 +95546 842233 +95546 842234 +95546 842235 +95546 842238 +95546 842663 +95546 842822 +95546 842831 +95546 842888 +95546 843127 +95546 843433 +95546 843643 +95546 843911 +95546 843913 +95546 844419 +95546 844441 +95546 845359 +95546 845752 +95546 845754 +95546 845760 +95546 845764 +95546 845769 +95546 845771 +95546 845791 +95546 846277 +95546 846284 +95546 846301 +95546 846970 +95546 847180 +95546 847372 +95546 848066 +95546 848261 +95546 848263 +95546 849153 +95546 849477 +95546 849674 +95546 849690 +95546 850889 +95546 850892 +95546 850893 +95546 850895 +95546 850897 +95546 850906 +95546 851310 +95546 852709 +95546 855060 +95546 855072 +95546 855761 +95546 855890 +95546 855971 +95546 858375 +95546 858577 +95546 859036 +95546 861270 +95546 861282 +95546 861474 +95546 861475 +95546 861476 +95546 861484 +95546 861487 +95546 861489 +95546 861499 +95546 861500 +95546 861505 +95546 861507 +95546 861581 +95546 861690 +95546 862157 +95546 862836 +95546 862837 +95546 862840 +95546 865655 +95546 865659 +95546 865661 +95546 866575 +95546 866595 +95546 867740 +95546 867995 +95546 868370 +95546 868372 +95546 869570 +95546 869605 +95546 870633 +95546 870697 +95546 870792 +95546 870832 +95546 870833 +95546 872312 +95546 872558 +95546 872743 +95546 872899 +95546 873272 +95546 874943 +95546 874944 +95546 882024 +95546 882033 +95546 882764 +95546 882768 +95546 882784 +95546 882811 +95546 882822 +95546 882825 +95546 882842 +95546 883315 +95546 883762 +95546 885766 +95546 890414 +95546 890675 +95546 891202 +95546 893638 +95546 894200 +95546 896978 +95546 898730 +95546 899565 +95546 899693 +95546 900812 +95546 901539 +95546 901880 +95546 903854 +95546 907454 +95546 908890 +95546 912299 +95546 912593 +95546 912866 +95546 914907 +95546 915355 +95546 915941 +95546 918339 +95546 919937 +95546 919938 +95546 921042 +95546 925945 +95546 926717 +95546 926720 +95546 931349 +95546 931384 +95546 931401 +95546 933757 +95546 935812 +95546 937077 +95546 939230 +95546 941850 +95546 942019 +95546 942359 +95546 946948 +95546 948628 +95546 95537 +95546 95542 +95546 95544 +95546 956952 +95546 966252 +95546 971040 +95546 973042 +95546 974043 +95546 978174 +95546 978175 +95546 978176 +95546 978177 +95546 981904 +95546 982225 +95546 986222 +95546 986694 +95546 988713 +95546 989105 +95546 995210 +95546 996443 +95546 998849 +95546 998855 +95546 998856 +95546 999914 +9555 13 +9555 161487 +95559 94995 +95559 95005 +955622 955621 +955690 76656 +955781 2770779 +955833 286764 +955876 821841 +956006 1448928 +956006 209529 +956006 263274 +9561 229057 +95610 2164 +956112 956113 +956220 317553 +956250 535204 +9566 102727 +9566 259338 +9566 3175042 +9566 57475 +9566 6530 +956696 472936 +956768 956768 +956952 448007 +956952 448010 +95699 6521 +95708 74531 +957085 1308680 +957098 164477 +957098 3525078 +957098 3525079 +957098 3525080 +957098 744724 +9571 3183 +9571 34 +9571 5615 +9571 59215 +9571 700 +9571 8899 +9571 96192 +9571 99415 +957152 835070 +95718 196558 +957326 36326 +95736 115251 +957466 3332357 +957517 2674928 +957518 1375373 +95766 179062 +957708 500963 +957730 873178 +957730 883962 +957730 883966 +957730 883967 +957761 957760 +957860 957875 +95794 481918 +958 21842 +9580 525178 +9580 7552 +958040 334388 +958120 873280 +958120 873562 +958125 873196 +958217 1608826 +958217 1608827 +958217 275456 +958235 639510 +958400 63772 +958433 1164497 +958583 226461 +958583 2383328 +958583 283469 +958583 759178 +958583 759182 +95871 29855 +95878 10355 +95878 297270 +95878 418236 +95882 10360 +958830 9040 +958917 2924497 +95919 1461793 +95919 289160 +95919 53976 +959207 1033221 +959208 374519 +959208 504486 +959331 1615116 +959331 195376 +959446 1065787 +959598 959599 +95962 448889 +95966 719077 +959744 1117543 +959744 1322776 +959744 364838 +959744 848163 +959744 855053 +959744 899843 +959744 969700 +959791 1722 +95995 185137 +96 13038 +96 222247 +96 52775 +96 546591 +96 708 +96 806697 +960 1749 +960547 360954 +960614 426668 +960902 898855 +960912 875353 +960922 868236 +960940 779781 +960940 834388 +960940 836665 +960940 837875 +960940 844160 +960940 845160 +960940 960952 +960940 998335 +960943 960909 +960952 834388 +96101 95158 +961093 1070192 +961093 1918122 +961093 1956896 +961093 2504916 +96111 510106 +961113 299967 +96114 113679 +96114 355915 +9612 102878 +9612 230154 +9612 71081 +96123 1025921 +96123 1030674 +96123 1032227 +96123 1053915 +96123 1053916 +96123 108439 +96123 108565 +96123 1381758 +96123 1484973 +96123 1490119 +96123 1632801 +96123 1659360 +96123 1692113 +96123 1762555 +96123 1868841 +96123 2000915 +96123 2023931 +96123 216140 +96123 253245 +96123 260744 +96123 271870 +96123 273804 +96123 27519 +96123 283122 +96123 3248391 +96123 325672 +96123 342541 +96123 361807 +96123 368137 +96123 375279 +96123 395913 +96123 397617 +96123 406273 +96123 406278 +96123 415720 +96123 424576 +96123 448007 +96123 448010 +96123 472036 +96123 490279 +96123 497542 +96123 506006 +96123 547971 +96123 626175 +96123 696225 +96123 744724 +96123 754894 +96123 775366 +96123 809856 +96123 832915 +96123 832917 +96123 833128 +96123 833240 +96123 833986 +96123 834226 +96123 834611 +96123 835518 +96123 837584 +96123 837615 +96123 841355 +96123 841533 +96123 843529 +96123 848261 +96123 859452 +96123 860230 +96123 867946 +96123 882946 +96123 895161 +96123 92243 +96123 942019 +96123 95546 +96123 959375 +96123 959744 +96123 966985 +96123 986694 +96123 999914 +961400 108565 +961400 361074 +961400 377139 +961400 456926 +961400 744724 +961400 833128 +961400 880293 +961400 931368 +961426 282137 +961426 837588 +961426 870694 +961426 982123 +961445 1325061 +96155 13879 +96155 220226 +96175 7568 +961787 1245781 +961833 998948 +9619 118882 +9619 156687 +96197 1271547 +962 112728 +962 37330 +962 4115 +962 48274 +962 97038 +962074 1037295 +96208 203906 +96215 28041 +962209 962211 +962210 962209 +962210 962211 +962494 716084 +962494 836185 +962497 836894 +96266 199605 +96266 201632 +96266 256187 +96266 268290 +96266 45127 +96266 494377 +962964 962962 +963116 777849 +963126 162052 +96316 117718 +96316 147234 +96316 166283 +96316 288657 +96316 390557 +96316 425237 +963287 1221626 +963375 913039 +963376 260744 +963376 834534 +963376 913039 +963610 5164 +963656 1001319 +963656 845763 +96408 298294 +96408 89598 +96416 155285 +964178 3095868 +964370 137604 +96440 132482 +96446 41725 +964641 74304 +9647 1082152 +9647 37722 +964778 1133104 +96490 62653 +96503 15125 +965067 64582 +965067 82775 +9651 237563 +96513 219249 +965141 1830244 +965144 1528200 +965144 550341 +965144 834226 +965144 914678 +965252 296957 +965286 21073 +96536 164349 +96536 2588891 +96536 2588892 +9654 28209 +9654 465585 +9655 141118 +965529 2850218 +965704 794856 +965717 192327 +965717 369053 +965839 1854838 +9659 111927 +9659 117612 +9659 364902 +9659 472173 +9659 483915 +9659 504023 +9659 565831 +9659 594064 +96593 100457 +96593 137940 +96593 169830 +96593 183741 +96593 200311 +96593 248607 +96593 26923 +96593 326945 +96593 474643 +96593 96593 +966067 1420582 +966104 390552 +9662 513 +966213 1496735 +96627 42941 +966321 336241 +966366 394791 +966366 394796 +966366 966367 +966367 394791 +966367 394796 +966368 212299 +966368 289522 +966368 394791 +966368 394796 +966368 833886 +966368 838409 +966368 855761 +966368 861690 +966368 966366 +966368 966367 +96657 100450 +96657 88809 +96657 92497 +966652 966651 +9667 9996 +966857 283473 +966857 406281 +966857 406283 +966857 552196 +966857 833033 +966857 834378 +966857 844250 +966857 883641 +966985 368137 +966987 975145 +96708 1135730 +96716 458215 +967387 356317 +967387 361805 +967387 671331 +967387 835060 +967387 883952 +967387 924333 +967411 996656 +96761 104319 +96761 22798 +9678 154 +96786 219296 +96786 225847 +967915 1117724 +967915 456926 +96794 162125 +968 6136 +96826 148835 +968274 1239015 +968274 725144 +968274 912553 +968274 986222 +96844 331248 +9686 292931 +968605 252775 +9688 3650734 +968871 248177 +969022 1823637 +969022 1855232 +969022 375279 +969087 1911555 +96929 96930 +96954 137540 +96960 135057 +96960 2336446 +969700 855053 +969882 951228 +9699 9318 +969930 267753 +969930 286093 +970204 970203 +970289 717315 +97033 104175 +97033 129798 +9704 233881 +970416 115469 +970416 1192372 +970416 1328725 +970416 394778 +970416 454981 +970416 95543 +970420 1670502 +970420 448008 +970420 843527 +970535 1544716 +970535 970535 +9706 21032 +97065 22506 +970650 108534 +970650 113778 +970650 25010 +970650 449907 +97069 29262 +9707 13879 +9707 160601 +9707 188393 +9707 302458 +9707 3352 +9707 36112 +9707 618095 +9707 96155 +970755 970754 +97078 121443 +970788 948220 +970878 1502336 +971033 173503 +971033 173511 +971040 260744 +971040 573235 +971040 573239 +971040 646860 +971040 833168 +971040 842238 +971040 883315 +971040 893904 +971041 1274505 +971041 451534 +971041 845760 +97112 55607 +97127 140583 +97139 1065010 +97139 13732 +97139 1615988 +97139 273381 +97139 35646 +97140 6478 +971454 273050 +971493 625684 +971537 3039304 +971545 14119 +97163 536254 +971723 386904 +971723 846446 +97190 724 +97202 23329 +97202 97229 +972045 800887 +97210 523565 +97213 515853 +972151 174250 +972242 378315 +97229 23329 +972354 1734081 +97260 2214416 +9729 117420 +9729 289198 +9729 442896 +9729 498647 +9729 980145 +972905 1064802 +973039 1651128 +973039 2757394 +973039 283122 +973041 1009447 +973041 1040777 +973041 1147100 +973041 1165562 +973041 1341603 +973041 179709 +973041 283122 +973041 577808 +973041 841593 +973041 900979 +973041 905491 +973042 1040777 +973042 1726080 +973042 1971571 +973042 2085393 +973042 260744 +973042 283122 +973042 283127 +973042 696253 +973042 754974 +973042 833554 +973042 833698 +973042 838400 +973042 841593 +973042 850897 +973042 855072 +973042 896995 +973042 900979 +973042 973041 +973069 310213 +973077 967174 +973153 539271 +973153 539272 +9732 30792 +9732 72542 +97321 155140 +973214 439261 +973276 973275 +973277 25394 +9733 17532 +9733 56016 +97356 191844 +973597 1028502 +973597 1354730 +973597 1531265 +973597 3506857 +973597 832951 +973597 859446 +973597 859998 +973597 868334 +97364 207302 +97364 2355 +973702 334031 +97378 941102 +97378 97378 +973801 1709635 +973801 304975 +973803 973799 +973993 1188375 +973993 764192 +974043 1315847 +974043 514466 +974237 1661073 +974322 992803 +97447 97448 +97449 11573 +97449 93207 +97452 97453 +974520 282591 +9746 17546 +974665 1564317 +97467 1340356 +97467 32915 +97467 83503 +97469 521667 +97483 225277 +97485 280357 +974881 1445264 +97491 209054 +97491 2967 +975144 269254 +975144 941854 +97515 51368 +97515 77522 +97516 91905 +97516 97517 +97523 72958 +975274 1022236 +97532 195813 +97532 236601 +97532 253447 +97532 265560 +97532 312072 +97532 317272 +97532 343389 +97532 42708 +97532 88124 +97535 84041 +97538 647823 +97538 954055 +97540 506364 +97540 619946 +97545 10514 +97545 145272 +97545 20956 +97545 241012 +97545 363266 +975499 975563 +97551 97552 +97561 37950 +9757 150920 +9757 176806 +9759 50061 +976044 806436 +976044 847484 +976044 858967 +97658 51087 +97660 1128427 +97664 97320 +976680 2984010 +9767 9768 +9768 125379 +9768 15900 +976859 425546 +976868 1861950 +97688 207261 +97740 97677 +97743 118162 +97745 490692 +977516 196446 +977533 977534 +977708 1603261 +977708 353791 +977719 347068 +977722 1060954 +9781 180662 +9781 74645 +978174 978177 +978176 1046946 +978176 1200910 +978211 696225 +978211 837550 +978211 855072 +978211 864674 +978253 1325918 +978253 517158 +978253 833173 +978254 2982835 +978254 397620 +978302 1009447 +978302 1147100 +978302 1165562 +978302 1208455 +978302 170759 +978302 179709 +978302 656869 +978302 696257 +978302 833628 +978302 837674 +978302 905491 +978302 973041 +978307 1281167 +978307 514756 +97834 303846 +97838 21070 +97838 46324 +97850 185492 +978522 1375373 +97859 220832 +97859 337829 +97859 385486 +9786 224273 +9786 3882 +9786 39954 +9786 427498 +9786 9786 +978601 1818586 +97916 1237165 +97917 2153665 +97917 277633 +97917 341422 +979187 985193 +9792 699597 +979223 979224 +979330 1021138 +9794 53023 +97951 20557 +979552 1493088 +979552 1548103 +979552 1965234 +979552 932064 +97959 152485 +97959 809205 +9796 143084 +9796 155488 +9796 212034 +9796 428776 +9796 437624 +9796 551324 +9796 551325 +9796 55648 +9796 681400 +9796 9796 +9797 99449 +97974 485047 +97974 97974 +97978 235939 +979822 301101 +97986 230723 +97986 256255 +979971 68807 +9800 172490 +980059 1408760 +980059 212034 +980059 26013 +98018 1073961 +980224 113916 +980231 1283947 +980241 367212 +98025 560791 +98027 190763 +98027 246455 +98027 8317 +98033 279553 +9804 92264 +98041 233316 +980465 900649 +980490 306877 +980526 1048430 +980526 224329 +980526 262940 +980526 415725 +98053 105456 +980563 283280 +98057 50892 +98062 231661 +9808 10014 +9808 134525 +9808 180642 +9808 241735 +9808 411620 +9808 6748 +980997 1462228 +981 1279 +981 983 +9810 31227 +981287 157405 +981348 981344 +98166 214021 +98169 139433 +981748 1130977 +981781 409891 +981781 749771 +981809 42936 +981845 981853 +981869 853441 +98194 139875 +982 981 +982 983 +9820 22975 +98201 594242 +98201 778613 +982087 70622 +982116 95623 +982123 282137 +982140 1552105 +982140 1999435 +982140 723872 +982177 759186 +982225 1102995 +982225 759186 +982225 849441 +98233 72186 +982396 1003993 +982396 1417030 +982396 1417031 +982396 1417032 +982396 27519 +982396 809856 +982396 982397 +982396 982399 +982396 986114 +982397 982399 +982520 1179326 +982549 139704 +982599 673902 +9827 16478 +9827 670 +982794 972801 +982819 49719 +982956 982958 +983159 1087595 +983159 645106 +98322 2393463 +983282 1255970 +9833 4993 +983349 1054626 +983349 1055198 +983349 2326899 +983481 1383928 +98356 182909 +983602 1692113 +983602 833599 +983657 192325 +983657 759178 +983657 759182 +983699 1025832 +983699 3549226 +98372 104370 +98372 3288 +98372 411285 +98372 48686 +98372 57477 +98381 780741 +983825 262940 +983825 561054 +98384 598297 +983966 537450 +984181 10850 +984181 984182 +984182 10850 +984186 1886097 +984186 283473 +984186 406281 +984186 424576 +984186 711106 +9842 58566 +9842 74937 +98423 711738 +984293 71844 +984353 436743 +98436 1301545 +98436 239261 +98436 98899 +984381 3030348 +984446 1503116 +98456 161760 +984639 59831 +9847 230338 +9847 604560 +984718 1107 +98472 98473 +984728 373385 +984756 1493009 +98481 702338 +98498 1065010 +98498 36527 +985039 3616691 +985088 260744 +985088 261451 +985088 552195 +985088 604396 +985088 617404 +985088 823465 +985088 833698 +985088 835519 +985088 845360 +985088 865050 +9852 121266 +985250 838747 +98545 68674 +985450 911001 +985480 158120 +98563 17587 +9858 10159 +9858 2698689 +9858 31262 +9858 511658 +9858 67703 +985811 1572214 +985811 1668356 +985811 1958244 +985811 2457407 +985811 308384 +985811 628737 +985811 987368 +98582 5493 +985822 2161262 +985926 335565 +985926 401802 +985935 344166 +985994 985992 +98608 248283 +986111 1616106 +986111 839080 +986112 1640327 +986112 2129819 +986112 2645574 +986112 395913 +986112 406273 +986112 406283 +986112 696257 +986112 754974 +986112 837550 +986112 837674 +986112 966985 +986114 1417030 +986114 1417031 +986114 1417032 +98616 32434 +986196 986197 +9862 163586 +986214 1353208 +986214 451534 +986214 495010 +986214 653372 +986214 833687 +986214 834071 +9863 227693 +98633 11802 +98633 1222695 +98633 239568 +98633 271508 +98633 4629 +98633 484739 +98633 528881 +98633 543427 +98633 601783 +98633 810207 +986427 456211 +986427 495010 +9866 1754529 +9866 1845278 +9866 358719 +9866 3850 +9866 39008 +9866 397679 +9866 40541 +9866 460922 +9866 87298 +9866 90203 +9866 90210 +986636 411447 +986694 847372 +98671 159384 +98671 177243 +98671 36239 +986743 1113594 +986743 1572214 +986743 2123557 +987 984 +987177 987178 +987256 132592 +987256 601960 +987368 1572214 +987368 1958244 +987368 2457407 +987368 628737 +987377 140032 +987377 258111 +987505 62678 +987776 1515763 +987860 1636340 +987860 415725 +987860 441528 +987860 837657 +987860 837660 +987860 838984 +987860 861690 +987860 987866 +987862 282639 +987866 1636340 +987866 837657 +987866 837660 +987866 838984 +987866 861690 +9880 158891 +9880 610955 +9880 7018 +988252 988249 +988252 991655 +98827 521920 +988349 2072619 +988349 2187 +988351 875953 +988463 40576 +988470 71172 +988487 538 +988591 120620 +988591 30552 +988591 64694 +9887 8298 +988705 3046011 +988711 988713 +988712 1728368 +988712 268272 +988712 832942 +988712 872129 +988744 1044184 +988744 1044185 +988744 630259 +988770 1479204 +988770 215993 +988770 2210246 +988777 988776 +988778 988776 +988778 988777 +988781 1004477 +988781 212299 +988781 663387 +988814 26101 +98885 198710 +988905 1202945 +988905 454981 +988905 95544 +988977 1114550 +98902 2436012 +989049 1324861 +989105 207945 +989105 302078 +989105 767642 +989105 832962 +989105 845769 +989105 890675 +989105 914150 +989105 995188 +98922 1297358 +989490 178010 +989655 989654 +989683 837386 +989687 1833723 +989687 725144 +989795 1007045 +989795 561943 +99018 101988 +9902 1196 +9902 30413 +99024 414628 +990340 910823 +990454 1015406 +990454 1151333 +990454 1246887 +990454 1548103 +990454 2203553 +990454 260744 +990454 448010 +990454 833179 +990454 834227 +990454 894398 +990454 979552 +990584 2241400 +990584 2241401 +990599 1012932 +990604 1244753 +99064 484268 +99064 75380 +990663 792555 +990733 114493 +99079 230491 +990814 1201468 +990925 349766 +990925 560687 +990969 702236 +991190 2101599 +9912 15869 +9912 194 +9912 202422 +9912 251428 +9912 454715 +9912 60702 +9912 86666 +9912 9808 +9913 197112 +9913 411631 +9913 61048 +9913 65130 +9913 9913 +99134 262062 +99137 241355 +991389 1032278 +991389 1478675 +991389 1636340 +991389 1640328 +991389 1728371 +991389 290601 +991389 39874 +991389 435555 +991389 448010 +991389 454293 +991389 526591 +991389 837512 +991389 838932 +991389 842132 +991389 851419 +991389 855065 +991389 922015 +991471 456764 +991471 924191 +99151 592098 +991517 2761548 +991517 432781 +991532 1250628 +991532 2118677 +991532 2179272 +991532 2179274 +991532 776858 +991532 835392 +991532 835396 +99159 14545 +9916 9278 +99164 52782 +991676 417469 +99172 198047 +99172 208442 +99172 26931 +991776 910341 +9918 25699 +991806 805613 +991863 938666 +991878 227549 +99193 612070 +99201 841998 +99207 458047 +992312 992326 +99233 1534857 +992589 1215013 +9926 1175 +9926 227837 +992682 992685 +992729 992728 +992743 352889 +992793 1395738 +992806 1094052 +992806 214913 +99289 109688 +99289 317 +99312 28680 +993186 2118781 +993186 286673 +9932 172004 +9932 75757 +993261 996059 +9933 11004 +9933 25716 +9933 3156817 +99379 622862 +99384 50430 +993878 279930 +99399 43095 +99413 20581 +99438 146216 +99442 578324 +99445 995991 +994569 1431768 +99472 271100 +994735 279413 +994748 108074 +99498 124159 +99506 529132 +99511 120233 +99512 177921 +99512 499885 +995188 375279 +995188 95546 +99521 629020 +995210 1046946 +995210 1849894 +995463 4628 +99547 31572 +99547 99548 +99548 31572 +995527 914950 +99571 68819 +995730 1249322 +995736 125388 +9959 9958 +99590 242174 +996 12185 +996 49145 +996 97633 +99609 1012905 +9962 194395 +9962 31995 +99628 218849 +99636 16453 +99636 206000 +99643 151897 +996441 2409461 +996441 2409463 +996441 610799 +996441 855890 +996441 882724 +996442 2500296 +996442 3580866 +996442 492930 +996442 867599 +996443 3101195 +996444 283122 +996474 1180987 +996474 134249 +996474 1377115 +996474 1398140 +996474 1494252 +996474 183427 +996474 475678 +996474 616271 +996474 996474 +9965 106720 +9965 21128 +9965 2671999 +9965 65048 +996547 996548 +996549 996547 +996549 996548 +996568 281833 +9966 37308 +9966 39713 +9966 665194 +996604 158822 +996604 364257 +99679 51271 +99679 90037 +996865 1963216 +996865 3688275 +9969 9962 +996986 1332498 +997 100293 +99701 76501 +997053 397620 +997053 754974 +997191 852709 +997191 92243 +9972 13017 +9972 18684 +9972 198518 +9972 207006 +9972 22877 +997210 1814562 +997277 1429382 +997277 834378 +997277 885767 +99729 416581 +99731 134681 +99731 141326 +99731 144927 +99731 264514 +99731 700504 +997585 226461 +997585 744724 +99767 151326 +997791 1470066 +997818 1204975 +99793 339282 +99793 342214 +99793 56343 +99811 362229 +998140 750827 +99821 1045524 +99821 3637547 +99821 515354 +998310 424754 +998335 779781 +998394 1163343 +998416 855059 +998416 855061 +998482 1269006 +998482 1378288 +998482 998484 +998484 1269006 +998484 1378288 +998484 412929 +99850 110884 +99850 362798 +99850 75922 +998654 1356610 +998654 2736228 +998666 276435 +998666 585178 +99871 149190 +99876 315101 +998760 153391 +998825 874943 +99884 1376038 +998849 283122 +998849 754974 +998849 833075 +998849 998856 +998855 283122 +998855 3740167 +998855 754974 +998855 833075 +998855 833686 +998855 839514 +998855 842641 +998855 842645 +998855 857122 +998855 900812 +998855 998849 +998855 998856 +998856 283122 +998856 415720 +998856 754974 +998856 833075 +998856 841593 +998856 900979 +998869 1446579 +998869 938452 +999037 336113 +99918 69673 +999186 488584 +999186 579373 +999189 1166843 +999189 212299 +999189 3010101 +999189 403638 +999189 412749 +999189 488584 +999189 579373 +999189 92243 +999189 999186 +999265 476221 +99929 96370 +9994 8425 +999536 135946 +9996 6753 +999642 631060 +999862 627921 +999914 1000280 +999914 1004028 +999914 1009447 +999914 1010199 +999914 1015406 +999914 1025832 +999914 1027989 +999914 1028502 +999914 1037730 +999914 1037731 +999914 1040507 +999914 1051616 +999914 1063052 +999914 1068298 +999914 108439 +999914 108566 +999914 110387 +999914 1127509 +999914 115466 +999914 1233999 +999914 1259272 +999914 1277579 +999914 1300737 +999914 1312375 +999914 1320696 +999914 1326044 +999914 1328919 +999914 1337833 +999914 1351876 +999914 1376703 +999914 1386786 +999914 1386787 +999914 1419981 +999914 1428466 +999914 1435431 +999914 1443685 +999914 1491036 +999914 1501991 +999914 1524329 +999914 153980 +999914 1588452 +999914 1608503 +999914 1707838 +999914 1731804 +999914 1733209 +999914 1917218 +999914 1976428 +999914 1999445 +999914 2013704 +999914 2037502 +999914 2059949 +999914 2196416 +999914 224329 +999914 226461 +999914 2323597 +999914 2433785 +999914 260744 +999914 261451 +999914 262940 +999914 268272 +999914 269254 +999914 271870 +999914 271874 +999914 271877 +999914 274325 +999914 27519 +999914 279614 +999914 282137 +999914 283122 +999914 283125 +999914 283127 +999914 283473 +999914 299702 +999914 304975 +999914 308115 +999914 3139504 +999914 317584 +999914 3331684 +999914 340210 +999914 343871 +999914 3586619 +999914 359068 +999914 366820 +999914 368137 +999914 374770 +999914 377139 +999914 379809 +999914 388185 +999914 394796 +999914 395913 +999914 397616 +999914 397617 +999914 397620 +999914 406271 +999914 406273 +999914 406278 +999914 406281 +999914 406283 +999914 406285 +999914 415720 +999914 424576 +999914 435555 +999914 439663 +999914 448007 +999914 448008 +999914 448009 +999914 448010 +999914 454293 +999914 454981 +999914 456764 +999914 459673 +999914 479033 +999914 479036 +999914 490290 +999914 499563 +999914 517144 +999914 517158 +999914 520248 +999914 521381 +999914 523633 +999914 526579 +999914 526590 +999914 526592 +999914 538821 +999914 539271 +999914 539272 +999914 542688 +999914 547969 +999914 547971 +999914 550341 +999914 552195 +999914 552196 +999914 576026 +999914 578737 +999914 604396 +999914 617133 +999914 626175 +999914 627128 +999914 662168 +999914 696188 +999914 696200 +999914 696225 +999914 704150 +999914 712500 +999914 725023 +999914 725217 +999914 730308 +999914 744724 +999914 749007 +999914 754894 +999914 754974 +999914 759182 +999914 784121 +999914 800996 +999914 805380 +999914 809856 +999914 826839 +999914 832673 +999914 832905 +999914 832915 +999914 832917 +999914 832942 +999914 832962 +999914 832992 +999914 833027 +999914 833033 +999914 833038 +999914 833068 +999914 833128 +999914 833179 +999914 833560 +999914 833687 +999914 833697 +999914 833698 +999914 833794 +999914 833798 +999914 833840 +999914 834224 +999914 834226 +999914 834227 +999914 834378 +999914 834577 +999914 834578 +999914 834611 +999914 834646 +999914 835066 +999914 835112 +999914 835190 +999914 835415 +999914 835518 +999914 835735 +999914 836429 +999914 837568 +999914 837575 +999914 837577 +999914 837626 +999914 837627 +999914 837674 +999914 837881 +999914 838295 +999914 838588 +999914 839640 +999914 840391 +999914 840489 +999914 841294 +999914 842132 +999914 842233 +999914 842888 +999914 843513 +999914 844250 +999914 845359 +999914 845775 +999914 846281 +999914 846296 +999914 846301 +999914 847818 +999914 849690 +999914 849793 +999914 854513 +999914 855059 +999914 855072 +999914 858372 +999914 859448 +999914 860273 +999914 860731 +999914 864672 +999914 864674 +999914 867946 +999914 867976 +999914 869796 +999914 869797 +999914 871323 +999914 872129 +999914 873814 +999914 874560 +999914 882946 +999914 883641 +999914 883777 +999914 888854 +999914 894410 +999914 900448 +999914 905982 +999914 914907 +999914 917373 +999914 933345 +999914 951326 +999914 951327 +999914 95537 +999914 95542 +999914 95543 +999914 970416 +999914 970420 +999914 976242 +999914 978211 +999914 984186 +999914 988712 +99993 1462228 +99993 980997 diff --git a/snap-python/source/test/data/g1.edgelist b/snap-python/source/test/data/g1.edgelist new file mode 100644 index 0000000000000000000000000000000000000000..190e6f30b747dd8272a2f5f6f0e26344c3d316f7 --- /dev/null +++ b/snap-python/source/test/data/g1.edgelist @@ -0,0 +1,100000 @@ +0 9174 +0 5763 +0 2693 +0 9827 +0 4131 +0 141 +0 5710 +0 8786 +0 9011 +0 4526 +0 4918 +0 5496 +0 6297 +0 163 +0 2843 +0 4054 +0 6334 +0 6943 +1 4130 +1 7683 +1 3428 +1 5670 +1 2731 +1 5838 +1 2448 +1 1041 +1 4306 +1 9395 +1 8628 +1 981 +1 9175 +1 8484 +1 5306 +1 1294 +1 2393 +2 2319 +2 8210 +2 668 +2 2600 +2 2228 +2 9657 +2 1726 +2 9538 +2 9161 +2 3786 +2 4173 +2 5454 +2 1743 +2 1492 +2 719 +2 3938 +2 8806 +2 5610 +2 886 +2 3924 +2 1151 +2 3071 +3 9089 +3 4866 +3 9991 +3 777 +3 4490 +3 3468 +3 6542 +3 2576 +3 3731 +3 1046 +3 6172 +3 2334 +3 8230 +3 9639 +3 2217 +3 1706 +3 9917 +3 8255 +3 4038 +3 9163 +3 7249 +3 8033 +3 3810 +3 2917 +3 8040 +3 7792 +3 3964 +3 7167 +4 2656 +4 4036 +4 6774 +4 230 +4 1863 +4 7304 +4 907 +4 3101 +4 9651 +4 4941 +4 9872 +4 2609 +4 3347 +4 5846 +4 4113 +4 6095 +4 9085 +4 2789 +5 3040 +5 9328 +5 473 +5 67 +5 7908 +5 6725 +5 5702 +5 6631 +5 1611 +5 9676 +5 4206 +5 3792 +5 1332 +5 9278 +5 4822 +5 8919 +5 4564 +5 7615 +5 1887 +5 798 +5 9695 +6 734 +6 6913 +6 1923 +6 2889 +6 2945 +6 233 +6 1225 +6 841 +6 4875 +6 3314 +6 9678 +6 9105 +6 3922 +6 9524 +6 1758 +6 7607 +6 2297 +6 4127 +6 5150 +6 4981 +7 2323 +7 916 +7 9749 +7 3734 +7 9631 +7 8353 +7 6747 +7 9384 +7 8493 +7 4411 +7 2365 +7 5439 +7 8768 +7 969 +7 8524 +7 4433 +7 852 +7 8150 +7 7387 +7 6626 +7 4586 +7 1398 +7 6519 +8 4356 +8 4582 +8 9062 +8 3698 +8 2674 +8 6067 +8 2326 +8 8087 +8 9625 +8 2111 +8 1373 +8 2975 +9 3596 +9 8845 +9 4494 +9 6170 +9 1315 +9 3751 +9 8363 +9 8878 +9 1456 +9 6705 +9 9146 +9 3903 +9 6208 +9 8390 +9 2892 +9 5844 +9 353 +9 5476 +9 3557 +9 9831 +9 8688 +9 6898 +9 3443 +9 9464 +10 4384 +10 3611 +10 612 +10 6597 +10 966 +10 7019 +10 9010 +10 5010 +10 435 +10 3124 +10 2262 +10 281 +10 8155 +10 9139 +10 2949 +11 4480 +11 581 +11 3430 +11 5543 +11 1896 +11 1244 +11 7495 +11 6124 +11 7855 +11 5488 +11 7058 +11 3828 +11 6325 +11 280 +11 5209 +11 1212 +11 7943 +12 3520 +12 3681 +12 9221 +12 7271 +12 3233 +12 9133 +12 5262 +12 2319 +12 4785 +12 4050 +12 8640 +12 1398 +12 8557 +12 600 +12 1467 +13 7552 +13 771 +13 3334 +13 2451 +13 8720 +13 6578 +13 8243 +13 4279 +13 4536 +13 9562 +13 3835 +13 1503 +14 7041 +14 7074 +14 4726 +14 3933 +14 6472 +14 1836 +14 8426 +14 3243 +14 5740 +14 4370 +14 7342 +14 9469 +14 114 +14 6995 +14 21 +14 414 +14 7767 +14 1875 +14 6666 +14 286 +14 5535 +15 7584 +15 961 +15 34 +15 8075 +15 4132 +15 7301 +15 8166 +15 1385 +15 1020 +15 3629 +15 9056 +15 6197 +15 534 +15 9687 +15 1914 +15 9723 +15 4060 +15 5417 +15 4286 +16 9728 +16 8961 +16 7173 +16 7944 +16 25 +16 8091 +16 4636 +16 9245 +16 9883 +16 6698 +16 2604 +16 4525 +16 7607 +16 4027 +16 5315 +16 1093 +16 6343 +16 5836 +16 7759 +16 594 +16 1491 +16 7253 +16 3547 +16 7145 +16 8567 +17 290 +17 6307 +17 9860 +17 517 +17 7441 +17 9192 +17 4937 +17 4010 +17 1611 +17 6640 +17 9009 +17 5043 +17 1652 +17 7509 +17 9815 +17 2265 +17 1370 +17 1947 +17 316 +17 2911 +18 1537 +18 7043 +18 6661 +18 4232 +18 7822 +18 6033 +18 2963 +18 7581 +18 8990 +18 6961 +18 3251 +18 9016 +18 2617 +18 4297 +18 8907 +18 4428 +18 974 +18 4318 +18 2794 +18 9196 +18 9711 +18 504 +19 5600 +19 2529 +19 9155 +19 2145 +19 8167 +19 6505 +19 7562 +19 8651 +19 6476 +19 5773 +19 4445 +19 8400 +19 4792 +19 8882 +19 212 +19 2648 +19 1401 +19 3053 +19 3485 +19 895 +20 6914 +20 5775 +20 9237 +20 6424 +20 170 +20 3503 +20 5942 +20 2103 +20 4409 +20 5435 +20 6592 +20 1863 +20 1634 +20 78 +20 3789 +20 9301 +20 8407 +20 3426 +20 5226 +20 3821 +20 1646 +20 9585 +20 9463 +20 1917 +21 4224 +21 9921 +21 6371 +21 7271 +21 1608 +21 1834 +21 8462 +21 2832 +21 3126 +21 184 +21 5146 +21 3068 +21 2762 +22 9538 +22 5027 +22 6245 +22 5864 +22 5322 +22 2669 +22 3920 +22 4595 +22 7317 +22 1337 +22 2586 +22 1372 +22 93 +23 3200 +23 660 +23 542 +23 8608 +23 8869 +23 3239 +23 9641 +23 8875 +23 1710 +23 5689 +23 1466 +23 2109 +23 575 +23 4057 +23 8538 +23 609 +23 9447 +23 9448 +23 6823 +23 6511 +23 5493 +23 3063 +23 2040 +23 1812 +23 4475 +23 1404 +24 5276 +24 6052 +24 485 +24 9702 +24 3249 +24 6152 +24 553 +24 1837 +24 8464 +24 1745 +24 3858 +24 3543 +24 2361 +24 2009 +24 7805 +24 3998 +24 7327 +25 9968 +25 5061 +25 8072 +25 8650 +25 7819 +25 9309 +25 9197 +25 8110 +25 207 +25 1701 +25 9235 +25 8276 +25 7893 +25 4022 +25 6041 +25 6778 +25 3772 +25 5405 +25 9749 +26 9450 +26 5529 +26 9504 +26 1017 +26 1314 +26 1318 +26 2476 +26 1077 +26 3642 +26 9531 +26 2367 +26 195 +26 3012 +26 2246 +26 7751 +26 72 +26 3922 +26 7763 +26 5719 +26 5985 +26 2277 +26 3432 +26 2410 +26 2293 +26 7801 +26 3453 +27 3741 +27 1360 +27 1122 +27 8387 +27 8258 +27 7344 +27 6636 +27 1538 +27 8701 +27 2032 +27 786 +27 4324 +27 9615 +27 3997 +28 6880 +28 2338 +28 3048 +28 9903 +28 3756 +28 6543 +28 1374 +28 9590 +28 6168 +28 601 +28 6831 +28 7069 +28 7198 +29 4456 +29 68 +29 9927 +29 6760 +29 1449 +29 2759 +29 6343 +29 78 +29 305 +29 8462 +29 9519 +29 6984 +29 849 +29 8120 +29 2645 +29 9687 +29 4591 +29 9530 +29 8047 +29 2301 +29 7487 +30 1280 +30 7952 +30 9314 +30 2277 +30 6920 +30 8204 +30 1450 +30 8236 +30 7106 +30 6446 +30 6896 +30 819 +30 5204 +30 1486 +30 3992 +30 5754 +30 9555 +31 3201 +31 8100 +31 4806 +31 6920 +31 1388 +31 1834 +31 6764 +31 9136 +31 1522 +31 6967 +31 9689 +31 2586 +31 3838 +31 8415 +32 5638 +32 2055 +32 2568 +32 6026 +32 5900 +32 3598 +32 4241 +32 8867 +32 5808 +32 9652 +32 4801 +32 5702 +32 5703 +32 8718 +32 2528 +32 1122 +32 9319 +32 621 +32 2672 +32 7416 +32 249 +32 3454 +33 1344 +33 3840 +33 3298 +33 6563 +33 9860 +33 8982 +33 4760 +33 813 +33 9712 +33 2264 +33 7030 +33 3608 +33 2713 +34 6656 +34 774 +34 8842 +34 6796 +34 5520 +34 659 +34 5654 +34 8728 +34 5664 +34 8994 +34 2219 +34 8879 +34 180 +34 4533 +34 5562 +34 76 +34 9167 +34 3664 +34 6626 +34 8303 +34 4859 +34 8828 +35 4739 +35 5895 +35 8332 +35 9362 +35 7187 +35 8734 +35 7199 +35 2596 +35 7591 +35 9263 +35 1842 +35 568 +35 7994 +35 7867 +35 3792 +35 7130 +35 2523 +35 1695 +35 8415 +35 2896 +35 7401 +35 2158 +35 8049 +35 4596 +35 2171 +35 9340 +35 765 +36 4416 +36 4097 +36 5350 +36 6119 +36 1897 +36 3595 +36 5420 +36 4557 +36 7159 +36 60 +37 2067 +37 8962 +37 3853 +37 8142 +37 1181 +37 970 +37 2258 +37 1682 +37 6830 +37 3261 +37 240 +37 3378 +37 5162 +37 8718 +37 535 +37 6135 +37 4634 +37 4475 +37 1578 +37 4351 +38 5272 +38 5271 +38 6552 +38 2216 +38 7468 +38 3117 +38 2222 +38 8369 +38 3636 +38 828 +38 3135 +38 845 +38 9933 +38 7508 +38 1372 +38 3686 +38 5868 +38 5102 +38 5363 +38 6004 +38 6612 +38 7803 +39 5248 +39 7824 +39 9315 +39 278 +39 6439 +39 6281 +39 202 +39 3499 +39 8014 +39 4887 +39 7740 +39 6558 +39 8533 +39 5878 +39 6807 +39 7992 +39 3007 +39 6332 +39 8829 +39 8318 +39 3807 +40 3010 +40 1291 +40 3685 +40 7655 +40 5960 +40 3913 +40 924 +40 107 +40 1900 +40 7537 +40 9800 +40 3059 +40 9846 +40 88 +40 1113 +40 8506 +40 7100 +40 3786 +40 9759 +41 9926 +41 5543 +41 8746 +41 9964 +41 9039 +41 4849 +41 4431 +41 3668 +41 117 +41 2298 +41 5691 +41 9628 +41 9658 +41 5566 +42 9187 +42 3813 +42 4515 +42 4653 +42 3406 +42 4079 +42 9861 +42 7569 +42 9459 +42 1797 +42 767 +42 6565 +43 9536 +43 718 +43 9186 +43 5035 +43 3460 +43 7505 +43 6601 +43 5351 +43 398 +43 7791 +43 3600 +43 6385 +43 4051 +43 1358 +43 3608 +43 1817 +43 5167 +43 2941 +43 2653 +44 1346 +44 2723 +44 2630 +44 966 +44 5713 +44 9192 +44 2857 +44 8106 +44 1771 +44 2925 +44 5359 +44 9648 +44 3665 +44 4243 +44 9982 +44 775 +44 5434 +44 7067 +44 2141 +44 9630 +45 8160 +45 481 +45 4438 +45 2550 +45 4198 +45 8993 +45 1096 +45 9449 +45 4173 +45 9328 +45 8817 +45 3638 +45 5080 +45 2276 +45 6394 +45 6591 +45 9116 +45 5722 +45 1466 +46 1987 +46 2728 +46 340 +46 7502 +46 3087 +46 5200 +46 4433 +46 8413 +46 7892 +46 277 +46 6937 +46 9019 +46 1085 +46 7838 +46 1813 +47 3617 +47 4322 +47 9699 +47 4321 +47 297 +47 2602 +47 8267 +47 396 +47 8813 +47 8143 +47 4114 +47 3221 +47 3642 +47 2831 +47 7293 +48 8930 +48 7047 +48 9487 +48 2704 +48 7444 +48 4889 +48 3355 +48 2844 +48 541 +48 5151 +48 8610 +48 1960 +48 5801 +48 9778 +48 1463 +48 189 +48 8393 +48 461 +48 6350 +48 1231 +48 3030 +48 2658 +48 9190 +48 7920 +48 7420 +49 2278 +49 5288 +49 9860 +49 8005 +49 3622 +49 9416 +49 3145 +49 7882 +49 9388 +49 1293 +49 8659 +49 8232 +49 6643 +49 6776 +49 4088 +49 2655 +49 1055 +49 7205 +49 8479 +50 9089 +50 398 +50 411 +50 9118 +50 1184 +50 1826 +50 1702 +50 6833 +50 2856 +50 7850 +50 8363 +50 7473 +50 9138 +50 1460 +50 6198 +50 3651 +50 5062 +50 6473 +50 1493 +50 2775 +50 5861 +50 7924 +51 5888 +51 8450 +51 4516 +51 1797 +51 2281 +51 140 +51 5262 +51 5231 +51 4923 +51 4028 +52 1155 +52 5765 +52 7430 +52 9541 +52 907 +52 4499 +52 4634 +52 3869 +52 1183 +52 9760 +52 161 +52 8757 +52 5440 +52 1733 +52 6982 +52 79 +52 5829 +52 8915 +52 4055 +52 4570 +52 5086 +52 5343 +52 2017 +52 5218 +52 9444 +52 7528 +52 3948 +52 978 +52 1134 +52 8564 +52 9845 +52 8184 +52 8702 +53 6278 +53 3863 +53 6298 +53 3997 +53 7454 +53 1574 +53 1711 +53 564 +53 5814 +53 3130 +53 4795 +53 9408 +53 1356 +53 9944 +53 990 +53 7519 +53 5030 +53 1383 +53 622 +53 7151 +53 2931 +53 1655 +53 6397 +54 9987 +54 4999 +54 4332 +54 6165 +54 7705 +54 9115 +54 9121 +54 674 +54 8262 +54 6192 +54 7358 +54 9151 +54 4037 +54 5446 +54 8522 +54 9036 +54 1997 +54 3152 +54 2411 +54 5868 +54 4846 +54 8437 +54 5111 +54 2424 +54 9338 +54 6782 +55 3338 +55 1419 +55 1935 +55 9234 +55 3733 +55 8087 +55 3095 +55 287 +55 2722 +55 4652 +55 9264 +55 4145 +55 1465 +55 4669 +55 4549 +55 8007 +55 2130 +55 4825 +55 8027 +55 6114 +55 5605 +55 4969 +55 9707 +55 4343 +56 4408 +56 5762 +56 6584 +56 967 +56 6313 +56 6090 +56 7623 +56 6380 +56 1999 +56 5788 +56 6833 +56 183 +56 3091 +56 6612 +56 2646 +56 439 +56 6904 +56 5980 +56 6941 +56 3870 +56 8511 +57 9543 +57 964 +57 4295 +57 1771 +57 7660 +57 9394 +57 2126 +57 9232 +57 946 +57 7605 +57 2455 +57 3287 +57 8092 +57 5726 +58 1760 +58 6053 +58 5096 +58 5324 +58 7466 +58 2699 +58 6092 +58 9965 +58 5971 +58 8717 +58 1800 +58 2898 +58 851 +58 6455 +58 9624 +58 6521 +58 8986 +58 4156 +58 8894 +58 1599 +59 3985 +59 8027 +59 5125 +59 5894 +59 9223 +59 4074 +59 7293 +59 6993 +59 5713 +59 5674 +59 1910 +59 791 +59 5401 +59 6223 +59 655 +59 1418 +60 5952 +60 7523 +60 2245 +60 8390 +60 2986 +60 7563 +60 9071 +60 4339 +60 3380 +60 8638 +60 2585 +60 9707 +60 1691 +60 3006 +60 3365 +61 3715 +61 5125 +61 1041 +61 7322 +61 2974 +61 2593 +61 2475 +61 2478 +61 2865 +61 4018 +61 1846 +61 6455 +61 1595 +61 2118 +61 2759 +61 1608 +61 5196 +61 206 +61 8272 +61 5588 +61 100 +61 7402 +61 3313 +61 3832 +62 4097 +62 6147 +62 9345 +62 5258 +62 6290 +62 4206 +62 9629 +62 7071 +62 4336 +62 5540 +62 1718 +62 2365 +62 6857 +62 5068 +62 8783 +62 5208 +62 7010 +62 1900 +62 5906 +62 6766 +62 5744 +62 8818 +62 2933 +63 4355 +63 4996 +63 4232 +63 3849 +63 5194 +63 5006 +63 6415 +63 5904 +63 8465 +63 2098 +63 4725 +63 1462 +63 2711 +63 5828 +63 2747 +63 284 +63 9245 +63 3166 +63 6505 +64 3682 +64 6683 +64 1366 +64 4817 +64 2632 +64 4297 +64 290 +64 3406 +64 2639 +64 6897 +64 3507 +64 4366 +64 8915 +64 4571 +64 4030 +64 8191 +65 8483 +65 6276 +65 374 +65 9159 +65 7144 +65 7452 +65 9098 +65 8041 +65 8113 +65 3443 +65 6068 +65 2300 +65 9558 +65 1161 +65 4888 +65 6393 +65 6716 +65 8746 +65 5777 +65 6196 +66 6530 +66 4996 +66 1810 +66 4757 +66 4442 +66 8989 +66 164 +66 1960 +66 8877 +66 1710 +66 2486 +66 7482 +66 5051 +66 1476 +66 8908 +66 6362 +66 314 +66 3044 +66 4337 +66 3446 +66 2555 +66 6549 +67 7776 +67 7041 +67 2658 +67 1829 +67 1382 +67 3144 +67 5098 +67 8032 +67 146 +67 7855 +67 368 +67 625 +67 3250 +67 7219 +67 4020 +67 2264 +67 7481 +67 9499 +67 1949 +67 3678 +68 9154 +68 1195 +68 8101 +68 1416 +68 3147 +68 1421 +68 9198 +68 3501 +68 9424 +68 9525 +68 6004 +68 2229 +68 2088 +68 1911 +68 9272 +68 8825 +68 2843 +68 3228 +68 7646 +68 5855 +69 8259 +69 6594 +69 2947 +69 4356 +69 7589 +69 6438 +69 3670 +69 1389 +69 8433 +69 7314 +69 9539 +69 7060 +69 5877 +69 4662 +69 5370 +69 4645 +69 4286 +69 5791 +70 8672 +70 1584 +70 9634 +70 6147 +70 7012 +70 2865 +70 9523 +70 435 +70 2637 +70 2062 +70 3567 +70 1555 +70 4401 +70 6802 +70 6211 +70 5397 +70 9211 +70 9309 +71 9217 +71 4488 +71 8721 +71 8470 +71 4891 +71 2266 +71 9377 +71 5538 +71 9764 +71 8999 +71 9642 +71 3757 +71 2864 +71 2744 +71 7482 +71 9277 +71 4163 +71 5444 +71 8901 +71 4307 +71 2522 +71 4059 +71 5341 +71 2906 +71 3053 +71 9328 +71 2545 +71 9982 +72 2177 +72 4994 +72 5764 +72 2952 +72 393 +72 4234 +72 400 +72 6296 +72 3093 +72 7832 +72 540 +72 2852 +72 6309 +72 7334 +72 4143 +72 2997 +72 2490 +72 1725 +72 3774 +72 3652 +72 8778 +72 344 +72 6361 +72 5984 +72 5158 +73 482 +73 6859 +73 518 +73 599 +73 2743 +73 556 +73 6978 +73 6802 +73 275 +73 2996 +73 6105 +73 2776 +73 4825 +73 3994 +73 159 +73 9431 +73 95 +74 1156 +74 2053 +74 1936 +74 5524 +74 7662 +74 7325 +74 4647 +74 6184 +74 2345 +74 6960 +74 945 +74 7734 +74 5175 +74 1728 +74 2886 +74 3912 +74 8395 +74 6734 +74 593 +74 5975 +74 1120 +74 7139 +74 6254 +74 7036 +74 6269 +74 7935 +75 4833 +75 9795 +75 7370 +75 8427 +75 4268 +75 6701 +75 9679 +75 2755 +75 3413 +75 4855 +75 120 +75 8059 +75 8597 +76 4662 +76 7656 +76 1129 +76 6283 +76 8973 +76 7152 +76 6003 +76 8660 +76 9365 +76 5750 +76 9737 +76 5179 +76 6237 +76 9470 +76 4083 +77 9440 +77 784 +77 7621 +77 550 +77 4561 +77 5064 +77 9257 +77 128 +77 6375 +77 1298 +77 8591 +77 2096 +77 2737 +77 6482 +77 659 +77 948 +77 8309 +77 6745 +77 1864 +77 8988 +77 7021 +78 3107 +78 4291 +78 2788 +78 4741 +78 2604 +78 9940 +78 655 +78 6704 +78 6225 +78 4179 +78 4823 +78 5561 +78 7836 +78 8029 +78 1726 +79 1170 +79 9090 +79 2537 +79 2949 +79 4774 +79 1657 +79 6921 +79 7562 +79 6953 +79 3769 +79 8306 +79 9429 +79 5817 +79 7321 +79 2769 +79 5375 +79 277 +80 3680 +80 513 +80 1531 +80 5284 +80 3606 +80 647 +80 7402 +80 1227 +80 7405 +80 7892 +80 8245 +80 6934 +80 4185 +80 5275 +80 9500 +80 4157 +80 7454 +80 2149 +81 9857 +81 6003 +81 6595 +81 6468 +81 6566 +81 5427 +81 3179 +81 5901 +81 6286 +81 6481 +81 7507 +81 8312 +81 8154 +81 3999 +81 1407 +82 7971 +82 5251 +82 4182 +82 8230 +82 7015 +82 5516 +82 8234 +82 3083 +82 4300 +82 7565 +82 4846 +82 3025 +82 9778 +82 8243 +82 2670 +82 1174 +82 7799 +82 3014 +82 8665 +82 4259 +82 703 +83 2127 +83 5633 +83 5122 +83 2571 +83 7315 +83 9126 +83 4200 +83 2538 +83 7539 +83 6179 +83 4290 +83 5519 +83 9800 +83 1107 +83 1013 +83 5274 +83 3835 +83 4467 +83 3197 +83 510 +83 4949 +84 133 +84 9900 +84 2973 +84 7329 +84 7771 +84 8484 +84 5671 +84 9384 +84 938 +84 4652 +84 5421 +84 1454 +84 9649 +84 6617 +84 6362 +84 2139 +84 2789 +84 4966 +84 4839 +84 2922 +84 1521 +84 1526 +85 8453 +85 827 +85 8202 +85 779 +85 3309 +85 4377 +85 1950 +85 2599 +85 6059 +85 3377 +85 6330 +85 5051 +85 1343 +85 3532 +85 3410 +85 6494 +85 9827 +85 7250 +85 2418 +85 9078 +85 8060 +85 3198 +86 6755 +86 5860 +86 9032 +86 8998 +86 1064 +86 3241 +86 1035 +86 3564 +86 5200 +86 2728 +86 3188 +86 4126 +86 8727 +86 2884 +86 3481 +86 4094 +87 6944 +87 5427 +87 359 +87 4326 +87 6406 +87 3705 +87 460 +87 3179 +87 7831 +87 1325 +87 1870 +87 253 +87 5795 +87 8317 +87 4469 +87 7894 +87 9273 +87 2777 +87 7803 +87 6588 +87 4189 +88 449 +88 3714 +88 227 +88 6852 +88 1837 +88 1201 +88 9738 +88 7212 +88 9602 +88 6465 +88 3215 +88 6696 +88 4493 +88 1269 +88 3318 +88 3672 +88 9787 +88 6961 +88 1470 +89 3521 +89 7706 +89 8972 +89 5031 +89 2824 +89 4649 +89 794 +89 4012 +89 3278 +89 6000 +89 2856 +89 6510 +89 6070 +89 1545 +89 7674 +89 4383 +89 2972 +89 2973 +89 9626 +89 7615 +90 4640 +90 2241 +90 1541 +90 1950 +90 6922 +90 6302 +90 3997 +90 4753 +90 2066 +90 5662 +90 5242 +90 5885 +90 3806 +90 8543 +91 5546 +91 5730 +91 7147 +91 3781 +91 2056 +91 8426 +91 1131 +91 3148 +91 7074 +91 7112 +91 3163 +91 6331 +91 9240 +91 4121 +91 4283 +91 3485 +91 8670 +91 6997 +92 5728 +92 5168 +92 8674 +92 3940 +92 9157 +92 737 +92 3595 +92 2576 +92 8529 +92 4723 +92 9508 +92 8475 +92 7013 +93 1302 +93 3337 +93 5389 +93 8335 +93 275 +93 5033 +93 1331 +93 834 +93 7364 +93 5957 +93 7110 +93 5704 +93 5454 +93 4175 +93 7250 +93 5843 +93 7517 +93 7013 +93 6120 +93 7275 +93 1901 +93 4849 +93 5372 +93 1789 +94 3360 +94 4449 +94 2083 +94 1782 +94 4033 +94 8467 +94 1257 +94 5835 +94 3885 +94 6419 +94 7984 +94 9714 +94 9107 +94 1718 +94 4792 +94 8922 +94 2429 +94 7358 +94 1919 +95 388 +95 9782 +95 8326 +95 2193 +95 1864 +95 4074 +95 3435 +95 4556 +95 525 +95 814 +95 4976 +95 904 +95 1076 +95 8054 +95 2582 +95 894 +95 701 +95 4030 +96 7168 +96 2945 +96 9090 +96 6789 +96 6534 +96 1602 +96 172 +96 5550 +96 1458 +96 7347 +96 9399 +96 1854 +96 7359 +96 2370 +96 6597 +96 6727 +96 4174 +96 1765 +96 998 +96 1899 +96 9840 +96 5364 +96 2495 +97 4229 +97 5514 +97 8344 +97 8083 +97 473 +97 6808 +97 9635 +97 935 +97 4012 +97 7085 +97 7600 +97 1592 +97 827 +97 7946 +97 9793 +97 194 +97 6598 +97 3128 +97 6745 +97 2532 +97 8295 +97 876 +97 5358 +97 2287 +97 247 +98 4737 +98 5956 +98 9953 +98 9992 +98 9609 +98 3756 +98 6610 +98 3731 +98 9172 +98 7893 +98 723 +98 4580 +98 9107 +98 8924 +98 7839 +99 4129 +99 1515 +99 4710 +99 710 +99 1575 +99 6588 +99 8106 +99 2923 +99 1582 +99 7599 +99 9012 +99 9525 +99 2070 +99 4476 +99 7738 +99 8188 +99 7946 +100 5250 +100 5125 +100 3846 +100 2312 +100 9804 +100 2383 +100 9352 +100 6677 +100 8566 +100 1592 +100 8540 +100 9470 +100 8069 +101 8801 +101 2306 +101 9099 +101 2053 +101 8678 +101 2759 +101 1226 +101 9643 +101 1964 +101 7024 +101 6584 +101 9971 +101 3508 +101 2070 +101 8183 +101 792 +101 2481 +101 9055 +102 6409 +102 9313 +102 1958 +102 2503 +102 8028 +102 4905 +102 1002 +102 9977 +102 9628 +102 5587 +102 5039 +102 8177 +102 723 +102 7758 +102 5685 +102 4953 +102 8344 +102 6169 +102 3194 +102 732 +102 1759 +103 5313 +103 7330 +103 485 +103 6536 +103 169 +103 6668 +103 4076 +103 3709 +103 688 +103 5905 +103 7828 +103 9513 +103 4568 +103 6745 +103 4186 +103 413 +103 7166 +104 9376 +104 4400 +104 3523 +104 9893 +104 4263 +104 9608 +104 8139 +104 2386 +104 5485 +104 3406 +104 3248 +104 2440 +104 9970 +104 2179 +104 2005 +104 7546 +104 2606 +104 7517 +105 7296 +105 262 +105 5259 +105 4238 +105 1423 +105 3355 +105 2719 +105 6562 +105 2211 +105 4275 +105 1091 +105 9412 +105 9928 +105 1482 +105 7330 +105 8156 +105 5730 +105 6499 +105 3816 +105 2799 +105 2297 +105 3453 +106 1344 +106 9347 +106 881 +106 1970 +106 7255 +106 5933 +106 6393 +106 399 +106 1169 +106 4187 +106 7035 +106 5371 +106 6969 +106 8922 +106 987 +106 2202 +106 4638 +106 9727 +107 6720 +107 3451 +107 3844 +107 7347 +107 1228 +107 9001 +107 2538 +107 4043 +107 2476 +107 9947 +107 6483 +107 6196 +107 398 +107 6427 +107 445 +107 7902 +108 5804 +108 6922 +108 8844 +108 3342 +108 8345 +108 2845 +108 8606 +108 3367 +108 6828 +108 8238 +108 4146 +108 8117 +108 4667 +108 2116 +108 5707 +108 1243 +108 8540 +108 2491 +108 9829 +108 9969 +108 6002 +108 5887 +109 8321 +109 6715 +109 3035 +109 9222 +109 1287 +109 5118 +109 2203 +109 2206 +109 7473 +109 5876 +109 3509 +109 4695 +109 5176 +109 5435 +109 2686 +109 5183 +110 4256 +110 1793 +110 8418 +110 6747 +110 7425 +110 3354 +110 1095 +110 9930 +110 2124 +110 3746 +110 5294 +110 1760 +110 9849 +110 2712 +110 1913 +110 7802 +110 1311 +110 2986 +110 3071 +111 7300 +111 6918 +111 7191 +111 3089 +111 6674 +111 3603 +111 1558 +111 6679 +111 9882 +111 6940 +111 1311 +111 421 +111 3625 +111 4284 +111 4673 +111 7501 +111 5587 +111 1627 +111 1502 +111 1385 +111 2542 +111 9199 +111 2802 +112 1088 +112 8069 +112 2604 +112 3340 +112 7982 +112 4879 +112 2129 +112 7123 +112 952 +112 3929 +112 9339 +112 8573 +113 1031 +113 9493 +113 3991 +113 3098 +113 6556 +113 2974 +113 4421 +113 1264 +113 551 +113 5032 +113 6812 +113 7303 +113 6468 +113 9541 +113 3531 +113 463 +113 6737 +113 978 +113 5863 +113 4079 +113 5872 +113 8819 +113 4341 +113 5495 +113 893 +114 521 +114 7312 +114 6291 +114 9108 +114 2837 +114 1561 +114 2592 +114 5286 +114 4778 +114 6444 +114 2742 +114 9530 +114 2620 +114 8765 +114 9796 +114 7887 +114 4946 +114 4954 +114 6248 +114 3820 +114 237 +114 6259 +114 1269 +114 7294 +115 1536 +115 6148 +115 1290 +115 526 +115 3606 +115 8226 +115 5798 +115 5165 +115 1599 +115 3908 +115 7499 +115 7505 +115 469 +115 7385 +115 8411 +115 5597 +115 9952 +115 8291 +115 4068 +115 8933 +115 9466 +115 3451 +116 7683 +116 3544 +116 488 +116 9084 +116 9293 +116 3629 +116 8977 +116 7161 +116 5429 +116 2582 +116 1815 +116 9496 +116 6105 +116 5992 +116 4860 +116 2301 +116 5758 +117 128 +117 6179 +117 2500 +117 7270 +117 1265 +117 4104 +117 6935 +117 1133 +117 4269 +117 5777 +117 7827 +117 3092 +117 6807 +117 1816 +117 2936 +117 4218 +117 7932 +117 6973 +117 671 +118 128 +118 4115 +118 8869 +118 5916 +118 5257 +118 907 +118 8045 +118 4399 +118 7536 +118 4050 +118 6355 +118 1433 +118 4122 +118 6876 +118 2141 +119 8197 +119 6539 +119 5900 +119 9230 +119 9155 +119 5784 +119 5404 +119 1310 +119 3742 +119 3766 +119 7627 +119 3147 +119 6340 +119 3657 +119 5707 +119 2001 +119 5589 +119 7383 +119 9431 +119 3558 +119 5870 +119 8560 +119 4492 +120 1609 +120 1400 +120 7595 +120 358 +120 8503 +120 2888 +120 9339 +120 2092 +120 168 +120 2735 +120 8479 +120 4632 +120 2675 +120 5590 +120 1463 +120 1208 +120 2522 +120 5595 +120 5662 +120 671 +121 4544 +121 2879 +121 6855 +121 3145 +121 4652 +121 5100 +121 5998 +121 6161 +121 7314 +121 6929 +121 1524 +121 5975 +121 4152 +121 1050 +121 6267 +121 5628 +121 7197 +121 5087 +122 6400 +122 4227 +122 4105 +122 9868 +122 5265 +122 1043 +122 9750 +122 2330 +122 1821 +122 158 +122 4255 +122 9127 +122 8367 +122 5553 +122 6707 +122 9783 +122 5945 +122 9148 +122 9533 +122 7749 +122 275 +122 5454 +122 8914 +122 8280 +122 8926 +122 3942 +122 6502 +122 1511 +122 1515 +122 8173 +122 7667 +123 5794 +123 5861 +123 2728 +123 4362 +123 2347 +123 8482 +123 4142 +123 642 +123 7248 +123 977 +123 9971 +123 3381 +123 342 +123 8248 +123 9177 +123 3450 +123 6590 +124 1280 +124 7937 +124 3095 +124 2062 +124 6295 +124 2718 +124 6948 +124 4525 +124 8502 +124 8507 +124 5059 +124 9924 +124 6095 +124 376 +124 8024 +124 8409 +124 1245 +124 4321 +124 7012 +124 5095 +124 366 +124 5104 +124 2168 +124 8575 +125 7552 +125 7168 +125 1409 +125 3337 +125 9866 +125 4121 +125 8667 +125 9894 +125 167 +125 8488 +125 5035 +125 6572 +125 5302 +125 708 +125 7493 +125 9551 +125 5595 +125 221 +125 6627 +125 1769 +125 5226 +125 8175 +125 3192 +125 7547 +125 253 +126 5506 +126 3845 +126 2698 +126 528 +126 8081 +126 1816 +126 2844 +126 5288 +126 8242 +126 5559 +126 8509 +126 7870 +126 194 +126 3143 +126 1229 +126 1104 +126 5074 +126 8660 +126 3546 +126 2918 +126 744 +126 7148 +126 8432 +126 9960 +126 7164 +126 3326 +127 1537 +127 4673 +127 7824 +127 9876 +127 9110 +127 7205 +127 3622 +127 4159 +127 1473 +127 2374 +127 8775 +127 3554 +127 9171 +127 4565 +127 3158 +127 7909 +127 3298 +127 8675 +127 1765 +127 874 +127 4205 +127 9207 +127 2553 +127 3835 +127 8958 +128 4741 +128 7686 +128 8334 +128 5533 +128 3620 +128 3879 +128 8493 +128 6574 +128 9648 +128 2484 +128 4788 +128 4539 +128 5310 +128 4671 +128 9665 +128 195 +128 596 +128 6623 +128 8415 +128 6843 +128 7913 +128 2540 +128 9331 +128 4212 +128 1142 +128 4471 +128 1786 +128 8701 +129 7936 +129 385 +129 3682 +129 1220 +129 4517 +129 2988 +129 1322 +129 2060 +129 3970 +129 6415 +129 9520 +129 5650 +129 3571 +129 7859 +129 1161 +129 3897 +129 1967 +129 1244 +129 1021 +129 8350 +129 4549 +130 7616 +130 9505 +130 2571 +130 2118 +130 615 +130 1320 +130 6475 +130 3660 +130 5935 +130 4712 +130 6930 +130 2739 +130 2644 +130 5525 +130 803 +130 6424 +130 4916 +130 6235 +130 2248 +130 9332 +130 1438 +131 4993 +131 7141 +131 7665 +131 5800 +131 6693 +131 717 +131 2766 +131 655 +131 8400 +131 3409 +131 8274 +131 9110 +131 7374 +131 7446 +131 5815 +131 8760 +131 2971 +131 9649 +132 4353 +132 9067 +132 1221 +132 4913 +132 4200 +132 4630 +132 4167 +132 4620 +132 1870 +132 413 +132 1361 +132 404 +132 9909 +132 6710 +132 7095 +132 6109 +132 7934 +132 8389 +133 9730 +133 452 +133 5829 +133 6214 +133 6217 +133 4522 +133 2662 +133 3694 +133 5993 +133 8753 +133 8340 +133 567 +133 9119 +133 9854 +133 9285 +134 2912 +134 4720 +134 5379 +134 4741 +134 9478 +134 8615 +134 7049 +134 8823 +134 3692 +134 8173 +134 2574 +134 1949 +134 1584 +134 8017 +134 6162 +134 1203 +134 8055 +134 5147 +134 924 +134 3869 +134 3551 +135 5952 +135 6723 +135 9252 +135 1334 +135 8390 +135 9523 +135 3077 +135 5137 +135 1074 +135 5587 +135 1683 +135 1659 +135 5913 +135 5257 +135 4057 +135 1225 +135 2491 +135 1948 +135 1886 +135 8383 +136 5856 +136 3457 +136 7043 +136 1380 +136 4974 +136 518 +136 9543 +136 7313 +136 7532 +136 1290 +136 9356 +136 3253 +136 1776 +136 7377 +136 3122 +136 1013 +136 3574 +136 7140 +136 6491 +136 2430 +136 8149 +137 4993 +137 6658 +137 6789 +137 2604 +137 5901 +137 7573 +137 7575 +137 8095 +137 7968 +137 1698 +137 5797 +137 3110 +137 936 +137 300 +137 7474 +137 9021 +137 9678 +137 4438 +137 7519 +137 3568 +137 4346 +137 7038 +138 7172 +138 1286 +138 8976 +138 6931 +138 3354 +138 3229 +138 9388 +138 7475 +138 4406 +138 9159 +138 3145 +138 6860 +138 6097 +138 3925 +138 347 +138 6116 +138 8806 +138 5735 +138 9328 +138 1905 +138 5876 +138 7674 +138 1662 +139 1282 +139 5828 +139 7591 +139 6793 +139 9002 +139 6050 +139 1621 +139 6518 +139 823 +139 3940 +139 1924 +139 8188 +139 7197 +140 903 +140 7177 +140 6541 +140 5526 +140 4384 +140 4525 +140 1710 +140 8499 +140 8383 +140 2208 +140 8002 +140 5062 +140 9041 +140 8022 +140 9047 +140 990 +140 607 +140 5602 +140 2534 +140 4841 +140 5103 +140 370 +140 8437 +140 1913 +140 636 +141 5379 +141 5764 +141 1295 +141 5143 +141 5923 +141 7716 +141 298 +141 3005 +141 5953 +141 1603 +141 8519 +141 2504 +141 841 +141 7757 +141 8785 +141 9810 +141 6615 +141 1113 +141 5485 +141 7922 +141 2898 +141 1021 +142 8276 +142 9410 +142 5127 +142 5676 +142 7410 +142 8684 +142 1677 +142 4046 +142 9714 +142 5012 +142 821 +142 8214 +142 8377 +142 1113 +142 9052 +142 2751 +143 6594 +143 388 +143 6118 +143 9830 +143 6377 +143 8974 +143 4880 +143 5745 +143 5938 +143 8659 +143 2457 +143 4986 +143 5790 +144 2052 +144 7818 +144 755 +144 5272 +144 2339 +144 4780 +144 557 +144 3507 +144 4663 +144 7647 +144 2492 +144 1525 +144 2628 +144 1862 +144 4948 +144 8028 +144 5727 +144 8929 +144 9571 +144 5619 +144 5237 +144 5117 +145 3872 +145 5025 +145 3426 +145 1379 +145 740 +145 2629 +145 5655 +145 4642 +145 1745 +145 3715 +145 5589 +145 2592 +145 5559 +145 7705 +145 1306 +145 2719 +145 5820 +145 7936 +145 8981 +146 4032 +146 2146 +146 2147 +146 9700 +146 5125 +146 5961 +146 5019 +146 7587 +146 7026 +146 5523 +146 5859 +146 7738 +146 5279 +146 3805 +146 7359 +147 2816 +147 6495 +147 6765 +147 5638 +147 7590 +147 4839 +147 9079 +147 4269 +147 857 +147 1615 +147 7664 +147 8273 +147 8658 +147 9779 +147 6169 +147 8914 +147 5657 +147 5938 +147 5918 +147 6399 +148 4512 +148 8449 +148 5442 +148 9443 +148 8229 +148 8275 +148 3009 +148 1754 +148 6634 +148 2431 +148 6995 +148 5141 +148 1270 +148 9690 +148 5435 +148 3418 +148 637 +148 1509 +149 5984 +149 7969 +149 7043 +149 6177 +149 989 +149 5703 +149 5416 +149 7274 +149 3403 +149 300 +149 8957 +149 2097 +149 6365 +149 8131 +149 4724 +149 2965 +149 1752 +149 3583 +149 4391 +149 6122 +149 9215 +150 5088 +150 7655 +150 3690 +150 9356 +150 7280 +150 466 +150 1274 +150 6747 +150 1981 +151 739 +151 9476 +151 4005 +151 4999 +151 5353 +151 3460 +151 5003 +151 1869 +151 7767 +151 7984 +151 5809 +151 6994 +151 6835 +151 4967 +151 8342 +151 7641 +151 9874 +151 6948 +151 1466 +151 4922 +152 5124 +152 1159 +152 9100 +152 3748 +152 4006 +152 433 +152 9388 +152 8241 +152 6578 +152 5558 +152 6217 +152 1985 +152 1732 +152 1735 +152 2633 +152 4555 +152 1993 +152 2390 +152 5212 +152 6498 +152 9981 +152 2086 +152 4477 +152 9336 +152 3709 +153 4739 +153 5128 +153 2828 +153 3095 +153 2843 +153 5791 +153 6432 +153 5944 +153 2617 +153 1723 +153 6079 +153 4676 +153 9926 +153 6346 +153 1355 +153 1236 +153 5974 +153 471 +153 8799 +153 4707 +153 1131 +153 9965 +153 3709 +153 9727 +154 5772 +154 9229 +154 6301 +154 9648 +154 9379 +154 2086 +154 2224 +154 5685 +154 5698 +154 6469 +154 6087 +154 456 +154 9930 +154 721 +154 8022 +154 7002 +154 7005 +154 3685 +154 5476 +154 5798 +154 7655 +154 6379 +154 9587 +154 6773 +154 5503 +155 8641 +155 2402 +155 580 +155 5654 +155 3110 +155 1543 +155 2859 +155 5798 +155 1235 +155 3444 +155 5925 +155 3286 +155 6487 +155 2680 +155 4025 +155 7130 +155 9663 +155 4054 +155 1825 +155 926 +155 383 +156 5376 +156 960 +156 8837 +156 5222 +156 7073 +156 905 +156 9514 +156 5579 +156 4332 +156 2774 +156 5458 +156 3572 +156 2773 +156 8054 +156 3543 +156 1754 +156 5339 +156 7818 +157 8416 +157 2273 +157 9091 +157 6212 +157 6321 +157 1479 +157 7055 +157 5513 +157 2285 +157 7918 +157 3791 +157 8177 +157 9460 +157 5429 +157 3350 +157 9751 +157 9839 +157 4060 +157 4701 +157 4597 +158 8195 +158 5025 +158 8354 +158 4707 +158 3078 +158 8425 +158 6506 +158 6925 +158 2190 +158 816 +158 4721 +158 4211 +158 9460 +158 6582 +158 7671 +158 9076 +158 2363 +158 9855 +159 7173 +159 5127 +159 8846 +159 1562 +159 8859 +159 6789 +159 9766 +159 7467 +159 5688 +159 954 +159 4191 +159 8764 +159 2498 +159 1478 +159 1745 +159 4180 +159 5208 +159 348 +159 7391 +159 1507 +159 6757 +159 8967 +159 8821 +159 9854 +160 9282 +160 4762 +160 7269 +160 4614 +160 2746 +160 4967 +160 3184 +160 6450 +160 9555 +160 5430 +160 184 +160 7865 +160 2618 +160 7485 +160 6590 +160 5087 +161 1922 +161 3171 +161 1797 +161 9735 +161 8873 +161 2698 +161 5357 +161 9453 +161 4848 +161 721 +161 9539 +161 2424 +161 3387 +162 6553 +162 5014 +162 934 +162 1485 +162 7951 +162 1669 +162 7506 +162 6227 +162 4148 +162 1878 +162 3865 +162 5369 +162 1565 +162 4214 +162 3230 +162 4613 +163 8161 +163 7204 +163 2628 +163 9184 +163 7943 +163 6409 +163 3402 +163 653 +163 9711 +163 9812 +163 9078 +163 7478 +163 8503 +163 3156 +163 6876 +163 2698 +163 1044 +163 7871 +164 4481 +164 1537 +164 267 +164 5144 +164 9501 +164 4007 +164 4653 +164 9393 +164 4150 +164 4919 +164 8120 +164 4669 +164 1474 +164 7734 +164 6475 +164 9688 +164 345 +164 9306 +164 7779 +164 2276 +164 7798 +164 6010 +164 8957 +165 2304 +165 4672 +165 8580 +165 4677 +165 4774 +165 4202 +165 4651 +165 884 +165 2869 +165 9942 +165 2309 +165 2329 +165 4443 +165 8828 +165 5759 +166 8033 +166 1923 +166 7044 +166 6758 +166 8872 +166 2378 +166 269 +166 7310 +166 5741 +166 9648 +166 3373 +166 8214 +166 6288 +166 5828 +166 2394 +166 926 +167 4867 +167 4488 +167 5257 +167 6670 +167 5265 +167 2840 +167 6809 +167 1563 +167 8349 +167 6942 +167 4899 +167 6440 +167 3116 +167 6069 +167 1339 +167 3517 +167 6848 +167 4166 +167 5703 +167 4425 +167 9805 +167 5006 +167 9559 +167 4440 +167 9945 +167 4830 +167 9185 +167 7784 +167 7793 +167 3321 +168 1287 +168 4641 +168 7042 +168 5475 +168 3559 +168 6322 +168 4712 +168 8297 +168 4427 +168 2637 +168 7601 +168 1266 +168 5523 +168 3764 +168 6997 +168 6178 +168 2296 +168 571 +168 5788 +169 4352 +169 4097 +169 2571 +169 8337 +169 1689 +169 6042 +169 8607 +169 5923 +169 3622 +169 8999 +169 1326 +169 5940 +169 5944 +169 3259 +169 2370 +169 3780 +169 7638 +169 2394 +169 5356 +169 9453 +169 242 +169 1012 +169 8574 +170 1537 +170 258 +170 1795 +170 1794 +170 4757 +170 9327 +170 8476 +170 7841 +170 9372 +170 6580 +170 440 +170 4805 +170 7777 +170 4557 +170 3833 +170 9185 +170 6119 +170 5609 +170 2926 +170 6383 +170 2162 +170 6649 +171 5440 +171 4097 +171 1730 +171 2731 +171 5188 +171 5283 +171 4466 +171 9661 +171 5993 +171 4938 +171 8619 +171 1389 +171 1735 +171 2077 +171 9938 +171 6675 +171 7338 +171 7001 +171 8027 +171 4019 +171 5318 +172 4256 +172 7090 +172 3312 +172 5767 +172 2411 +172 6285 +172 1294 +172 3599 +172 4880 +172 1105 +172 7538 +172 5523 +172 1262 +172 2230 +172 4952 +172 7002 +172 8891 +172 9308 +172 7679 +173 9606 +173 8080 +173 7185 +173 9746 +173 5662 +173 4129 +173 8360 +173 2604 +173 9134 +173 3763 +173 951 +173 8763 +173 9404 +173 3787 +173 3922 +173 4179 +173 8032 +173 8976 +173 4966 +173 4498 +173 5742 +173 3064 +173 1789 +174 417 +174 1315 +174 8261 +174 5953 +174 1364 +174 7433 +174 8556 +174 9649 +174 1900 +174 8401 +174 8498 +174 2292 +174 8021 +174 310 +174 8489 +174 4532 +174 1242 +174 7100 +174 6814 +174 6757 +175 9094 +175 8332 +175 6801 +175 5654 +175 2201 +175 9118 +175 9249 +175 8105 +175 684 +175 2353 +175 7218 +175 9907 +175 3125 +175 1975 +175 9144 +175 4923 +175 8653 +175 6351 +175 1360 +175 7769 +175 8923 +175 1121 +175 4450 +175 8295 +175 8941 +175 1525 +175 1016 +175 9724 +175 3454 +176 6721 +176 6747 +176 9475 +176 9892 +176 1861 +176 7025 +176 6952 +176 9523 +176 3287 +176 6384 +176 881 +176 9394 +176 8243 +176 5655 +176 3770 +176 2747 +176 3517 +176 5886 +177 5856 +177 2049 +177 875 +177 9957 +177 5399 +177 4333 +177 782 +177 2159 +177 6608 +177 2416 +177 7379 +177 7323 +177 2453 +177 8119 +177 6715 +177 5693 +178 5915 +178 996 +178 3461 +178 7558 +178 1393 +178 8968 +178 6119 +178 4270 +178 6461 +178 4688 +178 6696 +178 8249 +178 1494 +178 1335 +178 3576 +178 5721 +178 3706 +178 6875 +178 9852 +178 8957 +179 9104 +179 6301 +179 2336 +179 3105 +179 3490 +179 9129 +179 5546 +179 7215 +179 3890 +179 1205 +179 5819 +179 9405 +179 579 +179 7620 +179 6219 +179 3405 +179 1103 +179 5840 +179 4435 +179 4186 +179 9830 +179 5097 +179 8304 +179 9972 +179 9845 +179 9577 +179 9593 +179 7932 +179 3581 +180 1280 +180 3937 +180 6530 +180 2070 +180 2854 +180 8146 +180 782 +180 5804 +180 3794 +180 8366 +180 8143 +180 2424 +180 1842 +180 4307 +180 2485 +180 2486 +180 1112 +180 9710 +181 6915 +181 5636 +181 7054 +181 273 +181 6806 +181 3223 +181 495 +181 1825 +181 5410 +181 1179 +181 2604 +181 5297 +181 692 +181 5432 +181 9404 +181 9925 +181 6606 +181 2769 +181 2899 +181 3156 +181 8150 +181 3930 +181 4955 +181 6113 +181 9327 +181 4848 +181 4337 +181 9976 +181 6395 +181 4348 +182 4481 +182 7697 +182 3183 +182 1566 +182 5284 +182 6581 +182 9785 +182 9534 +182 5301 +182 6848 +182 1225 +182 5962 +182 2382 +182 5086 +182 8927 +182 8672 +182 3306 +182 491 +182 9711 +182 5622 +182 4087 +182 1343 +182 508 +183 6410 +183 2708 +183 3479 +183 8860 +183 7709 +183 3234 +183 931 +183 6825 +183 3886 +183 6704 +183 6327 +183 4546 +183 1605 +183 1734 +183 3152 +183 7138 +183 2149 +183 1385 +183 5998 +183 2293 +183 248 +184 9408 +184 4869 +184 902 +184 8327 +184 5273 +184 3101 +184 4284 +184 8896 +184 3522 +184 8134 +184 7367 +184 1481 +184 7756 +184 2126 +184 2386 +184 725 +184 5602 +184 7651 +184 9061 +184 749 +184 1778 +184 3454 +185 6562 +185 9987 +185 7750 +185 3206 +185 9118 +185 2697 +185 3865 +185 3853 +185 9747 +185 7381 +185 9750 +185 6743 +185 9017 +185 6246 +185 4275 +185 5983 +186 699 +186 4646 +186 6535 +186 3624 +186 4649 +186 7690 +186 6263 +186 5420 +186 1934 +186 7727 +186 9232 +186 9320 +186 9171 +186 2713 +186 2777 +186 2875 +186 350 +186 9951 +187 1153 +187 5283 +187 5156 +187 1093 +187 2950 +187 324 +187 2730 +187 2507 +187 6796 +187 6765 +187 1491 +187 6099 +187 6775 +187 3140 +187 5786 +187 8895 +187 8778 +187 2751 +188 4128 +188 6048 +188 9571 +188 4016 +188 8103 +188 4520 +188 4394 +188 6429 +188 6764 +188 2799 +188 6768 +188 1267 +188 1556 +188 4984 +188 2811 +188 9757 +189 832 +189 3936 +189 5927 +189 3196 +189 7694 +189 5473 +189 8051 +189 8980 +189 7541 +189 758 +189 4252 +189 3326 +190 3713 +190 3555 +190 2593 +190 4456 +190 7658 +190 9805 +190 1614 +190 6767 +190 6543 +190 5518 +190 4729 +190 1274 +190 6031 +190 5514 +190 8158 +191 5331 +191 5353 +191 6349 +191 2677 +191 5715 +191 5300 +191 6613 +191 6997 +191 3223 +191 9977 +191 3157 +191 9823 +191 3987 +191 1022 +191 5791 +192 6031 +192 6296 +192 8603 +192 8737 +192 930 +192 4806 +192 7342 +192 8368 +192 3122 +192 4275 +192 3140 +192 966 +192 1231 +192 7890 +192 6628 +192 8679 +192 5352 +192 2162 +192 2932 +192 1397 +192 8061 +192 3070 +193 8065 +193 5954 +193 5349 +193 1382 +193 942 +193 1166 +193 5354 +193 9067 +193 6254 +193 5230 +193 8401 +193 754 +193 1537 +193 5806 +193 5162 +193 6430 +193 2341 +194 7557 +194 5384 +194 3852 +194 4496 +194 5650 +194 8856 +194 5542 +194 9384 +194 4291 +194 2116 +194 6390 +194 2635 +194 6866 +194 3668 +194 9313 +194 9836 +194 2934 +194 1407 +194 4732 +194 9983 +195 6656 +195 2948 +195 4229 +195 6498 +195 6541 +195 4376 +195 9496 +195 1398 +195 1053 +195 290 +195 1318 +195 5543 +195 5161 +195 9649 +195 3892 +195 573 +195 7999 +195 9157 +195 2632 +195 6754 +195 6366 +195 4066 +195 1393 +195 2034 +195 2294 +196 4417 +196 7427 +196 3428 +196 4598 +196 1606 +196 265 +196 8395 +196 1804 +196 3101 +196 5428 +196 8054 +196 7032 +196 1977 +196 1039 +196 8956 +196 1053 +196 2565 +197 2820 +197 3205 +197 5959 +197 907 +197 1324 +197 7565 +197 3409 +197 7869 +197 3153 +197 7058 +197 9267 +197 789 +197 5399 +197 5924 +197 3901 +197 1637 +198 4773 +198 1001 +198 5005 +198 7965 +198 2066 +198 9270 +198 7034 +198 4154 +199 9282 +199 9667 +199 9255 +199 7372 +199 5613 +199 6640 +199 6514 +199 9428 +199 4316 +199 1821 +200 6468 +200 3589 +200 618 +200 2668 +200 3406 +200 2223 +200 8504 +200 6130 +200 2324 +200 9848 +200 3268 +200 6943 +200 7229 +200 6143 +201 6144 +201 1600 +201 8453 +201 4490 +201 2959 +201 579 +201 1817 +201 930 +201 2984 +201 426 +201 9517 +201 1268 +201 5820 +201 9792 +201 2370 +201 9027 +201 7120 +201 3678 +201 1377 +201 5606 +201 4588 +201 623 +201 6004 +202 9569 +202 9955 +202 5828 +202 7333 +202 3561 +202 5997 +202 9373 +202 9170 +202 4963 +202 2489 +202 8057 +202 1225 +202 1149 +202 7230 +203 4322 +203 9987 +203 5415 +203 8521 +203 7530 +203 7730 +203 8046 +203 8528 +203 7633 +203 6258 +203 3512 +203 8063 +203 4184 +203 6239 +203 8858 +203 5375 +203 5311 +204 1025 +204 1282 +204 9433 +204 5649 +204 1175 +204 9880 +204 5913 +204 282 +204 3099 +204 9139 +204 9892 +204 2867 +204 2747 +204 4068 +204 6469 +204 3784 +204 8905 +204 1227 +204 1101 +204 4563 +204 9124 +204 2144 +204 2148 +204 872 +204 506 +204 380 +204 8062 +205 3456 +205 1413 +205 615 +205 9514 +205 3863 +205 4613 +205 4274 +205 4944 +205 2449 +205 5910 +205 741 +205 1780 +205 4214 +205 7127 +205 9594 +205 2366 +205 767 +206 1032 +206 2954 +206 4240 +206 2199 +206 2330 +206 5532 +206 9390 +206 8712 +206 3129 +206 5182 +206 1088 +206 207 +206 2256 +206 9305 +206 8155 +206 7785 +206 1386 +206 4717 +206 8821 +206 2422 +206 4727 +206 3454 +207 6571 +207 8689 +207 7912 +207 7050 +207 8107 +207 6700 +207 2317 +207 7304 +207 3060 +207 9333 +207 5272 +207 7612 +207 9374 +208 2359 +208 6594 +208 4005 +208 9639 +208 6793 +208 4983 +208 4524 +208 4143 +208 3928 +208 369 +208 9682 +208 1108 +208 7657 +208 8376 +208 244 +208 2895 +208 990 +208 1957 +209 7825 +209 5474 +209 1641 +209 3590 +209 1799 +209 6185 +209 8650 +209 6219 +209 8290 +209 2191 +209 1713 +209 8882 +209 1526 +209 2889 +209 4119 +209 8153 +209 2666 +209 1785 +209 2047 +210 522 +210 9228 +210 6541 +210 2959 +210 8726 +210 6551 +210 4637 +210 2463 +210 1830 +210 697 +210 2108 +210 4803 +210 4938 +210 1102 +210 2512 +210 3667 +210 7011 +210 7525 +210 999 +210 6716 +210 4345 +210 2427 +210 7804 +210 1406 +211 2592 +211 9537 +211 291 +211 8934 +211 1119 +211 8174 +211 8285 +211 6301 +211 4241 +211 6595 +211 1230 +211 3286 +211 9881 +211 8986 +211 9179 +211 8860 +211 2813 +211 9823 +212 5664 +212 7012 +212 5065 +212 9879 +212 8813 +212 7790 +212 1327 +212 1116 +212 7445 +212 4183 +212 7867 +212 6734 +212 5807 +213 8199 +213 9099 +213 9360 +213 3220 +213 5149 +213 3744 +213 8361 +213 4269 +213 6962 +213 4532 +213 5561 +213 8898 +213 5326 +213 9554 +213 1875 +213 8153 +213 7776 +213 272 +213 4716 +213 9078 +213 8055 +213 2936 +214 5632 +214 8033 +214 9030 +214 2822 +214 1185 +214 6537 +214 1970 +214 7854 +214 5853 +214 2353 +214 8754 +214 9595 +214 828 +214 8797 +215 5083 +215 2182 +215 711 +215 6088 +215 3948 +215 7637 +215 5196 +215 1742 +215 4408 +215 5726 +215 5750 +215 1112 +215 4731 +215 1214 +215 4469 +216 3971 +216 3973 +216 8842 +216 397 +216 8594 +216 3603 +216 8477 +216 4511 +216 929 +216 1196 +216 4014 +216 9395 +216 1339 +216 9354 +216 7762 +216 1757 +216 9057 +216 4461 +216 8942 +216 8059 +216 6654 +216 1151 +217 3885 +217 5264 +217 7314 +217 9371 +217 8223 +217 4266 +217 813 +217 9902 +217 4143 +217 7345 +217 4677 +217 9031 +217 4440 +217 3545 +217 5722 +217 1119 +217 7648 +217 7012 +217 2282 +217 8814 +217 3439 +217 7666 +217 6011 +217 7422 +218 1200 +218 3394 +218 6630 +218 2409 +218 7756 +218 8461 +218 3984 +218 4113 +218 2137 +218 6329 +218 6360 +218 1529 +218 3997 +218 9080 +219 3083 +219 1678 +219 4509 +219 928 +219 5287 +219 8232 +219 6953 +219 2602 +219 7132 +219 432 +219 4659 +219 3007 +219 2510 +219 3798 +219 3417 +219 1884 +219 4063 +219 8682 +219 5867 +219 8812 +219 4976 +219 8691 +219 1790 +219 2168 +219 891 +219 2302 +220 3649 +220 9094 +220 4392 +220 7499 +220 5900 +220 6669 +220 6253 +220 1553 +220 9970 +220 2068 +220 754 +220 4506 +220 6427 +221 4610 +221 784 +221 1556 +221 7198 +221 6819 +221 3369 +221 9514 +221 3762 +221 6318 +221 9521 +221 9010 +221 9758 +221 5176 +221 5690 +221 2887 +221 8657 +221 1366 +221 3673 +221 8681 +221 9459 +221 8696 +222 3040 +222 6017 +222 610 +222 3971 +222 9829 +222 577 +222 8617 +222 6059 +222 3301 +222 2078 +222 4088 +222 5081 +222 2119 +222 2907 +222 5853 +222 3518 +222 5119 +223 7395 +223 4230 +223 1319 +223 1324 +223 9518 +223 1904 +223 6646 +223 5144 +223 7770 +223 733 +224 6661 +224 9253 +224 9127 +224 9160 +224 7401 +224 5386 +224 1035 +224 2092 +224 1741 +224 813 +224 721 +224 1105 +224 5650 +224 9193 +224 6164 +224 1782 +224 7094 +224 9029 +224 3931 +224 3134 +224 5727 +225 3456 +225 5025 +225 923 +225 9797 +225 7793 +225 7273 +225 9674 +225 1932 +225 3757 +225 8110 +225 6928 +225 785 +225 4210 +225 2593 +225 822 +225 7609 +225 5338 +225 2651 +225 5756 +225 5628 +226 6113 +226 5701 +226 4321 +226 3368 +226 5596 +226 7306 +226 7685 +226 3342 +226 6031 +226 3762 +226 3260 +226 5623 +226 5944 +226 5343 +226 2332 +226 7805 +226 9695 +227 7428 +227 9101 +227 7055 +227 8081 +227 1173 +227 6678 +227 6167 +227 9886 +227 5688 +227 828 +227 9789 +227 7493 +227 4934 +227 8652 +227 1876 +227 6485 +227 4456 +227 8252 +227 6378 +227 2029 +227 4979 +227 8821 +227 377 +228 7811 +228 4845 +228 1136 +228 8868 +228 1573 +228 4012 +228 946 +228 8761 +228 2112 +228 7240 +228 713 +228 975 +228 1363 +228 1753 +228 6112 +228 2405 +228 4456 +228 8173 +228 1007 +228 7408 +228 888 +228 9341 +229 1858 +229 1642 +229 615 +229 4124 +229 842 +229 4999 +229 6412 +229 1459 +229 8974 +229 4925 +229 8688 +229 5235 +229 628 +229 2582 +229 5719 +229 9748 +229 8359 +229 475 +229 2378 +229 3805 +229 1477 +230 4580 +230 3788 +230 5959 +230 8168 +230 1609 +230 9738 +230 7276 +230 1838 +230 656 +230 1073 +230 9522 +230 9043 +230 5459 +230 887 +230 9304 +230 1044 +230 1373 +230 4441 +231 3456 +231 8579 +231 3926 +231 6664 +231 3727 +231 4881 +231 2579 +231 9112 +231 2333 +231 3998 +231 2975 +231 9248 +231 2854 +231 556 +231 6451 +231 3132 +231 8266 +231 5195 +231 8012 +231 2510 +231 2004 +231 3286 +231 2274 +231 1637 +231 5237 +231 6783 +231 6782 +231 6911 +232 3969 +232 3971 +232 6533 +232 6151 +232 266 +232 1293 +232 5138 +232 5660 +232 2333 +232 7714 +232 7589 +232 7213 +232 2606 +232 6969 +232 5563 +232 7930 +232 2394 +232 3421 +232 5243 +232 2663 +232 5482 +232 6254 +232 8826 +232 3451 +232 7530 +233 7940 +233 9997 +233 4882 +233 4249 +233 5149 +233 9120 +233 6051 +233 9643 +233 9264 +233 8497 +233 5557 +233 5818 +233 955 +233 4924 +233 5201 +233 6482 +233 6099 +233 1369 +233 1375 +233 1656 +233 6522 +233 9979 +234 6400 +234 8673 +234 6944 +234 656 +234 8388 +234 8229 +234 5222 +234 2664 +234 6461 +234 5360 +234 7557 +234 9078 +234 8629 +234 2774 +234 3417 +234 2820 +234 7386 +234 7807 +234 5629 +234 7199 +235 6304 +235 6596 +235 7268 +235 6919 +235 3112 +235 9738 +235 2156 +235 3250 +235 4302 +235 5455 +235 657 +235 1170 +235 4818 +235 1369 +235 8655 +235 9322 +235 2110 +236 4320 +236 544 +236 5986 +236 5483 +236 4105 +236 2091 +236 9504 +236 625 +236 6579 +236 7124 +236 6646 +236 4504 +236 8148 +236 2972 +237 768 +237 8578 +237 7270 +237 8231 +237 4104 +237 2377 +237 4234 +237 9063 +237 9498 +237 1330 +237 4942 +237 7953 +237 3304 +237 265 +237 1276 +237 1530 +237 7560 +237 1916 +237 7674 +237 1671 +238 2818 +238 3204 +238 266 +238 5920 +238 4258 +238 5925 +238 9001 +238 2349 +238 8883 +238 6842 +238 4028 +238 2752 +238 4805 +238 4554 +238 5963 +238 1748 +238 3799 +238 2520 +238 3289 +238 2531 +238 6501 +238 8039 +238 1149 +239 1750 +239 7945 +239 4875 +239 1944 +239 3866 +239 2723 +239 1956 +239 7077 +239 4016 +239 6067 +239 439 +239 3132 +239 9123 +239 331 +239 5072 +239 721 +239 7587 +239 7765 +239 8406 +239 7588 +239 2400 +239 4964 +239 363 +239 6258 +239 6907 +240 3845 +240 9481 +240 8087 +240 5516 +240 7700 +240 4887 +240 4649 +240 9774 +240 4655 +240 5301 +240 3067 +240 5456 +240 7888 +240 6243 +240 358 +240 1643 +240 6892 +240 4205 +240 1137 +240 9973 +240 3960 +240 5908 +240 3451 +241 3969 +241 3905 +241 1417 +241 9744 +241 9363 +241 2325 +241 6679 +241 7047 +241 6963 +241 5940 +241 2367 +241 4673 +241 9158 +241 5209 +241 987 +241 2656 +241 8296 +241 8169 +241 8811 +241 6380 +241 5872 +241 1896 +241 2424 +241 6267 +241 5629 +241 1790 +242 9344 +242 4961 +242 6693 +242 3366 +242 1800 +242 2538 +242 9867 +242 2572 +242 3846 +242 5049 +242 346 +242 380 +243 1056 +243 5185 +243 2372 +243 4908 +243 7657 +243 6954 +243 6407 +243 3884 +243 8686 +243 9168 +243 7454 +243 940 +243 8792 +243 1241 +243 7866 +243 6813 +243 3838 +243 7263 +244 3424 +244 5730 +244 7747 +244 8196 +244 8199 +244 5794 +244 2415 +244 5392 +244 7075 +244 1495 +244 6264 +244 3514 +244 4155 +244 1213 +245 672 +245 5409 +245 1988 +245 3461 +245 8468 +245 8289 +245 3560 +245 2666 +245 1589 +245 590 +245 498 +245 7219 +245 2420 +245 1941 +245 3095 +245 9080 +245 697 +245 570 +245 7679 +246 7776 +246 7392 +246 1499 +246 3974 +246 5704 +246 9354 +246 2187 +246 3376 +246 8625 +246 7186 +246 8307 +246 4734 +246 2362 +246 2075 +246 2204 +246 4542 +247 4145 +247 2536 +247 6049 +247 1232 +247 4751 +247 4240 +247 3409 +247 2384 +247 7060 +247 5333 +247 5496 +247 4985 +247 5820 +248 9217 +248 6724 +248 9297 +248 7751 +248 5096 +248 3657 +248 4362 +248 9906 +248 4205 +248 5777 +248 9362 +248 9204 +248 5368 +248 7898 +248 5563 +248 9929 +248 7902 +248 6591 +249 3776 +249 9668 +249 1061 +249 7200 +249 6249 +249 4141 +249 3085 +249 6456 +249 4948 +249 7924 +249 4909 +249 3320 +249 3865 +249 1692 +249 925 +249 6398 +249 5055 +250 899 +250 2187 +250 793 +250 5647 +250 6295 +250 409 +250 6555 +250 1185 +250 9379 +250 4267 +250 2504 +250 8891 +250 4671 +250 8737 +250 4552 +250 1484 +250 1486 +250 6993 +250 1764 +250 7449 +250 1888 +250 7140 +250 6374 +250 6630 +250 7021 +251 2214 +251 1257 +251 3851 +251 7854 +251 6301 +251 8912 +251 8948 +251 7950 +251 4536 +251 3546 +251 7101 +251 3295 +252 4257 +252 7875 +252 5188 +252 5894 +252 6951 +252 3784 +252 2633 +252 7919 +252 1712 +252 9649 +252 3016 +252 1013 +252 4177 +252 9561 +253 7219 +253 9858 +253 5804 +253 4299 +253 9580 +253 877 +253 5816 +253 9075 +253 7160 +253 6329 +253 5114 +253 3646 +253 8255 +254 5152 +254 5760 +254 4290 +254 4931 +254 8468 +254 1735 +254 9546 +254 6970 +254 7341 +254 8302 +254 8925 +254 7585 +254 1874 +254 7732 +254 2710 +254 9112 +254 4850 +254 3322 +254 271 +254 8157 +254 1887 +255 1926 +255 8458 +255 5643 +255 4237 +255 3728 +255 3474 +255 4377 +255 1056 +255 7970 +255 8283 +255 3236 +255 5875 +255 9401 +255 2490 +255 3907 +255 8903 +255 9033 +255 3284 +255 7382 +255 3931 +255 4316 +255 9960 +255 8562 +255 883 +255 8702 +255 4471 +255 7800 +255 8188 +255 9214 +256 8577 +256 1795 +256 8587 +256 1293 +256 1682 +256 8467 +256 3226 +256 1950 +256 3824 +256 2338 +256 1063 +256 5545 +256 1579 +256 9391 +256 8378 +256 2759 +256 9160 +256 6223 +256 6617 +256 1114 +256 4848 +256 6931 +257 2155 +257 645 +257 1159 +257 3212 +257 1680 +257 9107 +257 1557 +257 7062 +257 3488 +257 1703 +257 8744 +257 2097 +257 9459 +257 3636 +257 4281 +257 6205 +257 9150 +257 1991 +257 3596 +257 9930 +257 6350 +257 8656 +257 1748 +257 7652 +257 8126 +257 7279 +257 8560 +257 7155 +257 1269 +257 2426 +257 4479 +258 3914 +258 1793 +258 5659 +258 4600 +258 6667 +258 5996 +258 7918 +258 5391 +258 8465 +258 8371 +258 1341 +258 5656 +258 8554 +258 7547 +258 3549 +259 1200 +259 6402 +259 7363 +259 2532 +259 2661 +259 583 +259 7881 +259 8401 +259 1964 +259 8802 +259 528 +259 7544 +259 5107 +259 7828 +259 9048 +259 4859 +259 5533 +259 9758 +260 7040 +260 4486 +260 3340 +260 5266 +260 9877 +260 3350 +260 6816 +260 8966 +260 8742 +260 4263 +260 5551 +260 9649 +260 3130 +260 8992 +260 1602 +260 6344 +260 9167 +260 8660 +260 1243 +260 6498 +260 1127 +260 9834 +260 8046 +260 3954 +260 9336 +260 1017 +261 1857 +261 1154 +261 3907 +261 3238 +261 2537 +261 5386 +261 8595 +261 4877 +261 3856 +261 4163 +261 8308 +261 8246 +261 1783 +261 9688 +261 8157 +262 5504 +262 8576 +262 916 +262 8214 +262 3095 +262 3354 +262 5412 +262 2984 +262 4667 +262 7356 +262 1858 +262 2756 +262 1221 +262 7371 +262 844 +262 4430 +262 9303 +262 5213 +262 6758 +262 5734 +262 3692 +262 8179 +262 8438 +262 8952 +262 1017 +262 1018 +262 4862 +263 7744 +263 6634 +263 4228 +263 8231 +263 7433 +263 8746 +263 7883 +263 3213 +263 9038 +263 2415 +263 2129 +263 8052 +263 7854 +263 3095 +263 5944 +263 6685 +264 6977 +264 2629 +264 550 +264 8360 +264 1084 +264 1661 +264 8753 +264 306 +264 4435 +264 2102 +264 2266 +264 6587 +264 5244 +264 5786 +264 1989 +265 6913 +265 4386 +265 2265 +265 8775 +265 9001 +265 6346 +265 951 +265 7827 +265 6676 +265 2926 +265 4449 +265 9203 +265 9812 +265 820 +265 4068 +265 2714 +265 5498 +265 3124 +266 8834 +266 2185 +266 7054 +266 7574 +266 2583 +266 2713 +266 1184 +266 6049 +266 8485 +266 4781 +266 7091 +266 5684 +266 7095 +266 9012 +266 454 +266 972 +266 1250 +266 6713 +266 9952 +266 4449 +266 5090 +266 8804 +266 2535 +266 6896 +266 5750 +266 7163 +267 7232 +267 5216 +267 3811 +267 453 +267 8455 +267 6152 +267 9436 +267 5579 +267 4856 +267 8370 +267 3731 +267 8769 +267 6840 +267 6244 +267 6495 +267 7644 +267 3240 +267 3327 +268 9664 +268 3872 +268 7491 +268 3653 +268 326 +268 3038 +268 7292 +268 621 +268 6255 +268 8049 +268 3990 +268 628 +268 8830 +268 2454 +268 3657 +268 9048 +268 2297 +268 1530 +268 764 +268 4734 +268 5374 +269 7654 +269 839 +269 7240 +269 7338 +269 2502 +269 4140 +269 367 +269 2408 +269 2324 +269 4981 +269 5752 +269 1850 +269 479 +269 4029 +269 9477 +270 9699 +270 1028 +270 4086 +270 4198 +270 2599 +270 7944 +270 1865 +270 6668 +270 882 +270 7663 +270 4627 +270 9714 +270 1971 +270 8851 +270 4053 +270 7190 +270 5274 +270 6463 +270 4895 +271 8832 +271 4342 +271 4037 +271 4551 +271 9279 +271 330 +271 8524 +271 5645 +271 6062 +271 5072 +271 4946 +271 8084 +271 8661 +271 5334 +271 1400 +271 3935 +271 517 +271 2014 +271 9765 +272 4736 +272 1154 +272 4099 +272 644 +272 4238 +272 536 +272 6107 +272 7984 +272 9532 +272 2623 +272 6337 +272 9160 +272 1609 +272 5066 +272 4571 +272 4320 +272 8801 +272 2280 +272 6896 +272 5369 +272 4218 +272 7765 +273 1024 +273 1953 +273 9606 +273 1544 +273 9930 +273 8363 +273 3948 +273 5101 +273 8079 +273 8369 +273 3381 +273 5430 +273 956 +273 2047 +274 9120 +274 2209 +274 1122 +274 998 +274 1511 +274 9291 +274 3372 +274 4978 +274 1742 +274 5711 +274 4784 +274 4593 +274 3762 +274 989 +274 6398 +275 2848 +275 8001 +275 1691 +275 4165 +275 8806 +275 7073 +275 9032 +275 9196 +275 2316 +275 1196 +275 9366 +275 5833 +275 633 +275 5247 +275 7542 +275 1658 +275 1535 +276 3051 +276 8039 +276 2470 +276 7037 +276 648 +276 1321 +276 9674 +276 9995 +276 6893 +276 3055 +276 9648 +276 7697 +276 946 +276 2355 +276 5909 +276 7753 +276 2328 +276 2267 +276 1853 +276 4990 +276 7061 +277 6912 +277 4877 +277 5650 +277 3864 +277 929 +277 4136 +277 3117 +277 6964 +277 2613 +277 2617 +277 1978 +277 5436 +277 6338 +277 4936 +277 589 +277 3022 +277 3025 +277 6734 +277 1082 +277 9699 +277 6122 +277 6895 +277 4666 +277 3189 +277 4219 +277 7934 +278 773 +278 9873 +278 6035 +278 5658 +278 6043 +278 6429 +278 342 +278 7083 +278 5548 +278 6829 +278 825 +278 5824 +278 7493 +278 2133 +278 6870 +278 4188 +278 3040 +278 9700 +278 4454 +278 5267 +278 8052 +278 3829 +278 1399 +278 9337 +278 8828 +279 6368 +279 5633 +279 9295 +279 1187 +279 3876 +279 8934 +279 295 +279 4649 +279 8810 +279 8359 +279 5613 +279 654 +279 7325 +279 6418 +279 2785 +279 9017 +279 1626 +279 7867 +279 6300 +279 5757 +279 1531 +280 3680 +280 5824 +280 4803 +280 1318 +280 5894 +280 8743 +280 7370 +280 7212 +280 4111 +280 2992 +280 9746 +280 2771 +280 2164 +280 9206 +280 9661 +281 7739 +281 4645 +281 2015 +281 8136 +281 9388 +281 9452 +281 4810 +281 1642 +281 8431 +281 7890 +281 2611 +281 7158 +281 7013 +281 600 +281 2586 +281 6111 +281 3997 +281 638 +281 2085 +282 3681 +282 5477 +282 6170 +282 2440 +282 3531 +282 1644 +282 5148 +282 1007 +282 7568 +282 5341 +282 6675 +282 7285 +282 1395 +282 8312 +282 5273 +282 1437 +282 1884 +282 8605 +282 798 +283 1541 +283 1297 +283 6164 +283 9624 +283 285 +283 2463 +283 1314 +283 8874 +283 8748 +283 6960 +283 4021 +283 8374 +283 7362 +283 7111 +283 1746 +283 3158 +283 6110 +283 5857 +283 8418 +283 4969 +283 2803 +283 5622 +283 9215 +284 4879 +284 1313 +284 2555 +284 7268 +284 1989 +284 2373 +284 7265 +284 9514 +284 875 +284 8559 +284 5024 +284 1600 +284 4916 +284 7765 +284 4006 +284 312 +284 9028 +284 8698 +284 3963 +285 2587 +285 3847 +285 6920 +285 7434 +285 9103 +285 2970 +285 4259 +285 1960 +285 2094 +285 6960 +285 7859 +285 822 +285 7999 +285 6336 +285 5046 +285 8778 +285 1355 +285 589 +285 4438 +285 2022 +285 6508 +285 1393 +285 9715 +285 7423 +286 3841 +286 7170 +286 3171 +286 6504 +286 4105 +286 8618 +286 9323 +286 2703 +286 3619 +286 4355 +286 1237 +286 3030 +286 2595 +286 8943 +286 3722 +286 7774 +287 2688 +287 4738 +287 1292 +287 8206 +287 2453 +287 1816 +287 2714 +287 667 +287 6428 +287 4767 +287 6900 +287 9018 +287 5692 +287 6089 +287 6858 +287 6604 +287 2257 +287 5865 +287 6251 +287 1389 +287 9070 +287 8564 +287 2941 +288 6786 +288 7915 +288 9607 +288 1545 +288 401 +288 2074 +288 4129 +288 5668 +288 1075 +288 5063 +288 5973 +288 4055 +288 5593 +288 5730 +288 744 +288 2027 +288 1389 +288 8296 +288 3700 +288 3452 +288 9469 +288 4350 +289 4204 +289 5392 +289 1043 +289 4758 +289 6679 +289 8219 +289 7072 +289 5025 +289 1966 +289 4284 +289 1994 +289 5571 +289 6476 +289 6602 +289 4684 +289 3289 +289 3816 +289 2796 +289 2028 +289 2288 +289 7537 +289 7154 +290 9792 +290 6467 +290 3108 +290 2504 +290 3974 +290 4360 +290 7642 +290 5361 +290 7218 +290 852 +290 9877 +290 6393 +290 3732 +290 6618 +290 733 +290 1343 +291 448 +291 3809 +291 2219 +291 5363 +291 9893 +291 6647 +291 2257 +291 8828 +291 746 +291 9639 +291 7463 +291 7950 +291 6640 +291 2289 +291 7666 +291 3668 +291 6464 +291 5787 +291 1788 +292 9249 +292 9147 +292 3301 +292 9232 +292 6652 +292 3996 +292 6672 +292 6360 +292 724 +292 3125 +292 3478 +292 5638 +292 3832 +292 7476 +292 1498 +292 3419 +292 8284 +292 602 +292 1566 +292 517 +293 1504 +293 5280 +293 5701 +293 5511 +293 6344 +293 1193 +293 5162 +293 3695 +293 813 +293 8373 +293 7823 +293 937 +293 6229 +293 1687 +293 3353 +293 9146 +293 1051 +293 4860 +293 9534 +293 2629 +294 2498 +294 3915 +294 4068 +294 1415 +294 5160 +294 8521 +294 3050 +294 2311 +294 3122 +294 6397 +294 5810 +294 4563 +294 7252 +294 2646 +294 8041 +294 852 +294 4345 +294 6395 +294 8220 +294 5149 +295 8836 +295 3781 +295 6696 +295 682 +295 403 +295 5391 +295 3696 +295 6163 +295 2068 +295 9654 +295 7865 +295 6655 +295 2149 +296 3617 +296 3458 +296 6659 +296 1270 +296 3013 +296 7782 +296 7463 +296 6665 +296 4717 +296 2401 +296 4850 +296 8982 +296 8868 +296 8068 +296 6799 +296 5854 +296 2084 +297 9729 +297 5282 +297 2195 +297 6727 +297 7432 +297 746 +297 4588 +297 3361 +297 3470 +297 2896 +297 1553 +297 8402 +297 4659 +297 470 +297 2584 +297 2682 +297 6097 +297 4316 +297 3517 +298 5724 +298 7062 +298 4615 +298 2396 +298 9543 +298 2508 +298 5363 +298 8495 +298 3344 +298 689 +298 9491 +298 8805 +298 3182 +298 8054 +298 4537 +298 5629 +298 3484 +298 7869 +298 9695 +299 4929 +299 6523 +299 6181 +299 5030 +299 8584 +299 1002 +299 9579 +299 6252 +299 7261 +299 7688 +299 3786 +299 1171 +299 5943 +299 4120 +299 2307 +299 6511 +299 4669 +300 3936 +300 7137 +300 3490 +300 8899 +300 3044 +300 1637 +300 4769 +300 1527 +300 3948 +300 1229 +300 5710 +300 6866 +300 1619 +300 5748 +300 9014 +300 8915 +300 4989 +300 3237 +301 8130 +301 4993 +301 8098 +301 5761 +301 1491 +301 2217 +301 7431 +301 4748 +301 3405 +301 3278 +301 656 +301 4496 +301 7219 +301 4789 +301 1321 +301 5792 +301 1473 +301 9342 +302 3296 +302 8257 +302 323 +302 8382 +302 2022 +302 8935 +302 9069 +302 9455 +302 7826 +302 8467 +302 4020 +302 3998 +302 5878 +302 1336 +302 3836 +302 6589 +302 3230 +302 9349 +303 7168 +303 2147 +303 9054 +303 1159 +303 9035 +303 3661 +303 5613 +303 2257 +303 6942 +303 6266 +303 7486 +304 7073 +304 9826 +304 9032 +304 957 +304 6730 +304 3896 +304 5326 +304 8559 +304 3656 +304 5300 +304 5366 +304 8888 +304 4249 +304 6346 +305 3680 +305 4708 +305 6151 +305 3080 +305 5943 +305 7562 +305 523 +305 399 +305 6065 +305 7059 +305 3860 +305 9333 +305 2871 +305 731 +305 7005 +305 6943 +306 4484 +306 6927 +306 3344 +306 5655 +306 6296 +306 5660 +306 4640 +306 1577 +306 6703 +306 5299 +306 2873 +306 5434 +306 9403 +306 2238 +306 4287 +306 1603 +306 964 +306 8406 +306 6616 +306 1499 +306 350 +306 5474 +306 8937 +306 2035 +306 8767 +306 4860 +307 3905 +307 2435 +307 1892 +307 1638 +307 1159 +307 9032 +307 4073 +307 1036 +307 5648 +307 5635 +307 3222 +307 8248 +307 8413 +308 4489 +308 6797 +308 5009 +308 7186 +308 7700 +308 8095 +308 6453 +308 777 +308 5257 +308 7866 +308 6469 +308 5318 +308 8391 +308 968 +308 5711 +308 5840 +308 6615 +308 2396 +308 609 +308 1766 +308 1255 +308 491 +308 3693 +308 4468 +308 5878 +308 1017 +309 803 +309 3333 +309 8422 +309 5255 +309 3097 +309 5033 +309 2551 +309 2509 +309 1805 +309 338 +309 3411 +309 5172 +309 1193 +309 5689 +309 9391 +309 4508 +310 8578 +310 8198 +310 3979 +310 2198 +310 6167 +310 3568 +310 3244 +310 6317 +310 3379 +310 3002 +310 5435 +310 6067 +310 9796 +310 716 +310 4950 +310 7644 +310 8251 +310 8552 +310 4976 +310 7927 +310 9080 +311 7809 +311 4878 +311 5007 +311 6672 +311 7185 +311 3100 +311 9119 +311 4002 +311 558 +311 6319 +311 6192 +311 7602 +311 2872 +311 5471 +311 4542 +311 3265 +311 7119 +311 6617 +311 8155 +311 7132 +311 6879 +311 7910 +311 1512 +311 6126 +311 5864 +312 3936 +312 8288 +312 6583 +312 2602 +312 6507 +312 7788 +312 2766 +312 1680 +312 1944 +312 9013 +312 6199 +312 2712 +312 9246 +312 9781 +313 3457 +313 9730 +313 7054 +313 2200 +313 4636 +313 3363 +313 2726 +313 5295 +313 5302 +313 7608 +313 701 +313 4085 +313 9411 +313 9802 +313 8654 +313 2776 +313 8796 +313 4960 +313 6382 +313 3261 +313 9457 +313 4597 +313 7288 +314 770 +314 7045 +314 903 +314 9995 +314 3085 +314 2321 +314 9107 +314 6677 +314 5155 +314 8117 +314 9659 +314 321 +314 1227 +314 7620 +314 6985 +314 8907 +314 1356 +314 2637 +314 3022 +314 4689 +314 6868 +314 6869 +314 9188 +314 6362 +314 5988 +314 4709 +314 1131 +314 1134 +314 3439 +314 3834 +314 6140 +314 3582 +315 5895 +315 3756 +315 9231 +315 5286 +315 1452 +315 5192 +315 1395 +315 2484 +315 6458 +315 6261 +315 8899 +315 5064 +315 4816 +315 3411 +315 2063 +315 3165 +315 5351 +315 7534 +315 4079 +315 979 +315 4085 +315 5111 +315 3704 +315 6521 +315 4095 +316 3808 +316 6562 +316 5443 +316 1750 +316 3842 +316 8305 +316 4492 +316 2348 +316 493 +316 1458 +316 1237 +316 9334 +316 8761 +316 1137 +316 8767 +316 6364 +316 893 +316 1503 +317 3330 +317 2092 +317 5261 +317 5522 +317 2197 +317 3737 +317 4122 +317 6557 +317 5408 +317 7074 +317 6442 +317 6700 +317 4400 +317 8648 +317 2259 +317 9556 +317 1497 +317 611 +317 8293 +317 614 +317 9959 +317 8169 +317 8821 +317 8438 +317 6135 +318 9216 +318 7938 +318 4102 +318 4872 +318 2061 +318 7981 +318 561 +318 7475 +318 3004 +318 2110 +318 3397 +318 712 +318 3273 +318 3428 +318 9317 +318 2024 +318 9454 +318 4975 +318 6387 +318 5877 +318 9594 +318 6651 +318 9596 +318 8445 +319 8262 +319 7266 +319 5251 +319 2789 +319 8134 +319 8232 +319 2218 +319 7470 +319 7709 +319 4465 +319 8850 +319 806 +319 3893 +319 8729 +319 1912 +319 2595 +319 3194 +319 8828 +319 5533 +320 6081 +320 9762 +320 8419 +320 5028 +320 3397 +320 4457 +320 7147 +320 9036 +320 717 +320 3182 +320 4304 +320 3729 +320 3827 +320 8821 +320 3625 +320 7162 +320 925 +321 3078 +321 5127 +321 8075 +321 5775 +321 4628 +321 1562 +321 2202 +321 1696 +321 3243 +321 9772 +321 9910 +321 5687 +321 960 +321 3266 +321 5955 +321 9284 +321 9040 +321 8790 +321 7640 +321 8548 +321 485 +321 8552 +321 8426 +322 8960 +322 7681 +322 5762 +322 9684 +322 4490 +322 2700 +322 4877 +322 6317 +322 7216 +322 8404 +322 4889 +322 2590 +322 5151 +323 5635 +323 6935 +323 5790 +323 3104 +323 6306 +323 5027 +323 4004 +323 9509 +323 2472 +323 5549 +323 9800 +323 9036 +323 1488 +323 6869 +323 984 +323 9564 +323 8541 +323 4574 +323 3936 +323 9315 +323 7142 +323 4972 +323 3570 +323 7035 +324 6148 +324 2312 +324 5401 +324 3742 +324 6303 +324 1440 +324 7585 +324 5155 +324 2728 +324 1966 +324 7993 +324 9274 +324 9148 +324 4157 +324 4552 +324 4445 +324 3553 +324 9955 +324 4455 +324 3624 +324 4468 +324 9976 +324 9979 +324 3964 +325 3721 +325 7948 +325 2835 +325 8477 +325 4131 +325 7217 +325 7731 +325 1801 +325 9529 +325 7997 +325 3011 +325 7108 +325 2501 +325 3212 +325 8522 +325 1875 +325 5718 +325 6363 +325 3676 +325 9823 +325 993 +325 9956 +325 3431 +325 9072 +325 3699 +325 1587 +326 5123 +326 2569 +326 4107 +326 3727 +326 3090 +326 6319 +326 8105 +326 3783 +326 9644 +326 9391 +326 6458 +326 4539 +326 4293 +326 7367 +326 5323 +326 851 +326 9559 +326 2272 +326 9569 +326 1649 +326 8955 +327 2839 +327 8929 +327 6115 +327 1505 +327 8585 +327 3095 +327 5040 +327 593 +327 4496 +327 3539 +327 4853 +327 1878 +327 5143 +327 1977 +327 4219 +327 3531 +327 8405 +328 3648 +328 8801 +328 1936 +328 7915 +328 4964 +328 1448 +328 7787 +328 3056 +328 2771 +328 6485 +328 7671 +328 7704 +328 3900 +329 6880 +329 2209 +329 4643 +329 7268 +329 7958 +329 8593 +329 7144 +329 5097 +329 4650 +329 1901 +329 7408 +329 648 +329 850 +329 3555 +329 734 +329 1654 +329 8479 +329 3612 +329 3550 +329 9215 +330 9474 +330 1156 +330 7432 +330 1564 +330 1577 +330 2480 +330 1343 +330 5577 +330 6776 +330 1749 +330 1243 +330 4582 +330 2022 +330 7271 +330 5097 +330 9578 +330 6637 +330 6645 +330 3702 +330 3832 +330 2425 +331 2144 +331 5604 +331 6693 +331 3527 +331 6504 +331 2793 +331 2388 +331 1238 +331 3844 +331 4572 +332 9475 +332 8708 +332 5767 +332 3852 +332 4493 +332 4249 +332 2716 +332 3110 +332 7467 +332 2094 +332 8879 +332 2951 +332 7732 +332 4794 +332 5599 +332 702 +332 7241 +332 7631 +332 5073 +332 7775 +332 5985 +332 5489 +332 7928 +333 8704 +333 8074 +333 5515 +333 8336 +333 6674 +333 3871 +333 1904 +333 1704 +333 3369 +333 1195 +333 431 +333 5298 +333 3359 +333 5692 +333 2442 +333 1479 +333 970 +333 7501 +333 2646 +333 859 +333 5724 +333 8679 +333 5872 +333 4341 +333 6782 +334 1634 +334 4773 +334 5317 +334 5996 +334 1975 +334 8876 +334 3087 +334 4113 +334 8978 +334 7475 +334 1909 +334 2807 +334 3801 +334 2682 +334 6591 +334 3519 +335 7970 +335 4164 +335 6678 +335 1638 +335 5799 +335 3724 +335 8620 +335 9810 +335 9203 +335 5684 +335 9470 +335 6518 +335 7172 +335 1177 +335 9980 +335 5725 +335 4702 +335 9471 +336 5920 +336 5408 +336 5387 +336 2401 +336 4583 +336 5961 +336 1607 +336 6287 +336 1773 +336 9582 +336 7887 +336 2385 +336 627 +336 2345 +336 1709 +336 1654 +336 6455 +336 4474 +336 3515 +336 1948 +336 1978 +337 7552 +337 3969 +337 916 +337 1308 +337 6306 +337 3235 +337 6952 +337 5935 +337 4792 +337 7481 +337 7484 +337 8509 +337 5950 +337 4045 +337 3027 +337 3029 +337 344 +337 4317 +337 2784 +337 5997 +337 2030 +337 5032 +337 6003 +338 7175 +338 520 +338 6410 +338 4747 +338 6927 +338 4375 +338 2585 +338 8486 +338 8364 +338 3885 +338 1968 +338 3255 +338 4035 +338 9287 +338 4810 +338 8271 +338 982 +338 6104 +338 3165 +338 7206 +338 9337 +338 2559 +339 4640 +339 6700 +339 2916 +339 2821 +339 7112 +339 4876 +339 7404 +339 6693 +339 3821 +339 4112 +339 9453 +339 9173 +339 6423 +339 6553 +339 1754 +339 6139 +339 4506 +339 9471 +340 4491 +340 2189 +340 8334 +340 3217 +340 4120 +340 3739 +340 3744 +340 3368 +340 9655 +340 7738 +340 8255 +340 6466 +340 583 +340 973 +340 2647 +340 8799 +340 1136 +340 756 +340 8565 +340 2552 +340 4543 +341 2114 +341 1827 +341 6116 +341 933 +341 7463 +341 9948 +341 5166 +341 5583 +341 8080 +341 3410 +341 470 +341 4937 +341 9048 +341 5052 +341 2269 +341 638 +341 869 +342 2242 +342 7574 +342 5159 +342 1992 +342 6535 +342 3149 +342 8432 +342 5842 +342 7603 +342 948 +342 6933 +342 8983 +342 2140 +343 1904 +343 6019 +343 708 +343 9957 +343 1003 +343 492 +343 7959 +343 7299 +343 6101 +343 8759 +343 8440 +343 9547 +343 6428 +343 7229 +343 3262 +343 9151 +344 4738 +344 6668 +344 654 +344 1679 +344 2320 +344 1181 +344 2906 +344 2090 +344 4402 +344 5945 +344 957 +344 1858 +344 1864 +344 4748 +344 7127 +344 7002 +344 1633 +344 354 +344 8805 +344 4972 +344 5489 +344 8818 +344 8055 +344 8313 +345 5394 +345 1558 +345 2009 +345 9247 +345 4848 +345 2212 +345 8871 +345 6573 +345 3896 +345 8256 +345 8993 +345 469 +345 2774 +345 2776 +345 1503 +345 6640 +345 759 +345 7672 +345 9209 +345 2173 +345 6741 +346 4162 +346 9443 +346 4906 +346 8718 +346 4751 +346 9456 +346 5299 +346 3828 +346 1208 +346 6004 +346 4890 +346 8143 +346 3402 +346 2335 +347 3648 +347 9153 +347 7650 +347 4355 +347 4581 +347 2022 +347 4073 +347 8866 +347 4302 +347 3313 +347 5138 +347 2979 +347 7284 +347 1206 +347 3608 +347 6324 +347 8083 +347 2908 +347 6602 +347 8990 +348 6878 +348 609 +348 7643 +348 548 +348 6854 +348 9799 +348 5388 +348 5738 +348 620 +348 7021 +348 6255 +348 1680 +348 8370 +348 6387 +348 6174 +348 8981 +348 1303 +348 6459 +348 5567 +348 990 +349 5666 +349 4299 +349 8657 +349 9816 +349 4458 +349 5182 +349 1422 +349 6191 +349 4785 +349 6645 +349 8632 +349 1660 +349 5022 +349 5727 +350 1538 +350 5393 +350 3220 +350 9626 +350 5403 +350 2339 +350 6726 +350 9766 +350 7463 +350 3250 +350 2606 +350 4783 +350 8500 +350 3131 +350 411 +350 4038 +350 5837 +350 9177 +350 4210 +350 2420 +351 1920 +351 9857 +351 867 +351 1171 +351 4038 +351 4017 +351 5500 +351 4202 +351 1739 +351 9292 +351 8845 +351 7249 +351 3506 +351 4403 +351 6388 +351 9107 +351 5848 +351 2553 +351 2484 +351 3388 +351 2068 +352 6147 +352 9552 +352 1154 +352 5091 +352 4776 +352 3842 +352 2096 +352 7633 +352 6418 +352 3283 +352 7380 +352 2110 +352 7830 +352 5978 +352 9567 +352 2044 +352 9886 +352 7935 +353 1411 +353 7434 +353 2700 +353 2574 +353 2578 +353 3859 +353 6489 +353 5024 +353 8101 +353 3882 +353 2485 +353 568 +353 3770 +353 8774 +353 3015 +353 6984 +353 8908 +353 8144 +353 2130 +353 601 +353 2268 +353 9448 +353 658 +353 8431 +353 3048 +353 1427 +353 9337 +353 9086 +354 3204 +354 2262 +354 5895 +354 5002 +354 9228 +354 5519 +354 7184 +354 6806 +354 4207 +354 7709 +354 6946 +354 4389 +354 6311 +354 2218 +354 1072 +354 3443 +354 2100 +354 8500 +354 9153 +354 2501 +354 5963 +354 5326 +354 4303 +354 1105 +354 2390 +354 6607 +354 2518 +354 9457 +354 5999 +354 6896 +354 6641 +354 4466 +354 499 +354 1910 +354 1149 +354 5374 +354 4863 +355 4866 +355 1942 +355 4358 +355 8970 +355 2195 +355 2582 +355 1051 +355 5754 +355 7203 +355 3249 +355 3257 +355 2241 +355 2886 +355 5450 +355 7883 +355 2125 +355 6989 +355 8785 +355 7507 +355 5561 +355 2269 +355 2272 +355 4577 +355 3044 +355 4585 +355 1006 +355 8954 +356 9120 +356 5474 +356 1220 +356 8965 +356 9289 +356 9290 +356 5932 +356 397 +356 5039 +356 7760 +356 3249 +356 594 +356 3187 +356 9876 +356 6613 +356 7433 +356 7706 +356 9211 +356 3295 +357 9346 +357 8580 +357 9863 +357 3868 +357 4130 +357 2470 +357 7080 +357 813 +357 5685 +357 1849 +357 705 +357 7875 +357 9925 +357 5447 +357 6985 +357 1994 +357 7760 +357 8661 +357 5976 +357 5849 +357 8543 +357 9449 +357 9331 +357 9205 +358 9986 +358 5508 +358 386 +358 9709 +358 1428 +358 5911 +358 8859 +358 5404 +358 6815 +358 2338 +358 2749 +358 5749 +358 1737 +358 3276 +358 3023 +358 9555 +358 6104 +358 8670 +358 5984 +358 2407 +358 8813 +358 5233 +358 757 +359 8608 +359 9826 +359 4003 +359 6679 +359 9769 +359 2571 +359 1676 +359 558 +359 3185 +359 9780 +359 3287 +359 7322 +360 4033 +360 5954 +360 3315 +360 737 +360 7944 +360 1962 +360 7042 +360 7005 +360 2130 +360 7955 +360 9816 +360 2532 +360 4411 +360 8828 +360 8029 +360 8863 +361 5952 +361 6640 +361 8708 +361 4199 +361 6889 +361 4042 +361 2375 +361 6226 +361 1767 +361 6000 +361 9937 +361 6194 +361 5718 +361 8856 +361 1799 +361 4783 +361 7039 +362 5635 +362 388 +362 773 +362 7060 +362 5024 +362 9635 +362 4142 +362 7349 +362 7606 +362 7735 +362 8381 +362 928 +362 7114 +362 8267 +362 1486 +362 1877 +362 728 +362 6236 +362 4829 +362 6248 +362 371 +362 633 +363 5632 +363 3971 +363 7822 +363 6422 +363 9113 +363 8751 +363 4381 +363 548 +363 7845 +363 7210 +363 7214 +363 2095 +363 9264 +363 4792 +363 1851 +363 5820 +363 834 +363 6615 +363 9688 +363 4852 +363 5883 +364 770 +364 8708 +364 5896 +364 2570 +364 3596 +364 7439 +364 5394 +364 9108 +364 1187 +364 2471 +364 4136 +364 4654 +364 7773 +364 7217 +364 571 +364 2368 +364 2882 +364 451 +364 8404 +364 2901 +364 5210 +364 3805 +364 2910 +364 2407 +364 7016 +364 5741 +364 1365 +365 1408 +365 6756 +365 3013 +365 9772 +365 939 +365 7852 +365 9775 +365 1278 +365 8472 +365 8602 +365 4094 +365 9717 +366 8321 +366 2433 +366 9355 +366 6164 +366 9241 +366 6939 +366 3228 +366 6685 +366 6001 +366 1453 +366 5422 +366 1949 +366 5556 +366 7737 +366 5829 +366 8647 +366 7243 +366 4830 +366 2917 +366 1905 +366 6775 +366 4477 +367 9989 +367 1301 +367 9284 +367 9114 +367 1568 +367 4258 +367 6053 +367 1707 +367 7352 +367 828 +367 5181 +367 5311 +367 7618 +367 7876 +367 6990 +367 1363 +367 4686 +367 3288 +367 9568 +367 4713 +367 5949 +367 5750 +368 2816 +368 6273 +368 4231 +368 8456 +368 1292 +368 403 +368 4503 +368 580 +368 6560 +368 7973 +368 8103 +368 7085 +368 2613 +368 5946 +368 1205 +368 1344 +368 1091 +368 7236 +368 4427 +368 6221 +368 474 +368 6629 +368 1762 +368 4452 +368 7269 +368 3816 +368 2286 +369 9089 +369 4388 +369 7623 +369 6697 +369 5803 +369 429 +369 3438 +369 7344 +369 9265 +369 3763 +369 8055 +369 8183 +369 3294 +369 1823 +370 4481 +370 6877 +370 2859 +370 6692 +370 7105 +370 2749 +370 6220 +370 586 +370 5881 +370 5994 +370 3503 +370 3114 +370 3028 +370 3705 +370 5206 +370 3577 +370 5593 +370 6106 +370 6442 +370 9757 +371 1536 +371 3211 +371 5907 +371 7086 +371 7127 +371 4905 +371 6572 +371 7470 +371 3121 +371 8244 +371 4278 +371 1470 +371 5186 +371 7753 +371 5708 +371 6997 +371 4183 +371 6368 +371 9315 +371 3559 +371 9960 +371 8822 +371 4477 +372 7682 +372 9507 +372 3524 +372 1316 +372 456 +372 1195 +372 3500 +372 8221 +372 1264 +372 6132 +372 5204 +372 5754 +372 6735 +372 986 +373 4865 +373 776 +373 4618 +373 8205 +373 9492 +373 9114 +373 9499 +373 4383 +373 9774 +373 9267 +373 3511 +373 1208 +373 9482 +373 5966 +373 9423 +373 2003 +373 7638 +373 5080 +373 3040 +373 5346 +373 7654 +373 5693 +373 3574 +373 2556 +374 4482 +374 1988 +374 7281 +374 2537 +374 9964 +374 9634 +374 5775 +374 6928 +374 6257 +374 9590 +374 9343 +374 7628 +374 4159 +375 8256 +375 7722 +375 2756 +375 5351 +375 1640 +375 9962 +375 2183 +375 9740 +375 4783 +375 3760 +375 2961 +375 3826 +375 9812 +375 7766 +375 6072 +375 9352 +375 907 +375 9258 +375 8927 +376 5440 +376 6913 +376 4616 +376 4233 +376 525 +376 3477 +376 1687 +376 6681 +376 1057 +376 4645 +376 5927 +376 7723 +376 9536 +376 5966 +376 8656 +376 6494 +376 1890 +376 7573 +376 1520 +376 1659 +376 917 +377 9089 +377 3202 +377 5769 +377 3215 +377 8854 +377 8736 +377 4258 +377 1222 +377 1575 +377 3498 +377 9772 +377 4783 +377 7865 +377 2758 +377 8784 +377 9173 +377 5462 +377 2659 +377 2789 +377 2408 +377 4968 +378 1664 +378 5250 +378 9219 +378 2006 +378 2440 +378 7700 +378 1047 +378 3354 +378 4592 +378 1193 +378 2730 +378 3380 +378 6453 +378 7609 +378 8256 +378 6982 +378 9163 +378 7884 +378 7117 +378 1358 +378 5325 +378 470 +378 5357 +378 4848 +378 9969 +378 4222 +379 3554 +379 3019 +379 3588 +379 7947 +379 6097 +379 6805 +379 1046 +379 9465 +379 1624 +379 4345 +379 4956 +379 1054 +379 8501 +380 2848 +380 8243 +380 8036 +380 7494 +380 9926 +380 6956 +380 6508 +380 9002 +380 1678 +380 7197 +380 3408 +380 2867 +380 9354 +380 5560 +380 1124 +380 1373 +380 8926 +381 7428 +381 1414 +381 3943 +381 8425 +381 3307 +381 6612 +381 4621 +381 876 +381 3069 +381 9778 +381 3123 +381 9268 +381 889 +381 1146 +381 796 +381 2973 +382 7562 +382 6541 +382 4495 +382 4496 +382 8723 +382 7576 +382 2715 +382 6684 +382 6822 +382 6954 +382 9265 +382 4918 +382 8378 +382 9021 +382 3521 +382 5705 +382 8018 +382 480 +382 9307 +382 2909 +382 8416 +382 4197 +382 3176 +382 8052 +382 3319 +382 9469 +382 1406 +383 1771 +383 6533 +383 2189 +383 1040 +383 8085 +383 535 +383 5400 +383 3098 +383 1567 +383 2210 +383 6439 +383 5162 +383 5423 +383 5434 +383 9917 +383 836 +383 592 +383 9178 +383 6747 +383 606 +383 2528 +383 8550 +383 619 +383 5565 +383 1784 +383 6805 +384 6921 +384 655 +384 4887 +384 668 +384 5282 +384 5541 +384 9259 +384 3119 +384 6074 +384 2528 +384 9669 +384 6471 +384 6476 +384 4066 +384 8530 +384 5728 +384 1250 +384 8678 +384 6888 +384 3050 +384 4690 +384 4974 +384 1522 +384 8438 +385 1027 +385 3094 +385 3336 +385 7947 +385 7951 +385 3350 +385 9751 +385 6296 +385 5402 +385 2842 +385 6432 +385 4006 +385 2990 +385 8623 +385 6194 +385 7862 +385 6586 +385 2243 +385 6984 +385 9812 +385 3415 +385 8027 +385 861 +385 8287 +385 9824 +385 6375 +385 9452 +385 1390 +385 6740 +385 5114 +386 9635 +386 1098 +386 2991 +386 6708 +386 8760 +386 9940 +386 4474 +386 2639 +386 6876 +387 9092 +387 1546 +387 4875 +387 6541 +387 3342 +387 4112 +387 406 +387 4247 +387 5528 +387 3503 +387 6686 +387 4771 +387 7588 +387 7338 +387 2223 +387 6707 +387 4415 +387 3013 +387 5200 +387 6229 +387 2391 +387 8805 +387 4327 +387 2550 +387 3961 +387 1532 +388 5986 +388 9028 +388 7149 +388 7663 +388 8272 +388 3601 +388 2580 +388 5590 +388 3064 +388 916 +388 3770 +388 4508 +389 8096 +389 8097 +389 7202 +389 9899 +389 4394 +389 6667 +389 3469 +389 1007 +389 9200 +389 8978 +389 1811 +389 9950 +389 8723 +389 4889 +389 1084 +389 3517 +389 9118 +389 3157 +390 4610 +390 8123 +390 9636 +390 1541 +390 1479 +390 7571 +390 1550 +390 8753 +390 562 +390 8019 +390 8468 +390 569 +390 5467 +390 8061 +390 5919 +391 5472 +391 9923 +391 9254 +391 1287 +391 8810 +391 2027 +391 9231 +391 9107 +391 2488 +392 6400 +392 4743 +392 1309 +392 3616 +392 8611 +392 3239 +392 5037 +392 1076 +392 5948 +392 6974 +392 7235 +392 6726 +392 3401 +392 4940 +392 9179 +392 4189 +392 3425 +392 8166 +392 6887 +392 9767 +392 9203 +392 1791 +393 9096 +393 7178 +393 7534 +393 7585 +393 939 +393 4744 +393 4404 +393 8891 +393 8914 +393 6618 +393 6494 +393 4063 +393 1506 +393 6885 +393 4454 +393 1511 +393 3688 +393 2535 +393 4974 +393 5112 +393 1146 +394 6976 +394 8900 +394 6725 +394 3218 +394 7241 +394 2956 +394 7213 +394 719 +394 1617 +394 9138 +394 467 +394 1682 +394 9912 +394 7321 +394 2778 +394 8252 +394 9597 +394 8894 +394 1887 +395 5954 +395 2499 +395 9732 +395 6533 +395 2125 +395 8489 +395 9707 +395 6861 +395 6734 +395 845 +395 7248 +395 3601 +395 1059 +395 4598 +395 6633 +395 5599 +395 3199 +396 771 +396 3208 +396 1929 +396 2704 +396 6929 +396 9382 +396 5288 +396 9900 +396 4654 +396 7733 +396 5944 +396 1722 +396 6463 +396 3520 +396 5186 +396 5573 +396 1068 +396 8146 +396 2262 +396 473 +396 5083 +396 9068 +396 9583 +396 4464 +396 1403 +397 4994 +397 5255 +397 5653 +397 4762 +397 1051 +397 8223 +397 550 +397 6951 +397 1457 +397 2612 +397 4791 +397 689 +397 1472 +397 3321 +397 2394 +397 8804 +397 4713 +397 8428 +397 1267 +397 4857 +397 893 +398 6849 +398 7172 +398 3048 +398 9436 +398 4740 +398 9902 +398 1424 +398 8723 +398 2933 +398 9623 +398 8344 +398 5241 +398 8826 +398 7611 +398 4156 +398 9146 +398 7230 +398 2527 +399 8704 +399 7046 +399 4231 +399 8329 +399 4492 +399 9614 +399 1453 +399 9112 +399 2078 +399 3488 +399 2467 +399 4004 +399 7333 +399 7341 +399 4015 +399 1212 +399 5443 +399 6882 +399 4312 +399 5284 +399 1122 +399 3309 +399 9983 +400 3976 +400 5257 +400 3213 +400 4003 +400 8753 +400 3752 +400 9777 +400 4402 +400 4403 +400 3636 +400 1717 +400 7996 +400 2379 +400 2765 +400 5585 +400 7891 +400 8279 +400 4576 +400 6114 +400 614 +400 8174 +400 4720 +401 7511 +401 3853 +401 2446 +401 924 +401 6817 +401 8612 +401 1449 +401 2612 +401 574 +401 2762 +401 9167 +401 4048 +401 9937 +401 5207 +401 4827 +401 3821 +401 2161 +401 5618 +401 9587 +401 8950 +401 3577 +401 9935 +402 7772 +402 8128 +402 2391 +402 612 +402 1284 +402 9544 +402 8092 +402 682 +402 5195 +402 6224 +402 5682 +402 3796 +402 6837 +402 662 +402 1641 +402 9156 +402 8890 +402 9756 +402 5386 +403 3585 +403 8762 +403 1798 +403 3366 +403 3031 +403 7468 +403 3311 +403 4528 +403 8179 +403 9269 +403 1782 +403 9175 +403 7065 +403 1242 +403 6269 +403 7969 +403 8005 +404 3941 +404 4460 +404 9901 +404 8302 +404 9553 +404 9811 +404 8211 +404 8851 +404 7182 +404 4728 +404 2644 +404 6106 +404 3099 +404 1500 +404 1085 +404 5998 +405 1027 +405 1315 +405 6182 +405 4168 +405 2364 +405 1067 +405 3599 +405 5168 +405 6897 +405 6386 +405 595 +405 4630 +405 9304 +405 1979 +405 6332 +405 4061 +406 9568 +406 5217 +406 5863 +406 8264 +406 6605 +406 1098 +406 7757 +406 6414 +406 6045 +406 5744 +406 4274 +406 7667 +406 5966 +406 3959 +406 6776 +406 8986 +406 8699 +406 5276 +406 3037 +406 9138 +407 6048 +407 4898 +407 7267 +407 2820 +407 4505 +407 4427 +407 2498 +407 5821 +407 3700 +407 2594 +407 820 +407 3415 +407 7140 +407 8953 +407 770 +407 6971 +407 7389 +407 8762 +407 4255 +408 768 +408 4224 +408 5650 +408 6959 +408 7352 +408 1209 +408 5563 +408 6204 +408 7237 +408 7879 +408 3275 +408 9295 +408 8918 +408 3424 +408 3771 +408 9317 +408 1001 +408 2676 +408 8055 +408 4858 +408 6395 +408 8700 +409 7180 +409 5645 +409 2459 +409 8865 +409 5420 +409 5042 +409 7219 +409 9269 +409 952 +409 5180 +409 1354 +409 1982 +409 7489 +409 7436 +409 1994 +409 6865 +409 6493 +409 5856 +409 5603 +409 9789 +409 4212 +409 6779 +410 8388 +410 6086 +410 9862 +410 3364 +410 2088 +410 522 +410 6603 +410 2860 +410 4046 +410 8911 +410 3440 +410 6961 +410 6418 +410 718 +410 9689 +410 9018 +410 7035 +410 3007 +410 3871 +411 4353 +411 9349 +411 6321 +411 1173 +411 9764 +411 8869 +411 2215 +411 7729 +411 5943 +411 7358 +411 3270 +411 3399 +411 8524 +411 3023 +411 9043 +411 7384 +411 8926 +411 9056 +411 7908 +411 9449 +411 2412 +411 8949 +411 5367 +411 6665 +412 1058 +412 5060 +412 7525 +412 2534 +412 1224 +412 2091 +412 9613 +412 7790 +412 7985 +412 1395 +412 5815 +412 6808 +412 5124 +412 5917 +413 4744 +413 8980 +413 2197 +413 2415 +413 9375 +413 9143 +413 2591 +413 4285 +413 8263 +413 6216 +413 8525 +413 6865 +413 8919 +413 3934 +413 5987 +413 4965 +413 8297 +413 6378 +413 4335 +413 7189 +414 832 +414 3680 +414 4971 +414 5087 +414 1595 +414 8597 +414 5707 +414 8242 +414 431 +414 2928 +414 1841 +414 4978 +414 3379 +414 4544 +414 7989 +414 8367 +414 4853 +415 9477 +415 4486 +415 8329 +415 1553 +415 1556 +415 5272 +415 7857 +415 3117 +415 3504 +415 945 +415 7222 +415 5562 +415 8510 +415 577 +415 8386 +415 846 +415 7891 +415 1878 +415 1640 +415 8684 +415 6514 +415 4475 +415 7293 +416 9348 +416 7049 +416 2317 +416 5869 +416 3478 +416 3868 +416 9123 +416 7851 +416 9517 +416 1071 +416 5171 +416 436 +416 2875 +416 4674 +416 5901 +416 8144 +416 1107 +416 1236 +416 9942 +416 8023 +416 4111 +416 2792 +416 4845 +416 7930 +416 1149 +417 3200 +417 6955 +417 8456 +417 4109 +417 7441 +417 5934 +417 4891 +417 8734 +417 4129 +417 2211 +417 939 +417 4015 +417 9782 +417 9533 +417 2754 +417 8353 +417 8776 +417 7881 +417 9684 +417 5731 +417 1768 +417 5868 +418 4161 +418 4834 +418 4645 +418 5350 +418 4199 +418 5512 +418 8649 +418 2282 +418 5707 +418 4685 +418 431 +418 3504 +418 8632 +418 4659 +418 7189 +418 9368 +418 4601 +418 5372 +419 4871 +419 6032 +419 9497 +419 544 +419 1572 +419 9381 +419 4136 +419 4667 +419 2247 +419 8136 +419 2505 +419 9303 +419 5338 +419 4955 +419 4368 +419 3944 +419 3819 +419 6525 +419 8437 +419 758 +419 4217 +419 7037 +420 7552 +420 3394 +420 3780 +420 1255 +420 7146 +420 8263 +420 3788 +420 846 +420 7773 +420 6800 +420 9693 +420 5237 +420 9239 +420 5912 +420 2618 +420 1935 +420 8170 +421 1697 +421 5447 +421 4497 +421 616 +421 4652 +421 1034 +421 2283 +421 4524 +421 8781 +421 4654 +421 9457 +421 6226 +421 5908 +421 5358 +421 6040 +421 7597 +421 7419 +421 3602 +422 3459 +422 8720 +422 5783 +422 8857 +422 7721 +422 2730 +422 8236 +422 4536 +422 3775 +422 5579 +422 8773 +422 4299 +422 5071 +422 9812 +422 1238 +422 7003 +422 6109 +422 4958 +422 4961 +422 4195 +422 8807 +422 8429 +422 3825 +422 8061 +422 2814 +423 1189 +423 1544 +423 2345 +423 8138 +423 4875 +423 3917 +423 5390 +423 1293 +423 6545 +423 626 +423 8693 +423 3414 +423 1929 +423 9817 +423 1628 +423 9246 +423 5183 +424 9056 +424 4448 +424 5955 +424 4772 +424 4652 +424 7980 +424 7725 +424 6670 +424 4528 +424 3948 +424 4208 +424 9109 +424 5388 +424 8023 +424 9496 +424 3963 +424 7005 +425 4002 +425 6987 +425 740 +425 5380 +425 8939 +425 6094 +425 688 +425 9937 +425 9458 +425 5171 +425 6766 +425 3062 +425 5145 +425 2811 +425 3965 +426 4736 +426 5515 +426 9484 +426 8084 +426 7280 +426 6562 +426 7462 +426 813 +426 2611 +426 1205 +426 842 +426 3021 +426 3156 +426 4697 +426 2906 +426 8671 +426 8174 +426 2032 +426 2290 +426 1654 +426 4983 +426 890 +427 6272 +427 803 +427 6565 +427 3048 +427 8075 +427 686 +427 3506 +427 1590 +427 2745 +427 9688 +427 8313 +427 5148 +427 4574 +427 8127 +428 4737 +428 3579 +428 9989 +428 3809 +428 9768 +428 7231 +428 5041 +428 8747 +428 8332 +428 3573 +428 1832 +428 7422 +428 5671 +428 9204 +428 1260 +428 3801 +428 7929 +428 9403 +428 9500 +428 7710 +428 7295 +429 6297 +429 9625 +429 5914 +429 7066 +429 9886 +429 3625 +429 6445 +429 5300 +429 6852 +429 4165 +429 2255 +429 8796 +429 7646 +429 8290 +429 7015 +429 6634 +429 1260 +429 2804 +429 3702 +429 5240 +429 1404 +430 1955 +430 7044 +430 8549 +430 3754 +430 2124 +430 9774 +430 6287 +430 2832 +430 1938 +430 1652 +430 566 +430 9175 +430 1285 +430 2140 +430 3498 +430 639 +431 2241 +431 9526 +431 8481 +431 1288 +431 2057 +431 2347 +431 2509 +431 7687 +431 7093 +431 3414 +431 8503 +431 536 +431 9151 +431 3989 +432 1216 +432 5952 +432 1464 +432 6245 +432 9799 +432 5032 +432 1673 +432 495 +432 7761 +432 6642 +432 8691 +432 5396 +432 8437 +432 2072 +432 8922 +432 6913 +433 7008 +433 7137 +433 2731 +433 8934 +433 9857 +433 2891 +433 8367 +433 1201 +433 9747 +433 1940 +433 6705 +433 6516 +434 2368 +434 7750 +434 662 +434 4454 +434 7335 +434 2696 +434 5852 +434 9868 +434 4525 +434 7470 +434 3954 +434 1526 +434 7913 +434 8186 +434 8892 +435 7936 +435 7298 +435 7556 +435 8582 +435 5384 +435 5897 +435 6159 +435 5649 +435 7315 +435 5154 +435 815 +435 5436 +435 2314 +435 6212 +435 5707 +435 1104 +435 4433 +435 3672 +435 5093 +435 3517 +436 3204 +436 6156 +436 5399 +436 7706 +436 5027 +436 5798 +436 6959 +436 1712 +436 1719 +436 8650 +436 7870 +436 451 +436 8136 +436 6345 +436 6474 +436 4259 +436 7765 +436 2657 +436 6498 +436 483 +436 8555 +436 7791 +436 8305 +436 8438 +436 8058 +436 8575 +436 853 +437 2592 +437 6179 +437 2181 +437 5350 +437 6248 +437 1577 +437 6484 +437 9493 +437 4439 +437 5785 +437 1886 +437 4837 +438 6673 +438 9493 +438 8729 +438 5148 +438 7710 +438 4896 +438 5923 +438 7206 +438 3502 +438 9525 +438 3512 +438 7993 +438 2494 +438 2879 +438 5280 +438 8002 +438 6889 +438 491 +438 754 +438 9205 +438 5370 +438 7807 +439 8072 +439 8588 +439 6032 +439 9621 +439 4507 +439 806 +439 1593 +439 9675 +439 5710 +439 6328 +439 3671 +439 1883 +439 5090 +439 8421 +439 5223 +439 4328 +439 1385 +439 2157 +439 882 +439 9337 +440 2050 +440 6699 +440 9735 +440 6154 +440 1420 +440 3475 +440 6948 +440 3241 +440 5675 +440 5423 +440 7344 +440 4275 +440 2616 +440 2745 +440 8892 +440 9154 +440 8265 +440 3028 +440 4694 +440 8484 +440 996 +440 5864 +440 6766 +440 4726 +440 7036 +441 7810 +441 8004 +441 2406 +441 6344 +441 572 +441 6237 +441 4818 +441 7861 +441 3382 +441 7993 +441 9340 +441 8605 +441 958 +442 578 +442 4652 +442 6026 +442 1932 +442 4466 +442 8878 +442 2973 +442 6066 +442 8692 +442 8981 +442 6361 +442 5368 +442 7444 +442 1309 +442 2782 +443 8683 +443 3576 +443 5201 +443 9905 +443 8933 +443 1258 +443 6507 +443 4792 +443 5490 +443 7411 +443 6548 +443 6055 +443 2198 +443 9112 +443 3737 +443 5076 +443 4733 +443 2526 +443 7783 +444 9376 +444 1505 +444 5442 +444 5572 +444 2673 +444 2122 +444 2351 +444 1752 +444 660 +444 8822 +444 5849 +444 3192 +444 3252 +444 9051 +444 7356 +444 4990 +445 3332 +445 3464 +445 6668 +445 6289 +445 920 +445 3993 +445 4016 +445 9736 +445 8504 +445 1466 +445 7358 +445 5440 +445 8261 +445 1351 +445 5577 +445 9296 +445 6104 +445 8166 +445 8039 +445 7313 +445 6253 +445 2676 +445 2681 +445 5756 +446 4096 +446 854 +446 2710 +446 8089 +446 7198 +446 1191 +446 9003 +446 7725 +446 4019 +446 8637 +446 835 +446 7113 +446 7758 +446 7510 +446 8313 +446 866 +446 1787 +446 4842 +446 9127 +446 8816 +446 5493 +446 9464 +446 5497 +446 6139 +447 5435 +447 4644 +447 9768 +447 4364 +447 4946 +447 1103 +447 5137 +447 6514 +447 9331 +447 5780 +447 2519 +447 506 +447 1903 +447 5404 +447 2074 +447 7902 +448 5763 +448 7564 +448 1295 +448 6970 +448 1197 +448 6194 +448 9012 +448 4154 +448 5051 +448 7358 +448 2240 +448 3396 +448 1739 +448 2127 +448 4312 +448 6748 +448 4573 +448 5994 +448 2670 +448 5113 +448 4475 +449 898 +449 6531 +449 904 +449 5516 +449 3603 +449 1958 +449 9005 +449 562 +449 6708 +449 6839 +449 6714 +449 5344 +449 8261 +449 8134 +449 3191 +449 3459 +449 3514 +449 5982 +449 480 +449 3817 +449 8427 +449 3309 +449 3447 +449 1145 +449 2682 +449 1790 +450 9091 +450 3464 +450 2570 +450 515 +450 9371 +450 8114 +450 6448 +450 2226 +450 3507 +450 953 +450 9917 +450 1982 +450 4164 +450 1099 +450 7377 +450 7252 +450 1628 +450 2910 +450 5731 +450 7914 +450 4717 +450 4797 +450 6257 +450 1790 +451 1376 +451 8674 +451 7939 +451 9700 +451 9446 +451 9606 +451 8199 +451 2760 +451 5417 +451 8782 +451 1604 +451 2548 +451 5349 +451 9641 +451 852 +451 761 +451 2847 +451 7307 +451 9119 +452 8296 +452 9353 +452 9450 +452 2219 +452 6408 +452 9045 +452 7574 +452 3992 +452 3418 +452 7677 +453 3681 +453 5137 +453 1576 +453 8524 +453 2859 +453 3820 +453 7240 +453 8436 +453 632 +453 3435 +453 7372 +454 8163 +454 8712 +454 8377 +454 8615 +454 4875 +454 9897 +454 4887 +454 7020 +454 3982 +454 815 +454 9360 +454 8104 +454 8017 +454 971 +454 2487 +454 952 +454 1913 +454 1356 +454 8126 +455 1090 +455 9091 +455 741 +455 4326 +455 1544 +455 5579 +455 7309 +455 4207 +455 6130 +455 6804 +455 6517 +455 2462 +455 7511 +455 3130 +455 6811 +455 2108 +455 9951 +455 1663 +456 9312 +456 6816 +456 3555 +456 5957 +456 3655 +456 6859 +456 2573 +456 2094 +456 5231 +456 3760 +456 853 +456 8600 +456 8473 +456 1743 +456 4860 +456 8976 +457 2880 +457 6529 +457 8738 +457 4259 +457 6500 +457 4550 +457 5542 +457 4669 +457 2924 +457 6802 +457 6717 +457 8512 +457 1757 +457 8755 +457 2837 +457 2722 +457 5015 +457 7247 +457 7069 +457 8085 +458 8016 +458 8033 +458 9923 +458 676 +458 6724 +458 9375 +458 5075 +458 6058 +458 1548 +458 4912 +458 9041 +458 2499 +458 8628 +458 2069 +458 663 +458 6132 +458 923 +458 4828 +458 9438 +458 5087 +459 8940 +459 5515 +459 2701 +459 1680 +459 7953 +459 1812 +459 6812 +459 6305 +459 9634 +459 2470 +459 7468 +459 6450 +459 4278 +459 2360 +459 5727 +459 7367 +459 6218 +459 3151 +459 7777 +459 4959 +459 4961 +459 6499 +459 8043 +459 2156 +459 7663 +459 2544 +459 8182 +459 1528 +459 6265 +460 3723 +460 4366 +460 5776 +460 6674 +460 792 +460 4122 +460 8988 +460 3366 +460 5034 +460 6621 +460 7358 +460 6923 +460 8649 +460 1486 +460 6865 +460 5845 +460 6237 +460 2663 +460 5101 +460 7924 +460 2806 +461 8081 +461 2789 +461 2759 +461 4041 +461 5701 +461 719 +461 3633 +461 2706 +461 7829 +461 2646 +461 6072 +461 7066 +461 3997 +461 4734 +461 6495 +462 7177 +462 2954 +462 1419 +462 7310 +462 1296 +462 6418 +462 803 +462 3623 +462 9644 +462 4525 +462 9567 +462 1341 +462 1344 +462 6081 +462 8517 +462 841 +462 7757 +462 2015 +462 9702 +462 1511 +462 502 +462 9080 +462 1146 +462 3836 +463 6561 +463 7138 +463 6307 +463 7108 +463 6693 +463 8137 +463 7471 +463 8867 +463 6739 +463 4916 +463 597 +463 8185 +463 9913 +463 2844 +463 5253 +464 2312 +464 9355 +464 6803 +464 4247 +464 3870 +464 7842 +464 4772 +464 3237 +464 7335 +464 8105 +464 2988 +464 1200 +464 2872 +464 2493 +464 4926 +464 5568 +464 4929 +464 5922 +464 2004 +464 8917 +464 7511 +464 5722 +464 8544 +464 9578 +464 7659 +464 2161 +464 2419 +465 9283 +465 1093 +465 1606 +465 7111 +465 7304 +465 1292 +465 1162 +465 2087 +465 4556 +465 2922 +465 9326 +465 8659 +465 1940 +465 2520 +465 8954 +465 8138 +466 865 +466 7300 +466 6853 +466 7558 +466 8136 +466 746 +466 3191 +466 9038 +466 6768 +466 8392 +466 3218 +466 1237 +466 3254 +466 3927 +466 3934 +466 4442 +466 5564 +466 6327 +466 798 +466 6661 +467 1953 +467 1540 +467 1802 +467 3339 +467 6220 +467 5677 +467 1971 +467 4820 +467 6366 +467 7446 +467 2679 +467 2521 +467 7610 +467 8083 +467 8147 +468 4928 +468 6785 +468 9603 +468 4417 +468 6218 +468 2891 +468 620 +468 2701 +468 9550 +468 2895 +468 1073 +468 7478 +468 8408 +468 8060 +469 2493 +469 6657 +469 6818 +469 6403 +469 5241 +469 5546 +469 2539 +469 9581 +469 1839 +469 1049 +469 2041 +469 6863 +469 6205 +469 3134 +470 8737 +470 5828 +470 6950 +470 3751 +470 3624 +470 1132 +470 1581 +470 9021 +470 9032 +470 9372 +470 7447 +470 7833 +470 2811 +470 9788 +470 1789 +471 3587 +471 5622 +471 6471 +471 4615 +471 600 +471 2871 +471 2511 +471 7083 +471 8975 +471 8280 +471 9874 +471 4067 +471 661 +471 1750 +471 5817 +471 824 +471 2079 +471 7741 +471 9013 +472 1099 +472 3429 +472 6033 +472 8563 +472 9615 +472 7889 +472 9267 +472 9588 +472 2247 +472 3859 +472 6329 +472 2298 +472 1083 +472 5820 +472 3710 +472 1823 +473 2880 +473 3657 +473 6747 +473 3590 +473 6888 +473 8905 +473 3963 +473 4594 +473 6574 +473 3823 +473 6994 +473 4470 +473 5257 +473 2234 +473 8571 +473 8060 +473 1406 +473 4255 +474 1159 +474 3267 +474 7829 +474 2971 +474 799 +474 2592 +474 3874 +474 2723 +474 3236 +474 9386 +474 7343 +474 5431 +474 1983 +474 9027 +474 4036 +474 6088 +474 9165 +474 8542 +474 4462 +474 5487 +474 4473 +474 7039 +475 1410 +475 5251 +475 6405 +475 3336 +475 7703 +475 1950 +475 2850 +475 4772 +475 5301 +475 9911 +475 4921 +475 6718 +475 821 +475 4164 +475 4677 +475 6854 +475 3618 +475 721 +475 2904 +475 1371 +475 9692 +475 3293 +475 1254 +475 8551 +475 8689 +475 884 +475 3702 +475 1529 +476 992 +476 8612 +476 7650 +476 2724 +476 8134 +476 8616 +476 4617 +476 1163 +476 1164 +476 4271 +476 1208 +476 2258 +476 6803 +476 8281 +476 6103 +476 8856 +476 4633 +476 4538 +476 7101 +476 5950 +477 2531 +477 7108 +477 3685 +477 4907 +477 7500 +477 8493 +477 2094 +477 9071 +477 5437 +477 3511 +477 8015 +477 9020 +477 8861 +477 8670 +477 4223 +478 1807 +478 9186 +478 7318 +478 7624 +478 6345 +478 5675 +478 9165 +478 5879 +478 721 +478 5271 +478 3645 +478 3318 +478 6519 +478 8953 +478 4891 +478 9756 +478 5981 +478 3679 +479 5769 +479 8586 +479 9742 +479 5526 +479 9894 +479 6313 +479 8491 +479 1965 +479 6833 +479 3769 +479 1119 +479 7235 +479 7883 +479 5712 +479 9556 +479 5334 +479 2783 +479 2658 +479 6895 +479 7792 +479 887 +479 9593 +480 656 +480 994 +480 9380 +480 3273 +480 9843 +480 1968 +480 3793 +480 4339 +480 4789 +480 9271 +480 8664 +480 1540 +480 4766 +480 2077 +480 3294 +481 5473 +481 4866 +481 3117 +481 3751 +481 6600 +481 3943 +481 7246 +481 3919 +481 8272 +481 5137 +481 5170 +481 7470 +481 2398 +481 4853 +481 758 +481 5224 +481 1918 +481 6901 +482 4866 +482 8027 +482 9737 +482 7103 +482 487 +482 4501 +482 521 +482 1546 +482 4716 +482 9647 +482 2237 +482 8243 +482 7156 +482 6997 +482 8214 +482 2104 +482 4191 +482 9919 +482 1375 +483 6560 +483 7170 +483 5219 +483 9347 +483 5669 +483 5128 +483 7625 +483 8172 +483 7522 +483 590 +483 5713 +483 4499 +483 2852 +483 2906 +483 9951 +483 7068 +483 3229 +483 7455 +484 8352 +484 4522 +484 9380 +484 1862 +484 4678 +484 3082 +484 4791 +484 6510 +484 8605 +484 1075 +484 1975 +484 2648 +484 2169 +484 3388 +484 7805 +484 2399 +485 5905 +485 1042 +485 7647 +485 7839 +485 6303 +485 9125 +485 4908 +485 9911 +485 8762 +485 6559 +485 4798 +485 2623 +485 4804 +485 3654 +485 5841 +485 2781 +485 5855 +485 1951 +485 879 +485 7802 +485 2427 +485 2044 +486 4310 +486 2192 +486 3476 +486 2200 +486 5017 +486 1178 +486 1436 +486 9503 +486 7202 +486 5044 +486 7996 +486 8261 +486 7248 +486 4563 +486 5206 +486 6999 +486 3289 +486 5343 +486 9185 +486 9318 +486 2795 +486 1521 +486 3829 +486 2039 +486 2808 +487 8160 +487 3937 +487 1411 +487 5413 +487 2247 +487 9161 +487 4778 +487 2055 +487 4878 +487 9199 +487 8307 +487 7033 +487 6778 +487 7130 +488 2945 +488 1220 +488 5414 +488 2268 +488 1672 +488 7260 +488 3724 +488 7169 +488 2097 +488 4466 +488 6003 +488 9460 +488 5817 +488 4696 +488 1811 +488 604 +489 6305 +489 2791 +489 2411 +489 1103 +489 6162 +489 9300 +489 6549 +489 2519 +489 3322 +489 3551 +490 5888 +490 2633 +490 5794 +490 2790 +490 614 +490 5415 +490 2940 +490 6381 +490 9121 +490 6991 +490 1329 +490 9618 +490 5782 +490 9303 +490 1048 +490 4985 +490 4284 +490 7773 +491 7938 +491 5667 +491 6598 +491 7015 +491 2988 +491 690 +491 6165 +491 950 +491 9524 +491 4890 +491 2202 +492 932 +492 6516 +492 2342 +492 9719 +492 5161 +492 3019 +492 3662 +492 5681 +492 2360 +492 9970 +492 1927 +492 3566 +492 1495 +492 2328 +492 4820 +492 8058 +492 8311 +492 4188 +493 9731 +493 5113 +493 4517 +493 7656 +493 3627 +493 8188 +493 6158 +493 9712 +493 7659 +493 4083 +493 7733 +493 5175 +493 3033 +493 5146 +493 1915 +493 3964 +493 3933 +493 1854 +493 5381 +494 901 +494 7263 +494 7308 +494 653 +494 4622 +494 7951 +494 5652 +494 5916 +494 9118 +494 7843 +494 7332 +494 7472 +494 8625 +494 7966 +494 6839 +494 4667 +494 1343 +494 8130 +494 7620 +494 2503 +494 9800 +494 843 +494 5086 +494 1759 +494 3939 +494 9066 +494 9719 +494 9209 +494 9980 +495 7840 +495 1472 +495 547 +495 8230 +495 5830 +495 987 +495 7561 +495 9997 +495 3886 +495 5199 +495 5457 +495 4950 +495 9592 +495 8058 +495 1179 +495 9564 +495 4158 +495 1183 +496 4832 +496 9696 +496 4387 +496 3624 +496 2538 +496 9067 +496 4236 +496 9813 +496 5968 +496 4712 +496 3455 +496 2101 +496 7606 +496 8183 +496 2299 +496 4117 +497 9220 +497 517 +497 9992 +497 2960 +497 5208 +497 6162 +497 3093 +497 4246 +497 7192 +497 9756 +497 2328 +497 7110 +497 1710 +497 7344 +497 4146 +497 3253 +497 5565 +497 9542 +497 9289 +497 8906 +497 846 +497 3320 +497 9943 +497 6104 +497 2652 +497 1762 +497 8550 +497 1770 +497 7147 +497 8312 +498 2318 +498 5268 +498 1177 +498 8095 +498 2849 +498 1449 +498 7713 +498 572 +498 2877 +498 8865 +498 7884 +498 6612 +498 7637 +498 7385 +498 7391 +498 8672 +498 9446 +498 9197 +498 1910 +498 8183 +498 6654 +499 9472 +499 9352 +499 5385 +499 780 +499 9486 +499 6671 +499 2578 +499 5827 +499 6303 +499 8992 +499 1187 +499 7589 +499 7465 +499 3252 +499 2243 +499 2119 +499 5963 +499 2257 +499 5076 +499 7639 +499 8293 +499 2665 +499 6511 +499 4594 +499 8828 +500 8713 +500 2573 +500 5785 +500 8354 +500 4391 +500 6087 +500 9138 +500 7994 +500 3778 +500 9157 +500 8417 +500 8649 +500 5201 +500 3797 +500 3937 +500 3302 +500 3816 +500 4201 +500 8556 +500 9070 +500 3825 +500 853 +501 9152 +501 9505 +501 6082 +501 3907 +501 6564 +501 5831 +501 8936 +501 4521 +501 8010 +501 9293 +501 7949 +501 3536 +501 7217 +501 2723 +501 1110 +501 1847 +501 4441 +501 2842 +502 8855 +502 9743 +502 3985 +502 9239 +502 5668 +502 6572 +502 8128 +502 3395 +502 6086 +502 2250 +502 4047 +502 592 +502 7761 +502 8274 +502 8403 +502 2268 +502 6372 +502 6117 +502 7915 +502 4050 +502 9718 +502 6141 +503 3936 +503 2704 +503 835 +503 4388 +503 9686 +503 4225 +503 3502 +503 6333 +503 9360 +503 2627 +503 8756 +503 2836 +503 3415 +503 505 +503 7387 +503 5373 +503 7237 +504 2337 +504 1573 +504 3621 +504 9031 +504 1161 +504 6603 +504 3314 +504 1139 +504 4659 +504 8692 +504 8248 +504 3577 +504 883 +504 3388 +504 8703 +505 6535 +505 5514 +505 8844 +505 2712 +505 7220 +505 1207 +505 7608 +505 4665 +505 6587 +505 4674 +505 5317 +505 710 +505 7880 +505 5326 +505 5332 +505 2777 +505 5083 +505 4957 +505 9568 +505 4449 +505 6971 +505 3049 +505 3695 +505 4977 +505 8058 +505 7931 +506 4992 +506 5249 +506 6530 +506 9092 +506 7174 +506 2055 +506 8589 +506 5006 +506 8080 +506 1304 +506 9118 +506 9888 +506 8489 +506 1543 +506 1587 +506 6069 +506 4025 +506 1342 +506 577 +506 6346 +506 9938 +506 6867 +506 6229 +506 1368 +506 6779 +506 1643 +506 4333 +506 4731 +506 5887 +507 2785 +507 3074 +507 6307 +507 900 +507 8406 +507 1227 +507 9397 +507 6274 +507 9199 +507 6328 +507 4786 +507 3027 +507 981 +507 7830 +507 3895 +507 8888 +507 6884 +507 2138 +507 9433 +507 3934 +507 9247 +508 3718 +508 9102 +508 9872 +508 2071 +508 1308 +508 2855 +508 3113 +508 7979 +508 8748 +508 9012 +508 1205 +508 9716 +508 6460 +508 5444 +508 5061 +508 4046 +508 2896 +508 3924 +508 1081 +508 1244 +508 3169 +508 3307 +508 6516 +508 6775 +509 6880 +509 6241 +509 6754 +509 5860 +509 1797 +509 4490 +509 7243 +509 6636 +509 3924 +509 2334 +509 2218 +509 8760 +509 3060 +509 4314 +509 7835 +509 5194 +509 6846 +510 6032 +510 4674 +510 5891 +510 2340 +510 8422 +510 9070 +510 4463 +510 688 +510 7057 +510 8564 +510 9262 +510 3990 +510 2712 +510 1529 +510 4830 +511 608 +511 673 +511 4387 +511 9477 +511 8070 +511 6631 +511 969 +511 1898 +511 8946 +511 1198 +511 7773 +511 1361 +511 3378 +511 9397 +511 7638 +511 2185 +511 5693 +511 7838 +511 3647 +512 1984 +512 8833 +512 7650 +512 6563 +512 9732 +512 3270 +512 1288 +512 1930 +512 6251 +512 7392 +512 8047 +512 2992 +512 1076 +512 7859 +512 7700 +512 9653 +512 7545 +512 6365 +512 1694 +512 8767 +513 7552 +513 1184 +513 3035 +513 4070 +513 9894 +513 6289 +513 8488 +513 5831 +513 524 +513 2029 +513 6543 +513 817 +513 7974 +513 3988 +513 7509 +513 5971 +513 4027 +513 2332 +513 9022 +513 4127 +514 6784 +514 1475 +514 3241 +514 2122 +514 3757 +514 7630 +514 3541 +514 9943 +514 4345 +514 6746 +514 4347 +514 1629 +515 544 +515 9729 +515 3624 +515 4275 +515 2695 +515 3144 +515 7529 +515 1131 +515 2252 +515 4749 +515 2960 +515 3985 +515 9459 +515 9206 +515 5776 +515 8698 +515 5054 +516 4544 +516 3938 +516 3076 +516 1573 +516 1625 +516 9415 +516 7644 +516 7287 +516 4674 +516 5977 +516 3313 +516 1619 +516 6174 +516 3319 +516 5208 +516 7257 +516 1161 +516 2203 +516 6428 +516 3300 +516 6558 +517 4480 +517 4486 +517 8584 +517 6537 +517 5005 +517 2446 +517 3730 +517 6549 +517 7706 +517 3878 +517 7340 +517 817 +517 5699 +517 1484 +517 9165 +517 1105 +517 9811 +517 5333 +517 3671 +517 4571 +517 6240 +517 6253 +517 2546 +517 3321 +517 9466 +518 4354 +518 3855 +518 1945 +518 2075 +518 9894 +518 3116 +518 2605 +518 2225 +518 4914 +518 8888 +518 2880 +518 4676 +518 1231 +518 2000 +518 2773 +518 5853 +518 2399 +518 8544 +518 7888 +518 4588 +518 2671 +518 5374 +519 2561 +519 6786 +519 6531 +519 8068 +519 9095 +519 2443 +519 3229 +519 6176 +519 7844 +519 6855 +519 9262 +519 3121 +519 3507 +519 4958 +519 6077 +519 9028 +519 5190 +519 8903 +519 588 +519 5969 +519 9822 +519 7394 +519 8824 +520 9968 +520 5220 +520 7553 +520 4552 +520 3274 +520 5228 +520 8047 +520 2896 +520 2578 +520 1081 +520 8668 +520 9853 +520 5695 +521 4065 +521 8611 +521 1886 +521 1671 +521 3465 +521 2263 +521 9036 +521 3373 +521 8269 +521 1232 +521 8017 +521 4995 +521 9908 +521 9790 +521 5718 +521 6871 +521 8914 +521 4411 +521 6014 +522 3328 +522 1664 +522 8194 +522 4490 +522 7563 +522 7042 +522 528 +522 9497 +522 6555 +522 5281 +522 9638 +522 7463 +522 6327 +522 1350 +522 1867 +522 4560 +522 8541 +522 6378 +522 3320 +522 8443 +522 1661 +523 2283 +523 9095 +523 9367 +523 8461 +523 1294 +523 5781 +523 7447 +523 2713 +523 2589 +523 2590 +523 3374 +523 8628 +523 2231 +523 4025 +523 7484 +523 9662 +523 757 +523 4164 +523 7223 +523 8144 +523 721 +523 9942 +523 8801 +523 7909 +523 6379 +523 4078 +523 881 +523 8254 +523 3449 +523 3964 +524 6016 +524 2308 +524 2951 +524 7562 +524 4107 +524 1299 +524 6830 +524 5038 +524 2484 +524 6966 +524 5172 +524 2619 +524 9148 +524 2239 +524 963 +524 3268 +524 4810 +524 8533 +524 4314 +524 9821 +524 608 +524 5603 +524 3313 +524 1621 +525 8528 +525 9890 +525 5283 +525 2501 +525 9032 +525 2474 +525 3373 +525 2509 +525 9264 +525 2577 +525 5714 +525 4788 +525 5557 +525 8296 +525 1659 +525 3996 +525 3549 +526 1932 +526 7694 +526 5910 +526 4762 +526 7259 +526 1191 +526 810 +526 6065 +526 8754 +526 565 +526 4283 +526 8640 +526 9666 +526 1478 +526 849 +526 2770 +526 4181 +526 6233 +526 1883 +526 5730 +526 5224 +526 7276 +526 8048 +526 754 +526 1013 +526 5494 +526 632 +526 5885 +527 6786 +527 6692 +527 1320 +527 2664 +527 9506 +527 8834 +527 3822 +527 655 +527 1840 +527 8520 +527 9844 +527 3246 +527 1609 +527 9592 +527 9940 +527 9432 +528 644 +528 1298 +528 7574 +528 3736 +528 6811 +528 5156 +528 3884 +528 4660 +528 6838 +528 4920 +528 6463 +528 576 +528 3660 +528 6478 +528 7768 +528 3037 +528 9057 +528 9454 +528 5372 +529 7715 +529 7780 +529 8069 +529 8231 +529 9448 +529 1578 +529 3851 +529 3467 +529 4918 +529 1654 +529 3351 +529 1466 +529 6844 +530 8033 +530 6587 +530 4613 +530 3273 +530 7947 +530 4300 +530 1325 +530 4893 +530 1170 +530 8084 +530 3998 +530 4981 +530 2324 +530 4215 +530 5821 +530 1598 +530 1580 +531 9547 +531 4118 +531 3429 +531 8295 +531 4393 +531 4714 +531 9835 +531 1965 +531 2989 +531 1838 +531 6255 +531 3378 +531 1619 +531 3926 +531 5463 +531 5753 +531 5658 +531 850 +531 1626 +531 2654 +531 4709 +532 3713 +532 6788 +532 5639 +532 652 +532 6286 +532 7079 +532 2344 +532 1459 +532 9395 +532 5811 +532 6583 +532 2622 +532 7615 +532 712 +532 1995 +532 6739 +532 7012 +532 7652 +532 880 +532 9043 +532 1913 +532 4478 +533 2178 +533 7939 +533 4484 +533 7835 +533 2973 +533 7323 +533 8742 +533 1959 +533 3897 +533 4447 +533 3907 +533 1863 +533 7768 +533 2012 +533 6367 +533 9696 +533 9577 +533 5354 +533 5622 +533 8831 +533 7294 +533 5631 +534 1157 +534 6151 +534 793 +534 5912 +534 8729 +534 8795 +534 5673 +534 7083 +534 7596 +534 4530 +534 1333 +534 7738 +534 1851 +534 2113 +534 9798 +534 1655 +534 9040 +534 4305 +534 4949 +534 8536 +534 8283 +534 1887 +534 5731 +534 7017 +534 887 +534 4092 +535 8834 +535 5227 +535 2564 +535 3861 +535 5152 +535 1188 +535 5799 +535 5167 +535 6578 +535 4925 +535 5182 +535 6591 +535 2894 +535 9426 +535 3294 +535 8552 +535 7913 +535 5099 +535 6513 +535 574 +535 4470 +535 4218 +536 7426 +536 9091 +536 2180 +536 6025 +536 8717 +536 2319 +536 9629 +536 6452 +536 3642 +536 2619 +536 4163 +536 7907 +536 8157 +536 5473 +536 9571 +536 3048 +536 9711 +536 4496 +536 4595 +536 1210 +537 7910 +537 6056 +537 2313 +537 3594 +537 4811 +537 2252 +537 1682 +537 6414 +537 4381 +537 6417 +537 7292 +537 1011 +537 6742 +537 5975 +537 9967 +537 1020 +537 3229 +537 9151 +538 4481 +538 2948 +538 8325 +538 2696 +538 6028 +538 3874 +538 680 +538 6442 +538 7239 +538 5169 +538 3251 +538 9016 +538 9401 +538 3772 +538 5575 +538 7380 +538 6103 +538 2922 +538 4459 +538 5484 +538 9841 +538 8951 +539 7552 +539 4033 +539 1124 +539 3974 +539 1127 +539 9132 +539 5898 +539 3755 +539 9196 +539 8046 +539 6164 +539 5173 +539 2393 +539 8340 +539 5178 +539 5148 +539 7357 +539 7964 +540 9564 +540 4291 +540 9286 +540 7750 +540 2503 +540 1993 +540 5482 +540 7607 +540 7858 +540 8183 +540 8312 +540 5330 +540 4642 +540 2645 +540 6025 +540 2680 +540 730 +540 7519 +540 7868 +540 5567 +541 5360 +541 3173 +541 5222 +541 6151 +541 7560 +541 7402 +541 6859 +541 8141 +541 1390 +541 1615 +541 5648 +541 8498 +541 8819 +541 5688 +541 3545 +541 3258 +541 2895 +541 4157 +541 4831 +541 8613 +542 8112 +542 5986 +542 2531 +542 6660 +542 2149 +542 9060 +542 3207 +542 4296 +542 5836 +542 6594 +542 1296 +542 3409 +542 7826 +542 2133 +542 6326 +542 6873 +542 1947 +543 5616 +543 4610 +543 1955 +543 8241 +543 2632 +543 2225 +543 9450 +543 2231 +543 7408 +543 2344 +543 4562 +543 7380 +543 7798 +543 3383 +543 9144 +543 6964 +543 7985 +543 4799 +544 9251 +544 5967 +544 9947 +544 802 +544 812 +544 6123 +544 7629 +544 5071 +544 8531 +544 6132 +544 4469 +544 9939 +544 8567 +544 4442 +544 5275 +544 9468 +544 7856 +544 8255 +545 4768 +545 5163 +545 2756 +545 3334 +545 1702 +545 1352 +545 1163 +545 9976 +545 9992 +545 1263 +545 4752 +545 9519 +545 4429 +545 5877 +545 9814 +545 9111 +545 3704 +545 8632 +545 3343 +545 2558 +546 6741 +546 9009 +546 3432 +546 2588 +546 3103 +546 7821 +546 3278 +546 8945 +546 4146 +546 2643 +546 2356 +546 7637 +546 1225 +546 7129 +546 3323 +546 6524 +546 4125 +546 8255 +547 4610 +547 4379 +547 4246 +547 8167 +547 2728 +547 5609 +547 1515 +547 9580 +547 2658 +547 762 +547 3421 +547 6577 +547 3106 +547 6581 +547 7862 +547 1816 +547 3130 +547 9274 +547 7966 +548 1280 +548 3336 +548 7960 +548 5524 +548 2200 +548 3994 +548 1183 +548 2221 +548 686 +548 7864 +548 1083 +548 8521 +548 2382 +548 5842 +548 4053 +548 1878 +548 4312 +548 7137 +548 2666 +548 4845 +548 2673 +548 2168 +549 4066 +549 4580 +549 7302 +549 1703 +549 7402 +549 6060 +549 9007 +549 6936 +549 6802 +549 2708 +549 8725 +549 5898 +549 8324 +549 3450 +549 4218 +550 9376 +550 1378 +550 1656 +550 6028 +550 6872 +550 1474 +550 5807 +550 3952 +550 7921 +550 6898 +550 5686 +550 3928 +550 5818 +550 3890 +550 3178 +550 7518 +550 9151 +551 7051 +551 7326 +551 4805 +551 9734 +551 5736 +551 1323 +551 6302 +551 3067 +551 2312 +551 5027 +551 7822 +551 5694 +551 3126 +551 2551 +551 3131 +551 2101 +551 3678 +551 6965 +552 6851 +552 9249 +552 3011 +552 1156 +552 5640 +552 1066 +552 2669 +552 9582 +552 6259 +552 8052 +552 7157 +552 9270 +552 4638 +553 8235 +553 9031 +553 5513 +553 5963 +553 5138 +553 9198 +553 751 +553 3280 +553 9681 +553 6739 +553 3219 +553 8437 +553 2104 +553 1783 +553 1721 +553 2143 +554 9154 +554 1547 +554 6756 +554 5908 +554 4071 +554 4068 +554 5451 +554 3042 +554 5597 +554 2868 +554 1950 +554 6087 +554 4375 +554 4633 +554 7130 +554 8287 +554 8093 +554 6398 +554 4287 +555 7489 +555 3714 +555 5539 +555 6916 +555 9441 +555 7336 +555 8074 +555 8725 +555 2210 +555 4514 +555 2920 +555 8658 +555 9941 +555 8149 +555 8727 +555 8441 +555 2619 +555 956 +555 1514 +555 7454 +555 6815 +556 9092 +556 7430 +556 5258 +556 6672 +556 7971 +556 4645 +556 8873 +556 1968 +556 3892 +556 9141 +556 7107 +556 8773 +556 8651 +556 7500 +556 5457 +556 4435 +556 6252 +556 7152 +556 7931 +556 3199 +557 6146 +557 5252 +557 8328 +557 3850 +557 9489 +557 6421 +557 1052 +557 8098 +557 8741 +557 3110 +557 5036 +557 8879 +557 5172 +557 5944 +557 9530 +557 3016 +557 849 +557 9042 +557 730 +557 3548 +557 8675 +557 7140 +557 9105 +557 629 +557 6390 +557 6396 +558 8962 +558 3589 +558 3597 +558 4755 +558 2839 +558 5534 +558 3104 +558 6441 +558 6571 +558 4662 +558 5439 +558 5443 +558 7881 +558 4427 +558 3801 +558 4444 +558 6622 +558 7135 +558 1632 +558 6374 +558 1896 +558 6379 +558 2030 +558 6259 +558 6516 +558 9974 +559 2439 +559 8588 +559 8974 +559 783 +559 8977 +559 3347 +559 8750 +559 5160 +559 4265 +559 3118 +559 7091 +559 5813 +559 3510 +559 4409 +559 5569 +559 2637 +559 3854 +559 4440 +559 2404 +559 9981 +559 1149 +559 7166 +560 9869 +560 4865 +560 1603 +560 1540 +560 741 +560 6278 +560 1351 +560 1705 +560 938 +560 2891 +560 589 +560 8846 +560 3757 +560 2064 +560 6835 +560 9577 +560 4601 +561 6459 +561 1317 +561 6759 +561 5961 +561 7491 +561 1776 +561 4305 +561 6003 +561 2806 +561 8215 +561 6297 +561 8538 +561 6907 +561 6268 +561 2622 +561 3541 +562 9761 +562 4395 +562 2340 +562 8743 +562 7432 +562 3370 +562 1803 +562 7310 +562 4337 +562 2499 +562 6581 +562 2104 +562 7672 +562 5370 +562 3355 +562 6204 +562 8799 +563 9616 +563 8515 +563 8708 +563 614 +563 2566 +563 1416 +563 2377 +563 7500 +563 8717 +563 4934 +563 4016 +563 8201 +563 8855 +563 856 +563 9977 +563 3193 +563 4220 +563 6942 +563 2825 +564 5529 +564 2843 +564 2849 +564 3364 +564 6193 +564 6328 +564 9787 +564 6335 +564 4294 +564 7495 +564 4812 +564 6349 +564 2147 +564 725 +564 4953 +564 3293 +564 8033 +564 8803 +564 1516 +564 2936 +564 1529 +565 6720 +565 6689 +565 7650 +565 4097 +565 1062 +565 5863 +565 1167 +565 4688 +565 6546 +565 3092 +565 1749 +565 5175 +565 8314 +565 7905 +565 3133 +565 1758 +565 2879 +566 6720 +566 2371 +566 3973 +566 5928 +566 3580 +566 3004 +566 6189 +566 8751 +566 5667 +566 8252 +566 9902 +566 3414 +566 4247 +566 764 +566 5295 +566 7740 +566 5270 +567 8385 +567 770 +567 9511 +567 4174 +567 8143 +567 8337 +567 5810 +567 4820 +567 5841 +567 2332 +567 9054 +567 6693 +568 4160 +568 5637 +568 4298 +568 4645 +568 5200 +568 9470 +568 9234 +568 4179 +568 2773 +568 3543 +568 9081 +568 4154 +568 2524 +568 8762 +568 9950 +568 2581 +569 8064 +569 3056 +569 5851 +569 3236 +569 8641 +569 6775 +569 5328 +569 2290 +569 1557 +569 6263 +569 8408 +569 4315 +569 7869 +570 9040 +570 6352 +570 7532 +570 6060 +570 8142 +570 7823 +570 3312 +570 745 +570 3288 +570 2425 +570 8794 +570 2895 +570 3418 +571 2736 +571 6938 +571 1886 +571 5680 +571 8793 +571 4265 +571 9930 +571 8311 +571 2160 +571 1265 +571 9458 +571 5300 +571 8350 +571 8938 +571 7607 +571 6169 +571 8538 +571 2621 +571 5502 +572 2560 +572 1505 +572 3043 +572 2408 +572 680 +572 1965 +572 8626 +572 1301 +572 5978 +572 7357 +572 8415 +573 5760 +573 896 +573 2182 +573 7570 +573 5392 +573 2577 +573 9746 +573 8725 +573 6422 +573 8100 +573 8613 +573 7342 +573 4662 +573 5049 +573 831 +573 5575 +573 2632 +573 5845 +573 7774 +573 6497 +573 3042 +573 3812 +573 9959 +573 8169 +573 7058 +573 2159 +573 756 +573 5880 +574 1411 +574 8036 +574 1445 +574 5190 +574 9704 +574 8137 +574 8368 +574 6771 +574 2484 +574 9694 +574 2198 +574 2297 +574 5530 +574 5467 +574 990 +575 2820 +575 1546 +575 8215 +575 1813 +575 4388 +575 7460 +575 6960 +575 3765 +575 2998 +575 9402 +575 2492 +575 6467 +575 6982 +575 8394 +575 6998 +575 8665 +575 5082 +575 3770 +575 609 +575 5858 +575 4851 +576 5633 +576 2146 +576 7876 +576 2246 +576 5862 +576 9185 +576 5993 +576 2506 +576 4268 +576 2639 +576 3729 +576 5460 +576 2045 +576 9279 +577 2050 +577 8931 +577 1063 +577 7594 +577 6221 +577 3742 +577 5713 +577 4755 +577 9173 +577 3515 +577 7324 +578 4674 +578 5371 +578 9426 +578 1577 +578 2797 +578 1998 +578 1933 +578 1200 +578 4401 +578 946 +578 1971 +578 5822 +578 7032 +578 633 +578 883 +578 2627 +578 6526 +578 8351 +579 9476 +579 900 +579 7706 +579 5532 +579 7326 +579 7201 +579 6731 +579 9124 +579 812 +579 2349 +579 692 +579 4662 +579 3001 +579 7738 +579 9147 +579 4291 +579 5956 +579 5960 +579 5707 +579 4057 +579 8417 +579 9035 +579 1387 +579 1774 +580 896 +580 3216 +580 995 +580 1830 +580 3123 +580 6908 +580 8011 +580 1710 +580 8755 +580 855 +580 8979 +580 5076 +580 2133 +580 6038 +580 3081 +580 3388 +581 9472 +581 9485 +581 6944 +581 7332 +581 8368 +581 5942 +581 954 +581 2878 +581 2768 +581 5074 +581 1109 +581 5079 +581 7900 +581 9311 +581 9040 +581 1532 +581 8170 +581 9326 +581 1777 +581 8828 +581 2301 +582 6384 +582 7555 +582 1924 +582 1990 +582 7910 +582 7115 +582 9391 +582 4400 +582 1491 +582 8405 +582 3194 +582 7867 +582 9308 +582 826 +582 2110 +582 5471 +583 9934 +583 1537 +583 6618 +583 4645 +583 6182 +583 1703 +583 808 +583 940 +583 8974 +583 5202 +583 7829 +583 9142 +583 5655 +583 2586 +583 795 +583 2422 +583 1117 +583 1087 +584 9921 +584 782 +584 9797 +584 8193 +584 3273 +584 9230 +584 8588 +584 8493 +584 9806 +584 787 +584 5173 +584 4150 +584 9065 +584 3737 +584 8797 +584 9662 +585 8097 +585 5987 +585 2180 +585 9158 +585 2439 +585 6568 +585 4457 +585 7242 +585 5463 +585 6062 +585 4591 +585 2225 +585 2136 +585 8150 +585 1209 +585 9400 +585 9305 +585 8123 +585 4586 +585 1255 +586 1414 +586 5383 +586 779 +586 7183 +586 4503 +586 2968 +586 3366 +586 6696 +586 7337 +586 5849 +586 945 +586 703 +586 9792 +586 9418 +586 4049 +586 7764 +586 6873 +586 2907 +586 1758 +586 5736 +586 9578 +586 9328 +586 7542 +586 9726 +587 7425 +587 4194 +587 7371 +587 5351 +587 5770 +587 7393 +587 2096 +587 4823 +587 795 +587 3210 +587 7774 +587 3327 +588 7072 +588 5922 +588 3716 +588 9157 +588 3305 +588 6348 +588 6989 +588 8752 +588 2065 +588 4855 +588 9464 +589 3008 +589 1473 +589 5925 +589 2504 +589 2698 +589 8907 +589 2604 +589 4333 +589 2062 +589 4689 +589 7616 +589 6613 +589 8404 +589 4189 +590 4576 +590 3681 +590 8339 +590 741 +590 2342 +590 936 +590 1315 +590 778 +590 5111 +590 4270 +590 9071 +590 6672 +590 6065 +590 7315 +590 7982 +590 697 +590 4635 +590 3823 +591 9859 +591 900 +591 5011 +591 686 +591 5784 +591 1476 +591 3098 +591 7708 +591 1818 +591 4382 +591 3489 +591 881 +591 4904 +591 1196 +591 5166 +591 1200 +591 9988 +591 1464 +591 2116 +591 1862 +591 5191 +591 968 +591 680 +591 2384 +591 3793 +591 1366 +591 5085 +591 4580 +591 4710 +591 4714 +591 4973 +591 7848 +591 4727 +592 1091 +592 3973 +592 1030 +592 9096 +592 642 +592 5375 +592 3473 +592 7235 +592 7832 +592 1179 +592 3228 +592 7969 +592 1058 +592 1828 +592 7216 +592 1462 +592 9660 +592 4163 +592 4807 +592 9941 +592 8289 +592 3044 +592 3941 +592 9455 +592 883 +592 6778 +592 2175 +593 2503 +593 994 +593 6467 +593 7076 +593 2129 +593 9770 +593 2795 +593 6541 +593 8686 +593 4335 +593 913 +593 5394 +593 8754 +593 5943 +593 5759 +593 9884 +593 9917 +593 4926 +593 2047 +594 5153 +594 2467 +594 4124 +594 9677 +594 2865 +594 6002 +594 5653 +594 6553 +594 6756 +594 6682 +594 7323 +594 3772 +594 1532 +594 2110 +594 9269 +595 7585 +595 4004 +595 6661 +595 3590 +595 8161 +595 777 +595 7818 +595 5543 +595 6828 +595 2797 +595 3729 +595 2583 +595 2321 +595 6773 +596 2944 +596 6658 +596 4897 +596 5609 +596 5239 +596 7693 +596 4079 +596 1232 +596 1361 +596 6578 +596 3943 +596 8820 +596 7030 +596 9751 +596 6426 +596 988 +596 4058 +597 2336 +597 7009 +597 7363 +597 8868 +597 1765 +597 1766 +597 7655 +597 4552 +597 4137 +597 5979 +597 5133 +597 4248 +597 8739 +597 9782 +597 3736 +597 1402 +597 5551 +597 4293 +598 1904 +598 3106 +598 9203 +598 2598 +598 1959 +598 7912 +598 7612 +598 4418 +598 1614 +598 1616 +598 1064 +598 1106 +598 9459 +598 8156 +598 9053 +598 7984 +599 8000 +599 9381 +599 3113 +599 4227 +599 7990 +599 8169 +599 5290 +599 9229 +599 2629 +599 9615 +599 8976 +599 8401 +599 5972 +599 9854 +599 4569 +599 6905 +599 5946 +599 1743 +599 3678 +599 6911 +600 4107 +600 912 +600 9108 +600 8470 +600 6562 +600 9437 +600 8497 +600 5811 +600 1205 +600 9156 +600 9933 +600 7631 +600 8792 +600 4957 +600 1239 +600 9440 +600 1128 +600 6761 +600 4074 +600 6124 +600 9577 +601 1728 +601 8003 +601 3653 +601 7721 +601 4202 +601 5280 +601 5900 +601 7181 +601 8771 +601 6419 +601 3445 +601 9849 +601 3907 +601 3744 +601 1882 +601 4254 +602 1216 +602 7681 +602 9174 +602 7526 +602 8871 +602 4840 +602 8489 +602 5514 +602 7276 +602 3686 +602 2797 +602 3120 +602 4689 +602 4914 +602 9365 +602 7318 +602 2456 +602 3996 +602 4618 +602 5104 +603 4482 +603 3984 +603 1696 +603 3875 +603 6700 +603 4909 +603 6575 +603 2096 +603 4530 +603 9780 +603 6070 +603 6457 +603 3387 +603 5953 +603 6582 +603 6179 +603 4692 +603 8543 +603 2528 +603 2157 +603 4347 +603 2303 +604 8577 +604 1062 +604 1383 +604 3818 +604 9034 +604 3758 +604 7663 +604 9298 +604 9555 +604 9268 +604 2582 +604 695 +604 3983 +604 1610 +605 5211 +605 836 +605 3848 +605 7274 +605 8427 +605 5260 +605 6541 +605 2605 +605 7472 +605 9265 +605 7122 +605 5429 +605 9334 +605 8023 +605 3896 +605 8538 +605 2427 +605 2044 +605 6590 +606 4096 +606 3078 +606 2056 +606 7817 +606 6042 +606 4764 +606 1791 +606 4258 +606 3996 +606 1323 +606 943 +606 5053 +606 959 +606 4545 +606 8774 +606 1480 +606 7375 +606 1491 +606 5460 +606 6613 +606 4444 +606 4831 +606 6142 +606 1531 +606 1022 +607 6818 +607 8899 +607 2534 +607 3409 +607 1004 +607 4215 +607 2350 +607 7057 +607 8051 +607 4596 +607 3989 +607 1801 +607 8569 +607 794 +607 4350 +607 3468 +608 9219 +608 6664 +608 1546 +608 1933 +608 5782 +608 2265 +608 4898 +608 6564 +608 3621 +608 8490 +608 8619 +608 3887 +608 6836 +608 1855 +608 9668 +608 4438 +608 7769 +608 7653 +608 2675 +608 1396 +609 1795 +609 6406 +609 1415 +609 7432 +609 5771 +609 2062 +609 1447 +609 9149 +609 8774 +609 5450 +609 2763 +609 2128 +609 3925 +609 3682 +609 4586 +609 3950 +609 4719 +609 7152 +610 7954 +610 3630 +610 795 +610 1949 +610 3875 +610 3142 +610 5160 +610 3370 +610 1451 +610 4398 +610 2223 +610 7990 +610 2981 +610 9668 +610 3398 +610 7263 +610 4834 +610 2406 +610 870 +610 6122 +610 5879 +611 801 +611 8802 +611 3108 +611 4101 +611 3335 +611 2185 +611 1290 +611 7308 +611 4940 +611 687 +611 6768 +611 7794 +611 2006 +611 5143 +611 3292 +611 9854 +611 1733 +612 7298 +612 6230 +612 5895 +612 2577 +612 3486 +612 7201 +612 9770 +612 9388 +612 4015 +612 1203 +612 6708 +612 9662 +612 4424 +612 6991 +612 5078 +612 2648 +612 1253 +612 4584 +612 9841 +612 8314 +613 8960 +613 9348 +613 2448 +613 5265 +613 5682 +613 5524 +613 9243 +613 754 +613 2482 +613 9909 +613 1989 +613 843 +613 2894 +613 1744 +613 981 +613 7384 +613 8932 +613 8171 +613 1393 +613 2162 +613 1525 +613 6139 +613 9087 +614 6722 +614 7364 +614 4006 +614 8744 +614 4776 +614 6378 +614 1099 +614 1869 +614 4168 +614 6197 +614 5462 +614 5907 +614 4801 +614 9819 +614 861 +615 1157 +615 6151 +615 9483 +615 3800 +615 7830 +615 7329 +615 8867 +615 6570 +615 2995 +615 3903 +615 7116 +615 7500 +615 6487 +615 8279 +615 1496 +615 4070 +615 5993 +615 4462 +615 1907 +615 5752 +615 1787 +615 1148 +615 1790 +616 7426 +616 8707 +616 4230 +616 9360 +616 6166 +616 6052 +616 8877 +616 6066 +616 4979 +616 6645 +616 8779 +616 718 +616 2131 +616 6436 +616 6244 +616 4453 +616 9427 +616 3061 +616 6906 +616 2939 +616 7676 +617 4336 +617 9954 +617 7420 +617 6762 +617 4527 +617 5712 +617 7352 +617 754 +617 6163 +617 9225 +617 7479 +617 5240 +617 3737 +617 7548 +617 8958 +617 7359 +618 2145 +618 5506 +618 7171 +618 4836 +618 9030 +618 5575 +618 5354 +618 4300 +618 6509 +618 4013 +618 2485 +618 9654 +618 6975 +619 1667 +619 4420 +619 1622 +619 683 +619 9484 +619 8717 +619 9614 +619 8755 +619 3476 +619 3861 +619 854 +619 3705 +619 2522 +620 9505 +620 1837 +620 5990 +620 4353 +620 4636 +620 1525 +620 8205 +620 2369 +620 4239 +620 3120 +620 6805 +620 8613 +620 6701 +620 6654 +620 703 +621 651 +621 9491 +621 5786 +621 3874 +621 6053 +621 8369 +621 2857 +621 2865 +621 952 +621 8127 +621 1984 +621 4678 +621 8395 +621 9421 +621 8911 +621 5342 +621 805 +621 5353 +621 4717 +621 2623 +622 2541 +622 8596 +622 2840 +622 5914 +622 1051 +622 5278 +622 5543 +622 1884 +622 6194 +622 7744 +622 3525 +622 6474 +622 4697 +622 7900 +622 861 +622 7390 +622 3935 +622 7526 +622 3050 +622 7915 +622 4205 +622 8050 +622 7802 +623 5123 +623 5188 +623 7643 +623 5222 +623 5201 +623 1482 +623 8204 +623 2061 +623 8303 +623 9489 +623 2867 +623 9932 +623 6014 +623 5271 +623 5460 +623 3034 +623 9851 +623 2588 +623 3326 +623 3349 +624 7350 +624 4689 +624 7148 +624 9548 +624 2444 +624 8172 +624 2990 +624 1072 +624 9644 +624 754 +624 8526 +624 9110 +624 5529 +624 1369 +624 2331 +624 3676 +625 801 +625 6018 +625 1111 +625 5226 +625 7851 +625 9293 +625 2798 +625 1264 +625 1137 +625 6773 +625 7447 +625 6628 +625 5402 +625 1387 +625 5692 +625 9213 +625 1045 +626 3203 +626 2566 +626 5511 +626 2184 +626 5130 +626 1936 +626 4509 +626 3590 +626 8486 +626 9131 +626 5426 +626 7612 +626 1985 +626 3138 +626 5571 +626 5840 +626 3159 +626 1503 +626 1424 +626 1764 +626 6888 +626 5799 +626 5157 +626 7295 +627 4194 +627 8502 +627 1031 +627 8952 +627 5816 +627 9261 +627 3953 +627 1266 +627 1397 +627 7574 +627 2744 +627 3391 +628 4353 +628 8201 +628 2060 +628 653 +628 6287 +628 5266 +628 3627 +628 2862 +628 8631 +628 2881 +628 3785 +628 3063 +628 5968 +628 1112 +628 7010 +628 4077 +628 9971 +628 6135 +628 2810 +628 5883 +629 3009 +629 2635 +629 7110 +629 6049 +629 876 +629 2606 +629 7435 +629 9516 +629 6862 +629 7985 +629 4498 +629 2837 +629 6709 +629 8823 +629 2779 +629 2378 +629 5183 +630 9989 +630 7564 +630 8337 +630 6163 +630 7958 +630 5786 +630 9370 +630 7838 +630 7720 +630 3753 +630 9006 +630 5181 +630 8909 +630 4177 +630 2013 +630 5218 +630 3173 +630 7015 +630 3310 +630 4080 +630 4471 +630 7290 +630 2427 +631 9472 +631 8097 +631 6722 +631 9571 +631 1543 +631 5347 +631 651 +631 6542 +631 2224 +631 3505 +631 952 +631 2710 +631 8952 +631 4825 +631 7071 +631 3260 +631 2461 +631 926 +631 735 +632 8708 +632 9608 +632 2313 +632 8738 +632 3547 +632 7215 +632 9013 +632 3977 +632 2360 +632 1338 +632 8513 +632 2628 +632 2373 +632 9550 +632 9941 +632 9558 +632 4443 +632 8171 +632 1133 +632 4086 +632 7799 +632 8575 +633 7690 +633 6554 +633 2590 +633 2781 +633 5556 +633 1993 +633 5056 +633 4809 +633 3658 +633 6092 +633 7800 +633 3541 +633 9693 +633 7013 +633 2407 +633 3324 +633 7276 +633 8559 +633 6121 +633 9080 +633 8828 +634 8840 +634 2827 +634 2828 +634 8207 +634 6167 +634 4508 +634 5278 +634 1189 +634 3499 +634 3764 +634 6204 +634 5053 +634 7875 +634 6855 +634 5960 +634 5772 +634 5326 +634 8800 +634 8803 +634 868 +634 3301 +634 7014 +634 1261 +634 6520 +634 3834 +635 2688 +635 3393 +635 5442 +635 9828 +635 4646 +635 8841 +635 2059 +635 3180 +635 8238 +635 2063 +635 9648 +635 1809 +635 9458 +635 8436 +635 1784 +635 3257 +635 1083 +635 6652 +635 1791 +636 5536 +636 5473 +636 6625 +636 7719 +636 2600 +636 5025 +636 9575 +636 1521 +636 1043 +636 789 +636 8154 +636 7679 +636 2396 +636 4285 +636 3870 +636 3487 +637 8256 +637 2576 +637 9154 +637 4003 +637 8193 +637 2790 +637 9031 +637 3657 +637 7754 +637 2187 +637 4908 +637 3021 +637 9390 +637 7888 +637 9875 +637 7541 +637 9878 +637 1406 +638 9633 +638 1870 +638 9926 +638 5930 +638 2731 +638 5100 +638 3822 +638 1149 +638 5171 +638 820 +638 3861 +638 5175 +638 7832 +638 8059 +638 2204 +638 4349 +639 6661 +639 5900 +639 9358 +639 8336 +639 5526 +639 3871 +639 9894 +639 6057 +639 7086 +639 993 +639 8781 +639 1878 +639 3799 +639 6362 +639 8033 +639 5345 +639 738 +639 5349 +639 3942 +639 3431 +639 4210 +639 8435 +639 7160 +640 7809 +640 8481 +640 4516 +640 8577 +640 2409 +640 1054 +640 1899 +640 4780 +640 5581 +640 4528 +640 2965 +640 9686 +640 5687 +640 1784 +640 7194 +640 4190 +640 3093 +641 3398 +641 1865 +641 3722 +641 3727 +641 4009 +641 4499 +641 9364 +641 2807 +641 1433 +641 1626 +641 9871 +642 1696 +642 5697 +642 4475 +642 6853 +642 8775 +642 6666 +642 3243 +642 1230 +642 1376 +642 1959 +642 2009 +642 9562 +642 4221 +643 8097 +643 867 +643 8467 +643 8137 +643 4492 +643 3373 +643 9324 +643 5298 +643 5491 +643 3028 +643 4668 +643 7711 +644 4289 +644 4290 +644 5162 +644 2148 +644 9285 +644 8904 +644 1002 +644 1247 +644 6365 +644 3441 +644 2195 +644 6069 +644 9846 +644 5592 +644 921 +644 8090 +644 3103 +644 5309 +644 9727 +645 7361 +645 2992 +645 5253 +645 9327 +645 839 +645 6120 +645 5514 +645 2823 +645 781 +645 1103 +645 9264 +645 6699 +645 3443 +645 4628 +645 9261 +645 8301 +645 2107 +645 4858 +645 9566 +645 1343 +646 6368 +646 9057 +646 9315 +646 9126 +646 8582 +646 3399 +646 8553 +646 3754 +646 2251 +646 6454 +646 1731 +646 5650 +646 4803 +646 2453 +646 4598 +646 8185 +646 5945 +646 5372 +646 7839 +647 8308 +647 2914 +647 5796 +647 1541 +647 4390 +647 6855 +647 7560 +647 9962 +647 778 +647 6839 +647 9873 +647 1426 +647 9236 +647 2421 +647 4665 +647 5380 +647 3560 +647 3325 +647 4574 +647 8927 +648 897 +648 5625 +648 1861 +648 3206 +648 8103 +648 8200 +648 4586 +648 2825 +648 2767 +648 2418 +648 8275 +648 7221 +648 7222 +648 3095 +648 4696 +648 2137 +648 2554 +648 1054 +648 2431 +649 2304 +649 7376 +649 8611 +649 8742 +649 2025 +649 5324 +649 3053 +649 2606 +649 5808 +649 1219 +649 7349 +649 3158 +649 739 +649 7000 +649 9209 +649 1850 +649 3515 +649 9948 +649 4702 +649 8021 +650 3520 +650 769 +650 4035 +650 6502 +650 7366 +650 5000 +650 9101 +650 9647 +650 4692 +650 7875 +650 7988 +650 2974 +650 6867 +650 3351 +650 5268 +650 7770 +650 764 +650 2046 +650 8373 +651 9345 +651 6149 +651 9606 +651 4745 +651 2071 +651 2837 +651 2327 +651 2590 +651 2727 +651 8489 +651 7469 +651 9392 +651 2355 +651 3901 +651 8257 +651 1099 +651 1880 +651 7847 +651 5613 +651 4208 +652 5825 +652 8822 +652 9985 +652 2795 +652 3468 +652 5425 +652 6006 +652 2426 +652 4348 +652 6650 +653 896 +653 9993 +653 9876 +653 9877 +653 3879 +653 9512 +653 816 +653 1074 +653 6592 +653 1602 +653 7882 +653 2635 +653 3278 +653 1890 +653 3051 +653 4589 +653 9459 +653 3192 +653 6265 +653 5500 +653 7677 +654 3172 +654 7817 +654 9098 +654 5963 +654 4556 +654 6957 +654 3997 +654 3507 +654 4150 +654 6520 +654 4100 +654 7610 +654 4381 +655 1045 +655 943 +655 3124 +655 3512 +655 1977 +655 6460 +655 9929 +655 7888 +655 1746 +655 5981 +655 5730 +655 4329 +655 6766 +655 5363 +655 8952 +655 3325 +655 9342 +656 4353 +656 4098 +656 5505 +656 8202 +656 6414 +656 3219 +656 8094 +656 5921 +656 4644 +656 7590 +656 4664 +656 9406 +656 3141 +656 6214 +656 9802 +656 7007 +656 9059 +656 4711 +656 6635 +656 4078 +656 7539 +656 9215 +657 3595 +657 9915 +657 4964 +657 1670 +657 8008 +657 8462 +657 911 +657 4336 +657 7875 +657 1844 +657 9422 +657 8027 +657 6878 +658 1120 +658 6950 +658 9575 +658 8808 +658 7292 +658 8906 +658 6783 +658 4015 +658 4528 +658 4177 +658 9685 +658 2169 +658 6009 +658 4665 +658 5115 +658 5596 +658 3901 +658 6590 +658 4767 +659 2944 +659 4226 +659 1032 +659 6921 +659 6924 +659 5517 +659 8725 +659 8346 +659 2853 +659 1318 +659 8253 +659 6220 +659 8405 +659 9051 +659 4572 +659 7645 +659 2530 +659 7790 +659 6394 +659 9979 +660 2308 +660 3343 +660 2068 +660 6433 +660 3491 +660 2089 +660 1322 +660 7980 +660 5679 +660 3770 +660 1723 +660 3773 +660 9412 +660 6740 +660 4570 +660 8283 +660 3551 +660 3259 +660 2532 +660 1265 +660 5362 +660 5880 +661 1056 +661 8770 +661 2628 +661 4422 +661 6387 +661 2986 +661 9655 +661 6159 +661 4208 +661 7249 +661 1799 +661 6035 +661 6517 +661 8950 +661 3898 +661 5213 +662 5601 +662 9442 +662 7011 +662 1829 +662 1479 +662 1802 +662 3851 +662 5196 +662 975 +662 3440 +662 6292 +662 3864 +662 5402 +662 4572 +662 9437 +662 4127 +663 8128 +663 8763 +663 9474 +663 4771 +663 5991 +663 6695 +663 2860 +663 6447 +663 1136 +663 3988 +663 4247 +663 4473 +663 5147 +663 6460 +663 6237 +663 5940 +664 3840 +664 4066 +664 4926 +664 7844 +664 2725 +664 5414 +664 5449 +664 8939 +664 844 +664 5454 +664 1424 +664 6004 +664 6898 +664 2804 +664 7230 +664 6265 +664 3769 +664 2842 +664 3900 +664 2493 +664 1822 +665 2067 +665 9179 +665 8902 +665 2665 +665 6922 +665 8651 +665 814 +665 7667 +665 9617 +665 9106 +665 1427 +665 1310 +665 5112 +665 1843 +665 9178 +665 9915 +665 7710 +666 1632 +666 2177 +666 9379 +666 6276 +666 8517 +666 2630 +666 5767 +666 1706 +666 1511 +666 4332 +666 687 +666 4913 +666 6546 +666 9622 +666 3744 +666 3614 +666 8191 +667 4483 +667 8581 +667 3590 +667 1557 +667 6047 +667 804 +667 9393 +667 947 +667 834 +667 1603 +667 1862 +667 6600 +667 7372 +667 4943 +667 6352 +667 6228 +667 2521 +667 4187 +667 1001 +667 2031 +667 1265 +667 7669 +667 7926 +667 6391 +667 2300 +668 899 +668 4613 +668 9227 +668 9742 +668 8847 +668 2307 +668 6420 +668 3093 +668 7845 +668 3880 +668 5677 +668 1457 +668 8120 +668 6585 +668 2108 +668 5771 +668 8782 +668 4310 +668 8335 +668 4588 +668 9859 +668 5363 +668 2296 +668 9465 +668 2682 +668 2965 +669 4642 +669 2596 +669 8037 +669 3271 +669 7144 +669 6763 +669 4306 +669 8622 +669 4879 +669 5872 +669 7250 +669 6452 +669 2041 +669 6375 +669 7844 +669 6330 +669 1135 +669 3868 +669 7450 +669 3391 +670 1763 +670 6947 +670 9910 +670 6762 +670 1291 +670 9741 +670 3824 +670 5251 +670 3125 +670 8118 +670 1879 +670 7961 +670 7359 +670 6876 +670 1502 +670 9343 +671 4000 +671 9921 +671 1347 +671 6951 +671 5841 +671 9207 +671 4428 +671 1421 +671 5678 +671 8952 +671 9651 +671 9461 +671 9303 +671 7290 +671 8223 +671 698 +671 1717 +672 9603 +672 906 +672 5954 +672 2462 +672 9506 +672 5927 +672 1325 +672 962 +672 6353 +672 8274 +672 8154 +672 8033 +672 1252 +672 6248 +672 1386 +672 8786 +672 5237 +672 6263 +672 6649 +672 8954 +672 3050 +673 7136 +673 3099 +673 9363 +673 4316 +673 8747 +673 1708 +673 6063 +673 3088 +673 8337 +673 6802 +673 8275 +673 7372 +673 1827 +673 4442 +673 4095 +673 3324 +673 895 +674 1154 +674 5507 +674 3208 +674 4875 +674 2192 +674 7059 +674 3220 +674 3033 +674 4763 +674 9119 +674 9893 +674 2819 +674 9277 +674 1475 +674 2252 +674 2388 +674 5625 +674 2265 +674 7775 +674 8672 +674 9844 +674 1397 +674 1143 +674 4345 +674 3194 +674 4094 +675 5793 +675 8388 +675 8357 +675 5062 +675 1735 +675 5192 +675 6439 +675 7374 +675 9556 +675 4854 +675 3160 +675 4660 +675 8635 +676 6228 +676 8321 +676 8611 +676 4708 +676 6128 +676 8337 +676 5192 +676 1736 +676 7472 +676 3952 +676 8232 +676 5139 +676 4308 +676 1397 +676 8609 +676 985 +676 1455 +676 8252 +676 9428 +676 9285 +677 9120 +677 7170 +677 770 +677 3557 +677 4177 +677 3112 +677 1071 +677 8011 +677 9115 +677 3010 +677 1390 +677 5903 +677 1456 +677 1873 +677 5780 +677 6197 +677 6772 +677 922 +677 5179 +677 3198 +677 5087 +678 7426 +678 8069 +678 7694 +678 1556 +678 9239 +678 2330 +678 4890 +678 7976 +678 9642 +678 3115 +678 5808 +678 4278 +678 1722 +678 1215 +678 7749 +678 857 +678 7131 +678 8287 +678 4583 +678 6004 +678 9721 +678 1662 +679 6752 +679 7136 +679 9283 +679 1670 +679 5991 +679 7183 +679 9673 +679 1035 +679 6540 +679 4461 +679 1277 +679 6920 +679 1746 +679 5268 +679 8041 +679 3489 +679 1946 +679 6303 +679 6493 +679 4126 +679 7423 +680 1824 +680 7970 +680 1155 +680 4935 +680 5163 +680 8044 +680 826 +680 7052 +680 3313 +680 1647 +680 6833 +680 787 +680 2516 +680 5237 +680 4310 +680 3386 +680 5563 +681 5696 +681 8289 +681 2722 +681 2307 +681 2118 +681 1446 +681 1511 +681 1398 +681 7497 +681 8298 +681 2923 +681 6156 +681 1248 +681 3219 +681 6740 +681 7606 +681 6199 +681 2476 +681 7996 +681 7242 +681 3303 +682 7424 +682 9346 +682 9603 +682 6794 +682 1169 +682 5652 +682 8597 +682 5782 +682 7065 +682 1435 +682 2850 +682 6826 +682 944 +682 6715 +682 5820 +682 4416 +682 2370 +682 6855 +682 7245 +682 4557 +682 5712 +682 8018 +682 1492 +682 8789 +682 3682 +682 3941 +682 1681 +682 3239 +682 6546 +682 4724 +682 1912 +682 8916 +682 8574 +682 5759 +683 5170 +683 3878 +683 4646 +683 1417 +683 8370 +683 8558 +683 8273 +683 9586 +683 739 +683 7252 +683 5374 +683 9630 +683 6985 +683 9353 +683 8692 +683 3273 +683 7037 +683 8894 +684 8835 +684 2949 +684 9352 +684 7946 +684 1809 +684 6292 +684 5920 +684 9511 +684 9736 +684 9920 +684 7887 +684 9940 +684 4693 +684 9445 +684 7649 +684 1122 +684 6115 +684 8933 +684 1768 +684 7146 +684 4336 +684 7669 +684 8831 +685 1290 +685 8080 +685 7958 +685 2353 +685 7346 +685 7605 +685 6070 +685 7995 +685 7613 +685 5447 +685 5879 +685 3789 +685 4195 +685 3286 +685 5975 +685 3939 +685 6375 +685 6634 +685 2035 +685 1141 +685 1399 +685 889 +685 2427 +686 8160 +686 1281 +686 6015 +686 7360 +686 8293 +686 7590 +686 8263 +686 6664 +686 3404 +686 3256 +686 786 +686 3571 +686 9175 +686 1016 +686 9951 +686 4735 +687 6048 +687 8481 +687 3396 +687 5061 +687 4230 +687 4284 +687 7725 +687 2320 +687 5603 +687 4053 +687 6230 +687 2938 +687 4956 +687 7198 +688 4353 +688 9253 +688 2909 +688 8081 +688 4584 +688 2241 +688 7916 +688 1453 +688 3150 +688 9743 +688 1521 +688 6930 +688 4243 +688 1301 +688 4282 +688 5658 +688 4709 +689 4228 +689 8840 +689 7947 +689 1679 +689 7952 +689 2577 +689 4243 +689 5665 +689 5666 +689 9259 +689 941 +689 6830 +689 9652 +689 4184 +689 5826 +689 1475 +689 9550 +689 9553 +689 9688 +689 8795 +689 4961 +689 3059 +689 7161 +689 5498 +690 6787 +690 8839 +690 9739 +690 8609 +690 803 +690 9893 +690 5430 +690 1976 +690 2367 +690 7620 +690 5576 +690 718 +690 2896 +690 1762 +690 1382 +690 3439 +690 5233 +690 4468 +690 9978 +690 766 +690 9599 +691 9339 +691 2565 +691 5000 +691 9931 +691 9516 +691 2803 +691 2197 +691 6294 +691 9143 +691 1528 +691 1593 +691 7195 +691 4054 +691 4541 +692 4995 +692 7684 +692 5125 +692 9223 +692 5519 +692 2196 +692 8853 +692 9878 +692 9881 +692 4380 +692 1437 +692 3461 +692 1321 +692 6829 +692 4535 +692 3002 +692 2741 +692 1986 +692 7803 +692 7150 +692 4342 +692 6138 +692 4859 +692 8189 +693 4386 +693 5925 +693 4390 +693 2242 +693 7564 +693 7434 +693 1259 +693 3052 +693 2178 +693 2480 +693 7185 +693 3861 +693 5974 +693 4280 +693 5017 +693 2523 +693 7276 +693 8670 +693 4255 +694 3808 +694 7809 +694 9412 +694 8865 +694 1825 +694 4551 +694 1709 +694 7325 +694 5616 +694 7735 +694 5881 +694 2746 +694 6879 +694 3071 +694 4445 +694 6334 +694 2335 +695 9634 +695 3723 +695 4838 +695 9319 +695 4360 +695 5225 +695 8359 +695 1293 +695 5455 +695 8048 +695 1159 +696 3521 +696 6178 +696 5923 +696 1075 +696 5477 +696 9798 +696 2291 +696 6795 +696 1260 +696 1154 +696 8016 +696 6801 +696 4626 +696 7123 +696 7828 +696 8862 +696 1638 +696 9849 +696 1820 +696 9790 +696 2495 +697 5280 +697 6848 +697 1059 +697 7300 +697 8615 +697 3881 +697 8301 +697 6607 +697 8368 +697 4155 +697 6196 +697 5001 +697 4153 +697 4736 +697 3407 +697 1085 +697 2421 +698 9703 +698 5385 +698 1997 +698 8625 +698 7507 +698 8851 +698 2453 +698 6281 +698 2399 +699 9728 +699 6114 +699 1955 +699 8615 +699 1319 +699 8041 +699 9863 +699 5389 +699 4355 +699 5204 +699 6837 +699 9240 +699 827 +699 2443 +699 5541 +700 7744 +700 5316 +700 3302 +700 5574 +700 4871 +700 8841 +700 6765 +700 7278 +700 5485 +700 3376 +700 9426 +700 3027 +700 6068 +700 9897 +700 1746 +700 9820 +700 8766 +700 927 +701 1764 +701 7046 +701 7657 +701 4718 +701 8335 +701 3376 +701 4243 +701 7221 +701 5400 +701 9946 +701 3358 +702 8035 +702 774 +702 9670 +702 8167 +702 4520 +702 7884 +702 1354 +702 8172 +702 7150 +702 2717 +702 1105 +702 9004 +702 9141 +702 8826 +702 7100 +702 4733 +702 9438 +703 8996 +703 9190 +703 7111 +703 3528 +703 8060 +703 845 +703 9134 +703 7759 +703 5328 +703 9384 +703 7790 +703 9880 +703 4601 +703 7002 +703 3452 +703 4413 +704 5504 +704 7812 +704 961 +704 1034 +704 2325 +704 3862 +704 6404 +704 4252 +704 8095 +704 5793 +704 6437 +704 8103 +704 5916 +704 3955 +704 6708 +704 6465 +704 5320 +704 8276 +704 4963 +704 7017 +704 7918 +704 2291 +704 3197 +705 9761 +705 7783 +705 6283 +705 3918 +705 9041 +705 4978 +705 9812 +705 5559 +705 7655 +705 2938 +705 5211 +706 3456 +706 707 +706 9734 +706 1960 +706 5426 +706 2324 +706 791 +706 4443 +706 6043 +706 1342 +707 2171 +707 2148 +707 8997 +707 1671 +707 3977 +707 1035 +707 6797 +707 5277 +707 5115 +707 7291 +707 2006 +707 5370 +707 6619 +707 1757 +707 4571 +707 8005 +708 8483 +708 2730 +708 1769 +708 6730 +708 2411 +708 1742 +708 6967 +708 9437 +708 3187 +708 2901 +708 3993 +708 9688 +708 6963 +708 2845 +708 4223 +709 9185 +709 5154 +709 6467 +709 9860 +709 9670 +709 4842 +709 7490 +709 9741 +709 4430 +709 6900 +709 9814 +709 3778 +709 8538 +709 9309 +709 3466 +709 735 +710 3938 +710 6372 +710 3718 +710 3180 +710 9387 +710 3436 +710 4685 +710 6990 +710 7811 +710 2905 +710 2444 +710 7868 +710 7418 +710 9246 +711 3585 +711 8210 +711 5016 +711 4510 +711 3359 +711 2211 +711 4005 +711 9001 +711 2221 +711 5811 +711 2230 +711 8379 +711 2370 +711 9028 +711 3141 +711 7971 +711 2006 +711 9828 +711 5351 +711 7401 +711 2155 +711 1133 +712 6027 +712 4109 +712 3090 +712 2326 +712 5787 +712 7070 +712 923 +712 4396 +712 6455 +712 1340 +712 9024 +712 6086 +712 9314 +712 7377 +712 8277 +712 7255 +712 9947 +712 6368 +712 6369 +712 6370 +712 1256 +712 1520 +713 6498 +713 9539 +713 1605 +713 3479 +713 8322 +713 2510 +713 4015 +713 5911 +713 7153 +713 3316 +713 2647 +713 6616 +713 8637 +713 7407 +713 4925 +713 9791 +714 6401 +714 9364 +714 9860 +714 7310 +714 2832 +714 6675 +714 3220 +714 3310 +714 2326 +714 8091 +714 8873 +714 2987 +714 8382 +714 5951 +714 1602 +714 6217 +714 3275 +714 5329 +714 1874 +714 2158 +714 1266 +714 5753 +715 2019 +715 4744 +715 5929 +715 6508 +715 8142 +715 2159 +715 1587 +715 6418 +715 4435 +715 9429 +715 1750 +715 3127 +715 7544 +715 7259 +715 6143 +716 9776 +716 1739 +716 8773 +716 6856 +716 7019 +716 9040 +716 7793 +716 3990 +716 5800 +717 3847 +717 906 +717 1678 +717 4163 +717 1814 +717 2721 +717 1187 +717 5669 +717 4907 +717 5807 +717 3443 +717 4919 +717 1091 +717 2886 +717 1771 +717 3784 +717 6091 +717 5723 +717 7140 +717 5222 +717 2027 +717 1651 +717 3832 +717 7163 +718 1805 +718 3470 +718 3730 +718 4630 +718 3867 +718 925 +718 7074 +718 6299 +718 8356 +718 2494 +718 9407 +718 7874 +718 5218 +718 7762 +718 2901 +718 9430 +718 6488 +718 3170 +718 8936 +718 8559 +718 2675 +718 1525 +719 2304 +719 7456 +719 2147 +719 747 +719 2574 +719 7965 +719 4144 +719 2994 +719 7540 +719 2094 +719 3769 +719 3835 +719 7549 +719 7902 +719 8607 +720 7041 +720 8194 +720 5641 +720 2064 +720 3217 +720 9772 +720 7857 +720 3126 +720 6495 +720 9794 +720 6753 +720 3790 +720 5839 +720 7758 +720 1626 +720 2655 +720 2784 +720 4577 +720 7922 +720 9973 +720 3446 +720 7550 +721 2048 +721 2053 +721 8841 +721 7056 +721 4371 +721 1177 +721 9393 +721 4654 +721 4783 +721 4785 +721 1972 +721 1857 +721 7492 +721 9289 +721 2901 +721 8662 +721 5336 +721 9177 +721 8671 +721 8800 +721 3298 +721 8298 +721 4717 +721 883 +721 9982 +721 8533 +722 4357 +722 1292 +722 9492 +722 9368 +722 3482 +722 9244 +722 4128 +722 7719 +722 7848 +722 6569 +722 1835 +722 2096 +722 8369 +722 2107 +722 9405 +722 4032 +722 7378 +722 5078 +722 4706 +722 7146 +722 880 +722 6771 +722 1143 +722 1656 +722 2686 +723 6273 +723 6919 +723 7048 +723 8713 +723 4619 +723 4621 +723 1681 +723 5780 +723 1687 +723 5414 +723 3164 +723 1161 +723 4797 +723 8766 +723 9425 +723 2901 +723 6364 +723 865 +723 3281 +723 4085 +723 4983 +723 4987 +724 9952 +724 9377 +724 962 +724 8515 +724 2724 +724 1445 +724 2662 +724 776 +724 4713 +724 8587 +724 9005 +724 8622 +724 3080 +724 1876 +724 5174 +724 2551 +724 4184 +724 2809 +724 6974 +725 6406 +725 4109 +725 7316 +725 2722 +725 9129 +725 6830 +725 3380 +725 5818 +725 5820 +725 5565 +725 4927 +725 4549 +725 2510 +725 6116 +725 1894 +725 2288 +725 6901 +725 7418 +725 5695 +725 9599 +726 8960 +726 1152 +726 4034 +726 9955 +726 8406 +726 3409 +726 1224 +726 7275 +726 4012 +726 6637 +726 2704 +726 4305 +726 2932 +726 1590 +726 2393 +726 2266 +726 3676 +726 9885 +726 4606 +727 5473 +727 2340 +727 6053 +727 2182 +727 8136 +727 4524 +727 4719 +727 4660 +727 6203 +727 4829 +727 8798 +728 8582 +728 9868 +728 785 +728 6935 +728 8992 +728 7714 +728 6693 +728 7666 +728 953 +728 3778 +728 3139 +728 8278 +728 5214 +728 870 +728 9191 +728 6377 +728 3946 +728 2158 +728 6141 +728 3314 +728 5237 +729 3648 +729 9892 +729 5321 +729 1099 +729 8559 +729 1392 +729 6993 +729 1175 +729 3449 +729 4251 +729 4828 +730 7275 +730 7638 +730 3724 +730 9987 +730 6048 +730 3875 +730 7976 +730 2740 +730 3899 +730 5087 +730 6729 +730 852 +730 4053 +730 2774 +730 7135 +730 6498 +730 8555 +730 4085 +730 9977 +730 7037 +731 4672 +731 2498 +731 8722 +731 1671 +731 6859 +731 3522 +731 6578 +731 6393 +731 9529 +731 7290 +731 9115 +731 4572 +731 1565 +731 9694 +732 3200 +732 1537 +732 2754 +732 1659 +732 1224 +732 8791 +732 9772 +732 3757 +732 4525 +732 1744 +732 1336 +732 5598 +732 5046 +732 9015 +732 1944 +732 9979 +732 1026 +732 830 +733 8449 +733 4241 +733 2576 +733 1297 +733 8477 +733 2219 +733 1964 +733 5058 +733 6987 +733 2253 +733 4309 +733 4054 +733 6881 +733 7650 +733 9062 +733 1425 +733 7912 +733 2418 +733 4984 +733 2174 +734 3745 +734 8646 +734 2151 +734 5512 +734 3113 +734 3819 +734 5004 +734 2504 +734 8755 +734 2772 +734 1302 +734 9911 +734 6233 +734 3514 +734 3547 +734 8313 +734 9822 +735 5122 +735 3723 +735 7317 +735 8601 +735 2971 +735 6362 +735 8350 +735 7839 +735 806 +735 8497 +735 3760 +735 9265 +735 9266 +735 5940 +735 5662 +735 6976 +735 964 +735 3408 +735 3162 +735 5852 +735 5983 +735 8293 +735 4095 +735 8469 +736 4225 +736 1412 +736 7047 +736 5389 +736 4116 +736 7193 +736 3101 +736 5026 +736 9152 +736 9003 +736 6830 +736 9135 +736 3123 +736 3636 +736 2748 +736 7360 +736 9922 +736 7159 +736 4440 +736 7769 +736 881 +736 7539 +736 7669 +736 6903 +737 8547 +737 9188 +737 3749 +737 3094 +737 7754 +737 9803 +737 6038 +737 4912 +737 4785 +737 8122 +737 2100 +737 4726 +737 1561 +737 2516 +737 7060 +737 6812 +737 9434 +737 5631 +738 5632 +738 7064 +738 6279 +738 909 +738 8592 +738 7825 +738 6550 +738 6552 +738 5529 +738 6942 +738 8226 +738 6949 +738 7723 +738 8370 +738 7732 +738 1717 +738 4406 +738 8377 +738 2749 +738 5316 +738 974 +738 1744 +738 3036 +738 3268 +738 8180 +738 4218 +739 1537 +739 6722 +739 2147 +739 9157 +739 5661 +739 2860 +739 1389 +739 3886 +739 3789 +739 8428 +739 8126 +739 8214 +739 6040 +739 4250 +739 4719 +739 3612 +739 8794 +739 8702 +740 8454 +740 2567 +740 7563 +740 4493 +740 2966 +740 2232 +740 3901 +740 6208 +740 1654 +740 4682 +740 9590 +740 5194 +740 7632 +740 4579 +740 5718 +740 1763 +740 7569 +740 1391 +740 5616 +740 5750 +740 6652 +740 8575 +741 4110 +741 915 +741 8980 +741 7585 +741 8879 +741 4403 +741 9398 +741 8120 +741 3772 +741 6717 +741 4799 +741 7750 +741 3657 +741 4578 +741 9955 +741 9963 +741 9200 +741 2164 +741 5751 +741 9727 +742 7971 +742 4113 +742 2792 +742 8809 +742 2986 +742 9209 +742 6225 +742 7282 +742 2431 +742 4116 +742 6839 +742 4168 +742 2900 +742 4539 +742 2076 +742 3133 +742 1919 +743 3461 +743 2442 +743 2196 +743 2966 +743 8344 +743 5532 +743 5155 +743 9765 +743 9776 +743 6451 +743 7991 +743 9919 +743 1730 +743 9163 +743 7250 +743 5283 +743 1364 +743 6229 +743 4587 +743 7157 +743 1399 +743 1144 +743 8185 +744 5890 +744 2281 +744 6498 +744 7924 +744 5720 +744 1853 +744 9791 +745 4611 +745 2948 +745 9223 +745 2953 +745 8975 +745 8726 +745 2970 +745 3355 +745 3104 +745 4642 +745 3243 +745 8367 +745 4405 +745 8508 +745 6215 +745 8268 +745 5201 +745 3796 +745 6997 +745 8288 +745 2769 +745 8681 +745 8299 +745 6771 +745 7925 +745 8822 +746 3684 +746 7562 +746 5355 +746 6094 +746 5679 +746 1555 +746 1715 +746 2195 +746 7640 +747 4960 +747 2496 +747 5667 +747 8199 +747 2796 +747 2186 +747 9196 +747 2417 +747 7123 +747 8213 +747 5206 +747 8090 +747 797 +747 1342 +747 1951 +748 2273 +748 1954 +748 5507 +748 3312 +748 4759 +748 9741 +748 8594 +748 3311 +748 3152 +748 5170 +748 7507 +748 2356 +748 9239 +748 8344 +748 4570 +748 2847 +748 3932 +748 6527 +749 9606 +749 2055 +749 2828 +749 781 +749 1552 +749 8852 +749 2542 +749 8727 +749 2078 +749 1187 +749 8238 +749 6081 +749 2242 +749 5833 +749 8267 +749 2381 +749 5331 +749 6874 +749 3088 +749 7908 +749 8302 +749 3061 +749 1146 +749 1148 +750 6896 +750 1154 +750 5923 +750 9446 +750 8358 +750 6582 +750 4136 +750 5257 +750 2762 +750 3916 +750 5520 +750 6326 +750 4089 +750 6553 +750 8154 +750 7711 +750 3338 +750 3423 +751 3616 +751 7841 +751 1756 +751 9353 +751 9619 +751 9071 +751 5234 +751 6899 +751 2644 +751 1174 +751 9775 +751 1306 +751 1215 +751 6815 +751 3564 +751 1011 +752 2048 +752 4800 +752 2722 +752 4259 +752 3333 +752 8553 +752 7275 +752 2092 +752 6093 +752 4352 +752 6701 +752 1432 +752 7315 +752 4235 +752 5813 +752 8855 +752 9080 +752 3895 +752 7968 +753 5856 +753 9825 +753 4387 +753 9233 +753 8801 +753 1803 +753 3433 +753 5354 +753 4267 +753 4909 +753 8110 +753 1469 +753 9601 +753 5937 +753 4274 +753 7347 +753 1524 +753 6617 +753 6043 +753 2013 +753 1460 +754 6483 +754 5644 +754 3216 +754 3867 +754 2206 +754 7207 +754 3504 +754 7858 +754 4535 +754 8653 +754 851 +754 7770 +754 6875 +754 9440 +754 3751 +754 1519 +754 7891 +755 8866 +755 4134 +755 7046 +755 4881 +755 4553 +755 2921 +755 5584 +755 2673 +755 2550 +755 2711 +755 2942 +756 9222 +756 9548 +756 5099 +756 6796 +756 3374 +756 6353 +756 882 +756 1129 +756 6294 +756 6359 +756 9691 +756 8124 +757 4609 +757 1160 +757 6409 +757 5913 +757 9498 +757 2347 +757 5559 +757 9918 +757 1344 +757 2497 +757 1931 +757 7158 +757 1228 +757 7246 +757 7631 +757 8530 +757 4563 +757 8533 +757 8151 +757 9177 +757 8164 +757 5990 +757 2535 +757 5099 +757 3185 +757 2550 +757 1400 +757 890 +758 2954 +758 9613 +758 1060 +758 7717 +758 4262 +758 7591 +758 1838 +758 5423 +758 817 +758 1077 +758 9738 +758 7496 +758 1100 +758 7502 +758 3107 +758 4059 +758 5869 +758 3575 +758 5499 +758 7422 +759 5376 +759 9986 +759 6981 +759 1449 +759 4492 +759 1650 +759 9583 +759 1394 +759 5171 +759 5389 +759 982 +759 5815 +759 3864 +759 8620 +759 3358 +759 8927 +760 6720 +760 9352 +760 9079 +760 4236 +760 5453 +760 2098 +760 8979 +760 9461 +760 4377 +760 7096 +760 4153 +760 5757 +760 5535 +761 3013 +761 4327 +761 2953 +761 7595 +761 9612 +761 6381 +761 8658 +761 7029 +761 2170 +762 866 +762 6340 +762 2661 +762 9927 +762 4711 +762 5698 +762 6669 +762 2595 +762 6611 +762 4308 +762 3573 +762 7318 +762 5016 +762 985 +762 8132 +762 2215 +762 2078 +762 3231 +763 4416 +763 993 +763 6370 +763 6859 +763 3493 +763 5927 +763 6321 +763 2059 +763 9298 +763 5967 +763 2033 +763 3378 +763 1459 +763 8628 +763 2134 +763 9367 +763 6283 +763 7971 +763 8343 +763 4453 +764 8960 +764 4227 +764 4624 +764 6036 +764 5784 +764 7194 +764 4635 +764 9757 +764 4255 +764 2084 +764 5932 +764 6514 +764 7476 +764 8122 +764 5819 +764 3082 +764 4031 +764 6729 +764 2423 +764 3404 +764 3661 +764 2382 +764 8655 +764 2647 +764 4954 +764 8250 +764 3935 +764 6249 +764 3058 +764 3433 +764 4472 +765 7558 +765 2055 +765 3342 +765 2599 +765 4141 +765 9391 +765 4664 +765 1851 +765 6588 +765 9919 +765 3780 +765 1740 +765 6239 +765 6625 +765 2789 +765 1255 +765 8045 +765 4719 +765 4980 +765 4342 +765 8703 +766 3496 +766 8086 +766 9191 +766 8840 +766 6697 +766 2318 +766 4049 +766 6454 +766 6569 +767 7872 +767 7202 +767 1590 +767 6342 +767 3655 +767 9673 +767 8237 +767 5962 +767 9996 +767 2509 +767 880 +767 2166 +767 6262 +767 1560 +767 1945 +767 1030 +767 1180 +767 9378 +767 6853 +768 8096 +768 8765 +768 1285 +768 3334 +768 9212 +768 3213 +768 6414 +768 4757 +768 7640 +768 6802 +768 4186 +768 7477 +768 8121 +768 2509 +768 9599 +768 8316 +768 1629 +768 6175 +769 5088 +769 1104 +769 4612 +769 3045 +769 4001 +769 8233 +769 9408 +769 4878 +769 4112 +769 2643 +769 3509 +769 8759 +769 7192 +769 5178 +770 8779 +770 9635 +770 8774 +770 4433 +770 5352 +770 1967 +770 3760 +770 6001 +770 3282 +770 5811 +770 2283 +770 4119 +770 4171 +770 7485 +770 2206 +770 9605 +771 2176 +771 4608 +771 9475 +771 5761 +771 6924 +771 4589 +771 3092 +771 4629 +771 1714 +771 6072 +771 4674 +771 5700 +771 5318 +771 4167 +771 8332 +771 9565 +771 3560 +771 9965 +771 7408 +771 2814 +772 8672 +772 5184 +772 7109 +772 8817 +772 5323 +772 1644 +772 3853 +772 9550 +772 1457 +772 4755 +772 3669 +772 1335 +772 1112 +772 2490 +772 6782 +772 9861 +773 896 +773 2569 +773 3212 +773 781 +773 1166 +773 8731 +773 6177 +773 4516 +773 4390 +773 6185 +773 7210 +773 5679 +773 4421 +773 2385 +773 1123 +773 6741 +773 1422 +773 6492 +773 2654 +773 1891 +773 3428 +773 6760 +773 7789 +773 5619 +773 6260 +773 1398 +773 9848 +773 4347 +773 4220 +774 2177 +774 1900 +774 1293 +774 7828 +774 2212 +774 9640 +774 6956 +774 1077 +774 822 +774 5385 +774 6586 +774 5822 +774 8002 +774 7363 +774 4806 +774 2507 +774 9580 +774 8172 +774 6641 +774 2035 +774 8319 +774 1279 +775 5164 +775 3084 +775 5518 +775 3727 +775 2449 +775 3220 +775 9237 +775 2073 +775 8349 +775 1834 +775 9799 +775 3756 +775 3509 +775 1727 +775 4551 +775 6346 +775 2891 +775 4940 +775 9172 +775 8334 +775 8794 +775 5595 +775 9834 +775 2540 +775 4590 +775 5695 +775 3836 +775 2558 +775 7445 +776 4609 +776 1418 +776 5515 +776 5133 +776 4238 +776 7582 +776 4512 +776 2992 +776 5794 +776 7334 +776 2224 +776 2866 +776 3358 +776 8248 +776 8586 +776 5459 +776 7644 +776 6367 +776 7144 +776 7019 +776 9196 +776 9584 +776 7933 +777 7937 +777 4998 +777 5639 +777 1933 +777 8976 +777 5524 +777 9764 +777 6918 +777 3126 +777 4924 +777 3137 +777 5442 +777 1860 +777 4428 +777 4173 +777 8782 +777 4306 +777 6228 +777 6999 +777 1656 +778 3138 +778 1259 +778 8805 +778 8233 +778 8843 +778 2253 +778 5391 +778 9392 +778 9874 +778 1491 +778 5396 +778 4375 +778 6215 +778 7375 +778 8186 +779 2443 +779 4973 +779 7961 +779 4377 +779 3612 +779 928 +779 2729 +779 2991 +779 2381 +779 3919 +779 8401 +779 4562 +779 6355 +779 9430 +779 3416 +779 3535 +779 7904 +779 5612 +779 7917 +779 7540 +779 8182 +779 5885 +780 7137 +780 6083 +780 4836 +780 5350 +780 7848 +780 4668 +780 7466 +780 2891 +780 6892 +780 5202 +780 3759 +780 9488 +780 9616 +780 7956 +780 6064 +780 1783 +780 4617 +780 1340 +780 5949 +780 4382 +781 5411 +781 5670 +781 9607 +781 9660 +781 4599 +781 1325 +781 9574 +781 6773 +781 5591 +781 6968 +781 8378 +781 9787 +781 5791 +781 8286 +781 8319 +782 8288 +782 2529 +782 2884 +782 1889 +782 1288 +782 3596 +782 4238 +782 4175 +782 4976 +782 9203 +782 2366 +782 2743 +782 5371 +782 4412 +782 1790 +783 1408 +783 5507 +783 2582 +783 9498 +783 2080 +783 9635 +783 6948 +783 935 +783 1607 +783 1836 +783 9134 +783 8881 +783 7482 +783 1595 +783 8519 +783 9298 +783 8659 +783 5461 +783 1444 +783 1339 +783 9445 +783 6631 +783 4850 +784 6209 +784 7650 +784 4459 +784 9700 +784 6438 +784 8966 +784 8801 +784 3368 +784 3348 +784 3985 +784 9682 +784 3636 +784 6934 +784 4663 +784 4932 +784 1076 +784 5786 +784 3229 +785 1153 +785 5385 +785 7306 +785 3086 +785 8606 +785 2862 +785 2223 +785 6577 +785 4917 +785 7862 +785 5897 +785 7745 +785 5316 +785 8005 +785 1862 +785 7114 +785 9038 +785 8528 +785 8405 +785 2269 +785 3042 +785 1257 +785 3055 +785 2546 +785 4599 +785 2171 +785 6271 +786 6913 +786 5442 +786 4987 +786 9585 +786 3042 +786 1481 +786 5671 +786 2764 +786 6370 +786 3887 +786 9744 +786 4689 +786 6179 +786 8109 +786 9292 +786 7480 +786 8154 +786 5246 +786 7103 +787 7172 +787 1675 +787 1420 +787 3491 +787 1060 +787 8870 +787 6059 +787 6445 +787 7240 +787 3645 +787 5313 +787 2883 +787 8076 +787 4050 +787 7125 +787 4328 +787 9705 +787 6638 +787 4475 +787 1365 +788 3744 +788 4928 +788 6760 +788 5611 +788 2348 +788 3406 +788 7087 +788 5423 +788 2229 +788 6670 +788 5179 +788 7196 +789 9344 +789 2565 +789 1162 +789 1811 +789 2325 +789 8854 +789 1687 +789 5273 +789 7837 +789 2083 +789 2468 +789 5290 +789 8367 +789 8118 +789 1340 +789 1290 +789 958 +789 7757 +789 3807 +789 6510 +789 3952 +789 2933 +789 2043 +790 6946 +790 9699 +790 3781 +790 7206 +790 5833 +790 6602 +790 2220 +790 1838 +790 1103 +790 5202 +790 2003 +790 8878 +790 1590 +790 5655 +790 3992 +790 9078 +790 5950 +791 2945 +791 1028 +791 1802 +791 9484 +791 4621 +791 4884 +791 5656 +791 7833 +791 2587 +791 9630 +791 8614 +791 9130 +791 9135 +791 2355 +791 3640 +791 5434 +791 5315 +791 7749 +791 1612 +791 4445 +791 8558 +791 3190 +791 7956 +791 8190 +792 4355 +792 4502 +792 8876 +792 5682 +792 3715 +792 8246 +792 1434 +792 8284 +792 5125 +793 6401 +793 7170 +793 9222 +793 9351 +793 9996 +793 9233 +793 6807 +793 3744 +793 2908 +793 6958 +793 943 +793 2747 +793 8511 +793 3525 +793 3402 +793 4811 +793 1869 +793 8398 +793 1244 +793 5488 +793 4593 +793 4084 +794 7427 +794 7052 +794 1431 +794 1370 +794 4010 +794 4653 +794 1131 +794 9780 +794 6197 +794 2444 +794 7888 +794 7257 +794 7768 +794 3546 +794 5980 +794 7650 +794 6632 +794 9066 +794 7275 +794 7661 +794 7413 +794 4214 +795 1825 +795 899 +795 9636 +795 1477 +795 3558 +795 9393 +795 3938 +795 5239 +795 4303 +795 9969 +795 6968 +795 8990 +795 6455 +795 952 +795 9530 +795 5371 +795 2106 +795 6174 +796 7712 +796 4705 +796 6262 +796 9958 +796 7433 +796 8973 +796 7470 +796 7759 +796 2451 +796 8660 +796 3446 +796 2008 +796 2075 +796 1948 +796 2782 +797 9025 +797 1412 +797 3622 +797 9448 +797 1036 +797 2026 +797 2476 +797 6512 +797 2929 +797 3576 +797 2395 +797 7231 +798 9604 +798 1159 +798 6664 +798 7309 +798 7813 +798 5150 +798 2565 +798 2594 +798 6949 +798 5681 +798 4008 +798 2604 +798 5165 +798 4784 +798 6152 +798 4018 +798 5441 +798 1606 +798 1492 +798 1494 +798 4448 +798 4391 +798 6610 +798 7667 +798 6904 +799 4715 +799 6661 +799 9736 +799 5769 +799 5273 +799 6042 +799 2854 +799 5256 +799 2485 +799 3518 +799 7363 +799 7622 +799 4937 +799 3277 +799 2894 +799 4178 +799 1899 +799 6764 +799 8301 +799 9838 +799 7795 +799 8319 +800 9088 +800 2177 +800 9892 +800 4965 +800 9479 +800 7816 +800 3135 +800 4493 +800 5614 +800 7807 +800 1624 +800 5396 +800 9774 +800 2917 +800 2488 +800 6948 +800 3354 +800 7131 +800 2397 +800 2981 +801 7939 +801 6153 +801 7956 +801 1176 +801 7961 +801 6171 +801 7838 +801 8481 +801 987 +801 3111 +801 6447 +801 5425 +801 3643 +801 4412 +801 8259 +801 8524 +801 9687 +801 4699 +801 2399 +801 9449 +801 1518 +801 2159 +801 9971 +801 2937 +801 7421 +801 3967 +802 2400 +802 9633 +802 6754 +802 1766 +802 6340 +802 5782 +802 6310 +802 5065 +802 2282 +802 8201 +802 9070 +802 1967 +802 2129 +802 6098 +802 9140 +802 6926 +802 1174 +802 7546 +802 7087 +802 5917 +803 9582 +803 6017 +803 7874 +803 1059 +803 5379 +803 3432 +803 6217 +803 9490 +803 7948 +803 9442 +803 2607 +803 1987 +803 3799 +803 8250 +803 9342 +804 2177 +804 7682 +804 9349 +804 7873 +804 9864 +804 8078 +804 6559 +804 6176 +804 6945 +804 8104 +804 4650 +804 4481 +804 6964 +804 2231 +804 7614 +804 8129 +804 3906 +804 4803 +804 5323 +804 4815 +804 1616 +804 4179 +804 855 +804 7503 +804 1246 +804 6117 +804 4197 +804 8040 +804 2665 +804 4724 +804 7657 +804 5624 +804 2169 +804 2428 +804 2941 +805 6881 +805 7051 +805 3009 +805 8136 +805 7499 +805 2414 +805 7472 +805 2161 +805 5522 +805 5236 +805 3349 +805 2166 +805 9159 +805 4848 +805 7070 +806 2432 +806 5775 +806 3735 +806 5018 +806 4768 +806 2161 +806 6855 +806 2864 +806 3125 +806 4024 +806 2375 +806 7505 +806 856 +806 7771 +806 7912 +806 1589 +806 1904 +806 1393 +806 3827 +807 9025 +807 2813 +807 9449 +807 9738 +807 1387 +807 2253 +807 4175 +807 4656 +807 3805 +808 6791 +808 909 +808 4931 +808 3479 +808 4376 +808 3993 +808 7582 +808 1568 +808 1580 +808 9006 +808 4783 +808 5552 +808 4918 +808 6970 +808 5187 +808 7625 +808 2890 +808 4365 +808 2641 +808 981 +808 9561 +808 9193 +808 5486 +808 7926 +808 9851 +808 7637 +809 8609 +809 8502 +809 8776 +809 1514 +809 7820 +809 8622 +809 8886 +809 9622 +809 9629 +809 4478 +809 7173 +810 7618 +810 1259 +810 4422 +810 5386 +810 9995 +810 1411 +810 9805 +810 6269 +810 4147 +810 2900 +810 8702 +810 3767 +810 7946 +810 8510 +810 3103 +811 6529 +811 1221 +811 6628 +811 3781 +811 7398 +811 2376 +811 2469 +811 4494 +811 1903 +811 2708 +811 5301 +811 8824 +811 3450 +811 1148 +811 989 +811 2588 +811 4469 +812 9612 +812 8206 +812 2413 +812 7184 +812 6299 +812 6945 +812 5541 +812 3890 +812 6205 +812 2112 +812 7436 +812 2640 +812 5752 +812 3028 +812 8539 +812 1119 +812 7013 +812 5094 +812 2412 +812 1005 +812 1263 +812 8050 +812 2035 +812 5240 +813 2694 +813 3721 +813 3472 +813 8666 +813 8354 +813 9644 +813 4722 +813 943 +813 7987 +813 1205 +813 1464 +813 5947 +813 961 +813 8647 +813 5832 +813 1610 +813 3535 +813 7127 +813 7514 +813 1636 +813 9842 +814 2087 +814 7426 +814 9483 +814 2276 +814 7174 +814 1553 +814 3916 +814 4105 +814 4747 +814 4844 +814 5229 +814 4423 +814 3281 +814 2359 +814 7066 +814 2543 +814 9820 +814 4478 +815 5793 +815 6818 +815 4132 +815 4647 +815 3945 +815 939 +815 3020 +815 2706 +815 2224 +815 8402 +815 2334 +815 5033 +815 2328 +815 3514 +815 2971 +815 4060 +815 2686 +816 8275 +816 2305 +816 2530 +816 8483 +816 8325 +816 1799 +816 8553 +816 6186 +816 3399 +816 976 +816 8785 +816 2339 +816 6673 +816 5527 +816 8153 +816 7842 +816 4913 +816 1790 +816 1189 +817 4356 +817 9989 +817 7689 +817 5258 +817 7566 +817 3730 +817 5273 +817 5533 +817 2079 +817 2091 +817 9004 +817 2733 +817 1717 +817 7096 +817 5693 +817 8258 +817 1741 +817 2872 +817 1785 +817 1372 +817 8289 +817 9061 +817 3306 +817 5240 +817 1273 +817 3069 +818 2945 +818 1294 +818 8208 +818 4245 +818 1686 +818 1178 +818 5559 +818 1348 +818 8135 +818 5751 +818 4557 +818 4046 +818 1637 +818 9703 +818 7276 +818 9070 +818 1775 +818 6131 +818 6772 +818 4087 +818 1278 +818 7551 +819 9736 +819 6927 +819 2067 +819 5781 +819 7065 +819 5548 +819 7797 +819 5811 +819 4661 +819 6847 +819 2244 +819 9807 +819 2906 +819 9871 +819 6240 +819 7781 +819 9702 +819 5483 +819 5487 +819 1137 +819 6803 +819 8821 +819 1022 +820 4998 +820 5255 +820 9225 +820 3469 +820 9744 +820 7577 +820 7333 +820 2992 +820 4595 +820 2358 +820 4279 +820 5068 +820 1500 +820 864 +820 4071 +820 6632 +820 4331 +820 9710 +820 8691 +820 9342 +820 5751 +820 2685 +820 3455 +821 9607 +821 3466 +821 5064 +821 4527 +821 944 +821 1224 +821 1845 +821 3255 +821 6472 +821 4171 +821 5964 +821 3917 +821 9295 +821 3164 +821 6756 +821 2665 +821 7280 +821 8566 +821 8058 +821 4863 +822 6160 +822 9187 +822 7428 +822 3685 +822 6953 +822 4330 +822 4939 +822 8644 +822 7183 +822 5936 +822 7313 +822 1842 +822 9827 +822 3307 +822 8631 +822 5337 +822 5884 +822 2878 +823 2667 +823 2692 +823 5383 +823 8074 +823 2581 +823 9754 +823 5409 +823 7586 +823 1322 +823 7083 +823 5933 +823 9010 +823 5300 +823 7559 +823 6085 +823 4167 +823 6234 +823 4323 +823 7140 +823 8678 +823 7786 +823 9707 +823 2807 +823 7420 +823 4906 +824 4737 +824 8964 +824 3299 +824 1674 +824 5389 +824 6165 +824 8836 +824 3105 +824 2467 +824 1829 +824 9638 +824 5294 +824 2367 +824 7497 +824 4940 +824 9555 +824 2005 +824 3037 +824 3811 +824 7026 +824 6137 +825 5282 +825 8483 +825 1638 +825 1927 +825 2057 +825 1997 +825 5010 +825 8623 +825 1970 +825 3923 +825 5876 +825 5001 +825 6202 +825 7003 +826 1173 +826 5793 +826 1443 +826 1959 +826 9135 +826 1204 +826 2235 +826 4030 +826 8649 +826 3404 +826 3024 +826 6485 +826 2392 +826 7909 +826 3685 +826 1512 +826 2544 +826 2216 +826 6334 +826 8958 +827 9408 +827 1570 +827 3139 +827 6628 +827 3910 +827 4369 +827 4663 +827 1387 +827 5008 +827 2225 +827 5268 +827 5943 +827 7684 +827 3130 +827 7108 +827 7934 +828 7430 +828 1239 +828 7746 +828 9363 +828 2712 +828 5403 +828 2719 +828 7596 +828 5559 +828 4289 +828 5186 +828 8135 +828 9431 +828 7771 +828 5084 +828 1631 +828 1385 +828 8942 +828 9972 +828 4474 +828 2812 +829 6602 +829 5411 +829 4357 +829 1222 +829 8488 +829 1347 +829 1847 +829 3372 +829 6701 +829 9806 +829 3641 +829 4787 +829 5817 +829 8313 +829 7109 +829 3899 +829 8170 +829 3903 +830 4833 +830 6052 +830 8773 +830 7548 +830 6167 +830 9102 +830 3695 +830 9330 +830 4014 +830 1285 +830 5079 +830 7065 +830 6495 +830 9989 +831 4352 +831 5127 +831 1549 +831 1040 +831 1555 +831 1688 +831 1577 +831 9006 +831 1714 +831 9408 +831 4039 +831 8904 +831 2253 +831 3540 +831 2901 +831 9046 +831 3417 +831 9438 +831 2022 +831 5997 +831 7157 +831 5588 +832 2528 +832 6365 +832 8099 +832 6852 +832 8358 +832 5194 +832 2189 +832 974 +832 5342 +832 3217 +832 1202 +832 3102 +832 6198 +832 5048 +832 5498 +832 5276 +832 7581 +832 8543 +833 7044 +833 3719 +833 2827 +833 7453 +833 5791 +833 8352 +833 9122 +833 7587 +833 6823 +833 4016 +833 9400 +833 3003 +833 9927 +833 1614 +833 9043 +833 1243 +833 7902 +833 2911 +833 5872 +833 4978 +833 7540 +833 3832 +833 2302 +834 8937 +834 3906 +834 4355 +834 5509 +834 6919 +834 3144 +834 6731 +834 8237 +834 6127 +834 1513 +834 4147 +834 1718 +834 1655 +834 5304 +834 4475 +834 3167 +835 896 +835 6454 +835 1509 +835 4860 +835 8586 +835 7374 +835 1208 +835 6965 +835 7126 +835 4312 +835 2137 +835 3726 +835 9270 +835 9052 +835 3446 +835 7742 +835 8309 +836 9090 +836 4740 +836 9862 +836 3080 +836 5145 +836 1824 +836 7464 +836 8106 +836 1840 +836 3249 +836 9783 +836 1594 +836 1868 +836 9934 +836 6098 +836 8019 +836 9044 +836 4062 +836 9311 +836 2016 +836 5602 +836 9195 +836 5742 +836 3709 +837 7424 +837 3904 +837 1122 +837 6102 +837 5831 +837 3208 +837 9701 +837 3874 +837 9170 +837 5811 +837 1204 +837 7541 +837 5632 +837 1527 +837 3992 +837 7508 +837 1215 +837 2813 +837 3027 +837 2901 +838 4891 +838 6044 +838 2719 +838 6560 +838 2651 +838 9767 +838 3246 +838 6834 +838 8897 +838 8526 +838 1875 +838 2772 +838 5847 +838 3163 +838 8542 +838 9703 +838 6764 +838 3184 +838 3411 +838 3061 +838 3574 +838 4599 +838 8958 +838 9087 +839 4480 +839 6912 +839 1545 +839 8844 +839 5165 +839 4635 +839 1186 +839 3878 +839 2861 +839 1200 +839 9908 +839 9653 +839 9780 +839 1474 +839 7364 +839 3927 +839 1259 +839 7154 +839 9719 +839 9209 +840 6534 +840 8842 +840 3085 +840 6672 +840 6038 +840 7192 +840 3871 +840 6434 +840 9381 +840 3631 +840 8368 +840 6581 +840 3258 +840 9790 +840 9279 +840 8896 +840 7617 +840 7620 +840 1861 +840 8134 +840 7905 +840 3279 +840 7004 +840 2832 +840 1506 +840 2412 +840 3309 +841 3588 +841 8713 +841 9232 +841 3217 +841 3992 +841 2980 +841 1953 +841 4132 +841 6571 +841 3891 +841 2740 +841 2869 +841 6457 +841 5699 +841 5833 +841 8010 +841 6351 +841 8281 +841 3728 +841 9316 +841 9834 +841 3577 +841 7679 +842 9348 +842 7173 +842 4492 +842 2829 +842 4494 +842 9745 +842 4499 +842 2453 +842 6788 +842 5914 +842 2625 +842 8395 +842 5968 +842 4182 +842 4192 +842 8688 +842 5745 +842 7795 +842 884 +842 4612 +842 6649 +842 3706 +843 5916 +843 6429 +843 2723 +843 6052 +843 9000 +843 6191 +843 3122 +843 5816 +843 1596 +843 1213 +843 5700 +843 7493 +843 8036 +843 7644 +843 8163 +843 1764 +843 4330 +843 5693 +843 8183 +843 7292 +843 5994 +844 1537 +844 2338 +844 7935 +844 1573 +844 9196 +844 7309 +844 1325 +844 5457 +844 5938 +844 2580 +844 917 +844 8026 +844 1087 +844 9359 +844 6757 +845 9495 +845 6212 +845 8006 +845 1640 +845 3755 +845 1842 +845 3060 +845 3294 +845 5398 +845 6935 +845 1460 +845 6650 +845 8379 +845 7718 +845 4670 +846 9266 +846 2566 +846 5021 +846 1185 +846 5542 +846 5799 +846 6189 +846 2098 +846 3382 +846 8762 +846 956 +846 5574 +846 9929 +846 9549 +846 8024 +846 9636 +846 3682 +846 9321 +846 2538 +846 3565 +846 4336 +846 6516 +846 7285 +846 9721 +846 5499 +847 9221 +847 9108 +847 8597 +847 8214 +847 1179 +847 2076 +847 8863 +847 5026 +847 2211 +847 7205 +847 4411 +847 6211 +847 1992 +847 2765 +847 1106 +847 4439 +847 8027 +847 6236 +847 2911 +847 1260 +847 4722 +847 8058 +847 5372 +847 8317 +847 2709 +848 4359 +848 3976 +848 4855 +848 6289 +848 2366 +848 4514 +848 6439 +848 8327 +848 1842 +848 1203 +848 7604 +848 5302 +848 7476 +848 5566 +848 6337 +848 4418 +848 3319 +848 8781 +848 5710 +848 2935 +848 2404 +848 6629 +848 5483 +848 5229 +848 7280 +848 5749 +848 1270 +848 887 +848 8955 +849 2722 +849 1443 +849 1284 +849 933 +849 3409 +849 7625 +849 5962 +849 6595 +849 4844 +849 9453 +849 3921 +849 3555 +849 7395 +849 9545 +849 9580 +849 6543 +849 7132 +849 2527 +850 3099 +850 9457 +850 8402 +850 9129 +850 1034 +850 8460 +850 4498 +850 6510 +850 9935 +850 7344 +850 8017 +850 9458 +850 7668 +850 6836 +850 8827 +850 5982 +851 4353 +851 7046 +851 7815 +851 2317 +851 1936 +851 5009 +851 9490 +851 8344 +851 8346 +851 2717 +851 3497 +851 1962 +851 4056 +851 4922 +851 1375 +851 3041 +851 4587 +851 3697 +851 5874 +851 8873 +851 8318 +851 3327 +852 6278 +852 1802 +852 5388 +852 7836 +852 5288 +852 4905 +852 4979 +852 6075 +852 3772 +852 1091 +852 5710 +852 1108 +852 8927 +852 4071 +852 1896 +852 7793 +852 4210 +852 4467 +853 4456 +853 3906 +853 2536 +853 4327 +853 2250 +853 9485 +853 878 +853 8334 +853 7601 +853 6738 +853 4435 +853 1006 +853 9719 +853 1486 +853 1370 +853 4572 +853 2237 +853 8319 +854 2048 +854 5857 +854 6755 +854 5136 +854 8997 +854 2811 +854 8545 +854 8711 +854 1129 +854 1578 +854 5001 +854 3145 +854 5492 +854 8310 +854 3209 +854 7899 +854 9481 +854 9085 +855 3650 +855 3363 +855 1125 +855 3432 +855 7593 +855 7082 +855 7565 +855 1070 +855 5512 +855 8306 +855 9011 +855 7732 +855 3799 +855 4312 +855 7897 +855 7967 +856 2274 +856 5763 +856 8133 +856 2161 +856 4457 +856 4071 +856 3757 +856 9614 +856 9423 +856 7088 +856 6642 +856 915 +856 2932 +856 7497 +856 9051 +856 1084 +856 4125 +856 8222 +856 5541 +857 5139 +857 8715 +857 4854 +857 8071 +857 7016 +857 938 +857 8267 +857 1512 +857 9714 +857 7859 +857 5206 +857 2360 +857 2201 +857 4251 +857 8479 +858 2818 +858 9574 +858 9962 +858 1771 +858 3406 +858 6191 +858 6058 +858 2770 +858 4659 +858 9396 +858 7605 +858 2478 +858 4855 +858 6708 +858 7731 +858 1514 +859 6736 +859 6727 +859 3592 +859 7209 +859 1162 +859 3214 +859 3792 +859 6418 +859 7124 +859 1749 +859 4024 +859 8633 +859 6234 +859 3515 +859 5565 +860 9024 +860 7201 +860 5218 +860 5339 +860 2790 +860 6753 +860 7051 +860 5698 +860 3949 +860 9587 +860 5812 +860 920 +860 4985 +860 3387 +860 2141 +861 7810 +861 9738 +861 8715 +861 6412 +861 5268 +861 1045 +861 9112 +861 4126 +861 8229 +861 5036 +861 1965 +861 3126 +861 3898 +861 3261 +861 8384 +861 9923 +861 2502 +861 6735 +861 6358 +861 988 +861 7135 +861 4716 +861 2427 +862 5856 +862 5312 +862 6499 +862 3820 +862 5286 +862 2855 +862 7689 +862 6539 +862 7246 +862 4910 +862 9202 +862 9550 +862 4247 +862 4058 +862 4314 +862 1973 +863 8601 +863 9249 +863 4581 +863 5642 +863 8013 +863 3119 +863 8592 +863 8785 +863 9811 +863 2197 +863 9366 +863 1081 +863 5944 +863 8185 +863 1850 +863 4923 +863 9692 +863 1002 +863 4408 +864 7176 +864 8585 +864 5134 +864 8366 +864 9883 +864 8609 +864 3118 +864 6703 +864 4536 +864 9661 +864 5957 +864 5830 +864 5709 +864 8145 +864 3675 +864 9956 +864 1917 +864 6634 +864 9323 +864 1519 +864 1144 +864 9852 +864 5117 +864 6526 +864 8831 +865 7329 +865 994 +865 3267 +865 6759 +865 3401 +865 2414 +865 3376 +865 7473 +865 1523 +865 8675 +865 8341 +865 2166 +865 1065 +865 1434 +865 1563 +865 9148 +866 2180 +866 1549 +866 1560 +866 3097 +866 2459 +866 8862 +866 2852 +866 1958 +866 3240 +866 6067 +866 9529 +866 9280 +866 5579 +866 9540 +866 6694 +866 3412 +866 6235 +866 5728 +866 8420 +866 8998 +866 9845 +866 4598 +866 8952 +867 5952 +867 2113 +867 5731 +867 3265 +867 5064 +867 7465 +867 7306 +867 7534 +867 5807 +867 5520 +867 7569 +867 1107 +867 3254 +867 6921 +867 1776 +868 3104 +868 4160 +868 2723 +868 5605 +868 8937 +868 1386 +868 6508 +868 2862 +868 7864 +868 4246 +868 6999 +868 8410 +868 7417 +868 3868 +868 1114 +868 926 +869 2336 +869 7046 +869 7079 +869 8103 +869 1710 +869 6653 +869 7857 +869 3219 +869 9429 +869 4182 +869 8312 +869 3869 +869 2003 +870 2305 +870 9988 +870 5258 +870 1295 +870 5008 +870 8088 +870 1948 +870 2461 +870 5023 +870 3119 +870 6967 +870 3257 +870 2235 +870 4807 +870 4041 +870 3531 +870 3413 +870 3033 +870 6369 +870 6638 +870 3443 +871 1805 +871 3342 +871 918 +871 8988 +871 7328 +871 3240 +871 3755 +871 9136 +871 7221 +871 8123 +871 5313 +871 6595 +871 9671 +871 6734 +871 5203 +871 5333 +871 6238 +871 7264 +871 8678 +871 5606 +871 6251 +871 1788 +871 7550 +871 4223 +872 7937 +872 1570 +872 1093 +872 9473 +872 7265 +872 1832 +872 7020 +872 2250 +872 4363 +872 3629 +872 1166 +872 5870 +872 8630 +872 4088 +872 9371 +872 7708 +872 5822 +872 6015 +873 8066 +873 3210 +873 6888 +873 2839 +873 2222 +873 8764 +873 9661 +873 6596 +873 1096 +873 8139 +873 8272 +873 8696 +873 7253 +873 6744 +873 2013 +873 9446 +873 5864 +873 2665 +873 1771 +873 2417 +873 4339 +873 9589 +873 3958 +873 8184 +873 6015 +874 1120 +874 8608 +874 4548 +874 2357 +874 3014 +874 8796 +874 9806 +874 8624 +874 9777 +874 4988 +874 4019 +874 4980 +874 2229 +874 8983 +874 5432 +874 1796 +874 6394 +874 2684 +874 8607 +875 1152 +875 9763 +875 7109 +875 3153 +875 1544 +875 5035 +875 8878 +875 3025 +875 4963 +875 1300 +875 3902 +875 1050 +875 3421 +875 8017 +875 6641 +876 3104 +876 2369 +876 9291 +876 7356 +876 8581 +876 7964 +876 7114 +876 5547 +876 6514 +876 1052 +876 2159 +876 5842 +876 6931 +876 4630 +876 5978 +876 7004 +876 9765 +877 8992 +877 5987 +877 5402 +877 1513 +877 3178 +877 5227 +877 9245 +877 4848 +877 2808 +877 1554 +877 4181 +877 8727 +877 6519 +877 4408 +877 6745 +877 2525 +877 3256 +877 924 +878 5220 +878 4202 +878 7435 +878 4556 +878 3762 +878 7629 +878 7153 +878 6386 +878 3187 +878 886 +878 6003 +878 6877 +878 6677 +879 9055 +879 3265 +879 6227 +879 3461 +879 8598 +879 6663 +879 7628 +879 4854 +879 7922 +879 2835 +879 9939 +879 2167 +879 5786 +879 8539 +879 4735 +880 6178 +880 6811 +880 3272 +880 4141 +880 7054 +880 8077 +880 5744 +880 6097 +880 3733 +880 7447 +880 7609 +880 1615 +880 8251 +880 8060 +881 7874 +881 2114 +881 8101 +881 5639 +881 3341 +881 7426 +881 3533 +881 7375 +881 9137 +881 9605 +881 5396 +881 5976 +881 4249 +881 8653 +881 4605 +881 8992 +882 2829 +882 9615 +882 5905 +882 3221 +882 5401 +882 6059 +882 4909 +882 4144 +882 3893 +882 3388 +882 7876 +882 8134 +882 7755 +882 8440 +882 8791 +882 6872 +882 989 +882 9956 +882 3047 +882 8940 +882 6766 +882 3441 +882 9842 +882 4471 +882 7544 +882 7676 +882 6143 +883 7911 +883 4887 +883 6539 +883 1407 +883 5172 +883 4981 +883 3415 +883 9402 +883 1115 +883 2750 +883 8383 +884 4609 +884 9602 +884 6661 +884 9478 +884 1165 +884 3729 +884 9874 +884 9385 +884 2354 +884 3768 +884 9412 +884 8782 +884 3024 +884 9810 +884 7265 +884 6801 +884 5756 +884 2044 +884 9854 +885 5513 +885 6032 +885 8724 +885 3739 +885 5021 +885 2078 +885 5151 +885 4384 +885 8353 +885 8483 +885 4900 +885 9382 +885 7335 +885 5417 +885 5300 +885 7989 +885 9225 +885 4152 +885 8543 +885 6464 +885 2371 +885 5574 +885 7246 +885 6227 +885 6616 +885 5595 +885 6751 +885 8298 +885 4007 +885 6393 +886 2656 +886 6945 +886 8386 +886 3962 +886 6638 +886 2639 +886 4240 +886 5266 +886 1268 +886 6038 +886 5241 +886 3513 +886 1615 +886 1695 +886 8924 +886 5108 +886 8094 +886 1599 +887 3392 +887 8048 +887 6373 +887 7877 +887 6441 +887 8714 +887 4535 +887 8750 +887 4156 +887 5811 +887 1815 +887 5051 +887 7740 +888 4996 +888 9221 +888 7174 +888 6543 +888 4752 +888 8476 +888 3243 +888 1710 +888 1847 +888 5177 +888 9146 +888 3904 +888 4038 +888 6728 +888 7506 +888 1877 +888 3158 +888 4442 +888 1551 +888 4581 +888 6882 +888 3813 +888 1129 +888 7535 +889 9251 +889 8773 +889 2828 +889 6407 +889 8680 +889 1769 +889 4651 +889 4844 +889 7325 +889 8936 +889 5938 +889 9388 +889 8252 +889 3612 +889 959 +890 3328 +890 6914 +890 8804 +890 9701 +890 5802 +890 7947 +890 3567 +890 4145 +890 9363 +890 9332 +890 2197 +890 7030 +890 3407 +890 7165 +890 6686 +891 4864 +891 2051 +891 9874 +891 4015 +891 9778 +891 1720 +891 9785 +891 9151 +891 8768 +891 3393 +891 4298 +891 2386 +891 1749 +891 6103 +891 8552 +891 1643 +891 2156 +891 1907 +891 6644 +891 4216 +891 3452 +892 8705 +892 7812 +892 3334 +892 1345 +892 2186 +892 9105 +892 6164 +892 9757 +892 4010 +892 5037 +892 3503 +892 3891 +892 2378 +892 7873 +892 7242 +892 6093 +892 1231 +892 3280 +892 9688 +892 4448 +892 7521 +892 1252 +892 5865 +892 1517 +892 8559 +892 6518 +892 2683 +893 8533 +893 9735 +893 5165 +893 9752 +893 6940 +893 9073 +893 7196 +893 6573 +893 5554 +893 9971 +893 8761 +893 8643 +893 2629 +893 5318 +893 2635 +893 8397 +893 6226 +893 4693 +893 7639 +893 7641 +893 2906 +893 3297 +893 2797 +893 6397 +893 1523 +893 2680 +893 5501 +893 2687 +894 4262 +894 3942 +894 8817 +894 4620 +894 7378 +894 9454 +894 4657 +894 2962 +894 3475 +894 7060 +894 1749 +894 9142 +894 8375 +894 2040 +894 7710 +894 3646 +895 7813 +895 3462 +895 1474 +895 7054 +895 8850 +895 8343 +895 8411 +895 6066 +895 7347 +895 3520 +895 6850 +895 6903 +895 7755 +895 3532 +895 6479 +895 2512 +895 6865 +895 9179 +895 3420 +895 8289 +895 6636 +895 6257 +895 6291 +895 8437 +895 3575 +896 9344 +896 5772 +896 7310 +896 2456 +896 6552 +896 7584 +896 3489 +896 4387 +896 9000 +896 2864 +896 9138 +896 7091 +896 6453 +896 1719 +896 9657 +896 4158 +896 6207 +896 1227 +896 4939 +896 3086 +896 1110 +896 1111 +896 2010 +896 8667 +896 8028 +896 3166 +896 7140 +896 2923 +896 7411 +896 5364 +896 9468 +896 7294 +896 8703 +897 2657 +897 6658 +897 6948 +897 2085 +897 1735 +897 5899 +897 9742 +897 3374 +897 9640 +897 7892 +897 5678 +897 9753 +897 5684 +897 9786 +897 3519 +897 9114 +897 8862 +897 1503 +898 3584 +898 7319 +898 6413 +898 7641 +898 3226 +898 8220 +898 3359 +898 5025 +898 8114 +898 4931 +898 8993 +898 5076 +898 7768 +898 6745 +898 4955 +898 5212 +898 8033 +898 2913 +898 8034 +898 7399 +898 5225 +898 8938 +898 6904 +898 4349 +899 3683 +899 8826 +899 8006 +899 1895 +899 2567 +899 4556 +899 9549 +899 5784 +899 2627 +899 3507 +899 9524 +899 1910 +899 7446 +899 8551 +899 8696 +899 3257 +899 4986 +899 4670 +900 9664 +900 6946 +900 8454 +900 6057 +900 5386 +900 1261 +900 2862 +900 9053 +900 8816 +900 9876 +900 2381 +900 1993 +900 4650 +901 3328 +901 4878 +901 9251 +901 3269 +901 1958 +901 7143 +901 3112 +901 6665 +901 9290 +901 6375 +901 941 +901 7022 +901 5167 +901 2128 +901 2454 +901 9496 +901 7802 +901 9514 +901 6493 +901 4734 +902 6748 +902 8065 +902 2795 +902 9702 +902 6822 +902 7785 +902 2218 +902 1323 +902 7789 +902 7314 +902 3315 +902 5462 +902 3833 +902 8985 +902 7098 +902 6876 +902 4458 +902 8287 +903 4610 +903 3561 +903 3082 +903 6285 +903 2542 +903 3888 +903 3603 +903 8085 +903 4055 +903 8312 +903 5786 +903 1149 +903 1749 +904 6176 +904 6497 +904 7748 +904 3205 +904 3687 +904 1289 +904 4554 +904 6743 +904 6741 +904 5161 +904 9943 +904 5793 +904 4893 +905 9988 +905 4744 +905 7695 +905 8859 +905 4380 +905 5278 +905 2607 +905 6448 +905 4360 +905 8882 +905 9655 +905 1720 +905 2106 +905 1990 +905 9809 +905 6357 +905 3944 +905 3951 +905 4467 +905 3448 +905 6777 +905 8661 +906 5763 +906 9605 +906 5127 +906 6920 +906 8204 +906 7569 +906 6682 +906 4635 +906 5148 +906 4638 +906 9251 +906 7207 +906 2728 +906 3757 +906 5432 +906 7366 +906 6478 +906 1622 +906 8412 +906 9192 +906 3819 +906 6254 +906 5624 +907 1379 +907 3716 +907 3718 +907 3865 +907 7213 +907 2830 +907 3686 +907 3605 +907 4279 +907 7711 +907 2297 +907 922 +907 3227 +907 6077 +907 7838 +907 2303 +908 4416 +908 9442 +908 3235 +908 1252 +908 4489 +908 5511 +908 7688 +908 5004 +908 6156 +908 7950 +908 2192 +908 4099 +908 5269 +908 4697 +908 7321 +908 4932 +908 2618 +908 5119 +908 2101 +908 9685 +909 7626 +909 8808 +909 1577 +909 9898 +909 7223 +909 9263 +909 7254 +909 3895 +909 8346 +909 6365 +909 6078 +909 5279 +910 8448 +910 9985 +910 2134 +910 8838 +910 2311 +910 3852 +910 1679 +910 6160 +910 1042 +910 2206 +910 1577 +910 1967 +910 945 +910 7351 +910 6077 +910 8384 +910 8130 +910 3013 +910 1990 +910 2386 +910 1876 +910 5974 +910 2784 +910 3555 +910 8509 +910 3570 +911 7265 +911 1634 +911 7555 +911 6181 +911 8519 +911 2535 +911 7106 +911 7470 +911 8594 +911 4756 +911 7028 +911 1397 +911 1368 +911 7929 +911 2589 +911 5310 +912 2176 +912 5121 +912 6914 +912 5380 +912 9229 +912 5010 +912 2836 +912 8647 +912 3887 +912 4405 +912 6200 +912 7867 +912 2109 +912 7486 +912 4416 +912 5955 +912 2375 +912 1109 +912 7511 +912 7398 +912 9832 +912 6250 +912 9790 +912 5502 +913 2448 +913 3185 +913 1735 +913 6679 +913 5964 +913 9322 +913 9707 +913 5612 +913 9166 +913 2671 +913 1616 +913 8657 +913 4236 +913 7860 +913 4373 +913 5417 +913 5988 +913 3817 +913 8724 +913 9438 +914 2694 +914 1424 +914 4632 +914 5535 +914 3108 +914 7409 +914 1450 +914 6066 +914 5185 +914 7117 +914 8273 +914 8147 +914 5211 +914 3427 +914 5093 +914 7398 +914 1255 +914 2282 +914 9456 +914 9073 +914 6388 +914 8060 +915 8192 +915 2530 +915 9315 +915 3815 +915 7656 +915 4361 +915 6250 +915 9805 +915 6191 +915 7665 +915 9010 +915 8035 +915 3227 +915 1929 +915 1242 +915 9371 +915 1738 +915 6783 +916 3339 +916 3960 +916 6938 +916 7453 +916 3746 +916 4644 +916 1331 +916 2892 +916 5586 +916 6998 +916 6877 +916 8160 +916 5352 +916 1258 +916 9579 +916 6899 +916 3444 +916 5624 +917 6817 +917 8612 +917 1509 +917 8230 +917 8125 +917 4972 +917 2637 +917 9453 +917 8818 +917 3373 +917 3671 +917 2520 +917 2916 +917 5690 +917 1594 +917 9055 +918 3424 +918 1185 +918 3810 +918 2149 +918 9222 +918 6839 +918 3467 +918 2092 +918 2541 +918 976 +918 7585 +918 3539 +918 4821 +918 4215 +918 4602 +918 1143 +918 3679 +919 6307 +919 1220 +919 3621 +919 998 +919 7207 +919 9774 +919 2544 +919 6001 +919 4324 +919 8926 +919 4119 +919 9369 +919 4473 +919 5786 +919 1883 +919 8157 +919 4062 +919 8479 +920 3329 +920 7995 +920 5893 +920 9575 +920 1001 +920 9319 +920 3475 +920 2565 +920 2127 +920 7219 +920 1268 +920 9975 +920 7576 +920 8537 +920 9114 +920 6431 +920 9343 +921 2993 +921 2691 +921 6694 +921 5094 +921 9351 +921 1320 +921 5548 +921 9101 +921 9390 +921 4623 +921 3765 +921 1522 +921 3443 +921 7188 +921 5493 +921 7863 +921 8420 +921 7519 +921 9085 +921 1759 +922 3362 +922 5581 +922 3438 +922 3695 +922 5616 +922 9496 +922 5909 +922 5462 +922 5304 +922 6047 +923 2294 +923 5541 +923 3014 +923 1383 +923 9257 +923 9420 +923 8909 +923 5245 +923 3443 +923 5109 +923 7670 +923 7946 +924 8711 +924 1929 +924 7952 +924 7441 +924 1170 +924 6297 +924 8091 +924 1309 +924 7200 +924 4891 +924 6708 +924 7222 +924 1848 +924 6710 +924 1990 +924 4172 +924 3410 +924 2136 +924 8956 +924 1023 +925 7808 +925 8665 +925 2228 +925 5732 +925 8582 +925 4263 +925 4729 +925 9481 +925 2841 +925 9007 +925 1072 +925 4488 +925 2772 +925 7785 +925 1339 +925 2908 +925 1012 +926 9350 +926 2952 +926 1676 +926 8471 +926 2713 +926 7066 +926 1448 +926 7861 +926 5817 +926 3517 +926 4033 +926 3650 +926 5955 +926 7638 +926 1500 +926 1895 +926 2162 +926 2810 +927 2432 +927 8832 +927 2184 +927 2828 +927 1677 +927 4880 +927 9878 +927 9113 +927 1309 +927 2207 +927 9252 +927 4778 +927 1195 +927 9783 +927 4024 +927 2119 +927 974 +927 4049 +927 5721 +927 5466 +927 6370 +927 6374 +927 2035 +927 7594 +927 7678 +927 4607 +928 4111 +928 7061 +928 9496 +928 2841 +928 4763 +928 4508 +928 2336 +928 3243 +928 4525 +928 3758 +928 6453 +928 2742 +928 7483 +928 9660 +928 8765 +928 2366 +928 8000 +928 2514 +928 4821 +928 7259 +928 9316 +928 6374 +928 6249 +928 5611 +928 2494 +928 8441 +928 9595 +929 9606 +929 7438 +929 1944 +929 9114 +929 3760 +929 3883 +929 6704 +929 7859 +929 3515 +929 4802 +929 8389 +929 6728 +929 7755 +929 3537 +929 9042 +929 3795 +929 9559 +929 1254 +929 6250 +929 7155 +929 2807 +930 6150 +930 3467 +930 4501 +930 1051 +930 2205 +930 9505 +930 7339 +930 5810 +930 1139 +930 8247 +930 5825 +930 6088 +930 3787 +930 5326 +930 3690 +930 2796 +930 2291 +930 4344 +930 7929 +930 1276 +930 3733 +931 4897 +931 8610 +931 8811 +931 2084 +931 6950 +931 3815 +931 8008 +931 6768 +931 9163 +931 4693 +931 7088 +931 4401 +931 5266 +931 3155 +931 3284 +931 2613 +931 2615 +931 9081 +931 4574 +931 6391 +932 5637 +932 6918 +932 7047 +932 5897 +932 9230 +932 9489 +932 4631 +932 7836 +932 4649 +932 9899 +932 7472 +932 6708 +932 9655 +932 1083 +932 7869 +932 8949 +932 1088 +932 6338 +932 6215 +932 1483 +932 6610 +932 7260 +932 2017 +932 1897 +932 8819 +932 4085 +932 2939 +933 1569 +933 7205 +933 5002 +933 6315 +933 1165 +933 8015 +933 2544 +933 2129 +933 1106 +933 6324 +933 5229 +933 3703 +933 9172 +933 4474 +933 2623 +933 8586 +933 1471 +934 9824 +934 5860 +934 9158 +934 9148 +934 2731 +934 8876 +934 8817 +934 7347 +934 3349 +934 4312 +934 6857 +934 7384 +934 6521 +934 6618 +934 9499 +934 6908 +934 3001 +934 5139 +935 1415 +935 6416 +935 7060 +935 2966 +935 1049 +935 1821 +935 9758 +935 4521 +935 1578 +935 6319 +935 2993 +935 3641 +935 6589 +935 2238 +935 3146 +935 7893 +935 2154 +935 6383 +935 6521 +935 8830 +936 8128 +936 1920 +936 9379 +936 6085 +936 3144 +936 4430 +936 5935 +936 8592 +936 8338 +936 6740 +936 6974 +936 5750 +936 6939 +936 8092 +936 1950 +937 1284 +937 9103 +937 2584 +937 1053 +937 3742 +937 3107 +937 1065 +937 5546 +937 3632 +937 9267 +937 7860 +937 1720 +937 7232 +937 6341 +937 5973 +937 8152 +937 2654 +937 9253 +937 1125 +937 8041 +937 7793 +937 7666 +937 3836 +938 3714 +938 8964 +938 8837 +938 1034 +938 9613 +938 8341 +938 1561 +938 8989 +938 2854 +938 8796 +938 1965 +938 4019 +938 4414 +938 8773 +938 2376 +938 7634 +938 2140 +938 2918 +938 9575 +938 5999 +938 9564 +938 2430 +939 7264 +939 6883 +939 4349 +939 3516 +939 2094 +939 8499 +939 1028 +939 3771 +939 1052 +939 1405 +939 1214 +939 5535 +940 3333 +940 1423 +940 9360 +940 1624 +940 3094 +940 4645 +940 2473 +940 2218 +940 7980 +940 4020 +940 3638 +940 4407 +940 7108 +940 4406 +940 4813 +940 8024 +940 5721 +940 5085 +940 4961 +940 6770 +940 3197 +941 5152 +941 4927 +941 6587 +941 2724 +941 1445 +941 2758 +941 7688 +941 4031 +941 1501 +941 6094 +941 2813 +941 8879 +941 3090 +941 7699 +941 9013 +941 2842 +941 5851 +941 8474 +941 2117 +942 6787 +942 9348 +942 5513 +942 8338 +942 8083 +942 7064 +942 2851 +942 9905 +942 2480 +942 4657 +942 1715 +942 5310 +942 1616 +942 2897 +942 4435 +942 4055 +942 7265 +942 3816 +942 2544 +942 2808 +942 5119 +943 8320 +943 7045 +943 8838 +943 2955 +943 1561 +943 1817 +943 4442 +943 6312 +943 7342 +943 9530 +943 1215 +943 6592 +943 1474 +943 6746 +943 6108 +943 8426 +943 5229 +943 2162 +943 2679 +944 7560 +944 6025 +944 1930 +944 1933 +944 2449 +944 5743 +944 6431 +944 1058 +944 5156 +944 3114 +944 7862 +944 2622 +944 3777 +944 8909 +944 1232 +944 1619 +944 8148 +944 2009 +944 6363 +944 2660 +944 1256 +944 1258 +944 4335 +944 8306 +944 6772 +945 1293 +945 8976 +945 5526 +945 9623 +945 4776 +945 8111 +945 9265 +945 9414 +945 8265 +945 6477 +945 7511 +945 6489 +945 9054 +945 9707 +945 8685 +945 2365 +945 3957 +945 1529 +945 4986 +945 3579 +945 4988 +946 7046 +946 6663 +946 1550 +946 5677 +946 1055 +946 2477 +946 1967 +946 2865 +946 2226 +946 4277 +946 7607 +946 6973 +946 6594 +946 9286 +946 4111 +946 4169 +946 1740 +946 3150 +946 2515 +946 8539 +946 2658 +946 2918 +946 3955 +946 2678 +946 1401 +946 3069 +947 9216 +947 7824 +947 2423 +947 9574 +947 6992 +947 7240 +947 970 +947 7319 +947 1998 +947 2479 +947 3664 +947 8008 +947 4343 +947 8088 +947 7513 +947 2490 +947 4382 +947 6719 +948 7040 +948 6518 +948 4706 +948 6565 +948 2502 +948 5064 +948 2495 +948 9229 +948 1678 +948 4399 +948 7602 +948 9826 +948 9525 +948 8375 +948 7000 +948 8795 +948 1790 +948 3167 +949 1920 +949 9345 +949 9991 +949 3467 +949 7955 +949 5792 +949 3234 +949 9635 +949 9906 +949 7239 +949 1281 +949 3922 +949 1366 +949 7000 +949 4441 +949 2426 +949 2147 +949 8549 +949 6246 +949 3181 +949 6388 +949 4341 +949 5754 +949 8571 +950 6080 +950 3169 +950 3724 +950 5508 +950 6278 +950 3494 +950 6881 +950 6313 +950 8170 +950 9931 +950 3148 +950 4654 +950 7663 +950 5392 +950 6867 +950 4660 +950 6677 +950 3286 +950 9094 +950 1423 +951 9953 +951 1739 +951 3219 +951 7557 +951 7847 +951 5512 +951 2954 +951 9463 +951 9009 +951 8178 +951 7731 +951 7395 +951 5335 +951 1528 +951 953 +951 2801 +951 3197 +951 5982 +951 4327 +952 9571 +952 5544 +952 4778 +952 1015 +952 9452 +952 5704 +952 6576 +952 6584 +952 8178 +952 8948 +952 3606 +952 2072 +953 3330 +953 3396 +953 4326 +953 1540 +953 7530 +953 6052 +953 5324 +953 5838 +953 4200 +953 1602 +953 3950 +953 4790 +953 1988 +953 1083 +953 1373 +953 6142 +953 1087 +954 7041 +954 3202 +954 5121 +954 4646 +954 2337 +954 4904 +954 1692 +954 7458 +954 8561 +954 7220 +954 5429 +954 5174 +954 4313 +954 8252 +954 2941 +955 4356 +955 4619 +955 2457 +955 7073 +955 4645 +955 2214 +955 3367 +955 2228 +955 1332 +955 4575 +955 6461 +955 4672 +955 7877 +955 3783 +955 6472 +955 3405 +955 2383 +955 8025 +955 5413 +955 1511 +955 5756 +955 3307 +955 1526 +955 6396 +956 7147 +956 9764 +956 8625 +956 5452 +956 4007 +956 3375 +956 2397 +956 9582 +956 5748 +956 4853 +956 5518 +956 5496 +956 6620 +956 5085 +957 1793 +957 8707 +957 1604 +957 4916 +957 2054 +957 6631 +957 2599 +957 9675 +957 8465 +957 9872 +957 4433 +957 7801 +957 6613 +957 7415 +957 7857 +957 7259 +957 1213 +957 9022 +958 9988 +958 9385 +958 9739 +958 3180 +958 3472 +958 2708 +958 2712 +958 7065 +958 6554 +958 7580 +958 9466 +958 8927 +959 3582 +959 6283 +959 5511 +959 5483 +959 9234 +959 3440 +959 3602 +959 2835 +959 4148 +959 3285 +959 6134 +959 3476 +959 9789 +960 4587 +960 1521 +960 2025 +960 7627 +960 1900 +960 2480 +960 5009 +960 3186 +960 9715 +960 3348 +960 2549 +960 8524 +960 8825 +960 6813 +961 8835 +961 7691 +961 5263 +961 5139 +961 8854 +961 7192 +961 8345 +961 4255 +961 8482 +961 4390 +961 5033 +961 8120 +961 8389 +961 5194 +961 5325 +961 7644 +961 7663 +961 9332 +961 5240 +961 8701 +962 3393 +962 1172 +962 9019 +962 9348 +962 3718 +962 9129 +962 4076 +962 1423 +962 2320 +962 3698 +962 3796 +962 8470 +962 6295 +962 4665 +962 9434 +962 1972 +962 1981 +962 1951 +963 3490 +963 9508 +963 4614 +963 8198 +963 1489 +963 5416 +963 6057 +963 4812 +963 8806 +963 6953 +963 6225 +963 1145 +963 2806 +963 9225 +963 9017 +963 4315 +963 8383 +964 9856 +964 5763 +964 2951 +964 3480 +964 1177 +964 1190 +964 4396 +964 3373 +964 3760 +964 7734 +964 4409 +964 1480 +964 9548 +964 5205 +964 1849 +964 2272 +964 5094 +964 9321 +964 9452 +964 4336 +964 5502 +965 3080 +965 8458 +965 1292 +965 1805 +965 7058 +965 3102 +965 5723 +965 5543 +965 1709 +965 7344 +965 9658 +965 2747 +965 7760 +965 5714 +965 9555 +965 1876 +965 8278 +965 7642 +965 2651 +965 3171 +965 5865 +965 4602 +966 6880 +966 7328 +966 8453 +966 3303 +966 4233 +966 7883 +966 2222 +966 4368 +966 9042 +966 7347 +966 2484 +966 3150 +966 4920 +966 2330 +966 3997 +966 9439 +967 6742 +967 2461 +967 8616 +967 7209 +967 2864 +967 3508 +967 9020 +967 8258 +967 6263 +967 5068 +967 2637 +967 4814 +967 4438 +967 1495 +967 9692 +967 4456 +967 3051 +967 2672 +967 1906 +967 4599 +967 1403 +967 4349 +967 3199 +968 7169 +968 1929 +968 3477 +968 1303 +968 5445 +968 5540 +968 1445 +968 2268 +968 1194 +968 7863 +968 7993 +968 4796 +968 9789 +968 8897 +968 2501 +968 6217 +968 8656 +968 6874 +968 3036 +968 1642 +968 1275 +969 6176 +969 2529 +969 2248 +969 7756 +969 5490 +969 9458 +969 3443 +969 6388 +969 6549 +969 4856 +970 3617 +970 3523 +970 6406 +970 5096 +970 9291 +970 8525 +970 7216 +970 8945 +970 7579 +970 6549 +970 4437 +970 2590 +970 9167 +970 2844 +970 5022 +970 5253 +971 1216 +971 9576 +971 1859 +971 1476 +971 2277 +971 4550 +971 5425 +971 7208 +971 3281 +971 6961 +971 8818 +971 8355 +971 5108 +971 4963 +971 2589 +972 4033 +972 9538 +972 3035 +972 3236 +972 4982 +972 6535 +972 5959 +972 6779 +972 8333 +972 5935 +972 8813 +972 3508 +972 1557 +972 7478 +972 4855 +972 1689 +972 4954 +972 5167 +972 7108 +972 8991 +973 8160 +973 9504 +973 6662 +973 3787 +973 9868 +973 8397 +973 8718 +973 6287 +973 7217 +973 9810 +973 2227 +973 2999 +973 3827 +973 1788 +973 6559 +974 4608 +974 7181 +974 4110 +974 3604 +974 9499 +974 6813 +974 1777 +974 5676 +974 2739 +974 7350 +974 1597 +974 7486 +974 3953 +974 6724 +974 6603 +974 1878 +974 5849 +974 5731 +974 6758 +974 8487 +974 9073 +974 3058 +974 2708 +974 2682 +974 9340 +975 6913 +975 9349 +975 7175 +975 6421 +975 1430 +975 7813 +975 7714 +975 5542 +975 4140 +975 5812 +975 8629 +975 4159 +975 8000 +975 9923 +975 4812 +975 1619 +975 5077 +975 3160 +975 6876 +975 5854 +975 1252 +975 6182 +975 8940 +976 5137 +976 8582 +976 8998 +976 5927 +976 4264 +976 4604 +976 1546 +976 5616 +976 6289 +976 9490 +976 4985 +976 8060 +976 2084 +977 9057 +977 4098 +977 9507 +977 9413 +977 5415 +977 3720 +977 8489 +977 3338 +977 8685 +977 2638 +977 8369 +977 9332 +977 3982 +977 3162 +977 9916 +977 1630 +977 5023 +978 1824 +978 5447 +978 4515 +978 4037 +978 1766 +978 2087 +978 3976 +978 8203 +978 3470 +978 8264 +978 6199 +978 6879 +978 5119 +979 6915 +979 7748 +979 9317 +979 8467 +979 7337 +979 5354 +979 2414 +979 4467 +979 5646 +979 7575 +979 9372 +979 9662 +980 6664 +980 1930 +980 1675 +980 1806 +980 6672 +980 7832 +980 1443 +980 9510 +980 8115 +980 8121 +980 5564 +980 7489 +980 5571 +980 6852 +980 8904 +980 3402 +980 1741 +980 7760 +980 5969 +980 8915 +980 1340 +980 9965 +980 2799 +980 6001 +981 3724 +981 1453 +981 1305 +981 1440 +981 6177 +981 3106 +981 2595 +981 5414 +981 3626 +981 6194 +981 8925 +981 1330 +981 9395 +981 7492 +981 3271 +981 8521 +981 7635 +981 6393 +981 6875 +981 6877 +981 2337 +981 2283 +981 4658 +981 7801 +981 9210 +982 2731 +982 9031 +982 1895 +982 1868 +982 1677 +982 6735 +982 6352 +982 2771 +982 3029 +982 8922 +982 9115 +982 2716 +982 9754 +983 2695 +983 1032 +983 4365 +983 8596 +983 7192 +983 2079 +983 6827 +983 6920 +983 9268 +983 1078 +983 1746 +983 6848 +983 1475 +983 3269 +983 3410 +983 5462 +983 1624 +983 3289 +983 8026 +983 5983 +983 999 +983 3949 +983 3069 +984 5538 +984 5476 +984 4426 +984 6576 +984 6740 +984 4821 +984 4470 +984 5948 +984 2654 +984 7957 +985 8909 +985 9603 +985 3749 +985 8391 +985 6408 +985 8620 +985 2893 +985 2382 +985 3439 +985 8081 +985 2644 +985 6585 +985 991 +986 4801 +986 5378 +986 2567 +986 8520 +986 4714 +986 8897 +986 1420 +986 6637 +986 4015 +986 2072 +986 3162 +986 1839 +986 3100 +986 7934 +986 5503 +987 9729 +987 2838 +987 4207 +987 6172 +987 5163 +987 1581 +987 6832 +987 3127 +987 3384 +987 9017 +987 2752 +987 8129 +987 4556 +987 3791 +987 8784 +987 5723 +987 3816 +987 9841 +987 1523 +987 8183 +988 6721 +988 6147 +988 8301 +988 4969 +988 1034 +988 6284 +988 4301 +988 6222 +988 2191 +988 2989 +988 4881 +988 5653 +988 1366 +988 2137 +988 7727 +988 8410 +988 1627 +988 5054 +989 7170 +989 3846 +989 9607 +989 4875 +989 3341 +989 3726 +989 7060 +989 7063 +989 5537 +989 2211 +989 6181 +989 3013 +989 5318 +989 7630 +989 1037 +989 2513 +989 4051 +989 2008 +989 1743 +989 5086 +989 2399 +989 999 +989 3090 +989 3060 +989 4991 +989 8316 +989 7039 +990 6660 +990 5698 +990 1438 +990 6571 +990 7475 +990 4404 +990 1718 +990 2228 +990 6837 +990 3138 +990 2757 +990 2513 +990 4409 +990 4187 +990 2141 +990 7262 +990 4454 +990 5742 +991 1856 +991 9121 +991 4387 +991 2470 +991 8145 +991 5384 +991 7676 +991 9547 +991 1132 +991 8555 +991 7080 +991 2514 +991 4307 +991 5108 +991 3989 +991 1641 +991 2171 +991 3964 +991 4030 +991 5055 +992 3735 +992 8573 +992 6758 +992 4262 +992 3751 +992 3708 +992 6631 +992 4647 +992 3948 +992 6157 +992 4525 +992 3987 +992 9846 +992 5367 +992 7709 +993 1248 +993 7842 +993 7686 +993 5585 +993 1320 +993 6282 +993 2156 +993 3597 +993 1200 +993 3761 +993 4402 +993 9762 +993 6174 +993 2934 +993 8248 +993 9311 +993 7558 +993 6302 +994 1090 +994 8548 +994 2844 +994 7617 +994 7248 +994 8009 +994 2765 +994 7341 +994 5807 +994 4944 +994 6642 +994 2227 +994 7540 +994 3477 +994 3321 +994 1497 +994 8047 +994 5180 +995 1808 +995 5218 +995 1286 +995 2982 +995 3719 +995 2792 +995 9756 +995 8267 +995 2989 +995 3725 +995 8720 +995 7442 +995 9172 +995 7797 +995 5850 +995 6780 +995 9119 +996 2307 +996 4740 +996 5253 +996 9479 +996 4877 +996 8466 +996 7576 +996 6439 +996 7976 +996 6830 +996 4912 +996 3891 +996 9799 +996 1993 +996 8654 +996 6738 +996 5985 +996 7655 +996 9194 +996 4331 +996 8698 +996 2171 +997 4705 +997 3139 +997 8664 +997 7238 +997 6950 +997 1483 +997 3182 +997 3087 +997 8880 +997 5745 +997 8406 +997 6937 +997 9112 +997 3961 +997 7962 +997 5020 +997 6941 +997 4606 +997 2175 +998 8816 +998 2115 +998 6628 +998 5606 +998 1800 +998 3497 +998 1964 +998 1389 +998 9056 +998 3408 +998 2453 +998 5942 +998 3191 +998 4856 +998 3036 +998 6366 +998 4671 +999 6561 +999 7919 +999 3313 +999 5612 +999 1127 +999 6547 +999 2317 +999 2287 +999 1233 +999 8227 +999 3355 +999 2367 +999 6767 +999 9244 +999 4478 +999 6847 +1000 4448 +1000 4097 +1000 5570 +1000 8331 +1000 8836 +1000 3111 +1000 7431 +1000 1324 +1000 2059 +1000 2169 +1000 1154 +1000 6287 +1000 7506 +1000 1427 +1000 4726 +1000 2775 +1000 3036 +1000 3127 +1000 1084 +1000 3806 +1000 7263 +1001 1153 +1001 3463 +1001 5128 +1001 6173 +1001 6561 +1001 4002 +1001 4166 +1001 1833 +1001 5039 +1001 7999 +1001 9155 +1001 5319 +1001 7885 +1001 8788 +1001 5214 +1001 3171 +1001 1386 +1001 7927 +1001 1404 +1002 6635 +1002 2660 +1002 5318 +1002 8391 +1002 6184 +1002 6185 +1002 6173 +1002 4687 +1002 4048 +1002 5458 +1002 7252 +1002 6774 +1002 1277 +1002 6750 +1002 9055 +1003 8064 +1003 9696 +1003 1250 +1003 1670 +1003 7782 +1003 9738 +1003 4523 +1003 9580 +1003 1106 +1003 3347 +1003 9269 +1003 3225 +1003 8698 +1003 2813 +1004 4960 +1004 9243 +1004 5701 +1004 9446 +1004 3754 +1004 8969 +1004 7003 +1004 2906 +1004 8814 +1004 8376 +1004 2065 +1004 8938 +1004 8088 +1004 4153 +1004 2682 +1004 3419 +1004 8445 +1005 8450 +1005 1539 +1005 5125 +1005 4360 +1005 9226 +1005 8860 +1005 1825 +1005 2599 +1005 7849 +1005 3503 +1005 1222 +1005 9418 +1005 4558 +1005 8409 +1005 2912 +1005 8036 +1005 5094 +1005 6631 +1005 9706 +1005 9578 +1005 5502 +1006 9984 +1006 1410 +1006 9231 +1006 7953 +1006 5780 +1006 2328 +1006 1317 +1006 1198 +1006 3632 +1006 3897 +1006 2756 +1006 4807 +1006 6216 +1006 5449 +1006 5072 +1006 6755 +1006 4566 +1006 3419 +1006 3037 +1006 7031 +1006 7544 +1007 9857 +1007 9224 +1007 8079 +1007 5648 +1007 3733 +1007 6679 +1007 8730 +1007 8735 +1007 5153 +1007 6948 +1007 7464 +1007 7209 +1007 4890 +1007 5547 +1007 8113 +1007 6335 +1007 4426 +1007 4431 +1007 2645 +1007 3428 +1007 5867 +1007 7408 +1007 8104 +1007 4223 +1008 5604 +1008 6725 +1008 8775 +1008 2316 +1008 1517 +1008 2702 +1008 6352 +1008 1524 +1008 8921 +1008 5144 +1008 9497 +1009 3841 +1009 6811 +1009 4161 +1009 7873 +1009 4840 +1009 9004 +1009 8555 +1009 8908 +1009 6669 +1009 3359 +1009 9048 +1009 1780 +1009 5464 +1009 3380 +1009 6491 +1009 1596 +1009 4603 +1010 2308 +1010 7685 +1010 1674 +1010 8333 +1010 5149 +1010 3742 +1010 5412 +1010 7089 +1010 6966 +1010 6711 +1010 1856 +1010 6980 +1010 9033 +1010 6731 +1010 4567 +1010 5858 +1010 8040 +1010 9961 +1010 5866 +1010 6127 +1010 7283 +1010 9332 +1010 8297 +1011 6656 +1011 5264 +1011 3723 +1011 4900 +1011 4133 +1011 4298 +1011 7371 +1011 3214 +1011 7888 +1011 5433 +1011 7508 +1011 9301 +1011 7063 +1011 5752 +1011 5562 +1011 9308 +1011 5258 +1011 1054 +1011 7925 +1012 4963 +1012 1348 +1012 6661 +1012 5286 +1012 7629 +1012 5807 +1012 5360 +1012 4017 +1012 9107 +1012 2206 +1012 2998 +1012 9033 +1012 3320 +1012 1828 +1012 3005 +1012 2750 +1012 9477 +1013 9346 +1013 2043 +1013 2149 +1013 6986 +1013 9068 +1013 8013 +1013 6493 +1013 3336 +1013 9524 +1013 5557 +1013 1144 +1013 3706 +1013 8379 +1013 5130 +1013 4446 +1013 6239 +1014 5139 +1014 8450 +1014 9284 +1014 3013 +1014 9350 +1014 6732 +1014 8203 +1014 9388 +1014 5389 +1014 6009 +1014 4816 +1014 5555 +1014 5076 +1014 7865 +1014 3305 +1014 4633 +1014 6885 +1015 2049 +1015 3588 +1015 7041 +1015 7822 +1015 9107 +1015 7829 +1015 6554 +1015 7842 +1015 6435 +1015 2341 +1015 6828 +1015 4533 +1015 9535 +1015 1507 +1015 7636 +1015 8662 +1015 7547 +1015 9070 +1015 4724 +1015 7289 +1015 7034 +1015 8187 +1016 8960 +1016 6785 +1016 4100 +1016 3718 +1016 8852 +1016 9122 +1016 1189 +1016 2103 +1016 3515 +1016 5089 +1016 5832 +1016 8247 +1016 9169 +1016 6485 +1016 2391 +1016 6494 +1016 2655 +1016 4448 +1016 7265 +1016 2274 +1016 1379 +1016 4587 +1016 4844 +1016 7662 +1016 8311 +1017 4743 +1017 2762 +1017 5391 +1017 8594 +1017 3347 +1017 9495 +1017 1946 +1017 2596 +1017 6309 +1017 6310 +1017 1461 +1017 6840 +1017 3274 +1017 5830 +1017 6090 +1017 1875 +1017 1624 +1017 1633 +1017 9578 +1017 2540 +1017 9848 +1017 4858 +1018 8928 +1018 1043 +1018 4644 +1018 3333 +1018 4487 +1018 3145 +1018 5482 +1018 5547 +1018 6547 +1018 4463 +1018 3792 +1018 2002 +1018 1811 +1018 1624 +1018 7355 +1018 7558 +1018 3759 +1018 1599 +1019 5125 +1019 1798 +1019 9873 +1019 3987 +1019 9923 +1019 4208 +1019 1187 +1019 1317 +1019 3628 +1019 7606 +1019 5823 +1019 6595 +1019 4293 +1019 2249 +1019 6858 +1019 3022 +1019 1878 +1019 2139 +1019 5092 +1019 9190 +1019 7664 +1019 1909 +1019 9208 +1019 8441 +1020 8963 +1020 7307 +1020 8076 +1020 5134 +1020 8847 +1020 8597 +1020 3607 +1020 9896 +1020 5294 +1020 1330 +1020 5695 +1020 5706 +1020 9174 +1020 7383 +1020 2521 +1020 7784 +1020 8041 +1020 5868 +1020 5105 +1020 2293 +1020 4471 +1020 8572 +1020 7166 +1021 6434 +1021 7268 +1021 7414 +1021 5062 +1021 3848 +1021 8713 +1021 8015 +1021 7094 +1021 5380 +1021 4251 +1021 7678 +1021 4671 +1022 2276 +1022 2303 +1022 5960 +1022 1774 +1022 3023 +1022 1585 +1022 5330 +1022 4246 +1022 3289 +1022 6619 +1022 4508 +1022 7773 +1023 4385 +1023 7966 +1023 5091 +1023 4449 +1023 6696 +1023 9884 +1023 5066 +1023 1195 +1023 7218 +1023 6510 +1023 2929 +1023 3090 +1023 1269 +1023 6584 +1023 4728 +1023 4155 +1023 5981 +1023 2814 +1024 6731 +1024 1847 +1024 5830 +1024 9073 +1024 3209 +1024 8874 +1024 5355 +1024 2413 +1024 1647 +1024 3987 +1024 7572 +1024 8469 +1024 2583 +1024 2217 +1024 3774 +1025 1259 +1025 8199 +1025 7817 +1025 9359 +1025 6297 +1025 4506 +1025 6944 +1025 8480 +1025 6689 +1025 4388 +1025 7350 +1025 3260 +1025 6816 +1025 8392 +1025 6614 +1025 7009 +1025 6248 +1025 3435 +1025 7927 +1025 7672 +1025 5370 +1026 5536 +1026 4144 +1026 5090 +1026 3875 +1026 7492 +1026 4598 +1026 7769 +1026 1223 +1026 7467 +1026 9798 +1026 3149 +1026 7748 +1026 1073 +1026 7075 +1026 5462 +1026 8185 +1026 5752 +1026 4473 +1026 9342 +1027 3971 +1027 2953 +1027 4618 +1027 7692 +1027 5262 +1027 4367 +1027 8244 +1027 5423 +1027 4787 +1027 7732 +1027 2356 +1027 1982 +1027 1091 +1027 6477 +1027 4432 +1027 1204 +1027 5714 +1027 5049 +1027 4832 +1027 8061 +1028 4630 +1028 2200 +1028 5660 +1028 4509 +1028 4007 +1028 1706 +1028 3101 +1028 5559 +1028 9400 +1028 9287 +1028 4554 +1028 3028 +1028 4186 +1028 1375 +1028 7136 +1028 3555 +1028 1766 +1028 9326 +1028 5615 +1028 1270 +1028 5119 +1029 2325 +1029 7079 +1029 6249 +1029 4523 +1029 4684 +1029 6610 +1029 7391 +1029 4623 +1029 5169 +1029 5266 +1029 4990 +1029 5883 +1029 3710 +1029 1759 +1030 3394 +1030 1723 +1030 2212 +1030 6886 +1030 4583 +1030 1148 +1030 4330 +1030 7025 +1030 1778 +1030 9315 +1030 4378 +1030 7387 +1030 3549 +1030 9695 +1031 8322 +1031 1284 +1031 4615 +1031 1928 +1031 6029 +1031 6416 +1031 8337 +1031 6950 +1031 5933 +1031 8368 +1031 6198 +1031 5690 +1031 3260 +1031 8383 +1031 9285 +1031 4551 +1031 3919 +1031 9048 +1031 5434 +1031 7006 +1031 6000 +1031 2936 +1032 5508 +1032 8205 +1032 2094 +1032 6680 +1032 8220 +1032 3229 +1032 8358 +1032 5292 +1032 2862 +1032 6728 +1032 3913 +1032 7124 +1032 5853 +1032 8927 +1032 7910 +1032 6511 +1032 1656 +1032 3065 +1032 5245 +1032 5247 +1033 3424 +1033 9921 +1033 1283 +1033 9349 +1033 9419 +1033 2956 +1033 2061 +1033 3954 +1033 7892 +1033 1983 +1034 4096 +1034 2049 +1034 2830 +1034 5135 +1034 2708 +1034 8987 +1034 2717 +1034 1440 +1034 2978 +1034 8998 +1034 1587 +1034 4831 +1034 2627 +1034 5584 +1034 7510 +1034 2263 +1034 5669 +1034 9185 +1034 5479 +1034 1384 +1034 2549 +1035 4615 +1035 9363 +1035 1684 +1035 9239 +1035 1443 +1035 5683 +1035 5470 +1035 4029 +1035 2885 +1035 3401 +1035 7893 +1035 8414 +1035 6111 +1035 6369 +1035 2661 +1035 3816 +1035 6763 +1035 8942 +1035 6771 +1035 1532 +1036 9478 +1036 2183 +1036 2064 +1036 6677 +1036 3734 +1036 5023 +1036 3875 +1036 3109 +1036 8359 +1036 2858 +1036 2733 +1036 3254 +1036 4664 +1036 7868 +1036 1475 +1036 2483 +1036 3590 +1036 6755 +1036 3558 +1036 7785 +1036 4459 +1036 9584 +1037 5792 +1037 6400 +1037 8299 +1037 9905 +1037 3304 +1037 2282 +1037 1739 +1037 7086 +1037 6576 +1037 9169 +1037 1620 +1037 1748 +1037 5558 +1037 5591 +1037 4024 +1037 1337 +1037 9466 +1037 7036 +1037 3358 +1038 8962 +1038 9481 +1038 7438 +1038 5654 +1038 5275 +1038 8521 +1038 8223 +1038 3867 +1038 5669 +1038 7086 +1038 5297 +1038 2996 +1038 6430 +1038 9527 +1038 1865 +1038 6731 +1038 3281 +1038 6307 +1038 6996 +1038 9821 +1038 8671 +1038 1763 +1038 8061 +1039 8608 +1039 1504 +1039 8195 +1039 4420 +1039 9905 +1039 4648 +1039 4812 +1039 3378 +1039 7472 +1039 6993 +1039 5586 +1039 2291 +1039 4441 +1039 4763 +1039 5628 +1039 8125 +1039 8062 +1040 5057 +1040 5699 +1040 7334 +1040 7366 +1040 9671 +1040 2504 +1040 4746 +1040 6764 +1040 5325 +1040 1774 +1040 6959 +1040 6472 +1040 2358 +1040 7479 +1040 2429 +1041 3136 +1041 7074 +1041 4003 +1041 1675 +1041 7766 +1041 8518 +1041 5321 +1041 6923 +1041 8075 +1041 7885 +1041 8925 +1041 9808 +1041 5178 +1041 4470 +1041 5305 +1041 9690 +1041 5980 +1041 8638 +1041 5599 +1042 9987 +1042 6148 +1042 6552 +1042 9627 +1042 1822 +1042 2080 +1042 1058 +1042 5539 +1042 2987 +1042 4957 +1042 8627 +1042 8910 +1042 2772 +1042 5070 +1042 9431 +1042 4445 +1042 2910 +1042 7519 +1042 9450 +1042 9965 +1042 2661 +1043 1930 +1043 1163 +1043 3343 +1043 7063 +1043 9498 +1043 9884 +1043 7206 +1043 5040 +1043 8889 +1043 3772 +1043 3521 +1043 7372 +1043 2510 +1043 3024 +1043 2515 +1043 7256 +1043 2527 +1043 6115 +1043 9324 +1043 3182 +1043 1619 +1043 1491 +1043 3700 +1043 6650 +1044 9345 +1044 8836 +1044 3336 +1044 8076 +1044 5010 +1044 2326 +1044 1432 +1044 1191 +1044 4266 +1044 8368 +1044 9523 +1044 7099 +1044 2882 +1044 4364 +1044 4298 +1044 8273 +1044 9427 +1044 9044 +1044 2645 +1044 9815 +1044 3596 +1044 1121 +1044 7906 +1044 9699 +1044 4844 +1044 8430 +1044 2801 +1044 4603 +1044 3453 +1045 1633 +1045 1795 +1045 1255 +1045 3943 +1045 6545 +1045 4465 +1045 5235 +1045 9172 +1045 7253 +1045 8790 +1045 1977 +1045 6447 +1045 8203 +1045 9183 +1046 9956 +1046 9025 +1046 2340 +1046 5961 +1046 5844 +1046 2539 +1046 1167 +1046 9646 +1046 6717 +1046 6416 +1046 3986 +1046 6612 +1046 9326 +1046 7832 +1046 5155 +1046 7899 +1046 1629 +1046 9630 +1046 3103 +1047 4966 +1047 3071 +1047 8839 +1047 5946 +1047 2282 +1047 3915 +1047 8397 +1047 7439 +1047 9812 +1047 9640 +1047 9554 +1047 7764 +1047 5813 +1047 8557 +1047 2680 +1047 8913 +1047 1147 +1047 4698 +1047 1695 +1048 2438 +1048 3431 +1048 1289 +1048 9643 +1048 7628 +1048 6802 +1048 8659 +1048 1449 +1048 3129 +1048 3770 +1048 9595 +1048 3517 +1048 2942 +1048 9439 +1049 1344 +1049 3745 +1049 1096 +1049 5348 +1049 3014 +1049 4200 +1049 6953 +1049 8951 +1049 7073 +1049 5745 +1049 1847 +1049 1176 +1049 5273 +1049 5760 +1049 8028 +1049 4221 +1049 6878 +1049 4853 +1050 5632 +1050 8584 +1050 3722 +1050 6156 +1050 7570 +1050 1940 +1050 6550 +1050 6681 +1050 9139 +1050 1712 +1050 2725 +1050 8494 +1050 9520 +1050 1075 +1050 5174 +1050 5184 +1050 9290 +1050 6733 +1050 6351 +1050 1491 +1050 4217 +1050 1887 +1050 9576 +1050 8682 +1050 5394 +1050 6643 +1050 1653 +1050 4726 +1050 4989 +1051 3585 +1051 1164 +1051 8334 +1051 1685 +1051 7958 +1051 6039 +1051 2073 +1051 5018 +1051 8477 +1051 2337 +1051 2478 +1051 6578 +1051 4536 +1051 2757 +1051 8137 +1051 2446 +1051 2015 +1051 8686 +1051 7159 +1052 4102 +1052 5387 +1052 4880 +1052 4056 +1052 3110 +1052 3624 +1052 1068 +1052 8493 +1052 2361 +1052 6716 +1052 1855 +1052 3782 +1052 3145 +1052 5581 +1052 6734 +1052 6223 +1052 8402 +1052 5074 +1052 5080 +1052 2907 +1052 1375 +1052 7400 +1052 2364 +1052 6509 +1052 5358 +1052 5238 +1053 1597 +1053 4893 +1053 8913 +1053 8616 +1053 3945 +1053 1226 +1053 6155 +1053 2397 +1053 2664 +1053 2449 +1053 7082 +1053 3475 +1053 3798 +1053 1527 +1053 8554 +1054 6531 +1054 1540 +1054 5547 +1054 8110 +1054 4912 +1054 3699 +1054 1590 +1054 5312 +1054 4427 +1054 5322 +1054 4939 +1054 2267 +1054 7133 +1054 4197 +1054 5861 +1054 9199 +1054 1523 +1054 6142 +1055 5604 +1055 5564 +1055 5002 +1055 5195 +1055 6320 +1055 6620 +1055 1460 +1055 6294 +1055 3223 +1055 5080 +1055 9436 +1055 9853 +1056 5632 +1056 5707 +1056 1315 +1056 7845 +1056 1222 +1056 8273 +1056 8648 +1056 1449 +1056 9278 +1056 1197 +1056 4117 +1056 2614 +1056 9758 +1056 1211 +1056 2492 +1056 2046 +1056 7711 +1057 6576 +1057 6370 +1057 2947 +1057 2309 +1057 2630 +1057 4711 +1057 8840 +1057 5354 +1057 6605 +1057 6800 +1057 7178 +1057 1827 +1057 8886 +1057 7866 +1057 3210 +1057 4286 +1058 7756 +1058 5643 +1058 8004 +1058 7813 +1058 8167 +1058 1644 +1058 9655 +1058 1580 +1058 4077 +1058 9934 +1058 1453 +1058 3380 +1058 6263 +1058 8027 +1058 7901 +1058 9246 +1058 9189 +1059 5346 +1059 6405 +1059 1546 +1059 7340 +1059 5102 +1059 3279 +1059 1648 +1059 7507 +1059 6812 +1059 4389 +1059 6981 +1060 2864 +1060 3363 +1060 1222 +1060 8871 +1060 5385 +1060 6288 +1060 5237 +1060 3062 +1060 9849 +1060 9819 +1060 7772 +1060 4861 +1060 3477 +1061 7456 +1061 7201 +1061 7299 +1061 6567 +1061 4678 +1061 4993 +1061 6730 +1061 9707 +1061 1709 +1061 7342 +1061 4382 +1061 2451 +1061 1652 +1061 2558 +1061 9400 +1061 2851 +1061 3194 +1061 6620 +1061 5534 +1062 2816 +1062 1505 +1062 6957 +1062 2147 +1062 2405 +1062 8262 +1062 1937 +1062 2922 +1062 3687 +1062 7853 +1062 7854 +1062 7342 +1062 5745 +1062 3125 +1062 3924 +1062 1731 +1062 7417 +1062 8317 +1062 9375 +1063 6916 +1063 5505 +1063 7721 +1063 3570 +1063 7154 +1063 7475 +1063 3124 +1063 1943 +1063 3001 +1063 4570 +1063 1275 +1063 8413 +1063 7903 +1064 8705 +1064 6789 +1064 4696 +1064 1938 +1064 8227 +1064 6436 +1064 8743 +1064 3504 +1064 6068 +1064 1212 +1064 4671 +1064 6351 +1064 1745 +1064 2392 +1064 7897 +1064 8923 +1064 9636 +1064 9964 +1064 1647 +1064 5625 +1064 1274 +1064 5629 +1065 4481 +1065 8802 +1065 2886 +1065 3484 +1065 5868 +1065 9586 +1065 6580 +1065 7286 +1065 8953 +1065 1658 +1065 4828 +1065 7645 +1065 4670 +1065 5695 +1066 7256 +1066 2723 +1066 4503 +1066 5624 +1066 8422 +1066 7755 +1066 9520 +1066 8657 +1066 7592 +1066 2069 +1066 2967 +1066 2680 +1067 9664 +1067 1536 +1067 8452 +1067 2599 +1067 9929 +1067 5818 +1067 7278 +1067 9999 +1067 5488 +1067 4850 +1067 7285 +1067 8822 +1067 6743 +1067 8313 +1067 6458 +1067 2875 +1067 2909 +1067 4766 +1068 3584 +1068 3708 +1068 4962 +1068 2877 +1068 3654 +1068 9436 +1068 5066 +1068 6379 +1068 3596 +1068 1711 +1068 4842 +1068 3093 +1068 9846 +1068 9386 +1068 3160 +1068 8764 +1068 4285 +1068 7902 +1068 5861 +1069 4481 +1069 4354 +1069 2954 +1069 5266 +1069 5779 +1069 4885 +1069 4504 +1069 2714 +1069 5915 +1069 3741 +1069 6303 +1069 7200 +1069 4145 +1069 2996 +1069 2741 +1069 1850 +1069 6005 +1069 4547 +1069 9161 +1069 5329 +1069 6227 +1069 3543 +1069 9817 +1069 4571 +1069 3935 +1069 8294 +1069 9076 +1069 6901 +1070 1537 +1070 5122 +1070 4462 +1070 3137 +1070 1185 +1070 2274 +1070 8237 +1070 4878 +1070 2168 +1070 8306 +1070 5524 +1070 1525 +1070 6936 +1070 8253 +1070 9854 +1070 3071 +1071 3168 +1071 5985 +1071 2276 +1071 2022 +1071 2497 +1071 6440 +1071 9089 +1071 3530 +1071 9871 +1071 4468 +1071 1790 +1071 4890 +1071 3225 +1071 3577 +1071 4954 +1071 4426 +1071 9150 +1072 3522 +1072 6255 +1072 4868 +1072 2309 +1072 5673 +1072 4215 +1072 6351 +1072 2609 +1072 7356 +1072 7036 +1072 3926 +1072 3895 +1072 8154 +1072 2287 +1072 5916 +1072 9758 +1072 2111 +1073 5763 +1073 5769 +1073 1165 +1073 3214 +1073 7171 +1073 2716 +1073 5408 +1073 1833 +1073 2229 +1073 8507 +1073 3791 +1073 9434 +1073 1627 +1073 2143 +1073 9187 +1073 7784 +1073 3952 +1073 4466 +1073 2811 +1074 8960 +1074 8480 +1074 7363 +1074 1220 +1074 8102 +1074 1766 +1074 5321 +1074 2769 +1074 6070 +1074 8457 +1074 1124 +1075 2322 +1075 6297 +1075 6041 +1075 5021 +1075 6430 +1075 8863 +1075 9254 +1075 1961 +1075 9003 +1075 2863 +1075 2357 +1075 6349 +1075 5325 +1075 2007 +1075 8409 +1075 8422 +1075 4456 +1075 4970 +1075 5100 +1075 4338 +1075 2431 +1076 9633 +1076 8043 +1076 6732 +1076 1995 +1076 7571 +1076 2930 +1076 2027 +1076 3858 +1076 6899 +1076 4787 +1076 9651 +1076 5561 +1076 7450 +1076 2331 +1076 5884 +1077 2881 +1077 6850 +1077 9590 +1077 8772 +1077 8838 +1077 8999 +1077 9328 +1077 2410 +1077 7915 +1077 1936 +1077 6951 +1077 3443 +1077 7049 +1077 4196 +1077 7258 +1077 7420 +1077 6842 +1077 4639 +1078 5025 +1078 7971 +1078 7428 +1078 7847 +1078 3626 +1078 6049 +1078 4620 +1078 2034 +1078 5614 +1078 4893 +1078 5489 +1078 2610 +1078 3793 +1078 1563 +1078 9194 +1079 5090 +1079 2851 +1079 8054 +1079 2182 +1079 5129 +1079 1090 +1079 1582 +1079 4272 +1079 9585 +1079 8643 +1079 4596 +1079 6262 +1079 1944 +1079 8892 +1080 6502 +1080 5921 +1080 4996 +1080 5285 +1080 6886 +1080 6143 +1080 7048 +1080 8810 +1080 7851 +1080 5708 +1080 3950 +1080 2237 +1080 7505 +1080 6579 +1080 8472 +1080 3460 +1080 3035 +1080 9802 +1080 4958 +1080 4703 +1081 9857 +1081 8965 +1081 9739 +1081 8210 +1081 8341 +1081 8709 +1081 6817 +1081 2233 +1081 3515 +1081 4419 +1081 9162 +1081 9163 +1081 8653 +1081 5851 +1081 4455 +1081 2922 +1081 9707 +1081 9460 +1081 7419 +1081 6780 +1081 3966 +1082 8192 +1082 1411 +1082 7766 +1082 5530 +1082 7964 +1082 5533 +1082 1440 +1082 8229 +1082 4903 +1082 4776 +1082 6428 +1082 6954 +1082 7083 +1082 5423 +1082 2884 +1082 8529 +1082 3030 +1082 4700 +1082 5732 +1082 9831 +1082 4970 +1082 9191 +1082 9976 +1082 1147 +1082 5738 +1083 9348 +1083 3211 +1083 2962 +1083 3091 +1083 7700 +1083 7447 +1083 8219 +1083 5661 +1083 5291 +1083 8349 +1083 1969 +1083 9795 +1083 8522 +1083 2385 +1083 7993 +1083 9688 +1083 1770 +1083 4845 +1083 7282 +1083 5747 +1083 6264 +1083 6268 +1084 9611 +1084 7960 +1084 1563 +1084 3237 +1084 3498 +1084 8752 +1084 4020 +1084 4030 +1084 3851 +1084 3145 +1084 7764 +1084 2901 +1084 6053 +1084 8419 +1084 7282 +1084 1141 +1084 5366 +1084 8695 +1085 4001 +1085 8450 +1085 3779 +1085 9801 +1085 7674 +1085 1868 +1085 3308 +1085 5842 +1085 6773 +1085 2633 +1085 9626 +1085 6197 +1085 7454 +1085 3573 +1086 6210 +1086 9924 +1086 2566 +1086 5830 +1086 4711 +1086 3242 +1086 2321 +1086 9471 +1086 8304 +1086 2833 +1086 4293 +1086 7863 +1086 4134 +1086 5341 +1086 1541 +1087 9511 +1087 2050 +1087 3651 +1087 3109 +1087 7367 +1087 8362 +1087 8647 +1087 8780 +1087 2434 +1087 7983 +1087 8368 +1087 7827 +1087 1402 +1087 8527 +1087 5916 +1087 7389 +1087 2046 +1087 6213 +1088 6283 +1088 2319 +1088 4634 +1088 8091 +1088 9778 +1088 9392 +1088 9522 +1088 4415 +1088 6981 +1088 5192 +1088 4681 +1088 8783 +1088 7509 +1088 1359 +1088 9308 +1088 9698 +1088 7538 +1088 9075 +1088 7546 +1089 2554 +1089 5604 +1089 2503 +1089 9608 +1089 7836 +1089 6891 +1089 3212 +1089 3341 +1089 9711 +1089 2360 +1089 7282 +1089 7797 +1089 1847 +1089 6717 +1089 3674 +1089 7319 +1089 5818 +1089 9375 +1090 4481 +1090 5635 +1090 6853 +1090 1894 +1090 9089 +1090 6825 +1090 1389 +1090 8880 +1090 4465 +1090 1714 +1090 7475 +1090 9003 +1090 7738 +1090 4474 +1090 7717 +1091 9601 +1091 2436 +1091 2320 +1091 2833 +1091 2947 +1091 4375 +1091 2202 +1091 7195 +1091 9886 +1091 1696 +1091 9261 +1091 4666 +1091 1344 +1091 3905 +1091 1355 +1091 8798 +1091 3551 +1091 5858 +1091 2963 +1091 4342 +1091 6520 +1092 6272 +1092 7576 +1092 1851 +1092 7303 +1092 7593 +1092 9290 +1092 7367 +1092 8419 +1092 1166 +1092 2863 +1092 8728 +1092 9163 +1092 4819 +1092 2772 +1092 6286 +1092 3352 +1092 2617 +1092 3231 +1092 3677 +1092 2558 +1092 6570 +1093 3073 +1093 6694 +1093 8614 +1093 3783 +1093 5802 +1093 2187 +1093 6828 +1093 3758 +1093 6869 +1093 6487 +1093 3705 +1093 2650 +1093 6716 +1093 8858 +1093 9918 +1094 4066 +1094 6870 +1094 3521 +1094 2066 +1094 2837 +1094 5465 +1094 7460 +1094 8240 +1094 1974 +1094 2746 +1094 5568 +1094 9793 +1094 2649 +1094 3018 +1094 8781 +1094 7510 +1094 3672 +1094 3929 +1094 1729 +1094 7260 +1094 7901 +1094 7906 +1094 4712 +1094 3575 +1094 1788 +1094 3325 +1095 7426 +1095 9093 +1095 4072 +1095 4092 +1095 2762 +1095 4493 +1095 6703 +1095 7536 +1095 3444 +1095 3118 +1095 9718 +1095 3159 +1095 9871 +1095 5276 +1095 4362 +1095 6684 +1096 5760 +1096 4737 +1096 7820 +1096 9362 +1096 1301 +1096 9433 +1096 9756 +1096 8863 +1096 2858 +1096 4025 +1096 9658 +1096 7485 +1096 4543 +1096 6606 +1096 2129 +1096 4814 +1096 6104 +1096 8793 +1096 3428 +1096 1127 +1096 9106 +1096 7920 +1096 8446 +1096 3327 +1097 2592 +1097 7809 +1097 2339 +1097 9185 +1097 9417 +1097 5215 +1097 2443 +1097 9708 +1097 2369 +1097 2256 +1097 9665 +1097 4403 +1097 6038 +1097 3319 +1097 6968 +1097 5787 +1097 8287 +1098 3073 +1098 3947 +1098 8999 +1098 5086 +1098 1136 +1098 3402 +1098 7399 +1098 5346 +1098 9422 +1098 7728 +1098 3473 +1098 8274 +1098 3568 +1098 7287 +1098 4024 +1098 6871 +1098 7710 +1098 5919 +1099 3337 +1099 9491 +1099 9625 +1099 5787 +1099 4129 +1099 2722 +1099 5411 +1099 8230 +1099 5287 +1099 6058 +1099 9410 +1099 5190 +1099 4385 +1099 8011 +1099 5582 +1099 7017 +1099 5232 +1099 8737 +1099 5372 +1100 5218 +1100 4995 +1100 4854 +1100 6246 +1100 1575 +1100 2376 +1100 4393 +1100 3211 +1100 1709 +1100 2350 +1100 2930 +1100 4585 +1100 8346 +1100 4994 +1100 7742 +1100 4002 +1101 1153 +1101 8491 +1101 5381 +1101 4649 +1101 7915 +1101 5644 +1101 1935 +1101 8624 +1101 3601 +1101 4195 +1101 8852 +1101 9685 +1101 1878 +1101 5176 +1101 4284 +1101 7901 +1102 6914 +1102 5445 +1102 4713 +1102 5643 +1102 4236 +1102 9680 +1102 7601 +1102 5301 +1102 3452 +1102 6362 +1102 7067 +1102 6524 +1102 1565 +1103 5024 +1103 8331 +1103 1958 +1103 4967 +1103 6403 +1103 9043 +1103 2255 +1103 2000 +1103 5619 +1103 8263 +1103 7065 +1103 5179 +1103 5373 +1104 5952 +1104 5795 +1104 1541 +1104 4876 +1104 2759 +1104 7944 +1104 2505 +1104 8586 +1104 2828 +1104 9389 +1104 4718 +1104 6643 +1104 5460 +1104 7413 +1104 1943 +1104 7097 +1104 9562 +1105 3856 +1105 2722 +1105 5380 +1105 5965 +1105 8202 +1105 1618 +1105 8591 +1105 1680 +1105 6865 +1105 3314 +1105 4692 +1105 2008 +1105 3972 +1105 4314 +1105 2874 +1106 9121 +1106 3716 +1106 1654 +1106 8806 +1106 8075 +1106 2957 +1106 8304 +1106 6259 +1106 8884 +1106 8917 +1106 8182 +1106 1348 +1106 8701 +1106 3516 +1106 6589 +1106 1918 +1106 1269 +1107 8192 +1107 3719 +1107 6153 +1107 8429 +1107 6421 +1107 6040 +1107 2713 +1107 3104 +1107 9896 +1107 1598 +1107 8902 +1107 4045 +1107 7893 +1107 8669 +1107 5357 +1107 6867 +1107 5365 +1107 7672 +1107 4217 +1107 7292 +1107 5246 +1107 4181 +1108 6896 +1108 5730 +1108 2000 +1108 9157 +1108 3175 +1108 8385 +1108 7436 +1108 6410 +1108 1131 +1108 3852 +1108 5246 +1108 9295 +1108 4341 +1108 5275 +1108 1180 +1108 9502 +1108 9445 +1109 9600 +1109 2572 +1109 9104 +1109 9880 +1109 2729 +1109 2096 +1109 2188 +1109 4169 +1109 4670 +1109 6719 +1109 3907 +1109 2249 +1109 5849 +1109 3038 +1109 5612 +1109 8815 +1109 5495 +1109 5497 +1109 1599 +1109 3710 +1110 8291 +1110 8870 +1110 5415 +1110 4296 +1110 7885 +1110 7247 +1110 8754 +1110 8886 +1110 7320 +1110 1119 +1111 4614 +1111 1914 +1111 4505 +1111 1565 +1111 2718 +1111 8863 +1111 9512 +1111 4649 +1111 6199 +1111 3416 +1111 5114 +1111 3429 +1111 2663 +1111 1127 +1111 3311 +1111 4720 +1111 6772 +1111 4469 +1111 7799 +1111 8568 +1111 2554 +1112 1792 +1112 5747 +1112 5799 +1112 5308 +1112 5322 +1112 1803 +1112 5517 +1112 8188 +1112 3981 +1112 1700 +1112 1656 +1112 6292 +1112 7034 +1112 6291 +1112 2211 +1112 1194 +1112 7486 +1113 2198 +1113 5382 +1113 1168 +1113 4242 +1113 7574 +1113 9111 +1113 4509 +1113 3628 +1113 1976 +1113 5945 +1113 4796 +1113 5565 +1113 6468 +1113 2005 +1113 8505 +1113 9052 +1113 6880 +1113 6758 +1113 5736 +1113 2160 +1113 2547 +1113 7798 +1113 4344 +1113 6869 +1114 9761 +1114 1303 +1114 3719 +1114 1546 +1114 9963 +1114 8846 +1114 4528 +1114 4240 +1114 3678 +1114 3959 +1114 5415 +1114 3236 +1114 2395 +1114 2638 +1114 5086 +1115 9505 +1115 3266 +1115 9126 +1115 9409 +1115 7177 +1115 2218 +1115 7891 +1115 4029 +1115 8469 +1115 8374 +1115 9047 +1115 3001 +1115 2986 +1116 1796 +1116 7688 +1116 2193 +1116 7187 +1116 9643 +1116 3373 +1116 6192 +1116 7226 +1116 1214 +1116 1471 +1116 7238 +1116 2764 +1116 1366 +1116 4439 +1116 8924 +1116 9573 +1116 4327 +1116 9065 +1116 3047 +1116 9847 +1116 1404 +1117 2816 +1117 8912 +1117 8771 +1117 8037 +1117 8125 +1117 5418 +1117 4221 +1117 6736 +1117 6419 +1117 1364 +1117 9429 +1117 6870 +1117 8733 +1117 3549 +1117 5342 +1118 5919 +1118 5441 +1118 6595 +1118 3940 +1118 3109 +1118 2888 +1118 5064 +1118 5902 +1118 2961 +1118 2484 +1118 9301 +1118 9046 +1118 2761 +1118 6329 +1118 6906 +1118 1179 +1118 1629 +1118 4229 +1119 3466 +1119 4492 +1119 5393 +1119 9363 +1119 1304 +1119 7457 +1119 2524 +1119 4915 +1119 4149 +1119 2999 +1119 2745 +1119 5692 +1119 5567 +1119 5953 +1119 2372 +1119 5580 +1119 9424 +1119 2386 +1119 4188 +1119 1120 +1119 4341 +1119 1398 +1120 7616 +1120 6624 +1120 7235 +1120 9348 +1120 7474 +1120 5260 +1120 1965 +1120 5808 +1120 5237 +1120 9335 +1120 2235 +1120 1566 +1120 6975 +1121 7576 +1121 5284 +1121 7333 +1121 3462 +1121 3143 +1121 8295 +1121 3596 +1121 3949 +1121 6958 +1121 6192 +1121 4337 +1121 1203 +1121 3029 +1121 7793 +1121 5062 +1121 1593 +1121 7834 +1121 9116 +1121 4837 +1122 2317 +1122 8095 +1122 1187 +1122 4525 +1122 3120 +1122 7606 +1122 7994 +1122 9660 +1122 6846 +1122 6217 +1122 8283 +1122 9439 +1122 6460 +1122 7788 +1122 8945 +1122 6143 +1123 6658 +1123 2838 +1123 7942 +1123 2183 +1123 3978 +1123 4750 +1123 9231 +1123 1302 +1123 6940 +1123 3102 +1123 5407 +1123 8966 +1123 1577 +1123 6059 +1123 7729 +1123 6323 +1123 5142 +1123 9152 +1123 7630 +1123 4956 +1123 6632 +1123 7791 +1123 1266 +1123 5491 +1123 6778 +1124 4353 +1124 9483 +1124 8978 +1124 6293 +1124 2591 +1124 7205 +1124 7470 +1124 4145 +1124 1842 +1124 7348 +1124 1977 +1124 4796 +1124 3902 +1124 5324 +1124 6608 +1124 7001 +1124 9572 +1124 7400 +1124 2286 +1124 4596 +1124 2938 +1125 8563 +1125 9611 +1125 4804 +1125 7441 +1125 2984 +1125 9706 +1125 9896 +1125 9229 +1125 4877 +1125 2190 +1125 5071 +1125 3920 +1125 2481 +1125 5843 +1125 1908 +1125 8142 +1125 6425 +1125 7407 +1125 9084 +1126 8448 +1126 4144 +1126 8706 +1126 9860 +1126 9704 +1126 1363 +1126 1485 +1126 5390 +1126 3024 +1126 3374 +1126 3509 +1126 9463 +1126 9162 +1126 3770 +1126 8890 +1126 6901 +1127 6976 +1127 4356 +1127 8791 +1127 3729 +1127 9882 +1127 4389 +1127 2349 +1127 6063 +1127 9907 +1127 7221 +1127 1600 +1127 3267 +1127 9284 +1127 4677 +1127 8518 +1127 6090 +1127 4044 +1127 4693 +1127 5343 +1127 2657 +1127 8422 +1127 3689 +1127 3829 +1127 3705 +1128 2112 +1128 2881 +1128 3588 +1128 1669 +1128 7750 +1128 7409 +1128 9901 +1128 9742 +1128 3629 +1128 3120 +1128 1496 +1128 3059 +1128 4212 +1128 8308 +1128 1976 +1128 9940 +1128 8913 +1128 6491 +1128 5907 +1129 5827 +1129 3926 +1129 9576 +1129 5193 +1129 8970 +1129 4023 +1129 1842 +1129 6133 +1129 1942 +1129 5625 +1129 1466 +1129 3454 +1129 8373 +1130 5092 +1130 3622 +1130 3753 +1130 1194 +1130 4811 +1130 1999 +1130 5393 +1130 7027 +1130 9524 +1130 2676 +1130 1755 +1130 3004 +1130 2301 +1131 9989 +1131 8583 +1131 3727 +1131 9754 +1131 5020 +1131 3744 +1131 8486 +1131 8748 +1131 9908 +1131 2105 +1131 3388 +1131 3651 +1131 1354 +1131 2515 +1131 9819 +1131 1628 +1131 6511 +1131 1747 +1132 2310 +1132 7174 +1132 8862 +1132 8097 +1132 5027 +1132 3109 +1132 4139 +1132 2350 +1132 1584 +1132 5297 +1132 3123 +1132 7348 +1132 3256 +1132 3133 +1132 9420 +1132 3799 +1132 8798 +1132 4066 +1132 2150 +1132 2280 +1132 6278 +1133 2690 +1133 5923 +1133 1381 +1133 3624 +1133 4329 +1133 8970 +1133 9229 +1133 7981 +1133 6682 +1133 5162 +1133 9498 +1133 8828 +1133 2941 +1133 4360 +1133 7861 +1134 7137 +1134 1862 +1134 6087 +1134 9198 +1134 5838 +1134 3508 +1134 8373 +1134 3126 +1134 2650 +1135 3136 +1135 3201 +1135 2371 +1135 3075 +1135 4998 +1135 9385 +1135 3084 +1135 2348 +1135 7086 +1135 9871 +1135 6680 +1135 5555 +1135 9812 +1135 4396 +1135 3576 +1135 5492 +1135 3387 +1135 1667 +1135 2035 +1136 3456 +1136 8070 +1136 7572 +1136 9621 +1136 7712 +1136 8993 +1136 5382 +1136 4902 +1136 4911 +1136 2736 +1136 1342 +1136 6084 +1136 3143 +1136 1224 +1136 9804 +1136 4179 +1136 8036 +1136 4571 +1136 4193 +1136 4323 +1136 8807 +1136 7023 +1136 8403 +1136 2807 +1136 7800 +1137 8709 +1137 8464 +1137 8342 +1137 8862 +1137 4257 +1137 8356 +1137 2982 +1137 3759 +1137 2225 +1137 7992 +1137 3391 +1137 3787 +1137 9456 +1137 1336 +1137 4692 +1137 5596 +1137 7661 +1137 3326 +1138 5360 +1138 1411 +1138 3012 +1138 4038 +1138 6955 +1138 5358 +1138 3344 +1138 8276 +1138 6360 +1138 4505 +1139 9328 +1139 6083 +1139 5224 +1139 2476 +1139 6796 +1139 5346 +1139 1613 +1139 2512 +1139 6504 +1139 3474 +1139 9043 +1139 3190 +1139 5372 +1139 5661 +1139 2014 +1140 6115 +1140 3493 +1140 2566 +1140 4136 +1140 4041 +1140 6506 +1140 4183 +1140 5388 +1140 4846 +1140 7005 +1140 8369 +1140 6479 +1140 7043 +1140 1589 +1140 7982 +1140 7673 +1140 8718 +1140 8367 +1140 6766 +1140 4670 +1141 3201 +1141 4226 +1141 7684 +1141 8845 +1141 3726 +1141 6426 +1141 4129 +1141 6186 +1141 6967 +1141 7360 +1141 7233 +1141 5827 +1141 9938 +1141 4184 +1141 3423 +1141 6240 +1141 7656 +1141 7148 +1141 5741 +1141 3304 +1142 1600 +1142 1891 +1142 2340 +1142 6085 +1142 4198 +1142 4359 +1142 4940 +1142 5963 +1142 4299 +1142 5767 +1142 5885 +1142 3057 +1142 8019 +1142 6717 +1142 3641 +1142 7915 +1142 9113 +1142 1978 +1142 9818 +1142 5726 +1143 4121 +1143 8220 +1143 2334 +1143 5027 +1143 3365 +1143 4649 +1143 9907 +1143 9013 +1143 1746 +1143 9915 +1143 1855 +1143 1475 +1143 5714 +1143 5844 +1143 8279 +1143 7384 +1143 3551 +1143 6753 +1143 2406 +1143 8550 +1143 5735 +1143 8958 +1143 1620 +1143 6270 +1144 4544 +1144 3397 +1144 9000 +1144 2697 +1144 4647 +1144 3948 +1144 2831 +1144 3314 +1144 2789 +1144 4854 +1144 2263 +1144 5528 +1144 4057 +1144 8890 +1144 9083 +1144 1692 +1144 3509 +1145 4864 +1145 4066 +1145 1819 +1145 2600 +1145 7402 +1145 4715 +1145 4752 +1145 1521 +1145 5227 +1145 5463 +1145 4857 +1145 3322 +1145 6907 +1145 1916 +1145 2618 +1145 1854 +1146 8834 +1146 8836 +1146 5260 +1146 7952 +1146 4885 +1146 6281 +1146 3645 +1146 6974 +1146 6468 +1146 8905 +1146 3019 +1146 8409 +1146 8800 +1146 1896 +1146 2670 +1146 9202 +1146 2812 +1146 8317 +1147 4513 +1147 5602 +1147 1387 +1147 9730 +1147 7141 +1147 3911 +1147 3720 +1147 3585 +1147 8471 +1147 1644 +1147 6610 +1147 2704 +1147 9544 +1147 8690 +1147 3699 +1147 1268 +1147 6776 +1147 5296 +1147 4926 +1148 5648 +1148 4760 +1148 1566 +1148 8355 +1148 9771 +1148 5422 +1148 3507 +1148 3764 +1148 9148 +1148 8132 +1148 4421 +1148 1738 +1148 5963 +1148 2275 +1148 6504 +1148 7530 +1148 5612 +1148 2557 +1149 9984 +1149 8325 +1149 5646 +1149 2335 +1149 2595 +1149 9517 +1149 7346 +1149 5811 +1149 6583 +1149 1503 +1149 4036 +1149 6469 +1149 1351 +1149 1480 +1149 7639 +1149 7007 +1149 8826 +1149 6783 +1150 6496 +1150 4839 +1150 9578 +1150 8615 +1150 3149 +1150 4942 +1150 4077 +1150 5863 +1150 9876 +1150 2174 +1150 6073 +1150 3033 +1150 9949 +1150 3198 +1151 2496 +1151 2371 +1151 1798 +1151 5169 +1151 6600 +1151 3324 +1151 7847 +1151 1292 +1151 7629 +1151 7535 +1151 6545 +1151 7377 +1151 2164 +1151 9077 +1151 3532 +1151 2777 +1151 2076 +1151 8541 +1151 9631 +1152 5122 +1152 7339 +1152 1667 +1152 4124 +1152 3527 +1152 3656 +1152 7103 +1152 1859 +1152 5061 +1152 4551 +1152 3912 +1152 7116 +1152 5834 +1152 4300 +1152 9551 +1152 9690 +1152 6620 +1152 4959 +1152 1509 +1152 7534 +1152 4739 +1152 9082 +1152 9415 +1153 3460 +1153 6795 +1153 5791 +1153 6312 +1153 8494 +1153 2227 +1153 3768 +1153 6718 +1153 2626 +1153 3015 +1153 4681 +1153 5837 +1153 4690 +1153 6227 +1153 8412 +1153 2909 +1153 8807 +1153 8940 +1153 7789 +1153 3826 +1153 8823 +1154 5517 +1154 9105 +1154 9362 +1154 8732 +1154 7332 +1154 9777 +1154 1967 +1154 9393 +1154 4979 +1154 6218 +1154 7756 +1154 7374 +1154 6643 +1154 7888 +1154 9784 +1154 5540 +1154 8417 +1154 6114 +1154 6121 +1154 2415 +1154 2291 +1154 4725 +1154 1406 +1155 2305 +1155 4883 +1155 4512 +1155 8356 +1155 2102 +1155 2491 +1155 7740 +1155 7361 +1155 5316 +1155 8657 +1155 9187 +1155 4308 +1155 3797 +1155 6493 +1155 7262 +1155 9019 +1155 3684 +1155 7014 +1155 6638 +1155 5108 +1155 4734 +1156 5889 +1156 9601 +1156 5522 +1156 7318 +1156 7063 +1156 8730 +1156 4378 +1156 6686 +1156 7592 +1156 8839 +1156 2860 +1156 2221 +1156 6574 +1156 1460 +1156 2881 +1156 1993 +1156 5596 +1156 5726 +1156 7007 +1156 2534 +1156 5746 +1157 7689 +1157 6956 +1157 6894 +1157 3311 +1157 4978 +1157 3347 +1157 8052 +1157 6646 +1157 1754 +1157 7772 +1157 2366 +1158 2498 +1158 3715 +1158 5892 +1158 5029 +1158 3367 +1158 1160 +1158 2825 +1158 7946 +1158 5195 +1158 3117 +1158 1326 +1158 8304 +1158 4883 +1158 8894 +1158 5208 +1158 3930 +1158 4490 +1158 4702 +1158 9301 +1159 3330 +1159 4743 +1159 9992 +1159 2955 +1159 6430 +1159 8099 +1159 2343 +1159 9897 +1159 5807 +1159 9013 +1159 3510 +1159 3647 +1159 2614 +1159 7750 +1159 9416 +1159 5450 +1159 1493 +1159 6500 +1159 4071 +1159 1385 +1159 3949 +1159 6001 +1159 5362 +1159 7798 +1160 9090 +1160 6827 +1160 3140 +1160 6062 +1160 9161 +1160 6375 +1160 9230 +1160 7293 +1160 1269 +1160 8210 +1160 8948 +1160 3015 +1160 9655 +1160 1336 +1160 2769 +1160 5435 +1160 9244 +1160 9838 +1160 9055 +1161 8333 +1161 6424 +1161 4764 +1161 2080 +1161 5668 +1161 2856 +1161 4791 +1161 7738 +1161 7877 +1161 5449 +1161 5198 +1161 1528 +1161 8279 +1161 1892 +1161 5222 +1161 9447 +1161 6120 +1161 6776 +1161 3944 +1161 2930 +1161 4329 +1162 2571 +1162 8461 +1162 8207 +1162 2704 +1162 7860 +1162 6807 +1162 6563 +1162 3760 +1162 1716 +1162 9012 +1162 3923 +1162 1602 +1162 2873 +1162 2125 +1162 6819 +1162 6101 +1162 7511 +1162 3291 +1162 4831 +1162 9697 +1162 3665 +1162 6637 +1162 3182 +1162 2931 +1162 9595 +1162 2046 +1163 9184 +1163 7137 +1163 7236 +1163 3862 +1163 9076 +1163 3977 +1163 5867 +1163 2062 +1163 4817 +1163 4658 +1163 9396 +1163 3765 +1163 6038 +1163 4921 +1163 9742 +1163 8634 +1163 1342 +1164 3458 +1164 4991 +1164 1983 +1164 8710 +1164 9767 +1164 3147 +1164 1390 +1164 8687 +1164 1302 +1164 7581 +1164 4124 +1164 9277 +1164 3230 +1164 4287 +1165 8926 +1165 9185 +1165 1755 +1165 1663 +1165 2841 +1165 1777 +1165 8818 +1165 1758 +1165 1782 +1165 7191 +1165 2526 +1165 5332 +1165 8603 +1165 9253 +1165 8542 +1165 6527 +1166 4610 +1166 5507 +1166 6658 +1166 3347 +1166 6676 +1166 3357 +1166 7583 +1166 9126 +1166 1319 +1166 6959 +1166 5171 +1166 7228 +1166 8002 +1166 6086 +1166 6669 +1166 9557 +1166 1753 +1166 5728 +1166 8686 +1166 3440 +1166 9843 +1166 7671 +1166 9982 +1167 4994 +1167 1797 +1167 7178 +1167 8459 +1167 7838 +1167 8611 +1167 2212 +1167 7208 +1167 2095 +1167 4150 +1167 8126 +1167 2495 +1167 8128 +1167 1974 +1167 1607 +1167 5833 +1167 8656 +1167 8923 +1167 6369 +1167 2662 +1167 8937 +1167 7544 +1167 5113 +1168 8001 +1168 2502 +1168 9606 +1168 2633 +1168 1258 +1168 8876 +1168 5750 +1168 9070 +1168 7277 +1168 2872 +1168 2006 +1168 4055 +1168 4152 +1168 1338 +1168 7995 +1168 3290 +1168 5821 +1168 9598 +1169 9475 +1169 2501 +1169 1929 +1169 5868 +1169 7213 +1169 6962 +1169 7501 +1169 8664 +1169 1906 +1169 3075 +1169 9588 +1169 6485 +1169 5910 +1169 5399 +1169 7800 +1169 5562 +1169 8191 +1169 5013 +1170 1954 +1170 8543 +1170 6524 +1170 9930 +1170 1355 +1170 1325 +1170 7695 +1170 6386 +1170 2324 +1170 6361 +1170 4639 +1170 1758 +1170 8607 +1171 6596 +1171 4966 +1171 3509 +1171 6029 +1171 6285 +1171 9045 +1171 3415 +1171 3034 +1171 3355 +1171 6909 +1171 6359 +1172 3744 +1172 7264 +1172 8098 +1172 8483 +1172 4580 +1172 7781 +1172 2054 +1172 5352 +1172 7401 +1172 5698 +1172 9102 +1172 4228 +1172 6097 +1172 8181 +1172 5973 +1172 1849 +1172 8549 +1173 7298 +1173 8712 +1173 7948 +1173 5520 +1173 1425 +1173 3346 +1173 5142 +1173 3102 +1173 4262 +1173 1580 +1173 2355 +1173 7734 +1173 2744 +1173 5830 +1173 7120 +1173 6456 +1173 2276 +1173 4457 +1173 2916 +1173 1513 +1173 9330 +1173 9718 +1173 5993 +1173 1274 +1173 5116 +1173 1790 +1174 4192 +1174 6912 +1174 2823 +1174 3848 +1174 9930 +1174 8327 +1174 4242 +1174 5135 +1174 8275 +1174 3989 +1174 9499 +1174 4586 +1175 3075 +1175 6935 +1175 3221 +1175 4503 +1175 2077 +1175 9893 +1175 2607 +1175 6966 +1175 9922 +1175 9156 +1175 3254 +1175 9031 +1175 7581 +1175 9178 +1175 8287 +1175 4580 +1175 4080 +1175 1523 +1175 4092 +1175 3327 +1176 1931 +1176 2066 +1176 7064 +1176 1572 +1176 6572 +1176 5427 +1176 7610 +1176 7868 +1176 2112 +1176 1398 +1176 9030 +1176 4938 +1176 1227 +1176 6611 +1176 3284 +1176 3167 +1176 8294 +1176 7143 +1176 3950 +1176 7279 +1176 5492 +1176 6134 +1176 6356 +1177 6061 +1177 8482 +1177 5739 +1177 6086 +1177 1511 +1177 4585 +1177 2795 +1177 4077 +1177 7534 +1177 9199 +1177 6288 +1177 6099 +1177 7352 +1177 3419 +1177 4735 +1178 5120 +1178 4496 +1178 4194 +1178 2788 +1178 2342 +1178 3208 +1178 7146 +1178 4330 +1178 1294 +1178 2960 +1178 6898 +1178 1203 +1178 2740 +1178 4535 +1178 4377 +1178 7306 +1178 4767 +1179 5563 +1179 9541 +1179 6385 +1179 1929 +1179 7785 +1179 2930 +1179 6030 +1179 2705 +1179 9906 +1179 9623 +1179 8984 +1179 3097 +1179 9083 +1179 6076 +1179 3221 +1180 1281 +1180 1539 +1180 2052 +1180 2440 +1180 5260 +1180 6926 +1180 3986 +1180 5530 +1180 1443 +1180 6965 +1180 6074 +1180 3519 +1180 5446 +1180 8402 +1180 3923 +1180 3158 +1180 1367 +1180 2777 +1180 6114 +1180 4585 +1180 3948 +1180 4471 +1180 2426 +1181 2304 +1181 3617 +1181 3640 +1181 2857 +1181 9639 +1181 3180 +1181 2834 +1181 1713 +1181 8050 +1181 7155 +1181 5657 +1181 2393 +1181 3260 +1182 5584 +1182 2354 +1182 7959 +1182 5466 +1182 2843 +1182 6588 +1182 9022 +1183 1923 +1183 6564 +1183 1638 +1183 5190 +1183 8684 +1183 3094 +1183 6295 +1183 6744 +1183 4442 +1183 3375 +1183 1372 +1183 3806 +1183 4447 +1184 8071 +1184 8072 +1184 5007 +1184 4370 +1184 6424 +1184 8866 +1184 9657 +1184 6462 +1184 7487 +1184 6336 +1184 4291 +1184 2511 +1184 2899 +1184 6872 +1184 3727 +1184 6762 +1184 3692 +1184 4725 +1184 1654 +1184 1914 +1184 3391 +1185 6596 +1185 1833 +1185 3787 +1185 5260 +1185 4269 +1185 9359 +1185 4300 +1185 4949 +1185 2889 +1185 8548 +1185 3067 +1185 2270 +1186 2305 +1186 5923 +1186 3844 +1186 4037 +1186 7110 +1186 9116 +1186 2183 +1186 4621 +1186 6556 +1186 3057 +1186 7224 +1186 2361 +1186 6330 +1186 9980 +1187 9186 +1187 4459 +1187 1960 +1187 2507 +1187 8046 +1187 3117 +1187 1776 +1187 7509 +1187 3973 +1187 6469 +1188 6272 +1188 7173 +1188 7046 +1188 2193 +1188 2452 +1188 3357 +1188 2212 +1188 5926 +1188 3635 +1188 5685 +1188 2108 +1188 5438 +1188 7877 +1188 9544 +1188 1747 +1188 1367 +1188 6617 +1188 7002 +1188 7008 +1188 1251 +1188 4113 +1188 8945 +1189 7052 +1189 1309 +1189 4208 +1189 8355 +1189 7204 +1189 5036 +1189 4786 +1189 6601 +1189 4794 +1189 3389 +1189 6590 +1189 9801 +1189 3032 +1189 9566 +1189 1891 +1189 9835 +1189 6000 +1189 6770 +1189 4860 +1190 4256 +1190 8331 +1190 5796 +1190 7462 +1190 9726 +1190 4330 +1190 4903 +1190 5970 +1190 4337 +1190 3826 +1190 8212 +1190 5342 +1190 3414 +1190 8984 +1190 2297 +1190 6334 +1190 9269 +1191 4609 +1191 7747 +1191 7015 +1191 9897 +1191 5479 +1191 5068 +1191 5187 +1191 1877 +1191 9334 +1191 7838 +1191 9724 +1191 3369 +1191 9887 +1192 2432 +1192 2818 +1192 7043 +1192 4497 +1192 5270 +1192 2711 +1192 1956 +1192 8492 +1192 6586 +1192 8507 +1192 6469 +1192 3159 +1192 9305 +1192 6881 +1192 4962 +1192 5862 +1192 7270 +1192 5227 +1192 6900 +1192 6645 +1192 6391 +1192 3066 +1192 6267 +1192 7677 +1193 7811 +1193 8265 +1193 9386 +1193 6732 +1193 3725 +1193 9274 +1193 9114 +1193 7740 +1193 2725 +1193 7570 +1193 4138 +1193 5589 +1193 1262 +1193 9688 +1193 6364 +1193 9770 +1194 5891 +1194 6438 +1194 6121 +1194 8621 +1194 4432 +1194 2204 +1194 1430 +1194 2716 +1194 3263 +1195 3716 +1195 1798 +1195 1927 +1195 9246 +1195 2851 +1195 6950 +1195 1832 +1195 6953 +1195 3114 +1195 9645 +1195 5426 +1195 7486 +1195 5749 +1195 9029 +1195 2640 +1195 2779 +1195 8672 +1195 3043 +1195 4200 +1195 2035 +1195 2805 +1195 1398 +1195 8697 +1196 9664 +1196 8033 +1196 8696 +1196 3462 +1196 8742 +1196 9185 +1196 3756 +1196 3532 +1196 1297 +1196 8946 +1196 5141 +1196 2743 +1196 9880 +1196 9757 +1196 3581 +1196 8755 +1197 5665 +1197 3875 +1197 6437 +1197 9639 +1197 8272 +1197 2155 +1197 7948 +1197 6639 +1197 5104 +1197 9681 +1197 9995 +1197 4308 +1197 9470 +1197 2487 +1197 8793 +1197 6812 +1197 5630 +1197 7295 +1198 1696 +1198 2213 +1198 9379 +1198 8166 +1198 7017 +1198 5099 +1198 3704 +1198 9906 +1198 8607 +1198 7278 +1198 2551 +1198 1368 +1198 3257 +1198 4571 +1198 2748 +1198 5855 +1199 6112 +1199 1409 +1199 6146 +1199 3907 +1199 8342 +1199 1640 +1199 5161 +1199 9613 +1199 9871 +1199 6128 +1199 8019 +1199 7156 +1199 7702 +1199 7160 +1199 9529 +1199 2490 +1199 8061 +1199 4702 +1200 6400 +1200 2945 +1200 1680 +1200 9616 +1200 5011 +1200 3096 +1200 4420 +1200 2853 +1200 5182 +1200 2880 +1200 5700 +1200 1350 +1200 9551 +1200 3165 +1200 3057 +1200 1783 +1201 6497 +1201 9794 +1201 4131 +1201 6180 +1201 2854 +1201 7750 +1201 5511 +1201 7638 +1201 5002 +1201 2289 +1201 7372 +1201 2626 +1201 8975 +1201 1731 +1201 9427 +1201 4625 +1201 4118 +1201 7323 +1202 3648 +1202 5952 +1202 9666 +1202 8833 +1202 5515 +1202 8556 +1202 2061 +1202 8401 +1202 2804 +1202 3925 +1202 2744 +1202 1500 +1203 7809 +1203 4460 +1203 5519 +1203 9877 +1203 6552 +1203 6362 +1203 5672 +1203 4024 +1203 7611 +1203 2890 +1203 8183 +1203 7770 +1203 2063 +1203 1638 +1203 8040 +1203 9580 +1203 7799 +1204 9232 +1204 4102 +1204 4817 +1204 5352 +1204 4556 +1204 9037 +1204 1485 +1204 1734 +1204 3249 +1204 3414 +1204 1815 +1204 9470 +1204 1503 +1205 6144 +1205 9993 +1205 4875 +1205 3345 +1205 4638 +1205 6310 +1205 8245 +1205 2999 +1205 6459 +1205 6453 +1205 3014 +1205 6215 +1205 7523 +1205 1681 +1205 9849 +1205 9085 +1206 7616 +1206 9986 +1206 4196 +1206 7733 +1206 9391 +1206 2414 +1206 1679 +1206 1298 +1206 4563 +1206 8142 +1206 6360 +1206 7758 +1206 8637 +1206 5918 +1206 4917 +1207 9984 +1207 1665 +1207 1635 +1207 6246 +1207 8289 +1207 9104 +1207 4433 +1207 1490 +1207 3923 +1207 8308 +1207 2645 +1207 6006 +1207 7384 +1207 7322 +1207 1425 +1207 5434 +1208 9730 +1208 9739 +1208 9239 +1208 1435 +1208 9885 +1208 4382 +1208 6433 +1208 6233 +1208 3384 +1208 3643 +1208 7373 +1208 6992 +1208 6867 +1208 1497 +1208 5856 +1208 3939 +1208 6758 +1208 1905 +1209 5923 +1209 3396 +1209 5258 +1209 6455 +1209 2669 +1209 5872 +1209 3096 +1209 9778 +1209 3124 +1209 4789 +1209 7990 +1209 8151 +1209 9444 +1209 8570 +1209 4249 +1210 9857 +1210 6115 +1210 3009 +1210 4658 +1210 6675 +1210 6646 +1210 2777 +1210 5404 +1211 3489 +1211 2340 +1211 7877 +1211 2886 +1211 3848 +1211 5420 +1211 8813 +1211 6574 +1211 6256 +1211 1777 +1211 3063 +1211 9496 +1211 5689 +1211 5274 +1212 2689 +1212 8970 +1212 5903 +1212 3473 +1212 5650 +1212 1429 +1212 5788 +1212 5921 +1212 6948 +1212 8135 +1212 1839 +1212 8628 +1212 2232 +1212 8865 +1212 1236 +1212 3290 +1212 9563 +1212 9309 +1212 9957 +1212 9312 +1212 9573 +1212 4840 +1212 4264 +1213 2180 +1213 2443 +1213 6924 +1213 5007 +1213 1427 +1213 1817 +1213 1318 +1213 4778 +1213 4524 +1213 7601 +1213 5561 +1213 2499 +1213 3655 +1213 2504 +1213 8021 +1213 6742 +1213 8154 +1213 5344 +1213 5608 +1213 7919 +1213 1322 +1214 1295 +1214 3099 +1214 8351 +1214 6688 +1214 1954 +1214 1443 +1214 2218 +1214 5166 +1214 2240 +1214 1345 +1214 8020 +1214 7517 +1214 5226 +1214 1515 +1214 9967 +1214 5104 +1214 3963 +1214 3580 +1214 3454 +1214 9983 +1215 3586 +1215 9603 +1215 5132 +1215 4752 +1215 7058 +1215 2326 +1215 4506 +1215 5274 +1215 4255 +1215 6703 +1215 3645 +1215 8768 +1215 8893 +1215 7242 +1215 7244 +1215 7888 +1215 6993 +1215 6740 +1215 4058 +1215 3934 +1215 1248 +1215 6374 +1215 7826 +1215 8060 +1215 7805 +1216 7489 +1216 6530 +1216 8804 +1216 5194 +1216 4812 +1216 1976 +1216 4148 +1216 7765 +1216 3638 +1216 8983 +1216 4856 +1216 8697 +1216 1692 +1216 9471 +1217 9607 +1217 8072 +1217 9742 +1217 5140 +1217 2350 +1217 1431 +1217 3609 +1217 1562 +1217 2843 +1217 7838 +1217 3114 +1217 2221 +1217 8110 +1217 6831 +1217 6456 +1217 5057 +1217 1869 +1217 1372 +1217 7396 +1217 5999 +1217 3825 +1217 9718 +1217 9210 +1218 6881 +1218 3155 +1218 8715 +1218 9963 +1218 7912 +1218 6186 +1218 8427 +1218 5228 +1218 7181 +1218 2095 +1218 4786 +1218 6631 +1218 6836 +1218 8950 +1218 6583 +1218 9976 +1218 2106 +1218 8060 +1219 8708 +1219 2067 +1219 4719 +1219 5789 +1219 4638 +1219 6821 +1219 1830 +1219 8369 +1219 1716 +1219 9141 +1219 4153 +1219 1981 +1219 9670 +1219 9524 +1219 5706 +1219 6608 +1219 6995 +1219 6996 +1219 9313 +1219 2530 +1219 5487 +1219 7930 +1219 2683 +1220 7172 +1220 4878 +1220 2837 +1220 2582 +1220 9879 +1220 2351 +1220 2843 +1220 8751 +1220 6708 +1220 5943 +1220 9145 +1220 7357 +1220 9281 +1220 5448 +1220 6985 +1220 7754 +1220 3662 +1220 6097 +1220 2645 +1220 7517 +1220 2018 +1220 9446 +1220 4842 +1220 3695 +1220 4726 +1220 1784 +1220 8085 +1221 4487 +1221 1803 +1221 2963 +1221 8212 +1221 5404 +1221 5917 +1221 8999 +1221 6448 +1221 4153 +1221 3779 +1221 1734 +1221 2378 +1221 4687 +1221 7890 +1221 8022 +1221 3675 +1221 8287 +1221 4717 +1221 2931 +1221 1918 +1222 2049 +1222 9218 +1222 5771 +1222 7828 +1222 4014 +1222 9648 +1222 3505 +1222 8630 +1222 9504 +1222 3276 +1222 7641 +1222 1635 +1222 7141 +1222 1511 +1222 6132 +1222 3068 +1222 9855 +1223 7169 +1223 7363 +1223 7428 +1223 7431 +1223 5418 +1223 2119 +1223 3635 +1223 5300 +1223 5764 +1223 4989 +1223 8510 +1224 9857 +1224 5384 +1224 9097 +1224 5904 +1224 7954 +1224 3356 +1224 3234 +1224 1448 +1224 7870 +1224 2751 +1224 6722 +1224 5192 +1224 1626 +1224 6115 +1224 5607 +1224 7279 +1224 3187 +1224 3958 +1224 4728 +1225 6913 +1225 7852 +1225 5060 +1225 7110 +1225 4680 +1225 7721 +1225 3691 +1225 3628 +1225 3297 +1225 5840 +1225 3843 +1225 2841 +1225 2873 +1225 6842 +1225 9755 +1226 9664 +1226 6369 +1226 4539 +1226 9380 +1226 3653 +1226 8710 +1226 6439 +1226 4651 +1226 8142 +1226 7247 +1226 7024 +1226 4465 +1226 3315 +1226 2673 +1226 7000 +1226 7960 +1226 7226 +1226 8539 +1226 3807 +1227 8450 +1227 3171 +1227 8005 +1227 7242 +1227 1963 +1227 9773 +1227 6862 +1227 7037 +1227 1969 +1227 5714 +1227 1243 +1227 3356 +1227 3274 +1227 6603 +1227 2245 +1228 9635 +1228 3173 +1228 3819 +1228 6696 +1228 1648 +1228 1521 +1228 4948 +1228 5719 +1228 8346 +1228 1628 +1228 2653 +1228 5429 +1229 9312 +1229 7298 +1229 5700 +1229 6630 +1229 7910 +1229 7881 +1229 2078 +1229 6124 +1229 4482 +1229 7586 +1229 5587 +1229 7639 +1229 7864 +1229 6622 +1229 6693 +1230 2061 +1230 9870 +1230 1687 +1230 3618 +1230 7336 +1230 2396 +1230 6060 +1230 9283 +1230 5833 +1230 7501 +1230 1487 +1230 7385 +1230 5978 +1230 6876 +1230 3933 +1230 9694 +1230 1774 +1230 2416 +1230 2674 +1230 6902 +1230 3069 +1231 6657 +1231 3848 +1231 7434 +1231 5259 +1231 3857 +1231 8597 +1231 8599 +1231 8994 +1231 9767 +1231 6067 +1231 5473 +1231 7091 +1231 2398 +1231 6239 +1231 1377 +1231 5098 +1231 5870 +1231 8047 +1231 3317 +1231 6134 +1232 4512 +1232 6117 +1232 3591 +1232 1258 +1232 1399 +1232 5421 +1232 7952 +1232 8722 +1232 4723 +1232 4501 +1232 7545 +1232 3578 +1232 2043 +1232 5789 +1232 1429 +1233 1408 +1233 8706 +1233 2055 +1233 1544 +1233 7563 +1233 9613 +1233 6426 +1233 8865 +1233 7721 +1233 9389 +1233 2824 +1233 8122 +1233 3004 +1233 8901 +1233 5964 +1233 5970 +1233 2899 +1233 1493 +1233 9956 +1233 2414 +1233 9973 +1233 3706 +1234 3490 +1234 3122 +1234 2790 +1234 3658 +1234 5218 +1234 7182 +1234 8143 +1234 8376 +1234 3154 +1234 3351 +1234 4408 +1234 5023 +1234 8671 +1235 8066 +1235 7555 +1235 9028 +1235 3729 +1235 5564 +1235 2059 +1235 3440 +1235 3416 +1235 5791 +1235 8564 +1235 2582 +1235 8376 +1235 6276 +1235 4090 +1235 9947 +1235 6076 +1235 3834 +1235 9119 +1236 9153 +1236 7842 +1236 6596 +1236 9350 +1236 8257 +1236 6762 +1236 9095 +1236 4845 +1236 1487 +1236 1936 +1236 9633 +1236 1363 +1236 9877 +1236 8528 +1236 5723 +1236 1885 +1236 3742 +1236 3925 +1237 6752 +1237 7971 +1237 4877 +1237 6345 +1237 2826 +1237 4951 +1237 3890 +1237 6669 +1237 3570 +1237 4978 +1237 3795 +1237 6453 +1237 4726 +1237 5207 +1237 8603 +1238 4448 +1238 1697 +1238 9186 +1238 8969 +1238 7911 +1238 3564 +1238 3692 +1238 7130 +1238 6328 +1238 3668 +1238 4309 +1238 1527 +1238 9208 +1238 3545 +1238 8090 +1238 1972 +1238 2716 +1238 8253 +1238 2015 +1239 8929 +1239 9304 +1239 1582 +1239 3731 +1239 9065 +1239 3664 +1239 7757 +1239 2830 +1239 4431 +1239 4725 +1239 6801 +1239 2739 +1239 4852 +1239 1653 +1239 9367 +1239 9423 +1239 5055 +1240 2819 +1240 3332 +1240 2825 +1240 4234 +1240 3342 +1240 5779 +1240 9242 +1240 6952 +1240 7339 +1240 5036 +1240 9647 +1240 9283 +1240 2629 +1240 8520 +1240 4682 +1240 8784 +1240 9181 +1240 5731 +1240 7656 +1240 2409 +1240 7660 +1240 6644 +1240 2550 +1240 1655 +1241 3553 +1241 5346 +1241 3523 +1241 2886 +1241 6950 +1241 5320 +1241 2890 +1241 1579 +1241 7650 +1241 4563 +1241 3887 +1241 2768 +1241 5352 +1241 7667 +1241 2262 +1241 3319 +1241 5625 +1241 2778 +1242 8960 +1242 2284 +1242 7308 +1242 1686 +1242 2714 +1242 5537 +1242 3765 +1242 6077 +1242 6470 +1242 6983 +1242 6228 +1242 6487 +1242 8664 +1242 3034 +1242 1245 +1242 3429 +1242 8808 +1242 2924 +1242 6638 +1242 6383 +1242 5874 +1242 7412 +1242 9594 +1243 7950 +1243 5269 +1243 4464 +1243 6946 +1243 3238 +1243 2216 +1243 4906 +1243 3503 +1243 7605 +1243 2493 +1243 3007 +1243 2627 +1243 1995 +1243 4047 +1243 9176 +1243 8304 +1243 6897 +1243 4853 +1243 3647 +1244 6951 +1244 2216 +1244 3338 +1244 1516 +1244 9970 +1244 6514 +1244 6739 +1244 3892 +1244 7081 +1244 7960 +1244 4058 +1244 4092 +1244 4733 +1244 9822 +1244 9567 +1245 6819 +1245 6212 +1245 2630 +1245 2823 +1245 2156 +1245 7741 +1245 5681 +1245 9108 +1245 8790 +1245 9753 +1245 1464 +1245 5145 +1245 9434 +1246 1758 +1246 3856 +1246 1351 +1246 8435 +1246 5833 +1246 4158 +1246 5740 +1246 9517 +1246 4400 +1246 8307 +1246 4469 +1246 7447 +1246 7175 +1246 2618 +1246 5118 +1247 9220 +1247 5771 +1247 9744 +1247 4501 +1247 9241 +1247 8795 +1247 6824 +1247 4393 +1247 2732 +1247 4529 +1247 6330 +1247 9019 +1247 2749 +1247 8254 +1247 4159 +1247 7489 +1247 8003 +1247 8904 +1247 3283 +1247 8665 +1247 8027 +1247 5213 +1247 2791 +1247 5821 +1247 5360 +1248 8591 +1248 4503 +1248 8089 +1248 2204 +1248 2207 +1248 5283 +1248 1956 +1248 3749 +1248 6316 +1248 2742 +1248 3774 +1248 1858 +1248 9284 +1248 7243 +1248 9549 +1248 2260 +1248 2539 +1248 6768 +1248 5694 +1248 6612 +1248 6906 +1249 4224 +1249 4002 +1249 9316 +1249 4293 +1249 5606 +1249 9671 +1249 3336 +1249 5610 +1249 3197 +1249 3120 +1249 6131 +1249 4148 +1249 3929 +1249 9564 +1249 5757 +1249 5509 +1250 8641 +1250 3088 +1250 7449 +1250 3482 +1250 3488 +1250 2485 +1250 5308 +1250 7487 +1250 1728 +1250 2881 +1250 4546 +1250 9930 +1250 2261 +1250 6749 +1250 5520 +1250 8293 +1250 2409 +1250 5503 +1250 5630 +1250 3285 +1251 3200 +1251 4961 +1251 7202 +1251 3699 +1251 2532 +1251 5766 +1251 6023 +1251 9576 +1251 4604 +1251 6766 +1251 6099 +1251 7412 +1251 4149 +1251 9334 +1251 4889 +1251 2776 +1251 8153 +1251 6876 +1251 1887 +1252 8032 +1252 1988 +1252 9934 +1252 1938 +1252 9140 +1252 9833 +1252 5689 +1252 2684 +1253 8198 +1253 2191 +1253 9232 +1253 8724 +1253 3232 +1253 7202 +1253 4925 +1253 3646 +1253 2497 +1253 4803 +1253 4936 +1253 9038 +1253 6354 +1253 2773 +1253 5345 +1253 2279 +1253 8680 +1253 2155 +1253 7151 +1253 3571 +1253 4500 +1254 9344 +1254 8993 +1254 6340 +1254 8232 +1254 9788 +1254 6483 +1254 2286 +1254 5776 +1254 5361 +1254 8914 +1254 2611 +1254 5460 +1254 4630 +1254 4152 +1254 1820 +1254 7165 +1254 2014 +1255 9732 +1255 5765 +1255 9606 +1255 5001 +1255 9102 +1255 2575 +1255 8336 +1255 2584 +1255 1436 +1255 3361 +1255 7331 +1255 7598 +1255 6575 +1255 8499 +1255 4535 +1255 2115 +1255 7621 +1255 6996 +1255 9686 +1255 9310 +1255 8807 +1255 5998 +1255 2935 +1256 6017 +1256 2274 +1256 8875 +1256 2918 +1256 1995 +1256 5328 +1256 8335 +1256 8144 +1256 7544 +1256 6675 +1256 3030 +1256 2168 +1256 6362 +1256 7055 +1256 3036 +1256 7270 +1257 3681 +1257 4412 +1257 2701 +1257 6866 +1257 8470 +1257 3676 +1258 8216 +1258 9757 +1258 8880 +1258 5795 +1258 4132 +1258 1318 +1258 9001 +1258 2474 +1258 2219 +1258 3256 +1258 4926 +1258 8260 +1258 9415 +1258 1481 +1258 8781 +1258 3154 +1258 6751 +1258 5344 +1258 6255 +1258 8177 +1258 2936 +1258 6265 +1258 2683 +1258 7550 +1258 5119 +1259 4741 +1259 6925 +1259 4624 +1259 8083 +1259 2974 +1259 6341 +1259 6827 +1259 7214 +1259 3177 +1259 8898 +1259 8387 +1259 4726 +1259 6984 +1259 6391 +1259 9807 +1259 2774 +1259 3728 +1259 1641 +1259 8559 +1259 7542 +1259 8183 +1260 8257 +1260 8517 +1260 7585 +1260 7624 +1260 4906 +1260 7917 +1260 4786 +1260 9813 +1260 9046 +1260 8431 +1260 9245 +1261 5760 +1261 4482 +1261 5955 +1261 3204 +1261 5873 +1261 8073 +1261 2922 +1261 9741 +1261 9358 +1261 6384 +1261 4569 +1261 3352 +1261 2617 +1261 5274 +1261 1500 +1261 1885 +1261 9343 +1262 6064 +1262 1702 +1262 9864 +1262 6999 +1262 4365 +1262 3918 +1262 4335 +1262 3632 +1262 4808 +1262 9939 +1262 6934 +1262 7831 +1262 9496 +1262 4188 +1262 8062 +1262 3775 +1263 9478 +1263 5638 +1263 2537 +1263 2090 +1263 2583 +1263 8172 +1263 5357 +1263 9966 +1263 6095 +1263 6545 +1263 7825 +1263 9085 +1263 4307 +1263 3766 +1263 7081 +1263 2954 +1264 6657 +1264 9027 +1264 2308 +1264 9393 +1264 9833 +1264 7274 +1264 7607 +1264 7117 +1264 4238 +1264 2059 +1264 7474 +1264 9655 +1264 5368 +1264 3801 +1264 7930 +1264 8926 +1264 4639 +1265 7936 +1265 3592 +1265 6670 +1265 7960 +1265 5663 +1265 9764 +1265 7208 +1265 2218 +1265 5566 +1265 1351 +1265 4170 +1265 5323 +1265 6991 +1265 6873 +1265 7529 +1265 6379 +1265 5358 +1265 3368 +1265 2675 +1265 6004 +1265 2429 +1266 8326 +1266 5395 +1266 3101 +1266 3615 +1266 5536 +1266 9123 +1266 4132 +1266 6567 +1266 6954 +1266 5547 +1266 9398 +1266 4427 +1266 9680 +1266 4178 +1266 9556 +1266 5853 +1266 3045 +1266 7784 +1266 2924 +1266 5870 +1266 3176 +1266 6644 +1267 8832 +1267 3362 +1267 8357 +1267 7750 +1267 1319 +1267 6440 +1267 8265 +1267 7978 +1267 1709 +1267 9332 +1267 5213 +1267 6206 +1268 4741 +1268 3721 +1268 4234 +1268 2706 +1268 8342 +1268 5143 +1268 4634 +1268 3951 +1268 3869 +1268 7455 +1268 8487 +1268 1576 +1268 7084 +1268 9005 +1268 7214 +1268 1285 +1268 9169 +1268 3028 +1268 9337 +1268 4828 +1268 8913 +1268 8047 +1268 7380 +1269 1298 +1269 8603 +1269 7325 +1269 7326 +1269 6573 +1269 3641 +1269 8506 +1269 6210 +1269 5963 +1269 6857 +1269 8139 +1269 9179 +1269 1373 +1269 1378 +1269 3944 +1269 6387 +1269 7668 +1269 5111 +1270 3985 +1270 1761 +1270 9723 +1270 8068 +1270 2145 +1270 7527 +1270 4840 +1270 7401 +1270 2190 +1270 5460 +1270 6811 +1270 5660 +1271 4224 +1271 7393 +1271 9188 +1271 3717 +1271 8326 +1271 9131 +1271 6479 +1271 3094 +1271 2205 +1271 9726 +1271 5823 +1272 5731 +1272 5124 +1272 9349 +1272 2217 +1272 7370 +1272 1711 +1272 5699 +1272 8611 +1272 5844 +1272 5143 +1272 9748 +1272 2947 +1272 7069 +1272 4682 +1273 8161 +1273 2275 +1273 2020 +1273 4709 +1273 2310 +1273 6705 +1273 2263 +1273 4332 +1273 8144 +1273 7570 +1273 4563 +1273 7636 +1273 7923 +1273 4504 +1273 3610 +1273 9563 +1273 8956 +1273 1309 +1273 5727 +1274 4267 +1274 8260 +1274 7749 +1274 6503 +1274 8427 +1274 4236 +1274 9166 +1274 4528 +1274 6947 +1274 4597 +1274 6551 +1274 1337 +1274 5758 +1274 3349 +1275 1538 +1275 8453 +1275 4774 +1275 1799 +1275 6121 +1275 3658 +1275 7117 +1275 3763 +1275 2292 +1275 2741 +1275 4150 +1275 9525 +1276 7504 +1276 7874 +1276 6917 +1276 6150 +1276 5927 +1276 4488 +1276 7721 +1276 6059 +1276 5421 +1276 6862 +1276 7376 +1276 9297 +1276 8500 +1276 6389 +1276 4758 +1276 2266 +1276 8735 +1276 7805 +1277 7683 +1277 7816 +1277 3601 +1277 4116 +1277 7598 +1277 5784 +1277 6041 +1277 6811 +1277 8489 +1277 3372 +1277 9646 +1277 4655 +1277 1597 +1277 2117 +1277 3910 +1277 1355 +1277 2639 +1277 4570 +1277 3302 +1277 3950 +1277 1651 +1277 3318 +1277 9080 +1278 3584 +1278 4481 +1278 8868 +1278 5701 +1278 4678 +1278 9201 +1278 8617 +1278 8427 +1278 5197 +1278 8496 +1278 2929 +1278 3154 +1278 2259 +1278 6166 +1278 9435 +1278 6560 +1278 4447 +1279 2529 +1279 5636 +1279 8901 +1279 5640 +1279 9097 +1279 7946 +1279 6894 +1279 4784 +1279 3539 +1279 2222 +1279 2102 +1279 7769 +1279 9112 +1279 8601 +1279 5019 +1279 2329 +1279 5855 +1280 2786 +1280 5095 +1280 2856 +1280 4713 +1280 1328 +1280 9832 +1280 4373 +1280 8532 +1280 4185 +1280 6356 +1280 4415 +1280 7966 +1280 9813 +1281 5252 +1281 3542 +1281 3334 +1281 5257 +1281 3466 +1281 3595 +1281 9617 +1281 1824 +1281 9506 +1281 8489 +1281 5547 +1281 8241 +1281 2106 +1281 3905 +1281 2503 +1281 9171 +1281 5078 +1281 7569 +1281 5353 +1281 8819 +1281 5404 +1282 3610 +1282 7876 +1282 2860 +1282 7901 +1282 1680 +1282 7416 +1282 2739 +1282 7127 +1282 2230 +1282 4828 +1282 8696 +1282 8121 +1282 1402 +1282 3740 +1282 1530 +1282 9214 +1282 3007 +1283 1568 +1283 5633 +1283 5123 +1283 7748 +1283 7686 +1283 6150 +1283 4362 +1283 8352 +1283 4846 +1283 9981 +1283 2805 +1283 2104 +1283 1594 +1283 7964 +1283 7485 +1284 5381 +1284 1288 +1284 6282 +1284 5900 +1284 2712 +1284 3102 +1284 5291 +1284 3631 +1284 8625 +1284 4402 +1284 6074 +1284 7102 +1284 9155 +1284 2956 +1284 9418 +1284 6865 +1284 2002 +1284 1881 +1284 6418 +1284 3822 +1285 6794 +1285 5004 +1285 5391 +1285 8849 +1285 3366 +1285 8234 +1285 3761 +1285 7735 +1285 7736 +1285 6720 +1285 5186 +1285 9929 +1285 4555 +1285 3023 +1285 5856 +1285 6497 +1285 1762 +1285 6246 +1285 2677 +1285 7546 +1285 5290 +1285 7678 +1285 1791 +1286 4864 +1286 3650 +1286 2163 +1286 5732 +1286 9558 +1286 5798 +1286 3882 +1286 3529 +1286 4843 +1286 6140 +1286 4146 +1286 6451 +1286 7284 +1286 1430 +1286 1818 +1286 5179 +1286 6230 +1286 2333 +1287 9614 +1287 2193 +1287 7704 +1287 4506 +1287 2970 +1287 2079 +1287 8486 +1287 4139 +1287 9900 +1287 8245 +1287 8248 +1287 1721 +1287 2107 +1287 9916 +1287 3134 +1287 6719 +1287 3608 +1287 3527 +1287 8650 +1287 3278 +1287 2254 +1287 3798 +1287 5211 +1287 7017 +1288 4705 +1288 8195 +1288 3205 +1288 9062 +1288 6761 +1288 6129 +1288 8147 +1288 2741 +1288 5879 +1288 5668 +1288 4443 +1288 2683 +1288 7133 +1288 4750 +1288 3839 +1289 7044 +1289 9097 +1289 4370 +1289 6553 +1289 6660 +1289 1948 +1289 7581 +1289 2337 +1289 1320 +1289 8496 +1289 9787 +1289 4030 +1289 3788 +1289 5587 +1289 9175 +1289 8538 +1289 7644 +1289 6715 +1289 6162 +1289 1646 +1289 3569 +1290 6707 +1290 9298 +1290 5093 +1290 5958 +1290 1896 +1290 3279 +1290 6129 +1290 1330 +1290 6483 +1290 4149 +1290 9753 +1290 9919 +1290 9660 +1290 9822 +1291 2950 +1291 7377 +1291 5289 +1291 3575 +1291 8301 +1291 3791 +1291 3376 +1291 9553 +1291 1395 +1291 5063 +1291 5271 +1291 2965 +1291 2266 +1291 7643 +1291 9338 +1291 9278 +1291 1385 +1292 3072 +1292 1558 +1292 3350 +1292 8735 +1292 8866 +1292 8236 +1292 2356 +1292 4406 +1292 8504 +1292 1439 +1292 5438 +1292 4546 +1292 2903 +1292 8794 +1292 6751 +1292 3046 +1292 9703 +1292 3945 +1292 5116 +1293 6285 +1293 4635 +1293 9008 +1293 9656 +1293 4159 +1293 7752 +1293 8778 +1293 9294 +1293 6357 +1293 3168 +1293 8812 +1293 2285 +1293 3438 +1293 6768 +1293 7539 +1293 9332 +1293 5626 +1294 2243 +1294 5925 +1294 7121 +1294 3336 +1294 5193 +1294 7274 +1294 2638 +1294 7752 +1294 7784 +1294 1332 +1294 8622 +1294 6678 +1294 5756 +1294 7610 +1294 4991 +1295 7431 +1295 2185 +1295 8849 +1295 6551 +1295 8353 +1295 5284 +1295 1707 +1295 6319 +1295 9532 +1295 4293 +1295 3533 +1295 2771 +1295 8792 +1295 8417 +1295 8805 +1295 6133 +1295 6518 +1295 9213 +1296 2690 +1296 9827 +1296 1956 +1296 2629 +1296 5580 +1296 8076 +1296 8811 +1296 6764 +1296 6068 +1296 2121 +1296 7960 +1296 1572 +1296 5435 +1296 4798 +1297 6762 +1297 5152 +1297 6818 +1297 9635 +1297 7908 +1297 8773 +1297 5001 +1297 5130 +1297 4846 +1297 2607 +1297 2900 +1297 4181 +1297 8662 +1297 4951 +1297 5519 +1297 4063 +1298 6768 +1298 5730 +1298 8878 +1298 9848 +1298 8010 +1298 2795 +1298 3438 +1298 2745 +1298 1521 +1298 9491 +1298 6263 +1298 4952 +1298 9209 +1298 4187 +1298 3644 +1298 3199 +1299 5123 +1299 7048 +1299 5261 +1299 5263 +1299 6433 +1299 9765 +1299 8486 +1299 2983 +1299 7088 +1299 4658 +1299 7221 +1299 3767 +1299 6089 +1299 8163 +1299 4696 +1299 4316 +1299 2142 +1299 4449 +1299 3043 +1299 2791 +1299 8820 +1299 2040 +1299 6908 +1300 3712 +1300 3808 +1300 7044 +1300 9801 +1300 7178 +1300 5296 +1300 3601 +1300 7570 +1300 5685 +1300 3671 +1300 5561 +1300 2554 +1300 1373 +1300 8543 +1301 6372 +1301 3217 +1301 3464 +1301 7836 +1301 1361 +1301 8011 +1301 7916 +1301 6734 +1301 3407 +1301 2579 +1301 2366 +1301 3639 +1301 2015 +1301 6461 +1301 8574 +1301 9727 +1302 2722 +1302 2218 +1302 7979 +1302 2786 +1302 9203 +1302 2934 +1302 7019 +1302 3704 +1302 5499 +1302 7292 +1302 4475 +1303 8834 +1303 3715 +1303 5128 +1303 7053 +1303 8596 +1303 6683 +1303 7596 +1303 4912 +1303 9032 +1303 5431 +1303 3520 +1303 3525 +1303 7113 +1303 3027 +1303 5241 +1303 7518 +1303 8546 +1303 9209 +1303 8189 +1304 9056 +1304 2753 +1304 7915 +1304 6934 +1304 7976 +1304 1663 +1304 4427 +1304 7528 +1304 4589 +1304 6200 +1304 8434 +1304 3187 +1304 9237 +1304 6763 +1304 7064 +1304 4761 +1304 4351 +1304 6140 +1304 7870 +1305 4681 +1305 2585 +1305 3078 +1305 5446 +1305 1513 +1305 2506 +1305 9231 +1305 4825 +1305 5353 +1305 4233 +1305 9721 +1305 9403 +1305 1532 +1305 2079 +1306 1825 +1306 7684 +1306 4342 +1306 7719 +1306 8809 +1306 4973 +1306 4337 +1306 5365 +1306 3926 +1306 8817 +1306 9211 +1306 5919 +1307 2274 +1307 5540 +1307 5157 +1307 3366 +1307 3857 +1307 8682 +1307 3346 +1307 6383 +1307 1745 +1307 6066 +1307 2068 +1307 2072 +1307 3608 +1307 5583 +1307 1546 +1308 9216 +1308 2306 +1308 2916 +1308 5509 +1308 2729 +1308 8748 +1308 3685 +1308 7821 +1308 8782 +1308 3821 +1308 6770 +1308 4085 +1308 6168 +1308 5434 +1308 7229 +1308 5285 +1309 2018 +1309 5901 +1309 6086 +1309 2726 +1309 6569 +1309 4010 +1309 2700 +1309 2050 +1309 5359 +1309 2152 +1309 9800 +1309 3509 +1309 4364 +1309 2786 +1309 6822 +1310 8072 +1310 8331 +1310 5009 +1310 5522 +1310 1559 +1310 3352 +1310 3107 +1310 9256 +1310 4141 +1310 5040 +1310 6360 +1310 4186 +1310 4190 +1310 3813 +1310 4449 +1310 8290 +1310 8165 +1310 6759 +1310 4335 +1310 3314 +1310 3955 +1310 7031 +1310 7825 +1310 1663 +1311 4610 +1311 4870 +1311 2570 +1311 5259 +1311 4501 +1311 4591 +1311 8731 +1311 2846 +1311 1695 +1311 2694 +1311 1961 +1311 2092 +1311 8238 +1311 8123 +1311 7753 +1311 2256 +1311 8532 +1311 7125 +1311 9697 +1311 7673 +1311 5653 +1312 7426 +1312 5644 +1312 2963 +1312 5406 +1312 6817 +1312 7597 +1312 9774 +1312 2504 +1312 4290 +1312 5572 +1312 8518 +1312 3400 +1312 8525 +1312 9805 +1312 5330 +1312 8277 +1312 1622 +1312 6874 +1312 2396 +1312 2528 +1312 4204 +1312 5753 +1312 9981 +1313 6113 +1313 1668 +1313 2481 +1313 7180 +1313 4366 +1313 5231 +1313 7856 +1313 2673 +1313 6354 +1313 4821 +1313 3511 +1313 8441 +1313 6876 +1313 5214 +1313 8223 +1314 2945 +1314 8503 +1314 9965 +1314 9444 +1314 3111 +1314 9671 +1314 6254 +1314 6409 +1314 3755 +1314 6572 +1314 8365 +1314 6894 +1314 6643 +1314 6769 +1314 3283 +1314 5454 +1314 9335 +1314 8889 +1314 4223 +1315 9729 +1315 2317 +1315 2973 +1315 2742 +1315 9225 +1315 5560 +1315 4797 +1315 6214 +1315 1864 +1315 6224 +1315 5978 +1315 4835 +1315 3046 +1315 7536 +1315 8948 +1315 6261 +1315 7930 +1316 8098 +1316 5923 +1316 6757 +1316 5382 +1316 9160 +1316 5834 +1316 9676 +1316 3982 +1316 4413 +1316 4042 +1316 9617 +1316 6354 +1316 4055 +1316 7642 +1316 8095 +1316 3356 +1316 6013 +1316 2558 +1316 5087 +1317 8768 +1317 1920 +1317 3555 +1317 2468 +1317 5480 +1317 1993 +1317 8458 +1317 8016 +1317 2355 +1317 5013 +1317 9754 +1318 4678 +1318 1702 +1318 9769 +1318 9712 +1318 5649 +1318 8884 +1318 3158 +1318 9335 +1318 4348 +1318 9318 +1318 9054 +1319 4932 +1319 7589 +1319 2631 +1319 7304 +1319 7865 +1319 7818 +1319 4365 +1319 9389 +1319 1428 +1319 3959 +1319 8394 +1319 8644 +1319 6045 +1319 2462 +1320 4870 +1320 2186 +1320 8717 +1320 7188 +1320 8222 +1320 5429 +1320 8841 +1320 3384 +1320 4799 +1320 3145 +1320 5330 +1320 6622 +1320 4953 +1320 9743 +1320 9309 +1320 3550 +1320 7912 +1320 6893 +1320 3952 +1320 3838 +1321 6497 +1321 2338 +1321 6438 +1321 7548 +1321 2502 +1321 6369 +1321 2665 +1321 3734 +1321 4939 +1321 1580 +1321 2542 +1321 7887 +1321 7299 +1321 9793 +1321 8801 +1321 5963 +1321 8732 +1321 3997 +1322 9603 +1322 5509 +1322 8333 +1322 5903 +1322 5011 +1322 6687 +1322 1971 +1322 8504 +1322 7360 +1322 3650 +1322 5188 +1322 7878 +1322 9676 +1322 4817 +1322 1362 +1322 1378 +1322 9190 +1322 7402 +1322 2671 +1322 9794 +1322 3704 +1322 4985 +1323 4354 +1323 4742 +1323 7049 +1323 6670 +1323 4888 +1323 2068 +1323 2071 +1323 2328 +1323 7710 +1323 7587 +1323 6205 +1323 9791 +1323 1857 +1323 2115 +1323 8776 +1323 9450 +1323 2549 +1323 3318 +1323 7295 +1324 3972 +1324 2829 +1324 4239 +1324 7592 +1324 3569 +1324 4392 +1324 9266 +1324 3386 +1324 5699 +1324 9284 +1324 1992 +1324 9673 +1324 3018 +1324 9548 +1324 6350 +1324 3667 +1324 2649 +1324 9274 +1324 3553 +1324 9579 +1324 9967 +1324 6824 +1324 8312 +1324 8571 +1325 6533 +1325 3334 +1325 9991 +1325 4639 +1325 3872 +1325 7587 +1325 7976 +1325 2476 +1325 1327 +1325 6453 +1325 4150 +1325 3396 +1325 7114 +1325 9763 +1325 1386 +1325 9711 +1325 4458 +1325 5496 +1325 7786 +1326 6432 +1326 2017 +1326 3940 +1326 6246 +1326 4712 +1326 4500 +1326 4620 +1326 8562 +1326 9903 +1326 9617 +1326 5618 +1326 1491 +1326 8084 +1326 9751 +1326 3097 +1326 6826 +1326 3614 +1326 6117 +1327 9344 +1327 3846 +1327 9232 +1327 8599 +1327 2719 +1327 5536 +1327 9508 +1327 8488 +1327 6443 +1327 5677 +1327 6460 +1327 6603 +1327 7502 +1327 9041 +1327 5587 +1327 3492 +1327 5211 +1327 8956 +1327 6767 +1327 3452 +1328 9409 +1328 5827 +1328 5638 +1328 3014 +1328 1706 +1328 5994 +1328 1357 +1328 9901 +1328 6384 +1328 8914 +1328 2371 +1328 8372 +1328 6870 +1328 6263 +1328 8697 +1328 3348 +1328 8122 +1328 9002 +1328 2910 +1328 4319 +1329 4259 +1329 9092 +1329 7942 +1329 8967 +1329 2056 +1329 4297 +1329 3693 +1329 2318 +1329 7279 +1329 8753 +1329 9554 +1329 9876 +1329 9966 +1329 1527 +1329 9117 +1329 5567 +1330 7072 +1330 4078 +1330 1932 +1330 2349 +1330 3438 +1330 3985 +1330 7027 +1330 1976 +1331 8224 +1331 7778 +1331 5059 +1331 7624 +1331 8876 +1331 1730 +1331 8558 +1331 2845 +1331 9328 +1331 4242 +1331 7150 +1331 5369 +1331 4383 +1332 6259 +1332 2308 +1332 1478 +1332 2876 +1332 7670 +1332 2283 +1332 3375 +1332 7344 +1332 7089 +1332 2226 +1332 9747 +1332 5397 +1332 2070 +1332 3305 +1332 4655 +1332 8220 +1332 6909 +1332 7854 +1333 3660 +1333 6818 +1333 1795 +1333 4908 +1333 6090 +1333 4364 +1333 9133 +1333 3120 +1333 6483 +1333 3481 +1333 5727 +1333 9243 +1333 4380 +1333 3579 +1334 2176 +1334 4246 +1334 4231 +1334 7112 +1334 4009 +1334 8391 +1334 9417 +1334 7725 +1334 9807 +1334 2696 +1334 9715 +1334 2837 +1334 3926 +1334 4663 +1334 6394 +1334 9375 +1334 5694 +1334 7717 +1335 1347 +1335 3557 +1335 2982 +1335 4391 +1335 7912 +1335 5033 +1335 9194 +1335 4460 +1335 3822 +1335 3824 +1335 4328 +1335 8163 +1335 7798 +1335 6020 +1335 6778 +1335 2461 +1335 6655 +1336 4546 +1336 3363 +1336 7619 +1336 6694 +1336 4519 +1336 2472 +1336 7271 +1336 8046 +1336 8207 +1336 2254 +1336 7957 +1336 2263 +1337 3969 +1337 6562 +1337 1968 +1337 5552 +1337 3303 +1337 6984 +1337 5385 +1337 2241 +1337 7244 +1337 9716 +1337 9200 +1337 4648 +1337 5091 +1337 5140 +1337 5529 +1337 8281 +1337 1726 +1338 2053 +1338 3601 +1338 5787 +1338 6431 +1338 9761 +1338 5410 +1338 3879 +1338 9782 +1338 8503 +1338 9148 +1338 6978 +1338 8773 +1338 7751 +1338 1483 +1338 5454 +1338 8664 +1338 2400 +1338 2401 +1338 9959 +1338 9579 +1338 7286 +1338 9983 +1339 8544 +1339 4129 +1339 8012 +1339 2634 +1339 4142 +1339 2252 +1339 3253 +1339 7008 +1339 4659 +1339 4116 +1339 6677 +1339 5783 +1339 4851 +1339 5471 +1340 9995 +1340 5008 +1340 6033 +1340 5660 +1340 1566 +1340 7473 +1340 4533 +1340 5943 +1340 6074 +1340 7237 +1340 3270 +1340 2896 +1340 9941 +1340 5871 +1340 6257 +1340 2170 +1340 2172 +1340 7806 +1341 5984 +1341 7617 +1341 3139 +1341 5787 +1341 8369 +1341 3347 +1341 5491 +1341 5521 +1341 6385 +1341 3570 +1341 2739 +1341 5600 +1341 3671 +1341 9499 +1341 9982 +1341 5407 +1342 2063 +1342 6292 +1342 3994 +1342 8481 +1342 1955 +1342 7462 +1342 3001 +1342 5316 +1342 3015 +1342 3784 +1342 8905 +1342 7498 +1342 7635 +1342 7508 +1342 8412 +1342 3238 +1342 4969 +1342 6645 +1342 9978 +1343 8579 +1343 4361 +1343 3349 +1343 5921 +1343 8228 +1343 7590 +1343 3243 +1343 3629 +1343 9527 +1343 7252 +1343 8288 +1343 8164 +1343 6375 +1343 9580 +1343 3313 +1343 4598 +1344 5762 +1344 9731 +1344 7558 +1344 9927 +1344 3220 +1344 1705 +1344 9643 +1344 6316 +1344 9654 +1344 1848 +1344 5819 +1344 9024 +1344 7073 +1344 2894 +1344 5334 +1344 2648 +1344 8550 +1344 8302 +1344 6517 +1344 5878 +1344 2168 +1345 8705 +1345 3339 +1345 9709 +1345 1570 +1345 6691 +1345 4519 +1345 7081 +1345 5300 +1345 8384 +1345 5580 +1345 6744 +1345 6873 +1345 2143 +1345 7529 +1345 8172 +1345 4333 +1345 2672 +1345 6514 +1345 2549 +1345 2806 +1345 6263 +1345 8699 +1346 9186 +1346 1901 +1346 3560 +1346 2412 +1346 1802 +1346 9687 +1346 2317 +1346 5935 +1346 8304 +1346 3925 +1346 8119 +1346 8554 +1346 5295 +1346 4988 +1346 3005 +1346 6270 +1346 5023 +1347 5284 +1347 8165 +1347 6513 +1347 2952 +1347 3849 +1347 9162 +1347 5815 +1347 6446 +1347 6927 +1347 4593 +1347 5503 +1347 3412 +1347 6574 +1347 4149 +1347 4023 +1347 9279 +1348 2886 +1348 4072 +1348 1380 +1348 6283 +1348 9359 +1348 3024 +1348 9490 +1348 9842 +1348 2969 +1348 7695 +1348 9593 +1348 2298 +1348 7707 +1348 5791 +1348 8125 +1348 7231 +1349 3611 +1349 4611 +1349 9925 +1349 6792 +1349 8490 +1349 7211 +1349 6668 +1349 3295 +1349 2757 +1349 7331 +1349 1867 +1349 7342 +1349 7227 +1349 3260 +1349 3973 +1350 3808 +1350 6939 +1350 5509 +1350 5350 +1350 7048 +1350 6971 +1350 1803 +1350 9421 +1350 6510 +1350 8488 +1350 2166 +1350 9224 +1350 6171 +1350 4700 +1351 9318 +1351 2279 +1351 9832 +1351 8237 +1351 8845 +1351 5709 +1351 1619 +1351 9306 +1351 4851 +1351 1530 +1351 7099 +1352 4066 +1352 8838 +1352 3815 +1352 8107 +1352 3180 +1352 5901 +1352 3695 +1352 3121 +1352 4115 +1352 2005 +1352 9145 +1352 2648 +1352 5337 +1352 6490 +1352 2938 +1353 1667 +1353 8356 +1353 8776 +1353 9835 +1353 2548 +1353 7470 +1353 1903 +1353 3600 +1353 4200 +1353 8402 +1353 6932 +1353 1557 +1353 5974 +1353 8153 +1353 3164 +1353 2645 +1354 2064 +1354 8853 +1354 4248 +1354 8474 +1354 5487 +1354 3102 +1354 7329 +1354 4654 +1354 4022 +1354 5833 +1354 3925 +1354 2524 +1354 5986 +1354 4198 +1354 3823 +1354 4594 +1354 4341 +1354 5501 +1354 1534 +1354 7381 +1355 8458 +1355 2027 +1355 3340 +1355 1518 +1355 9731 +1355 5587 +1355 8311 +1356 3330 +1356 7556 +1356 6935 +1356 3993 +1356 7707 +1356 9632 +1356 5538 +1356 8902 +1356 8107 +1356 2348 +1356 5168 +1356 2226 +1356 8262 +1356 4413 +1356 1605 +1356 3270 +1356 8521 +1356 5196 +1356 1871 +1356 7123 +1356 7892 +1356 6809 +1356 8691 +1356 9972 +1357 3458 +1357 2694 +1357 3219 +1357 9630 +1357 3487 +1357 8112 +1357 8099 +1357 1701 +1357 5542 +1357 1843 +1357 5686 +1357 5688 +1357 8510 +1357 4292 +1357 5574 +1357 5193 +1357 4687 +1357 7766 +1357 8152 +1357 6361 +1357 4198 +1357 3440 +1357 4347 +1358 9888 +1358 4224 +1358 8611 +1358 2724 +1358 8327 +1358 2225 +1358 4818 +1358 3502 +1358 8304 +1358 7313 +1358 2098 +1358 3991 +1358 1624 +1358 9147 +1359 7488 +1359 5506 +1359 4451 +1359 2533 +1359 4841 +1359 7242 +1359 5387 +1359 2541 +1359 6063 +1359 2576 +1359 3953 +1359 8341 +1359 1720 +1359 9250 +1359 9279 +1359 2046 +1359 4959 +1360 5658 +1360 7940 +1360 7622 +1360 9062 +1360 7785 +1360 1864 +1360 7865 +1360 4619 +1360 5581 +1360 6258 +1360 9972 +1360 6617 +1360 8281 +1360 6586 +1360 7642 +1360 5822 +1360 8933 +1361 6048 +1361 4577 +1361 1733 +1361 7210 +1361 8171 +1361 7180 +1361 5902 +1361 6895 +1361 5136 +1361 3155 +1361 1463 +1361 9914 +1361 8668 +1361 1498 +1362 8640 +1362 3586 +1362 3947 +1362 4808 +1362 7243 +1362 8588 +1362 4366 +1362 8720 +1362 8689 +1362 1558 +1362 9370 +1362 3933 +1363 2688 +1363 7873 +1363 8930 +1363 5541 +1363 7148 +1363 9611 +1363 2028 +1363 2180 +1363 2744 +1363 4374 +1363 9208 +1363 9204 +1363 2682 +1363 4157 +1363 4671 +1364 6784 +1364 5281 +1364 3618 +1364 9152 +1364 9424 +1364 6273 +1364 3338 +1364 2087 +1364 7948 +1364 6093 +1364 7280 +1364 4808 +1364 1587 +1364 7989 +1364 5053 +1364 6270 +1364 3679 +1365 1506 +1365 5003 +1365 4078 +1365 6199 +1365 5592 +1365 6233 +1365 2459 +1366 1793 +1366 3715 +1366 2180 +1366 2439 +1366 7838 +1366 8112 +1366 2367 +1366 5718 +1366 8280 +1366 2656 +1366 4962 +1366 4324 +1366 8294 +1366 1384 +1366 5225 +1366 7658 +1366 5869 +1366 4468 +1367 2656 +1367 5542 +1367 8359 +1367 4371 +1367 9852 +1367 5611 +1367 6029 +1367 8686 +1367 1776 +1367 6355 +1367 3350 +1367 1401 +1367 3452 +1368 9731 +1368 8839 +1368 7050 +1368 8844 +1368 5649 +1368 6172 +1368 6430 +1368 4769 +1368 5895 +1368 3504 +1368 8759 +1368 9419 +1368 1611 +1368 3540 +1368 9181 +1368 4459 +1368 2292 +1368 8439 +1368 1406 +1369 4992 +1369 8807 +1369 9379 +1369 5798 +1369 9521 +1369 3912 +1369 3626 +1369 2365 +1369 4253 +1369 2680 +1369 8629 +1369 8495 +1369 4856 +1369 8632 +1369 6523 +1369 2813 +1369 4958 +1370 2592 +1370 3392 +1370 8162 +1370 2755 +1370 5413 +1370 7622 +1370 5096 +1370 7753 +1370 6509 +1370 9667 +1370 5268 +1370 2870 +1370 6551 +1370 6516 +1370 7259 +1371 1601 +1371 7170 +1371 7003 +1371 8420 +1371 9093 +1371 7271 +1371 4136 +1371 3339 +1371 6941 +1371 1937 +1371 5569 +1371 4083 +1371 7894 +1371 1623 +1371 1912 +1371 3387 +1371 6170 +1371 2525 +1371 9183 +1372 8969 +1372 8719 +1372 7322 +1372 3675 +1372 3621 +1372 1447 +1372 8748 +1372 5746 +1372 6574 +1372 6963 +1372 9782 +1372 9783 +1372 3270 +1372 4564 +1372 7770 +1372 9487 +1372 5490 +1372 9470 +1373 8547 +1373 4491 +1373 4703 +1373 5514 +1373 8395 +1373 9516 +1373 5358 +1373 4303 +1373 9137 +1373 6707 +1373 3448 +1373 6751 +1373 2223 +1373 2698 +1373 9183 +1374 4231 +1374 8585 +1374 3978 +1374 8467 +1374 3861 +1374 1443 +1374 1702 +1374 7342 +1374 6456 +1374 1604 +1374 7367 +1374 2892 +1374 3919 +1374 6096 +1374 9682 +1374 8152 +1374 5989 +1374 3812 +1374 8358 +1374 9709 +1374 8688 +1374 4473 +1374 6268 +1374 3198 +1374 9599 +1375 6657 +1375 8076 +1375 4109 +1375 7185 +1375 4503 +1375 2591 +1375 4025 +1375 9019 +1375 3900 +1375 8637 +1375 4290 +1375 5191 +1375 9041 +1375 7128 +1375 9439 +1375 9455 +1375 6867 +1375 6137 +1376 5828 +1376 3382 +1376 6857 +1376 4938 +1376 5516 +1376 7725 +1376 7858 +1376 8180 +1376 4565 +1376 8822 +1376 9177 +1376 2244 +1376 3230 +1377 6337 +1377 4579 +1377 4950 +1377 3849 +1377 3307 +1377 5499 +1377 9432 +1377 9171 +1377 4630 +1377 6935 +1377 7695 +1377 1531 +1377 5756 +1377 2109 +1377 4766 +1377 3583 +1378 9095 +1378 4119 +1378 8335 +1378 5392 +1378 6423 +1378 2718 +1378 9634 +1378 3378 +1378 2354 +1378 8129 +1378 5588 +1378 9046 +1378 3928 +1378 2018 +1378 8547 +1378 2535 +1378 8940 +1378 5748 +1378 9334 +1378 3706 +1378 7164 +1379 5892 +1379 6550 +1379 5529 +1379 1949 +1379 9253 +1379 5804 +1379 9134 +1379 4794 +1379 3135 +1379 9536 +1379 2633 +1379 6735 +1379 2389 +1379 5306 +1379 2400 +1379 4712 +1379 3947 +1379 6776 +1379 6654 +1379 7893 +1380 7937 +1380 6659 +1380 5030 +1380 9415 +1380 6602 +1380 5166 +1380 5096 +1380 7795 +1380 7574 +1380 3576 +1380 7614 +1381 1921 +1381 3698 +1381 9061 +1381 5997 +1381 7080 +1381 2189 +1381 5009 +1381 9234 +1381 2259 +1381 5310 +1381 2072 +1381 7353 +1381 7804 +1381 4670 +1381 4933 +1382 7693 +1382 5518 +1382 8975 +1382 4369 +1382 6677 +1382 4640 +1382 1961 +1382 3628 +1382 8887 +1382 7102 +1382 1591 +1382 8462 +1382 4730 +1382 5346 +1382 3432 +1382 3944 +1382 5234 +1382 3319 +1382 2938 +1383 9170 +1383 8258 +1383 7363 +1383 8876 +1383 7692 +1383 1485 +1383 5199 +1383 6514 +1383 9583 +1383 8663 +1383 8995 +1383 8573 +1383 5845 +1384 5409 +1384 4194 +1384 3875 +1384 7493 +1384 9102 +1384 8431 +1384 5488 +1384 8242 +1384 8180 +1384 6807 +1384 5258 +1385 5134 +1385 7184 +1385 9617 +1385 1812 +1385 6167 +1385 7199 +1385 3463 +1385 5304 +1385 3523 +1385 5451 +1385 4302 +1385 7772 +1385 8421 +1385 3055 +1385 2038 +1385 1785 +1386 4038 +1386 2824 +1386 5930 +1386 4652 +1386 3665 +1386 2834 +1386 5717 +1386 5156 +1386 3003 +1386 4533 +1387 9476 +1387 3080 +1387 6035 +1387 3615 +1387 9374 +1387 2719 +1387 8353 +1387 7206 +1387 5927 +1387 2372 +1387 2900 +1387 9430 +1387 9185 +1387 7394 +1387 4325 +1387 5097 +1387 4591 +1387 5267 +1388 8693 +1388 4551 +1388 3400 +1388 4908 +1388 4683 +1388 5708 +1388 2824 +1388 8113 +1388 7796 +1388 7061 +1388 7881 +1388 8984 +1388 2663 +1388 2527 +1388 5052 +1389 3333 +1389 8587 +1389 7565 +1389 2670 +1389 8855 +1389 7576 +1389 7450 +1389 5792 +1389 4001 +1389 3386 +1389 9227 +1389 8388 +1389 3660 +1389 5464 +1389 4058 +1389 9449 +1389 4590 +1389 2161 +1389 3062 +1389 2300 +1390 4103 +1390 3228 +1390 9764 +1390 3621 +1390 7463 +1390 5802 +1390 9519 +1390 9780 +1390 2230 +1390 1975 +1390 8124 +1390 4674 +1390 2499 +1390 1482 +1390 2261 +1390 3435 +1390 8221 +1390 8688 +1390 3570 +1390 7284 +1390 1781 +1391 1952 +1391 2977 +1391 1739 +1391 2758 +1391 7697 +1391 4424 +1391 9482 +1391 9675 +1391 8461 +1391 9422 +1391 7185 +1391 8466 +1391 1523 +1391 9273 +1391 1947 +1391 7068 +1391 5491 +1392 3643 +1392 7524 +1392 5319 +1392 2408 +1392 2186 +1392 4300 +1392 6773 +1392 5649 +1392 5362 +1392 2291 +1392 9493 +1392 1691 +1392 5309 +1392 4414 +1392 9365 +1393 2689 +1393 5765 +1393 6159 +1393 3606 +1393 5015 +1393 4000 +1393 4774 +1393 5548 +1393 7474 +1393 3375 +1393 5425 +1393 3263 +1393 2790 +1393 7823 +1393 8286 +1393 7141 +1393 1766 +1393 3050 +1393 3437 +1393 9076 +1394 7458 +1394 8164 +1394 5811 +1394 4169 +1394 1687 +1394 2841 +1394 4237 +1394 1966 +1394 8751 +1394 2704 +1394 4057 +1394 8083 +1394 7412 +1394 3765 +1394 1428 +1394 2779 +1394 7740 +1394 7596 +1394 1438 +1395 8322 +1395 1955 +1395 2076 +1395 9416 +1395 7266 +1395 3502 +1395 5277 +1395 2929 +1395 5635 +1395 5006 +1395 3190 +1395 2935 +1395 6460 +1395 7293 +1395 8147 +1395 6783 +1396 9587 +1396 9347 +1396 2342 +1396 4017 +1396 8840 +1396 5963 +1396 7979 +1396 6797 +1396 6990 +1396 5039 +1396 4400 +1396 8625 +1396 9681 +1396 6211 +1396 3028 +1396 4296 +1396 1976 +1396 2932 +1396 7452 +1396 5790 +1397 2052 +1397 2674 +1397 9903 +1397 7056 +1397 5553 +1397 9394 +1397 8244 +1397 1686 +1397 5015 +1397 2747 +1397 8149 +1398 6531 +1398 3728 +1398 3985 +1398 3610 +1398 6195 +1398 1845 +1398 5188 +1398 7891 +1398 6996 +1398 4694 +1398 8154 +1398 8796 +1398 9823 +1398 2670 +1398 4342 +1398 4346 +1399 3329 +1399 7446 +1399 9735 +1399 1929 +1399 3724 +1399 4885 +1399 7192 +1399 7454 +1399 8107 +1399 4780 +1399 1839 +1399 2999 +1399 7876 +1399 9296 +1399 6611 +1399 8161 +1399 5739 +1399 9717 +1400 7429 +1400 1414 +1400 3463 +1400 3209 +1400 5519 +1400 4244 +1400 6691 +1400 5547 +1400 6574 +1400 1715 +1400 8123 +1400 5196 +1400 3916 +1400 5027 +1400 9439 +1400 9825 +1400 9585 +1400 2420 +1400 1534 +1401 8608 +1401 9395 +1401 8324 +1401 8438 +1401 4455 +1401 2824 +1401 4334 +1401 6939 +1401 1616 +1401 4146 +1401 6355 +1401 5078 +1401 6070 +1401 2043 +1402 5984 +1402 6401 +1402 9186 +1402 3907 +1402 1829 +1402 5159 +1402 7562 +1402 2081 +1402 2735 +1402 3298 +1402 4275 +1402 8788 +1402 9338 +1402 4963 +1402 4604 +1402 7973 +1403 8704 +1403 6819 +1403 3022 +1403 4114 +1403 1582 +1403 2130 +1403 2419 +1403 6542 +1403 1722 +1403 5919 +1403 7157 +1404 8864 +1404 6529 +1404 6092 +1404 6627 +1404 9990 +1404 8680 +1404 3244 +1404 3853 +1404 4625 +1404 4431 +1404 4019 +1404 7220 +1404 4854 +1404 9641 +1404 5615 +1404 3515 +1404 4652 +1405 9794 +1405 9547 +1405 2215 +1405 6506 +1405 1581 +1405 8749 +1405 3407 +1405 4435 +1405 2996 +1405 7859 +1405 7517 +1405 9016 +1405 8538 +1405 7451 +1405 6396 +1405 8125 +1405 8683 +1406 1801 +1406 3339 +1406 3596 +1406 6926 +1406 4754 +1406 3097 +1406 8346 +1406 5790 +1406 3237 +1406 8903 +1406 6843 +1406 7356 +1406 3519 +1406 1479 +1406 2764 +1406 5453 +1406 1872 +1406 4058 +1406 8272 +1406 5994 +1406 8177 +1406 6910 +1406 8953 +1407 5025 +1407 6275 +1407 9127 +1407 3689 +1407 7351 +1407 1900 +1407 4946 +1407 2672 +1407 2066 +1407 6729 +1407 8312 +1407 2347 +1407 6110 +1407 8863 +1408 8780 +1408 8865 +1408 3266 +1408 7428 +1408 6565 +1408 9265 +1408 1770 +1408 2986 +1408 3372 +1408 9166 +1408 8560 +1408 7665 +1408 2744 +1408 6682 +1408 3483 +1408 4378 +1408 5695 +1409 5765 +1409 2063 +1409 9391 +1409 5917 +1409 8990 +1409 7813 +1409 9136 +1409 7740 +1409 6590 +1409 5572 +1409 4805 +1409 7242 +1409 3790 +1409 7643 +1409 7905 +1409 5948 +1409 2799 +1409 6259 +1409 7412 +1409 9206 +1409 1915 +1410 6146 +1410 5891 +1410 3079 +1410 9870 +1410 2193 +1410 6693 +1410 4266 +1410 1970 +1410 8114 +1410 9792 +1410 9413 +1410 3281 +1410 4622 +1410 3762 +1410 4574 +1410 2274 +1410 5009 +1410 7658 +1410 3572 +1410 7029 +1410 6011 +1411 7397 +1411 6182 +1411 7082 +1411 6615 +1411 3181 +1411 2413 +1411 4433 +1411 9015 +1411 8919 +1411 6132 +1411 1722 +1411 8926 +1412 9861 +1412 8330 +1412 2329 +1412 1563 +1412 6187 +1412 6446 +1412 9524 +1412 3017 +1412 5258 +1412 5439 +1412 8770 +1412 5191 +1412 1736 +1412 5833 +1412 2125 +1412 7885 +1412 8793 +1412 4967 +1412 3178 +1412 4455 +1412 8556 +1413 3808 +1413 2722 +1413 6916 +1413 6728 +1413 1770 +1413 2284 +1413 7539 +1413 7956 +1413 6107 +1413 9311 +1414 6530 +1414 5259 +1414 2316 +1414 2194 +1414 7959 +1414 6557 +1414 1951 +1414 5408 +1414 7208 +1414 1451 +1414 9261 +1414 8285 +1414 6097 +1414 5463 +1414 2140 +1414 3805 +1414 5857 +1414 3056 +1414 2685 +1414 1918 +1414 4479 +1415 7328 +1415 6599 +1415 5165 +1415 5134 +1415 8079 +1415 5357 +1415 9304 +1415 2137 +1415 6427 +1415 6460 +1415 9469 +1415 2590 +1415 7039 +1416 9474 +1416 2153 +1416 7882 +1416 8684 +1416 9774 +1416 5938 +1416 9662 +1416 5420 +1416 8955 +1416 5950 +1416 3999 +1417 6530 +1417 2043 +1417 6596 +1417 5093 +1417 2919 +1417 4680 +1417 2729 +1417 6602 +1417 5613 +1417 4465 +1417 6935 +1417 5202 +1417 2427 +1417 3191 +1417 3320 +1417 7962 +1417 8475 +1417 2952 +1417 9502 +1418 9027 +1418 8324 +1418 2342 +1418 5958 +1418 8263 +1418 2697 +1418 2410 +1418 6219 +1418 9905 +1418 7524 +1418 9492 +1418 1813 +1418 1991 +1418 4569 +1418 2091 +1418 6777 +1418 7418 +1418 7962 +1419 3680 +1419 6388 +1419 6517 +1419 2441 +1419 2476 +1419 6258 +1419 2195 +1419 4596 +1419 6325 +1419 3510 +1419 6553 +1419 6586 +1419 9371 +1419 9693 +1419 3669 +1420 2978 +1420 2307 +1420 9093 +1420 8742 +1420 3558 +1420 7786 +1420 6670 +1420 8797 +1420 6962 +1420 8323 +1420 1820 +1420 9885 +1420 7550 +1420 6245 +1421 3937 +1421 2435 +1421 9989 +1421 9384 +1421 5578 +1421 4626 +1421 3661 +1421 5713 +1421 2482 +1421 8931 +1421 9524 +1421 2581 +1421 8023 +1421 4824 +1421 6073 +1421 6170 +1421 4092 +1421 4925 +1422 8256 +1422 2528 +1422 8482 +1422 3046 +1422 5420 +1422 2861 +1422 4783 +1422 5104 +1422 9267 +1422 4084 +1422 8982 +1422 8730 +1423 8736 +1423 2174 +1423 1756 +1423 7237 +1423 3178 +1423 8717 +1423 7279 +1423 8668 +1423 4276 +1423 6965 +1423 6615 +1423 5273 +1423 3163 +1423 4604 +1423 8766 +1423 3029 +1424 1787 +1424 8775 +1424 1704 +1424 8840 +1424 8522 +1424 2635 +1424 7020 +1424 9837 +1424 3221 +1424 5368 +1424 8729 +1424 6778 +1424 6843 +1424 8445 +1424 4511 +1425 1895 +1425 5333 +1425 9234 +1425 6274 +1425 4263 +1425 7464 +1425 9961 +1425 1706 +1425 1714 +1425 8846 +1425 1810 +1425 8915 +1425 2548 +1425 9303 +1425 8281 +1425 6331 +1425 2364 +1425 2421 +1426 2952 +1426 7049 +1426 4753 +1426 9362 +1426 6421 +1426 4376 +1426 7842 +1426 1450 +1426 6065 +1426 2616 +1426 2312 +1426 5190 +1426 9934 +1426 2770 +1426 3923 +1426 3290 +1426 3169 +1426 9574 +1426 8299 +1426 9202 +1426 9716 +1426 9078 +1426 5627 +1427 1667 +1427 4612 +1427 9737 +1427 2186 +1427 7958 +1427 5790 +1427 3489 +1427 7690 +1427 4276 +1427 5561 +1427 2237 +1427 9287 +1427 9677 +1427 8272 +1427 7379 +1427 2271 +1427 6119 +1427 3565 +1427 5877 +1428 1984 +1428 7298 +1428 6215 +1428 4490 +1428 9195 +1428 7726 +1428 2447 +1428 7477 +1428 1433 +1428 8345 +1428 5406 +1428 8990 +1428 9023 +1429 9168 +1429 5026 +1429 8003 +1429 7345 +1429 4104 +1429 8961 +1429 8994 +1429 4174 +1429 2120 +1429 3150 +1429 7798 +1429 7543 +1429 2719 +1429 9256 +1429 3487 +1430 6912 +1430 8839 +1430 5130 +1430 5516 +1430 1935 +1430 6161 +1430 8092 +1430 3229 +1430 6565 +1430 5938 +1430 7342 +1430 1457 +1430 5426 +1430 9019 +1430 4106 +1430 5443 +1430 3780 +1430 6991 +1430 6490 +1430 2895 +1430 6371 +1430 5649 +1430 6387 +1430 5369 +1430 2175 +1431 7349 +1431 5124 +1431 8487 +1431 2155 +1431 2925 +1431 7919 +1431 5752 +1431 6834 +1431 8445 +1431 1525 +1431 1432 +1431 2266 +1431 6844 +1431 6525 +1431 2111 +1432 5259 +1432 1937 +1432 6808 +1432 3609 +1432 8607 +1432 9840 +1432 6819 +1432 7726 +1432 7219 +1432 4920 +1432 9917 +1432 6594 +1432 9160 +1432 7626 +1432 9816 +1432 4830 +1432 9440 +1432 6389 +1432 7161 +1432 7832 +1433 8240 +1433 8515 +1433 3013 +1433 6248 +1433 3276 +1433 7015 +1433 6956 +1433 7536 +1433 4817 +1433 9267 +1433 7529 +1433 3547 +1433 9052 +1433 8351 +1434 5797 +1434 1516 +1434 2794 +1434 4940 +1434 2702 +1434 7248 +1434 8914 +1434 4022 +1434 8887 +1434 8600 +1434 4825 +1434 6234 +1434 2270 +1434 1445 +1435 9698 +1435 6467 +1435 3140 +1435 9394 +1435 5896 +1435 9131 +1435 4813 +1435 4145 +1435 9554 +1435 5636 +1435 3057 +1435 2684 +1435 6589 +1436 9664 +1436 5217 +1436 5378 +1436 9667 +1436 3429 +1436 3461 +1436 1867 +1436 2828 +1436 2847 +1436 9379 +1436 6837 +1436 6232 +1436 4795 +1436 3678 +1436 9717 +1437 9456 +1437 9282 +1437 8950 +1437 3366 +1437 7376 +1437 5134 +1437 8048 +1437 7064 +1437 2002 +1437 6004 +1437 8661 +1437 8470 +1437 4951 +1437 7864 +1437 8249 +1437 5243 +1437 9240 +1437 8469 +1438 7520 +1438 1440 +1438 7106 +1438 4644 +1438 5666 +1438 1798 +1438 6087 +1438 1608 +1438 2060 +1438 5137 +1438 3731 +1438 4276 +1438 6133 +1438 3449 +1438 9204 +1438 5083 +1438 4765 +1439 3216 +1439 4187 +1439 9737 +1439 8518 +1439 9865 +1439 4363 +1439 9776 +1439 6995 +1439 4948 +1439 9333 +1439 9782 +1439 3479 +1439 7673 +1439 6075 +1439 5180 +1440 6827 +1440 2438 +1440 6682 +1440 7201 +1440 8356 +1440 6565 +1440 7211 +1440 5168 +1440 6706 +1440 5175 +1440 6209 +1440 9802 +1440 6737 +1440 1491 +1440 6247 +1440 3434 +1440 3051 +1440 1654 +1440 5631 +1441 6881 +1441 4034 +1441 3750 +1441 9217 +1441 6410 +1441 9389 +1441 9006 +1441 2992 +1441 8209 +1441 5234 +1441 6163 +1441 8629 +1441 5482 +1441 9753 +1441 6941 +1442 2213 +1442 6726 +1442 3784 +1442 2953 +1442 9005 +1442 4302 +1442 8463 +1442 4592 +1442 7992 +1442 6770 +1442 4084 +1442 9621 +1442 5048 +1442 7961 +1442 4250 +1442 9374 +1443 5377 +1443 3975 +1443 5774 +1443 7571 +1443 7446 +1443 2334 +1443 4517 +1443 9767 +1443 3753 +1443 9269 +1443 3903 +1443 5063 +1443 9178 +1443 9310 +1443 2279 +1443 3055 +1443 2935 +1444 2375 +1444 3716 +1444 8839 +1444 7817 +1444 5483 +1444 6124 +1444 6434 +1444 4814 +1444 7190 +1444 2063 +1445 7169 +1445 4984 +1445 5206 +1445 6343 +1445 8362 +1445 2061 +1445 3405 +1445 7048 +1445 2194 +1445 9078 +1445 7992 +1445 1780 +1445 6427 +1445 3589 +1446 1761 +1446 9698 +1446 1924 +1446 7335 +1446 6059 +1446 9646 +1446 8915 +1446 8756 +1446 5624 +1446 8826 +1447 1856 +1447 6915 +1447 5901 +1447 5413 +1447 5292 +1447 7821 +1447 5615 +1447 4656 +1447 8531 +1447 4432 +1447 5976 +1447 8186 +1447 5691 +1447 7130 +1447 5189 +1448 5911 +1448 4771 +1448 7977 +1448 1849 +1448 9278 +1448 5442 +1448 2756 +1448 6605 +1448 5198 +1448 4387 +1448 6868 +1448 6485 +1448 8668 +1448 3166 +1448 5093 +1448 6131 +1448 4340 +1448 6902 +1448 4989 +1449 2688 +1449 7683 +1449 7948 +1449 5261 +1449 5008 +1449 4509 +1449 2980 +1449 2612 +1449 8759 +1449 9787 +1449 6076 +1449 1856 +1449 2128 +1449 7764 +1449 8160 +1449 4504 +1449 9617 +1449 7407 +1449 9072 +1449 1905 +1450 5129 +1450 4674 +1450 9763 +1450 3876 +1450 1642 +1450 4713 +1450 3146 +1450 9522 +1450 6316 +1450 4941 +1450 6637 +1450 6032 +1450 2643 +1450 3860 +1450 2174 +1450 5467 +1450 1565 +1450 4703 +1451 3744 +1451 7462 +1451 3525 +1451 7047 +1451 7336 +1451 7274 +1451 6731 +1451 5132 +1451 7426 +1451 2824 +1451 6353 +1451 4104 +1451 9847 +1451 5322 +1451 7321 +1451 3514 +1451 5149 +1452 2690 +1452 6331 +1452 6214 +1452 9574 +1452 6439 +1452 4770 +1452 2063 +1452 5873 +1452 6547 +1452 5112 +1452 4573 +1452 8959 +1453 2437 +1453 5896 +1453 4110 +1453 7192 +1453 6687 +1453 8360 +1453 1586 +1453 6327 +1453 9276 +1453 2878 +1453 5449 +1453 2251 +1453 9553 +1453 2043 +1453 2539 +1453 6515 +1453 2292 +1453 6139 +1454 7937 +1454 8681 +1454 1546 +1454 5901 +1454 6926 +1454 3471 +1454 3568 +1454 8393 +1454 5524 +1454 3803 +1454 4700 +1454 9150 +1454 2111 +1455 2950 +1455 1799 +1455 7959 +1455 7447 +1455 5540 +1455 6694 +1455 8231 +1455 3883 +1455 8366 +1455 2608 +1455 7857 +1455 2611 +1455 3255 +1455 1596 +1455 5183 +1455 9671 +1455 1609 +1455 8267 +1455 2514 +1455 5075 +1455 6485 +1455 4568 +1455 8543 +1455 7479 +1455 7139 +1455 9579 +1455 1772 +1455 8695 +1456 6402 +1456 5483 +1456 9988 +1456 4869 +1456 6537 +1456 7822 +1456 6160 +1456 2333 +1456 4382 +1456 6816 +1456 4315 +1456 7972 +1456 3497 +1456 2525 +1456 3890 +1456 6196 +1456 4289 +1456 5828 +1456 8134 +1456 4558 +1456 9307 +1456 3677 +1456 2660 +1456 8039 +1456 7272 +1456 6123 +1457 9222 +1457 7569 +1457 4499 +1457 4501 +1457 8470 +1457 4004 +1457 6312 +1457 4652 +1457 1584 +1457 4936 +1457 6218 +1457 2638 +1457 7503 +1457 6995 +1457 4948 +1457 9700 +1457 9064 +1457 3960 +1457 7035 +1457 7805 +1457 5759 +1458 8931 +1458 7236 +1458 6086 +1458 2727 +1458 9194 +1458 6727 +1458 2254 +1458 6577 +1458 5619 +1458 3310 +1458 1912 +1458 3960 +1458 9220 +1458 3418 +1458 7387 +1458 8138 +1458 9886 +1459 8835 +1459 8714 +1459 7831 +1459 8355 +1459 6696 +1459 8235 +1459 5677 +1459 7471 +1459 6452 +1459 3267 +1459 4165 +1459 9674 +1459 7765 +1459 2518 +1459 2392 +1459 5465 +1459 3292 +1459 7650 +1459 5481 +1459 3055 +1459 9841 +1459 5114 +1459 4094 +1460 7808 +1460 8705 +1460 6149 +1460 6278 +1460 7181 +1460 4239 +1460 2966 +1460 2588 +1460 4645 +1460 4502 +1460 5233 +1460 6441 +1460 5946 +1460 4796 +1460 6591 +1460 4050 +1460 7764 +1460 9183 +1460 3553 +1460 3046 +1460 7274 +1460 6507 +1460 9966 +1460 2931 +1460 5367 +1461 9996 +1461 2977 +1461 4516 +1461 4015 +1461 6192 +1461 9911 +1461 9277 +1461 1470 +1461 6848 +1461 5313 +1461 3270 +1461 9546 +1461 5195 +1461 1890 +1461 6487 +1461 8283 +1461 5725 +1461 5602 +1461 9445 +1461 8560 +1461 1787 +1462 9473 +1462 4867 +1462 8340 +1462 4634 +1462 5539 +1462 8874 +1462 5172 +1462 6198 +1462 1606 +1462 4684 +1462 9165 +1462 4048 +1462 2262 +1462 5082 +1462 2017 +1462 2402 +1462 9700 +1462 4456 +1462 7546 +1462 9213 +1463 8162 +1463 9252 +1463 1932 +1463 2706 +1463 5683 +1463 2516 +1463 6485 +1463 6838 +1463 1495 +1463 7955 +1463 7226 +1463 9564 +1463 3541 +1464 3072 +1464 3329 +1464 4098 +1464 2437 +1464 8968 +1464 6666 +1464 9867 +1464 1549 +1464 6164 +1464 8606 +1464 6693 +1464 4907 +1464 1583 +1464 8377 +1464 2109 +1464 6219 +1464 3273 +1464 8011 +1464 1766 +1464 6376 +1464 9066 +1464 7793 +1464 6774 +1464 6776 +1465 5431 +1465 9669 +1465 1542 +1465 2473 +1465 7659 +1465 8525 +1465 3918 +1465 8240 +1465 5811 +1465 8535 +1465 4312 +1465 7835 +1465 5117 +1466 7328 +1466 6562 +1466 1579 +1466 9644 +1466 9778 +1466 4797 +1466 3232 +1466 3143 +1466 3786 +1466 8794 +1466 6631 +1466 6767 +1466 9464 +1466 2427 +1466 7804 +1466 1534 +1467 4450 +1467 6937 +1467 6181 +1467 8294 +1467 5448 +1467 9042 +1467 2827 +1467 9186 +1467 7951 +1467 6472 +1467 5170 +1467 5045 +1467 2102 +1467 9815 +1467 4313 +1467 7375 +1467 3132 +1467 2767 +1467 7391 +1468 6658 +1468 9771 +1468 3109 +1468 5702 +1468 8273 +1468 3880 +1468 7082 +1468 9099 +1468 3309 +1468 2864 +1468 9265 +1468 7603 +1468 4404 +1468 8469 +1468 5974 +1468 5046 +1468 9404 +1468 1661 +1469 9056 +1469 5921 +1469 8067 +1469 1732 +1469 6470 +1469 6647 +1469 8904 +1469 1943 +1469 2511 +1469 5326 +1469 4271 +1469 2674 +1469 2260 +1469 6614 +1469 2167 +1469 5753 +1469 7355 +1470 2368 +1470 9025 +1470 2083 +1470 4228 +1470 6984 +1470 5086 +1470 9902 +1470 4783 +1470 8336 +1470 4658 +1470 1495 +1470 9491 +1470 9244 +1470 2910 +1470 2613 +1471 4960 +1471 8576 +1471 4580 +1471 3177 +1471 5324 +1471 7215 +1471 4147 +1471 7348 +1471 6902 +1471 3960 +1471 6074 +1471 6365 +1472 6784 +1472 5538 +1472 3003 +1472 1892 +1472 8231 +1472 2216 +1472 6667 +1472 5133 +1472 4685 +1472 7793 +1472 5746 +1472 7683 +1472 7349 +1472 6166 +1472 3863 +1472 7097 +1472 7162 +1472 4573 +1472 6293 +1473 6016 +1473 6784 +1473 6500 +1473 9261 +1473 1550 +1473 9336 +1473 2848 +1473 3054 +1473 2359 +1473 2424 +1473 3129 +1473 1924 +1473 7483 +1473 2941 +1473 7038 +1474 7040 +1474 8128 +1474 4549 +1474 2220 +1474 4106 +1474 9196 +1474 8238 +1474 3760 +1474 7153 +1474 4894 +1474 9558 +1474 4698 +1474 8347 +1474 5725 +1474 6826 +1474 6078 +1475 4290 +1475 2083 +1475 7460 +1475 8530 +1475 5669 +1475 9644 +1475 4719 +1475 2498 +1475 4690 +1475 6902 +1475 2201 +1475 6172 +1475 8222 +1475 2061 +1476 4162 +1476 8951 +1476 8218 +1476 2458 +1476 6045 +1476 2333 +1476 5435 +1476 6334 +1476 4929 +1476 6219 +1476 6600 +1476 9049 +1476 3804 +1476 8558 +1476 3440 +1476 7027 +1476 4855 +1476 6011 +1476 5118 +1477 8589 +1477 4884 +1477 5019 +1477 9257 +1477 1717 +1477 4279 +1477 8120 +1477 4415 +1477 3912 +1477 6711 +1477 5323 +1477 3085 +1477 4050 +1477 7645 +1477 9310 +1477 4960 +1477 2403 +1477 3944 +1477 7790 +1477 6771 +1478 1904 +1478 7363 +1478 9990 +1478 7751 +1478 7368 +1478 5513 +1478 5547 +1478 7307 +1478 2909 +1478 9392 +1478 3070 +1478 5976 +1478 3036 +1478 3549 +1478 8702 +1479 8739 +1479 9350 +1479 1771 +1479 4942 +1479 6768 +1479 2808 +1479 1731 +1479 3028 +1479 3166 +1479 8408 +1479 6138 +1480 2624 +1480 9252 +1480 7597 +1480 3657 +1480 9197 +1480 9293 +1480 9716 +1480 3767 +1480 5978 +1480 1499 +1480 6908 +1481 8459 +1481 6297 +1481 6554 +1481 9500 +1481 9370 +1481 7582 +1481 4000 +1481 2337 +1481 9388 +1481 4909 +1481 3762 +1481 9271 +1481 9280 +1481 6342 +1481 2487 +1481 1614 +1481 9424 +1481 3794 +1481 8803 +1481 5597 +1481 3707 +1481 3944 +1481 8298 +1481 9323 +1481 2031 +1481 6139 +1481 4586 +1482 5120 +1482 6951 +1482 5865 +1482 3915 +1482 6796 +1482 9181 +1482 7505 +1482 1682 +1482 1597 +1482 7545 +1482 6013 +1482 9854 +1483 5793 +1483 3143 +1483 7560 +1483 2364 +1483 8171 +1483 3215 +1483 3509 +1483 4796 +1483 9149 +1484 3380 +1484 1702 +1484 5351 +1484 1800 +1484 4444 +1484 8467 +1484 4724 +1484 5301 +1484 9978 +1484 8410 +1484 9788 +1484 9021 +1484 7774 +1485 2881 +1485 3106 +1485 2985 +1485 5442 +1485 8749 +1485 4600 +1485 4088 +1485 3065 +1485 8923 +1485 5954 +1485 8127 +1486 9619 +1486 1940 +1486 7070 +1486 9634 +1486 3498 +1486 2864 +1486 5426 +1486 5301 +1486 4022 +1486 1594 +1486 4925 +1486 4542 +1486 7222 +1486 3272 +1486 3401 +1486 3658 +1486 7637 +1486 3177 +1486 4459 +1486 8821 +1486 4735 +1486 4053 +1487 7185 +1487 8735 +1487 8994 +1487 2468 +1487 7207 +1487 1961 +1487 5936 +1487 8753 +1487 3651 +1487 3018 +1487 7756 +1487 5582 +1487 6355 +1487 7895 +1487 8945 +1487 7018 +1487 2801 +1487 5619 +1487 2938 +1487 8829 +1487 2302 +1488 9088 +1488 5314 +1488 8905 +1488 8395 +1488 6091 +1488 3439 +1488 8728 +1488 8882 +1488 1875 +1488 8020 +1488 9129 +1488 7320 +1488 8879 +1488 4604 +1489 2272 +1489 1793 +1489 3367 +1489 7016 +1489 7434 +1489 3179 +1489 8640 +1489 4110 +1489 2312 +1489 3027 +1489 5012 +1489 1902 +1489 9920 +1489 1882 +1489 3516 +1489 6874 +1489 2943 +1490 3205 +1490 9992 +1490 1801 +1490 1549 +1490 5272 +1490 7193 +1490 6426 +1490 9643 +1490 6830 +1490 2863 +1490 6792 +1490 4794 +1490 8125 +1490 6206 +1490 8903 +1490 6866 +1490 2142 +1490 2400 +1490 7784 +1490 9450 +1490 6639 +1490 5875 +1490 2494 +1490 2810 +1490 8955 +1490 1789 +1491 7426 +1491 5381 +1491 8838 +1491 2584 +1491 7835 +1491 4510 +1491 7714 +1491 9894 +1491 2358 +1491 9399 +1491 9916 +1491 8383 +1491 2114 +1491 2629 +1491 4167 +1491 6603 +1491 8397 +1491 8655 +1491 3798 +1491 9576 +1491 8431 +1491 1778 +1491 6776 +1492 6656 +1492 2056 +1492 8207 +1492 7318 +1492 2777 +1492 9498 +1492 9377 +1492 7724 +1492 7220 +1492 6814 +1492 8908 +1492 4560 +1492 5337 +1492 7002 +1492 7899 +1492 8165 +1492 2791 +1492 6506 +1492 2806 +1493 7684 +1493 8069 +1493 2054 +1493 4875 +1493 3879 +1493 3757 +1493 6454 +1493 2747 +1493 4543 +1493 2761 +1493 8782 +1493 9296 +1493 9425 +1493 7508 +1493 2775 +1493 6489 +1493 2015 +1493 4065 +1493 8549 +1493 8305 +1493 9080 +1494 6272 +1494 1952 +1494 4059 +1494 8260 +1494 9582 +1494 1809 +1494 7924 +1494 7438 +1494 9012 +1494 8120 +1494 9497 +1494 7323 +1494 9244 +1494 7455 +1495 2913 +1495 6243 +1495 1745 +1495 4424 +1495 4685 +1495 9295 +1495 7696 +1495 3953 +1495 7794 +1495 2259 +1495 4053 +1495 3671 +1495 8816 +1495 4666 +1495 3619 +1496 3204 +1496 9991 +1496 3083 +1496 5656 +1496 6041 +1496 3742 +1496 2855 +1496 5416 +1496 6829 +1496 4667 +1496 3516 +1496 3394 +1496 3530 +1496 2011 +1496 5089 +1496 9019 +1496 6885 +1496 9962 +1496 4854 +1496 9215 +1497 8641 +1497 3269 +1497 3944 +1497 8842 +1497 6835 +1497 9269 +1497 1591 +1497 7609 +1498 8968 +1498 8842 +1498 7565 +1498 1806 +1498 2198 +1498 2594 +1498 6819 +1498 3626 +1498 1708 +1498 6581 +1498 9404 +1498 6991 +1498 2386 +1498 5587 +1498 5412 +1498 6878 +1498 7649 +1498 8937 +1498 8941 +1498 5106 +1499 6276 +1499 4358 +1499 8977 +1499 4996 +1499 5029 +1499 7605 +1499 5055 +1499 4160 +1499 4726 +1499 7499 +1499 3537 +1499 4050 +1499 7891 +1499 8310 +1499 6565 +1499 7267 +1499 9461 +1499 5624 +1499 9211 +1500 4480 +1500 5920 +1500 6804 +1500 2819 +1500 9926 +1500 7951 +1500 4495 +1500 2091 +1500 2349 +1500 7252 +1500 2895 +1500 3216 +1500 6522 +1500 7771 +1500 3292 +1500 5567 +1501 5270 +1501 5771 +1501 9485 +1501 6158 +1501 5779 +1501 7316 +1501 5398 +1501 4976 +1501 2470 +1501 7732 +1501 7477 +1501 3138 +1501 9164 +1501 4302 +1501 2767 +1501 3931 +1501 3299 +1501 5996 +1501 6512 +1501 5746 +1501 9978 +1501 9085 +1502 3020 +1502 3018 +1502 8364 +1502 9613 +1502 3150 +1502 9935 +1502 9877 +1502 9807 +1502 2995 +1502 4628 +1502 8526 +1502 4279 +1502 9530 +1502 6075 +1502 3133 +1502 7594 +1503 1888 +1503 8324 +1503 8487 +1503 7083 +1503 4564 +1503 1550 +1503 9422 +1503 3841 +1503 2869 +1503 5888 +1504 4611 +1504 3030 +1504 6408 +1504 3606 +1504 4888 +1504 3741 +1504 6943 +1504 9120 +1504 8871 +1504 2486 +1504 6973 +1504 6596 +1504 5190 +1504 8655 +1504 9809 +1504 7766 +1504 7132 +1504 1898 +1504 3310 +1504 6001 +1504 7282 +1504 7286 +1504 6391 +1505 5120 +1505 2945 +1505 7077 +1505 3654 +1505 3713 +1505 1542 +1505 9191 +1505 4972 +1505 6577 +1505 6328 +1505 1907 +1505 9846 +1505 8280 +1505 2265 +1505 6045 +1505 6808 +1505 2463 +1506 5003 +1506 1806 +1506 3095 +1506 2844 +1506 4141 +1506 9007 +1506 2865 +1506 6707 +1506 3060 +1506 9156 +1506 4682 +1506 8143 +1506 3421 +1506 7269 +1506 5990 +1506 8304 +1506 1522 +1506 7796 +1506 3705 +1506 6650 +1506 9339 +1507 7680 +1507 2563 +1507 8196 +1507 3719 +1507 6283 +1507 9484 +1507 7182 +1507 9872 +1507 3092 +1507 3880 +1507 2986 +1507 3883 +1507 4652 +1507 8493 +1507 9269 +1507 1609 +1507 1866 +1507 6732 +1507 1881 +1507 7773 +1507 8672 +1507 3809 +1507 4066 +1507 7278 +1507 5119 +1508 4707 +1508 1796 +1508 5893 +1508 6956 +1508 7240 +1508 2332 +1508 8396 +1508 3341 +1508 3672 +1508 3092 +1508 6805 +1508 2934 +1508 8727 +1508 6552 +1508 9913 +1508 7707 +1508 3676 +1508 7454 +1508 2117 +1509 5409 +1509 1511 +1509 2275 +1509 4545 +1509 7907 +1509 6507 +1509 8012 +1509 9421 +1509 7344 +1509 1952 +1509 6723 +1509 1941 +1509 9975 +1509 3960 +1509 2595 +1509 1530 +1509 5627 +1510 9527 +1510 2086 +1510 6273 +1510 3626 +1510 1579 +1510 2893 +1510 6269 +1510 8306 +1510 8628 +1510 8566 +1510 2425 +1510 4088 +1510 9401 +1510 7130 +1510 9147 +1510 4028 +1510 2314 +1510 7967 +1511 9797 +1511 5524 +1511 7830 +1511 6555 +1511 5445 +1511 4593 +1511 4152 +1511 7109 +1511 3148 +1511 8910 +1511 5112 +1511 4695 +1511 2905 +1511 7900 +1511 9565 +1511 8420 +1511 3950 +1511 8433 +1511 8184 +1511 7678 +1511 7551 +1512 8576 +1512 2115 +1512 5981 +1512 7206 +1512 5161 +1512 4170 +1512 1709 +1512 7311 +1512 2737 +1512 3382 +1512 8989 +1512 6815 +1513 9600 +1513 9604 +1513 7052 +1513 7437 +1513 5902 +1513 6160 +1513 5268 +1513 6807 +1513 4636 +1513 8098 +1513 5925 +1513 3116 +1513 5550 +1513 5688 +1513 4025 +1513 8133 +1513 3914 +1513 6353 +1513 5977 +1513 4074 +1513 4344 +1514 4485 +1514 1926 +1514 2065 +1514 4114 +1514 7320 +1514 3745 +1514 6278 +1514 7975 +1514 6312 +1514 9901 +1514 4016 +1514 7476 +1514 6971 +1514 7870 +1514 7115 +1514 9295 +1514 8921 +1514 9311 +1514 2789 +1514 6632 +1514 1902 +1514 8126 +1515 7044 +1515 7047 +1515 8845 +1515 8335 +1515 9360 +1515 7442 +1515 9879 +1515 3621 +1515 4910 +1515 6836 +1515 1981 +1515 5054 +1515 3529 +1515 4172 +1515 6607 +1515 7892 +1515 8795 +1515 1631 +1515 5991 +1515 9067 +1515 3320 +1515 1535 +1516 8321 +1516 2012 +1516 6926 +1516 4239 +1516 8046 +1516 5270 +1516 8867 +1516 4261 +1516 9513 +1516 9391 +1516 2485 +1516 5175 +1516 3519 +1516 5211 +1516 5725 +1516 9467 +1516 4462 +1516 1781 +1516 6523 +1516 6652 +1517 8994 +1517 9859 +1517 6374 +1517 6408 +1517 7466 +1517 1666 +1517 7534 +1517 7181 +1517 2897 +1517 9362 +1517 6595 +1517 3508 +1517 4150 +1517 7433 +1517 7353 +1517 4284 +1517 4702 +1518 5538 +1518 9124 +1518 4999 +1518 3688 +1518 3050 +1518 9548 +1518 3010 +1518 8814 +1518 4514 +1518 9256 +1518 8466 +1518 2135 +1518 9016 +1518 7194 +1518 7451 +1518 9180 +1518 5722 +1518 7806 +1518 9512 +1519 4769 +1519 2531 +1519 9733 +1519 8234 +1519 7019 +1519 6094 +1519 9009 +1519 9827 +1519 3061 +1519 2841 +1519 8768 +1519 3705 +1519 2171 +1519 3467 +1519 9898 +1519 3082 +1519 4991 +1520 9656 +1520 3918 +1520 2575 +1520 7944 +1520 3881 +1520 9066 +1520 5496 +1520 4942 +1520 6543 +1520 4114 +1520 7123 +1520 7605 +1520 5752 +1520 9626 +1520 4027 +1520 3740 +1520 9213 +1520 8699 +1521 7817 +1521 4746 +1521 6418 +1521 6806 +1521 4517 +1521 7206 +1521 9011 +1521 6469 +1521 9286 +1521 9164 +1521 2514 +1521 7892 +1521 8925 +1521 7646 +1521 4448 +1521 2026 +1521 6635 +1521 5358 +1522 3585 +1522 3843 +1522 1543 +1522 8072 +1522 6538 +1522 5251 +1522 5269 +1522 8349 +1522 2211 +1522 8100 +1522 9382 +1522 7350 +1522 2363 +1522 6592 +1522 3908 +1522 6734 +1522 9507 +1522 4693 +1522 8280 +1522 7387 +1522 6877 +1522 3439 +1522 1650 +1523 9730 +1523 7558 +1523 1801 +1523 5903 +1523 4625 +1523 9875 +1523 6169 +1523 8218 +1523 3361 +1523 7727 +1523 7501 +1523 5210 +1523 7261 +1523 9322 +1523 2805 +1523 8570 +1524 7940 +1524 7176 +1524 4619 +1524 4502 +1524 5531 +1524 2853 +1524 6566 +1524 8689 +1524 5425 +1524 3443 +1524 7483 +1524 4811 +1524 4175 +1524 4187 +1524 3678 +1524 8805 +1524 9835 +1524 4333 +1524 4339 +1525 8614 +1525 7372 +1525 1681 +1525 9203 +1525 2196 +1525 2798 +1525 7992 +1525 5851 +1525 8767 +1526 5218 +1526 9755 +1526 2409 +1526 6223 +1526 5227 +1526 9005 +1526 3474 +1526 7983 +1526 6581 +1526 6615 +1526 6506 +1526 8034 +1526 1549 +1526 7357 +1527 7169 +1527 4100 +1527 2822 +1527 7309 +1527 6296 +1527 6022 +1527 9384 +1527 7868 +1527 7741 +1527 8256 +1527 5193 +1527 8797 +1527 3422 +1527 4961 +1527 8124 +1527 9074 +1527 1909 +1527 3830 +1527 9725 +1528 2976 +1528 4225 +1528 5867 +1528 7653 +1528 4074 +1528 5039 +1528 9042 +1528 4979 +1528 6202 +1528 5309 +1529 2025 +1529 7140 +1529 7005 +1529 2408 +1529 7657 +1529 5130 +1529 7883 +1529 6829 +1529 9017 +1529 5774 +1529 4687 +1529 3283 +1529 6612 +1529 3319 +1529 7516 +1529 2346 +1530 7296 +1530 7299 +1530 9096 +1530 3483 +1530 4900 +1530 4006 +1530 2093 +1530 5935 +1530 7868 +1530 2109 +1530 5830 +1530 2503 +1530 9422 +1530 4579 +1530 8683 +1530 7409 +1530 2047 +1531 6658 +1531 4739 +1531 5510 +1531 4618 +1531 7819 +1531 9874 +1531 6163 +1531 8088 +1531 8994 +1531 3751 +1531 6834 +1531 8074 +1531 6322 +1531 2490 +1531 5307 +1531 4874 +1531 3390 +1531 8384 +1531 8002 +1531 6241 +1531 6604 +1531 8271 +1531 7780 +1531 6119 +1531 3645 +1531 4850 +1531 7667 +1531 9467 +1532 8834 +1532 9880 +1532 6541 +1532 4878 +1532 9872 +1532 5777 +1532 2840 +1532 2474 +1532 8880 +1532 1724 +1532 3774 +1532 8771 +1532 6598 +1532 9031 +1532 7884 +1532 8786 +1532 2003 +1532 8539 +1532 7646 +1532 7647 +1532 6007 +1532 9724 +1533 8910 +1533 6241 +1533 2086 +1533 9224 +1533 3465 +1533 8139 +1533 7374 +1533 8561 +1533 4435 +1533 8884 +1533 3253 +1533 6542 +1533 9207 +1533 9240 +1533 5876 +1533 3703 +1533 9052 +1533 6229 +1533 4862 +1533 7639 +1534 4641 +1534 9186 +1534 5859 +1534 4614 +1534 7368 +1534 4043 +1534 9954 +1534 4878 +1534 1805 +1534 1560 +1534 7603 +1534 3636 +1534 2478 +1534 5011 +1534 6045 +1535 4359 +1535 8584 +1535 2580 +1535 5909 +1535 6937 +1535 3099 +1535 2983 +1535 2100 +1535 7094 +1535 1978 +1535 4160 +1535 6211 +1535 8264 +1535 3803 +1535 2653 +1535 7006 +1535 3554 +1535 4837 +1535 4848 +1535 6517 +1536 9473 +1536 3396 +1536 7713 +1536 6761 +1536 8780 +1536 3437 +1536 6446 +1536 2351 +1536 2672 +1536 5406 +1536 7348 +1536 9461 +1536 2130 +1536 2521 +1536 1883 +1536 4733 +1536 6718 +1536 7957 +1537 5001 +1537 4106 +1537 9355 +1537 7439 +1537 1687 +1537 1947 +1537 3882 +1537 9145 +1537 6462 +1537 5061 +1537 2125 +1537 4561 +1537 6117 +1537 5479 +1537 7038 +1538 9527 +1538 3395 +1538 8676 +1538 2961 +1538 3818 +1538 2231 +1538 6093 +1538 1806 +1538 7697 +1538 4850 +1538 8311 +1538 3386 +1538 4060 +1538 2666 +1539 9355 +1539 7526 +1539 8615 +1539 8424 +1539 9607 +1539 5832 +1539 4413 +1539 6041 +1539 2929 +1539 5891 +1539 5652 +1539 3094 +1539 7833 +1539 6327 +1539 8377 +1539 2799 +1539 3004 +1539 3069 +1539 7112 +1540 5378 +1540 7560 +1540 4501 +1540 8600 +1540 6046 +1540 5151 +1540 8992 +1540 7073 +1540 4002 +1540 4259 +1540 7471 +1540 5557 +1540 5054 +1540 6082 +1540 5318 +1540 5576 +1540 3276 +1540 2136 +1540 3684 +1540 4836 +1540 1639 +1540 7018 +1540 9043 +1540 4474 +1540 8447 +1540 4245 +1541 9348 +1541 5145 +1541 4515 +1541 5159 +1541 8752 +1541 4788 +1541 9272 +1541 6855 +1541 4450 +1541 9433 +1541 9820 +1541 4688 +1541 4577 +1541 8034 +1541 9852 +1541 7786 +1541 8183 +1541 2552 +1541 8185 +1541 2812 +1541 9215 +1542 3105 +1542 1849 +1542 7841 +1542 4777 +1542 6337 +1542 6369 +1542 4172 +1542 7757 +1542 2924 +1542 8332 +1542 5780 +1542 9145 +1542 2584 +1542 1562 +1542 5595 +1542 8890 +1543 6944 +1543 4516 +1543 8364 +1543 2002 +1543 8558 +1543 4143 +1543 2205 +1543 9839 +1543 3187 +1543 7061 +1543 7894 +1543 4818 +1543 7706 +1544 8211 +1544 2241 +1544 2155 +1544 9059 +1544 2277 +1544 6022 +1544 3079 +1544 1929 +1544 3409 +1544 2863 +1544 4723 +1544 2582 +1544 4919 +1544 3263 +1544 7966 +1545 4289 +1545 6085 +1545 9894 +1545 5036 +1545 9642 +1545 7788 +1545 9357 +1545 8692 +1545 4217 +1545 2714 +1545 2299 +1545 4828 +1545 8894 +1546 3074 +1546 1796 +1546 3472 +1546 4247 +1546 8985 +1546 1697 +1546 2471 +1546 4783 +1546 4148 +1546 4410 +1546 5326 +1546 3539 +1546 7253 +1546 5087 +1546 3940 +1546 4592 +1546 9171 +1546 8826 +1546 2171 +1546 5247 +1547 3844 +1547 1801 +1547 7181 +1547 8727 +1547 3867 +1547 7969 +1547 5794 +1547 4123 +1547 4519 +1547 7850 +1547 5167 +1547 6076 +1547 4029 +1547 1982 +1547 1613 +1547 4690 +1547 5079 +1547 6364 +1547 4218 +1547 8314 +1547 9852 +1547 4479 +1548 1666 +1548 5284 +1548 2917 +1548 2183 +1548 8072 +1548 4498 +1548 9677 +1548 6158 +1548 6321 +1548 8882 +1548 3230 +1548 9527 +1548 7353 +1548 6075 +1548 7677 +1548 3966 +1548 6501 +1549 4107 +1549 9873 +1549 9750 +1549 7580 +1549 7326 +1549 2460 +1549 4270 +1549 1712 +1549 6705 +1549 5692 +1549 5447 +1549 6861 +1549 6840 +1549 9684 +1549 5979 +1549 4060 +1549 8035 +1549 5094 +1549 6376 +1549 3185 +1550 8705 +1550 9605 +1550 5648 +1550 4113 +1550 5782 +1550 9367 +1550 5790 +1550 4652 +1550 1967 +1550 8127 +1550 9673 +1550 2519 +1550 2144 +1550 1890 +1550 4713 +1550 9580 +1550 2799 +1550 2162 +1550 9845 +1550 7292 +1551 8299 +1551 8205 +1551 5064 +1551 2891 +1551 3672 +1551 5645 +1551 3278 +1551 9039 +1551 7505 +1551 3029 +1551 1846 +1551 6073 +1551 2715 +1552 1633 +1552 6562 +1552 6323 +1552 9510 +1552 9831 +1552 2856 +1552 3452 +1552 9291 +1552 7281 +1552 7187 +1552 2421 +1552 2038 +1552 8521 +1552 2908 +1552 6110 +1552 3903 +1553 3204 +1553 3589 +1553 4134 +1553 2506 +1553 3307 +1553 3633 +1553 6450 +1553 9843 +1553 5454 +1553 3702 +1553 9011 +1553 9786 +1553 5727 +1554 4993 +1554 4439 +1554 6507 +1554 7206 +1554 9674 +1554 2187 +1554 8140 +1554 3309 +1554 7895 +1554 2481 +1554 8078 +1554 6135 +1554 9213 +1555 9392 +1555 8843 +1555 2053 +1555 6855 +1555 3176 +1555 5387 +1555 9005 +1555 6766 +1555 5167 +1555 7504 +1555 2577 +1555 4210 +1555 3299 +1555 1748 +1555 5838 +1555 4566 +1555 5485 +1555 9663 +1556 2592 +1556 2748 +1556 6986 +1556 5872 +1556 6867 +1556 3956 +1556 3511 +1556 8441 +1557 4739 +1557 8580 +1557 2963 +1557 9245 +1557 6305 +1557 5287 +1557 6184 +1557 3256 +1557 8135 +1557 4553 +1557 3662 +1557 2392 +1557 6473 +1557 2655 +1557 8097 +1557 1897 +1557 4087 +1557 7289 +1557 9338 +1557 5243 +1558 4224 +1558 8453 +1558 2066 +1558 3736 +1558 4847 +1558 9374 +1558 3751 +1558 9011 +1558 2878 +1558 9922 +1558 1611 +1558 9421 +1558 7891 +1558 8021 +1558 8665 +1558 5979 +1558 5983 +1558 8817 +1558 5364 +1558 6396 +1558 8702 +1559 1984 +1559 5122 +1559 6503 +1559 7893 +1559 6738 +1559 4462 +1559 9487 +1559 1616 +1559 6002 +1559 3598 +1559 8731 +1559 4284 +1559 3805 +1559 8927 +1560 9186 +1560 9499 +1560 8036 +1560 2085 +1560 4042 +1560 2767 +1560 6001 +1560 5396 +1560 6618 +1560 6043 +1560 8970 +1560 9791 +1561 1984 +1561 3043 +1561 2311 +1561 3136 +1561 9335 +1561 6275 +1561 2868 +1561 2037 +1561 2327 +1561 9593 +1561 1823 +1562 7319 +1562 8857 +1562 3873 +1562 1580 +1562 7469 +1562 9775 +1562 7221 +1562 2358 +1562 3258 +1562 7231 +1562 6098 +1562 4691 +1562 5078 +1562 5207 +1562 9052 +1562 3553 +1562 3943 +1562 4457 +1562 7537 +1563 9344 +1563 4493 +1563 8348 +1563 6431 +1563 8110 +1563 3504 +1563 1594 +1563 7868 +1563 3402 +1563 5460 +1563 7637 +1563 8026 +1563 5221 +1563 8304 +1563 4469 +1563 5756 +1563 9597 +1564 4064 +1564 2213 +1564 4998 +1564 5485 +1564 7054 +1564 6893 +1564 5072 +1564 7089 +1564 5422 +1564 3478 +1564 9976 +1564 5113 +1564 3486 +1564 8326 +1565 6519 +1565 4644 +1565 7846 +1565 3144 +1565 8585 +1565 4247 +1565 7181 +1565 5122 +1565 8781 +1565 2065 +1565 5292 +1565 7956 +1565 7765 +1565 7320 +1566 5250 +1566 8589 +1566 9362 +1566 6934 +1566 2586 +1566 3362 +1566 5155 +1566 8748 +1566 8109 +1566 4911 +1566 9266 +1566 8756 +1566 1975 +1566 8769 +1566 5442 +1566 2378 +1566 4555 +1566 6993 +1566 5845 +1566 6618 +1566 2152 +1566 2928 +1567 6849 +1567 3042 +1567 7203 +1567 5028 +1567 8422 +1567 4903 +1567 4394 +1567 9259 +1567 4653 +1567 8573 +1567 3280 +1567 7986 +1567 2787 +1567 9300 +1567 1880 +1567 2621 +1567 7167 +1568 2180 +1568 6038 +1568 4504 +1568 2201 +1568 6181 +1568 2997 +1568 2495 +1568 7363 +1568 5448 +1568 2638 +1568 9681 +1568 9554 +1568 2395 +1568 4188 +1568 3293 +1568 6757 +1568 9448 +1568 7534 +1568 8954 +1568 8060 +1568 9981 +1568 2942 +1569 2909 +1569 7685 +1569 4742 +1569 3183 +1569 8297 +1569 8919 +1569 3101 +1569 2381 +1569 3022 +1569 9167 +1569 9241 +1569 2527 +1569 4006 +1569 2779 +1569 5628 +1569 9277 +1569 5342 +1569 8511 +1570 8485 +1570 7846 +1570 3464 +1570 3057 +1570 9074 +1570 5236 +1570 5558 +1570 7270 +1570 2493 +1571 5833 +1571 9035 +1571 3313 +1571 8660 +1571 7575 +1571 9243 +1572 6048 +1572 5569 +1572 9002 +1572 1580 +1572 6766 +1572 2264 +1572 7289 +1572 2905 +1572 3098 +1572 1979 +1572 6330 +1573 7303 +1573 7304 +1573 2444 +1573 5261 +1573 8974 +1573 5784 +1573 4382 +1573 6305 +1573 5283 +1573 5157 +1573 3495 +1573 4395 +1573 2750 +1573 3265 +1573 2245 +1573 3782 +1573 1612 +1573 2378 +1573 7949 +1573 3796 +1573 2526 +1573 2085 +1573 9570 +1573 3812 +1573 8711 +1573 4976 +1573 6517 +1573 6721 +1574 9734 +1574 4519 +1574 5096 +1574 7132 +1574 7146 +1574 3879 +1574 8780 +1574 4111 +1574 6513 +1574 8467 +1574 9975 +1574 6063 +1574 3964 +1574 8735 +1575 6113 +1575 2200 +1575 2725 +1575 6759 +1575 6380 +1575 8363 +1575 6381 +1575 6511 +1575 7097 +1575 1814 +1575 5649 +1575 8789 +1575 9494 +1575 8313 +1575 7128 +1575 2426 +1575 6366 +1575 2230 +1576 8320 +1576 2177 +1576 5142 +1576 1943 +1576 4124 +1576 2205 +1576 6691 +1576 8233 +1576 5810 +1576 9145 +1576 7580 +1576 5179 +1576 8137 +1576 4942 +1576 2767 +1576 5539 +1576 9949 +1576 2401 +1576 6882 +1576 3456 +1577 4801 +1577 6435 +1577 6596 +1577 6930 +1577 3848 +1577 5481 +1577 4813 +1577 7058 +1577 8336 +1577 9865 +1577 7812 +1577 4506 +1578 1840 +1578 9671 +1578 3563 +1578 8845 +1578 7758 +1578 9936 +1578 1649 +1578 5842 +1578 4499 +1578 6964 +1578 3512 +1578 2873 +1578 5339 +1578 7324 +1578 1725 +1578 7448 +1578 4229 +1579 5893 +1579 8454 +1579 3471 +1579 4369 +1579 3745 +1579 4386 +1579 9513 +1579 2230 +1579 6971 +1579 8254 +1579 6865 +1579 5075 +1579 4695 +1579 2276 +1579 2279 +1579 9450 +1579 8691 +1579 6013 +1580 9352 +1580 6297 +1580 4384 +1580 8490 +1580 8634 +1580 8511 +1580 6337 +1580 4802 +1580 3398 +1580 5198 +1580 4180 +1580 7510 +1580 2776 +1580 4825 +1580 7142 +1580 5365 +1581 3201 +1581 8708 +1581 5899 +1581 6674 +1581 3844 +1581 2331 +1581 8988 +1581 9629 +1581 7329 +1581 3291 +1581 5156 +1581 7218 +1581 8499 +1581 5561 +1581 6218 +1581 8417 +1581 8295 +1581 6509 +1581 9326 +1581 3954 +1581 4852 +1581 6655 +1582 8096 +1582 8673 +1582 7640 +1582 5064 +1582 7435 +1582 7470 +1582 9405 +1582 2847 +1582 3089 +1582 2258 +1582 8180 +1582 2165 +1582 2200 +1582 5565 +1582 5566 +1582 3774 +1583 5824 +1583 3008 +1583 6939 +1583 3917 +1583 3368 +1583 8106 +1583 9388 +1583 1837 +1583 7375 +1583 7325 +1583 9955 +1583 5305 +1583 5049 +1583 7483 +1583 3388 +1583 1981 +1583 4094 +1584 9235 +1584 6932 +1584 3673 +1584 8609 +1584 7206 +1584 5165 +1584 2354 +1584 7228 +1584 5184 +1584 8775 +1584 6392 +1584 8661 +1584 9817 +1584 6618 +1584 2649 +1584 9382 +1584 9718 +1584 7672 +1585 1920 +1585 5249 +1585 9603 +1585 9348 +1585 3217 +1585 8473 +1585 3739 +1585 2212 +1585 2213 +1585 9771 +1585 8109 +1585 1594 +1585 3260 +1585 3905 +1585 4549 +1585 5575 +1585 7517 +1585 9058 +1585 8424 +1585 8814 +1585 4214 +1586 7681 +1586 8386 +1586 5347 +1586 3844 +1586 2917 +1586 4679 +1586 2186 +1586 5227 +1586 4621 +1586 4142 +1586 7375 +1586 5104 +1586 5297 +1586 4819 +1586 8796 +1586 4798 +1586 2335 +1587 2848 +1587 7937 +1587 6499 +1587 3745 +1587 8776 +1587 3685 +1587 8965 +1587 5469 +1587 7856 +1587 8063 +1587 5527 +1587 8047 +1587 3839 +1587 7386 +1587 7359 +1588 8737 +1588 4386 +1588 5982 +1588 2982 +1588 1665 +1588 7721 +1588 6241 +1588 8935 +1588 9356 +1588 3330 +1588 4622 +1588 8367 +1588 1970 +1588 8755 +1588 8309 +1588 5689 +1588 5691 +1588 8414 +1589 2337 +1589 4422 +1589 7909 +1589 5130 +1589 9646 +1589 4625 +1589 6898 +1589 3027 +1589 2041 +1590 3595 +1590 2861 +1590 9941 +1590 4339 +1590 9686 +1590 9815 +1590 8664 +1590 5850 +1590 3647 +1590 9181 +1590 8286 +1590 7807 +1591 6017 +1591 7970 +1591 2250 +1591 4267 +1591 7362 +1591 8431 +1591 5138 +1591 2324 +1591 5655 +1591 5882 +1591 3434 +1592 3266 +1592 9093 +1592 9576 +1592 7436 +1592 2382 +1592 7983 +1592 6792 +1592 4595 +1592 9582 +1592 6582 +1592 8217 +1592 8636 +1592 6751 +1593 9861 +1593 8982 +1593 4357 +1593 7338 +1593 4958 +1593 2358 +1593 9275 +1593 8647 +1593 5663 +1593 7646 +1593 7995 +1593 8804 +1593 2279 +1593 4458 +1593 3303 +1593 5869 +1593 1649 +1593 5752 +1593 9978 +1593 6654 +1594 9476 +1594 3088 +1594 9155 +1594 6020 +1594 1821 +1594 5673 +1594 5683 +1594 2749 +1594 4291 +1594 2636 +1594 7373 +1594 8915 +1594 9048 +1594 7907 +1594 5743 +1594 3954 +1594 2807 +1595 7264 +1595 3579 +1595 8103 +1595 2696 +1595 2093 +1595 8589 +1595 2611 +1595 4948 +1595 6906 +1595 4621 +1595 2714 +1595 7167 +1596 7054 +1596 8719 +1596 3985 +1596 4754 +1596 8085 +1596 8726 +1596 5529 +1596 2079 +1596 4899 +1596 5031 +1596 4284 +1596 1856 +1596 7117 +1596 9614 +1596 7133 +1596 4193 +1596 6673 +1596 7785 +1596 2029 +1596 9968 +1596 2810 +1597 2851 +1597 4291 +1597 4349 +1597 4263 +1597 4872 +1597 9609 +1597 1997 +1597 9164 +1597 2637 +1597 4239 +1597 8948 +1597 9753 +1597 5551 +1597 5052 +1598 5633 +1598 7042 +1598 8047 +1598 8841 +1598 9391 +1598 4766 +1598 6436 +1598 2247 +1598 4015 +1598 9017 +1598 7231 +1598 5575 +1598 4939 +1598 4692 +1598 2390 +1598 5083 +1598 2287 +1598 4597 +1598 6268 +1598 4733 +1599 6785 +1599 6338 +1599 9606 +1599 9894 +1599 7367 +1599 4616 +1599 6514 +1599 4524 +1599 7986 +1599 6448 +1599 8218 +1599 5234 +1599 3411 +1599 1907 +1599 4446 +1599 7743 +1600 9733 +1600 8454 +1600 5642 +1600 7308 +1600 8216 +1600 2209 +1600 7302 +1600 7339 +1600 6061 +1600 6190 +1600 9776 +1600 3249 +1600 4663 +1600 9145 +1600 8138 +1600 4290 +1600 3528 +1600 3274 +1600 5175 +1600 7138 +1600 4710 +1600 7920 +1601 4592 +1601 8006 +1601 4774 +1601 9000 +1601 1640 +1601 6858 +1601 6349 +1601 5199 +1601 5392 +1601 2481 +1601 5874 +1601 7507 +1601 3256 +1601 3610 +1601 1949 +1601 2686 +1602 8641 +1602 5990 +1602 7046 +1602 4135 +1602 3400 +1602 7945 +1602 9260 +1602 4271 +1602 3772 +1602 7358 +1602 8895 +1603 4611 +1603 4105 +1603 8332 +1603 4502 +1603 6807 +1603 2714 +1603 7713 +1603 4773 +1603 3110 +1603 6188 +1603 3245 +1603 8625 +1603 4790 +1603 3003 +1603 6212 +1603 7643 +1603 7077 +1603 9056 +1603 9962 +1603 4402 +1603 4343 +1604 7837 +1604 6273 +1604 1762 +1604 3062 +1604 8969 +1604 2731 +1604 5004 +1604 8142 +1604 2575 +1604 2673 +1604 4242 +1604 8655 +1604 5070 +1604 5310 +1604 6007 +1604 9307 +1605 5088 +1605 4880 +1605 4866 +1605 8242 +1605 2853 +1605 1798 +1605 4583 +1605 2242 +1605 5378 +1605 6573 +1605 7663 +1605 6992 +1605 5845 +1605 8917 +1605 4825 +1605 2266 +1605 5086 +1605 7167 +1606 8325 +1606 5162 +1606 4363 +1606 6222 +1606 3120 +1606 4785 +1606 3380 +1606 9813 +1606 6900 +1606 5946 +1606 9674 +1606 8638 +1606 5093 +1607 6480 +1607 7171 +1607 5157 +1607 8713 +1607 3857 +1607 3186 +1607 9315 +1607 6644 +1607 5193 +1607 5272 +1607 9465 +1607 5471 +1608 9920 +1608 6080 +1608 2628 +1608 9670 +1608 2919 +1608 7785 +1608 6506 +1608 4743 +1608 6284 +1608 7261 +1608 2708 +1608 7684 +1608 3261 +1609 7694 +1609 8352 +1609 8881 +1609 6334 +1609 1983 +1609 2117 +1609 1863 +1609 1998 +1609 5713 +1609 2382 +1609 7900 +1609 3041 +1609 8291 +1609 5585 +1609 7402 +1609 8171 +1609 6769 +1609 4476 +1610 6592 +1610 4192 +1610 6083 +1610 2795 +1610 7849 +1610 1963 +1610 6791 +1610 9198 +1610 5843 +1610 8660 +1610 5269 +1610 7607 +1611 9952 +1611 9953 +1611 4101 +1611 5191 +1611 9608 +1611 6027 +1611 7756 +1611 8302 +1611 5455 +1611 4660 +1611 4174 +1611 4665 +1611 5530 +1611 7579 +1611 7604 +1611 5374 +1612 8198 +1612 4710 +1612 2952 +1612 5486 +1612 9488 +1612 9873 +1612 9269 +1612 3002 +1612 2746 +1612 2975 +1613 2784 +1613 7264 +1613 6710 +1613 3336 +1613 4585 +1613 2539 +1613 2060 +1613 2735 +1613 4757 +1613 9714 +1613 5267 +1613 6804 +1613 6453 +1613 2582 +1613 5148 +1613 9973 +1614 5891 +1614 8334 +1614 2194 +1614 9757 +1614 4646 +1614 3625 +1614 9515 +1614 5292 +1614 3507 +1614 2488 +1614 5180 +1614 3908 +1614 4423 +1614 9800 +1614 1745 +1614 3292 +1614 7787 +1614 2540 +1614 2157 +1614 4983 +1614 2171 +1614 9727 +1615 8715 +1615 5604 +1615 5830 +1615 4201 +1615 9162 +1615 6507 +1615 3276 +1615 7790 +1615 8238 +1615 2585 +1615 1939 +1615 7039 +1616 1856 +1616 9610 +1616 2195 +1616 7854 +1616 3867 +1616 6684 +1616 4638 +1616 2736 +1616 2480 +1616 4273 +1616 9523 +1616 1718 +1616 1976 +1616 8128 +1616 8137 +1616 4176 +1616 5680 +1616 6616 +1616 5028 +1616 4318 +1616 5603 +1616 8429 +1616 3438 +1616 7422 +1616 5880 +1616 4857 +1616 2814 +1617 4075 +1617 7845 +1617 5352 +1617 4139 +1617 9469 +1617 5361 +1617 5369 +1617 5757 +1617 5445 +1618 6209 +1618 8322 +1618 2907 +1618 8872 +1618 6697 +1618 8042 +1618 8460 +1618 7861 +1618 5398 +1618 7703 +1618 5915 +1618 5565 +1618 7806 +1618 7487 +1619 1670 +1619 7084 +1619 9613 +1619 9232 +1619 8850 +1619 6931 +1619 9750 +1619 4890 +1619 7850 +1619 3883 +1619 8264 +1619 2616 +1619 8895 +1619 3653 +1619 6088 +1619 2136 +1619 3292 +1619 5226 +1620 9120 +1620 7350 +1620 4422 +1620 6809 +1620 3063 +1620 4467 +1620 9940 +1620 9654 +1620 5272 +1620 6644 +1620 1725 +1620 2334 +1621 9733 +1621 6791 +1621 5645 +1621 6546 +1621 1822 +1621 3244 +1621 6445 +1621 5817 +1621 9786 +1621 1852 +1621 3517 +1621 5054 +1621 9290 +1621 3149 +1621 1877 +1621 9692 +1621 6626 +1621 8806 +1621 4797 +1621 4465 +1621 9723 +1621 5757 +1622 3536 +1622 2498 +1622 4715 +1622 4513 +1622 3528 +1622 1897 +1622 7947 +1622 9743 +1622 7440 +1622 9161 +1622 2354 +1622 9680 +1622 8023 +1622 1656 +1622 2618 +1622 7003 +1622 1823 +1623 4320 +1623 7568 +1623 6850 +1623 9797 +1623 6727 +1623 4682 +1623 9070 +1623 2511 +1623 9296 +1623 7635 +1623 9972 +1623 9718 +1623 9955 +1623 3515 +1624 9943 +1624 7180 +1624 8605 +1624 4258 +1624 7591 +1624 8748 +1624 8111 +1624 7738 +1624 9152 +1624 7361 +1624 2884 +1624 6237 +1624 7528 +1624 9961 +1624 8558 +1624 5243 +1624 3710 +1625 3335 +1625 9871 +1625 8722 +1625 1811 +1625 6174 +1625 7071 +1625 4008 +1625 6366 +1625 9659 +1625 9533 +1625 7951 +1625 3010 +1625 6341 +1625 2887 +1625 2769 +1625 7511 +1625 9759 +1625 9434 +1625 2651 +1625 4318 +1625 6115 +1625 7781 +1625 2152 +1625 3433 +1625 5105 +1625 6259 +1625 4983 +1626 6151 +1626 6305 +1626 3236 +1626 3631 +1626 5684 +1626 6968 +1626 5817 +1626 5444 +1626 7381 +1626 1883 +1626 5469 +1626 9316 +1626 7397 +1626 6760 +1626 7410 +1626 8055 +1626 4221 +1627 2632 +1627 2506 +1627 7691 +1627 4525 +1627 3025 +1627 6578 +1627 8979 +1627 3157 +1627 9751 +1627 5049 +1627 7579 +1627 5098 +1627 5877 +1628 9931 +1628 8775 +1628 5352 +1628 9706 +1628 2050 +1628 6184 +1628 8116 +1628 9461 +1628 5367 +1628 7671 +1628 3988 +1628 6908 +1628 9447 +1629 9987 +1629 8975 +1629 3479 +1629 8476 +1629 6688 +1629 7592 +1629 8732 +1629 3505 +1629 6208 +1629 9540 +1629 5197 +1629 3668 +1629 5080 +1629 8411 +1629 2400 +1629 9339 +1629 6396 +1629 7421 +1630 7168 +1630 5383 +1630 7825 +1630 9106 +1630 6308 +1630 1967 +1630 9905 +1630 2996 +1630 2487 +1630 2237 +1630 2123 +1630 6221 +1630 7517 +1630 6361 +1630 9949 +1630 1633 +1630 4452 +1630 8552 +1630 5993 +1630 4075 +1630 3061 +1630 5626 +1631 6178 +1631 2347 +1631 9655 +1631 4018 +1631 5918 +1631 7550 +1631 6962 +1631 3957 +1631 7445 +1631 8983 +1631 7801 +1631 8699 +1631 6332 +1631 6525 +1631 2302 +1631 6719 +1632 5504 +1632 6625 +1632 2722 +1632 6883 +1632 7620 +1632 1672 +1632 6386 +1632 9922 +1632 5521 +1632 5458 +1632 9635 +1632 5982 +1632 8899 +1632 4085 +1632 6766 +1632 2270 +1632 5429 +1633 7968 +1633 5305 +1633 8741 +1633 2214 +1633 5219 +1633 8332 +1633 8846 +1633 5016 +1633 6579 +1633 8414 +1633 9466 +1633 5307 +1633 6798 +1634 4224 +1634 4354 +1634 2058 +1634 8715 +1634 6675 +1634 9114 +1634 9633 +1634 5540 +1634 8364 +1634 7088 +1634 3392 +1634 6341 +1634 3280 +1634 5728 +1634 8036 +1634 3306 +1634 7917 +1634 2547 +1634 5886 +1635 7426 +1635 9476 +1635 3077 +1635 7313 +1635 9880 +1635 2854 +1635 8872 +1635 9004 +1635 3631 +1635 4168 +1635 5818 +1635 3902 +1635 6079 +1635 3399 +1635 1736 +1635 4553 +1635 7505 +1635 8088 +1635 9940 +1635 8279 +1635 3540 +1635 4731 +1636 2528 +1636 6464 +1636 7874 +1636 4612 +1636 7461 +1636 9288 +1636 2144 +1636 7850 +1636 9037 +1636 8398 +1636 3473 +1636 2868 +1636 5141 +1636 2076 +1637 6048 +1637 4481 +1637 7515 +1637 2535 +1637 2446 +1637 5522 +1637 6996 +1637 7733 +1637 6958 +1637 1879 +1637 6424 +1637 4347 +1637 8027 +1637 9116 +1637 7294 +1637 2239 +1638 7329 +1638 3396 +1638 6849 +1638 7208 +1638 9815 +1638 4400 +1638 4113 +1638 8148 +1638 3294 +1638 9224 +1638 7253 +1638 5913 +1638 8635 +1638 5437 +1638 6718 +1639 8930 +1639 5507 +1639 7173 +1639 3496 +1639 5436 +1639 2538 +1639 4299 +1639 3788 +1639 4365 +1639 8528 +1639 5265 +1639 2068 +1639 9366 +1639 4396 +1639 6760 +1639 8764 +1639 5579 +1640 8730 +1640 8989 +1640 2978 +1640 8612 +1640 5298 +1640 1853 +1640 2367 +1640 2628 +1640 3270 +1640 6990 +1640 4304 +1640 5076 +1640 4949 +1640 3800 +1640 3681 +1640 3554 +1640 2408 +1640 1901 +1640 5107 +1640 5372 +1640 7421 +1641 1672 +1641 2830 +1641 4883 +1641 2324 +1641 3223 +1641 3761 +1641 7090 +1641 4664 +1641 9022 +1641 4674 +1641 2761 +1641 4045 +1641 5327 +1641 4712 +1641 1647 +1641 9205 +1641 2937 +1641 4730 +1642 1888 +1642 3265 +1642 1698 +1642 4835 +1642 8014 +1642 7750 +1642 8308 +1642 4366 +1642 5583 +1642 9348 +1642 2974 +1642 7034 +1642 8347 +1642 7770 +1642 5726 +1642 4997 +1643 8836 +1643 8201 +1643 4879 +1643 9113 +1643 4763 +1643 8348 +1643 5662 +1643 5408 +1643 2977 +1643 6562 +1643 8859 +1643 8872 +1643 8860 +1643 1981 +1643 3392 +1643 3915 +1643 9681 +1643 5461 +1643 3030 +1643 2523 +1643 6368 +1643 2790 +1644 7917 +1644 1936 +1644 4881 +1644 3476 +1644 2351 +1644 3481 +1644 9883 +1644 3364 +1644 8361 +1644 5679 +1644 8881 +1644 9656 +1644 6587 +1644 9790 +1644 9162 +1644 7352 +1644 4314 +1644 3809 +1644 6253 +1644 2293 +1644 8442 +1644 7480 +1645 5385 +1645 5803 +1645 5202 +1645 4781 +1645 6098 +1645 8535 +1645 1946 +1645 2866 +1645 8447 +1646 2032 +1646 9762 +1646 4139 +1646 4070 +1646 4582 +1646 4743 +1646 5384 +1646 6371 +1646 4359 +1646 9635 +1646 5085 +1646 3824 +1646 3410 +1646 4819 +1646 5235 +1646 5942 +1646 3796 +1646 6170 +1646 8541 +1647 9808 +1647 3970 +1647 3715 +1647 5860 +1647 8966 +1647 2246 +1647 4732 +1647 6856 +1647 8398 +1647 8495 +1647 7536 +1647 6385 +1647 2889 +1647 4476 +1647 6408 +1647 4885 +1648 2310 +1648 4230 +1648 9479 +1648 5132 +1648 5658 +1648 9372 +1648 5153 +1648 5029 +1648 6054 +1648 6695 +1648 8618 +1648 6571 +1648 8754 +1648 1716 +1648 5047 +1648 7740 +1648 6333 +1648 8524 +1648 3151 +1648 2132 +1648 2008 +1648 7642 +1648 9851 +1649 1730 +1649 3270 +1649 4039 +1649 4456 +1649 4060 +1649 8551 +1649 4497 +1649 8369 +1649 6388 +1649 9431 +1649 4280 +1649 5274 +1649 8315 +1649 8700 +1649 9855 +1650 6497 +1650 7682 +1650 8163 +1650 5508 +1650 7077 +1650 7815 +1650 3272 +1650 2057 +1650 9800 +1650 3248 +1650 6152 +1650 4723 +1650 4404 +1650 1854 +1650 4248 +1650 1786 +1650 2427 +1650 3006 +1650 9649 +1651 3469 +1651 1821 +1651 3490 +1651 5738 +1651 5033 +1651 9902 +1651 6194 +1651 5179 +1651 3902 +1651 3778 +1651 7363 +1651 9799 +1651 8139 +1651 6105 +1651 5083 +1651 7520 +1651 4963 +1651 3434 +1651 6768 +1651 3442 +1651 6206 +1651 9207 +1651 9338 +1651 2427 +1652 7333 +1652 3078 +1652 7121 +1652 3592 +1652 9970 +1652 6067 +1652 6646 +1652 7576 +1652 3482 +1652 8955 +1652 6813 +1652 6879 +1653 6721 +1653 4962 +1653 2313 +1653 8363 +1653 2829 +1653 6062 +1653 9551 +1653 2319 +1653 7669 +1653 6850 +1653 9563 +1653 3772 +1653 8382 +1654 7562 +1654 8729 +1654 2602 +1654 2996 +1654 5047 +1654 8120 +1654 7348 +1654 2623 +1654 3397 +1654 3398 +1654 8007 +1654 6092 +1654 6476 +1654 4301 +1654 2004 +1654 8669 +1654 9186 +1654 5092 +1654 4070 +1654 8308 +1655 9602 +1655 6404 +1655 5085 +1655 8212 +1655 2799 +1655 6183 +1655 3625 +1655 8495 +1655 6840 +1655 2115 +1655 5448 +1655 9309 +1655 3041 +1655 7269 +1655 5735 +1655 7788 +1655 4463 +1655 2160 +1655 2035 +1656 3590 +1656 4749 +1656 2206 +1656 9890 +1656 2851 +1656 3247 +1656 6966 +1656 8119 +1656 9277 +1656 3787 +1656 9741 +1656 7331 +1656 4694 +1656 8668 +1656 5346 +1656 6774 +1656 9591 +1656 8056 +1657 6603 +1657 8011 +1657 1965 +1657 4973 +1657 9584 +1657 8340 +1657 5429 +1657 1878 +1657 2455 +1657 4212 +1657 3418 +1657 2043 +1657 3260 +1658 4036 +1658 6759 +1658 1898 +1658 8590 +1658 5520 +1658 5585 +1658 1790 +1658 6089 +1658 3001 +1658 5849 +1658 8092 +1658 1821 +1658 2334 +1659 7233 +1659 4642 +1659 2502 +1659 5353 +1659 9447 +1659 8653 +1659 6417 +1659 2513 +1659 2357 +1659 6231 +1660 3587 +1660 8586 +1660 8076 +1660 6551 +1660 7451 +1660 5147 +1660 4573 +1660 6200 +1660 4153 +1660 5186 +1660 8644 +1660 3019 +1660 5711 +1660 3540 +1660 4565 +1660 3927 +1660 2918 +1660 7404 +1660 8820 +1660 8916 +1660 2302 +1661 6720 +1661 8648 +1661 7400 +1661 6282 +1661 7247 +1661 3569 +1661 3570 +1661 6837 +1661 2391 +1661 3291 +1661 9054 +1661 8191 +1662 6753 +1662 9003 +1662 5220 +1662 4390 +1662 2129 +1662 9128 +1662 4585 +1662 9995 +1662 1839 +1662 5648 +1662 8081 +1662 4665 +1662 7518 +1662 9047 +1662 7812 +1662 9182 +1663 8192 +1663 2049 +1663 6659 +1663 7812 +1663 4875 +1663 6682 +1663 5669 +1663 6954 +1663 2533 +1663 2354 +1663 5299 +1663 2745 +1663 7618 +1663 9411 +1663 7118 +1663 4453 +1663 1893 +1663 2813 +1663 6271 +1664 9728 +1664 2528 +1664 5634 +1664 5797 +1664 8710 +1664 5163 +1664 5586 +1664 3759 +1664 3538 +1664 1747 +1664 6994 +1664 9811 +1664 4916 +1664 9858 +1664 3353 +1664 8441 +1664 9866 +1664 9957 +1665 4971 +1665 6441 +1665 5079 +1665 6221 +1665 7791 +1665 5872 +1665 8344 +1665 6738 +1665 1749 +1665 2486 +1665 4440 +1665 7353 +1665 5077 +1666 6401 +1666 8839 +1666 2441 +1666 7895 +1666 1914 +1666 7318 +1666 5019 +1666 5281 +1666 4774 +1666 4908 +1666 2486 +1666 4795 +1666 6460 +1666 8002 +1666 8403 +1666 8276 +1666 8407 +1666 5847 +1666 5990 +1666 9198 +1666 7024 +1666 3962 +1666 1788 +1667 9986 +1667 9482 +1667 6042 +1667 7326 +1667 7970 +1667 3107 +1667 4904 +1667 5290 +1667 2610 +1667 3392 +1667 6085 +1667 3106 +1667 4052 +1667 6115 +1667 9080 +1667 4346 +1667 3580 +1668 7491 +1668 7204 +1668 9222 +1668 8769 +1668 4588 +1668 8877 +1668 8334 +1668 5808 +1668 2738 +1668 4787 +1668 3092 +1668 7926 +1668 7735 +1668 8900 +1668 5636 +1668 7550 +1668 4626 +1669 4629 +1669 1814 +1669 6597 +1669 3498 +1669 3630 +1669 7219 +1669 2484 +1669 4149 +1669 8633 +1669 7739 +1669 9148 +1669 6846 +1669 6209 +1669 5954 +1669 2117 +1669 7245 +1669 3920 +1669 5718 +1669 9441 +1669 9186 +1669 9195 +1669 8046 +1669 8957 +1669 4596 +1669 6903 +1669 4601 +1669 4989 +1670 5120 +1670 7364 +1670 6437 +1670 4460 +1670 8370 +1670 8532 +1670 7891 +1670 7575 +1670 7931 +1670 9660 +1670 7037 +1671 7590 +1671 6075 +1671 5931 +1671 8045 +1671 5039 +1671 4048 +1671 6317 +1671 2355 +1671 7733 +1671 2965 +1671 6652 +1671 7583 +1671 2589 +1671 3581 +1671 3455 +1672 8961 +1672 5186 +1672 7819 +1672 5125 +1672 4096 +1672 5395 +1672 3370 +1672 4683 +1672 5517 +1672 3182 +1672 5747 +1672 8727 +1672 3321 +1672 2012 +1672 1693 +1672 9823 +1673 8520 +1673 3248 +1673 8676 +1673 3464 +1673 1681 +1673 7666 +1673 8467 +1673 7828 +1673 2233 +1673 6968 +1673 9049 +1673 4251 +1674 7041 +1674 6532 +1674 5633 +1674 7180 +1674 3218 +1674 9177 +1674 8225 +1674 4642 +1674 6948 +1674 5804 +1674 2095 +1674 7349 +1674 5436 +1674 2756 +1674 7758 +1674 1872 +1674 3795 +1674 9300 +1674 2777 +1674 3942 +1674 4969 +1674 5101 +1674 2035 +1674 6138 +1674 2044 +1674 4093 +1674 6180 +1675 4480 +1675 9313 +1675 1730 +1675 7075 +1675 6147 +1675 2227 +1675 2307 +1675 4747 +1675 2882 +1675 7183 +1675 4144 +1675 7211 +1675 9010 +1675 3637 +1675 8657 +1675 2947 +1675 6385 +1676 7968 +1676 6689 +1676 2820 +1676 7077 +1676 3496 +1676 8039 +1676 3855 +1676 9392 +1676 3528 +1676 6676 +1676 7221 +1676 8945 +1676 9497 +1676 5231 +1676 8189 +1676 9215 +1677 7008 +1677 4546 +1677 6363 +1677 5220 +1677 7014 +1677 7527 +1677 6024 +1677 9674 +1677 1995 +1677 5043 +1677 9422 +1677 7450 +1677 8987 +1677 3932 +1678 1963 +1678 8593 +1678 6675 +1678 6295 +1678 6931 +1678 2587 +1678 4003 +1678 2344 +1678 7339 +1678 9776 +1678 5939 +1678 7093 +1678 1976 +1678 5044 +1678 4430 +1678 3666 +1678 2400 +1678 2088 +1678 9363 +1678 2425 +1679 9859 +1679 1709 +1679 9013 +1679 7284 +1679 7868 +1679 3517 +1679 7231 +1679 6979 +1679 5448 +1679 3414 +1679 5301 +1679 9186 +1679 9703 +1679 3388 +1679 7921 +1679 8948 +1679 5500 +1679 6526 +1680 4633 +1680 9606 +1680 2502 +1680 4743 +1680 2985 +1680 1972 +1680 9687 +1680 8550 +1680 5246 +1681 8325 +1681 7434 +1681 9622 +1681 8990 +1681 4357 +1681 5283 +1681 3363 +1681 7603 +1681 8628 +1681 9910 +1681 9205 +1681 5065 +1681 4043 +1681 2018 +1681 9709 +1681 9844 +1681 4086 +1681 4984 +1681 7931 +1682 5665 +1682 6618 +1682 9830 +1682 4615 +1682 9263 +1682 2059 +1682 4914 +1682 9167 +1682 7026 +1682 4532 +1682 2710 +1682 2392 +1682 7994 +1682 2847 +1682 6111 +1683 9954 +1683 9157 +1683 7335 +1683 3880 +1683 8412 +1683 3690 +1683 5863 +1683 2317 +1683 5262 +1683 8175 +1683 3208 +1683 5330 +1683 9933 +1683 2517 +1683 4567 +1683 7128 +1683 3487 +1683 6684 +1683 7013 +1684 2976 +1684 7970 +1684 8611 +1684 2455 +1684 5222 +1684 6887 +1684 2696 +1684 7178 +1684 1751 +1684 3342 +1684 9423 +1684 3121 +1684 8186 +1684 4084 +1684 8149 +1684 6935 +1684 4954 +1684 8945 +1684 6301 +1685 9792 +1685 4833 +1685 6434 +1685 6885 +1685 2246 +1685 3752 +1685 8613 +1685 5037 +1685 9864 +1685 1970 +1685 7616 +1685 2901 +1685 6394 +1685 6559 +1686 3789 +1686 3515 +1686 1924 +1686 8453 +1686 2598 +1686 3055 +1686 4582 +1686 4714 +1686 4973 +1686 5039 +1686 3860 +1686 2774 +1686 9911 +1686 9460 +1686 2715 +1686 3206 +1686 2197 +1687 8586 +1687 2828 +1687 7437 +1687 7325 +1687 7843 +1687 5028 +1687 7079 +1687 6898 +1687 7484 +1687 6987 +1687 2105 +1687 3677 +1687 9697 +1687 9575 +1687 5874 +1687 8694 +1688 4160 +1688 8036 +1688 4428 +1688 9581 +1688 2801 +1688 3986 +1688 7221 +1688 2810 +1688 4442 +1689 8832 +1689 6529 +1689 7046 +1689 6502 +1689 7785 +1689 4104 +1689 7628 +1689 9261 +1689 7213 +1689 6768 +1689 2769 +1689 9459 +1689 4468 +1689 3142 +1689 6776 +1689 1812 +1689 8122 +1689 2716 +1689 3966 +1690 4307 +1690 9009 +1690 2442 +1690 7975 +1690 6353 +1690 2931 +1690 7958 +1690 3480 +1690 5241 +1691 6944 +1691 7312 +1691 8770 +1691 2051 +1691 8488 +1691 8329 +1691 7658 +1691 8204 +1691 5293 +1691 7665 +1691 1923 +1691 2972 +1691 2200 +1691 5433 +1691 3642 +1691 5149 +1691 9599 +1692 3907 +1692 5457 +1692 2604 +1692 6215 +1692 2540 +1692 2829 +1692 3569 +1692 9843 +1692 2964 +1692 3641 +1692 8187 +1692 4051 +1692 8799 +1693 3512 +1693 6084 +1693 6801 +1693 3564 +1693 9645 +1693 6959 +1693 6632 +1693 3699 +1693 7637 +1693 9334 +1693 5592 +1693 6298 +1693 8767 +1694 5440 +1694 3906 +1694 1931 +1694 4132 +1694 5509 +1694 9414 +1694 3809 +1694 2888 +1694 9321 +1694 4618 +1694 8971 +1694 6605 +1694 7031 +1694 1877 +1694 1878 +1694 9879 +1694 5688 +1694 4023 +1694 8489 +1694 2237 +1695 9793 +1695 4834 +1695 4964 +1695 8485 +1695 2779 +1695 4993 +1695 4872 +1695 3243 +1695 8396 +1695 4269 +1695 4079 +1695 6103 +1695 3803 +1695 5751 +1696 9091 +1696 2757 +1696 4385 +1696 6409 +1696 7597 +1696 9071 +1696 8728 +1696 3534 +1696 3256 +1696 2235 +1696 9245 +1696 4926 +1696 6581 +1697 4624 +1697 7569 +1697 9747 +1697 7964 +1697 3760 +1697 2473 +1697 8876 +1697 7086 +1697 5936 +1697 9527 +1697 8762 +1697 1726 +1697 8263 +1697 2261 +1697 8281 +1697 8540 +1697 3171 +1697 3432 +1697 1908 +1697 7029 +1697 5545 +1697 7293 +1697 3198 +1698 7137 +1698 9890 +1698 4803 +1698 5348 +1698 3302 +1698 9095 +1698 5735 +1698 5292 +1698 6029 +1698 3085 +1698 3346 +1698 5428 +1698 2965 +1698 8374 +1698 6075 +1698 7516 +1698 2922 +1698 4767 +1699 6672 +1699 8168 +1699 3949 +1699 9085 +1699 2832 +1699 9970 +1699 2516 +1699 3798 +1699 3224 +1699 9178 +1699 5533 +1700 2945 +1700 8971 +1700 5906 +1700 8723 +1700 5530 +1700 6300 +1700 6559 +1700 3618 +1700 3635 +1700 6712 +1700 1980 +1700 5839 +1700 2132 +1700 6742 +1700 9945 +1700 4559 +1700 3934 +1700 4963 +1700 6898 +1700 3701 +1700 8698 +1700 2685 +1701 1920 +1701 8455 +1701 5519 +1701 4124 +1701 9246 +1701 8645 +1701 2466 +1701 5020 +1701 8877 +1701 4910 +1701 6814 +1701 6329 +1701 2750 +1701 2422 +1701 7244 +1701 9807 +1701 3800 +1701 1753 +1701 7247 +1701 8028 +1701 3037 +1701 3553 +1701 5227 +1701 8685 +1701 7411 +1701 3956 +1701 8182 +1701 4600 +1702 4352 +1702 4230 +1702 8739 +1702 7092 +1702 3255 +1702 4924 +1702 3903 +1702 9792 +1702 2117 +1702 5578 +1702 4811 +1702 7257 +1702 8036 +1702 1903 +1702 6259 +1702 8955 +1703 5317 +1703 4611 +1703 3494 +1703 9350 +1703 9293 +1703 9459 +1703 5332 +1703 9238 +1703 4666 +1703 2527 +1703 8261 +1703 9797 +1704 2048 +1704 6405 +1704 8976 +1704 3861 +1704 2070 +1704 1706 +1704 8242 +1704 7220 +1704 5048 +1704 2491 +1704 4927 +1704 8771 +1704 3014 +1704 4679 +1704 9426 +1704 5844 +1704 4696 +1704 7143 +1704 5458 +1704 9721 +1705 7971 +1705 8168 +1705 9609 +1705 8682 +1705 3597 +1705 5597 +1705 4208 +1705 2417 +1705 1874 +1705 9529 +1705 5305 +1705 4506 +1705 1724 +1705 2237 +1706 5280 +1706 9153 +1706 6725 +1706 9062 +1706 5927 +1706 7722 +1706 3207 +1706 2735 +1706 7907 +1706 8021 +1706 2896 +1706 2392 +1706 6750 +1706 4542 +1707 5537 +1707 4035 +1707 9381 +1707 6598 +1707 8266 +1707 4525 +1707 3165 +1707 4367 +1707 4977 +1707 4628 +1707 2445 +1707 6522 +1707 9213 +1707 9630 +1707 5759 +1708 4705 +1708 3334 +1708 2602 +1708 3019 +1708 3340 +1708 6324 +1708 8798 +1708 5078 +1708 4119 +1708 6585 +1708 8732 +1708 4202 +1708 9278 +1708 9439 +1709 2455 +1709 2320 +1709 4887 +1709 4899 +1709 2980 +1709 7476 +1709 7113 +1709 6346 +1709 7505 +1709 3799 +1709 2906 +1709 5601 +1709 3705 +1709 7295 +1710 5248 +1710 8194 +1710 6421 +1710 7281 +1710 4520 +1710 6320 +1710 9145 +1710 1978 +1710 1857 +1710 8160 +1710 5833 +1710 3028 +1710 6101 +1710 4064 +1710 8044 +1710 7154 +1711 5122 +1711 9083 +1711 5956 +1711 2413 +1711 3501 +1711 8914 +1711 6585 +1711 2458 +1711 6203 +1711 5789 +1711 8926 +1711 8781 +1712 5772 +1712 3851 +1712 7846 +1712 3048 +1712 2188 +1712 2187 +1712 6988 +1712 5454 +1712 3471 +1712 3122 +1712 2358 +1712 8026 +1712 3836 +1712 2335 +1713 9857 +1713 9859 +1713 6928 +1713 3989 +1713 4914 +1713 6459 +1713 6716 +1713 5054 +1713 5058 +1713 8772 +1713 6214 +1713 4052 +1713 5334 +1713 6875 +1713 8168 +1713 2027 +1713 3055 +1713 9586 +1713 7415 +1713 7805 +1713 8958 +1714 2560 +1714 8802 +1714 9637 +1714 3687 +1714 8234 +1714 5515 +1714 6959 +1714 2384 +1714 4274 +1714 6835 +1714 2558 +1714 7874 +1714 6170 +1714 5086 +1714 9733 +1715 8524 +1715 7308 +1715 1966 +1715 4573 +1715 4368 +1715 8920 +1715 1878 +1715 3625 +1715 6154 +1715 3352 +1715 3903 +1716 5090 +1716 8802 +1716 5636 +1716 8615 +1716 4875 +1716 8188 +1716 2347 +1716 6284 +1716 5154 +1716 5102 +1716 2415 +1716 3794 +1716 2003 +1716 6136 +1716 9561 +1716 1793 +1716 3914 +1716 5214 +1717 2309 +1717 4742 +1717 8212 +1717 7319 +1717 2332 +1717 2338 +1717 6563 +1717 2087 +1717 9145 +1717 3267 +1717 7492 +1717 1734 +1717 7500 +1717 4566 +1717 6369 +1717 4205 +1717 8054 +1718 6663 +1718 9738 +1718 2701 +1718 4511 +1718 3492 +1718 8614 +1718 9512 +1718 9735 +1718 7476 +1718 8265 +1718 6605 +1718 5842 +1718 5076 +1718 5337 +1718 9845 +1718 8191 +1718 6398 +1718 4223 +1719 2913 +1719 7138 +1719 9507 +1719 3749 +1719 4742 +1719 3745 +1719 4892 +1719 3659 +1719 2956 +1719 4354 +1719 2414 +1719 2530 +1719 6964 +1719 8789 +1719 6737 +1719 7708 +1720 9132 +1720 8331 +1720 4695 +1720 4215 +1720 8301 +1720 6001 +1720 2867 +1720 7572 +1720 5879 +1720 7769 +1720 1854 +1720 2463 +1721 1921 +1721 3970 +1721 6115 +1721 5609 +1721 3018 +1721 9196 +1721 4206 +1721 3593 +1721 5787 +1721 8652 +1722 9601 +1722 8710 +1722 6414 +1722 7568 +1722 3473 +1722 6062 +1722 5017 +1722 5531 +1722 7708 +1722 3103 +1722 2208 +1722 8364 +1722 9134 +1722 9273 +1722 7229 +1722 9920 +1722 4942 +1722 7506 +1722 3414 +1722 4711 +1722 1853 +1722 2032 +1722 9587 +1722 6006 +1723 3718 +1723 2173 +1723 6696 +1723 4013 +1723 3338 +1723 9262 +1723 6029 +1723 4558 +1723 8813 +1723 4042 +1723 3569 +1723 2606 +1723 7287 +1723 5500 +1723 7581 +1723 9573 +1724 8672 +1724 5991 +1724 6282 +1724 4588 +1724 2254 +1724 4751 +1724 6257 +1724 5138 +1724 8110 +1724 4511 +1725 4417 +1725 9122 +1725 6756 +1725 3015 +1725 3562 +1725 6475 +1725 3394 +1725 5358 +1725 6705 +1725 5907 +1725 9794 +1725 5141 +1725 4260 +1725 2237 +1725 9301 +1725 3967 +1726 7460 +1726 5061 +1726 2609 +1726 9768 +1726 9865 +1726 5718 +1726 8205 +1726 9423 +1726 8008 +1726 5006 +1726 5142 +1726 3489 +1726 5592 +1726 5851 +1726 9036 +1726 3934 +1727 2176 +1727 2372 +1727 4901 +1727 2568 +1727 1801 +1727 5994 +1727 4398 +1727 3955 +1727 8372 +1727 2837 +1727 6198 +1727 6745 +1727 9308 +1727 2181 +1728 3104 +1728 5216 +1728 6011 +1728 5028 +1728 5123 +1728 8449 +1728 5929 +1728 7786 +1728 8752 +1728 3987 +1728 5490 +1728 4211 +1728 5843 +1728 2425 +1728 4315 +1728 2364 +1729 4929 +1729 5347 +1729 9894 +1729 8775 +1729 3976 +1729 8551 +1729 5100 +1729 6190 +1729 2480 +1729 7124 +1729 2775 +1729 8378 +1729 2491 +1729 6138 +1730 3707 +1730 4965 +1730 6057 +1730 4460 +1730 4079 +1730 9969 +1730 8657 +1730 8792 +1730 4123 +1730 3987 +1730 9629 +1730 2462 +1731 2016 +1731 5552 +1731 7106 +1731 8907 +1731 3620 +1731 2119 +1731 2295 +1731 6238 +1731 8802 +1731 3344 +1731 6256 +1731 4158 +1731 5655 +1731 3930 +1731 3499 +1731 9726 +1731 5367 +1732 6208 +1732 7105 +1732 2772 +1732 7270 +1732 5991 +1732 9549 +1732 9262 +1732 2004 +1732 8281 +1732 3614 +1733 7815 +1733 8584 +1733 9997 +1733 4625 +1733 9239 +1733 8218 +1733 3099 +1733 5148 +1733 4003 +1733 4007 +1733 2088 +1733 7980 +1733 2637 +1733 1744 +1733 7384 +1733 5849 +1733 6618 +1733 3803 +1733 4330 +1733 8557 +1733 8689 +1733 3315 +1733 9718 +1734 3648 +1734 6715 +1734 8387 +1734 5510 +1734 8968 +1734 5289 +1734 5906 +1734 8559 +1734 6096 +1734 6513 +1734 2130 +1734 2875 +1734 9594 +1734 9307 +1734 7887 +1735 6659 +1735 2199 +1735 9356 +1735 4751 +1735 7312 +1735 9363 +1735 3479 +1735 5276 +1735 3552 +1735 8900 +1735 6217 +1735 2900 +1735 5719 +1735 6496 +1735 5860 +1735 5605 +1735 1901 +1736 6624 +1736 2278 +1736 2568 +1736 2732 +1736 8654 +1736 6152 +1736 2514 +1736 2932 +1736 2586 +1736 8478 +1737 7667 +1737 9025 +1737 6562 +1737 6691 +1737 4902 +1737 9345 +1737 3914 +1737 2605 +1737 2669 +1737 9264 +1737 7218 +1737 8210 +1737 3350 +1737 1751 +1737 2809 +1737 5626 +1737 9404 +1737 6845 +1738 2882 +1738 8931 +1738 3530 +1738 9163 +1738 8366 +1738 5807 +1738 6229 +1738 5080 +1738 5785 +1738 3643 +1738 5276 +1738 3933 +1738 7199 +1739 6659 +1739 4232 +1739 9744 +1739 3348 +1739 5359 +1739 8357 +1739 5427 +1739 3388 +1739 5190 +1739 9036 +1739 5714 +1739 3161 +1739 7389 +1739 8030 +1739 2274 +1739 7652 +1739 9451 +1739 4205 +1739 7154 +1740 4800 +1740 5771 +1740 8306 +1740 5738 +1740 8459 +1740 3213 +1740 5615 +1740 2416 +1740 9554 +1740 8691 +1740 6325 +1740 7863 +1740 9835 +1740 1754 +1740 4094 +1741 3376 +1741 5379 +1741 6852 +1741 3013 +1741 3185 +1741 6122 +1741 8908 +1741 7757 +1741 9582 +1741 2000 +1741 9619 +1741 1877 +1741 7767 +1741 3898 +1741 7291 +1741 2941 +1741 6303 +1742 9381 +1742 2662 +1742 3367 +1742 9736 +1742 7817 +1742 2954 +1742 9061 +1742 8879 +1742 8337 +1742 8184 +1742 8857 +1742 3451 +1742 4805 +1742 5866 +1742 4703 +1743 7528 +1743 8165 +1743 4294 +1743 6215 +1743 6952 +1743 2793 +1743 7402 +1743 6375 +1743 6637 +1743 4142 +1743 7250 +1743 2358 +1743 9111 +1743 8167 +1743 5564 +1743 2973 +1743 4542 +1744 5520 +1744 3787 +1744 3492 +1744 6662 +1744 8487 +1744 9212 +1744 6535 +1744 7206 +1744 8208 +1744 7986 +1744 8147 +1744 9013 +1744 6808 +1744 5370 +1744 9791 +1744 2842 +1744 9471 +1745 4488 +1745 9241 +1745 6816 +1745 3362 +1745 2467 +1745 8357 +1745 7592 +1745 8496 +1745 2482 +1745 5185 +1745 4933 +1745 9428 +1745 4950 +1745 9184 +1745 2280 +1745 8177 +1745 6651 +1745 4862 +1746 4992 +1746 3228 +1746 3613 +1746 6566 +1746 6449 +1746 9412 +1746 4806 +1746 9560 +1746 2393 +1746 3162 +1746 3936 +1746 6889 +1746 4075 +1746 4719 +1746 4082 +1746 7156 +1747 7041 +1747 7300 +1747 4363 +1747 7199 +1747 8614 +1747 8492 +1747 2863 +1747 8752 +1747 9660 +1747 4291 +1747 8310 +1747 5319 +1747 9674 +1747 5974 +1747 2270 +1747 4836 +1747 8230 +1747 6254 +1747 9206 +1747 4216 +1747 7109 +1748 1796 +1748 9431 +1748 3095 +1748 7322 +1748 4699 +1748 5029 +1748 5416 +1748 5421 +1748 4912 +1748 8374 +1748 9272 +1748 3513 +1748 5184 +1748 7244 +1748 3918 +1748 8149 +1748 2135 +1748 5211 +1748 8289 +1748 7267 +1748 2422 +1748 8059 +1749 6025 +1749 7186 +1749 7572 +1749 1824 +1749 3373 +1749 6065 +1749 6325 +1749 7863 +1749 8635 +1749 3658 +1749 6348 +1749 4943 +1749 7633 +1749 3797 +1749 5495 +1749 4349 +1749 1919 +1750 3520 +1750 2593 +1750 6723 +1750 1957 +1750 5958 +1750 7053 +1750 9358 +1750 2703 +1750 5136 +1750 2283 +1750 4377 +1750 6201 +1750 7567 +1750 9052 +1750 8463 +1751 7936 +1751 9441 +1751 2179 +1751 2438 +1751 4168 +1751 8490 +1751 6320 +1751 6289 +1751 2976 +1751 7280 +1751 2519 +1751 9786 +1751 3930 +1751 7103 +1751 6748 +1751 5823 +1751 7582 +1751 4415 +1752 4863 +1752 8740 +1752 4005 +1752 5259 +1752 1968 +1752 5778 +1752 8665 +1752 6008 +1752 1988 +1752 4795 +1752 9605 +1753 6144 +1753 6402 +1753 3975 +1753 8336 +1753 7325 +1753 6440 +1753 7608 +1753 6971 +1753 3648 +1753 2628 +1753 6085 +1753 5601 +1753 6987 +1753 8919 +1753 9050 +1753 6491 +1753 7009 +1753 9698 +1753 4008 +1753 4466 +1753 7798 +1754 7520 +1754 2128 +1754 4356 +1754 4228 +1754 9734 +1754 4551 +1754 6793 +1754 8299 +1754 2382 +1754 3792 +1754 1778 +1754 3796 +1754 9302 +1754 2875 +1754 2622 +1755 8210 +1755 7907 +1755 2023 +1755 7593 +1755 3915 +1755 6188 +1755 5870 +1755 2226 +1755 5267 +1755 5396 +1755 5630 +1755 9910 +1755 3703 +1755 7898 +1755 2461 +1755 6814 +1755 2367 +1756 5507 +1756 4871 +1756 4490 +1756 4756 +1756 7336 +1756 7090 +1756 6198 +1756 9035 +1756 7503 +1756 6864 +1756 2772 +1756 6232 +1756 8797 +1756 9054 +1756 6629 +1756 9577 +1756 7533 +1756 2686 +1756 4457 +1756 4094 +1757 2051 +1757 8999 +1757 4012 +1757 2883 +1757 3543 +1757 4793 +1758 9027 +1758 6989 +1758 3752 +1758 3447 +1758 2642 +1758 2802 +1758 6477 +1758 4950 +1758 4886 +1758 3671 +1758 2236 +1758 9405 +1758 8082 +1758 3477 +1759 4128 +1759 3842 +1759 3523 +1759 2225 +1759 3022 +1759 6474 +1759 9067 +1759 4748 +1759 8111 +1759 6920 +1759 3694 +1759 4472 +1759 5050 +1759 8188 +1759 3677 +1759 2334 +1760 8960 +1760 6208 +1760 6114 +1760 9603 +1760 1828 +1760 6373 +1760 2856 +1760 5130 +1760 5885 +1760 4945 +1760 8195 +1760 4707 +1760 8278 +1760 9209 +1760 8666 +1760 9595 +1760 3813 +1761 9349 +1761 4971 +1761 4997 +1761 3558 +1761 7336 +1761 2409 +1761 3557 +1761 4973 +1761 4014 +1761 3250 +1761 9139 +1761 6030 +1761 6391 +1761 7608 +1761 4282 +1761 7292 +1761 7676 +1761 9374 +1761 6271 +1762 3489 +1762 2466 +1762 9892 +1762 4069 +1762 6758 +1762 2407 +1762 7817 +1762 4650 +1762 3495 +1762 2319 +1762 4609 +1762 6101 +1762 5593 +1762 4881 +1763 2177 +1763 3875 +1763 3461 +1763 5948 +1763 4636 +1763 8811 +1763 8429 +1763 7921 +1763 6354 +1763 9014 +1763 7497 +1763 5528 +1763 4452 +1763 9724 +1763 5470 +1763 1951 +1764 3976 +1764 8759 +1764 9765 +1764 4780 +1764 7088 +1764 2485 +1764 6454 +1764 5687 +1764 8013 +1764 5207 +1764 8537 +1764 7655 +1764 5488 +1764 6769 +1764 7795 +1764 6005 +1764 6779 +1764 3454 +1765 9601 +1765 1799 +1765 8728 +1765 7323 +1765 2719 +1765 8488 +1765 2091 +1765 2994 +1765 3893 +1765 8735 +1765 7751 +1765 9682 +1765 6614 +1765 9319 +1765 6505 +1765 5484 +1765 6896 +1765 8689 +1765 3322 +1766 4878 +1766 1809 +1766 6044 +1766 2850 +1766 3758 +1766 7222 +1766 5048 +1766 4799 +1766 5061 +1766 1870 +1766 6737 +1766 5722 +1766 2779 +1766 4061 +1766 9950 +1766 6929 +1766 2669 +1766 3317 +1766 9078 +1766 1789 +1767 4579 +1767 9956 +1767 9829 +1767 3527 +1767 2344 +1767 7626 +1767 5165 +1767 8592 +1767 3825 +1767 9202 +1767 2995 +1767 8873 +1767 6875 +1768 5079 +1768 7651 +1768 6163 +1768 9958 +1768 6865 +1768 3200 +1768 7147 +1768 7501 +1768 6638 +1768 7371 +1768 9680 +1768 2033 +1768 2155 +1768 5494 +1768 7447 +1768 7033 +1768 6512 +1768 2384 +1769 8864 +1769 2644 +1769 1866 +1769 6637 +1769 8784 +1769 2930 +1769 8979 +1769 8340 +1769 6873 +1769 5658 +1769 9535 +1769 8511 +1770 8325 +1770 9478 +1770 9611 +1770 5391 +1770 6803 +1770 5654 +1770 3866 +1770 7581 +1770 2336 +1770 2344 +1770 5418 +1770 5806 +1770 4784 +1770 6194 +1770 5820 +1770 2493 +1770 8766 +1770 7285 +1770 4575 +1770 3686 +1770 7145 +1770 4205 +1770 7534 +1770 8949 +1770 8315 +1771 2507 +1771 7940 +1771 8870 +1771 8619 +1771 6768 +1771 4025 +1771 3667 +1771 6803 +1771 2036 +1771 2905 +1771 5208 +1771 3067 +1771 4221 +1772 6848 +1772 4545 +1772 5956 +1772 7161 +1772 8103 +1772 8553 +1772 2297 +1772 7377 +1772 2931 +1772 8724 +1772 8629 +1772 2487 +1772 5076 +1772 4507 +1772 3036 +1772 3806 +1773 9376 +1773 7616 +1773 2660 +1773 5894 +1773 5447 +1773 7434 +1773 5303 +1773 8877 +1773 3886 +1773 8765 +1773 7409 +1773 5367 +1773 7108 +1773 3802 +1773 8987 +1773 2877 +1773 4734 +1774 2195 +1774 9189 +1774 6193 +1774 2891 +1774 4877 +1774 4717 +1774 2776 +1774 7986 +1774 7987 +1774 9492 +1774 9013 +1774 8005 +1774 6488 +1774 7353 +1774 8991 +1775 1995 +1775 7461 +1775 7046 +1775 4031 +1775 2122 +1775 9611 +1775 7466 +1775 4333 +1775 6670 +1775 3773 +1775 8377 +1775 2682 +1775 2719 +1775 7037 +1775 3550 +1775 9759 +1776 2371 +1776 7364 +1776 4550 +1776 4998 +1776 5809 +1776 9608 +1776 2620 +1776 7210 +1776 6866 +1776 1961 +1776 2918 +1776 7843 +1776 8249 +1776 9384 +1776 6140 +1776 4949 +1777 8578 +1777 5252 +1777 9615 +1777 6935 +1777 2784 +1777 8099 +1777 6181 +1777 7334 +1777 5165 +1777 7478 +1777 2235 +1777 4028 +1777 9824 +1777 8502 +1777 3527 +1777 2126 +1777 5080 +1777 2524 +1777 4573 +1777 9440 +1777 6822 +1777 9346 +1777 2535 +1777 4462 +1777 5373 +1778 4963 +1778 9540 +1778 6406 +1778 9947 +1778 6089 +1778 8747 +1778 8204 +1778 9224 +1778 8596 +1778 2677 +1778 3419 +1778 4571 +1778 8218 +1778 6613 +1779 5025 +1779 3298 +1779 8003 +1779 5060 +1779 6648 +1779 9382 +1779 3623 +1779 5032 +1779 7753 +1779 5279 +1779 6636 +1779 4911 +1779 8152 +1779 4147 +1779 6356 +1779 9985 +1779 3160 +1779 7035 +1779 3068 +1779 5118 +1779 3775 +1780 2336 +1780 3171 +1780 3766 +1780 9489 +1780 4732 +1780 4811 +1780 2764 +1780 9005 +1780 7565 +1780 6352 +1780 2563 +1780 3564 +1780 9484 +1780 5178 +1780 7036 +1780 3866 +1780 8114 +1781 7872 +1781 3659 +1781 8070 +1781 5035 +1781 4428 +1781 5777 +1781 4259 +1781 2228 +1781 3606 +1781 7706 +1782 7776 +1782 5731 +1782 7949 +1782 6341 +1782 5260 +1782 9930 +1782 4588 +1782 7765 +1782 8783 +1782 4208 +1782 2545 +1782 4562 +1782 4692 +1782 4252 +1782 4382 +1782 8639 +1783 4866 +1783 8077 +1783 4397 +1783 1937 +1783 3355 +1783 4263 +1783 7149 +1783 4909 +1783 7752 +1783 2238 +1783 3905 +1783 6853 +1783 8776 +1783 8460 +1783 1933 +1783 2896 +1783 7507 +1783 9444 +1783 5471 +1783 8931 +1783 4708 +1783 9361 +1783 9325 +1783 4974 +1783 9043 +1784 7328 +1784 5954 +1784 2662 +1784 8966 +1784 8264 +1784 3595 +1784 4561 +1784 6451 +1784 9947 +1785 3842 +1785 2322 +1785 2587 +1785 2332 +1785 6556 +1785 2477 +1785 9008 +1785 2866 +1785 5171 +1785 2758 +1785 4304 +1785 9299 +1785 3673 +1785 3932 +1785 8039 +1785 2151 +1785 6643 +1785 4983 +1785 5369 +1786 7171 +1786 6276 +1786 3094 +1786 8973 +1786 7568 +1786 4374 +1786 2713 +1786 9627 +1786 5663 +1786 5794 +1786 7716 +1786 5286 +1786 4135 +1786 3501 +1786 8370 +1786 8764 +1786 6090 +1786 8522 +1786 4823 +1786 7921 +1786 2933 +1786 4986 +1787 5000 +1787 4237 +1787 2322 +1787 4125 +1787 9246 +1787 7072 +1787 4270 +1787 8497 +1787 8754 +1787 6073 +1787 8512 +1787 9412 +1787 2640 +1787 9302 +1787 8538 +1787 5724 +1787 9313 +1787 7400 +1787 2578 +1787 2462 +1787 7673 +1788 2565 +1788 4618 +1788 2818 +1788 2704 +1788 1937 +1788 7065 +1788 3738 +1788 2587 +1788 5029 +1788 6057 +1788 9134 +1788 7088 +1788 3124 +1788 4149 +1788 9271 +1788 7355 +1788 5180 +1788 7306 +1788 8257 +1788 6347 +1788 7126 +1788 2777 +1788 8167 +1788 3180 +1788 2040 +1788 9722 +1789 7040 +1789 8461 +1789 6556 +1789 7714 +1789 4262 +1789 4395 +1789 8760 +1789 3514 +1789 3778 +1789 2890 +1789 1868 +1789 6608 +1789 8408 +1789 4448 +1789 3815 +1789 2670 +1789 9588 +1789 9212 +1789 2815 +1790 2433 +1790 9349 +1790 7948 +1790 3597 +1790 6681 +1790 3824 +1790 3013 +1790 8778 +1790 2136 +1790 3550 +1790 3945 +1790 9711 +1790 6512 +1790 6518 +1790 5246 +1790 3967 +1791 7298 +1791 4196 +1791 9289 +1791 6570 +1791 4909 +1791 2766 +1791 4657 +1791 5362 +1791 5492 +1791 3574 +1791 4068 +1791 3126 +1791 9724 +1792 3552 +1792 8614 +1792 9991 +1792 7496 +1792 4493 +1792 2478 +1792 2960 +1792 8787 +1792 4660 +1792 5686 +1792 7987 +1792 7610 +1792 2362 +1792 7613 +1793 8704 +1793 5122 +1793 5755 +1793 9802 +1793 2877 +1793 9385 +1793 4973 +1793 8221 +1793 8593 +1793 9481 +1793 2264 +1793 9273 +1793 8559 +1793 2524 +1794 1954 +1794 9731 +1794 9014 +1794 3270 +1794 4007 +1794 9032 +1794 2793 +1794 4842 +1794 9459 +1794 8086 +1794 4333 +1794 6191 +1794 2672 +1794 3698 +1794 8307 +1794 2886 +1794 4214 +1794 1833 +1794 8059 +1795 6625 +1795 7238 +1795 6886 +1795 1896 +1795 9803 +1795 3636 +1795 9238 +1795 5017 +1795 5306 +1795 5662 +1796 7553 +1796 5764 +1796 1900 +1796 9732 +1796 3232 +1796 4464 +1796 3244 +1796 5298 +1796 6203 +1796 1930 +1796 8638 +1796 6207 +1796 2630 +1796 7329 +1796 7635 +1796 6999 +1796 7399 +1796 5612 +1796 2669 +1796 3952 +1796 5369 +1797 6939 +1797 9318 +1797 8233 +1797 8076 +1797 9235 +1797 2143 +1797 2527 +1797 9336 +1797 2715 +1797 8158 +1797 9247 +1798 4194 +1798 6950 +1798 3427 +1798 7465 +1798 4791 +1798 9622 +1798 8335 +1798 9727 +1798 4918 +1798 8638 +1798 5718 +1798 6121 +1798 8137 +1798 7769 +1798 5629 +1799 7943 +1799 8075 +1799 5531 +1799 9123 +1799 6984 +1799 8630 +1799 7608 +1799 5177 +1799 4288 +1799 8264 +1799 8527 +1799 3670 +1799 8155 +1799 5856 +1799 7399 +1799 2665 +1799 5612 +1799 9203 +1799 5369 +1799 2429 +1800 7831 +1800 2316 +1800 2964 +1800 6807 +1800 6168 +1800 6684 +1800 5920 +1800 6691 +1800 9642 +1800 4524 +1800 9133 +1800 4142 +1800 6836 +1800 7872 +1800 4676 +1800 5458 +1800 8026 +1800 7137 +1800 2914 +1800 7908 +1800 2414 +1800 9199 +1800 5107 +1801 6827 +1801 9412 +1801 9734 +1801 4583 +1801 8808 +1801 7817 +1801 8234 +1801 5132 +1801 9582 +1801 5071 +1801 7696 +1801 2872 +1801 7038 +1802 3376 +1802 5794 +1802 7137 +1802 8967 +1802 8680 +1802 4586 +1802 2157 +1802 6832 +1802 2421 +1802 9398 +1802 7867 +1802 7804 +1803 6179 +1803 4324 +1803 4656 +1803 4210 +1803 7587 +1803 4532 +1803 5525 +1803 5254 +1803 4671 +1804 5379 +1804 8292 +1804 4645 +1804 4648 +1804 3689 +1804 1948 +1804 9100 +1804 5870 +1804 5168 +1804 9745 +1804 5699 +1804 1943 +1804 1944 +1804 4005 +1804 9852 +1804 7422 +1804 9214 +1804 7135 +1805 6533 +1805 9991 +1805 5001 +1805 7821 +1805 4881 +1805 1941 +1805 7702 +1805 4769 +1805 6063 +1805 5561 +1805 8636 +1805 4672 +1805 4047 +1805 9043 +1805 8276 +1805 4302 +1805 5209 +1805 9564 +1805 9319 +1805 4970 +1805 5113 +1805 3197 +1805 5717 +1806 4746 +1806 2192 +1806 2193 +1806 5401 +1806 5279 +1806 1824 +1806 5595 +1806 2356 +1806 2492 +1806 8510 +1806 5567 +1806 6982 +1806 9416 +1806 9570 +1806 6875 +1806 4072 +1806 9330 +1806 6772 +1806 7486 +1806 6396 +1806 7165 +1807 9760 +1807 7515 +1807 6372 +1807 6373 +1807 4358 +1807 2663 +1807 2440 +1807 4471 +1807 2829 +1807 6094 +1807 7344 +1807 3570 +1807 8722 +1807 4791 +1807 6335 +1807 7964 +1807 2333 +1807 1982 +1807 7813 +1808 2272 +1808 4257 +1808 9794 +1808 7715 +1808 7429 +1808 4901 +1808 6118 +1808 8170 +1808 3883 +1808 8565 +1808 2551 +1808 8702 +1808 4767 +1809 6060 +1809 3340 +1809 3981 +1809 6563 +1809 8745 +1809 4524 +1809 5298 +1809 5048 +1809 4167 +1809 4937 +1809 4554 +1809 2382 +1809 3107 +1809 2907 +1809 7268 +1809 3444 +1809 6134 +1809 3582 +1810 8993 +1810 4420 +1810 9350 +1810 4678 +1810 5543 +1810 6664 +1810 9343 +1810 3070 +1810 4344 +1810 9695 +1810 4312 +1810 8093 +1810 8472 +1810 8351 +1811 7936 +1811 4843 +1811 6027 +1811 5268 +1811 2863 +1811 5038 +1811 6959 +1811 5939 +1811 5841 +1811 2525 +1811 2526 +1811 8416 +1811 7121 +1811 5867 +1811 4720 +1811 3582 +1811 3071 +1812 7072 +1812 7714 +1812 8227 +1812 8471 +1812 9992 +1812 9545 +1812 2327 +1812 5102 +1812 2224 +1812 8040 +1812 8643 +1812 2267 +1812 7848 +1812 1854 +1812 8479 +1813 6241 +1813 2539 +1813 4037 +1813 3175 +1813 4826 +1813 8668 +1813 6970 +1813 2098 +1813 4686 +1813 6365 +1813 8626 +1813 7411 +1813 5517 +1813 5082 +1813 7644 +1813 6730 +1813 7710 +1814 2051 +1814 7366 +1814 2469 +1814 9482 +1814 4463 +1814 2834 +1814 5780 +1814 7477 +1814 8564 +1814 2363 +1814 7549 +1814 6143 +1815 8096 +1815 7707 +1815 3524 +1815 9541 +1815 8647 +1815 2151 +1815 5287 +1815 7473 +1815 3919 +1815 9329 +1815 4150 +1815 6840 +1815 5209 +1815 7547 +1815 8124 +1815 2623 +1816 8592 +1816 4250 +1816 3234 +1816 1963 +1816 5046 +1816 9530 +1816 3900 +1816 3518 +1816 8640 +1816 4931 +1816 7252 +1816 9557 +1816 4154 +1816 5354 +1816 5996 +1816 5873 +1816 4338 +1816 7283 +1816 5240 +1816 7417 +1817 5345 +1817 2569 +1817 8017 +1817 9576 +1817 6289 +1817 7727 +1817 6576 +1817 8273 +1817 4719 +1817 3860 +1817 2549 +1817 7319 +1817 2297 +1817 8986 +1817 4431 +1817 6174 +1817 2165 +1818 4097 +1818 3907 +1818 3332 +1818 8805 +1818 5778 +1818 9106 +1818 7380 +1818 6686 +1818 6974 +1818 5815 +1818 3807 +1818 2939 +1818 5501 +1818 8798 +1818 9663 +1819 2786 +1819 8483 +1819 8517 +1819 6630 +1819 8071 +1819 3913 +1819 7889 +1819 4053 +1819 8376 +1819 8858 +1819 2043 +1819 3900 +1819 9853 +1820 4879 +1820 4882 +1820 5656 +1820 3485 +1820 6817 +1820 5797 +1820 9775 +1820 6576 +1820 3775 +1820 7874 +1820 8647 +1820 5837 +1820 2644 +1820 3416 +1820 9565 +1820 3560 +1820 5481 +1820 7672 +1820 4180 +1820 7674 +1821 6657 +1821 3460 +1821 7687 +1821 4873 +1821 9226 +1821 7181 +1821 6535 +1821 7342 +1821 6447 +1821 2998 +1821 5570 +1821 8649 +1821 3293 +1821 5089 +1821 9059 +1821 8420 +1821 6768 +1821 5620 +1821 3192 +1821 7551 +1822 5888 +1822 2018 +1822 8251 +1822 4101 +1822 3214 +1822 7698 +1822 4654 +1822 6416 +1822 4430 +1822 9653 +1822 4438 +1822 9401 +1822 5593 +1822 2138 +1822 6875 +1822 8050 +1822 1886 +1822 8735 +1823 7942 +1823 2059 +1823 9231 +1823 6289 +1823 3098 +1823 3487 +1823 3498 +1823 2101 +1823 3000 +1823 3776 +1823 4442 +1823 5600 +1823 9569 +1823 4706 +1823 6373 +1823 1896 +1823 8821 +1823 6135 +1824 2691 +1824 8444 +1824 5485 +1824 3025 +1824 5012 +1824 7502 +1824 3414 +1824 3704 +1824 3676 +1824 5246 +1824 2591 +1825 5505 +1825 5765 +1825 6029 +1825 2962 +1825 3611 +1825 4165 +1825 7080 +1825 6954 +1825 4914 +1825 1847 +1825 3387 +1825 9526 +1825 8905 +1825 9677 +1825 1999 +1825 4049 +1825 6614 +1825 2391 +1825 6885 +1825 9703 +1825 7788 +1825 5103 +1825 2814 +1825 3967 +1826 5029 +1826 3464 +1826 2473 +1826 4206 +1826 8541 +1826 5777 +1826 3444 +1826 5678 +1826 3673 +1826 9818 +1826 5173 +1826 5759 +1827 5510 +1827 2060 +1827 4241 +1827 6035 +1827 5272 +1827 2073 +1827 3099 +1827 4764 +1827 4780 +1827 4674 +1827 4164 +1827 2193 +1827 7123 +1827 9561 +1827 2524 +1827 2143 +1827 5473 +1827 2661 +1827 6375 +1827 7149 +1827 5230 +1827 4596 +1827 8700 +1827 6783 +1828 5136 +1828 2306 +1828 6851 +1828 2820 +1828 9093 +1828 9863 +1828 5036 +1828 2413 +1828 7694 +1828 3533 +1828 2930 +1828 3189 +1828 3545 +1828 6297 +1828 2660 +1828 2138 +1828 2162 +1829 2432 +1829 3851 +1829 5391 +1829 2077 +1829 8991 +1829 2347 +1829 3374 +1829 9521 +1829 5813 +1829 9018 +1829 4027 +1829 9141 +1829 2255 +1829 7760 +1829 8273 +1829 6740 +1829 8150 +1829 8911 +1829 3940 +1829 6245 +1829 5876 +1829 3062 +1829 7543 +1829 6522 +1829 9341 +1830 7872 +1830 1836 +1830 6025 +1830 4044 +1830 6765 +1830 6895 +1830 5970 +1830 7223 +1830 8056 +1830 9625 +1830 3996 +1830 7262 +1831 5504 +1831 4929 +1831 4923 +1831 6565 +1831 6753 +1831 4252 +1831 8490 +1831 7595 +1831 6124 +1831 2610 +1831 7067 +1831 2256 +1831 8273 +1831 5490 +1831 2740 +1831 4150 +1831 2348 +1831 2520 +1831 6975 +1831 9404 +1831 8319 +1832 7457 +1832 4436 +1832 7884 +1832 4007 +1832 5916 +1832 3540 +1832 4973 +1832 1965 +1832 4496 +1832 6227 +1832 6964 +1832 3860 +1832 3321 +1832 6936 +1832 6356 +1832 3611 +1832 8668 +1832 7198 +1833 7886 +1833 7109 +1833 2247 +1833 7593 +1833 5962 +1833 2610 +1833 4017 +1833 4208 +1833 9074 +1833 6722 +1833 2654 +1833 1943 +1833 2936 +1833 9471 +1833 4010 +1833 2430 +1833 6677 +1834 5664 +1834 8066 +1834 4095 +1834 2853 +1834 7911 +1834 9677 +1834 8401 +1834 8307 +1834 3795 +1834 1944 +1834 7801 +1834 8732 +1834 9245 +1834 7807 +1835 4256 +1835 9259 +1835 3908 +1835 5642 +1835 3659 +1835 8626 +1835 5678 +1835 7503 +1835 8469 +1835 8823 +1835 3578 +1835 2423 +1835 7646 +1835 4415 +1836 6050 +1836 2308 +1836 8776 +1836 4234 +1836 4781 +1836 4207 +1836 8968 +1836 4495 +1836 9461 +1836 4791 +1836 9396 +1836 6522 +1836 9659 +1836 2461 +1837 8386 +1837 7291 +1837 5007 +1837 2470 +1837 2823 +1837 5897 +1837 5005 +1837 6447 +1837 6706 +1837 4052 +1837 6836 +1837 7759 +1837 7099 +1838 3488 +1838 7007 +1838 8379 +1838 2309 +1838 2538 +1838 6316 +1838 3950 +1838 2703 +1838 9041 +1838 7508 +1838 4600 +1838 7705 +1838 5851 +1838 2879 +1839 5341 +1839 5579 +1839 8523 +1839 7980 +1839 2605 +1839 4335 +1839 2896 +1839 7761 +1839 4306 +1839 2007 +1839 8729 +1839 9949 +1839 4255 +1840 5728 +1840 4549 +1840 3965 +1840 3368 +1840 5836 +1840 4621 +1840 7854 +1840 5489 +1840 5204 +1840 9175 +1840 7768 +1840 7375 +1840 2248 +1840 4125 +1841 4066 +1841 7044 +1841 4165 +1841 9009 +1841 3913 +1841 8779 +1841 7876 +1841 3405 +1841 4783 +1841 2404 +1841 9937 +1841 2930 +1841 1843 +1841 9076 +1841 2261 +1841 3416 +1841 3908 +1841 9627 +1841 6815 +1842 8161 +1842 9922 +1842 8435 +1842 7336 +1842 8971 +1842 2765 +1842 6267 +1842 8345 +1842 9147 +1842 8542 +1843 8240 +1843 3643 +1843 4965 +1843 5478 +1843 3921 +1843 7753 +1843 3306 +1843 3696 +1843 5458 +1843 7865 +1843 6811 +1843 2780 +1843 8126 +1844 8769 +1844 1922 +1844 6054 +1844 5607 +1844 6216 +1844 5687 +1844 2250 +1844 4119 +1844 3980 +1844 9229 +1844 6643 +1844 1971 +1844 3156 +1844 3349 +1844 3959 +1844 4764 +1844 2015 +1845 3091 +1845 5634 +1845 8740 +1845 8982 +1845 4102 +1845 8819 +1845 5547 +1845 2641 +1845 3763 +1845 4313 +1845 5214 +1846 9345 +1846 5634 +1846 1926 +1846 4262 +1846 4929 +1846 9270 +1846 8045 +1846 8592 +1846 2929 +1846 5330 +1846 2547 +1846 6678 +1846 8570 +1846 9711 +1846 2909 +1847 3585 +1847 5890 +1847 3096 +1847 7578 +1847 6300 +1847 6563 +1847 7599 +1847 7093 +1847 2746 +1847 6460 +1847 2494 +1847 4287 +1847 2368 +1847 7890 +1847 2008 +1847 3942 +1847 6866 +1847 4215 +1848 9120 +1848 2979 +1848 7087 +1848 8390 +1848 5340 +1848 7018 +1848 5930 +1848 5580 +1848 8655 +1848 9301 +1848 3734 +1848 6121 +1848 3129 +1848 9851 +1848 7740 +1848 6282 +1848 7379 +1849 7557 +1849 9105 +1849 5010 +1849 2339 +1849 7334 +1849 5294 +1849 4657 +1849 8759 +1849 3897 +1849 8899 +1849 9034 +1849 2382 +1849 7759 +1849 2259 +1849 5340 +1849 8173 +1849 3220 +1850 2688 +1850 9055 +1850 5355 +1850 6916 +1850 8374 +1850 7431 +1850 6951 +1850 8254 +1850 3478 +1850 9017 +1850 7775 +1850 3739 +1850 6010 +1850 5246 +1850 6239 +1851 5269 +1851 8417 +1851 9347 +1851 7077 +1851 4533 +1851 2507 +1851 3637 +1851 6574 +1851 3695 +1851 9040 +1851 4323 +1851 5364 +1851 9205 +1851 4695 +1851 6297 +1851 9045 +1851 7605 +1852 9120 +1852 3969 +1852 4471 +1852 3982 +1852 3628 +1852 5098 +1852 5739 +1852 7244 +1852 7149 +1852 8206 +1852 9725 +1852 2028 +1852 7863 +1852 2137 +1852 4090 +1852 5469 +1852 6910 +1853 5889 +1853 2716 +1853 3791 +1853 9447 +1853 6153 +1853 5391 +1853 3057 +1853 6674 +1853 3347 +1853 3030 +1853 4443 +1853 8604 +1853 7134 +1854 8705 +1854 3079 +1854 8344 +1854 4280 +1854 4655 +1854 9526 +1854 6967 +1854 6200 +1854 8899 +1854 8646 +1854 8272 +1854 3935 +1854 5862 +1854 4330 +1854 7790 +1854 9330 +1854 6390 +1854 7673 +1854 9850 +1854 3452 +1855 2080 +1855 5602 +1855 3395 +1855 5924 +1855 2245 +1855 9323 +1855 8733 +1855 5904 +1855 5367 +1855 2852 +1855 2170 +1855 9243 +1855 4573 +1855 3582 +1855 2303 +1856 5507 +1856 3216 +1856 9236 +1856 4507 +1856 8478 +1856 5407 +1856 2478 +1856 6078 +1856 4802 +1856 5841 +1856 2401 +1856 5860 +1856 7909 +1856 4847 +1856 7921 +1856 3881 +1856 7549 +1857 9841 +1857 2599 +1857 4743 +1857 3059 +1857 5141 +1857 5663 +1857 6393 +1857 7867 +1857 3580 +1857 3121 +1857 3359 +1858 7874 +1858 3043 +1858 5062 +1858 4327 +1858 4937 +1858 5354 +1858 6283 +1858 3389 +1858 6705 +1858 4818 +1858 3145 +1858 5850 +1858 3994 +1858 5246 +1859 4993 +1859 5602 +1859 2883 +1859 8278 +1859 2551 +1859 6119 +1859 3944 +1859 2857 +1859 1881 +1859 3792 +1859 4305 +1859 8467 +1859 5494 +1859 7929 +1859 9753 +1859 7097 +1860 2016 +1860 5826 +1860 7939 +1860 4744 +1860 2026 +1860 5099 +1860 5996 +1860 7017 +1860 7733 +1860 8663 +1860 6808 +1860 3098 +1860 2522 +1860 6613 +1861 3651 +1861 7080 +1861 5193 +1861 7703 +1861 3735 +1861 1874 +1861 5405 +1861 7730 +1861 4820 +1861 4630 +1861 7319 +1861 4282 +1861 6479 +1861 9916 +1861 3450 +1862 8578 +1862 7047 +1862 6794 +1862 6305 +1862 6957 +1862 7608 +1862 4542 +1862 1953 +1862 8145 +1862 5714 +1862 9813 +1862 2280 +1862 4073 +1862 9964 +1862 5234 +1862 5054 +1862 9725 +1863 5829 +1863 9867 +1863 8399 +1863 8689 +1864 7819 +1864 3472 +1864 7058 +1864 7065 +1864 9499 +1864 9889 +1864 8125 +1864 6599 +1864 8914 +1864 5848 +1864 8412 +1864 3295 +1864 6240 +1864 3682 +1864 5475 +1864 4196 +1864 7015 +1864 9965 +1864 8567 +1864 7423 +1865 6150 +1865 9873 +1865 7839 +1865 2593 +1865 3854 +1865 9641 +1865 4523 +1865 7731 +1865 9781 +1865 8384 +1865 8135 +1865 2891 +1865 8974 +1865 5602 +1865 8556 +1865 2803 +1865 6654 +1865 8953 +1865 4222 +1866 5509 +1866 8845 +1866 7703 +1866 8472 +1866 1947 +1866 5669 +1866 9766 +1866 7079 +1866 7849 +1866 8880 +1866 7736 +1866 5452 +1866 9808 +1866 8281 +1866 7519 +1866 3682 +1866 4709 +1866 8553 +1866 3312 +1866 3454 +1867 7972 +1867 8745 +1867 4522 +1867 9148 +1867 8077 +1867 2357 +1867 8121 +1867 1881 +1867 7767 +1867 2654 +1867 6453 +1868 1926 +1868 6412 +1868 8334 +1868 2585 +1868 4761 +1868 5919 +1868 7714 +1868 9401 +1868 8762 +1868 7365 +1868 5576 +1868 6924 +1868 9802 +1868 5724 +1868 9315 +1868 2685 +1868 6899 +1868 4215 +1868 8441 +1869 8288 +1869 7847 +1869 5578 +1869 6190 +1869 8499 +1869 8725 +1869 3608 +1869 2035 +1870 3298 +1870 9060 +1870 8197 +1870 4135 +1870 3628 +1870 6666 +1870 6956 +1870 8303 +1870 4368 +1870 9971 +1870 6328 +1870 5292 +1870 8541 +1870 4293 +1871 8736 +1871 6640 +1871 6227 +1871 8413 +1871 3878 +1871 7558 +1871 6919 +1871 9416 +1871 5069 +1871 8303 +1871 4816 +1871 6993 +1871 8657 +1871 2515 +1871 6877 +1872 8324 +1872 3079 +1872 3596 +1872 7982 +1872 8144 +1872 7342 +1872 8374 +1872 7131 +1873 6023 +1873 8073 +1873 3213 +1873 3732 +1873 4138 +1873 5554 +1873 7476 +1873 4404 +1873 5053 +1873 5054 +1873 7615 +1873 8256 +1873 7496 +1873 3789 +1873 9551 +1873 7503 +1873 9823 +1873 8288 +1873 2022 +1873 9446 +1873 8295 +1873 7533 +1873 6777 +1873 3661 +1874 7172 +1874 5494 +1874 3721 +1874 6532 +1874 4933 +1874 9381 +1874 9386 +1874 5547 +1874 7867 +1874 8002 +1874 3779 +1874 9286 +1874 6091 +1874 9678 +1874 7652 +1874 6121 +1874 5101 +1874 3694 +1874 9200 +1874 5746 +1874 5492 +1874 2806 +1874 2679 +1874 4090 +1875 7587 +1875 7835 +1875 6760 +1875 4796 +1875 2972 +1875 3500 +1875 9180 +1875 7022 +1875 2031 +1875 8337 +1875 8899 +1875 9292 +1875 6459 +1875 2492 +1875 8894 +1876 8482 +1876 7556 +1876 2693 +1876 7785 +1876 4362 +1876 5879 +1876 5996 +1876 6573 +1876 7781 +1876 8208 +1876 6807 +1876 3212 +1876 3126 +1876 3081 +1876 5949 +1876 1886 +1877 3456 +1877 9217 +1877 5255 +1877 3086 +1877 9493 +1877 8601 +1877 5791 +1877 3360 +1877 3312 +1877 8098 +1877 9126 +1877 2869 +1877 2746 +1877 6773 +1877 1999 +1877 2395 +1877 3055 +1877 5616 +1877 7413 +1877 3029 +1878 9994 +1878 8627 +1878 7567 +1878 3733 +1878 9369 +1878 2456 +1878 7705 +1878 7195 +1878 9139 +1878 4894 +1878 5083 +1878 9128 +1878 3999 +1878 8380 +1878 5317 +1878 6356 +1878 5205 +1878 8411 +1878 9052 +1878 5599 +1878 9316 +1878 6175 +1878 4072 +1878 6517 +1878 7670 +1879 3202 +1879 5255 +1879 2825 +1879 3802 +1879 7200 +1879 5029 +1879 3254 +1879 5178 +1879 2620 +1879 4157 +1879 7620 +1879 5448 +1879 4175 +1879 5752 +1879 4179 +1879 3668 +1879 3029 +1879 9306 +1879 7650 +1879 7918 +1879 5233 +1879 7763 +1879 3832 +1880 5488 +1880 8227 +1880 4913 +1880 8744 +1880 2217 +1880 6250 +1880 8015 +1880 3472 +1880 8593 +1880 2826 +1880 4766 +1880 4985 +1880 5199 +1880 6826 +1880 8062 +1881 5282 +1881 2179 +1881 7941 +1881 5415 +1881 3912 +1881 9004 +1881 5955 +1881 4743 +1881 4750 +1881 8720 +1881 4755 +1881 9398 +1881 7738 +1881 2970 +1881 4954 +1881 8542 +1882 4245 +1882 6940 +1882 9893 +1882 2342 +1882 9896 +1882 2494 +1882 7615 +1882 9540 +1882 6213 +1882 9000 +1882 7891 +1882 9429 +1882 3548 +1882 7519 +1882 2784 +1882 4581 +1882 4073 +1882 1900 +1882 7976 +1882 6773 +1882 7414 +1883 2308 +1883 4183 +1883 7940 +1883 6682 +1883 3227 +1883 4124 +1883 4639 +1883 4768 +1883 3759 +1883 8756 +1883 2357 +1883 5690 +1883 2485 +1883 6583 +1883 6604 +1883 2259 +1883 9303 +1883 9947 +1883 3054 +1883 8054 +1883 9084 +1884 4808 +1884 8984 +1884 4807 +1884 9520 +1884 8392 +1884 6197 +1884 4661 +1884 3271 +1884 5704 +1884 6347 +1884 5070 +1884 1998 +1884 7133 +1884 8416 +1884 7393 +1884 7409 +1884 4341 +1884 5238 +1884 2555 +1884 8444 +1885 7778 +1885 9443 +1885 7076 +1885 2966 +1885 7462 +1885 8969 +1885 4910 +1885 8719 +1885 6446 +1885 9174 +1885 3961 +1885 1945 +1885 4891 +1885 7932 +1885 7997 +1885 7742 +1885 8383 +1886 9345 +1886 6927 +1886 9497 +1886 2970 +1886 8613 +1886 4914 +1886 5559 +1886 3896 +1886 7361 +1886 4546 +1886 2756 +1886 8010 +1886 2510 +1886 6234 +1886 7904 +1886 5862 +1886 2282 +1887 2178 +1887 4228 +1887 2966 +1887 6025 +1887 6796 +1887 5518 +1887 5139 +1887 8324 +1887 7202 +1887 7080 +1887 2866 +1887 9273 +1887 8636 +1887 2881 +1887 4292 +1887 7551 +1887 6232 +1887 1896 +1887 4075 +1887 2674 +1887 6643 +1887 9851 +1887 3967 +1888 8704 +1888 5285 +1888 8631 +1888 8459 +1888 2372 +1888 6806 +1888 9223 +1888 7307 +1888 7310 +1888 2352 +1888 4689 +1888 7254 +1888 5559 +1888 2308 +1888 6780 +1888 9898 +1889 8354 +1889 4867 +1889 3620 +1889 8454 +1889 7915 +1889 9164 +1889 5455 +1889 6769 +1889 9437 +1889 5059 +1889 6934 +1889 9368 +1889 6653 +1889 5917 +1889 5727 +1890 8323 +1890 8197 +1890 6287 +1890 6166 +1890 6950 +1890 6828 +1890 2742 +1890 3639 +1890 9022 +1890 2869 +1890 3266 +1890 9411 +1890 6966 +1890 5591 +1890 5593 +1890 3238 +1890 9322 +1890 5483 +1890 8699 +1890 2428 +1890 6781 +1890 6782 +1891 7008 +1891 7297 +1891 5602 +1891 9923 +1891 4840 +1891 7177 +1891 9900 +1891 4559 +1891 4913 +1891 5843 +1891 9908 +1891 5877 +1891 8120 +1891 5499 +1892 4485 +1892 8843 +1892 9497 +1892 3231 +1892 6892 +1892 2139 +1892 2599 +1892 5800 +1892 6197 +1892 7350 +1892 2622 +1892 5698 +1892 9032 +1892 4310 +1892 2778 +1892 5467 +1892 6750 +1892 2654 +1892 6500 +1892 4968 +1892 5996 +1892 7664 +1892 7153 +1892 7027 +1892 9725 +1893 6339 +1893 9765 +1893 9415 +1893 7464 +1893 3435 +1893 3532 +1893 7122 +1893 9646 +1893 7247 +1893 2834 +1893 5859 +1893 9460 +1893 6133 +1893 7572 +1893 9914 +1893 5627 +1893 7124 +1893 8990 +1894 3867 +1894 3370 +1894 7340 +1894 1965 +1894 8046 +1894 3129 +1894 7327 +1894 2140 +1894 3498 +1894 6101 +1895 6656 +1895 4489 +1895 5899 +1895 3855 +1895 3984 +1895 8596 +1895 7578 +1895 2972 +1895 7837 +1895 5800 +1895 8492 +1895 6958 +1895 8243 +1895 3260 +1895 3009 +1895 5058 +1895 3017 +1895 8652 +1895 4563 +1895 8276 +1895 8535 +1895 6488 +1896 5472 +1896 6529 +1896 9315 +1896 9221 +1896 2501 +1896 7505 +1896 4424 +1896 5232 +1896 3632 +1896 3290 +1896 4890 +1896 2298 +1897 6148 +1897 4488 +1897 5648 +1897 2322 +1897 3875 +1897 8614 +1897 3759 +1897 7096 +1897 5821 +1897 9534 +1897 9536 +1897 5573 +1897 3528 +1897 2837 +1897 9941 +1897 6372 +1897 4202 +1897 6769 +1897 3828 +1897 5845 +1898 5185 +1898 5858 +1898 4902 +1898 5127 +1898 5452 +1898 2061 +1898 8495 +1898 6352 +1898 2385 +1898 9455 +1898 4412 +1898 8990 +1899 7553 +1899 5254 +1899 1937 +1899 4886 +1899 3225 +1899 2716 +1899 4514 +1899 9768 +1899 2588 +1899 5168 +1899 2746 +1899 5191 +1899 5321 +1899 8913 +1899 5330 +1899 9559 +1899 7516 +1899 2407 +1899 8566 +1899 8187 +1900 3468 +1900 7186 +1900 8708 +1900 7461 +1900 6311 +1900 8236 +1900 2093 +1900 9545 +1900 5948 +1900 3647 +1900 6472 +1900 7241 +1900 3019 +1900 2770 +1900 6613 +1900 5085 +1900 5223 +1900 2028 +1900 4847 +1900 9078 +1901 5632 +1901 9488 +1901 7791 +1901 7075 +1901 3633 +1901 8246 +1901 6458 +1901 6849 +1901 5846 +1901 6112 +1901 9188 +1901 7279 +1901 5873 +1901 6774 +1901 6263 +1901 9336 +1901 8569 +1901 6523 +1902 6800 +1902 1925 +1902 7825 +1902 6056 +1902 4169 +1902 9867 +1902 5454 +1902 6000 +1902 7729 +1902 8084 +1902 3669 +1902 2490 +1902 6954 +1902 8414 +1903 3462 +1903 9303 +1903 2572 +1903 2191 +1903 5284 +1903 2235 +1903 9280 +1903 4292 +1903 8663 +1903 4772 +1903 8794 +1903 5853 +1903 6366 +1903 8812 +1903 4334 +1903 9076 +1903 5884 +1903 9725 +1904 6295 +1904 8730 +1904 5659 +1904 4766 +1904 6965 +1904 5691 +1904 3519 +1904 2499 +1904 6587 +1904 6182 +1904 3175 +1904 8040 +1904 4840 +1904 9972 +1904 9333 +1904 8568 +1905 4617 +1905 7310 +1905 5649 +1905 8096 +1905 8365 +1905 6831 +1905 3763 +1905 7484 +1905 4541 +1905 7104 +1905 5313 +1905 5314 +1905 5069 +1905 8653 +1905 3409 +1905 8412 +1905 5097 +1905 4468 +1906 2528 +1906 2944 +1906 5211 +1906 2949 +1906 8614 +1906 5119 +1906 8715 +1906 3404 +1906 2256 +1906 3123 +1906 5688 +1906 3814 +1906 3802 +1906 7003 +1906 2749 +1906 2622 +1906 6047 +1907 5760 +1907 4839 +1907 9529 +1907 2729 +1907 7596 +1907 8141 +1907 2253 +1907 2479 +1907 5873 +1907 8210 +1907 5684 +1907 8329 +1907 4281 +1907 8913 +1907 3932 +1907 3293 +1908 4483 +1908 2959 +1908 7142 +1908 3152 +1908 8170 +1908 3693 +1908 9069 +1908 2320 +1908 7112 +1908 4242 +1908 3699 +1908 4473 +1908 9563 +1908 7133 +1908 9502 +1909 7479 +1909 6020 +1909 4726 +1909 2471 +1909 7628 +1909 6922 +1909 5675 +1909 6444 +1909 9011 +1909 6798 +1909 4598 +1909 9564 +1909 2013 +1909 9567 +1910 5508 +1910 3470 +1910 6929 +1910 5907 +1910 3617 +1910 9900 +1910 7603 +1910 4417 +1910 8391 +1910 8650 +1910 5836 +1910 6479 +1910 8158 +1910 8416 +1910 8423 +1910 5993 +1910 5105 +1910 5879 +1911 2304 +1911 1919 +1911 4069 +1911 6833 +1911 7532 +1911 2215 +1911 9932 +1911 5807 +1911 9124 +1911 9041 +1911 8947 +1911 5620 +1911 9462 +1911 5753 +1911 4600 +1911 4761 +1911 5548 +1911 5980 +1911 9023 +1912 8458 +1912 7329 +1912 3803 +1912 8999 +1912 3752 +1912 9650 +1912 2112 +1912 3011 +1912 5702 +1912 7111 +1912 5578 +1912 5077 +1912 4960 +1912 5092 +1912 8936 +1912 2541 +1912 8184 +1912 3882 +1913 6927 +1913 6241 +1913 3778 +1913 5243 +1913 5798 +1913 7649 +1913 7117 +1913 9390 +1913 8642 +1913 4078 +1913 3512 +1913 6228 +1913 4090 +1913 9967 +1913 4026 +1914 2062 +1914 4242 +1914 3860 +1914 7062 +1914 9779 +1914 4790 +1914 3127 +1914 8760 +1914 3254 +1914 5190 +1914 6603 +1914 5965 +1914 6740 +1914 4961 +1914 9571 +1914 8939 +1914 2678 +1914 5882 +1915 5901 +1915 7304 +1915 1929 +1915 5164 +1915 8111 +1915 7890 +1915 9531 +1915 2877 +1916 5888 +1916 4368 +1916 8857 +1916 2372 +1916 6427 +1916 4892 +1916 7455 +1916 2338 +1916 2203 +1916 7844 +1916 4389 +1916 1961 +1916 4529 +1916 9141 +1916 2625 +1916 8260 +1916 6468 +1916 7892 +1916 3287 +1916 7010 +1917 5264 +1917 3857 +1917 3477 +1917 7703 +1917 9369 +1917 8345 +1917 3355 +1917 6172 +1917 9255 +1917 9388 +1917 5555 +1917 7997 +1917 3656 +1917 7374 +1917 3026 +1917 6488 +1917 7130 +1917 9830 +1917 6506 +1917 8305 +1917 7666 +1917 9204 +1917 9492 +1917 8442 +1917 9339 +1917 6525 +1918 6281 +1918 4118 +1918 8482 +1918 6565 +1918 8118 +1918 5432 +1918 9916 +1918 8638 +1918 5311 +1918 7233 +1918 6723 +1918 6989 +1918 4280 +1918 6995 +1918 6751 +1918 8290 +1918 4324 +1918 3437 +1918 4211 +1918 3963 +1918 7164 +1919 4256 +1919 2177 +1919 5858 +1919 7399 +1919 3118 +1919 8733 +1919 7025 +1919 2068 +1919 5614 +1919 8694 +1919 6717 +1919 5693 +1920 4261 +1920 6082 +1920 4355 +1920 5830 +1920 4839 +1920 5128 +1920 4906 +1920 5653 +1920 9068 +1920 8674 +1920 4387 +1920 7734 +1920 3642 +1920 9439 +1921 4066 +1921 7812 +1921 6534 +1921 9865 +1921 8810 +1921 3036 +1921 4110 +1921 3087 +1921 2608 +1921 9811 +1921 7891 +1921 9654 +1921 9720 +1921 7279 +1921 5500 +1921 8573 +1922 5666 +1922 9841 +1922 7080 +1922 7369 +1922 4007 +1922 2956 +1922 5361 +1922 8114 +1922 4883 +1922 5943 +1922 8474 +1922 6267 +1923 5633 +1923 4047 +1923 7274 +1923 7373 +1923 7181 +1923 2256 +1923 9584 +1923 3567 +1923 8059 +1923 4764 +1924 4867 +1924 2569 +1924 2444 +1924 8619 +1924 3483 +1924 7709 +1924 6947 +1924 2987 +1924 8386 +1924 8396 +1924 9294 +1924 6223 +1924 2646 +1924 7129 +1924 4317 +1924 4518 +1924 7410 +1924 2548 +1924 8310 +1924 8187 +1925 6786 +1925 5014 +1925 7065 +1925 4249 +1925 8858 +1925 6557 +1925 3742 +1925 4520 +1925 8625 +1925 5555 +1925 5172 +1925 5946 +1925 7099 +1925 4169 +1925 2769 +1925 8788 +1925 5719 +1925 2008 +1925 2138 +1925 3678 +1925 9700 +1925 7914 +1925 9840 +1925 6899 +1925 2388 +1925 2554 +1925 2299 +1925 4220 +1925 4970 +1926 4738 +1926 4618 +1926 9867 +1926 2715 +1926 4894 +1926 4002 +1926 5795 +1926 7081 +1926 8008 +1926 9160 +1926 4819 +1926 4820 +1926 8022 +1926 9687 +1926 7400 +1926 9578 +1926 2924 +1926 7533 +1926 3954 +1927 8450 +1927 8611 +1927 5932 +1927 8776 +1927 2876 +1927 4066 +1927 9005 +1927 6131 +1927 3285 +1927 8183 +1927 6937 +1927 2458 +1927 5468 +1927 3229 +1927 4127 +1928 3563 +1928 5253 +1928 2441 +1928 2958 +1928 5779 +1928 8983 +1928 6177 +1928 9510 +1928 3367 +1928 8492 +1928 5172 +1928 5053 +1928 5185 +1928 5025 +1928 8782 +1928 6612 +1928 5593 +1928 3559 +1928 4456 +1928 5354 +1928 3239 +1928 2365 +1928 9725 +1928 6654 +1929 4268 +1929 5652 +1929 8614 +1929 8748 +1929 6721 +1929 4034 +1929 8652 +1929 3277 +1929 2680 +1929 9043 +1929 7637 +1929 4063 +1929 5221 +1929 9575 +1929 2407 +1929 6769 +1929 7666 +1929 8696 +1929 6268 +1930 6162 +1930 2717 +1930 4640 +1930 5026 +1930 2727 +1930 9896 +1930 9900 +1930 7472 +1930 9787 +1930 3004 +1930 9171 +1930 2399 +1930 2145 +1930 2402 +1930 8807 +1930 2800 +1930 5242 +1930 4222 +1931 5248 +1931 5281 +1931 7763 +1931 2727 +1931 5127 +1931 9150 +1931 8210 +1931 3923 +1931 3636 +1931 4213 +1931 3158 +1931 7417 +1931 9113 +1931 5971 +1931 6175 +1931 7386 +1931 2643 +1931 2549 +1932 2500 +1932 9157 +1932 8870 +1932 7466 +1932 9586 +1932 3821 +1932 2514 +1932 2388 +1932 6453 +1932 5046 +1932 3348 +1932 3259 +1932 8284 +1932 6074 +1932 3198 +1933 7938 +1933 9771 +1933 8066 +1933 8720 +1933 6673 +1933 4621 +1933 4895 +1933 5412 +1933 3115 +1933 2614 +1933 4280 +1933 9887 +1933 3908 +1933 4559 +1933 3923 +1933 9560 +1933 4057 +1933 4955 +1933 2916 +1933 5608 +1933 8046 +1933 6639 +1933 8316 +1934 3329 +1934 5263 +1934 9235 +1934 8218 +1934 7583 +1934 7974 +1934 5419 +1934 7853 +1934 4145 +1934 3634 +1934 2377 +1934 5846 +1934 4445 +1934 4960 +1934 7912 +1934 3565 +1934 7278 +1934 3829 +1934 7542 +1934 6010 +1934 5245 +1935 2979 +1935 7432 +1935 5513 +1935 2827 +1935 2161 +1935 2931 +1935 2998 +1935 9656 +1935 2621 +1935 3966 +1936 8968 +1936 5228 +1936 9616 +1936 3628 +1936 3037 +1936 8072 +1936 9660 +1936 5055 +1936 4061 +1936 2526 +1936 2783 +1936 8289 +1936 5626 +1936 9469 +1936 9343 +1937 5857 +1937 9601 +1937 3833 +1937 9838 +1937 7888 +1937 4136 +1937 6099 +1937 5397 +1937 7351 +1937 9339 +1937 4669 +1938 8896 +1938 3456 +1938 2082 +1938 8161 +1938 7333 +1938 4423 +1938 2761 +1938 6482 +1938 4416 +1938 4690 +1938 9173 +1938 1942 +1938 3689 +1938 5018 +1938 8475 +1938 2300 +1938 8126 +1939 2208 +1939 5280 +1939 5668 +1939 5382 +1939 3809 +1939 7022 +1939 7089 +1939 8340 +1939 6900 +1939 6838 +1939 7252 +1939 7613 +1939 8415 +1940 6163 +1940 3587 +1940 6020 +1940 2502 +1940 5038 +1940 5736 +1940 4714 +1940 9197 +1940 8078 +1940 6194 +1940 7505 +1940 7317 +1940 9721 +1940 8606 +1941 2368 +1941 9123 +1941 6054 +1941 9586 +1941 6779 +1941 2925 +1941 8847 +1941 5328 +1941 9745 +1941 4114 +1941 7235 +1941 5654 +1941 4538 +1941 7487 +1941 8030 +1941 9790 +1941 7167 +1942 6298 +1942 2881 +1942 9122 +1942 4740 +1942 7653 +1942 9255 +1942 7434 +1942 5518 +1942 6771 +1942 7124 +1942 6645 +1942 9878 +1942 2679 +1942 5658 +1942 5114 +1942 1950 +1942 5567 +1943 4769 +1943 5603 +1943 7044 +1943 8933 +1943 9264 +1943 9293 +1943 4573 +1943 8945 +1943 5747 +1943 5196 +1943 7768 +1943 4956 +1943 6270 +1943 3709 +1944 3841 +1944 8068 +1944 6281 +1944 8078 +1944 2073 +1944 9116 +1944 5701 +1944 3872 +1944 5158 +1944 2983 +1944 5936 +1944 9138 +1944 3510 +1944 5696 +1944 8389 +1944 5774 +1944 3437 +1944 6254 +1944 3442 +1944 6521 +1944 8572 +1944 6781 +1944 9086 +1945 7360 +1945 5921 +1945 2819 +1945 4420 +1945 4677 +1945 7974 +1945 6529 +1945 5160 +1945 5262 +1945 3035 +1945 6256 +1945 5458 +1945 6371 +1945 3747 +1945 8118 +1945 5979 +1945 2433 +1945 7611 +1946 2401 +1946 6178 +1946 7267 +1946 5398 +1946 9335 +1946 1997 +1946 2002 +1946 9747 +1946 5044 +1946 9814 +1946 8311 +1946 3164 +1946 2493 +1946 5791 +1947 4192 +1947 2180 +1947 7268 +1947 9833 +1947 7763 +1947 2293 +1947 9988 +1947 2040 +1947 8025 +1947 8378 +1947 2523 +1947 6186 +1947 2879 +1948 4227 +1948 9837 +1948 6416 +1948 9247 +1948 3747 +1948 9515 +1948 9776 +1948 7364 +1948 4679 +1948 9805 +1948 6989 +1948 3920 +1948 9683 +1948 4948 +1948 8045 +1948 8179 +1948 2681 +1948 4477 +1949 5284 +1949 6928 +1949 4819 +1949 2229 +1949 2294 +1949 4757 +1950 7568 +1950 6427 +1950 8484 +1950 2408 +1950 9995 +1950 3136 +1950 3504 +1950 2578 +1950 6015 +1950 3126 +1950 3454 +1950 7573 +1951 4867 +1951 9992 +1951 2063 +1951 8211 +1951 6040 +1951 2088 +1951 5163 +1951 7215 +1951 8638 +1951 6336 +1951 9550 +1951 9231 +1951 9440 +1951 6755 +1951 3044 +1951 3814 +1951 4725 +1952 2656 +1952 9267 +1952 3397 +1952 2163 +1952 9542 +1952 9395 +1952 6278 +1952 5545 +1952 9326 +1952 9519 +1952 7535 +1952 7061 +1952 4537 +1952 4985 +1952 6491 +1952 7675 +1952 6581 +1953 4128 +1953 6693 +1953 5943 +1953 2386 +1953 9208 +1953 6519 +1953 5464 +1953 3002 +1953 5275 +1954 3904 +1954 7393 +1954 3057 +1954 9156 +1954 6140 +1954 2025 +1954 8682 +1954 7392 +1954 5294 +1954 9489 +1954 8307 +1954 5332 +1954 7446 +1954 8855 +1954 9012 +1954 9980 +1954 5533 +1955 6528 +1955 9067 +1955 9444 +1955 5958 +1955 9511 +1955 6697 +1955 5995 +1955 7021 +1955 8464 +1955 3230 +1955 4299 +1955 5431 +1956 5377 +1956 7651 +1956 3268 +1956 6504 +1956 9298 +1956 6263 +1956 6736 +1956 6073 +1956 4667 +1956 8284 +1956 3421 +1956 7486 +1956 8927 +1957 2368 +1957 8769 +1957 7618 +1957 7875 +1957 2244 +1957 7921 +1957 7143 +1957 8973 +1957 3565 +1957 7943 +1957 6961 +1957 8914 +1957 7761 +1957 9852 +1957 8701 +1957 4287 +1958 3467 +1958 3141 +1958 4907 +1958 8077 +1958 7633 +1958 6802 +1958 4469 +1958 2678 +1958 2935 +1958 7343 +1958 7612 +1958 7149 +1959 8642 +1959 9124 +1959 4406 +1959 4136 +1959 3166 +1959 3694 +1959 3453 +1959 6077 +1959 4510 +1960 6721 +1960 8388 +1960 5131 +1960 3743 +1960 5918 +1960 4466 +1960 8853 +1960 9494 +1960 3767 +1960 5402 +1960 5263 +1960 9871 +1960 3677 +1960 2942 +1960 1983 +1961 4832 +1961 3339 +1961 4740 +1961 6940 +1961 2287 +1961 3100 +1961 2603 +1961 5997 +1961 3086 +1961 4527 +1961 8853 +1961 8625 +1961 4373 +1961 4299 +1961 3610 +1962 9792 +1962 2753 +1962 8227 +1962 5252 +1962 8423 +1962 6288 +1962 9966 +1962 2448 +1962 7637 +1962 2774 +1962 9849 +1962 8122 +1962 6811 +1963 4450 +1963 4747 +1963 7275 +1963 4261 +1963 5809 +1963 5417 +1963 5133 +1963 2608 +1963 9457 +1963 2578 +1963 4531 +1963 7230 +1963 8915 +1963 7025 +1963 6299 +1963 6494 +1963 3999 +1964 8800 +1964 7433 +1964 5842 +1964 6616 +1964 7634 +1964 8119 +1964 9048 +1964 3100 +1965 7136 +1965 8259 +1965 6281 +1965 8618 +1965 8050 +1965 9987 +1965 3765 +1966 8705 +1966 3395 +1966 2696 +1966 4023 +1966 6433 +1966 6737 +1966 9815 +1966 8475 +1966 3038 +1967 9476 +1967 4614 +1967 8989 +1967 6699 +1967 5809 +1967 4661 +1967 4026 +1967 9055 +1967 5301 +1967 6340 +1967 3915 +1967 4684 +1967 3025 +1967 5343 +1967 6498 +1967 7917 +1967 7798 +1967 2297 +1968 3425 +1968 6115 +1968 2764 +1968 6221 +1968 8568 +1968 6285 +1968 3488 +1968 4242 +1968 7443 +1968 6292 +1968 5550 +1968 3512 +1968 4477 +1969 5443 +1969 2980 +1969 9393 +1969 7945 +1969 9834 +1969 6499 +1969 9164 +1969 8688 +1969 9585 +1969 5778 +1969 5187 +1969 3828 +1969 7097 +1969 9289 +1969 8196 +1969 3293 +1969 2590 +1969 3615 +1970 3393 +1970 5443 +1970 9302 +1970 4646 +1970 5416 +1970 3529 +1970 7434 +1970 4905 +1970 3246 +1970 4911 +1970 7638 +1970 6898 +1970 9305 +1970 6463 +1971 2934 +1971 6474 +1971 5131 +1971 7501 +1971 5698 +1971 5967 +1971 8209 +1971 6515 +1971 4854 +1971 7095 +1971 2338 +1971 9373 +1971 7409 +1972 4230 +1972 9898 +1972 8940 +1972 2125 +1972 2941 +1972 4098 +1972 4692 +1972 8922 +1972 3130 +1972 7166 +1973 2144 +1973 3872 +1973 9755 +1973 9056 +1973 7847 +1973 9096 +1973 1994 +1973 8684 +1973 3470 +1973 7791 +1973 4689 +1973 3922 +1973 9406 +1973 7608 +1973 7610 +1973 6907 +1973 3946 +1974 4610 +1974 9995 +1974 6928 +1974 8468 +1974 5912 +1974 6939 +1974 2077 +1974 6943 +1974 2502 +1974 9389 +1974 8878 +1974 2225 +1974 3387 +1974 4161 +1974 1996 +1974 8282 +1974 2018 +1974 8561 +1974 7543 +1974 7800 +1975 5312 +1975 9886 +1975 4995 +1975 3749 +1975 7558 +1975 5191 +1975 9169 +1975 8920 +1975 5211 +1975 9822 +1975 3709 +1975 7263 +1976 6256 +1976 3300 +1976 2182 +1976 7494 +1976 3562 +1976 2219 +1976 5702 +1976 9721 +1976 5212 +1976 3261 +1977 9089 +1977 3336 +1977 2213 +1977 9660 +1977 7485 +1977 9675 +1977 8646 +1977 4427 +1977 2125 +1977 2514 +1977 5845 +1977 3551 +1977 7276 +1977 8402 +1977 2801 +1977 7167 +1977 7807 +1978 8672 +1978 9124 +1978 6149 +1978 3593 +1978 5389 +1978 7005 +1978 5650 +1978 7913 +1978 3514 +1978 2334 +1978 7774 +1979 8238 +1979 9441 +1979 9506 +1979 4324 +1979 6615 +1979 2406 +1979 7836 +1979 3467 +1979 8268 +1979 7757 +1979 7246 +1979 2287 +1979 4887 +1979 2449 +1979 6451 +1979 4919 +1979 8732 +1980 7969 +1980 3302 +1980 4234 +1980 2763 +1980 8301 +1980 4792 +1980 5240 +1980 7423 +1980 8298 +1980 7231 +1981 5398 +1981 8341 +1981 7830 +1981 8984 +1981 5914 +1981 2340 +1981 8999 +1981 6833 +1981 4914 +1981 2868 +1981 7107 +1981 7113 +1981 3279 +1981 4176 +1981 3283 +1981 3032 +1981 4188 +1981 6366 +1981 3056 +1982 8925 +1982 4353 +1982 5283 +1982 6470 +1982 7656 +1982 5577 +1982 6188 +1982 4752 +1982 7208 +1982 5504 +1982 3651 +1982 3791 +1982 8061 +1982 2828 +1983 2932 +1983 3784 +1983 3523 +1983 7942 +1983 8358 +1983 2762 +1983 6413 +1983 6831 +1983 6897 +1983 8562 +1983 9620 +1983 4183 +1983 7001 +1983 7003 +1984 6624 +1984 2603 +1984 3684 +1984 7781 +1984 9118 +1984 9473 +1984 7912 +1984 8426 +1984 9678 +1984 8689 +1984 3987 +1984 9525 +1984 3577 +1984 6748 +1984 5875 +1985 4226 +1985 4483 +1985 7556 +1985 3461 +1985 9731 +1985 2082 +1985 2723 +1985 2980 +1985 4525 +1985 7599 +1985 9270 +1985 6468 +1985 5558 +1985 8149 +1985 4061 +1985 6629 +1985 8169 +1985 2413 +1985 4718 +1985 4755 +1985 2036 +1985 7672 +1985 7290 +1986 4160 +1986 3106 +1986 4387 +1986 3972 +1986 3590 +1986 5511 +1986 6442 +1986 4047 +1986 9101 +1986 5134 +1986 8141 +1986 3248 +1986 4598 +1986 3983 +1986 8058 +1986 3451 +1986 9118 +1987 4256 +1987 8582 +1987 2407 +1987 8104 +1987 2569 +1987 9612 +1987 7982 +1987 9160 +1987 5170 +1987 8819 +1987 6069 +1987 6737 +1987 6714 +1987 2202 +1987 2814 +1987 9503 +1988 2977 +1988 5890 +1988 7208 +1988 6316 +1988 8748 +1988 5295 +1988 5840 +1988 9567 +1988 8854 +1988 8056 +1988 5339 +1988 5726 +1988 8766 +1988 4703 +1989 3587 +1989 7991 +1989 2511 +1989 4147 +1989 6740 +1989 7477 +1989 7894 +1989 2711 +1989 6107 +1989 4275 +1990 8070 +1990 6151 +1990 9994 +1990 6671 +1990 6040 +1990 2202 +1990 8990 +1990 8774 +1990 5542 +1990 6556 +1990 5039 +1990 3785 +1990 9166 +1990 3409 +1990 8536 +1990 3300 +1990 7785 +1990 9836 +1990 4717 +1990 9339 +1991 2521 +1991 2531 +1991 8356 +1991 9963 +1991 8072 +1991 6314 +1991 9719 +1991 2285 +1991 9390 +1991 9843 +1991 2324 +1991 5013 +1991 4726 +1991 2647 +1991 3513 +1991 5066 +1991 7742 +1991 2815 +1992 5967 +1992 9595 +1992 4676 +1992 6501 +1992 6939 +1992 2539 +1992 7458 +1992 5806 +1992 8019 +1992 7668 +1992 4910 +1992 7547 +1992 3973 +1993 7488 +1993 8946 +1993 4516 +1993 3366 +1993 9900 +1993 5842 +1993 4677 +1993 3983 +1993 8146 +1993 7219 +1993 7286 +1993 9337 +1993 7482 +1993 5765 +1994 4736 +1994 2084 +1994 5448 +1994 4105 +1994 2040 +1994 7764 +1994 5912 +1994 5179 +1994 3997 +1994 3045 +1995 6938 +1995 6817 +1995 5414 +1995 2215 +1995 4530 +1995 4274 +1995 4918 +1995 4159 +1995 9165 +1995 6349 +1995 7760 +1995 2654 +1995 2655 +1995 6374 +1995 6895 +1995 4727 +1996 4483 +1996 4517 +1996 2182 +1996 8999 +1996 4264 +1996 3817 +1996 3276 +1996 4531 +1996 5903 +1996 3571 +1996 8917 +1996 5989 +1996 2968 +1996 9215 +1996 4158 +1996 2453 +1997 7138 +1997 3363 +1997 4708 +1997 7433 +1997 7198 +1997 5437 +1997 8083 +1997 9332 +1997 9557 +1997 7542 +1997 9978 +1997 3834 +1997 2782 +1998 9408 +1998 7937 +1998 7456 +1998 4135 +1998 3137 +1998 5549 +1998 9839 +1998 9745 +1998 8980 +1998 6361 +1998 9466 +1998 4603 +1998 4636 +1998 5661 +1999 7939 +1999 4196 +1999 3559 +1999 5612 +1999 6013 +1999 3956 +1999 5365 +1999 7734 +1999 5850 +1999 7311 +1999 6108 +1999 3197 +1999 9950 +2000 6626 +2000 2779 +2000 7055 +2000 2054 +2000 6566 +2000 3436 +2000 8334 +2000 9005 +2000 5303 +2000 5784 +2000 3663 +2000 6693 +2001 3520 +2001 5730 +2001 5735 +2001 2536 +2001 9279 +2001 7755 +2001 6445 +2001 6735 +2001 5406 +2001 5210 +2001 3807 +2001 3422 +2001 5333 +2002 8738 +2002 4452 +2002 2245 +2002 5959 +2002 9932 +2002 3918 +2002 7632 +2002 8563 +2002 3982 +2002 3383 +2002 6276 +2002 9509 +2003 3876 +2003 3591 +2003 4263 +2003 8780 +2003 2094 +2003 5967 +2003 3953 +2003 7665 +2003 2201 +2003 6270 +2004 7566 +2004 8480 +2004 5540 +2004 3104 +2004 3627 +2004 7212 +2004 7469 +2004 9646 +2004 8370 +2004 8243 +2004 2228 +2004 2102 +2004 6328 +2004 7998 +2004 9120 +2004 3528 +2004 8011 +2004 5068 +2004 5456 +2004 8025 +2004 9179 +2004 9700 +2004 3429 +2004 5356 +2004 8945 +2004 3570 +2004 6397 +2005 4513 +2005 8644 +2005 8265 +2005 2315 +2005 9772 +2005 6637 +2005 8009 +2005 9181 +2005 8112 +2005 7422 +2005 3646 +2005 8791 +2005 2461 +2005 6366 +2005 2751 +2006 6941 +2006 7110 +2006 7467 +2006 8419 +2006 2290 +2006 7247 +2006 2354 +2006 7318 +2006 7994 +2006 7771 +2007 9121 +2007 2765 +2007 7179 +2007 2790 +2007 5958 +2007 9032 +2007 6026 +2007 7767 +2007 2674 +2007 9389 +2007 4806 +2007 9458 +2007 3925 +2007 8919 +2007 5946 +2007 7786 +2008 2785 +2008 8419 +2008 8070 +2008 9255 +2008 4713 +2008 5930 +2008 4396 +2008 4046 +2008 6323 +2008 6388 +2008 8377 +2008 4026 +2009 9217 +2009 3522 +2009 4195 +2009 6694 +2009 5318 +2009 3420 +2009 5893 +2009 9582 +2009 7064 +2009 4532 +2009 5782 +2009 3802 +2009 9116 +2009 2461 +2009 8197 +2010 4481 +2010 8200 +2010 7562 +2010 6288 +2010 6941 +2010 2467 +2010 6951 +2010 7595 +2010 2224 +2010 3765 +2010 4799 +2010 8897 +2010 2370 +2010 7116 +2010 8782 +2010 2132 +2010 7512 +2010 3804 +2010 9056 +2010 9830 +2010 6247 +2010 9321 +2010 2940 +2010 7935 +2011 9763 +2011 4682 +2011 8677 +2011 5835 +2011 5127 +2011 7850 +2011 9963 +2011 8818 +2011 2659 +2011 8867 +2011 9526 +2011 7519 +2011 3836 +2011 2301 +2011 5502 +2011 7423 +2012 7314 +2012 9507 +2012 5040 +2012 6267 +2012 4407 +2012 3386 +2012 8507 +2012 8516 +2012 7622 +2012 7628 +2012 7634 +2012 8404 +2012 5211 +2012 7647 +2012 8635 +2012 2150 +2012 6122 +2012 7788 +2012 9197 +2012 9838 +2012 3067 +2013 7233 +2013 2043 +2013 4100 +2013 6437 +2013 2340 +2013 5898 +2013 7191 +2013 6352 +2013 7223 +2013 2616 +2013 7993 +2013 5403 +2014 8455 +2014 7953 +2014 6171 +2014 8608 +2014 6568 +2014 2478 +2014 6835 +2014 7734 +2014 7491 +2014 7751 +2014 5589 +2014 5974 +2014 3543 +2014 3932 +2014 4193 +2014 6801 +2014 5224 +2014 8940 +2014 5873 +2014 3446 +2014 5751 +2015 8705 +2015 5253 +2015 3334 +2015 8476 +2015 2070 +2015 8860 +2015 8406 +2015 6044 +2015 9002 +2015 3765 +2015 6839 +2015 2759 +2015 9942 +2015 7889 +2015 4819 +2015 9945 +2015 3560 +2015 8556 +2015 7537 +2015 9973 +2016 6017 +2016 3972 +2016 7692 +2016 9998 +2016 7439 +2016 5524 +2016 7063 +2016 6685 +2016 4518 +2016 3886 +2016 4018 +2016 5301 +2016 5317 +2016 8398 +2016 2392 +2016 2658 +2016 2788 +2016 8549 +2016 7148 +2016 3826 +2016 9587 +2017 3713 +2017 9003 +2017 8583 +2017 7434 +2017 4312 +2017 6044 +2017 5413 +2017 7975 +2017 4009 +2017 2347 +2017 6447 +2017 3000 +2017 4292 +2017 8013 +2017 9421 +2017 7768 +2017 3418 +2017 8541 +2017 8161 +2017 5484 +2018 2057 +2018 2826 +2018 8865 +2018 7089 +2018 6409 +2018 5182 +2018 4932 +2018 2773 +2018 9822 +2018 2065 +2018 3822 +2018 3056 +2018 2930 +2018 2547 +2018 9982 +2018 6613 +2019 9729 +2019 2491 +2019 9764 +2019 8165 +2019 9062 +2019 7427 +2019 2698 +2019 4394 +2019 3491 +2019 5134 +2019 6671 +2019 3792 +2019 5331 +2019 7156 +2019 4890 +2019 2500 +2019 7834 +2019 4699 +2019 7709 +2019 5669 +2020 5281 +2020 5666 +2020 8295 +2020 7400 +2020 7593 +2020 7434 +2020 3961 +2020 4450 +2020 9391 +2020 5904 +2020 6929 +2020 9783 +2020 3535 +2020 9148 +2020 2943 +2021 7040 +2021 7137 +2021 4098 +2021 3387 +2021 2277 +2021 4486 +2021 9281 +2021 9869 +2021 7858 +2021 7843 +2021 7806 +2021 2328 +2021 2681 +2021 4634 +2021 4379 +2021 4922 +2021 3038 +2022 2561 +2022 7045 +2022 8717 +2022 5648 +2022 8338 +2022 2324 +2022 3243 +2022 7345 +2022 8761 +2022 5180 +2022 5059 +2022 3191 +2022 4717 +2022 4846 +2022 8437 +2022 7031 +2022 2041 +2023 2688 +2023 3396 +2023 4293 +2023 6537 +2023 5259 +2023 8337 +2023 3090 +2023 4499 +2023 6421 +2023 2262 +2023 9207 +2023 5401 +2023 3869 +2024 8768 +2024 7934 +2024 5403 +2024 7236 +2024 7110 +2024 7071 +2024 8255 +2024 2828 +2024 9342 +2024 9870 +2024 5908 +2024 4654 +2024 7350 +2024 8089 +2024 7705 +2024 4159 +2024 5493 +2025 3713 +2025 3171 +2025 6532 +2025 6344 +2025 3402 +2025 5367 +2025 8749 +2025 7120 +2025 3240 +2025 3154 +2025 8949 +2025 6614 +2025 6105 +2025 3160 +2025 9178 +2025 9819 +2025 9405 +2026 5568 +2026 2977 +2026 7622 +2026 3974 +2026 4776 +2026 7818 +2026 8984 +2026 4785 +2026 5336 +2026 5780 +2026 7317 +2026 5631 +2026 2648 +2026 2532 +2026 3547 +2026 8092 +2026 2469 +2027 9217 +2027 3586 +2027 9956 +2027 2151 +2027 3689 +2027 9066 +2027 4238 +2027 7855 +2027 7213 +2027 9621 +2027 7448 +2027 6420 +2027 5435 +2027 7037 +2028 2949 +2028 3366 +2028 4903 +2028 4968 +2028 5676 +2028 7178 +2028 7431 +2028 7464 +2028 8274 +2028 5044 +2028 7861 +2028 7446 +2028 5911 +2028 4474 +2028 7100 +2028 4061 +2029 4113 +2029 5139 +2029 5268 +2029 6293 +2029 8216 +2029 2073 +2029 4514 +2029 3370 +2029 3243 +2029 5423 +2029 8257 +2029 5961 +2029 9939 +2029 8285 +2029 8929 +2029 9058 +2029 7922 +2029 9850 +2029 4475 +2029 3070 +2030 5644 +2030 4495 +2030 7957 +2030 6038 +2030 9626 +2030 4508 +2030 4128 +2030 7469 +2030 5683 +2030 7745 +2030 4931 +2030 5316 +2030 9927 +2030 4427 +2030 8789 +2030 3414 +2030 3549 +2030 8286 +2030 4320 +2030 2658 +2030 5739 +2030 9851 +2030 7294 +2030 2047 +2031 8235 +2031 8966 +2031 4615 +2031 2707 +2031 4119 +2031 2456 +2031 9884 +2031 2462 +2031 8095 +2031 3207 +2031 5551 +2031 7101 +2031 3552 +2031 5455 +2031 6480 +2031 4690 +2031 5331 +2031 8916 +2031 6624 +2031 3323 +2031 2055 +2031 6003 +2031 6776 +2031 6139 +2032 9793 +2032 7779 +2032 5318 +2032 9799 +2032 4298 +2032 8331 +2032 5117 +2032 4048 +2032 8241 +2032 2803 +2032 6135 +2032 3321 +2032 9011 +2032 3101 +2033 2338 +2033 8339 +2033 6949 +2033 5183 +2033 5611 +2033 4237 +2033 5071 +2033 3235 +2033 7091 +2033 6389 +2033 6710 +2033 3465 +2033 5560 +2033 9689 +2033 9531 +2033 3036 +2033 6237 +2033 9662 +2033 4949 +2034 4610 +2034 2599 +2034 4029 +2034 2411 +2034 7314 +2034 6798 +2034 3055 +2034 5874 +2034 8035 +2034 5966 +2034 5453 +2034 2458 +2034 3709 +2034 2718 +2034 3263 +2035 2944 +2035 6660 +2035 6792 +2035 7218 +2035 5435 +2035 9679 +2035 7250 +2035 2390 +2035 4824 +2035 5849 +2035 9313 +2035 3560 +2036 7073 +2036 2275 +2036 9014 +2036 3853 +2036 8941 +2036 2712 +2036 7893 +2036 5238 +2036 5752 +2036 7903 +2037 7328 +2037 6179 +2037 4805 +2037 5059 +2037 6089 +2037 9335 +2037 4189 +2037 8125 +2037 5008 +2037 7160 +2037 6515 +2037 6652 +2037 7353 +2037 5273 +2037 7663 +2037 6044 +2037 3069 +2037 8911 +2037 4767 +2038 5296 +2038 9186 +2038 3079 +2038 4808 +2038 5481 +2038 6440 +2038 4209 +2038 6034 +2038 2335 +2038 6004 +2038 4630 +2038 5047 +2038 9449 +2038 4926 +2038 9663 +2039 3745 +2039 5570 +2039 8139 +2039 9988 +2039 5910 +2039 7804 +2039 3114 +2039 3115 +2039 6722 +2039 5008 +2039 3792 +2039 8594 +2039 9299 +2039 4062 +2039 2494 +2039 2999 +2039 4956 +2039 7390 +2040 3971 +2040 8214 +2040 8683 +2040 2929 +2040 7464 +2040 9134 +2040 7602 +2040 9911 +2040 9384 +2040 4698 +2040 3931 +2040 5734 +2040 4715 +2040 7281 +2040 6517 +2040 7030 +2040 3833 +2041 2659 +2041 2404 +2041 4262 +2041 2153 +2041 5266 +2041 2574 +2041 3421 +2041 2449 +2041 4306 +2041 9141 +2041 6938 +2041 2363 +2041 2428 +2041 5493 +2042 6113 +2042 5218 +2042 3171 +2042 7784 +2042 8811 +2042 6860 +2042 3842 +2042 7752 +2042 7637 +2042 5753 +2042 4090 +2042 7452 +2042 9278 +2043 9657 +2043 5090 +2043 7589 +2043 8698 +2043 8937 +2043 5805 +2043 6990 +2043 7634 +2043 3930 +2043 5562 +2044 2501 +2044 2600 +2044 7047 +2044 7048 +2044 5963 +2044 2109 +2044 8302 +2044 9629 +2044 5736 +2044 7699 +2044 3444 +2044 7413 +2044 4447 +2044 7484 +2044 8894 +2044 6165 +2045 8066 +2045 8918 +2045 9350 +2045 4871 +2045 7176 +2045 5385 +2045 7692 +2045 8987 +2045 4523 +2045 4909 +2045 9390 +2045 5299 +2045 7738 +2045 3539 +2045 4566 +2045 4955 +2045 8543 +2045 5859 +2045 9832 +2045 8048 +2045 8680 +2045 7411 +2045 5372 +2046 6401 +2046 4488 +2046 8980 +2046 3093 +2046 6559 +2046 8612 +2046 3750 +2046 7229 +2046 9024 +2046 7750 +2046 2146 +2046 6484 +2046 4473 +2046 6882 +2046 5603 +2046 2276 +2046 2917 +2046 8953 +2047 2209 +2047 5477 +2047 2826 +2047 9383 +2047 5903 +2047 3102 +2047 4921 +2047 9148 +2047 9662 +2047 3973 +2048 6919 +2048 4489 +2048 5899 +2048 9103 +2048 3220 +2048 5910 +2048 8728 +2048 5409 +2048 8866 +2048 7846 +2048 5169 +2048 3184 +2048 2739 +2048 8116 +2048 3512 +2048 7647 +2048 8509 +2048 4158 +2048 5183 +2048 4545 +2048 2882 +2048 3105 +2048 5335 +2048 4769 +2048 8927 +2048 7394 +2048 9833 +2048 5867 +2048 8169 +2048 2681 +2049 6721 +2049 4642 +2049 6437 +2049 3368 +2049 3881 +2049 9683 +2049 3576 +2049 4410 +2049 4924 +2049 5930 +2050 9007 +2050 3716 +2050 6063 +2050 6250 +2050 6541 +2050 8701 +2050 4608 +2050 5109 +2050 3850 +2050 7802 +2050 6671 +2050 9948 +2050 2442 +2050 2719 +2051 4032 +2051 5313 +2051 2131 +2051 3268 +2051 8039 +2051 3788 +2051 7021 +2051 8491 +2051 4844 +2051 2765 +2051 3632 +2051 2097 +2051 8915 +2051 3574 +2051 4509 +2051 6172 +2051 2685 +2052 6543 +2052 2961 +2052 8855 +2052 9753 +2052 2586 +2052 3365 +2052 6044 +2052 4154 +2052 2239 +2052 3282 +2052 3031 +2052 3288 +2052 9817 +2052 9696 +2052 8208 +2052 9187 +2052 7909 +2052 3182 +2052 7165 +2053 4483 +2053 3729 +2053 5778 +2053 2330 +2053 2479 +2053 7713 +2053 5287 +2053 9512 +2053 6062 +2053 3247 +2053 8771 +2053 8055 +2053 5073 +2053 4954 +2053 9179 +2053 7388 +2053 5213 +2053 2274 +2053 7159 +2054 8528 +2054 7299 +2054 9476 +2054 8006 +2054 7687 +2054 5800 +2054 3884 +2054 8561 +2054 4914 +2054 9697 +2054 5462 +2054 9303 +2054 4200 +2054 3583 +2055 9096 +2055 3850 +2055 5392 +2055 8559 +2055 3695 +2055 4254 +2055 2980 +2055 8358 +2055 6439 +2055 2863 +2055 8500 +2055 2997 +2055 4920 +2055 6078 +2055 7745 +2055 5703 +2055 3020 +2055 7760 +2055 7253 +2055 5466 +2055 8412 +2055 5713 +2055 5354 +2056 4257 +2056 7810 +2056 9435 +2056 5974 +2056 9703 +2056 6569 +2056 6668 +2056 2096 +2056 9649 +2056 2206 +2056 6737 +2056 3945 +2056 2072 +2056 3129 +2056 4542 +2056 4670 +2056 3999 +2057 6400 +2057 3042 +2057 6811 +2057 3110 +2057 9231 +2057 2698 +2057 6987 +2057 7117 +2057 5137 +2057 8851 +2057 5199 +2057 2744 +2057 7832 +2057 4687 +2057 5182 +2058 8416 +2058 5505 +2058 4546 +2058 5347 +2058 8293 +2058 8338 +2058 7368 +2058 4010 +2058 4983 +2058 2509 +2058 8184 +2058 7090 +2058 6490 +2058 3317 +2058 8096 +2058 8248 +2058 7808 +2058 3740 +2058 4986 +2058 4149 +2059 9987 +2059 7691 +2059 5264 +2059 7575 +2059 4766 +2059 6832 +2059 5931 +2059 8240 +2059 3147 +2059 8141 +2059 4566 +2059 7517 +2059 8032 +2059 9314 +2059 9210 +2060 2675 +2060 8793 +2060 3046 +2060 2471 +2060 6953 +2060 9980 +2060 7692 +2060 3917 +2060 7086 +2060 7314 +2060 5996 +2060 4599 +2060 9753 +2060 4667 +2060 5116 +2061 7811 +2061 2693 +2061 5128 +2061 7439 +2061 7319 +2061 7448 +2061 5785 +2061 9375 +2061 5668 +2061 6575 +2061 6979 +2061 9170 +2061 4035 +2061 7263 +2061 9187 +2061 2149 +2061 8039 +2061 8817 +2061 8180 +2061 6399 +2062 6722 +2062 9099 +2062 3329 +2062 5352 +2062 2442 +2062 9740 +2062 6510 +2062 2192 +2062 7208 +2062 2708 +2062 3320 +2062 9625 +2062 2492 +2063 8711 +2063 7950 +2063 5392 +2063 6420 +2063 9113 +2063 7077 +2063 3750 +2063 2095 +2063 8752 +2063 7492 +2063 6087 +2063 9936 +2063 2147 +2063 3565 +2063 4718 +2063 7933 +2063 8312 +2063 6265 +2063 3581 +2064 5280 +2064 5250 +2064 6683 +2064 3621 +2064 7175 +2064 6924 +2064 4718 +2064 6927 +2064 2193 +2064 4467 +2064 9272 +2064 6288 +2064 9659 +2064 2332 +2064 7198 +2064 9983 +2065 9059 +2065 9383 +2065 8987 +2065 8265 +2065 3080 +2065 6129 +2065 5970 +2065 8723 +2065 8276 +2065 5558 +2065 4218 +2065 9755 +2066 7298 +2066 3465 +2066 7819 +2066 7311 +2066 3476 +2066 6810 +2066 7974 +2066 4152 +2066 5434 +2066 7775 +2066 8381 +2066 7743 +2066 8133 +2066 6996 +2066 9561 +2066 7647 +2066 9957 +2066 3437 +2066 9455 +2066 6514 +2066 7029 +2066 9207 +2067 8795 +2067 9381 +2067 7558 +2067 8135 +2067 9577 +2067 7530 +2067 6359 +2067 2572 +2067 5166 +2067 5519 +2067 6194 +2067 3689 +2067 4281 +2067 7227 +2068 6272 +2068 7013 +2068 4037 +2068 2984 +2068 3612 +2068 5104 +2068 3669 +2068 3961 +2068 2329 +2068 9628 +2068 9149 +2069 8529 +2069 2376 +2069 2508 +2069 3565 +2069 9864 +2069 3346 +2069 7092 +2069 6206 +2069 2743 +2069 2968 +2069 2169 +2069 8442 +2069 3964 +2069 5341 +2069 4606 +2070 9365 +2070 4516 +2070 9557 +2070 9896 +2070 4508 +2070 5349 +2070 9685 +2070 8878 +2070 5455 +2070 4880 +2070 3697 +2070 9845 +2070 5589 +2070 2108 +2070 4863 +2071 8421 +2071 5788 +2071 4483 +2071 6349 +2071 5646 +2071 6192 +2071 6002 +2071 6723 +2071 6904 +2071 8153 +2071 6603 +2071 3998 +2071 8607 +2072 9083 +2072 7640 +2072 7623 +2072 4945 +2072 9832 +2072 9993 +2072 9706 +2072 3415 +2072 9693 +2072 9906 +2072 6837 +2072 7798 +2072 4279 +2072 7930 +2072 8053 +2073 2461 +2073 4520 +2073 7210 +2073 4536 +2073 7540 +2073 4155 +2073 4426 +2073 7626 +2073 7370 +2073 5718 +2073 3034 +2073 8674 +2073 4325 +2073 2922 +2073 8180 +2073 7802 +2073 5247 +2074 3266 +2074 4108 +2074 4971 +2074 5164 +2074 6544 +2074 8530 +2074 2966 +2074 6463 +2075 8321 +2075 9154 +2075 4292 +2075 4102 +2075 9997 +2075 4669 +2075 4338 +2075 4284 +2075 5940 +2075 7253 +2075 7642 +2075 4060 +2075 5725 +2075 3693 +2076 6402 +2076 9667 +2076 6916 +2076 4357 +2076 6599 +2076 8935 +2076 5965 +2076 4142 +2076 5201 +2076 6419 +2076 9492 +2076 8918 +2076 8119 +2076 5432 +2076 5103 +2077 9471 +2077 6467 +2077 6372 +2077 5959 +2077 3658 +2077 7073 +2077 3534 +2077 2735 +2077 2641 +2077 5074 +2077 8595 +2077 3926 +2077 2387 +2077 8374 +2077 4091 +2077 9605 +2078 6534 +2078 2577 +2078 7315 +2078 6603 +2078 8736 +2078 2210 +2078 7208 +2078 7599 +2078 6709 +2078 4537 +2078 4410 +2078 4160 +2078 5315 +2078 5573 +2078 5065 +2078 3787 +2078 6457 +2078 8665 +2078 9053 +2078 2665 +2078 6507 +2078 8488 +2078 3486 +2078 3832 +2079 2603 +2079 9231 +2079 8084 +2079 6678 +2079 6935 +2079 7068 +2079 6438 +2079 5544 +2079 5035 +2079 4653 +2079 9262 +2079 7088 +2079 2270 +2079 7012 +2079 4724 +2079 2805 +2080 3716 +2080 2949 +2080 8587 +2080 7057 +2080 8091 +2080 5790 +2080 3875 +2080 6948 +2080 9564 +2080 3631 +2080 6193 +2080 8115 +2080 9150 +2080 4417 +2080 3211 +2080 9931 +2080 5973 +2080 3929 +2080 6364 +2080 8949 +2081 4193 +2081 9219 +2081 5398 +2081 8370 +2081 7850 +2081 4076 +2081 7762 +2081 4110 +2081 7311 +2081 6384 +2081 9234 +2081 3668 +2081 5941 +2081 6838 +2081 7223 +2081 8827 +2081 8734 +2081 9087 +2082 5653 +2082 8772 +2082 3909 +2082 9446 +2082 9032 +2082 8777 +2082 9548 +2082 2830 +2082 2896 +2082 4689 +2082 6309 +2082 3726 +2082 7671 +2082 2554 +2082 6525 +2082 4094 +2082 6175 +2083 8965 +2083 4614 +2083 3081 +2083 5386 +2083 5134 +2083 4247 +2083 4762 +2083 6308 +2083 7851 +2083 7471 +2083 8755 +2083 6843 +2083 7107 +2083 9034 +2083 6996 +2083 9764 +2083 2282 +2083 3698 +2083 3832 +2083 8315 +2083 7420 +2083 8318 +2084 5276 +2084 3104 +2084 6576 +2084 4517 +2084 8367 +2084 2480 +2084 9777 +2084 9780 +2084 5814 +2084 2493 +2084 3781 +2084 6854 +2084 4305 +2084 5846 +2084 8280 +2084 7390 +2084 3707 +2084 7273 +2084 4204 +2084 3568 +2084 6513 +2084 3782 +2084 8955 +2084 6142 +2085 7810 +2085 6276 +2085 9630 +2085 2598 +2085 4525 +2085 9390 +2085 7986 +2085 5574 +2085 7116 +2085 3533 +2085 3538 +2085 9299 +2085 4320 +2085 5734 +2085 4333 +2085 2415 +2085 6517 +2085 6994 +2086 3459 +2086 7176 +2086 7690 +2086 3868 +2086 5277 +2086 7977 +2086 2347 +2086 2733 +2086 3787 +2086 6348 +2086 2773 +2086 4444 +2086 9052 +2086 9693 +2086 5214 +2086 2413 +2086 8316 +2086 9429 +2087 7936 +2087 4739 +2087 3611 +2087 3686 +2087 9543 +2087 2089 +2087 8746 +2087 2375 +2087 8201 +2087 3471 +2087 3953 +2087 6932 +2087 8873 +2087 8376 +2087 6426 +2087 4937 +2088 7712 +2088 9891 +2088 8615 +2088 8008 +2088 8522 +2088 4523 +2088 8243 +2088 4854 +2088 2335 +2088 3743 +2089 8640 +2089 5776 +2089 3852 +2089 8835 +2089 8709 +2089 6022 +2089 4584 +2089 5015 +2089 3638 +2089 7468 +2089 7982 +2089 8624 +2089 9557 +2089 5718 +2089 4526 +2089 9947 +2089 4988 +2089 3365 +2090 6021 +2090 4028 +2090 8812 +2090 2968 +2090 6645 +2090 4985 +2090 3535 +2090 7100 +2090 6879 +2090 2405 +2091 9511 +2091 4087 +2091 3063 +2091 7129 +2091 2143 +2091 7039 +2092 7136 +2092 5682 +2092 6255 +2092 5778 +2092 6520 +2092 6735 +2092 2556 +2092 9886 +2093 7331 +2093 8259 +2093 3619 +2093 7461 +2093 5895 +2093 7880 +2093 7787 +2093 7980 +2093 9680 +2093 2898 +2093 3731 +2093 6356 +2093 3288 +2093 6279 +2093 5119 +2094 7072 +2094 9250 +2094 8739 +2094 5924 +2094 6327 +2094 7226 +2094 6716 +2094 3009 +2094 9424 +2094 6483 +2094 9051 +2094 4191 +2094 6643 +2094 2810 +2094 5375 +2095 8352 +2095 9955 +2095 6537 +2095 3114 +2095 8919 +2095 8205 +2095 5713 +2095 8627 +2095 4523 +2095 4887 +2095 8922 +2095 4445 +2095 8958 +2096 7579 +2096 7922 +2096 4103 +2096 7274 +2096 9163 +2096 2445 +2096 2160 +2096 7860 +2096 7222 +2096 5592 +2096 5460 +2096 2911 +2097 9536 +2097 5608 +2097 9030 +2097 8433 +2097 8616 +2097 9545 +2097 6059 +2097 7308 +2097 2829 +2097 5960 +2097 3720 +2097 2892 +2097 2426 +2097 8122 +2097 9365 +2098 8321 +2098 5991 +2098 9004 +2098 7889 +2098 2227 +2098 2804 +2098 5749 +2098 7702 +2098 7479 +2098 6714 +2098 9019 +2098 8287 +2099 9665 +2099 3155 +2099 3107 +2099 5892 +2099 2789 +2099 4487 +2099 2601 +2099 3083 +2099 5292 +2099 5455 +2099 3267 +2099 2678 +2099 2167 +2099 7268 +2099 8794 +2099 7647 +2099 3324 +2099 4317 +2099 7102 +2099 5477 +2100 6870 +2100 2440 +2100 3273 +2100 8716 +2100 9686 +2100 4082 +2100 7286 +2100 5464 +2100 6586 +2100 4254 +2100 3647 +2101 7393 +2101 7589 +2101 7591 +2101 5264 +2101 9965 +2101 9584 +2101 6966 +2101 5015 +2101 2808 +2101 2362 +2101 3357 +2102 5545 +2102 2402 +2102 4168 +2102 3017 +2102 5235 +2102 4183 +2102 7727 +2102 2728 +2102 2869 +2102 9846 +2102 6135 +2102 9483 +2102 5977 +2102 3263 +2102 8765 +2102 3262 +2103 4672 +2103 6945 +2103 8354 +2103 2635 +2103 6597 +2103 2584 +2103 6184 +2103 2858 +2103 6059 +2103 6380 +2103 3343 +2103 7889 +2103 2194 +2103 4787 +2103 6294 +2103 4087 +2103 5369 +2103 3165 +2103 6015 +2104 9504 +2104 2117 +2104 3590 +2104 3336 +2104 6332 +2104 6157 +2104 2515 +2104 7993 +2104 2748 +2104 3612 +2104 2911 +2105 6114 +2105 6245 +2105 5190 +2105 8360 +2105 2281 +2105 6765 +2105 2152 +2105 3606 +2105 8214 +2105 9786 +2105 7133 +2105 9535 +2106 8513 +2106 3041 +2106 7172 +2106 6405 +2106 8998 +2106 6856 +2106 5420 +2106 2156 +2106 2693 +2106 4936 +2106 6324 +2106 3913 +2106 6808 +2106 9049 +2106 5308 +2106 2749 +2106 9471 +2107 2702 +2107 6801 +2107 8851 +2107 6039 +2107 9883 +2107 3744 +2107 9894 +2107 3057 +2107 9515 +2107 7094 +2107 3139 +2107 8009 +2107 8394 +2107 9934 +2107 4181 +2107 6493 +2107 3813 +2107 5361 +2107 4594 +2107 9203 +2107 5497 +2108 6272 +2108 6114 +2108 5067 +2108 9512 +2108 7562 +2108 5175 +2108 8435 +2108 3637 +2108 7437 +2108 8884 +2108 9204 +2108 9717 +2108 6743 +2108 5460 +2108 2461 +2108 8863 +2109 4738 +2109 9351 +2109 2184 +2109 5648 +2109 4163 +2109 8472 +2109 7713 +2109 2347 +2109 6970 +2109 9406 +2109 2883 +2109 2893 +2109 2903 +2109 6115 +2109 3562 +2109 5495 +2109 4094 +2109 7807 +2110 4352 +2110 2689 +2110 9223 +2110 4490 +2110 2955 +2110 5390 +2110 9999 +2110 7830 +2110 7194 +2110 3514 +2110 3656 +2110 5833 +2110 5965 +2110 9806 +2110 5840 +2110 8916 +2110 4438 +2110 3294 +2110 8295 +2110 3945 +2111 4929 +2111 6819 +2111 7236 +2111 4359 +2111 3784 +2111 9043 +2111 7028 +2111 5688 +2111 3898 +2111 7452 +2111 8702 +2112 8834 +2112 3204 +2112 3719 +2112 7055 +2112 4887 +2112 6813 +2112 9759 +2112 5468 +2112 6974 +2112 5440 +2112 3280 +2112 8920 +2112 6748 +2112 4832 +2112 9061 +2112 3177 +2112 2942 +2112 3839 +2113 6720 +2113 7074 +2113 6471 +2113 2312 +2113 4425 +2113 3687 +2113 6636 +2113 6317 +2113 4528 +2113 3955 +2113 2294 +2113 4505 +2113 4761 +2113 6075 +2113 6149 +2114 9472 +2114 9729 +2114 5385 +2114 2575 +2114 5154 +2114 7203 +2114 7467 +2114 4017 +2114 2231 +2114 3256 +2114 7099 +2114 8896 +2114 5061 +2114 3275 +2114 8399 +2114 7759 +2114 7790 +2114 7409 +2114 3189 +2114 6007 +2114 4089 +2115 6787 +2115 3236 +2115 3272 +2115 7658 +2115 7115 +2115 9228 +2115 6979 +2115 2699 +2115 4054 +2115 7799 +2115 5912 +2115 2266 +2115 6535 +2115 6110 +2116 9696 +2116 4864 +2116 6955 +2116 7557 +2116 9192 +2116 2423 +2116 5250 +2116 2837 +2116 3257 +2116 7737 +2116 3451 +2116 7797 +2117 2184 +2117 4238 +2117 5392 +2117 9882 +2117 9763 +2117 4266 +2117 5932 +2117 7341 +2117 6830 +2117 7349 +2117 3005 +2117 4934 +2117 9547 +2117 7378 +2117 9435 +2117 2922 +2117 8044 +2117 7287 +2117 6143 +2118 9100 +2118 3218 +2118 6681 +2118 5024 +2118 4770 +2118 6947 +2118 7474 +2118 3510 +2118 6712 +2118 7436 +2118 6219 +2118 8659 +2118 7765 +2118 9436 +2118 8033 +2118 8553 +2118 9197 +2118 4307 +2118 4852 +2118 7800 +2119 9216 +2119 3600 +2119 4523 +2119 4804 +2119 7571 +2119 5867 +2119 6415 +2119 2992 +2119 3731 +2119 4631 +2119 7897 +2119 2586 +2119 8155 +2119 6588 +2119 3967 +2120 2699 +2120 9796 +2120 6757 +2120 4967 +2120 9129 +2120 2919 +2120 6732 +2120 4661 +2120 5102 +2120 8727 +2120 9301 +2120 3799 +2120 9018 +2120 6399 +2120 6684 +2120 7130 +2120 3679 +2121 4613 +2121 6406 +2121 2825 +2121 8476 +2121 4381 +2121 3102 +2121 4900 +2121 2484 +2121 8628 +2121 8385 +2121 3651 +2121 9688 +2121 9434 +2121 8698 +2121 7144 +2121 7404 +2121 3054 +2121 3186 +2121 9976 +2121 2810 +2121 9979 +2122 4736 +2122 3011 +2122 9830 +2122 7207 +2122 7511 +2122 2530 +2122 9774 +2122 5716 +2122 5553 +2122 8402 +2122 9507 +2122 5300 +2122 6222 +2122 6105 +2122 4664 +2122 9268 +2122 6587 +2123 3362 +2123 5734 +2123 8776 +2123 3778 +2123 5107 +2123 8281 +2123 5306 +2123 2652 +2123 6269 +2123 2239 +2124 4100 +2124 9153 +2124 5132 +2124 8975 +2124 8348 +2124 4510 +2124 4265 +2124 7979 +2124 7214 +2124 5552 +2124 7217 +2124 4673 +2124 3777 +2124 7362 +2124 2243 +2124 5046 +2124 6984 +2124 6356 +2124 6877 +2124 8617 +2125 6497 +2125 5090 +2125 4356 +2125 6134 +2125 3273 +2125 3342 +2125 9764 +2125 6096 +2125 6673 +2125 6675 +2125 3190 +2125 7351 +2125 4378 +2125 3242 +2126 3091 +2126 8996 +2126 4229 +2126 8966 +2126 7761 +2126 6632 +2126 3466 +2126 4807 +2126 2719 +2126 3824 +2126 5912 +2126 6899 +2126 2905 +2126 2236 +2126 9374 +2126 3615 +2127 7937 +2127 3203 +2127 9221 +2127 5705 +2127 7132 +2127 8938 +2127 2296 +2127 9205 +2127 3415 +2127 5112 +2127 7353 +2127 9436 +2128 7570 +2128 8753 +2128 7602 +2128 9268 +2128 8506 +2128 2619 +2128 4809 +2128 4435 +2128 3539 +2128 7380 +2128 9817 +2128 5343 +2128 8932 +2128 5989 +2128 3686 +2128 8174 +2128 4978 +2128 9683 +2129 8387 +2129 6788 +2129 7452 +2129 3282 +2129 5934 +2129 2543 +2129 7762 +2129 6357 +2129 5303 +2129 7002 +2129 8463 +2129 2844 +2130 8000 +2130 7042 +2130 2339 +2130 9737 +2130 8778 +2130 5777 +2130 3442 +2130 9080 +2130 8666 +2130 4283 +2130 6746 +2130 2271 +2131 9249 +2131 7238 +2131 6369 +2131 4338 +2131 9069 +2131 6158 +2131 6706 +2131 4579 +2131 6392 +2131 6073 +2131 9563 +2131 4796 +2131 7839 +2132 6368 +2132 9377 +2132 7843 +2132 3969 +2132 9608 +2132 7465 +2132 9642 +2132 9409 +2132 4659 +2132 4624 +2132 5625 +2132 7868 +2133 8770 +2133 6179 +2133 8232 +2133 5066 +2133 9612 +2133 6157 +2133 6530 +2133 6255 +2133 9672 +2133 4850 +2133 9811 +2133 6787 +2133 5982 +2133 7799 +2133 4601 +2133 5141 +2134 6977 +2134 5026 +2134 5040 +2134 8325 +2134 3239 +2134 3082 +2134 4396 +2134 3603 +2134 4722 +2134 8147 +2134 4222 +2134 5046 +2134 2167 +2134 3027 +2134 3644 +2134 6398 +2134 7167 +2135 4320 +2135 9979 +2135 7045 +2135 8392 +2135 4202 +2135 9975 +2135 6412 +2135 2987 +2135 7735 +2135 3611 +2135 7326 +2136 3399 +2136 8260 +2136 8774 +2136 2727 +2136 9770 +2136 2155 +2136 9101 +2136 7537 +2136 3975 +2136 5237 +2136 8669 +2136 2590 +2137 3220 +2137 6936 +2137 9242 +2137 5281 +2137 9895 +2137 2856 +2137 8108 +2137 7095 +2137 6852 +2137 4550 +2137 9167 +2137 7895 +2137 5469 +2137 9830 +2137 3688 +2137 2922 +2137 7285 +2137 8468 +2137 3708 +2137 8701 +2137 6655 +2138 6016 +2138 4482 +2138 6539 +2138 2690 +2138 4880 +2138 7441 +2138 2836 +2138 9764 +2138 5541 +2138 6834 +2138 3388 +2138 9803 +2138 5709 +2138 9052 +2138 5865 +2138 2541 +2138 4207 +2138 7932 +2139 5907 +2139 8220 +2139 7199 +2139 8098 +2139 4920 +2139 4548 +2139 6987 +2139 5583 +2139 7888 +2139 3025 +2139 9700 +2139 4956 +2139 5086 +2139 4816 +2139 6761 +2139 3437 +2139 3694 +2139 4090 +2139 3199 +2140 9440 +2140 4481 +2140 9250 +2140 8486 +2140 7175 +2140 4457 +2140 3590 +2140 6839 +2140 3439 +2140 3408 +2140 9862 +2140 5362 +2140 5843 +2140 6199 +2140 6678 +2140 3269 +2141 2307 +2141 6414 +2141 6674 +2141 2582 +2141 8855 +2141 2465 +2141 7592 +2141 3896 +2141 6975 +2141 5317 +2141 8009 +2141 6485 +2141 9558 +2141 8922 +2141 2914 +2141 7145 +2141 3818 +2141 6512 +2141 6771 +2141 4181 +2142 5696 +2142 7649 +2142 2283 +2142 7876 +2142 7045 +2142 3174 +2142 7915 +2142 9564 +2142 5290 +2142 6411 +2142 4141 +2142 7245 +2142 6580 +2142 5782 +2142 3305 +2142 2396 +2142 2366 +2143 2587 +2143 9281 +2143 5768 +2143 8622 +2143 6811 +2143 2204 +2143 5190 +2143 9002 +2143 2606 +2143 5446 +2143 6235 +2143 8157 +2143 9060 +2143 6510 +2143 7023 +2143 7029 +2143 4984 +2144 4544 +2144 8193 +2144 8162 +2144 6567 +2144 2636 +2144 9090 +2144 3024 +2144 5425 +2144 8978 +2144 6473 +2144 7938 +2144 8994 +2144 5918 +2145 9934 +2145 5797 +2145 6460 +2145 7882 +2145 9581 +2145 5934 +2145 7605 +2145 6997 +2145 3159 +2145 3804 +2145 3178 +2145 3509 +2146 2948 +2146 7181 +2146 3983 +2146 4240 +2146 3998 +2146 5414 +2146 5982 +2146 5707 +2146 9156 +2146 5573 +2146 8264 +2146 8010 +2146 2379 +2146 5207 +2146 5720 +2146 9177 +2146 7258 +2146 7774 +2146 2915 +2146 5482 +2146 3948 +2146 2925 +2146 2159 +2146 9726 +2146 5881 +2147 3589 +2147 6411 +2147 9996 +2147 6165 +2147 7198 +2147 9121 +2147 9762 +2147 4534 +2147 4151 +2147 7613 +2147 2752 +2147 8392 +2147 5065 +2147 8908 +2147 2381 +2147 3410 +2147 6386 +2148 7492 +2148 9800 +2148 6155 +2148 5293 +2148 3509 +2148 7350 +2148 7193 +2148 4088 +2148 2969 +2148 7898 +2148 9340 +2149 3757 +2149 4187 +2149 6433 +2149 8214 +2149 5929 +2149 6248 +2149 5289 +2149 8686 +2149 9037 +2149 7986 +2149 2455 +2149 9560 +2149 3003 +2149 8668 +2150 9901 +2150 7643 +2150 5702 +2150 2193 +2150 8746 +2150 3757 +2150 6643 +2150 4016 +2150 5169 +2150 4243 +2150 6612 +2150 9907 +2150 2230 +2150 3545 +2150 7291 +2150 9725 +2150 8990 +2151 8598 +2151 7308 +2151 4973 +2151 3715 +2151 6806 +2151 8793 +2151 2333 +2151 7591 +2151 2179 +2151 9767 +2151 5032 +2151 4150 +2151 4797 +2151 3395 +2151 8005 +2151 6244 +2151 5468 +2151 6877 +2151 7140 +2151 2411 +2151 3181 +2151 9585 +2151 9331 +2151 5753 +2151 4859 +2152 9987 +2152 9604 +2152 3975 +2152 9353 +2152 8333 +2152 9369 +2152 7919 +2152 3463 +2152 3884 +2152 8237 +2152 2863 +2152 3506 +2152 5429 +2152 5056 +2152 6724 +2152 5803 +2152 2634 +2152 3027 +2152 5076 +2152 4182 +2152 5472 +2152 3307 +2152 4207 +2152 2160 +2152 5364 +2153 6721 +2153 7755 +2153 6788 +2153 4997 +2153 9898 +2153 9194 +2153 7848 +2153 4268 +2153 5639 +2153 4008 +2153 8917 +2153 9235 +2153 2485 +2153 2234 +2153 8891 +2153 5404 +2153 3082 +2153 6725 +2154 9987 +2154 7815 +2154 3595 +2154 9603 +2154 8603 +2154 5414 +2154 9003 +2154 6831 +2154 8639 +2154 9666 +2154 8780 +2154 3792 +2154 2514 +2154 4835 +2154 3031 +2154 3427 +2154 7268 +2154 9510 +2154 6381 +2154 8691 +2154 3583 +2155 3075 +2155 3462 +2155 3467 +2155 5005 +2155 6670 +2155 3473 +2155 7826 +2155 2595 +2155 7217 +2155 7487 +2155 3016 +2155 6107 +2155 7140 +2155 4969 +2155 9066 +2156 6912 +2156 6308 +2156 3365 +2156 6184 +2156 5193 +2156 5674 +2156 5810 +2156 7855 +2156 3986 +2156 4214 +2157 4424 +2157 5826 +2157 7492 +2157 5135 +2157 2999 +2157 5783 +2157 9871 +2157 7473 +2157 6868 +2157 7414 +2157 7517 +2158 3392 +2158 8289 +2158 7654 +2158 2769 +2158 7751 +2158 9068 +2158 7121 +2158 8729 +2158 4346 +2158 8286 +2159 6509 +2159 3908 +2159 2385 +2159 3513 +2159 2637 +2159 7186 +2159 6485 +2159 5974 +2159 3255 +2159 9922 +2159 5945 +2159 3066 +2159 6013 +2160 7456 +2160 4865 +2160 8069 +2160 3673 +2160 4552 +2160 4394 +2160 2927 +2160 8656 +2160 4512 +2160 5226 +2160 3897 +2160 8490 +2160 6922 +2160 8933 +2161 4097 +2161 2697 +2161 8726 +2161 6178 +2161 8231 +2161 2344 +2161 5033 +2161 3629 +2161 3765 +2161 3510 +2161 4162 +2161 6476 +2161 4698 +2161 2532 +2161 5225 +2161 3055 +2161 3576 +2162 8200 +2162 2829 +2162 4242 +2162 7060 +2162 6550 +2162 3865 +2162 9126 +2162 5928 +2162 8926 +2162 6090 +2162 3658 +2162 5210 +2162 4062 +2162 8804 +2162 5885 +2162 6256 +2162 8063 +2162 2557 +2162 6399 +2163 9985 +2163 4098 +2163 7563 +2163 5933 +2163 5394 +2163 9877 +2163 8598 +2163 5531 +2163 5539 +2163 8107 +2163 9773 +2163 9265 +2163 2868 +2163 3639 +2163 9785 +2163 5691 +2163 6332 +2163 9661 +2163 4677 +2163 6216 +2163 4812 +2163 9552 +2163 8463 +2163 2659 +2163 8676 +2163 3173 +2163 6773 +2164 8427 +2164 9636 +2164 7639 +2164 4071 +2164 6120 +2164 5899 +2164 3090 +2164 6637 +2164 4913 +2164 2738 +2164 4595 +2164 9300 +2164 4821 +2164 9207 +2164 2323 +2164 8409 +2164 9435 +2165 6629 +2165 3527 +2165 2387 +2165 8207 +2165 5299 +2165 3289 +2165 9530 +2165 4303 +2165 6717 +2165 2437 +2166 8416 +2166 5092 +2166 4359 +2166 6154 +2166 8370 +2166 5101 +2166 9906 +2166 3070 +2166 4006 +2166 4222 +2166 9951 +2167 8288 +2167 7042 +2167 2979 +2167 6245 +2167 7975 +2167 2453 +2167 4585 +2167 2542 +2167 7279 +2167 6257 +2167 4126 +2167 7832 +2167 4698 +2167 5214 +2167 7189 +2168 3819 +2168 4998 +2168 3753 +2168 8203 +2168 3067 +2168 4500 +2168 5689 +2168 8189 +2169 6848 +2169 9285 +2169 8940 +2169 4939 +2169 6316 +2169 5902 +2169 5712 +2169 5076 +2169 4854 +2169 8026 +2170 6339 +2170 6052 +2170 8069 +2170 8807 +2170 4712 +2170 2318 +2170 7537 +2170 6066 +2170 4819 +2170 6452 +2170 8763 +2170 8638 +2171 2721 +2171 6762 +2171 3564 +2171 5499 +2171 4155 +2171 5428 +2171 6741 +2171 4921 +2171 9540 +2171 8538 +2171 4571 +2171 7772 +2171 7965 +2172 2560 +2172 5154 +2172 2403 +2172 2308 +2172 8360 +2172 6698 +2172 6519 +2172 3914 +2172 6920 +2172 7023 +2172 7784 +2172 7502 +2172 4126 +2172 3863 +2172 8344 +2172 6521 +2172 4955 +2172 8700 +2172 8635 +2172 6814 +2173 7680 +2173 2950 +2173 5129 +2173 4751 +2173 5179 +2173 5650 +2173 3477 +2173 8345 +2173 8096 +2173 6569 +2173 4786 +2173 4532 +2173 6281 +2173 9527 +2173 2902 +2173 8794 +2173 7004 +2173 6755 +2173 7529 +2173 9403 +2173 8180 +2174 7232 +2174 6467 +2174 8901 +2174 9901 +2174 4654 +2174 5330 +2174 4915 +2174 9044 +2174 9334 +2174 6871 +2174 5912 +2174 9199 +2174 5445 +2175 9674 +2175 3169 +2175 6786 +2175 2902 +2175 4545 +2175 3304 +2175 5546 +2175 7564 +2175 8493 +2175 6161 +2175 2258 +2175 6708 +2175 9302 +2175 8413 +2176 9861 +2176 3208 +2176 7441 +2176 8850 +2176 4632 +2176 3360 +2176 6820 +2176 8871 +2176 7980 +2176 2605 +2176 6706 +2176 3004 +2176 2248 +2176 3920 +2176 2769 +2176 5715 +2176 3286 +2176 5862 +2176 8999 +2177 5259 +2177 8335 +2177 7697 +2177 6423 +2177 5921 +2177 7046 +2177 6319 +2177 9904 +2177 5302 +2177 8123 +2177 9282 +2177 3534 +2177 8786 +2177 7396 +2177 5224 +2177 5609 +2177 2286 +2177 2287 +2177 4600 +2178 5058 +2178 4740 +2178 6789 +2178 2187 +2178 3084 +2178 4077 +2178 2861 +2178 4049 +2178 8402 +2178 9876 +2178 9913 +2178 6584 +2178 8452 +2178 2268 +2179 4971 +2179 9868 +2179 6287 +2179 6930 +2179 5143 +2179 3121 +2179 6196 +2179 9020 +2179 6591 +2179 7757 +2179 2901 +2179 8665 +2179 4067 +2179 7019 +2179 8684 +2179 3567 +2179 6006 +2179 3583 +2180 4355 +2180 9350 +2180 4680 +2180 9677 +2180 7055 +2180 2289 +2180 2292 +2180 8670 +2180 8310 +2180 9465 +2180 6170 +2180 2255 +2180 2846 +2181 7936 +2181 3073 +2181 6306 +2181 3076 +2181 8869 +2181 2824 +2181 8425 +2181 6474 +2181 6413 +2181 5263 +2181 3856 +2181 2577 +2181 6658 +2181 2228 +2181 6070 +2181 5572 +2181 6236 +2181 6175 +2182 2563 +2182 7172 +2182 2497 +2182 4238 +2182 9621 +2182 6550 +2182 5271 +2182 4253 +2182 3241 +2182 7929 +2182 3508 +2182 6588 +2182 6205 +2182 6206 +2182 8768 +2182 5057 +2182 4305 +2182 8798 +2182 2400 +2182 6883 +2182 2663 +2182 7402 +2182 9319 +2182 5741 +2182 3700 +2182 8313 +2183 2818 +2183 2819 +2183 3718 +2183 2391 +2183 7437 +2183 3854 +2183 7700 +2183 8469 +2183 7580 +2183 3485 +2183 8101 +2183 4520 +2183 6456 +2183 6844 +2183 9661 +2183 2880 +2183 4675 +2183 6087 +2183 3530 +2183 3023 +2183 6743 +2183 5081 +2183 3035 +2183 2654 +2183 4579 +2183 3058 +2183 7411 +2183 5365 +2184 7361 +2184 2877 +2184 4035 +2184 2852 +2184 5414 +2184 6359 +2184 6642 +2184 6205 +2184 5967 +2184 3487 +2184 2613 +2184 6775 +2184 6009 +2184 7613 +2184 7451 +2184 6815 +2185 7393 +2185 4098 +2185 7077 +2185 8135 +2185 8551 +2185 5932 +2185 8144 +2185 4184 +2185 9266 +2185 4883 +2185 8661 +2185 3191 +2185 5112 +2185 4284 +2185 5413 +2186 3857 +2186 5912 +2186 7966 +2186 9375 +2186 2729 +2186 7472 +2186 5690 +2186 7876 +2186 8389 +2186 6600 +2186 7244 +2186 4942 +2186 9045 +2186 3929 +2186 4826 +2186 4447 +2186 4453 +2186 6119 +2186 5737 +2186 8182 +2187 2824 +2187 3981 +2187 6546 +2187 7452 +2187 2851 +2187 8359 +2187 8239 +2187 4788 +2187 7991 +2187 7894 +2187 9433 +2187 8182 +2187 8171 +2187 4079 +2187 8444 +2188 4784 +2188 9998 +2188 2981 +2188 9767 +2188 4969 +2188 8302 +2188 9102 +2188 9391 +2188 9043 +2188 2935 +2188 4856 +2188 2991 +2189 7676 +2189 2731 +2189 2706 +2189 5200 +2189 7506 +2189 4054 +2189 9656 +2189 2868 +2189 3034 +2189 4891 +2189 2684 +2189 4029 +2189 9477 +2190 2789 +2190 8164 +2190 7302 +2190 6385 +2190 3882 +2190 9644 +2190 9666 +2190 7886 +2190 4719 +2190 7192 +2190 7027 +2190 9140 +2190 3669 +2190 7704 +2190 3802 +2190 9435 +2190 8511 +2191 6944 +2191 3585 +2191 9156 +2191 5415 +2191 2634 +2191 5255 +2191 2417 +2191 8304 +2191 7476 +2191 7063 +2191 3642 +2191 5563 +2191 3836 +2191 9637 +2192 9697 +2192 7651 +2192 2532 +2192 9414 +2192 7411 +2192 6730 +2192 7822 +2192 4499 +2192 2966 +2192 6103 +2192 5987 +2192 4892 +2192 2975 +2193 7552 +2193 2413 +2193 5909 +2193 6175 +2193 2611 +2193 3253 +2193 5727 +2193 2633 +2193 9292 +2193 9552 +2193 8146 +2193 5924 +2193 5210 +2193 6241 +2193 9915 +2193 5479 +2193 4845 +2193 9981 +2193 3581 +2193 9471 +2194 6592 +2194 3649 +2194 4130 +2194 6083 +2194 2770 +2194 3891 +2194 3189 +2194 6584 +2194 3998 +2195 2565 +2195 9363 +2195 8873 +2195 5833 +2195 7992 +2195 6973 +2195 9791 +2195 9801 +2195 5459 +2195 4184 +2195 8666 +2195 9054 +2195 7776 +2195 4711 +2195 3050 +2195 5739 +2195 9718 +2195 2423 +2195 9341 +2196 6779 +2196 7556 +2196 7205 +2196 4008 +2196 5652 +2196 5327 +2196 5713 +2196 7128 +2196 5430 +2196 4182 +2196 5785 +2196 6072 +2196 7065 +2196 3549 +2196 6815 +2196 3741 +2196 7902 +2196 3935 +2197 2816 +2197 6528 +2197 7682 +2197 6920 +2197 8457 +2197 8718 +2197 8347 +2197 9251 +2197 8231 +2197 2602 +2197 8372 +2197 4661 +2197 8758 +2197 9533 +2197 9414 +2197 5476 +2197 5850 +2197 6372 +2197 3693 +2197 3711 +2198 7585 +2198 8164 +2198 8342 +2198 2248 +2198 7722 +2198 9452 +2198 7053 +2198 8431 +2198 7440 +2198 6769 +2198 5042 +2198 7443 +2198 6676 +2198 8030 +2198 5244 +2198 8533 +2199 5857 +2199 9314 +2199 5992 +2199 7051 +2199 4781 +2199 6319 +2199 3731 +2199 5748 +2199 7310 +2199 3193 +2199 9915 +2199 2205 +2200 7184 +2200 7189 +2200 6806 +2200 5271 +2200 4011 +2200 4595 +2200 6709 +2200 5939 +2200 3644 +2200 8757 +2200 4308 +2200 7130 +2200 6498 +2200 7654 +2200 3305 +2200 2801 +2200 6771 +2200 8831 +2201 3617 +2201 9255 +2201 8423 +2201 3947 +2201 5901 +2201 4398 +2201 3441 +2201 9365 +2201 8952 +2201 8569 +2201 7151 +2201 8860 +2201 8734 +2201 3455 +2202 4544 +2202 4617 +2202 4147 +2202 7020 +2202 6895 +2202 7312 +2202 7187 +2202 8373 +2202 6272 +2202 7866 +2202 9626 +2202 8415 +2203 6912 +2203 5633 +2203 5922 +2203 4933 +2203 2268 +2203 2345 +2203 9708 +2203 4877 +2203 2835 +2203 4564 +2203 3317 +2203 5654 +2203 9401 +2203 6298 +2203 9915 +2203 5108 +2204 7381 +2204 9412 +2204 5445 +2204 8999 +2204 7114 +2204 3691 +2204 2642 +2204 9422 +2204 9873 +2204 4946 +2204 5301 +2204 8759 +2204 8253 +2205 4545 +2205 2886 +2205 9873 +2205 5066 +2205 9708 +2205 5826 +2205 6959 +2205 3665 +2205 3602 +2205 4658 +2205 4212 +2205 5300 +2205 9885 +2205 6334 +2205 7688 +2206 8128 +2206 4100 +2206 7070 +2206 3753 +2206 5358 +2206 6609 +2206 8819 +2206 6041 +2206 4955 +2206 9692 +2206 6269 +2206 9054 +2207 4865 +2207 6242 +2207 5699 +2207 4772 +2207 9607 +2207 3785 +2207 7789 +2207 2290 +2207 5827 +2207 5371 +2207 5988 +2207 3547 +2207 6910 +2208 7683 +2208 6502 +2208 2408 +2208 2953 +2208 9866 +2208 4011 +2208 5712 +2208 3048 +2208 4275 +2208 6229 +2208 6614 +2208 3322 +2208 2588 +2208 9237 +2209 8034 +2209 4219 +2209 8039 +2209 5272 +2209 6826 +2209 3215 +2209 6318 +2209 2863 +2209 6417 +2209 8718 +2209 8311 +2209 7128 +2209 4666 +2209 7675 +2209 6554 +2210 4864 +2210 5537 +2210 3202 +2210 3467 +2210 7588 +2210 9837 +2210 8079 +2210 5105 +2210 7860 +2210 2709 +2210 5007 +2210 8781 +2210 7582 +2210 2879 +2211 6277 +2211 3081 +2211 6034 +2211 4375 +2211 8345 +2211 7324 +2211 3102 +2211 8114 +2211 6324 +2211 6537 +2211 6201 +2211 4538 +2211 4673 +2211 9157 +2211 2761 +2211 3021 +2211 5966 +2211 7993 +2211 8158 +2211 2913 +2211 5348 +2211 4590 +2211 8957 +2212 5408 +2212 5757 +2212 7023 +2212 3365 +2212 6321 +2212 3277 +2212 3471 +2212 9648 +2212 8465 +2212 7503 +2212 7285 +2212 4600 +2212 5754 +2212 5341 +2212 8031 +2213 7171 +2213 3590 +2213 3978 +2213 7314 +2213 4628 +2213 2409 +2213 5083 +2213 6821 +2213 5030 +2213 4403 +2213 2230 +2213 4417 +2213 5448 +2213 7755 +2213 5581 +2213 7507 +2213 3031 +2213 8280 +2213 5467 +2213 3806 +2213 6505 +2213 8043 +2213 6674 +2213 2935 +2213 6676 +2214 3616 +2214 6049 +2214 7107 +2214 6789 +2214 4230 +2214 4161 +2214 6665 +2214 6647 +2214 6494 +2214 8070 +2214 8378 +2214 4317 +2214 4254 +2215 5224 +2215 8644 +2215 4966 +2215 7944 +2215 3002 +2215 5725 +2215 2792 +2215 3090 +2215 3162 +2215 6005 +2215 9270 +2215 3076 +2215 6490 +2215 9994 +2215 5405 +2216 4256 +2216 3935 +2216 6209 +2216 9991 +2216 3655 +2216 9070 +2216 7088 +2216 6001 +2216 4659 +2216 9095 +2216 8750 +2216 9279 +2217 2603 +2217 2541 +2217 7275 +2217 3020 +2217 3118 +2217 5423 +2217 8500 +2217 2518 +2217 8023 +2217 7705 +2217 6842 +2217 8315 +2217 5309 +2217 8062 +2218 6791 +2218 7179 +2218 2452 +2218 5783 +2218 3483 +2218 5277 +2218 9631 +2218 6171 +2218 9509 +2218 3629 +2218 8368 +2218 3001 +2218 3023 +2218 8534 +2218 7770 +2218 8667 +2218 9211 +2218 6396 +2218 2687 +2219 8256 +2219 3539 +2219 7015 +2219 5032 +2219 5111 +2219 5102 +2219 8561 +2219 5971 +2219 3988 +2219 4622 +2219 8022 +2219 9687 +2219 5892 +2219 3027 +2219 7967 +2220 6466 +2220 3171 +2220 6948 +2220 3301 +2220 2632 +2220 2859 +2220 4591 +2220 2992 +2220 8370 +2220 8020 +2220 5335 +2220 2959 +2220 4891 +2220 4028 +2220 4805 +2221 7815 +2221 2283 +2221 9430 +2222 5513 +2222 2826 +2222 8075 +2222 8973 +2222 4368 +2222 3481 +2222 4761 +2222 8475 +2222 2723 +2222 4531 +2222 3508 +2222 8631 +2222 5442 +2222 5955 +2222 8266 +2222 6541 +2222 6100 +2222 9049 +2222 4449 +2222 9829 +2222 9191 +2222 4464 +2222 7281 +2223 9089 +2223 4742 +2223 8551 +2223 8589 +2223 9745 +2223 8975 +2223 8163 +2223 5108 +2223 7573 +2223 8248 +2223 4891 +2223 6076 +2223 7775 +2224 4359 +2224 8714 +2224 2316 +2224 4546 +2224 5518 +2224 3604 +2224 8725 +2224 3995 +2224 8990 +2224 9507 +2224 3236 +2224 4395 +2224 2733 +2224 6320 +2224 3102 +2224 5048 +2224 7738 +2224 6594 +2224 8140 +2224 2641 +2224 8033 +2224 4208 +2224 9845 +2224 5012 +2225 3257 +2225 9188 +2225 6438 +2225 7341 +2225 9838 +2225 6671 +2225 8690 +2225 6638 +2225 8082 +2225 8856 +2225 8286 +2225 8741 +2226 3585 +2226 6281 +2226 2572 +2226 6168 +2226 7706 +2226 3101 +2226 4640 +2226 9761 +2226 8873 +2226 8116 +2226 6718 +2226 5184 +2226 7623 +2226 4948 +2226 7125 +2226 8792 +2226 4315 +2226 2803 +2226 5752 +2227 8833 +2227 2574 +2227 3860 +2227 5790 +2227 8609 +2227 6066 +2227 6458 +2227 8252 +2227 5518 +2227 3544 +2227 2649 +2227 3808 +2227 9187 +2227 2663 +2227 3944 +2227 2547 +2227 9467 +2228 5511 +2228 2697 +2228 4626 +2228 5268 +2228 3743 +2228 6694 +2228 8364 +2228 6196 +2228 3265 +2228 4036 +2228 4551 +2228 3032 +2228 5599 +2228 8166 +2228 2536 +2228 5100 +2228 5613 +2228 5488 +2228 6760 +2228 4473 +2228 4218 +2229 9734 +2229 2824 +2229 7827 +2229 8608 +2229 5921 +2229 2466 +2229 6950 +2229 2346 +2229 2461 +2229 8499 +2229 3893 +2229 8633 +2229 7484 +2229 3519 +2229 3655 +2229 5964 +2229 2900 +2229 2778 +2229 8287 +2229 3821 +2229 5487 +2229 9841 +2229 8568 +2229 8830 +2229 4351 +2230 2307 +2230 3076 +2230 8837 +2230 3078 +2230 6036 +2230 8853 +2230 9110 +2230 5404 +2230 5922 +2230 6070 +2230 4030 +2230 2755 +2230 4938 +2230 7516 +2230 7136 +2230 4584 +2230 3956 +2230 3961 +2230 5629 +2231 2308 +2231 3338 +2231 9616 +2231 9126 +2231 9641 +2231 8879 +2231 4788 +2231 3594 +2231 9287 +2231 3916 +2231 6990 +2231 4054 +2231 4312 +2231 3108 +2231 8417 +2231 8358 +2231 3946 +2232 5250 +2232 8251 +2232 3368 +2232 3259 +2232 6605 +2232 5806 +2232 8431 +2232 4976 +2232 3748 +2232 5010 +2232 4019 +2232 4053 +2232 7318 +2232 7992 +2232 9188 +2232 4890 +2232 6459 +2232 7642 +2232 8831 +2233 5024 +2233 3793 +2233 5736 +2233 8202 +2233 4972 +2233 2509 +2233 7121 +2233 6066 +2233 2520 +2234 5920 +2234 5604 +2234 6771 +2234 3399 +2234 3116 +2234 7630 +2234 4242 +2234 5747 +2234 8725 +2234 2902 +2234 4393 +2234 2559 +2234 4021 +2235 7297 +2235 2697 +2235 5388 +2235 2318 +2235 8083 +2235 7385 +2235 8104 +2235 2862 +2235 7100 +2235 2422 +2235 4807 +2235 7112 +2235 8281 +2235 7652 +2235 9957 +2235 9577 +2235 3821 +2235 3570 +2235 4982 +2236 9378 +2236 5923 +2236 6566 +2236 9415 +2236 3593 +2236 5052 +2236 9968 +2236 2292 +2236 3801 +2236 4345 +2236 3610 +2236 8476 +2236 4570 +2237 6500 +2237 8167 +2237 7565 +2237 9360 +2237 2706 +2237 2419 +2237 3476 +2237 2971 +2237 8221 +2237 3349 +2238 5536 +2238 4836 +2238 9414 +2238 2376 +2238 4522 +2238 5131 +2238 2892 +2238 9037 +2238 7088 +2238 6513 +2238 2745 +2238 2907 +2238 9469 +2238 5448 +2239 9378 +2239 9769 +2239 9574 +2239 5354 +2239 3820 +2239 3842 +2239 3087 +2239 5840 +2239 5046 +2239 8183 +2239 8344 +2239 8281 +2239 4815 +2239 7068 +2239 7869 +2240 8481 +2240 3525 +2240 3192 +2240 3809 +2240 7336 +2240 8711 +2240 9940 +2240 9168 +2240 4369 +2240 2612 +2240 4885 +2240 8311 +2240 8920 +2240 7348 +2240 2996 +2240 9013 +2241 7264 +2241 3201 +2241 7490 +2241 5350 +2241 5515 +2241 7255 +2241 8731 +2241 6461 +2242 7781 +2242 5190 +2242 7336 +2242 8524 +2242 8076 +2242 9836 +2242 8269 +2242 7732 +2242 3551 +2243 7552 +2243 7558 +2243 3849 +2243 5137 +2243 8724 +2243 2465 +2243 4002 +2243 3875 +2243 4521 +2243 7083 +2243 8116 +2243 4873 +2243 7995 +2243 7612 +2243 7869 +2243 3649 +2243 4556 +2243 9037 +2243 7886 +2243 8398 +2243 8151 +2243 8155 +2243 7261 +2243 8421 +2243 4881 +2243 5739 +2243 5233 +2243 4086 +2244 9120 +2244 6274 +2244 7459 +2244 3142 +2244 3857 +2244 4224 +2244 2535 +2244 8076 +2244 7952 +2244 5233 +2244 5107 +2244 6644 +2244 6422 +2244 9015 +2244 2712 +2244 7646 +2244 3013 +2245 7170 +2245 7659 +2245 4875 +2245 6673 +2245 2588 +2245 5930 +2245 8754 +2245 4405 +2245 7863 +2245 4280 +2245 6719 +2245 2884 +2245 8012 +2245 8270 +2245 2270 +2245 8676 +2245 3435 +2245 2798 +2245 9075 +2245 7028 +2245 7285 +2245 2428 +2245 7594 +2246 5376 +2246 7303 +2246 9480 +2246 5139 +2246 8477 +2246 7073 +2246 5412 +2246 9510 +2246 2727 +2246 8711 +2246 9135 +2246 6455 +2246 8521 +2246 9163 +2246 8166 +2246 5863 +2246 3564 +2246 7917 +2246 2812 +2246 9341 +2247 9216 +2247 9217 +2247 9230 +2247 5650 +2247 3605 +2247 3095 +2247 8417 +2247 3362 +2247 2469 +2247 6059 +2247 8882 +2247 5050 +2247 4159 +2247 2759 +2247 7241 +2247 3618 +2247 6562 +2247 5845 +2247 6618 +2247 8033 +2247 7522 +2247 6116 +2247 9063 +2247 2549 +2248 8450 +2248 4843 +2248 3821 +2248 7662 +2248 7151 +2248 7633 +2248 4629 +2248 3446 +2248 7387 +2248 7999 +2249 9952 +2249 6277 +2249 7704 +2249 5297 +2249 3816 +2249 8653 +2249 7053 +2249 5608 +2249 7796 +2249 2649 +2249 6744 +2249 6201 +2249 3304 +2250 6272 +2250 9608 +2250 5027 +2250 8328 +2250 9129 +2250 9866 +2250 6989 +2250 7598 +2250 9437 +2250 6928 +2250 3697 +2250 2774 +2250 4852 +2250 3707 +2250 2365 +2251 5318 +2251 9200 +2251 2326 +2251 3235 +2251 9124 +2251 4037 +2251 5513 +2251 4110 +2251 9488 +2251 8934 +2251 8148 +2251 6766 +2251 6454 +2251 6811 +2251 3004 +2251 7134 +2251 7487 +2252 2304 +2252 4228 +2252 5313 +2252 5038 +2252 2968 +2252 3105 +2252 4910 +2252 6321 +2252 6584 +2252 3261 +2252 4929 +2252 8641 +2252 3279 +2252 8915 +2252 8920 +2252 9186 +2252 7011 +2252 8932 +2252 5607 +2252 6889 +2252 7021 +2252 6005 +2252 6505 +2253 9731 +2253 6417 +2253 2711 +2253 7080 +2253 3768 +2253 2489 +2253 3002 +2253 9159 +2253 3938 +2253 5983 +2253 5089 +2253 3426 +2253 7655 +2253 6249 +2253 4598 +2253 5495 +2253 2685 +2254 7820 +2254 2829 +2254 7699 +2254 7061 +2254 9128 +2254 7214 +2254 5180 +2254 6193 +2254 9022 +2254 8143 +2254 7763 +2254 5082 +2254 2255 +2254 6669 +2254 7645 +2254 5730 +2254 9189 +2254 3561 +2254 3051 +2254 5617 +2254 9586 +2254 9875 +2254 7929 +2254 6035 +2255 8448 +2255 8321 +2255 4579 +2255 6401 +2255 5033 +2255 8423 +2255 4588 +2255 4480 +2255 8915 +2255 3211 +2255 4277 +2255 8951 +2255 4186 +2255 4702 +2255 6165 +2256 6019 +2256 9478 +2256 7948 +2256 7056 +2256 7427 +2256 5524 +2256 8867 +2256 6697 +2256 5931 +2256 4211 +2256 6083 +2256 9924 +2256 3542 +2256 8279 +2256 7259 +2256 3429 +2256 5355 +2256 9203 +2257 3104 +2257 9122 +2257 2917 +2257 6306 +2257 7305 +2257 9163 +2257 5901 +2257 6333 +2257 4086 +2257 8348 +2257 7165 +2257 5790 +2258 8896 +2258 2786 +2258 4420 +2258 2513 +2258 7640 +2258 5937 +2258 3070 +2258 5654 +2258 9879 +2258 3832 +2258 8607 +2258 6961 +2258 8958 +2259 5409 +2259 9763 +2259 7621 +2259 7274 +2259 9098 +2259 3837 +2259 4784 +2259 9138 +2259 8755 +2259 7252 +2259 7150 +2259 3102 +2259 3898 +2259 6588 +2259 8357 +2260 2307 +2260 6252 +2260 2672 +2260 8145 +2260 8771 +2260 8566 +2260 5049 +2260 3707 +2260 3484 +2260 5534 +2261 9219 +2261 3557 +2261 5447 +2261 7211 +2261 4780 +2261 8497 +2261 3346 +2261 7609 +2261 9308 +2261 9630 +2261 2853 +2262 2581 +2262 5275 +2262 4258 +2262 6171 +2262 3748 +2262 5575 +2262 9396 +2262 9025 +2262 8902 +2262 4551 +2262 5840 +2262 3044 +2262 6761 +2262 6644 +2262 2683 +2262 6555 +2262 8447 +2263 4064 +2263 5793 +2263 3010 +2263 4004 +2263 4069 +2263 9350 +2263 4658 +2263 5931 +2263 6797 +2263 7344 +2263 7954 +2263 5203 +2263 2585 +2263 8213 +2263 9561 +2263 2464 +2264 8835 +2264 8076 +2264 8003 +2264 6677 +2264 4635 +2264 4637 +2264 6235 +2264 2854 +2264 4012 +2264 9011 +2264 5049 +2264 3537 +2264 4289 +2264 8017 +2264 4537 +2264 9563 +2264 3166 +2264 6497 +2264 4071 +2264 8168 +2264 6770 +2264 4086 +2265 8386 +2265 7012 +2265 9317 +2265 7201 +2265 3850 +2265 2599 +2265 8175 +2265 9114 +2265 5659 +2265 4540 +2265 9726 +2266 9324 +2266 6295 +2266 7822 +2266 3215 +2266 5014 +2266 9892 +2266 4669 +2266 8130 +2266 5453 +2266 5391 +2266 9826 +2266 8419 +2266 3180 +2266 4980 +2267 2432 +2267 2305 +2267 4566 +2267 6161 +2267 8328 +2267 4362 +2267 4352 +2267 2702 +2267 5935 +2267 6526 +2267 6001 +2267 5520 +2267 2963 +2267 2358 +2267 5721 +2267 2268 +2267 3134 +2268 7043 +2268 2310 +2268 2453 +2268 9759 +2268 6944 +2268 2982 +2268 9645 +2268 3634 +2268 6078 +2268 4163 +2268 5575 +2268 5331 +2268 9442 +2268 3050 +2268 7535 +2269 8706 +2269 6372 +2269 4391 +2269 5512 +2269 7305 +2269 4874 +2269 3660 +2269 3746 +2269 5860 +2269 4344 +2269 6873 +2269 9100 +2269 4988 +2269 7253 +2269 2687 +2270 6149 +2270 5079 +2270 8974 +2270 9107 +2270 7191 +2270 5403 +2270 5274 +2270 5795 +2270 2736 +2270 5811 +2270 3231 +2270 8002 +2270 4803 +2270 5968 +2270 4564 +2270 5718 +2270 4567 +2270 7909 +2270 2812 +2271 3040 +2271 8198 +2271 9383 +2271 7898 +2271 7791 +2271 8881 +2271 6169 +2271 3418 +2271 7610 +2271 8766 +2271 5823 +2272 9388 +2272 5680 +2272 8626 +2272 2998 +2272 7736 +2272 9535 +2272 7237 +2272 3277 +2272 8534 +2272 5208 +2272 6501 +2272 5585 +2272 5495 +2272 5369 +2272 2298 +2272 9596 +2272 5245 +2273 4545 +2273 8925 +2273 2982 +2273 3590 +2273 3975 +2273 6248 +2273 3306 +2273 8591 +2273 2678 +2273 4285 +2273 7218 +2273 7924 +2273 3222 +2273 7385 +2273 5336 +2273 8985 +2273 8006 +2274 4352 +2274 7558 +2274 9867 +2274 8717 +2274 5531 +2274 7196 +2274 8754 +2274 9656 +2274 9536 +2274 3019 +2274 7119 +2274 2649 +2274 5085 +2274 4710 +2275 2659 +2275 8296 +2275 3079 +2275 6952 +2275 6215 +2275 7852 +2275 4045 +2275 5998 +2275 3560 +2275 3125 +2275 8606 +2275 5209 +2275 8761 +2275 4311 +2276 8065 +2276 6669 +2276 8195 +2276 9245 +2276 5161 +2276 6173 +2276 9774 +2276 9279 +2276 7232 +2276 5701 +2276 3654 +2276 3911 +2276 7504 +2276 9764 +2276 3035 +2276 5866 +2276 5868 +2276 9584 +2276 6900 +2276 7547 +2276 6140 +2276 8447 +2277 6371 +2277 7206 +2277 7591 +2277 9865 +2277 3853 +2277 5639 +2277 8687 +2277 9073 +2277 2867 +2277 3806 +2277 5753 +2277 5882 +2278 8864 +2278 5376 +2278 6594 +2278 5443 +2278 6276 +2278 5413 +2278 9265 +2278 2508 +2278 9294 +2278 4687 +2278 7184 +2278 2833 +2278 4691 +2278 6167 +2278 9179 +2278 9541 +2279 5603 +2279 4232 +2279 6661 +2279 8454 +2279 2760 +2279 6409 +2279 6666 +2279 2763 +2279 8941 +2279 4143 +2279 9416 +2279 9126 +2279 5127 +2279 7546 +2279 4061 +2280 3984 +2280 6064 +2280 6788 +2280 5348 +2280 6868 +2280 5368 +2280 9220 +2280 7582 +2281 2628 +2281 8301 +2281 5358 +2281 5264 +2281 9074 +2281 8755 +2281 9907 +2281 2980 +2281 5662 +2282 6023 +2282 4236 +2282 8080 +2282 3752 +2282 5434 +2282 3265 +2282 7238 +2282 8782 +2282 5330 +2282 2650 +2282 9443 +2282 3432 +2282 8682 +2282 7545 +2283 6149 +2283 7405 +2283 7317 +2283 7941 +2283 8487 +2283 4648 +2283 9513 +2283 9643 +2283 9743 +2283 3934 +2283 2403 +2283 3816 +2283 5159 +2283 9197 +2283 5230 +2283 5615 +2283 5032 +2283 5880 +2284 7355 +2284 4869 +2284 7782 +2284 9895 +2284 6549 +2284 9867 +2284 7121 +2284 9143 +2284 6740 +2284 7157 +2284 5622 +2284 5687 +2284 4574 +2284 4665 +2284 4538 +2284 6491 +2284 5182 +2284 6789 +2285 5712 +2285 8482 +2285 6666 +2285 8139 +2285 6050 +2285 9294 +2285 8045 +2285 5616 +2285 2641 +2285 3570 +2285 4567 +2285 7608 +2285 9255 +2285 8831 +2285 2527 +2286 6208 +2286 9667 +2286 9637 +2286 9671 +2286 9800 +2286 5769 +2286 5386 +2286 7719 +2286 6061 +2286 6542 +2286 4241 +2286 8050 +2286 8340 +2286 8538 +2286 3867 +2286 4157 +2286 8510 +2287 2952 +2287 6415 +2287 9366 +2287 8987 +2287 7723 +2287 9266 +2287 5556 +2287 7620 +2287 8656 +2287 4438 +2287 2527 +2287 2923 +2287 3694 +2287 3059 +2287 5244 +2288 9570 +2288 3843 +2288 6180 +2288 9126 +2288 6343 +2288 5645 +2288 7933 +2288 7217 +2288 2676 +2288 2840 +2288 9236 +2288 5341 +2289 5996 +2289 7171 +2289 4211 +2289 9000 +2289 6089 +2289 3850 +2289 5676 +2289 4404 +2289 4015 +2289 8337 +2289 2644 +2289 6645 +2289 3417 +2289 5434 +2289 3614 +2289 5727 +2290 8202 +2290 7443 +2290 6168 +2290 7723 +2290 6446 +2290 4401 +2290 6006 +2290 7113 +2290 2509 +2290 6612 +2290 4949 +2290 5343 +2290 7139 +2290 9575 +2290 7527 +2290 5629 +2290 6259 +2290 6902 +2290 8532 +2290 5885 +2291 2896 +2291 8836 +2291 6982 +2291 2856 +2291 4332 +2291 3980 +2291 4142 +2291 3741 +2291 3345 +2291 6781 +2292 8192 +2292 7434 +2292 6317 +2292 9896 +2292 5165 +2292 5568 +2292 2505 +2292 6478 +2292 8656 +2292 6100 +2292 5855 +2292 9959 +2292 8173 +2292 4982 +2292 3704 +2292 8317 +2293 5504 +2293 3203 +2293 3340 +2293 9104 +2293 2579 +2293 7572 +2293 6294 +2293 9753 +2293 3740 +2293 9763 +2293 3117 +2293 9007 +2293 5823 +2293 8784 +2293 5585 +2293 2390 +2293 8536 +2293 3417 +2293 2660 +2293 9972 +2294 6407 +2294 7311 +2294 7189 +2294 8598 +2294 2967 +2294 5402 +2294 2721 +2294 7418 +2294 6711 +2294 3768 +2294 2873 +2294 5316 +2294 9287 +2294 9167 +2294 7261 +2294 9441 +2294 7399 +2294 9194 +2294 4205 +2294 2674 +2294 3450 +2295 5408 +2295 3845 +2295 9286 +2295 5000 +2295 9737 +2295 6314 +2295 3823 +2295 6833 +2295 9394 +2295 5955 +2295 6164 +2295 8085 +2295 3638 +2295 3191 +2295 4316 +2295 3190 +2295 2685 +2295 7909 +2296 4256 +2296 9184 +2296 6114 +2296 8547 +2296 5798 +2296 7708 +2296 3787 +2296 7138 +2296 7345 +2296 7275 +2296 6325 +2296 3437 +2296 7486 +2296 7637 +2297 5391 +2297 3603 +2297 7700 +2297 8854 +2297 4512 +2297 4771 +2297 7976 +2297 9139 +2297 6200 +2297 7615 +2297 3393 +2297 8259 +2297 6343 +2297 8140 +2297 7510 +2297 5082 +2297 2915 +2297 7656 +2297 9967 +2297 3112 +2297 4983 +2298 8835 +2298 6411 +2298 7186 +2298 3990 +2298 5146 +2298 3764 +2298 7096 +2298 5820 +2298 7362 +2298 7748 +2298 7109 +2298 5190 +2298 9680 +2298 9337 +2298 9817 +2298 8794 +2298 7904 +2298 4978 +2298 6393 +2298 9468 +2299 5859 +2299 9524 +2299 6522 +2299 9789 +2299 3665 +2299 8931 +2299 7924 +2299 6230 +2299 3129 +2299 7160 +2299 8762 +2299 6106 +2299 3215 +2299 5839 +2299 6493 +2299 7486 +2300 3363 +2300 9905 +2300 5992 +2300 7019 +2300 8530 +2300 6670 +2300 6632 +2300 3054 +2300 7385 +2300 7992 +2300 3321 +2300 6748 +2300 7357 +2300 6334 +2301 9477 +2301 8719 +2301 9747 +2301 6468 +2301 3483 +2301 8224 +2301 2523 +2301 3495 +2301 3502 +2301 7343 +2301 2752 +2301 6722 +2301 6596 +2301 7877 +2301 7112 +2301 5195 +2301 7628 +2301 5850 +2301 3438 +2301 5871 +2301 7921 +2301 5750 +2301 9722 +2301 7421 +2302 4996 +2302 3093 +2302 4376 +2302 8757 +2302 7482 +2302 4671 +2302 3398 +2302 9814 +2302 9269 +2302 3425 +2302 3049 +2302 3436 +2302 7791 +2302 8306 +2302 8953 +2302 3135 +2302 3964 +2303 6848 +2303 9922 +2303 7462 +2303 4647 +2303 9965 +2303 8399 +2303 5586 +2303 7922 +2303 8502 +2304 9987 +2304 6404 +2304 9451 +2304 2668 +2304 4528 +2304 6548 +2304 7582 +2304 6167 +2304 7064 +2304 7348 +2304 9147 +2304 2814 +2304 9461 +2305 6820 +2305 7080 +2305 6195 +2305 7483 +2305 7746 +2305 5366 +2305 7503 +2305 8403 +2305 3542 +2305 8155 +2305 8925 +2305 8290 +2305 5225 +2305 7530 +2305 6774 +2305 6761 +2305 7290 +2305 4351 +2306 8416 +2306 3872 +2306 5730 +2306 3083 +2306 9128 +2306 6027 +2306 8141 +2306 8245 +2306 6262 +2306 2711 +2306 5848 +2306 3802 +2306 9181 +2306 6398 +2307 6400 +2307 4488 +2307 4245 +2307 4504 +2307 4145 +2307 2367 +2307 5706 +2307 4313 +2307 7900 +2307 9182 +2307 2658 +2307 3429 +2307 2805 +2307 5494 +2307 8148 +2308 4227 +2308 7940 +2308 3981 +2308 9998 +2308 9253 +2308 5549 +2308 6065 +2308 3518 +2308 3659 +2308 2887 +2308 8523 +2308 5966 +2308 3597 +2308 7250 +2308 9952 +2308 2406 +2308 4470 +2308 5119 +2309 3137 +2309 8107 +2309 9701 +2309 3143 +2309 6443 +2309 2777 +2309 9913 +2309 2663 +2309 7195 +2309 4860 +2309 5981 +2310 8672 +2310 3085 +2310 4933 +2310 8074 +2310 6957 +2310 4270 +2310 2991 +2310 5688 +2310 8178 +2310 3958 +2310 8952 +2310 3738 +2310 6309 +2311 4832 +2311 3009 +2311 3778 +2311 5744 +2311 9542 +2311 8769 +2311 5130 +2311 8919 +2311 4046 +2311 8208 +2311 7538 +2311 4149 +2311 5655 +2311 9848 +2311 3802 +2311 4955 +2311 7646 +2312 4704 +2312 7041 +2312 2466 +2312 8993 +2312 5992 +2312 4905 +2312 5895 +2312 4557 +2312 5609 +2312 5756 +2312 8863 +2313 3521 +2313 7267 +2313 3813 +2313 3274 +2313 5903 +2313 3600 +2313 3505 +2313 7666 +2313 7476 +2313 9718 +2313 5145 +2313 8732 +2313 6282 +2314 8609 +2314 7259 +2314 6213 +2314 8618 +2314 3851 +2314 3855 +2314 3153 +2314 6549 +2314 4022 +2314 5615 +2314 2840 +2314 8922 +2314 4603 +2314 5754 +2314 8637 +2314 6078 +2314 3423 +2315 9904 +2315 9251 +2315 3333 +2315 2598 +2315 3400 +2315 7442 +2315 3986 +2315 4301 +2315 5648 +2315 9379 +2315 6162 +2315 5587 +2315 4660 +2315 7257 +2315 3706 +2315 4122 +2315 4766 +2316 5507 +2316 4743 +2316 3342 +2316 4368 +2316 9363 +2316 6582 +2316 6956 +2316 7732 +2316 7862 +2316 5181 +2316 8643 +2316 4293 +2316 6350 +2316 8271 +2316 7438 +2316 4067 +2316 2408 +2316 9711 +2316 4339 +2317 7438 +2317 9378 +2317 3826 +2317 5681 +2317 6452 +2317 5952 +2317 9283 +2317 9162 +2317 5068 +2317 3932 +2317 3948 +2317 3821 +2317 9586 +2317 3704 +2317 7676 +2318 3008 +2318 3041 +2318 9954 +2318 7587 +2318 3846 +2318 6246 +2318 5927 +2318 7304 +2318 7501 +2318 8655 +2318 2897 +2318 8404 +2318 8022 +2318 4052 +2318 3835 +2318 8060 +2319 7812 +2319 6298 +2319 7072 +2319 3108 +2319 6823 +2319 4139 +2319 2865 +2319 7614 +2319 5109 +2319 5826 +2319 9868 +2319 7504 +2319 4561 +2319 8415 +2319 4600 +2319 7546 +2319 5755 +2320 6891 +2320 5230 +2320 7128 +2320 7260 +2320 9565 +2320 6718 +2321 5134 +2321 6928 +2321 6556 +2321 6060 +2321 7599 +2321 9648 +2321 9393 +2321 3443 +2321 3380 +2321 3515 +2321 6131 +2321 8900 +2321 7242 +2321 4044 +2321 6480 +2321 2392 +2321 9310 +2321 2671 +2321 6259 +2321 3832 +2322 5947 +2322 7587 +2322 6116 +2322 4678 +2322 7655 +2322 6596 +2322 6546 +2322 8847 +2322 7824 +2322 5553 +2322 7762 +2322 5524 +2322 5527 +2322 6072 +2322 4685 +2323 8320 +2323 8836 +2323 8201 +2323 3978 +2323 8843 +2323 7198 +2323 8864 +2323 9765 +2323 3496 +2323 9645 +2323 7088 +2323 7730 +2323 4873 +2323 2745 +2323 5066 +2323 4153 +2323 9529 +2323 8423 +2323 6889 +2323 6824 +2323 3827 +2323 4854 +2323 6014 +2324 3972 +2324 4361 +2324 9996 +2324 7055 +2324 5264 +2324 4547 +2324 5908 +2324 5654 +2324 2499 +2324 7367 +2324 3668 +2324 9564 +2324 5733 +2324 9322 +2324 7423 +2325 4678 +2325 7977 +2325 3570 +2325 2962 +2325 5651 +2325 2676 +2325 4280 +2325 8281 +2325 3322 +2325 2651 +2325 6652 +2325 3391 +2326 9349 +2326 4493 +2326 7696 +2326 3015 +2326 8621 +2326 4143 +2326 6967 +2326 5691 +2326 9927 +2326 6728 +2326 9037 +2326 2901 +2326 7899 +2326 5855 +2326 6379 +2326 4211 +2327 3718 +2327 6410 +2327 3857 +2327 4165 +2327 8235 +2327 7090 +2327 8128 +2327 7363 +2327 9541 +2327 4806 +2327 7372 +2327 5197 +2327 9593 +2327 3418 +2327 4963 +2327 8081 +2327 4338 +2327 2422 +2327 4344 +2327 8697 +2328 7044 +2328 8972 +2328 7054 +2328 8387 +2328 8871 +2328 7993 +2328 4666 +2328 9792 +2328 4417 +2328 8131 +2328 4037 +2328 6992 +2328 6740 +2328 4312 +2328 3934 +2328 7538 +2328 3707 +2328 2684 +2329 9344 +2329 4166 +2329 6024 +2329 4013 +2329 2346 +2329 9933 +2329 5167 +2329 6193 +2329 5202 +2329 6966 +2329 6942 +2330 3617 +2330 9475 +2330 4646 +2330 7391 +2330 2983 +2330 7131 +2330 2577 +2330 6869 +2330 4021 +2330 4919 +2330 8667 +2330 3260 +2330 9951 +2331 3648 +2331 3253 +2331 3650 +2331 6501 +2331 6342 +2331 2600 +2331 7241 +2331 9869 +2331 9105 +2331 2645 +2331 2934 +2331 6809 +2331 9816 +2331 8153 +2331 4474 +2331 8866 +2331 2605 +2331 9055 +2332 3971 +2332 4229 +2332 6214 +2332 4272 +2332 6604 +2332 4273 +2332 6292 +2332 9143 +2332 3668 +2332 5499 +2332 2533 +2333 5641 +2333 8083 +2333 9522 +2333 2606 +2333 5170 +2333 8117 +2333 2615 +2333 8889 +2333 4032 +2333 7259 +2333 3299 +2333 3561 +2333 2800 +2333 3059 +2333 2808 +2334 9473 +2334 5639 +2334 6794 +2334 6429 +2334 3882 +2334 6329 +2334 9788 +2334 4554 +2334 6336 +2334 3014 +2334 6087 +2334 7930 +2334 2378 +2334 3662 +2334 9296 +2334 7760 +2334 7802 +2334 9057 +2334 5178 +2334 3412 +2335 7427 +2335 2823 +2335 6285 +2335 8975 +2335 6033 +2335 6039 +2335 9624 +2335 6684 +2335 6960 +2335 9905 +2335 7737 +2335 8461 +2335 7376 +2335 8533 +2335 6878 +2335 8954 +2336 6024 +2336 8726 +2336 2652 +2336 5540 +2336 5929 +2336 6152 +2336 7607 +2336 3128 +2336 5343 +2336 3645 +2336 5950 +2336 3782 +2336 9911 +2336 8780 +2336 2637 +2336 7388 +2336 6245 +2336 5113 +2337 5584 +2337 9698 +2337 4388 +2337 7142 +2337 5314 +2337 8170 +2337 6988 +2337 4034 +2337 5087 +2337 9361 +2337 6613 +2337 4905 +2337 4671 +2338 5507 +2338 9870 +2338 5552 +2338 6450 +2338 8243 +2338 7738 +2338 3138 +2338 5061 +2338 6607 +2338 4048 +2338 7764 +2338 8153 +2338 6363 +2338 6238 +2338 8528 +2338 6633 +2338 9834 +2338 9257 +2339 5568 +2339 7330 +2339 4806 +2339 9354 +2339 8567 +2339 5842 +2339 3536 +2339 3573 +2339 5913 +2339 2648 +2339 9856 +2339 5371 +2339 2485 +2340 7043 +2340 2445 +2340 7696 +2340 7327 +2340 9909 +2340 4535 +2340 6713 +2340 6845 +2340 8128 +2340 6857 +2340 2508 +2340 6748 +2340 7390 +2340 5347 +2340 7272 +2340 4204 +2340 8565 +2340 6399 +2341 4738 +2341 4059 +2341 6342 +2341 9289 +2341 3434 +2341 2347 +2341 9004 +2341 8258 +2341 7920 +2341 5429 +2341 5886 +2341 7035 +2341 6782 +2341 8574 +2342 8865 +2342 4931 +2342 2887 +2342 9192 +2342 8396 +2342 2599 +2342 7073 +2342 5552 +2342 9507 +2342 6836 +2342 3413 +2342 8476 +2342 4892 +2342 3962 +2342 4927 +2343 7042 +2343 9358 +2343 7322 +2343 2848 +2343 2722 +2343 4011 +2343 6070 +2343 7735 +2343 4153 +2343 4045 +2343 8284 +2343 2525 +2343 5611 +2343 6892 +2343 5360 +2343 9842 +2343 3704 +2343 9338 +2343 8447 +2343 9852 +2343 7039 +2344 4739 +2344 4229 +2344 3846 +2344 3368 +2344 5549 +2344 5432 +2344 5436 +2344 9151 +2344 8132 +2344 3014 +2344 7378 +2344 3598 +2344 3291 +2344 5087 +2344 3174 +2344 7662 +2344 4852 +2345 2601 +2345 6631 +2345 5036 +2345 4269 +2345 3954 +2345 7955 +2345 9876 +2345 8372 +2345 2973 +2345 5278 +2346 7577 +2346 8528 +2346 6020 +2346 9637 +2346 8423 +2346 5832 +2346 3561 +2346 4527 +2346 7850 +2346 8494 +2346 5668 +2346 7792 +2346 6105 +2346 6902 +2346 4505 +2346 9914 +2346 3611 +2346 8477 +2347 9090 +2347 8580 +2347 5394 +2347 6419 +2347 4758 +2347 5144 +2347 5039 +2347 6433 +2347 6441 +2347 6049 +2347 4853 +2347 6595 +2347 5025 +2347 6354 +2347 2520 +2347 5344 +2347 8037 +2347 3306 +2347 8609 +2347 8051 +2347 6014 +2348 8288 +2348 2757 +2348 7336 +2348 7633 +2348 4495 +2348 8613 +2349 2880 +2349 3101 +2349 3215 +2349 9692 +2349 6764 +2349 4083 +2349 2863 +2349 3939 +2349 4686 +2349 3803 +2349 3453 +2349 5695 +2350 8644 +2350 3717 +2350 9419 +2350 5422 +2350 9876 +2350 4516 +2350 3002 +2350 6715 +2350 8734 +2351 4615 +2351 5913 +2351 7334 +2351 9907 +2351 5942 +2351 9015 +2351 5184 +2351 8137 +2351 2743 +2351 3916 +2351 9175 +2351 6747 +2351 6237 +2351 4963 +2351 8550 +2351 7401 +2351 7536 +2351 3574 +2351 7799 +2351 6776 +2352 2704 +2352 7691 +2352 9957 +2352 2630 +2352 9249 +2352 5194 +2352 4491 +2352 7469 +2352 3568 +2352 5362 +2352 7936 +2352 6520 +2352 4986 +2352 5054 +2353 7256 +2353 9315 +2353 6596 +2353 8615 +2353 9160 +2353 4428 +2353 3249 +2353 7507 +2353 2548 +2353 9911 +2353 6488 +2353 2969 +2353 7323 +2353 2557 +2354 2566 +2354 7181 +2354 2711 +2354 8611 +2354 9131 +2354 7228 +2354 2879 +2354 9815 +2354 4712 +2354 9065 +2354 5354 +2354 6632 +2354 2931 +2354 6394 +2354 7548 +2355 3680 +2355 6119 +2355 3276 +2355 9267 +2355 7255 +2356 4742 +2356 3208 +2356 7305 +2356 3341 +2356 3733 +2356 4764 +2356 7718 +2356 5165 +2356 9390 +2356 3504 +2356 6006 +2356 8521 +2356 7890 +2356 3287 +2356 9822 +2356 8933 +2356 2659 +2356 5477 +2356 4841 +2356 8819 +2356 4597 +2356 7414 +2356 2554 +2357 3545 +2357 9054 +2357 3014 +2357 9608 +2357 8988 +2357 6474 +2357 5757 +2357 3227 +2357 9653 +2357 3127 +2357 3320 +2357 8921 +2357 8826 +2357 5401 +2357 9050 +2357 3646 +2358 4868 +2358 7302 +2358 5289 +2358 9136 +2358 6329 +2358 8124 +2358 8776 +2358 2634 +2358 2391 +2358 7768 +2358 7645 +2358 9060 +2358 3948 +2358 9841 +2358 9458 +2359 6048 +2359 8929 +2359 2947 +2359 6280 +2359 8810 +2359 7051 +2359 9328 +2359 9265 +2359 7858 +2359 3030 +2359 7006 +2360 2944 +2360 5761 +2360 6151 +2360 8462 +2360 5138 +2360 4130 +2360 6949 +2360 9767 +2360 5293 +2360 7110 +2360 7757 +2360 4304 +2360 9301 +2360 6245 +2360 8934 +2360 6898 +2360 6391 +2360 8828 +2360 3581 +2361 5664 +2361 5537 +2361 9702 +2361 7751 +2361 8873 +2361 3050 +2361 8300 +2361 9929 +2361 5392 +2361 8306 +2361 2484 +2361 4592 +2361 3465 +2361 5787 +2361 4604 +2361 4149 +2362 5570 +2362 7747 +2362 8199 +2362 7339 +2362 9932 +2362 9392 +2362 3252 +2362 9689 +2362 5912 +2362 9876 +2362 3711 +2362 7806 +2362 6686 +2362 2815 +2363 3585 +2363 9411 +2363 6344 +2363 4042 +2363 9932 +2363 6765 +2363 3086 +2363 4701 +2363 7696 +2363 6903 +2363 9720 +2363 7514 +2363 8957 +2364 4673 +2364 3875 +2364 9110 +2364 8646 +2364 5009 +2364 6092 +2364 6130 +2364 7119 +2364 8240 +2364 6106 +2364 3158 +2364 9400 +2364 5945 +2364 6394 +2364 8093 +2365 7521 +2365 4291 +2365 3284 +2365 7625 +2365 3271 +2365 4754 +2365 6255 +2365 5714 +2365 3635 +2365 4052 +2365 9886 +2365 4507 +2365 6716 +2365 6463 +2366 6126 +2366 4683 +2366 5039 +2366 7625 +2366 9626 +2366 2781 +2366 6719 +2367 3588 +2367 6182 +2367 9479 +2367 6154 +2367 8306 +2367 4238 +2367 4356 +2367 6641 +2367 3733 +2367 3833 +2367 4923 +2368 5125 +2368 9995 +2368 5645 +2368 7313 +2368 8340 +2368 7452 +2368 7709 +2368 5953 +2368 5698 +2368 4166 +2368 9419 +2368 8653 +2368 4062 +2368 5734 +2368 4582 +2368 5741 +2368 9599 +2369 2534 +2369 3977 +2369 8432 +2369 2707 +2369 3796 +2369 9621 +2369 4884 +2369 5914 +2370 8449 +2370 6658 +2370 3980 +2370 6040 +2370 8600 +2370 5915 +2370 6056 +2370 3633 +2370 9652 +2370 2869 +2370 8886 +2370 3402 +2370 2765 +2370 4067 +2370 5223 +2370 8949 +2370 3963 +2371 8800 +2371 9667 +2371 6045 +2371 6028 +2371 7755 +2371 5004 +2371 6381 +2371 4464 +2371 6201 +2371 4506 +2371 6938 +2371 7615 +2372 9441 +2372 5893 +2372 5416 +2372 9486 +2372 4335 +2372 9011 +2372 5818 +2372 5983 +2372 5661 +2372 2654 +2373 4739 +2373 2454 +2373 2967 +2373 8312 +2373 4005 +2373 3878 +2373 6187 +2373 2477 +2373 6702 +2373 3648 +2373 8518 +2373 9416 +2373 4558 +2373 7416 +2373 3288 +2373 9561 +2373 9308 +2373 9381 +2373 8165 +2373 7144 +2373 2797 +2373 9960 +2373 8948 +2374 5538 +2374 9493 +2374 8135 +2374 6632 +2374 3017 +2374 3084 +2374 4627 +2374 2398 +2374 6326 +2374 5497 +2374 5951 +2374 3068 +2374 6686 +2375 8213 +2375 4759 +2375 4889 +2375 3870 +2375 8483 +2375 5809 +2375 4638 +2375 8890 +2375 6459 +2375 4924 +2375 7235 +2375 3014 +2375 8273 +2375 6229 +2375 9942 +2375 3938 +2375 9445 +2375 8948 +2375 5368 +2375 3580 +2376 2464 +2376 6912 +2376 2755 +2376 6110 +2376 9575 +2376 9416 +2376 3954 +2376 5870 +2376 7921 +2376 5816 +2376 4040 +2376 6968 +2376 8874 +2377 2717 +2377 7234 +2377 9412 +2377 7846 +2377 8967 +2377 6887 +2377 6831 +2377 5325 +2377 9875 +2377 4666 +2377 6205 +2378 7883 +2378 8520 +2378 6505 +2378 4555 +2378 7400 +2378 7285 +2378 2647 +2378 8069 +2378 7327 +2378 9061 +2379 4512 +2379 4805 +2379 2421 +2379 6216 +2379 8425 +2379 6807 +2379 5932 +2379 3821 +2379 4782 +2379 4637 +2379 7308 +2379 3571 +2379 3636 +2379 6677 +2379 3065 +2379 4834 +2379 3355 +2379 4413 +2379 6143 +2380 8355 +2380 8164 +2380 6821 +2380 9577 +2380 3371 +2380 9262 +2380 6800 +2380 7217 +2380 8788 +2380 7381 +2380 6505 +2380 5401 +2380 7871 +2380 6174 +2380 3349 +2381 5723 +2381 3771 +2381 5641 +2381 2893 +2381 6447 +2381 4083 +2381 8965 +2381 4183 +2381 6010 +2381 4795 +2381 4159 +2382 4163 +2382 6435 +2382 5462 +2382 2887 +2382 7527 +2382 6547 +2382 8047 +2382 9139 +2382 4377 +2382 5949 +2383 4816 +2383 7588 +2383 5106 +2383 3151 +2383 9840 +2383 3864 +2383 8274 +2383 6835 +2383 3960 +2384 2863 +2384 6760 +2384 6476 +2384 2544 +2384 9145 +2384 4467 +2384 4884 +2384 9144 +2384 6233 +2384 3962 +2384 4059 +2384 4348 +2384 8212 +2384 9919 +2385 5184 +2385 9732 +2385 6098 +2385 4200 +2385 5516 +2385 9357 +2385 6768 +2385 3375 +2385 5682 +2385 6898 +2385 9309 +2385 6943 +2386 3101 +2386 9517 +2386 6397 +2386 5201 +2386 8051 +2386 5780 +2386 2453 +2386 7355 +2386 4666 +2387 5953 +2387 9828 +2387 4902 +2387 8865 +2387 3310 +2387 7599 +2387 4913 +2387 5524 +2387 2517 +2387 4726 +2387 9848 +2387 4764 +2387 9886 +2387 3007 +2388 4998 +2388 3214 +2388 7963 +2388 9758 +2388 3103 +2388 4001 +2388 3255 +2388 6332 +2388 3138 +2388 6476 +2388 5710 +2388 2770 +2388 5724 +2388 7141 +2388 3260 +2388 9962 +2388 4203 +2388 8062 +2389 7812 +2389 8134 +2389 3559 +2389 9290 +2389 2695 +2389 9405 +2389 7250 +2389 7987 +2389 4500 +2389 7931 +2389 5939 +2389 6555 +2389 8924 +2389 3997 +2389 5374 +2390 3713 +2390 4646 +2390 2919 +2390 4936 +2390 3049 +2390 5546 +2390 8332 +2390 7896 +2390 7510 +2390 5209 +2390 8249 +2390 5971 +2390 9917 +2391 7936 +2391 6555 +2391 8869 +2391 2633 +2391 9898 +2391 5070 +2391 3920 +2391 6746 +2391 9819 +2391 9242 +2391 7359 +2392 4867 +2392 6408 +2392 8330 +2392 3723 +2392 8718 +2392 3750 +2392 5953 +2392 2892 +2392 5584 +2392 8554 +2392 5483 +2392 2924 +2392 6011 +2392 8575 +2393 7046 +2393 4619 +2393 8716 +2393 5136 +2393 9877 +2393 8986 +2393 2461 +2393 7481 +2393 6331 +2393 5314 +2393 3405 +2393 7505 +2393 8532 +2393 8543 +2393 5856 +2393 4071 +2393 8685 +2393 6645 +2393 9979 +2393 9983 +2394 5441 +2394 8578 +2394 9955 +2394 8997 +2394 7175 +2394 5932 +2394 3982 +2394 6789 +2394 7874 +2394 3615 +2394 5663 +2395 8456 +2395 9581 +2395 7824 +2395 3221 +2395 2987 +2395 5055 +2395 3904 +2395 6048 +2395 8530 +2395 3801 +2395 4450 +2395 3685 +2395 2538 +2395 3181 +2395 9504 +2395 9457 +2395 6138 +2395 8574 +2395 4095 +2396 2842 +2396 7963 +2396 7582 +2396 7073 +2396 4009 +2396 6315 +2396 6702 +2396 9271 +2396 8390 +2396 6348 +2396 5068 +2396 8406 +2396 9180 +2396 6879 +2396 8167 +2396 7027 +2396 5242 +2397 6433 +2397 7202 +2397 4955 +2397 3046 +2397 3585 +2397 9096 +2397 9290 +2397 6379 +2397 7084 +2397 7949 +2397 3950 +2397 8851 +2397 6100 +2397 3031 +2397 7608 +2397 2811 +2397 4316 +2397 6654 +2398 3642 +2398 4839 +2398 6571 +2398 6157 +2398 4462 +2398 6650 +2398 5564 +2398 4026 +2398 9726 +2398 7871 +2399 9728 +2399 9699 +2399 3302 +2399 6088 +2399 3561 +2399 6064 +2399 6539 +2399 4333 +2399 5264 +2399 3080 +2399 9780 +2399 8885 +2399 6998 +2399 8952 +2399 8484 +2400 2852 +2400 3738 +2400 9615 +2400 6289 +2400 9339 +2400 6679 +2400 4024 +2400 5017 +2400 6395 +2400 2711 +2401 5122 +2401 9307 +2401 6431 +2401 3399 +2401 5179 +2401 5676 +2401 9133 +2401 6861 +2401 4497 +2401 7988 +2401 9653 +2401 2935 +2401 6491 +2402 3830 +2402 8517 +2402 7560 +2402 8233 +2402 4496 +2402 8529 +2402 3519 +2402 9596 +2402 6853 +2403 5985 +2403 3938 +2403 6151 +2403 7915 +2403 7490 +2403 4271 +2403 7730 +2403 3955 +2403 4455 +2403 9013 +2403 2649 +2403 7864 +2403 4601 +2403 6821 +2404 7136 +2404 7170 +2404 9123 +2404 8022 +2404 4209 +2404 7338 +2404 7050 +2404 2928 +2404 9971 +2404 6550 +2404 4281 +2404 7352 +2404 7087 +2404 7805 +2404 8837 +2405 2913 +2405 8902 +2405 7817 +2405 5609 +2405 7914 +2405 8075 +2405 5485 +2405 3214 +2405 9213 +2405 9296 +2405 6385 +2405 6675 +2405 8393 +2405 8728 +2405 4187 +2405 7836 +2405 5322 +2405 3006 +2406 4256 +2406 2432 +2406 2694 +2406 9199 +2406 9453 +2406 3214 +2406 9709 +2406 6832 +2406 8210 +2406 8728 +2406 5369 +2406 8957 +2407 5569 +2407 6948 +2407 5640 +2407 8048 +2407 3983 +2407 3568 +2407 3147 +2407 9396 +2407 2788 +2407 9208 +2407 2847 +2407 7068 +2407 3709 +2407 9151 +2408 3971 +2408 9355 +2408 6545 +2408 8222 +2408 3952 +2408 9771 +2408 2732 +2408 4831 +2408 6846 +2408 6605 +2408 6623 +2408 3301 +2408 3089 +2408 2806 +2408 3069 +2409 4097 +2409 8836 +2409 5649 +2409 8979 +2409 6949 +2409 7334 +2409 8874 +2409 6574 +2409 2617 +2409 5439 +2409 7158 +2409 9799 +2409 4177 +2409 7779 +2409 7911 +2409 5353 +2409 3178 +2409 8429 +2409 8511 +2410 6340 +2410 4679 +2410 2894 +2410 8090 +2411 2766 +2411 3883 +2411 3592 +2411 8139 +2411 8460 +2411 3758 +2411 8701 +2411 4107 +2411 6546 +2411 5972 +2411 8238 +2411 2825 +2411 6906 +2411 9611 +2411 4189 +2412 7232 +2412 4038 +2412 3878 +2412 8393 +2412 3759 +2412 4081 +2412 4916 +2412 3766 +2412 8297 +2412 2811 +2412 9566 +2412 8805 +2413 2565 +2413 3846 +2413 7047 +2413 3860 +2413 7960 +2413 6816 +2413 3369 +2413 9902 +2413 7234 +2413 6855 +2413 5582 +2413 9687 +2413 9562 +2413 9715 +2413 3574 +2413 9463 +2413 7956 +2413 6907 +2413 4733 +2414 7938 +2414 9989 +2414 9871 +2414 2628 +2414 5160 +2414 9397 +2414 8891 +2414 9790 +2414 7093 +2414 4171 +2414 4292 +2414 3915 +2414 7757 +2414 7892 +2414 8406 +2414 3160 +2414 4947 +2414 6395 +2414 5735 +2414 9065 +2414 4595 +2414 5495 +2414 8059 +2414 9084 +2415 8450 +2415 6805 +2415 8734 +2415 3232 +2415 7203 +2415 9649 +2415 2622 +2415 8644 +2415 6134 +2415 6470 +2415 9949 +2415 9954 +2415 9064 +2415 7276 +2415 8694 +2415 3710 +2416 8226 +2416 8867 +2416 8677 +2416 4134 +2416 2537 +2416 9391 +2416 6893 +2416 2735 +2416 9393 +2416 5091 +2416 6350 +2416 5047 +2416 4217 +2416 2970 +2416 3061 +2416 4263 +2416 4094 +2416 8053 +2417 5200 +2417 3396 +2417 6566 +2417 3431 +2417 5132 +2417 8847 +2417 5104 +2417 2741 +2417 4660 +2417 8233 +2417 5500 +2417 4090 +2417 4687 +2417 5884 +2418 3905 +2418 7915 +2418 6564 +2418 4613 +2418 8326 +2418 8041 +2418 7563 +2418 6094 +2418 2927 +2418 8916 +2418 7287 +2418 8345 +2419 7649 +2419 5659 +2419 4262 +2419 9102 +2419 3112 +2419 5034 +2419 2955 +2419 3630 +2419 8687 +2419 7474 +2419 2965 +2419 3773 +2420 4354 +2420 4228 +2420 8845 +2420 5654 +2420 7172 +2420 6175 +2420 7072 +2420 6946 +2420 8744 +2420 6582 +2420 8387 +2420 4690 +2420 3547 +2420 5852 +2420 3169 +2420 7146 +2420 9451 +2420 6269 +2420 3327 +2421 9666 +2421 8079 +2421 7462 +2421 5389 +2421 4718 +2421 6863 +2421 9427 +2421 3765 +2421 8854 +2421 4388 +2421 7003 +2422 7392 +2422 5442 +2422 8868 +2422 7781 +2422 5753 +2422 2794 +2422 4813 +2422 9871 +2422 5686 +2422 6071 +2422 9716 +2422 8516 +2422 4589 +2422 7341 +2422 5727 +2423 8259 +2423 8163 +2423 9221 +2423 9190 +2423 7931 +2423 4360 +2423 5737 +2423 6570 +2423 3085 +2423 5229 +2423 3154 +2423 6740 +2423 5206 +2423 4505 +2423 5211 +2423 9375 +2424 4930 +2424 4552 +2424 6460 +2424 3464 +2424 6928 +2424 2642 +2424 7319 +2424 3704 +2424 9625 +2424 4540 +2425 7819 +2425 3972 +2425 4680 +2425 9387 +2425 5836 +2425 2575 +2425 3960 +2425 6803 +2425 3645 +2425 8727 +2425 7448 +2425 3891 +2425 7162 +2426 4736 +2426 4225 +2426 7176 +2426 8576 +2426 2580 +2426 6173 +2426 5422 +2426 4405 +2426 7991 +2426 9672 +2426 5456 +2426 4692 +2426 3032 +2426 3934 +2426 4837 +2426 7892 +2427 8451 +2427 5765 +2427 9352 +2427 5517 +2427 5653 +2427 5125 +2427 4385 +2427 6954 +2427 8255 +2427 9940 +2427 2779 +2427 2781 +2427 8162 +2427 3830 +2428 4929 +2428 5649 +2428 6930 +2428 6805 +2428 7193 +2428 9370 +2428 5540 +2428 7346 +2428 9523 +2428 7989 +2428 3255 +2428 4543 +2428 4032 +2428 6337 +2428 3142 +2428 3151 +2428 6099 +2428 6692 +2428 3813 +2428 2666 +2428 3566 +2428 5487 +2428 4982 +2428 6264 +2428 9469 +2429 9826 +2429 5419 +2429 6052 +2429 4553 +2429 9607 +2429 4973 +2429 5745 +2429 2788 +2429 3162 +2429 3874 +2430 6785 +2430 8721 +2430 9880 +2430 7449 +2430 4769 +2430 5926 +2430 3111 +2430 4533 +2430 3513 +2430 2876 +2430 4289 +2430 5314 +2430 5196 +2430 7764 +2430 6329 +2430 4312 +2430 3707 +2430 8936 +2430 3561 +2430 2811 +2430 5802 +2431 8739 +2431 6459 +2431 6486 +2431 3722 +2431 3183 +2431 2736 +2431 9905 +2431 2707 +2431 8374 +2431 4728 +2431 7003 +2431 5364 +2432 4239 +2432 5635 +2432 2825 +2432 8906 +2432 7116 +2432 8157 +2432 9373 +2432 3346 +2432 3702 +2432 7933 +2432 9190 +2432 7196 +2432 9501 +2433 5257 +2433 9741 +2433 2833 +2433 8338 +2433 8220 +2433 6945 +2433 4523 +2433 4652 +2433 9648 +2433 2611 +2433 7605 +2433 5816 +2433 8508 +2433 2503 +2433 3277 +2433 5586 +2433 8275 +2433 2904 +2433 9691 +2433 5052 +2433 3707 +2434 6626 +2434 9156 +2434 6313 +2434 9578 +2434 9419 +2434 6032 +2434 7058 +2434 2740 +2434 9476 +2434 6234 +2434 5149 +2434 6175 +2435 4834 +2435 4899 +2435 3878 +2435 7689 +2435 3946 +2435 6348 +2435 7507 +2435 3379 +2435 8053 +2435 7785 +2435 9851 +2435 5978 +2435 6139 +2435 8947 +2435 8917 +2436 7392 +2436 9893 +2436 2823 +2436 6664 +2436 6839 +2436 6318 +2436 3701 +2436 8469 +2436 3350 +2436 8825 +2436 7608 +2436 3417 +2436 9690 +2436 3989 +2436 4254 +2436 7647 +2437 7041 +2437 5762 +2437 3723 +2437 9229 +2437 8334 +2437 6040 +2437 2846 +2437 5283 +2437 6694 +2437 6572 +2437 9649 +2437 9397 +2437 6341 +2437 4300 +2437 4052 +2437 5983 +2437 8803 +2437 6517 +2437 9151 +2437 6527 +2438 3523 +2438 5029 +2438 5295 +2438 6728 +2438 5450 +2438 9867 +2438 8716 +2438 6866 +2438 4239 +2438 5715 +2438 6387 +2438 2740 +2438 5371 +2438 9247 +2439 4353 +2439 8130 +2439 7747 +2439 2692 +2439 5055 +2439 2598 +2439 5383 +2439 6057 +2439 5707 +2439 7375 +2439 3121 +2439 5455 +2439 5243 +2439 7657 +2439 4250 +2439 4796 +2439 2687 +2440 7328 +2440 4129 +2440 5156 +2440 7781 +2440 9084 +2440 5419 +2440 3948 +2440 5101 +2440 9469 +2440 8752 +2440 8922 +2440 3513 +2440 6905 +2440 6778 +2440 9349 +2441 3011 +2441 8324 +2441 2501 +2441 8646 +2441 8202 +2441 5361 +2441 8626 +2441 4020 +2441 8632 +2441 4740 +2441 4634 +2441 7610 +2442 6153 +2442 6668 +2442 7309 +2442 7828 +2442 4251 +2442 3740 +2442 3754 +2442 2737 +2442 3766 +2442 2503 +2442 7371 +2442 8270 +2442 6224 +2442 5710 +2442 3549 +2442 4066 +2442 6262 +2442 4884 +2443 9479 +2443 6050 +2443 6790 +2443 3494 +2443 4264 +2443 3119 +2443 9384 +2443 4210 +2443 9193 +2443 8372 +2443 9557 +2443 4055 +2443 8188 +2443 7871 +2444 5904 +2444 5448 +2444 4012 +2444 8207 +2444 5000 +2444 4117 +2444 6488 +2444 2713 +2444 6328 +2444 3644 +2444 3706 +2445 8576 +2445 3491 +2445 6372 +2445 4101 +2445 3046 +2445 3340 +2445 8237 +2445 2959 +2445 8312 +2445 4021 +2445 4086 +2445 6104 +2445 7133 +2446 5376 +2446 4769 +2446 4460 +2446 7427 +2446 5692 +2446 4488 +2446 8876 +2446 9964 +2446 6465 +2446 6888 +2446 9044 +2446 7734 +2446 6873 +2446 3162 +2446 6972 +2446 3613 +2447 3301 +2447 3492 +2447 6309 +2447 8550 +2447 2472 +2447 6793 +2447 6990 +2447 8835 +2447 8726 +2447 8539 +2447 8380 +2447 6814 +2447 3845 +2448 5891 +2448 5031 +2448 3272 +2448 8043 +2448 6988 +2448 4813 +2448 6644 +2448 4789 +2448 8790 +2448 4632 +2448 2971 +2448 7871 +2449 3905 +2449 8258 +2449 4483 +2449 4260 +2449 3803 +2449 8968 +2449 3379 +2449 6442 +2449 7663 +2449 6865 +2449 3667 +2449 8720 +2449 6555 +2449 7326 +2450 8448 +2450 3720 +2450 5642 +2450 8334 +2450 9879 +2450 4634 +2450 9562 +2450 9765 +2450 6951 +2450 8105 +2450 7082 +2450 9900 +2450 7854 +2450 8880 +2450 8456 +2450 5556 +2450 3512 +2450 2622 +2450 5568 +2450 7386 +2450 3547 +2450 4831 +2450 6874 +2450 6311 +2451 5602 +2451 6411 +2451 6724 +2451 8649 +2451 8203 +2451 8652 +2451 7659 +2451 5957 +2451 3484 +2451 7743 +2452 3172 +2452 9989 +2452 6566 +2452 4263 +2452 9356 +2452 4431 +2452 7280 +2452 9233 +2452 7700 +2452 7481 +2452 8411 +2452 7146 +2452 3134 +2453 3457 +2453 3591 +2453 8072 +2453 9488 +2453 9491 +2453 2977 +2453 9003 +2453 5678 +2453 3123 +2453 7739 +2453 3137 +2453 7492 +2453 8518 +2453 2649 +2453 4058 +2453 8667 +2453 9446 +2453 4074 +2453 6512 +2453 5501 +2454 4545 +2454 6051 +2454 4262 +2454 6908 +2454 9131 +2454 4077 +2454 5661 +2454 8311 +2454 5905 +2454 7909 +2454 6932 +2454 8600 +2454 4793 +2454 5183 +2454 9052 +2454 7741 +2454 8958 +2454 9439 +2455 2692 +2455 6406 +2455 6231 +2455 6804 +2455 8646 +2455 8105 +2455 7083 +2455 5811 +2455 4023 +2455 6460 +2455 8774 +2455 5072 +2455 4827 +2455 8286 +2455 9253 +2455 7904 +2455 5948 +2455 5355 +2455 9618 +2455 6905 +2455 3066 +2455 9212 +2456 9986 +2456 7046 +2456 3463 +2456 8843 +2456 8211 +2456 3864 +2456 4906 +2456 7134 +2456 6711 +2456 9144 +2456 6717 +2456 6748 +2456 5342 +2456 7519 +2456 4064 +2456 9062 +2456 9197 +2456 9454 +2456 5105 +2456 7286 +2456 7799 +2457 9379 +2457 6631 +2457 5896 +2457 9257 +2457 3146 +2457 6802 +2457 5083 +2457 4336 +2457 9208 +2457 3442 +2457 7124 +2457 6709 +2457 5334 +2457 7032 +2457 6105 +2457 3226 +2457 9692 +2457 6474 +2457 8597 +2458 4033 +2458 6794 +2458 8358 +2458 2858 +2458 7470 +2458 3701 +2458 3065 +2458 3931 +2458 8924 +2458 3946 +2458 5311 +2459 2503 +2459 5097 +2459 9226 +2459 3063 +2459 7821 +2459 7895 +2459 5549 +2459 7223 +2459 8472 +2459 6393 +2459 7383 +2460 4354 +2460 3337 +2460 8778 +2460 9483 +2460 6323 +2460 2868 +2460 4819 +2460 3416 +2460 4860 +2461 3473 +2461 5404 +2461 6941 +2461 9258 +2461 3500 +2461 7986 +2461 6194 +2461 5044 +2461 4214 +2461 4680 +2461 4169 +2461 4813 +2461 8413 +2461 4836 +2461 9334 +2461 8059 +2461 7082 +2462 9665 +2462 8161 +2462 8143 +2462 9153 +2462 9708 +2462 3341 +2462 2638 +2462 7952 +2462 8275 +2462 4310 +2462 8571 +2462 3775 +2463 6147 +2463 9604 +2463 3702 +2463 5544 +2463 8427 +2463 9554 +2463 8941 +2463 9742 +2463 8401 +2463 5458 +2463 2996 +2463 3766 +2463 3481 +2463 4541 +2464 5825 +2464 4548 +2464 6918 +2464 4744 +2464 9961 +2464 5866 +2464 7735 +2464 8749 +2464 4498 +2464 3023 +2464 8946 +2464 2836 +2464 4501 +2464 3446 +2464 7876 +2464 6907 +2464 4126 +2465 8048 +2465 3080 +2465 4688 +2465 8626 +2465 4723 +2465 8723 +2465 9278 +2466 9088 +2466 3720 +2466 5513 +2466 5775 +2466 5909 +2466 8095 +2466 4649 +2466 4652 +2466 6664 +2466 6580 +2466 5047 +2466 9424 +2466 7634 +2466 3925 +2466 6230 +2466 7777 +2466 4582 +2466 5673 +2467 4207 +2467 5007 +2467 4079 +2467 9778 +2467 3764 +2467 8377 +2467 8250 +2467 7356 +2467 4669 +2467 7490 +2467 6602 +2467 4025 +2467 2525 +2467 3044 +2467 7275 +2467 9199 +2467 3444 +2468 7298 +2468 7557 +2468 8723 +2468 5017 +2468 3241 +2468 6698 +2468 4530 +2468 4277 +2468 7865 +2468 9291 +2468 7627 +2468 8268 +2468 9208 +2468 5589 +2468 5341 +2468 5600 +2468 9957 +2468 6630 +2468 2897 +2468 3691 +2468 7288 +2468 5371 +2468 3196 +2469 7424 +2469 5696 +2469 4355 +2469 3045 +2469 3671 +2469 7008 +2469 5358 +2469 3249 +2469 6033 +2469 5463 +2469 7223 +2469 4158 +2469 7135 +2470 3457 +2470 3841 +2470 8584 +2470 9355 +2470 9621 +2470 8474 +2470 7326 +2470 6815 +2470 7978 +2470 2866 +2470 6197 +2470 7350 +2470 9922 +2470 3907 +2470 6610 +2470 6631 +2470 3304 +2470 3059 +2470 8700 +2471 4576 +2471 5088 +2471 7235 +2471 3016 +2471 2954 +2471 5930 +2471 4333 +2471 7389 +2471 4899 +2471 9812 +2471 3093 +2471 8633 +2471 9239 +2471 4633 +2471 4061 +2471 4477 +2471 2933 +2472 4064 +2472 3906 +2472 3601 +2472 5980 +2472 8714 +2472 5452 +2472 4653 +2472 5233 +2472 5970 +2472 2515 +2472 9726 +2472 7254 +2472 5532 +2472 7102 +2473 5504 +2473 6276 +2473 6405 +2473 8198 +2473 5137 +2473 9618 +2473 3734 +2473 3868 +2473 8224 +2473 5282 +2473 3891 +2473 8885 +2473 7355 +2473 8523 +2473 9952 +2473 3428 +2473 8171 +2473 4220 +2474 6242 +2474 5283 +2474 3206 +2474 7462 +2474 5867 +2474 2792 +2474 3019 +2474 3340 +2474 2733 +2474 2958 +2474 7504 +2474 8402 +2474 6087 +2474 4828 +2474 5533 +2474 5278 +2475 4416 +2475 9160 +2475 5419 +2475 5709 +2475 6993 +2475 7220 +2475 4886 +2475 9272 +2475 5562 +2475 2875 +2476 5514 +2476 2575 +2476 2583 +2476 5937 +2476 5302 +2476 3642 +2476 5430 +2476 5318 +2476 9290 +2476 7504 +2476 5335 +2476 6759 +2476 6640 +2476 9080 +2476 7548 +2476 3453 +2477 6939 +2477 7325 +2477 8358 +2477 4521 +2477 3627 +2477 6444 +2477 4662 +2477 7100 +2477 4157 +2477 6594 +2477 9289 +2477 3791 +2477 4576 +2477 4577 +2477 8805 +2477 6972 +2477 4156 +2477 4462 +2477 2802 +2477 6646 +2477 4137 +2478 8578 +2478 7163 +2478 5397 +2478 9890 +2478 5412 +2478 5294 +2478 4912 +2478 9905 +2478 7359 +2478 9665 +2478 3149 +2478 4429 +2478 6353 +2478 6226 +2478 2637 +2478 3037 +2478 3039 +2478 5627 +2478 6758 +2478 7015 +2478 3560 +2478 6761 +2478 5994 +2478 7501 +2478 8622 +2478 8442 +2478 8443 +2479 5761 +2479 3715 +2479 4104 +2479 4750 +2479 6416 +2479 5932 +2479 8494 +2479 4412 +2479 3389 +2479 3520 +2479 8517 +2479 8520 +2479 8662 +2479 7639 +2479 8419 +2479 3307 +2479 6893 +2479 3763 +2479 7036 +2480 8454 +2480 6209 +2480 7692 +2480 6419 +2480 4886 +2480 9753 +2480 7207 +2480 5801 +2480 3548 +2480 2659 +2480 7910 +2480 9064 +2480 7146 +2480 4978 +2480 4988 +2481 6209 +2481 6043 +2481 5381 +2481 6052 +2481 4456 +2481 9554 +2481 5298 +2481 7789 +2481 6536 +2481 3733 +2481 5494 +2481 8346 +2481 5857 +2481 8154 +2481 7058 +2481 2655 +2482 4353 +2482 7681 +2482 5522 +2482 6166 +2482 3095 +2482 3103 +2482 6816 +2482 4327 +2482 4642 +2482 5156 +2482 7858 +2482 4274 +2482 9400 +2482 7865 +2482 9679 +2482 4689 +2482 6095 +2482 7007 +2482 6499 +2482 3051 +2482 6508 +2482 3956 +2482 3831 +2482 7675 +2483 7168 +2483 4705 +2483 6768 +2483 4424 +2483 3821 +2483 7248 +2483 5938 +2483 6037 +2483 4759 +2483 3673 +2484 5999 +2484 4230 +2484 5386 +2484 5806 +2484 2671 +2484 7472 +2484 7953 +2484 8008 +2484 7641 +2484 7262 +2485 9219 +2485 5125 +2485 3207 +2485 4883 +2485 5403 +2485 5668 +2485 9253 +2485 8744 +2485 2733 +2485 6579 +2485 5308 +2485 8767 +2485 8897 +2485 7389 +2485 7262 +2485 8566 +2485 4218 +2486 9441 +2486 5960 +2486 9319 +2486 4396 +2486 8623 +2486 9601 +2486 8381 +2486 6643 +2486 3485 +2486 9374 +2486 5087 +2487 7936 +2487 3106 +2487 4453 +2487 3143 +2487 8679 +2487 5104 +2487 5862 +2487 9179 +2487 4191 +2488 2721 +2488 8802 +2488 9604 +2488 4990 +2488 8743 +2488 9994 +2488 5323 +2488 6864 +2488 9173 +2488 5275 +2488 6429 +2488 9406 +2489 8962 +2489 7046 +2489 4393 +2489 8874 +2489 5547 +2489 8845 +2489 8849 +2489 6226 +2489 9523 +2489 5494 +2489 8216 +2489 8667 +2489 5340 +2490 3106 +2490 6395 +2490 3312 +2490 3480 +2490 7699 +2490 7071 +2491 9536 +2491 6788 +2491 8743 +2491 9632 +2491 4685 +2491 6386 +2491 8135 +2491 6264 +2491 2753 +2491 7295 +2491 7393 +2492 8340 +2492 6425 +2492 9123 +2492 5540 +2492 8366 +2492 9391 +2492 6322 +2492 5300 +2492 5301 +2492 5182 +2492 9152 +2492 6857 +2492 7760 +2492 3681 +2492 7018 +2492 3947 +2492 9069 +2492 8821 +2492 2878 +2493 3844 +2493 3596 +2493 5007 +2493 9379 +2493 8999 +2493 6314 +2493 8252 +2493 9918 +2493 8139 +2493 9286 +2493 4937 +2493 4810 +2493 5963 +2493 7642 +2493 9321 +2493 6101 +2494 9452 +2494 7179 +2494 4877 +2494 4845 +2494 4887 +2494 3736 +2494 9249 +2494 8740 +2494 2524 +2494 5162 +2494 5678 +2494 8756 +2494 4703 +2494 4572 +2494 4956 +2494 8415 +2494 5474 +2494 7272 +2494 9833 +2494 4716 +2494 3181 +2495 7046 +2495 8734 +2495 3890 +2495 4016 +2495 4658 +2495 6454 +2495 4286 +2495 7362 +2495 3536 +2495 9425 +2495 8536 +2495 8411 +2495 4560 +2495 7525 +2495 5862 +2495 5351 +2495 8948 +2495 6718 +2496 6336 +2496 7361 +2496 3428 +2496 8966 +2496 4321 +2496 2920 +2496 7434 +2496 8332 +2496 2798 +2496 7185 +2496 6738 +2496 3065 +2496 8703 +2496 6105 +2496 6842 +2496 7391 +2496 3196 +2496 7294 +2497 5706 +2497 8144 +2497 8114 +2497 7449 +2497 8861 +2497 6718 +2497 8997 +2498 7430 +2498 3465 +2498 7957 +2498 7748 +2498 3484 +2498 9886 +2498 3492 +2498 3371 +2498 9022 +2498 7743 +2498 4801 +2498 5316 +2498 2895 +2498 7895 +2498 3673 +2498 7385 +2498 3173 +2498 3443 +2498 5239 +2498 6141 +2499 8833 +2499 9986 +2499 3079 +2499 9098 +2499 5776 +2499 4889 +2499 3243 +2499 4783 +2499 4528 +2499 6452 +2499 8379 +2499 7120 +2499 4313 +2499 3932 +2499 6878 +2499 8805 +2499 4454 +2499 6631 +2499 7156 +2499 2964 +2499 5758 +2500 8832 +2500 5121 +2500 8579 +2500 3334 +2500 8839 +2500 4234 +2500 5654 +2500 3999 +2500 6709 +2500 9281 +2500 8392 +2500 6114 +2500 2514 +2500 7766 +2500 6360 +2500 3553 +2500 5858 +2500 4205 +2500 2550 +2500 9849 +2501 5916 +2501 2956 +2501 9869 +2501 9872 +2501 5907 +2501 3994 +2501 3996 +2501 3036 +2501 6078 +2501 3022 +2501 6227 +2501 8662 +2501 3292 +2501 3561 +2501 4973 +2501 3192 +2501 3194 +2502 4487 +2502 7313 +2502 5655 +2502 3625 +2502 9644 +2502 2862 +2502 3764 +2502 4032 +2502 5829 +2502 8409 +2502 7130 +2502 5470 +2502 4579 +2502 2919 +2502 5868 +2502 5741 +2502 6768 +2502 8442 +2503 6532 +2503 2702 +2503 5523 +2503 8863 +2503 6437 +2503 8235 +2503 7213 +2503 2990 +2503 7618 +2503 6213 +2503 5449 +2503 2783 +2503 4968 +2503 6397 +2503 6646 +2503 3837 +2504 2688 +2504 9353 +2504 3979 +2504 9371 +2504 8604 +2504 5405 +2504 7324 +2504 6729 +2504 3286 +2504 6749 +2504 8805 +2504 7667 +2504 5497 +2504 6911 +2505 5697 +2505 7675 +2505 3429 +2505 6758 +2505 4235 +2505 9961 +2505 5579 +2505 3244 +2505 9294 +2505 3151 +2505 9855 +2505 9878 +2505 5817 +2505 4628 +2505 5689 +2505 3355 +2505 8188 +2505 7135 +2506 5764 +2506 3878 +2506 6543 +2506 7468 +2506 5357 +2506 3822 +2506 8079 +2506 3601 +2506 6866 +2506 7379 +2506 3060 +2506 9711 +2506 7341 +2506 8318 +2506 2975 +2507 3972 +2507 5381 +2507 3096 +2507 7451 +2507 8224 +2507 8225 +2507 7461 +2507 8362 +2507 8110 +2507 6325 +2507 6199 +2507 2874 +2507 7227 +2507 7743 +2507 4418 +2507 7122 +2507 5716 +2507 4833 +2507 3053 +2507 6134 +2508 2976 +2508 4902 +2508 5834 +2508 9962 +2508 3479 +2508 3597 +2508 9910 +2508 4211 +2508 9332 +2508 7926 +2508 7511 +2508 8952 +2508 6268 +2508 4522 +2509 2658 +2509 3011 +2509 3236 +2509 3974 +2509 3752 +2509 4206 +2509 3986 +2509 3907 +2509 7385 +2509 8437 +2509 5791 +2509 6397 +2509 8350 +2510 5275 +2510 9508 +2510 4005 +2510 2735 +2510 4541 +2510 9152 +2510 9540 +2510 6991 +2510 2896 +2510 2644 +2510 7016 +2510 6634 +2510 8424 +2510 6136 +2510 8276 +2510 5757 +2511 8975 +2511 3909 +2511 4129 +2511 4770 +2511 6694 +2511 6824 +2511 6215 +2511 7470 +2511 9009 +2511 7992 +2511 5434 +2511 7199 +2511 8003 +2511 6599 +2511 4187 +2511 9955 +2511 5105 +2512 8768 +2512 8705 +2512 4066 +2512 8291 +2512 5541 +2512 2982 +2512 7655 +2512 5667 +2512 7610 +2512 9296 +2512 3123 +2512 6902 +2512 3386 +2512 4287 +2512 9107 +2512 3304 +2512 6526 +2513 5757 +2513 8930 +2513 5221 +2513 8296 +2513 6249 +2513 9853 +2513 5534 +2513 7927 +2513 6872 +2513 5881 +2513 8506 +2513 3743 +2513 5628 +2513 6047 +2514 7303 +2514 6544 +2514 8601 +2514 5918 +2514 6689 +2514 6954 +2514 6963 +2514 9951 +2514 9415 +2514 9308 +2514 9054 +2514 7394 +2514 3173 +2514 3690 +2514 3696 +2514 4211 +2514 2940 +2515 7137 +2515 8674 +2515 6756 +2515 2695 +2515 8809 +2515 8490 +2515 3166 +2515 3182 +2515 5552 +2515 5043 +2515 9982 +2515 4888 +2515 6430 +2516 5312 +2516 7819 +2516 4225 +2516 5512 +2516 2889 +2516 9131 +2516 7340 +2516 9293 +2516 4557 +2516 4304 +2516 6289 +2516 9269 +2516 3286 +2516 6231 +2516 5690 +2516 8538 +2517 3233 +2517 6851 +2517 6661 +2517 3238 +2517 3201 +2517 5288 +2517 6057 +2517 8683 +2517 4211 +2517 2965 +2517 6230 +2517 4681 +2517 3859 +2517 7450 +2517 3818 +2517 8351 +2518 5408 +2518 3969 +2518 7588 +2518 4781 +2518 4514 +2518 6357 +2518 5402 +2518 9693 +2518 2805 +2519 4256 +2519 7363 +2519 5315 +2519 2811 +2519 5544 +2519 8498 +2519 7683 +2519 3323 +2519 4181 +2519 8566 +2519 9140 +2519 7515 +2519 3227 +2519 5086 +2520 9345 +2520 7650 +2520 8771 +2520 6765 +2520 4751 +2520 4050 +2520 6551 +2520 5935 +2520 8635 +2520 6044 +2520 4441 +2521 3931 +2521 2992 +2521 2577 +2521 8819 +2521 5454 +2521 5806 +2521 8887 +2521 5364 +2522 6016 +2522 3138 +2522 2723 +2522 3574 +2522 5149 +2522 8590 +2522 6895 +2522 5392 +2522 4882 +2522 3477 +2522 6134 +2522 9879 +2522 3343 +2522 8509 +2523 5253 +2523 9345 +2523 3381 +2523 4923 +2523 3020 +2523 5550 +2523 5437 +2523 3344 +2523 6805 +2523 3830 +2523 2714 +2523 9983 +2524 7938 +2524 6666 +2524 9364 +2524 8737 +2524 4004 +2524 9399 +2524 3004 +2524 2626 +2524 3780 +2524 9819 +2524 3932 +2524 7137 +2524 8546 +2524 3954 +2524 9335 +2525 3457 +2525 3337 +2525 8090 +2525 5152 +2525 4642 +2525 6179 +2525 8102 +2525 8237 +2525 6587 +2525 8005 +2525 9680 +2525 7254 +2525 9564 +2525 5087 +2525 4458 +2525 4883 +2526 4608 +2526 4932 +2526 9254 +2526 5340 +2526 4843 +2526 6158 +2526 9716 +2526 6677 +2526 3190 +2526 5048 +2526 5433 +2526 9530 +2526 6236 +2526 6749 +2526 9791 +2527 7431 +2527 6155 +2527 8718 +2527 3949 +2527 5395 +2527 8985 +2527 2974 +2527 3205 +2527 5292 +2527 6840 +2527 5344 +2527 9035 +2527 2901 +2527 7512 +2527 7002 +2527 3548 +2527 4061 +2527 3296 +2527 5346 +2527 7920 +2527 6131 +2527 9727 +2528 3968 +2528 6025 +2528 2829 +2528 4125 +2528 5662 +2528 4208 +2528 4527 +2528 9911 +2528 3513 +2528 5303 +2528 3411 +2528 6106 +2528 6758 +2528 4845 +2528 6768 +2528 2808 +2528 9084 +2528 5886 +2529 9348 +2529 3593 +2529 7564 +2529 2969 +2529 6170 +2529 6172 +2529 5409 +2529 8866 +2529 7982 +2529 9536 +2529 8771 +2529 4108 +2529 7035 +2529 4045 +2529 8278 +2529 9315 +2529 9068 +2529 4091 +2530 6448 +2530 2594 +2530 2789 +2530 7121 +2530 5596 +2530 7533 +2530 2734 +2530 8173 +2530 7473 +2530 8279 +2530 8856 +2530 4346 +2530 6075 +2530 6140 +2531 8736 +2531 8747 +2531 6375 +2531 8552 +2531 9033 +2531 6987 +2531 6828 +2531 8881 +2531 4446 +2531 7928 +2531 4442 +2531 9116 +2531 6906 +2531 8391 +2531 5823 +2532 8578 +2532 7657 +2532 3956 +2532 9041 +2532 6440 +2532 7177 +2532 9261 +2532 5230 +2532 4403 +2532 9812 +2532 9572 +2532 7355 +2533 2691 +2533 8198 +2533 7050 +2533 5645 +2533 7789 +2533 8848 +2533 3098 +2533 7963 +2533 7586 +2533 7470 +2533 5040 +2533 2994 +2533 3636 +2533 9788 +2533 9535 +2533 7233 +2533 9541 +2533 6731 +2533 2594 +2533 3408 +2533 8785 +2533 4701 +2533 7760 +2533 8419 +2533 7151 +2533 9709 +2533 8559 +2534 3967 +2534 8453 +2534 7910 +2534 9336 +2534 8759 +2534 5452 +2534 3149 +2534 8177 +2534 5108 +2534 3574 +2534 8375 +2534 2552 +2534 7705 +2534 4063 +2534 9756 +2535 9228 +2535 8462 +2535 5523 +2535 6427 +2535 8733 +2535 5931 +2535 6447 +2535 5936 +2535 4402 +2535 6713 +2535 9785 +2535 4967 +2535 6504 +2535 8560 +2535 6514 +2535 4348 +2536 3458 +2536 6412 +2536 5141 +2536 4251 +2536 3622 +2536 9385 +2536 5292 +2536 6958 +2536 2886 +2536 8909 +2536 4046 +2536 5455 +2536 6737 +2536 3797 +2536 9706 +2536 9580 +2536 7420 +2536 4223 +2537 9481 +2537 6027 +2537 9233 +2537 9243 +2537 7324 +2537 8605 +2537 7454 +2537 9123 +2537 5924 +2537 6321 +2537 8889 +2537 7360 +2537 9928 +2537 8280 +2537 3811 +2537 9700 +2537 8810 +2537 7282 +2537 8051 +2537 7671 +2538 6848 +2538 9819 +2538 8485 +2538 5254 +2538 4145 +2538 9000 +2538 9001 +2538 9354 +2538 6640 +2538 3208 +2538 8954 +2538 2554 +2538 7998 +2539 3200 +2539 8933 +2539 4437 +2539 6889 +2539 5643 +2539 5000 +2539 4723 +2539 7317 +2539 2743 +2539 5593 +2540 6500 +2540 7772 +2540 3769 +2540 3527 +2540 4548 +2540 7823 +2540 7473 +2540 5170 +2540 9943 +2540 5656 +2540 6660 +2540 5242 +2540 9551 +2540 4510 +2541 3808 +2541 6497 +2541 4515 +2541 8484 +2541 4264 +2541 9096 +2541 5609 +2541 2700 +2541 4370 +2541 9743 +2541 5842 +2541 3896 +2541 9444 +2541 6930 +2541 6719 +2542 4993 +2542 3747 +2542 5412 +2542 7749 +2542 4102 +2542 3368 +2542 5546 +2542 8011 +2542 8812 +2542 2717 +2542 4627 +2542 6199 +2542 5664 +2542 8604 +2542 9405 +2542 7358 +2543 3940 +2543 7334 +2543 8702 +2543 8039 +2543 8840 +2543 9995 +2543 4909 +2543 6223 +2543 2960 +2543 7667 +2543 6900 +2543 7742 +2543 9614 +2543 4574 +2543 5017 +2543 4637 +2543 5662 +2544 9473 +2544 8726 +2544 3346 +2544 3862 +2544 2728 +2544 2996 +2544 7101 +2544 9034 +2544 2895 +2544 6739 +2544 7504 +2544 2662 +2544 7284 +2544 7033 +2544 4989 +2544 6654 +2545 3362 +2545 3109 +2545 7004 +2545 4778 +2545 6611 +2545 7090 +2545 8979 +2545 2803 +2545 9530 +2545 4315 +2545 5372 +2546 5570 +2546 7979 +2546 6501 +2546 7270 +2546 8433 +2546 4523 +2546 9967 +2546 8944 +2546 8419 +2546 7307 +2546 9527 +2546 6751 +2546 6205 +2546 4863 +2547 2828 +2547 4749 +2547 5007 +2547 3345 +2547 7317 +2547 4246 +2547 2853 +2547 6328 +2547 8249 +2547 9548 +2547 8012 +2547 8407 +2547 5596 +2547 4065 +2547 8039 +2547 3306 +2547 8555 +2547 4207 +2547 2800 +2548 8737 +2548 7297 +2548 6984 +2548 6063 +2548 8340 +2548 3285 +2548 4374 +2548 9231 +2548 7743 +2549 7432 +2549 5131 +2549 3596 +2549 3478 +2549 4249 +2549 6946 +2549 6705 +2549 7480 +2549 6859 +2549 5068 +2549 4686 +2549 3667 +2549 9560 +2549 6236 +2549 3825 +2549 6516 +2550 9633 +2550 9067 +2550 7222 +2550 3243 +2550 3343 +2550 6253 +2550 9507 +2550 6101 +2550 6867 +2550 3460 +2550 6911 +2550 8092 +2550 9885 +2550 8543 +2551 4258 +2551 7043 +2551 8296 +2551 2601 +2551 4170 +2551 5507 +2551 8114 +2551 3983 +2551 5490 +2551 9108 +2551 2926 +2551 6298 +2551 7706 +2551 7725 +2552 4619 +2552 8643 +2552 6342 +2552 8231 +2552 3082 +2552 3243 +2552 6478 +2552 5752 +2552 8814 +2552 5110 +2552 5751 +2552 6744 +2552 6554 +2552 2620 +2552 6359 +2553 4863 +2553 3270 +2553 4197 +2553 5958 +2553 8137 +2553 6732 +2553 4174 +2553 2802 +2553 9493 +2553 5047 +2553 3615 +2553 6073 +2553 9242 +2553 3325 +2554 6388 +2554 6562 +2554 8259 +2554 5092 +2554 7143 +2554 7436 +2554 9716 +2554 2638 +2554 9168 +2554 7610 +2554 3964 +2554 3266 +2555 9218 +2555 9609 +2555 6801 +2555 7452 +2555 3744 +2555 6562 +2555 5469 +2555 5172 +2555 3001 +2555 3258 +2555 4924 +2555 7370 +2555 7502 +2555 9565 +2555 9709 +2555 7410 +2555 4851 +2555 9978 +2555 5373 +2556 7075 +2556 9412 +2556 7052 +2556 7821 +2556 7534 +2556 3919 +2556 6577 +2556 5714 +2556 2743 +2556 5813 +2556 5374 +2556 7039 +2557 4965 +2557 3306 +2557 5042 +2557 9168 +2557 7764 +2557 7422 +2558 3708 +2558 6307 +2558 6812 +2558 8074 +2558 7533 +2558 6465 +2558 3312 +2558 4056 +2558 4577 +2558 9525 +2558 5976 +2558 9208 +2558 9946 +2558 3548 +2559 6017 +2559 4515 +2559 9220 +2559 7749 +2559 6536 +2559 8983 +2559 5874 +2559 6799 +2559 3953 +2559 8310 +2559 2615 +2559 3897 +2560 4192 +2560 2785 +2560 4610 +2560 5603 +2560 7535 +2560 4069 +2560 3120 +2560 8586 +2560 9134 +2560 6397 +2560 5872 +2560 6419 +2560 8362 +2560 2586 +2560 9375 +2560 4058 +2560 3454 +2560 8479 +2561 7488 +2561 9894 +2561 5660 +2561 4810 +2561 6604 +2561 4494 +2561 3601 +2561 8211 +2561 9268 +2561 5590 +2561 6392 +2561 6964 +2561 4474 +2561 4860 +2561 9342 +2561 7525 +2562 3596 +2562 5005 +2562 2834 +2562 6428 +2562 6815 +2562 3239 +2562 6061 +2562 4526 +2562 8243 +2562 9524 +2562 9787 +2562 5316 +2562 5453 +2562 3413 +2562 7772 +2562 4667 +2562 7274 +2562 5232 +2562 6644 +2562 9208 +2562 8442 +2562 4091 +2562 2686 +2563 6401 +2563 6913 +2563 3082 +2563 8335 +2563 8210 +2563 3620 +2563 3206 +2563 9255 +2563 6321 +2563 7091 +2563 2746 +2563 2885 +2563 5704 +2563 9935 +2563 4949 +2563 4695 +2563 7263 +2563 5223 +2563 9064 +2563 7789 +2563 9714 +2563 8440 +2564 8176 +2564 7853 +2564 7720 +2564 4976 +2564 9547 +2564 2668 +2564 6733 +2564 6957 +2564 6736 +2564 3987 +2564 9365 +2564 3451 +2564 8156 +2564 9354 +2564 7562 +2564 3967 +2565 3009 +2565 2850 +2565 8419 +2565 4929 +2565 3434 +2565 3627 +2565 2701 +2565 4601 +2565 5114 +2565 8859 +2565 7774 +2565 2682 +2566 4228 +2566 3849 +2566 7820 +2566 5652 +2566 3607 +2566 5145 +2566 5151 +2566 3107 +2566 6025 +2566 3131 +2566 7365 +2566 9163 +2566 4308 +2566 9813 +2566 9825 +2566 6645 +2566 4601 +2567 6944 +2567 9953 +2567 8388 +2567 5861 +2567 4001 +2567 8168 +2567 6569 +2567 7499 +2567 7001 +2567 8847 +2567 4786 +2567 7669 +2567 7369 +2567 6872 +2567 7785 +2567 6597 +2568 6881 +2568 2626 +2568 5509 +2568 8033 +2568 7850 +2568 3310 +2568 3503 +2568 6640 +2568 4023 +2568 3609 +2568 3963 +2568 4925 +2569 3969 +2569 6786 +2569 9228 +2569 6417 +2569 5522 +2569 8085 +2569 9882 +2569 2726 +2569 7743 +2569 9793 +2569 4680 +2569 7507 +2569 6870 +2569 4827 +2569 9821 +2569 4576 +2569 9442 +2569 8677 +2569 4200 +2569 9193 +2569 8172 +2569 4847 +2569 6001 +2569 3958 +2569 5246 +2570 8962 +2570 9991 +2570 3906 +2570 9872 +2570 3605 +2570 6679 +2570 3613 +2570 5922 +2570 8750 +2570 8115 +2570 5813 +2570 2998 +2570 5045 +2570 5046 +2570 8141 +2570 7247 +2570 5850 +2570 9180 +2570 8420 +2570 3953 +2570 4084 +2571 9985 +2571 4747 +2571 7316 +2571 7066 +2571 6683 +2571 7330 +2571 6822 +2571 4016 +2571 8970 +2571 4670 +2571 4927 +2571 3789 +2571 3790 +2571 4687 +2571 6745 +2571 7389 +2571 8160 +2571 9187 +2571 6438 +2571 5884 +2571 8058 +2571 4860 +2572 3040 +2572 7875 +2572 3110 +2572 5063 +2572 8105 +2572 5589 +2572 8043 +2572 5805 +2572 3217 +2572 7811 +2572 8149 +2572 8568 +2572 3292 +2572 5151 +2573 8066 +2573 4293 +2573 4743 +2573 4169 +2573 8266 +2573 9611 +2573 3791 +2573 8920 +2573 5430 +2573 8183 +2573 7224 +2573 5748 +2573 5519 +2573 8933 +2574 9922 +2574 3880 +2574 9641 +2574 8458 +2574 7852 +2574 5550 +2574 5041 +2574 8978 +2574 8820 +2574 4474 +2574 6026 +2574 7658 +2574 7007 +2575 2944 +2575 3073 +2575 4228 +2575 3587 +2575 6728 +2575 5225 +2575 3595 +2575 4366 +2575 2802 +2575 5716 +2575 3130 +2575 3514 +2575 6462 +2576 6368 +2576 5157 +2576 7082 +2576 4523 +2576 6860 +2576 3917 +2576 3830 +2576 2994 +2576 6004 +2576 3414 +2576 4984 +2576 2818 +2576 6139 +2576 6364 +2576 3222 +2577 4610 +2577 2694 +2577 7055 +2577 8080 +2577 4754 +2577 3734 +2577 9495 +2577 6054 +2577 7848 +2577 6068 +2577 9028 +2577 7110 +2577 6090 +2577 4051 +2577 7770 +2577 5903 +2577 8336 +2577 4841 +2577 3314 +2577 4725 +2577 5755 +2578 6254 +2578 4504 +2578 8604 +2578 3464 +2578 6589 +2578 8004 +2578 5061 +2578 8393 +2578 7755 +2578 8407 +2578 5721 +2578 8539 +2578 2908 +2578 8315 +2578 8171 +2578 4332 +2578 6510 +2578 8176 +2579 4353 +2579 2695 +2579 7307 +2579 6925 +2579 7313 +2579 3476 +2579 8471 +2579 3864 +2579 4890 +2579 7461 +2579 4780 +2579 3245 +2579 4285 +2579 3647 +2579 3784 +2579 2646 +2579 8284 +2579 4701 +2579 2920 +2579 8047 +2579 6641 +2579 6677 +2580 8289 +2580 5622 +2580 4038 +2580 8661 +2580 5866 +2580 5605 +2580 3212 +2580 5361 +2580 3348 +2580 7829 +2580 8950 +2580 5813 +2580 3134 +2581 7819 +2581 7568 +2581 2710 +2581 4247 +2581 9759 +2581 6949 +2581 6183 +2581 8110 +2581 9273 +2581 4670 +2581 7879 +2581 7243 +2581 4300 +2581 5837 +2581 3929 +2581 9953 +2581 3303 +2581 3816 +2581 3820 +2581 7923 +2581 8510 +2581 9336 +2581 7550 +2582 8196 +2582 7192 +2582 5534 +2582 7584 +2582 7843 +2582 3493 +2582 3496 +2582 8156 +2582 8109 +2582 7733 +2582 4417 +2582 8392 +2582 9801 +2582 3021 +2582 4577 +2582 2662 +2582 4712 +2582 4589 +2582 5032 +2582 6115 +2583 5760 +2583 5132 +2583 4749 +2583 4250 +2583 6044 +2583 8606 +2583 9764 +2583 8487 +2583 9516 +2583 6320 +2583 2782 +2583 5689 +2583 3258 +2583 5309 +2583 4670 +2583 9569 +2583 4559 +2583 9433 +2583 3934 +2583 4193 +2583 2788 +2584 7174 +2584 4513 +2584 5795 +2584 7141 +2584 3304 +2584 3305 +2584 8905 +2584 4427 +2584 6761 +2584 6231 +2584 6268 +2584 8115 +2584 4410 +2584 5258 +2584 8261 +2585 6177 +2585 4034 +2585 6273 +2585 4615 +2585 8471 +2585 3468 +2585 8724 +2585 7311 +2585 6352 +2585 9588 +2585 7767 +2585 7063 +2586 7563 +2586 3596 +2586 9616 +2586 9751 +2586 9500 +2586 5418 +2586 6061 +2586 6191 +2586 5918 +2586 8893 +2586 8510 +2586 8278 +2586 6620 +2586 6115 +2586 3312 +2586 6772 +2586 3711 +2587 9152 +2587 7619 +2587 7238 +2587 9703 +2587 3823 +2587 8271 +2587 7665 +2587 4024 +2587 7225 +2587 5531 +2587 4734 +2587 9215 +2588 5255 +2588 4873 +2588 6925 +2588 8723 +2588 4130 +2588 3497 +2588 2872 +2588 4039 +2588 4171 +2588 5841 +2588 7383 +2588 5616 +2588 3057 +2588 5235 +2588 9214 +2589 4768 +2589 4164 +2589 9253 +2589 6397 +2589 2864 +2589 8913 +2589 9875 +2589 6852 +2589 3319 +2589 3929 +2589 6897 +2589 4700 +2589 8413 +2589 4295 +2589 8703 +2590 6981 +2590 5800 +2590 5452 +2590 8367 +2590 3992 +2590 5490 +2590 4340 +2590 7003 +2590 3132 +2590 7391 +2591 7942 +2591 5313 +2591 6668 +2591 3363 +2591 8743 +2591 6451 +2591 6197 +2591 4919 +2591 3896 +2591 7226 +2591 2625 +2591 6985 +2591 4687 +2591 7254 +2591 9700 +2591 4582 +2591 5478 +2591 5736 +2591 7283 +2591 9716 +2591 2678 +2591 5755 +2591 7164 +2592 5569 +2592 6722 +2592 9508 +2592 9733 +2592 7962 +2592 5776 +2592 9905 +2592 3926 +2592 7383 +2592 3988 +2592 4442 +2593 6753 +2593 5243 +2593 7087 +2593 6577 +2593 4975 +2593 3832 +2593 3491 +2593 7030 +2593 3318 +2593 3512 +2593 6618 +2593 4475 +2594 9473 +2594 9381 +2594 8332 +2594 4012 +2594 5709 +2594 5645 +2594 5171 +2594 9876 +2594 7061 +2594 3897 +2594 7156 +2594 6383 +2594 4841 +2594 6781 +2594 7487 +2595 5383 +2595 8970 +2595 5138 +2595 4644 +2595 5292 +2595 6191 +2595 6834 +2595 4275 +2595 2869 +2595 7122 +2595 9568 +2595 6374 +2595 9447 +2595 3950 +2595 6639 +2595 4977 +2596 7716 +2596 8421 +2596 3590 +2596 8135 +2596 3049 +2596 7371 +2596 6956 +2596 5581 +2596 5742 +2596 8285 +2596 6835 +2596 6964 +2596 4630 +2596 3960 +2596 3923 +2596 5725 +2596 7155 +2597 7328 +2597 9252 +2597 9925 +2597 9990 +2597 4872 +2597 8580 +2597 5549 +2597 9553 +2597 6867 +2597 5332 +2597 4469 +2597 6840 +2597 4132 +2597 9435 +2597 6981 +2598 4480 +2598 5889 +2598 6102 +2598 9478 +2598 8334 +2598 8464 +2598 5906 +2598 2708 +2598 7575 +2598 8453 +2598 6304 +2598 3361 +2598 8265 +2598 8633 +2598 4247 +2598 5185 +2598 8777 +2598 4946 +2598 3412 +2598 7006 +2598 4581 +2598 8764 +2598 7167 +2599 3840 +2599 6916 +2599 7703 +2599 9371 +2599 6556 +2599 6947 +2599 7860 +2599 7222 +2599 3256 +2599 9536 +2599 4557 +2599 8664 +2600 8704 +2600 3269 +2600 9862 +2600 7434 +2600 3118 +2600 3061 +2600 6586 +2600 9214 +2600 7573 +2601 2848 +2601 4449 +2601 5730 +2601 3606 +2601 7560 +2601 3037 +2601 2765 +2601 9454 +2601 9853 +2601 4336 +2601 6929 +2601 8822 +2601 9888 +2601 9213 +2602 7943 +2602 5002 +2602 3214 +2602 5406 +2602 7593 +2602 9259 +2602 8630 +2602 4151 +2602 7225 +2602 9482 +2602 9538 +2602 5319 +2602 7863 +2602 6604 +2602 8936 +2602 9214 +2603 8384 +2603 3907 +2603 5915 +2603 5287 +2603 4424 +2603 7131 +2603 9200 +2603 5301 +2603 2934 +2603 6713 +2603 6335 +2604 8812 +2604 9607 +2604 6636 +2604 3790 +2604 7825 +2604 5339 +2604 5212 +2605 5380 +2605 5430 +2605 3000 +2605 6330 +2605 3260 +2605 3520 +2605 7110 +2605 5326 +2605 7763 +2605 8533 +2605 6110 +2605 5987 +2605 7780 +2605 4340 +2605 8951 +2605 2937 +2605 8698 +2606 7299 +2606 3464 +2606 2958 +2606 6034 +2606 6702 +2606 6063 +2606 9656 +2606 3517 +2606 5956 +2606 4805 +2606 4426 +2606 7521 +2606 4452 +2606 8978 +2606 3828 +2606 6013 +2607 7841 +2607 7685 +2607 7498 +2607 4970 +2607 9245 +2607 5450 +2607 9786 +2607 5308 +2607 4477 +2607 7551 +2608 9376 +2608 8240 +2608 9987 +2608 5924 +2608 5222 +2608 2854 +2608 2728 +2608 3952 +2608 8332 +2608 4845 +2608 6608 +2608 8274 +2608 8180 +2608 8469 +2608 7284 +2609 8128 +2609 5857 +2609 6565 +2609 6568 +2609 6377 +2609 9003 +2609 6478 +2609 2836 +2609 8371 +2609 6996 +2609 6390 +2609 4265 +2609 4201 +2609 9812 +2609 9210 +2609 4731 +2609 4380 +2609 8026 +2610 9602 +2610 9317 +2610 7046 +2610 7623 +2610 9614 +2610 6001 +2610 6963 +2610 6612 +2610 6997 +2610 3259 +2610 4327 +2611 5248 +2611 3201 +2611 7440 +2611 3860 +2611 6059 +2611 2992 +2611 4660 +2611 2617 +2611 4284 +2611 9030 +2611 6992 +2611 7130 +2611 5091 +2611 8036 +2611 6529 +2611 9236 +2612 7360 +2612 3143 +2612 7243 +2612 5133 +2612 6094 +2612 5009 +2612 7160 +2612 9849 +2612 7066 +2612 7806 +2613 3496 +2613 7809 +2613 5123 +2613 7315 +2613 5381 +2613 3432 +2613 7561 +2613 4398 +2613 6456 +2613 3670 +2613 5496 +2613 9630 +2613 7292 +2613 6591 +2614 3201 +2614 9186 +2614 9636 +2614 7694 +2614 7567 +2614 5168 +2614 8113 +2614 7796 +2614 8893 +2614 8119 +2614 8701 +2614 5503 +2615 4110 +2615 7824 +2615 8337 +2615 4257 +2615 5931 +2615 6911 +2615 8128 +2615 7361 +2615 9028 +2615 3658 +2615 4299 +2615 8099 +2615 9430 +2615 9559 +2615 7643 +2615 7900 +2615 3812 +2615 5615 +2615 3195 +2615 7678 +2616 6720 +2616 9451 +2616 8204 +2616 5327 +2616 6543 +2616 5784 +2616 3734 +2616 6456 +2616 7257 +2616 8026 +2616 3195 +2616 9788 +2617 8928 +2617 5284 +2617 6926 +2617 6929 +2617 7470 +2617 3702 +2617 5528 +2617 8127 +2617 7999 +2618 7521 +2618 4163 +2618 8299 +2618 8624 +2618 5843 +2618 8851 +2618 6549 +2618 5562 +2618 6204 +2618 5818 +2618 3733 +2619 3952 +2619 4427 +2619 7434 +2619 3085 +2619 5490 +2619 5584 +2619 6388 +2619 8757 +2619 6902 +2619 9563 +2619 3260 +2619 8701 +2620 4289 +2620 6853 +2620 3239 +2620 9960 +2620 5803 +2620 8013 +2620 6302 +2620 6097 +2620 7059 +2620 6366 +2620 7481 +2620 6238 +2621 7264 +2621 6128 +2621 3140 +2621 3558 +2621 3105 +2621 5672 +2621 4046 +2621 5360 +2621 4211 +2621 7573 +2621 8694 +2621 6935 +2621 9978 +2621 9694 +2622 9316 +2622 6021 +2622 7113 +2622 3794 +2622 4761 +2622 9082 +2622 7323 +2622 4292 +2623 4912 +2623 5808 +2623 6531 +2623 2889 +2623 7210 +2623 2643 +2623 9648 +2623 6325 +2623 5468 +2623 7551 +2624 2689 +2624 5250 +2624 4292 +2624 3017 +2624 6924 +2624 9421 +2624 5039 +2624 3602 +2624 2867 +2624 8117 +2624 7987 +2624 6426 +2624 5372 +2624 9986 +2624 4894 +2625 5825 +2625 3298 +2625 5603 +2625 8740 +2625 2949 +2625 3622 +2625 3212 +2625 8194 +2625 3502 +2625 3279 +2625 6288 +2625 3726 +2625 6167 +2625 9818 +2625 5978 +2625 4190 +2626 5921 +2626 6371 +2626 7260 +2626 9194 +2626 7755 +2626 8172 +2626 6703 +2626 5140 +2626 9173 +2626 6313 +2626 2713 +2626 9757 +2627 8805 +2627 2953 +2627 8588 +2627 9326 +2627 6869 +2627 2633 +2627 6872 +2627 2905 +2627 9532 +2628 8710 +2628 6280 +2628 5916 +2628 7727 +2628 6962 +2628 5947 +2628 7874 +2628 6347 +2628 4941 +2628 3286 +2628 7645 +2628 7778 +2628 4715 +2628 4850 +2628 5883 +2629 3459 +2629 9363 +2629 4629 +2629 8496 +2629 5299 +2629 8248 +2629 7102 +2629 7360 +2629 4295 +2629 2772 +2629 6759 +2629 4328 +2629 3053 +2629 9854 +2630 5768 +2630 5897 +2630 2960 +2630 9639 +2630 8883 +2630 6966 +2630 6587 +2630 4284 +2630 9937 +2630 3032 +2630 4187 +2630 6630 +2630 3431 +2630 6648 +2630 2940 +2630 9085 +2631 9291 +2631 9764 +2631 4870 +2631 7083 +2631 9869 +2631 3022 +2631 9059 +2631 7384 +2631 4031 +2632 3842 +2632 8643 +2632 9334 +2632 3596 +2632 8653 +2632 8942 +2632 5263 +2632 8594 +2632 4397 +2632 4559 +2632 7319 +2632 8182 +2633 2830 +2633 8598 +2633 6295 +2633 3620 +2633 8870 +2633 3751 +2633 4264 +2633 4777 +2633 4267 +2633 9132 +2633 3249 +2633 6966 +2633 9147 +2633 5462 +2633 9076 +2634 4228 +2634 2704 +2634 6418 +2634 6293 +2634 7590 +2634 8105 +2634 3125 +2634 5816 +2634 5818 +2634 6460 +2634 9021 +2634 8000 +2634 3009 +2634 3274 +2634 8780 +2634 7762 +2634 3794 +2634 2676 +2634 4221 +2635 9217 +2635 9354 +2635 3467 +2635 2958 +2635 7314 +2635 8985 +2635 5022 +2635 5029 +2635 8870 +2635 3893 +2635 5827 +2635 6346 +2635 6103 +2635 5849 +2635 7005 +2635 8416 +2635 7658 +2635 3307 +2636 4800 +2636 4054 +2636 7846 +2636 6919 +2636 6920 +2636 6601 +2636 3702 +2636 4078 +2636 5391 +2636 6482 +2636 6454 +2636 4348 +2636 4958 +2637 8965 +2637 5005 +2637 3732 +2637 5148 +2637 7068 +2637 9389 +2637 5166 +2637 5168 +2637 5705 +2637 4559 +2637 5077 +2637 8911 +2637 4195 +2637 9574 +2637 6635 +2638 9120 +2638 5602 +2638 4131 +2638 8552 +2638 8841 +2638 5773 +2638 4816 +2638 7560 +2638 9971 +2638 5814 +2638 5673 +2639 5637 +2639 5514 +2639 9617 +2639 7060 +2639 5142 +2639 8603 +2639 5916 +2639 6045 +2639 4534 +2639 4667 +2639 3850 +2639 5835 +2639 5721 +2639 6881 +2639 3683 +2639 5874 +2639 5756 +2640 2668 +2640 8482 +2640 8964 +2640 6341 +2640 6246 +2640 7783 +2640 6600 +2640 8297 +2640 8330 +2640 5579 +2640 5581 +2640 7632 +2640 9587 +2640 7509 +2640 3480 +2640 4732 +2640 4773 +2641 8848 +2641 4625 +2641 5275 +2641 7074 +2641 8487 +2641 7088 +2641 9908 +2641 3253 +2641 6710 +2641 7608 +2641 3897 +2641 7489 +2641 6215 +2641 5194 +2641 3938 +2641 7636 +2641 5090 +2641 7525 +2641 3327 +2642 2818 +2642 6664 +2642 7561 +2642 9868 +2642 4755 +2642 8350 +2642 9761 +2642 3106 +2642 4393 +2642 4669 +2642 6080 +2642 6412 +2642 5837 +2642 4559 +2642 4050 +2642 2781 +2642 6750 +2642 3687 +2642 3538 +2642 5247 +2643 7744 +2643 4676 +2643 6245 +2643 7553 +2643 6498 +2643 8458 +2643 5799 +2643 7856 +2643 8512 +2643 8977 +2643 5763 +2643 4820 +2643 6422 +2643 6234 +2643 8864 +2643 6826 +2644 9219 +2644 8072 +2644 7180 +2644 5269 +2644 7847 +2644 8232 +2644 2985 +2644 8493 +2644 9775 +2644 8244 +2644 9784 +2644 6713 +2644 6971 +2644 8511 +2644 6594 +2644 2762 +2644 8269 +2644 9449 +2644 4460 +2644 5148 +2644 3319 +2644 5117 +2645 6275 +2645 2825 +2645 2698 +2645 3982 +2645 8218 +2645 9125 +2645 9772 +2645 3245 +2645 8008 +2645 4148 +2645 5816 +2645 5177 +2645 9020 +2645 9533 +2645 7622 +2645 8392 +2645 8651 +2645 9424 +2645 4238 +2645 6489 +2645 3547 +2645 3302 +2645 3819 +2646 6625 +2646 6259 +2646 5414 +2646 3015 +2646 3177 +2646 7571 +2646 3889 +2646 9650 +2646 4213 +2646 7353 +2646 5242 +2646 7742 +2647 3200 +2647 3227 +2647 2884 +2647 3525 +2647 9832 +2647 5767 +2647 3597 +2647 9646 +2647 9779 +2647 6698 +2647 9499 +2647 3621 +2647 7643 +2647 9850 +2647 4613 +2648 4128 +2648 8614 +2648 8681 +2648 3754 +2648 9483 +2648 8304 +2648 9655 +2649 3089 +2649 7699 +2649 9375 +2649 2854 +2649 3441 +2649 5672 +2649 4535 +2649 5701 +2649 8518 +2649 3383 +2649 5838 +2649 3440 +2649 8945 +2649 5629 +2650 4895 +2650 9889 +2650 3427 +2650 8805 +2650 5665 +2650 9253 +2650 9161 +2650 9386 +2650 8215 +2650 8111 +2650 9876 +2650 9559 +2650 9012 +2650 4795 +2650 9439 +2651 3848 +2651 6796 +2651 7440 +2651 5655 +2651 7198 +2651 3931 +2651 9533 +2651 4934 +2651 6731 +2651 6435 +2651 6107 +2651 9054 +2651 5219 +2651 2660 +2651 3691 +2651 6770 +2651 9206 +2651 3323 +2652 7371 +2652 3526 +2652 6855 +2652 9980 +2652 6794 +2652 6956 +2652 2765 +2652 8207 +2652 3345 +2652 3186 +2652 9748 +2652 7230 +2652 3736 +2652 4120 +2652 6428 +2652 3466 +2652 9086 +2653 4097 +2653 9636 +2653 9798 +2653 3431 +2653 5127 +2653 4813 +2653 5661 +2653 8304 +2653 8461 +2653 4949 +2653 7897 +2653 3192 +2653 5695 +2653 7548 +2653 9917 +2653 4863 +2654 9506 +2654 4330 +2654 4332 +2654 5932 +2654 3151 +2654 7634 +2654 6412 +2654 8442 +2654 8829 +2655 4814 +2655 5025 +2655 4675 +2655 7717 +2655 7910 +2655 9752 +2655 5788 +2655 4462 +2655 3886 +2655 8569 +2655 5244 +2655 6556 +2655 4957 +2655 6085 +2656 6148 +2656 4486 +2656 7179 +2656 2700 +2656 8976 +2656 3362 +2656 7077 +2656 9516 +2656 3123 +2656 8005 +2656 5879 +2656 3234 +2656 4942 +2656 9549 +2656 8164 +2656 6246 +2656 9719 +2656 2680 +2657 6596 +2657 7115 +2657 2701 +2657 7311 +2657 2929 +2657 6962 +2657 9400 +2657 4410 +2657 4895 +2657 7868 +2657 7007 +2658 6292 +2658 7263 +2658 6077 +2658 8766 +2658 3519 +2658 7362 +2658 5573 +2658 8902 +2658 9560 +2658 9711 +2658 5365 +2658 7672 +2658 7871 +2659 3335 +2659 8717 +2659 3735 +2659 8602 +2659 4124 +2659 4766 +2659 3123 +2659 5174 +2659 5946 +2659 7755 +2659 5963 +2659 4186 +2659 8030 +2659 6758 +2659 8305 +2659 6655 +2660 3680 +2660 3897 +2660 8294 +2660 5287 +2660 6793 +2660 7756 +2660 6031 +2660 6225 +2660 5620 +2660 3340 +2660 7895 +2660 3417 +2660 8252 +2661 4736 +2661 2665 +2661 6413 +2661 3566 +2661 9807 +2661 6385 +2661 8114 +2661 7827 +2661 9906 +2661 2809 +2661 6108 +2662 6785 +2662 9559 +2662 7137 +2662 4586 +2662 7143 +2662 3020 +2662 3796 +2662 3982 +2662 5369 +2662 7128 +2662 5159 +2662 7103 +2662 4959 +2663 7939 +2663 7320 +2663 5533 +2663 8990 +2663 9644 +2663 5693 +2663 8268 +2663 7247 +2663 4563 +2663 5983 +2663 4453 +2663 8166 +2663 2794 +2663 3704 +2663 6777 +2663 7163 +2663 4095 +2664 8394 +2664 3373 +2664 2941 +2664 7376 +2664 6642 +2664 8317 +2665 4489 +2665 8077 +2665 5518 +2665 8594 +2665 2970 +2665 5289 +2665 4016 +2665 3004 +2665 3912 +2665 3036 +2665 7521 +2665 8557 +2665 6257 +2665 8062 +2666 3904 +2666 9668 +2666 8198 +2666 6208 +2666 5340 +2666 8108 +2666 4781 +2666 9394 +2666 3796 +2666 4543 +2666 7164 +2666 9598 +2666 5535 +2667 7104 +2667 3905 +2667 9283 +2667 7015 +2667 3177 +2667 6519 +2667 4396 +2667 8558 +2667 9276 +2667 6734 +2667 6008 +2667 8602 +2667 6588 +2667 7165 +2668 8193 +2668 4740 +2668 9098 +2668 3854 +2668 6800 +2668 5534 +2668 9510 +2668 8626 +2668 3891 +2668 4813 +2668 3408 +2668 7761 +2668 3803 +2668 3038 +2668 7120 +2668 8937 +2668 7150 +2668 3068 +2668 9470 +2669 9216 +2669 9098 +2669 6871 +2669 9116 +2669 7078 +2669 4012 +2669 9518 +2669 9653 +2669 8630 +2669 6101 +2669 7097 +2669 3032 +2669 8157 +2669 4319 +2669 8416 +2669 7143 +2669 5610 +2669 6378 +2670 7616 +2670 7844 +2670 6582 +2670 7078 +2670 7063 +2670 7981 +2670 7501 +2670 4787 +2670 9810 +2670 2742 +2670 5202 +2670 9087 +2670 9596 +2670 2815 +2671 3681 +2671 8323 +2671 5224 +2671 4380 +2671 4321 +2671 4820 +2671 7792 +2671 9809 +2671 8883 +2671 4884 +2671 9524 +2671 2747 +2671 5980 +2672 4935 +2672 3628 +2672 3276 +2672 9248 +2672 5294 +2672 5813 +2672 2688 +2672 8508 +2672 9946 +2673 3717 +2673 4235 +2673 7063 +2673 4515 +2673 6055 +2673 5289 +2673 2734 +2673 3128 +2673 4418 +2673 3654 +2673 6354 +2673 5082 +2673 8039 +2673 3183 +2673 7024 +2673 4596 +2673 5877 +2673 5627 +2674 6157 +2674 8078 +2674 3999 +2674 4646 +2674 8872 +2674 9268 +2674 4789 +2674 8887 +2674 7864 +2674 3647 +2674 6852 +2674 7257 +2674 6748 +2674 7389 +2674 7015 +2674 4458 +2674 9847 +2674 5880 +2675 6969 +2675 4112 +2675 4254 +2675 4266 +2675 4657 +2675 3678 +2675 6326 +2675 3769 +2675 6074 +2675 3643 +2675 8309 +2675 4567 +2675 9566 +2675 3808 +2675 9360 +2675 9577 +2675 8565 +2675 8953 +2676 9472 +2676 3408 +2676 5254 +2676 9162 +2676 6540 +2676 8174 +2676 5496 +2676 5205 +2676 7256 +2676 9808 +2676 9532 +2676 6461 +2676 3006 +2677 3840 +2677 8043 +2677 5092 +2677 4231 +2677 9448 +2677 8937 +2677 3723 +2677 7602 +2677 7016 +2677 9013 +2677 9465 +2677 4312 +2677 2713 +2677 6139 +2678 2699 +2678 8230 +2678 8663 +2678 9096 +2678 9226 +2678 7543 +2678 5320 +2678 6105 +2678 9401 +2678 6847 +2678 8540 +2678 9438 +2678 5215 +2679 3026 +2679 8033 +2679 4197 +2679 5862 +2679 2759 +2679 8008 +2679 6281 +2679 7885 +2679 9423 +2679 8113 +2679 7538 +2679 7953 +2679 4150 +2679 5879 +2679 7480 +2680 6243 +2680 9948 +2680 3173 +2680 3430 +2680 3211 +2680 4617 +2680 3036 +2680 4690 +2680 2962 +2680 7307 +2680 9412 +2680 4453 +2681 9697 +2681 8515 +2681 6225 +2681 4487 +2681 9609 +2681 7819 +2681 4908 +2681 4813 +2681 7311 +2681 9200 +2681 6097 +2681 6066 +2681 2868 +2681 3081 +2681 4318 +2682 7170 +2682 4227 +2682 4363 +2682 7825 +2682 6283 +2682 5020 +2682 8502 +2682 4663 +2682 8131 +2682 7241 +2682 6858 +2682 8653 +2682 7763 +2682 3406 +2682 6252 +2682 6396 +2682 6655 +2683 9568 +2683 3329 +2683 5698 +2683 6921 +2683 9036 +2683 2944 +2683 7184 +2683 5521 +2683 8789 +2683 2743 +2683 6651 +2683 6492 +2683 6165 +2684 7983 +2684 5691 +2684 8839 +2684 8587 +2684 9197 +2684 6927 +2684 7376 +2684 3345 +2684 9522 +2684 4403 +2684 5365 +2684 5239 +2684 4227 +2684 5930 +2684 6270 +2685 8962 +2685 9476 +2685 3725 +2685 8481 +2685 6691 +2685 6567 +2685 4655 +2685 9787 +2685 5825 +2685 5969 +2685 9173 +2685 9834 +2685 8428 +2685 7664 +2685 4473 +2685 9855 +2686 6080 +2686 6754 +2686 5027 +2686 8801 +2686 4043 +2686 9485 +2686 8368 +2686 8785 +2686 4345 +2686 3098 +2686 9403 +2686 4062 +2687 3978 +2687 4125 +2687 4011 +2687 8197 +2687 5095 +2687 6443 +2687 9068 +2687 7790 +2687 6416 +2687 8851 +2687 7928 +2687 6554 +2687 5930 +2687 3261 +2687 9150 +2688 9230 +2688 3727 +2688 8338 +2688 5399 +2688 5272 +2688 9499 +2688 6049 +2688 3491 +2688 6466 +2688 8391 +2688 9676 +2688 6733 +2688 8405 +2688 3035 +2688 3564 +2688 2799 +2689 9220 +2689 6023 +2689 3337 +2689 4364 +2689 6291 +2689 6165 +2689 4761 +2689 6436 +2689 8945 +2689 5935 +2689 4536 +2689 7617 +2689 9296 +2689 9636 +2689 9055 +2689 7279 +2689 8951 +2689 2936 +2689 5881 +2690 7235 +2690 4003 +2690 3364 +2690 8072 +2690 9004 +2690 8842 +2690 5547 +2690 3533 +2690 5166 +2690 3179 +2690 8590 +2690 7862 +2690 7096 +2690 6436 +2690 4155 +2690 6524 +2691 4833 +2691 8034 +2691 4646 +2691 8967 +2691 3592 +2691 8874 +2691 4331 +2691 8685 +2691 4720 +2691 8497 +2691 8820 +2691 9941 +2691 8790 +2691 6807 +2691 7760 +2691 3839 +2691 7037 +2691 8927 +2692 4617 +2692 2847 +2692 4208 +2692 7970 +2692 3761 +2692 7493 +2692 4166 +2692 8142 +2692 7251 +2692 3029 +2692 4827 +2692 4859 +2692 4964 +2692 8685 +2692 7792 +2692 4337 +2692 8186 +2692 4091 +2692 4732 +2693 6016 +2693 7554 +2693 6467 +2693 9700 +2693 9253 +2693 3655 +2693 6857 +2693 9514 +2693 4812 +2693 9388 +2693 4387 +2693 9843 +2693 6633 +2693 3145 +2693 5784 +2694 3137 +2694 6850 +2694 2959 +2694 4417 +2694 5321 +2694 8554 +2694 5550 +2694 4212 +2694 8398 +2694 3796 +2694 6959 +2695 8936 +2695 4333 +2695 4143 +2695 7283 +2695 7700 +2695 8343 +2695 7704 +2695 6009 +2695 7159 +2695 5055 +2695 3838 +2695 7487 +2696 3809 +2696 8066 +2696 6710 +2696 9222 +2696 8615 +2696 6984 +2696 4874 +2696 3886 +2696 7521 +2696 6992 +2696 4015 +2696 2904 +2696 4732 +2696 2813 +2696 4501 +2697 6912 +2697 3569 +2697 5288 +2697 3918 +2697 9022 +2697 2742 +2697 4183 +2697 7188 +2697 5468 +2697 8254 +2698 6016 +2698 8449 +2698 6914 +2698 4357 +2698 5128 +2698 3594 +2698 5005 +2698 3216 +2698 4761 +2698 5661 +2698 7974 +2698 6793 +2698 6862 +2698 7459 +2698 4328 +2698 8943 +2698 5240 +2698 5503 +2699 4354 +2699 4102 +2699 3983 +2699 2962 +2699 6035 +2699 2710 +2699 3608 +2699 9755 +2699 5916 +2699 5028 +2699 4777 +2699 4906 +2699 9013 +2699 8000 +2699 6612 +2699 8022 +2699 7354 +2699 4705 +2699 3044 +2699 8825 +2699 9979 +2699 7933 +2699 7807 +2700 3969 +2700 6402 +2700 6147 +2700 2825 +2700 3851 +2700 5260 +2700 5005 +2700 3587 +2700 5142 +2700 8343 +2700 9687 +2700 6874 +2700 5598 +2700 5223 +2700 3689 +2700 9329 +2700 6388 +2700 4995 +2701 7057 +2701 7194 +2701 3867 +2701 6177 +2701 6054 +2701 5287 +2701 5175 +2701 5439 +2701 6625 +2701 4816 +2701 3283 +2701 9562 +2701 4700 +2701 8290 +2701 9452 +2701 9683 +2701 7273 +2702 5508 +2702 6153 +2702 8462 +2702 8978 +2702 9115 +2702 9380 +2702 4005 +2702 8359 +2702 3638 +2702 6849 +2702 9924 +2702 7752 +2702 7130 +2702 8050 +2702 5365 +2702 8056 +2702 3453 +2702 5118 +2703 6725 +2703 7718 +2703 3942 +2703 5039 +2703 5009 +2703 6194 +2703 2900 +2703 9877 +2703 8663 +2703 2936 +2703 7867 +2703 4541 +2703 2709 +2704 6699 +2704 5129 +2704 7043 +2704 7962 +2704 5403 +2704 7207 +2704 8746 +2704 7339 +2704 6060 +2704 9332 +2704 7613 +2704 5831 +2704 5579 +2704 6989 +2704 4305 +2704 8531 +2704 8664 +2704 7807 +2704 4964 +2704 5096 +2704 9066 +2704 8427 +2704 3316 +2704 3581 +2704 8447 +2705 6944 +2705 9387 +2705 5604 +2705 9701 +2705 7244 +2705 6507 +2705 6028 +2705 6318 +2705 6193 +2705 8692 +2705 3388 +2705 6020 +2705 6684 +2705 9669 +2706 5227 +2706 5126 +2706 5575 +2706 2794 +2706 5031 +2706 3023 +2706 7423 +2706 3380 +2706 6072 +2706 9620 +2706 7873 +2706 6815 +2706 7007 +2707 4002 +2707 6149 +2707 5473 +2707 3753 +2707 9067 +2707 7085 +2707 7489 +2707 9745 +2707 6738 +2707 5111 +2707 5143 +2707 9785 +2708 5954 +2708 5467 +2708 4612 +2708 8220 +2708 4970 +2708 3519 +2708 7061 +2708 2742 +2708 7387 +2708 3100 +2708 5823 +2709 6721 +2709 9771 +2709 9352 +2709 4306 +2709 6636 +2709 6989 +2709 5550 +2709 6256 +2709 9426 +2709 7605 +2709 6487 +2709 5912 +2709 7769 +2709 6704 +2709 7579 +2709 7644 +2709 7259 +2709 4703 +2710 7944 +2710 6793 +2710 9561 +2710 6557 +2710 8608 +2710 8865 +2710 8995 +2710 2993 +2710 8872 +2710 8237 +2710 4910 +2710 3633 +2710 7481 +2710 6849 +2710 4553 +2710 7129 +2710 8294 +2710 6892 +2710 9470 +2710 6777 +2710 6011 +2710 5373 +2711 5891 +2711 4748 +2711 3228 +2711 7839 +2711 7729 +2711 7612 +2711 7628 +2711 4559 +2711 8657 +2711 5332 +2711 3161 +2711 9439 +2711 4708 +2711 5436 +2711 7292 +2712 8967 +2712 5905 +2712 7319 +2712 2721 +2712 6054 +2712 9139 +2712 9279 +2712 8655 +2712 7266 +2712 6755 +2712 8165 +2712 5232 +2712 4984 +2713 3204 +2713 3722 +2713 5908 +2713 3375 +2713 5661 +2713 3998 +2713 3803 +2713 7076 +2713 9767 +2713 7081 +2713 7724 +2713 6063 +2713 7362 +2713 7244 +2713 9485 +2713 6992 +2713 4948 +2713 4953 +2713 3418 +2713 2779 +2713 3314 +2714 7299 +2714 3461 +2714 7046 +2714 3465 +2714 9237 +2714 2843 +2714 4570 +2714 8350 +2714 6303 +2714 7975 +2714 6326 +2714 3402 +2714 4170 +2714 9297 +2714 8419 +2714 2915 +2714 4341 +2714 9084 +2714 9854 +2715 7154 +2715 8228 +2715 7017 +2715 7245 +2715 7886 +2715 9362 +2715 9880 +2715 7129 +2715 8634 +2715 5597 +2715 4031 +2716 6080 +2716 5379 +2716 6412 +2716 6551 +2716 2843 +2716 9250 +2716 5019 +2716 5412 +2716 5414 +2716 6823 +2716 6959 +2716 4917 +2716 3642 +2716 3776 +2716 4680 +2716 9425 +2716 4643 +2716 3669 +2716 4828 +2716 9530 +2716 3048 +2716 2924 +2716 5368 +2717 8707 +2717 9492 +2717 8599 +2717 6298 +2717 5665 +2717 2853 +2717 8881 +2717 6322 +2717 4661 +2717 5961 +2717 8387 +2717 3528 +2717 7114 +2717 7373 +2717 6100 +2717 9306 +2717 8283 +2717 9954 +2717 4584 +2717 9456 +2717 6002 +2717 4346 +2718 9418 +2718 4012 +2718 6685 +2718 8381 +2718 2932 +2718 6458 +2718 7261 +2718 3070 +2719 2817 +2719 3204 +2719 7432 +2719 6797 +2719 9615 +2719 6164 +2719 3100 +2719 5919 +2719 9637 +2719 3494 +2719 4279 +2719 6310 +2719 3783 +2719 3383 +2719 5073 +2719 9173 +2719 2833 +2719 6494 +2719 3558 +2719 5223 +2720 9569 +2720 9123 +2720 8005 +2720 7437 +2720 9135 +2720 6257 +2720 8867 +2720 9973 +2720 4987 +2720 7679 +2721 8709 +2721 7186 +2721 9235 +2721 3356 +2721 6816 +2721 2980 +2721 3131 +2721 6973 +2721 6990 +2721 9295 +2721 9400 +2721 3926 +2721 8664 +2721 5981 +2721 6368 +2721 6630 +2721 8554 +2721 5228 +2721 7155 +2722 6914 +2722 7697 +2722 7321 +2722 9886 +2722 4902 +2722 6962 +2722 4794 +2722 9917 +2722 8794 +2722 3299 +2722 8425 +2722 7403 +2723 6211 +2723 6602 +2723 7785 +2723 5251 +2723 9717 +2723 4886 +2723 3681 +2723 5967 +2723 2940 +2723 6847 +2724 3552 +2724 9793 +2724 3299 +2724 3940 +2724 7845 +2724 9262 +2724 3239 +2724 6023 +2724 3278 +2724 9648 +2724 6129 +2724 6771 +2724 9188 +2724 8991 +2725 5163 +2725 5509 +2725 4487 +2725 5800 +2725 9479 +2725 7789 +2725 3685 +2725 9768 +2725 7811 +2725 5567 +2725 6775 +2725 5279 +2725 4669 +2725 5663 +2725 3487 +2726 5794 +2726 9604 +2726 9086 +2726 6152 +2726 7690 +2726 8978 +2726 4693 +2726 3190 +2726 4984 +2726 9593 +2726 5918 +2727 5769 +2727 7818 +2727 9295 +2727 9450 +2727 4667 +2727 7594 +2727 8478 +2728 5345 +2728 9255 +2728 5335 +2728 7308 +2728 6573 +2728 2866 +2728 4599 +2728 3388 +2729 6530 +2729 9228 +2729 3994 +2729 7580 +2729 4517 +2729 4784 +2729 2743 +2729 8510 +2729 3904 +2729 3265 +2729 8772 +2729 8392 +2729 9419 +2729 5324 +2729 8159 +2729 8288 +2729 8419 +2729 3428 +2729 7024 +2730 8768 +2730 7683 +2730 6678 +2730 7089 +2730 4072 +2730 9545 +2730 3111 +2730 7501 +2730 6445 +2730 4595 +2730 3025 +2730 8579 +2730 4245 +2730 9206 +2731 5513 +2731 5642 +2731 7951 +2731 6674 +2731 8340 +2731 3990 +2731 9757 +2731 8517 +2731 3574 +2731 3795 +2731 9561 +2731 9698 +2731 7013 +2731 4342 +2732 5538 +2732 7883 +2732 6757 +2732 5937 +2732 6472 +2732 6378 +2732 4535 +2732 8172 +2732 9969 +2732 2834 +2732 6581 +2732 3735 +2732 6911 +2732 6073 +2732 4443 +2732 2876 +2732 8875 +2733 5377 +2733 6595 +2733 6660 +2733 5334 +2733 3825 +2733 3052 +2733 9934 +2733 8370 +2733 3606 +2733 5656 +2733 4537 +2733 7835 +2733 7601 +2733 7614 +2733 5285 +2734 6848 +2734 6049 +2734 3051 +2734 8964 +2734 8293 +2734 8556 +2734 9452 +2734 3691 +2734 3020 +2734 3534 +2734 9551 +2734 5195 +2734 3439 +2734 3502 +2734 4809 +2734 2884 +2734 8825 +2734 5711 +2735 7981 +2735 4393 +2735 5578 +2735 3917 +2735 7119 +2735 6128 +2735 7029 +2735 5078 +2735 3832 +2735 3321 +2735 9349 +2736 4224 +2736 3524 +2736 4328 +2736 5229 +2736 8880 +2736 5557 +2736 4729 +2736 7993 +2736 3739 +2737 4961 +2737 7426 +2737 7958 +2737 4577 +2737 8748 +2737 8205 +2737 7410 +2737 3126 +2737 4056 +2738 3360 +2738 8048 +2738 6501 +2738 9555 +2738 9652 +2738 7021 +2738 3460 +2738 6512 +2738 8786 +2738 5395 +2738 3924 +2738 9237 +2738 6518 +2738 7031 +2738 7098 +2738 9307 +2738 3292 +2738 4858 +2739 7056 +2739 7495 +2739 6952 +2739 6796 +2739 5834 +2739 7404 +2739 6953 +2739 8605 +2739 4144 +2739 6932 +2739 6521 +2739 7824 +2739 8313 +2740 5796 +2740 5286 +2740 9736 +2740 9770 +2740 6187 +2740 5740 +2740 9039 +2740 8646 +2740 5267 +2740 8919 +2740 7229 +2740 5503 +2741 3735 +2741 9999 +2741 2965 +2741 6935 +2741 6427 +2741 7986 +2741 2996 +2741 3131 +2741 5052 +2741 2888 +2741 4942 +2741 4817 +2741 5592 +2741 3302 +2741 8430 +2741 7023 +2741 5877 +2741 6905 +2741 5754 +2741 2813 +2742 9237 +2742 6186 +2742 8883 +2742 4156 +2742 5700 +2742 2895 +2742 2774 +2742 7759 +2742 4703 +2742 3559 +2742 3772 +2742 9196 +2742 3828 +2742 7161 +2742 5839 +2743 6659 +2743 6310 +2743 8359 +2743 3528 +2743 9482 +2743 4879 +2743 5207 +2743 9048 +2743 4442 +2743 7773 +2744 4355 +2744 4242 +2744 9507 +2744 9003 +2744 5692 +2744 7364 +2744 9032 +2744 5724 +2744 7009 +2744 7419 +2744 7920 +2744 6002 +2744 9720 +2744 2809 +2744 9594 +2744 5883 +2744 9212 +2745 5854 +2745 4289 +2745 4805 +2745 7974 +2745 6920 +2745 4586 +2745 5259 +2745 8653 +2745 6129 +2745 6014 +2745 5942 +2745 9178 +2745 3421 +2745 3582 +2746 3585 +2746 2975 +2746 3207 +2746 2836 +2746 6038 +2746 9370 +2746 4895 +2746 4130 +2746 8740 +2746 4010 +2746 6175 +2746 6973 +2746 9406 +2746 7231 +2746 5334 +2746 9887 +2746 7389 +2746 4193 +2746 8552 +2746 4974 +2746 9967 +2746 7666 +2746 7795 +2747 2829 +2747 7694 +2747 7318 +2747 3887 +2747 5554 +2747 7226 +2747 7235 +2747 3672 +2747 7778 +2747 4581 +2747 9718 +2747 4986 +2747 3323 +2747 8830 +2747 6015 +2748 6576 +2748 7909 +2748 6343 +2748 5227 +2748 4048 +2748 4120 +2748 7444 +2748 4942 +2748 4089 +2748 8286 +2749 3840 +2749 2828 +2749 9998 +2749 2964 +2749 4648 +2749 4669 +2749 9541 +2749 6087 +2749 3406 +2749 4219 +2749 3046 +2749 9319 +2749 7787 +2749 4845 +2749 3067 +2749 7164 +2750 9243 +2750 6116 +2750 9893 +2750 5735 +2750 7240 +2750 4906 +2750 6700 +2750 7598 +2750 5683 +2750 5784 +2750 5012 +2750 5658 +2750 9598 +2751 9443 +2751 3557 +2751 6117 +2751 7622 +2751 7025 +2751 5256 +2751 7913 +2751 8135 +2751 8041 +2751 7921 +2751 9236 +2751 9015 +2751 4005 +2751 3029 +2751 5469 +2751 9406 +2751 5535 +2752 6541 +2752 6800 +2752 6163 +2752 3611 +2752 5162 +2752 7600 +2752 4147 +2752 9526 +2752 6587 +2752 9534 +2752 3013 +2752 5959 +2752 8393 +2752 4574 +2752 4192 +2752 9872 +2752 9829 +2752 8428 +2752 7154 +2752 5267 +2752 8312 +2752 3195 +2753 9696 +2753 7451 +2753 6788 +2753 6278 +2753 7303 +2753 6642 +2753 2960 +2753 5458 +2753 9972 +2753 8793 +2753 9947 +2754 6019 +2754 4069 +2754 4616 +2754 6841 +2754 8459 +2754 9581 +2754 9486 +2754 5647 +2754 2768 +2754 4403 +2754 5845 +2754 5143 +2754 7321 +2754 6362 +2754 3625 +2754 5059 +2754 6271 +2755 3432 +2755 7369 +2755 4778 +2755 7442 +2755 5774 +2755 3506 +2755 2964 +2755 3930 +2755 8123 +2756 7046 +2756 6726 +2756 8009 +2756 4012 +2756 9936 +2756 3558 +2756 8211 +2756 5875 +2756 9656 +2756 4985 +2756 2911 +2757 2980 +2757 3654 +2757 8614 +2757 4460 +2757 8887 +2757 8312 +2757 5173 +2757 8070 +2757 4215 +2757 3256 +2757 9404 +2758 8926 +2758 6243 +2758 3653 +2758 9063 +2758 6792 +2758 5439 +2758 4745 +2758 3729 +2758 7043 +2758 6485 +2758 8728 +2758 8101 +2758 4511 +2758 5429 +2758 7198 +2758 8437 +2759 8580 +2759 6829 +2759 4886 +2759 6039 +2759 7452 +2759 6566 +2759 3879 +2759 2856 +2759 5417 +2759 4781 +2759 4671 +2759 2884 +2759 9128 +2759 9433 +2759 3294 +2759 4322 +2759 9710 +2759 8616 +2759 6143 +2760 8514 +2760 5452 +2760 8976 +2760 3254 +2760 5081 +2760 8381 +2761 2950 +2761 4628 +2761 7189 +2761 7959 +2761 4127 +2761 5281 +2761 8874 +2761 5944 +2761 5060 +2761 9286 +2761 6087 +2761 6219 +2761 4447 +2761 8097 +2761 4335 +2761 5746 +2761 5747 +2761 6905 +2761 6101 +2762 4482 +2762 5379 +2762 3472 +2762 7442 +2762 7662 +2762 7704 +2762 6053 +2762 9400 +2762 8640 +2762 4547 +2762 9168 +2762 7824 +2762 4321 +2762 9193 +2762 8825 +2762 4180 +2762 4990 +2763 8640 +2763 6627 +2763 9318 +2763 7337 +2763 4682 +2763 3691 +2763 4913 +2763 7955 +2764 6657 +2764 7877 +2764 8550 +2764 3607 +2764 6930 +2764 5584 +2764 5649 +2764 3703 +2764 4412 +2764 8848 +2764 8860 +2764 4858 +2764 6527 +2765 9872 +2765 3234 +2765 9891 +2765 6703 +2765 5046 +2765 8631 +2765 5311 +2765 3910 +2765 6245 +2765 7911 +2765 4074 +2765 6127 +2765 5033 +2765 3066 +2765 6908 +2766 3840 +2766 8326 +2766 6856 +2766 9705 +2766 9994 +2766 9815 +2766 4818 +2766 5617 +2766 6290 +2766 6291 +2766 5588 +2766 4169 +2766 9529 +2766 3321 +2766 5979 +2766 5855 +2767 5152 +2767 3281 +2767 4554 +2767 2893 +2767 3385 +2767 8698 +2767 6523 +2767 8735 +2768 3344 +2768 7387 +2768 8932 +2768 4997 +2768 8006 +2768 3575 +2768 5705 +2768 8394 +2768 9335 +2768 9602 +2768 6512 +2768 9091 +2768 7093 +2768 3223 +2768 4219 +2768 4188 +2768 6750 +2769 2817 +2769 8966 +2769 3592 +2769 4878 +2769 7058 +2769 9635 +2769 9641 +2769 9770 +2769 7855 +2769 3768 +2769 4931 +2769 3530 +2769 4699 +2769 7532 +2769 8850 +2769 7032 +2769 5497 +2769 9083 +2770 4708 +2770 4741 +2770 3050 +2770 8319 +2770 3953 +2770 6386 +2770 7096 +2770 8537 +2770 6043 +2770 7386 +2770 5855 +2771 7009 +2771 7074 +2771 5574 +2771 7911 +2771 3433 +2771 2954 +2771 8364 +2771 3986 +2771 5709 +2771 6440 +2771 9810 +2771 8535 +2771 7833 +2771 9066 +2771 9310 +2772 9062 +2772 3926 +2772 7256 +2772 7769 +2772 6234 +2773 5139 +2773 5155 +2773 4004 +2773 5430 +2773 9286 +2773 6646 +2773 5228 +2773 8696 +2773 4658 +2773 6966 +2773 3128 +2773 7674 +2773 5915 +2773 7034 +2773 7166 +2774 5921 +2774 8709 +2774 8397 +2774 7856 +2774 6954 +2775 6017 +2775 9346 +2775 5638 +2775 4204 +2775 6933 +2775 3994 +2775 3487 +2775 6960 +2775 9906 +2775 6198 +2775 8895 +2775 5568 +2775 7105 +2775 5334 +2775 9692 +2775 3300 +2775 9964 +2775 8565 +2776 7554 +2776 9253 +2776 3607 +2776 4018 +2776 9423 +2776 2953 +2776 8081 +2776 8274 +2776 9429 +2776 6264 +2776 7611 +2776 5086 +2776 3685 +2777 5513 +2777 4495 +2777 9488 +2777 6293 +2777 7832 +2777 6041 +2777 9371 +2777 5287 +2777 7217 +2777 4037 +2777 9670 +2777 5703 +2777 4812 +2777 4054 +2777 6488 +2777 9309 +2777 3934 +2777 5904 +2777 7909 +2777 3169 +2778 7746 +2778 3491 +2778 8580 +2778 2825 +2778 4203 +2778 3822 +2778 5871 +2778 5776 +2778 9715 +2778 5337 +2778 6043 +2778 9308 +2778 7838 +2779 5396 +2779 8836 +2779 8040 +2779 8810 +2779 9872 +2779 5649 +2779 7795 +2779 3732 +2779 5942 +2779 8788 +2779 9402 +2779 6314 +2780 9537 +2780 9573 +2780 6097 +2780 8340 +2780 4980 +2780 7098 +2780 5724 +2780 4126 +2780 5823 +2781 3599 +2781 6171 +2781 7454 +2781 4777 +2781 5554 +2781 3119 +2781 4913 +2781 9138 +2781 9396 +2781 9276 +2781 4419 +2781 9028 +2781 5473 +2781 9930 +2781 5070 +2781 7634 +2781 5594 +2781 4193 +2781 6888 +2781 3951 +2781 3698 +2781 5310 +2782 8724 +2782 5911 +2782 8731 +2782 4772 +2782 8871 +2782 7863 +2782 6858 +2782 6283 +2782 5448 +2782 3146 +2782 2891 +2782 8013 +2782 7888 +2782 3037 +2782 6733 +2782 6755 +2782 4328 +2782 4986 +2783 7632 +2783 4226 +2783 4187 +2783 3620 +2783 4453 +2783 9420 +2783 9214 +2783 6937 +2783 3353 +2783 9406 +2783 6053 +2784 6912 +2784 6977 +2784 7491 +2784 9381 +2784 8177 +2784 9769 +2784 3500 +2784 4781 +2784 3488 +2784 6254 +2784 5367 +2784 2842 +2784 9214 +2785 7777 +2785 7747 +2785 6566 +2785 4881 +2785 4609 +2785 3147 +2785 4824 +2785 7152 +2785 6392 +2785 5715 +2785 3861 +2785 6904 +2785 6425 +2785 5904 +2785 7966 +2785 7029 +2786 5638 +2786 9510 +2786 3751 +2786 5704 +2786 5962 +2786 6344 +2786 5300 +2786 6456 +2786 4410 +2786 7708 +2786 4830 +2786 5663 +2787 9952 +2787 4256 +2787 5924 +2787 5701 +2787 3751 +2787 3528 +2787 5449 +2787 6379 +2787 2833 +2787 5489 +2787 4178 +2787 9460 +2787 3414 +2787 3674 +2787 8164 +2787 4698 +2787 4219 +2787 6972 +2787 9277 +2788 5537 +2788 7842 +2788 3012 +2788 9351 +2788 5865 +2788 5431 +2788 7058 +2788 2801 +2788 9202 +2788 8438 +2788 8297 +2789 3263 +2789 4371 +2789 6303 +2789 3113 +2789 8493 +2789 5827 +2789 6340 +2789 4424 +2789 7113 +2789 9933 +2789 6991 +2789 6996 +2789 6095 +2789 9960 +2789 3441 +2789 6395 +2790 3200 +2790 7371 +2790 5604 +2790 6693 +2790 6439 +2790 5801 +2790 9426 +2790 3997 +2790 4086 +2790 4539 +2790 9278 +2790 3231 +2791 7971 +2791 7239 +2791 8584 +2791 6922 +2791 6803 +2791 5678 +2791 8799 +2791 6779 +2792 7936 +2792 6920 +2792 9084 +2792 3690 +2792 5804 +2792 4142 +2792 3925 +2792 8415 +2792 3260 +2792 9661 +2792 8510 +2792 5855 +2793 4800 +2793 8624 +2793 7910 +2793 5131 +2793 6466 +2793 3629 +2793 3246 +2793 3791 +2793 8880 +2793 6834 +2793 7285 +2793 2966 +2793 7888 +2794 7840 +2794 9699 +2794 9394 +2794 3144 +2794 9641 +2794 4045 +2794 3886 +2794 6463 +2794 5141 +2794 3449 +2794 6875 +2794 5629 +2794 7743 +2795 9883 +2795 6889 +2795 6828 +2795 6863 +2795 6616 +2795 6806 +2795 4279 +2795 2872 +2795 3515 +2795 3964 +2795 5989 +2795 8959 +2796 9154 +2796 8548 +2796 9830 +2796 9069 +2796 9476 +2796 5447 +2796 9196 +2796 8398 +2796 5677 +2796 2864 +2796 5105 +2796 4117 +2796 7161 +2796 5186 +2796 9301 +2797 9921 +2797 6006 +2797 4998 +2797 5961 +2797 2957 +2797 9839 +2797 9394 +2797 8022 +2797 6936 +2797 6106 +2797 4511 +2798 4224 +2798 9729 +2798 9963 +2798 4869 +2798 9217 +2798 7553 +2798 8989 +2798 8352 +2798 7205 +2798 5414 +2798 3497 +2798 5552 +2798 4529 +2798 4609 +2798 3637 +2798 4022 +2798 7391 +2798 6247 +2798 3307 +2799 8076 +2799 9620 +2799 3222 +2799 6824 +2799 6442 +2799 8749 +2799 3129 +2799 5072 +2799 7126 +2799 5465 +2799 8425 +2799 4459 +2799 3699 +2799 8821 +2799 8698 +2800 6587 +2800 4774 +2800 5331 +2800 5937 +2800 4073 +2800 5229 +2800 9233 +2800 6386 +2800 9945 +2800 3098 +2800 3579 +2801 8449 +2801 6923 +2801 4239 +2801 2972 +2801 9887 +2801 8736 +2801 5286 +2801 7977 +2801 4413 +2801 5831 +2801 3924 +2801 3419 +2801 3955 +2801 4598 +2801 5625 +2802 5824 +2802 9056 +2802 7812 +2802 9573 +2802 3078 +2802 5489 +2802 3551 +2802 8842 +2802 5133 +2802 2897 +2802 8914 +2802 6996 +2802 8850 +2802 4207 +2802 6977 +2802 5407 +2803 4834 +2803 4923 +2803 6821 +2803 6317 +2803 3213 +2803 9205 +2803 7023 +2803 4279 +2803 3865 +2804 3837 +2804 4806 +2804 2825 +2804 3250 +2804 9614 +2804 6869 +2804 6459 +2804 4533 +2804 5629 +2804 4018 +2805 8836 +2805 6310 +2805 8585 +2805 4397 +2805 8701 +2805 7984 +2805 5567 +2805 4759 +2805 3096 +2805 7003 +2805 4189 +2806 7438 +2806 5138 +2806 4885 +2806 5147 +2806 2975 +2806 8225 +2806 8106 +2806 3252 +2806 9887 +2806 9405 +2806 3774 +2806 9541 +2806 8993 +2806 7368 +2806 6747 +2806 9070 +2806 9723 +2806 8572 +2806 7677 +2807 2968 +2807 8862 +2807 6308 +2807 8367 +2807 4275 +2807 6452 +2807 4662 +2807 9656 +2807 9151 +2807 4165 +2807 4023 +2807 5074 +2807 2894 +2807 4701 +2807 8034 +2807 4836 +2807 8169 +2807 3564 +2807 6898 +2807 4083 +2807 7805 +2808 3009 +2808 8164 +2808 3876 +2808 5383 +2808 9089 +2808 6186 +2808 4397 +2808 4430 +2808 3631 +2808 4882 +2808 5076 +2808 9527 +2808 6628 +2809 8582 +2809 9096 +2809 9995 +2809 9242 +2809 7195 +2809 7341 +2809 6194 +2809 4151 +2809 4933 +2809 2886 +2809 8779 +2809 3661 +2809 6757 +2809 7142 +2809 8319 +2809 6268 +2809 6398 +2809 6655 +2810 7328 +2810 5328 +2810 8112 +2810 7399 +2810 7786 +2810 7117 +2810 6863 +2810 7312 +2810 5393 +2810 7582 +2810 5684 +2810 7354 +2811 7554 +2811 4999 +2811 8336 +2811 7324 +2811 2973 +2811 5812 +2811 5182 +2811 9416 +2811 8521 +2811 4687 +2811 4821 +2811 7512 +2811 4841 +2811 6379 +2811 3912 +2811 7544 +2811 3577 +2812 7872 +2812 8292 +2812 9925 +2812 9993 +2812 6479 +2812 3632 +2812 5779 +2812 9653 +2812 3094 +2812 8856 +2812 3195 +2812 4282 +2812 5598 +2812 8639 +2813 9481 +2813 4490 +2813 3853 +2813 9106 +2813 7829 +2813 4132 +2813 4902 +2813 5547 +2813 7730 +2813 3391 +2813 9157 +2813 9438 +2813 9830 +2813 3576 +2813 8313 +2813 8059 +2814 5251 +2814 7944 +2814 8205 +2814 7828 +2814 6686 +2814 4400 +2814 9781 +2814 9418 +2814 5957 +2814 8010 +2814 7883 +2814 9613 +2814 3670 +2814 9067 +2814 3827 +2814 7293 +2815 4880 +2815 5509 +2815 2849 +2815 6663 +2815 3980 +2815 9354 +2815 5767 +2815 7244 +2815 7984 +2815 7762 +2815 6670 +2815 3689 +2815 6584 +2815 6751 +2815 3413 +2816 9624 +2816 3976 +2816 9230 +2816 7496 +2816 5588 +2816 9718 +2816 4023 +2816 7672 +2816 8159 +2816 6716 +2816 3677 +2816 9502 +2816 4309 +2817 9346 +2817 3163 +2817 7458 +2817 2957 +2817 4045 +2817 6672 +2817 3283 +2817 6580 +2817 5849 +2817 4632 +2817 4596 +2817 3067 +2818 3465 +2818 9357 +2818 4004 +2818 3750 +2818 4805 +2818 8905 +2818 5452 +2818 3597 +2818 5979 +2818 7775 +2818 5089 +2818 5474 +2818 4071 +2818 8012 +2818 9078 +2818 8698 +2818 9341 +2818 8319 +2819 4759 +2819 3224 +2819 5025 +2819 9257 +2819 4017 +2819 3507 +2819 5559 +2819 8768 +2819 4673 +2819 8386 +2819 4935 +2819 8810 +2819 4085 +2819 8822 +2819 9463 +2819 5115 +2819 6143 +2820 9472 +2820 7488 +2820 4579 +2820 3752 +2820 7276 +2820 8557 +2820 8013 +2820 3216 +2820 3997 +2820 3741 +2820 7198 +2820 3575 +2820 5764 +2820 5437 +2820 6494 +2821 5216 +2821 7624 +2821 8677 +2821 7080 +2821 4956 +2821 3723 +2821 6700 +2821 3122 +2821 5797 +2821 4465 +2821 8306 +2821 3061 +2821 8053 +2821 5753 +2821 9402 +2821 6312 +2821 5689 +2821 5406 +2821 8671 +2822 4610 +2822 7431 +2822 5335 +2822 7256 +2822 3476 +2822 5141 +2822 3094 +2822 4247 +2822 3099 +2822 7464 +2822 3975 +2822 9772 +2822 9266 +2822 9790 +2822 9536 +2822 4039 +2822 9806 +2822 3152 +2822 3799 +2822 7768 +2822 8981 +2823 4710 +2823 3012 +2823 9254 +2823 6983 +2823 7782 +2823 6628 +2823 3997 +2823 7536 +2823 3349 +2823 4439 +2823 6680 +2823 8825 +2823 4698 +2823 7494 +2823 6014 +2824 4518 +2824 5785 +2824 4297 +2824 3644 +2824 6510 +2824 9487 +2824 4914 +2824 4268 +2824 7829 +2824 8245 +2824 5788 +2824 3325 +2825 5387 +2825 9233 +2825 5010 +2825 7700 +2825 4377 +2825 9371 +2825 6490 +2825 3125 +2825 5065 +2825 8145 +2825 7644 +2825 3039 +2825 4069 +2825 9580 +2825 8947 +2825 5492 +2825 4344 +2825 8573 +2826 3200 +2826 5019 +2826 6980 +2826 8491 +2826 7313 +2826 9930 +2826 5879 +2826 4396 +2826 5816 +2826 9140 +2826 6805 +2826 7575 +2826 9528 +2826 7577 +2826 4794 +2826 7018 +2827 2850 +2827 8484 +2827 8166 +2827 6760 +2827 7753 +2827 4779 +2827 8994 +2827 3799 +2827 9808 +2827 9432 +2827 3491 +2827 5941 +2827 5175 +2827 8888 +2827 9913 +2827 9615 +2827 5533 +2828 3975 +2828 5257 +2828 4492 +2828 7054 +2828 4112 +2828 4499 +2828 4382 +2828 9761 +2828 7202 +2828 6199 +2828 9929 +2828 8525 +2828 6861 +2828 6612 +2828 9177 +2828 7119 +2828 5200 +2828 5736 +2828 4712 +2828 8307 +2828 5876 +2829 7191 +2829 5785 +2829 6559 +2829 7587 +2829 5036 +2829 9952 +2829 7506 +2829 5588 +2829 6649 +2829 4751 +2829 4574 +2829 9704 +2829 3183 +2829 8404 +2829 8188 +2829 7165 +2830 7907 +2830 7748 +2830 3077 +2830 8710 +2830 5671 +2830 9578 +2830 3980 +2830 6701 +2830 7325 +2830 2833 +2830 8082 +2830 7349 +2830 8938 +2830 6341 +2831 3436 +2831 5135 +2831 6167 +2831 3609 +2831 9242 +2831 6298 +2831 5536 +2831 7715 +2831 6856 +2831 8648 +2831 8780 +2831 5454 +2831 4821 +2831 8409 +2831 3930 +2831 3806 +2831 4712 +2831 3051 +2831 8940 +2831 9584 +2832 7296 +2832 3184 +2832 4739 +2832 7748 +2832 7145 +2832 6539 +2832 9552 +2832 6385 +2832 2866 +2832 9748 +2832 5014 +2832 2903 +2832 3448 +2832 3001 +2832 4931 +2832 4629 +2833 8961 +2833 6403 +2833 3590 +2833 5139 +2833 7713 +2833 4527 +2833 5709 +2833 3661 +2833 7124 +2833 3670 +2833 7524 +2833 4062 +2833 3168 +2833 9188 +2833 5351 +2833 3181 +2833 7926 +2834 9731 +2834 9961 +2834 8685 +2834 4206 +2834 6356 +2834 3326 +2834 9786 +2834 7420 +2834 8106 +2834 6398 +2835 5967 +2835 2943 +2835 9732 +2835 4839 +2835 8105 +2835 9131 +2835 8908 +2835 6036 +2835 2902 +2835 7670 +2835 5914 +2835 8220 +2835 8733 +2836 3904 +2836 3074 +2836 7779 +2836 5284 +2836 8746 +2836 8439 +2836 5964 +2836 7021 +2836 5935 +2836 6552 +2836 3437 +2836 9688 +2836 6780 +2836 6538 +2837 7808 +2837 3206 +2837 3208 +2837 8093 +2837 2981 +2837 3250 +2837 5577 +2837 5437 +2837 5567 +2837 8256 +2837 7626 +2837 8419 +2837 3428 +2837 7535 +2837 3827 +2837 9849 +2837 8827 +2838 4777 +2838 8078 +2838 5777 +2838 6202 +2838 7254 +2838 7961 +2838 7610 +2838 6781 +2839 4929 +2839 9445 +2839 9398 +2839 8328 +2839 3306 +2839 5815 +2839 9869 +2839 6132 +2839 4438 +2839 7959 +2839 5257 +2839 5593 +2839 6938 +2839 5147 +2839 7450 +2839 7710 +2839 4255 +2840 9857 +2840 6468 +2840 9142 +2840 4502 +2840 8137 +2840 3812 +2840 4047 +2840 7664 +2840 4148 +2840 8725 +2840 8150 +2840 8727 +2840 6484 +2840 5722 +2840 9150 +2840 6053 +2841 7265 +2841 5602 +2841 8387 +2841 7909 +2841 5926 +2841 6057 +2841 5768 +2841 6124 +2841 3119 +2841 4337 +2841 7032 +2841 3407 +2841 4060 +2841 4573 +2842 3972 +2842 5521 +2842 5959 +2842 8122 +2842 9148 +2842 9918 +2842 9536 +2842 4295 +2842 8163 +2842 8037 +2842 3814 +2842 5356 +2842 4078 +2842 6646 +2842 5117 +2842 8062 +2843 8327 +2843 7581 +2843 6824 +2843 8493 +2843 5936 +2843 6069 +2843 4042 +2843 4305 +2843 6484 +2843 3931 +2843 3166 +2843 8671 +2843 3809 +2844 9477 +2844 4366 +2844 7960 +2844 5160 +2844 7985 +2844 3762 +2844 3268 +2844 6862 +2844 6609 +2844 4690 +2844 5591 +2844 6744 +2844 5857 +2844 4454 +2844 9447 +2844 3184 +2844 9331 +2844 3197 +2845 5153 +2845 5669 +2845 5382 +2845 3975 +2845 8939 +2845 6128 +2845 6035 +2845 7721 +2845 5273 +2845 8187 +2845 9247 +2846 3842 +2846 3718 +2846 3847 +2846 9999 +2846 6803 +2846 2967 +2846 7708 +2846 4129 +2846 9126 +2846 6316 +2846 4016 +2846 4531 +2846 8009 +2846 6076 +2846 8137 +2846 4430 +2846 7888 +2846 6601 +2846 7524 +2846 8935 +2846 6265 +2846 6909 +2847 6017 +2847 4802 +2847 3547 +2847 3012 +2847 7109 +2847 9345 +2847 8556 +2847 9991 +2847 8657 +2847 6139 +2847 8092 +2847 4670 +2847 8319 +2848 2880 +2848 8880 +2848 5788 +2848 6571 +2848 3140 +2848 3177 +2848 9591 +2848 3987 +2848 8629 +2848 8791 +2848 7837 +2849 3459 +2849 4615 +2849 9902 +2849 7183 +2849 5667 +2849 8212 +2849 5486 +2849 4184 +2849 3610 +2849 3419 +2849 9277 +2849 5502 +2850 5697 +2850 3333 +2850 3846 +2850 8455 +2850 5417 +2850 6547 +2850 7283 +2850 4852 +2850 7891 +2850 9911 +2850 4383 +2850 5531 +2850 2973 +2850 3774 +2850 5823 +2851 5729 +2851 8932 +2851 6439 +2851 3363 +2851 3530 +2851 5134 +2851 6269 +2851 4919 +2851 5470 +2851 7098 +2851 6474 +2851 7453 +2851 6398 +2851 2901 +2852 8202 +2852 6445 +2852 5527 +2852 8217 +2852 9632 +2852 2989 +2852 7220 +2852 8894 +2852 3938 +2852 9811 +2852 4316 +2852 5734 +2852 7403 +2852 6511 +2852 4080 +2852 9333 +2852 4729 +2853 5376 +2853 6403 +2853 7945 +2853 3750 +2853 5679 +2853 4020 +2853 7609 +2853 5309 +2853 6475 +2853 9811 +2853 6236 +2853 4703 +2853 7403 +2853 9708 +2853 6514 +2853 8314 +2853 9981 +2854 7939 +2854 4741 +2854 6790 +2854 8455 +2854 9225 +2854 3466 +2854 8460 +2854 3728 +2854 4765 +2854 5540 +2854 6453 +2854 8249 +2854 4411 +2854 4285 +2854 9664 +2854 9540 +2854 8392 +2854 3938 +2854 8291 +2854 5346 +2854 7019 +2855 5568 +2855 4614 +2855 4838 +2855 9354 +2855 3724 +2855 4941 +2855 9843 +2855 9943 +2855 8920 +2855 3743 +2856 6050 +2856 5153 +2856 7432 +2856 4329 +2856 9738 +2856 3507 +2856 3822 +2856 3742 +2856 6300 +2856 6365 +2856 3806 +2856 4565 +2857 3908 +2857 6917 +2857 7110 +2857 3912 +2857 7383 +2857 5454 +2857 3821 +2857 7646 +2857 8791 +2857 6788 +2857 8375 +2857 8158 +2857 5055 +2858 4993 +2858 9893 +2858 5798 +2858 3847 +2858 3531 +2858 7023 +2858 6416 +2858 9810 +2858 6579 +2858 8116 +2858 8990 +2858 5907 +2858 6777 +2858 6238 +2859 4320 +2859 5067 +2859 3684 +2859 9767 +2859 5962 +2859 4939 +2859 7858 +2859 9294 +2859 9617 +2859 8405 +2859 9689 +2859 9434 +2859 2877 +2859 4254 +2859 6741 +2860 4740 +2860 2951 +2860 4750 +2860 4624 +2860 5142 +2860 8096 +2860 4008 +2860 8491 +2860 5169 +2860 4030 +2860 4287 +2860 6592 +2860 4931 +2860 4039 +2860 9813 +2860 8280 +2860 9334 +2860 2939 +2860 7036 +2861 7792 +2861 6595 +2861 8460 +2861 6887 +2861 7148 +2861 8880 +2861 5272 +2861 3635 +2861 3924 +2861 6078 +2861 8342 +2861 3479 +2861 9976 +2861 5694 +2861 7805 +2861 7422 +2861 7295 +2862 6277 +2862 6553 +2862 8495 +2862 7217 +2862 7862 +2862 5816 +2862 9412 +2862 9029 +2862 4169 +2862 3256 +2862 9829 +2862 7400 +2862 6131 +2862 8564 +2862 6517 +2863 5634 +2863 7177 +2863 9615 +2863 7330 +2863 7844 +2863 8487 +2863 8491 +2863 9648 +2863 6194 +2863 5311 +2863 7366 +2863 4338 +2864 4846 +2864 6282 +2864 3182 +2864 3354 +2864 9627 +2864 7069 +2864 9503 +2864 9150 +2864 8515 +2864 9165 +2864 4945 +2864 4693 +2864 9177 +2864 5474 +2864 4970 +2864 9198 +2864 6642 +2864 7027 +2865 8576 +2865 4484 +2865 7942 +2865 4745 +2865 7956 +2865 3477 +2865 5915 +2865 5406 +2865 5539 +2865 6558 +2865 4798 +2865 5045 +2865 7623 +2865 7892 +2865 7531 +2866 8032 +2866 8228 +2866 8101 +2866 4267 +2866 7633 +2866 7636 +2866 8244 +2866 7062 +2866 4183 +2866 6744 +2867 7360 +2867 5602 +2867 7025 +2867 4168 +2867 6795 +2867 7632 +2867 9041 +2867 9159 +2867 2871 +2867 9182 +2868 4865 +2868 4870 +2868 4747 +2868 5269 +2868 5159 +2868 5800 +2868 4786 +2868 9653 +2868 3134 +2868 8911 +2868 9553 +2868 6228 +2868 8166 +2868 2926 +2868 9149 +2868 5237 +2869 9602 +2869 4746 +2869 7179 +2869 5265 +2869 7966 +2869 3881 +2869 6955 +2869 4402 +2869 5969 +2869 8953 +2869 7140 +2869 4200 +2869 3702 +2869 7801 +2870 7553 +2870 7651 +2870 3397 +2870 5224 +2870 6379 +2870 3918 +2870 3376 +2870 4616 +2870 6259 +2870 5556 +2870 3827 +2870 7699 +2870 5498 +2870 8350 +2871 5697 +2871 6466 +2871 5962 +2871 4077 +2871 5614 +2871 4753 +2871 7222 +2871 4184 +2871 7354 +2871 8639 +2871 4668 +2871 6813 +2871 6495 +2872 8964 +2872 3211 +2872 6808 +2872 6300 +2872 5927 +2872 8746 +2872 9774 +2872 7049 +2872 9284 +2872 9419 +2872 7502 +2872 8018 +2872 6229 +2872 3038 +2872 9232 +2872 8548 +2872 3432 +2872 3439 +2872 4279 +2873 6660 +2873 5515 +2873 3981 +2873 3728 +2873 6425 +2873 7453 +2873 9248 +2873 5298 +2873 7348 +2873 4282 +2873 9927 +2873 8035 +2873 6488 +2873 4831 +2873 4065 +2873 7779 +2873 8815 +2873 5745 +2873 7927 +2874 9867 +2874 6037 +2874 3227 +2874 9893 +2874 9511 +2874 6702 +2874 7343 +2874 5943 +2874 6842 +2874 8891 +2874 5063 +2874 8268 +2874 9811 +2874 7769 +2874 5987 +2874 5201 +2874 4840 +2874 3434 +2874 9964 +2874 4474 +2874 3323 +2875 6049 +2875 5378 +2875 6635 +2875 4807 +2875 3470 +2875 3571 +2875 3710 +2876 4579 +2876 9550 +2876 9103 +2876 3729 +2876 5875 +2876 9621 +2876 3352 +2876 7961 +2876 9914 +2876 3035 +2876 4154 +2877 6912 +2877 3587 +2877 7815 +2877 9325 +2877 5469 +2877 4256 +2877 6562 +2877 9842 +2877 9647 +2877 5562 +2877 3646 +2877 7359 +2877 7254 +2877 4653 +2877 8159 +2877 5347 +2877 4074 +2877 6254 +2878 6080 +2878 3267 +2878 5046 +2878 3271 +2878 6471 +2878 6203 +2878 7868 +2878 4382 +2879 6016 +2879 4874 +2879 8207 +2879 7449 +2879 3232 +2879 3122 +2879 3118 +2879 9278 +2879 6863 +2879 8827 +2879 5092 +2879 5225 +2879 6506 +2879 4978 +2879 3195 +2880 3681 +2880 4998 +2880 9640 +2880 9706 +2880 5100 +2880 4974 +2880 7637 +2880 9558 +2880 6779 +2880 6173 +2881 8200 +2881 3723 +2881 9245 +2881 5155 +2881 9134 +2881 6045 +2881 7217 +2881 2999 +2881 7866 +2881 9922 +2881 5190 +2881 6747 +2881 7399 +2881 6894 +2881 6774 +2881 6619 +2882 7828 +2882 4679 +2882 6088 +2882 7465 +2882 3948 +2882 2898 +2882 6612 +2882 9468 +2882 5981 +2882 9663 +2883 3489 +2883 8324 +2883 6947 +2883 6500 +2883 3045 +2883 3016 +2883 4845 +2883 9102 +2883 8527 +2883 4840 +2883 7503 +2883 4628 +2883 6350 +2883 8980 +2883 6052 +2884 9513 +2884 6477 +2884 7447 +2884 5241 +2884 3418 +2884 6844 +2885 3616 +2885 3105 +2885 4290 +2885 5510 +2885 7809 +2885 8009 +2885 5293 +2885 9678 +2885 4579 +2885 4255 +2886 9850 +2886 8041 +2886 5993 +2886 7858 +2886 5363 +2886 4534 +2886 3460 +2886 6106 +2886 7675 +2886 5055 +2887 7064 +2887 4633 +2887 8859 +2887 8349 +2887 6302 +2887 9634 +2887 2989 +2887 4937 +2887 3282 +2887 9299 +2887 7897 +2887 9690 +2887 5986 +2887 7718 +2887 7656 +2887 7282 +2887 5492 +2888 6401 +2888 3998 +2888 7683 +2888 6438 +2888 6407 +2888 3434 +2888 9575 +2888 7405 +2888 9647 +2888 4848 +2888 8082 +2888 4531 +2888 5302 +2888 3842 +2888 7647 +2889 9443 +2889 3141 +2889 7080 +2889 3115 +2889 4558 +2889 8785 +2889 6962 +2889 5651 +2889 3094 +2889 8031 +2889 4860 +2889 3229 +2889 8542 +2890 5730 +2890 8939 +2890 3717 +2890 9638 +2890 6183 +2890 4393 +2890 4586 +2890 2955 +2890 8809 +2890 4077 +2890 2986 +2890 6034 +2890 6198 +2890 8425 +2890 9147 +2890 5342 +2891 9094 +2891 9624 +2891 4762 +2891 9888 +2891 9008 +2891 7588 +2891 5166 +2891 3264 +2891 3016 +2891 5580 +2891 8397 +2891 6877 +2891 6772 +2892 9878 +2892 5136 +2892 4758 +2892 3607 +2892 7718 +2892 5929 +2892 8492 +2892 5952 +2892 3779 +2892 3399 +2892 3919 +2892 6236 +2892 9744 +2892 9442 +2892 7280 +2892 5756 +2893 5216 +2893 9248 +2893 3713 +2893 5156 +2893 6881 +2893 7432 +2893 8714 +2893 4644 +2893 5232 +2893 7097 +2893 6590 +2893 4759 +2893 5976 +2893 7419 +2893 8444 +2893 3647 +2894 5217 +2894 9830 +2894 7020 +2894 3279 +2894 7535 +2894 4697 +2894 3013 +2894 8859 +2894 5276 +2895 7968 +2895 9981 +2895 3048 +2895 9344 +2895 9519 +2895 7089 +2895 6738 +2895 7472 +2895 9781 +2895 6487 +2895 4026 +2895 7067 +2896 7296 +2896 8323 +2896 3333 +2896 8002 +2896 5392 +2896 4908 +2896 6621 +2896 8117 +2896 8762 +2896 4669 +2896 5570 +2896 4937 +2896 4308 +2896 9820 +2896 7226 +2896 4065 +2896 6375 +2896 9462 +2896 9086 +2897 7122 +2897 8261 +2897 3581 +2897 5996 +2897 4301 +2897 5716 +2897 5656 +2897 6617 +2897 9850 +2897 8783 +2897 3869 +2897 8653 +2898 6400 +2898 8992 +2898 7141 +2898 5287 +2898 4520 +2898 5578 +2898 9132 +2898 6042 +2898 3828 +2898 9325 +2898 5143 +2898 4441 +2898 2986 +2898 5637 +2899 5762 +2899 5124 +2899 3849 +2899 5147 +2899 6048 +2899 9392 +2899 7606 +2899 7998 +2899 6852 +2899 4294 +2899 6350 +2899 4820 +2899 8922 +2899 7643 +2899 5344 +2899 3815 +2899 7402 +2899 3701 +2899 3194 +2900 4608 +2900 9227 +2900 3087 +2900 7704 +2900 4380 +2900 8221 +2900 7969 +2900 4393 +2900 6572 +2900 6066 +2900 8500 +2900 8253 +2900 7110 +2900 8695 +2900 3040 +2900 4073 +2900 6767 +2900 6513 +2900 4338 +2900 5737 +2900 6648 +2900 9081 +2901 4867 +2901 3368 +2901 4396 +2901 7751 +2901 9300 +2901 3159 +2901 3164 +2901 5085 +2901 7781 +2901 3793 +2901 9580 +2901 9968 +2901 7124 +2901 3579 +2902 9248 +2902 8243 +2902 7963 +2902 6726 +2902 5670 +2902 9867 +2902 3789 +2902 4462 +2902 7601 +2902 3187 +2902 6068 +2902 7449 +2902 3892 +2902 9658 +2902 8143 +2902 9373 +2903 8450 +2903 7555 +2903 6530 +2903 8726 +2903 7195 +2903 7200 +2903 9896 +2903 3511 +2903 6458 +2903 3516 +2903 9662 +2903 5956 +2903 3913 +2903 9557 +2903 5206 +2903 8919 +2903 3181 +2903 2932 +2903 6718 +2903 4859 +2904 9995 +2904 8708 +2904 7237 +2904 5508 +2904 4267 +2904 3726 +2904 6960 +2904 7193 +2904 5849 +2904 4346 +2904 7709 +2904 6110 +2905 2976 +2905 7393 +2905 8508 +2905 5291 +2905 7847 +2905 9550 +2905 4336 +2905 3662 +2905 3392 +2905 8119 +2905 8697 +2905 5532 +2905 6623 +2906 3906 +2906 5060 +2906 6502 +2906 3846 +2906 7049 +2906 9742 +2906 6420 +2906 3349 +2906 3869 +2907 3168 +2907 8715 +2907 3367 +2907 7049 +2907 4295 +2907 5324 +2907 8110 +2907 6510 +2907 5333 +2907 8183 +2907 7032 +2907 5658 +2907 4911 +2907 7775 +2908 5388 +2908 4888 +2908 7834 +2908 5027 +2908 6055 +2908 4394 +2908 7349 +2908 8257 +2908 4806 +2908 3340 +2908 4558 +2908 6231 +2908 3802 +2908 3042 +2908 9060 +2908 9194 +2908 6511 +2909 9728 +2909 8968 +2909 6793 +2909 7711 +2909 3106 +2909 7331 +2909 7858 +2909 3508 +2909 8501 +2909 5570 +2909 6598 +2909 4434 +2909 8667 +2909 9952 +2909 8806 +2909 7021 +2909 7279 +2909 3324 +2910 7003 +2910 4068 +2910 7845 +2910 6535 +2910 3913 +2910 6540 +2910 6434 +2910 9041 +2910 7891 +2910 4180 +2910 6197 +2910 6292 +2910 8873 +2910 3515 +2910 7692 +2911 3970 +2911 5001 +2911 9615 +2911 6434 +2911 7459 +2911 6955 +2911 2988 +2911 9901 +2911 3505 +2911 4786 +2911 3914 +2911 6605 +2911 9938 +2911 7635 +2911 4574 +2911 5863 +2911 7287 +2912 4163 +2912 3652 +2912 8038 +2912 8311 +2912 9126 +2912 6097 +2912 5746 +2912 8691 +2912 4606 +2912 8663 +2912 3160 +2912 4442 +2912 8027 +2912 9852 +2912 5565 +2912 8894 +2913 5026 +2913 7813 +2913 3720 +2913 3881 +2913 9674 +2913 6252 +2913 3887 +2913 4351 +2913 6194 +2913 8824 +2913 8895 +2913 6434 +2913 3263 +2914 9762 +2914 4388 +2914 4038 +2914 4390 +2914 8584 +2914 8043 +2914 4780 +2914 4893 +2914 4309 +2914 6414 +2914 5604 +2914 7965 +2914 8479 +2915 7649 +2915 8579 +2915 6917 +2915 8038 +2915 5736 +2915 8299 +2915 4592 +2915 9077 +2915 9688 +2915 8059 +2915 6044 +2915 8677 +2916 3841 +2916 4744 +2916 7186 +2916 3867 +2916 7197 +2916 6176 +2916 6947 +2916 7207 +2916 3506 +2916 3507 +2916 6848 +2916 6944 +2916 5572 +2916 4834 +2916 8677 +2916 8550 +2916 3304 +2916 9706 +2916 3686 +2916 4211 +2916 4019 +2917 9680 +2917 5858 +2917 6571 +2917 5092 +2917 5606 +2917 3755 +2917 7632 +2917 8355 +2917 9141 +2917 4792 +2917 9083 +2917 8542 +2917 9461 +2918 8737 +2918 4930 +2918 5859 +2918 3301 +2918 6054 +2918 3560 +2918 5515 +2918 4398 +2918 5044 +2918 9845 +2918 5529 +2918 8573 +2919 9188 +2919 7974 +2919 3557 +2919 4553 +2919 5623 +2919 4077 +2919 8974 +2919 8559 +2919 8082 +2919 4179 +2919 2971 +2919 6044 +2919 7005 +2919 8764 +2920 7008 +2920 9923 +2920 4165 +2920 3371 +2920 4591 +2920 4592 +2920 8692 +2920 9398 +2920 8795 +2920 4860 +2921 4355 +2921 7813 +2921 4006 +2921 9322 +2921 5908 +2921 5205 +2921 4154 +2921 7034 +2921 7007 +2922 3075 +2922 7300 +2922 4621 +2922 3476 +2922 9732 +2922 4649 +2922 7350 +2922 8510 +2922 9809 +2922 4694 +2922 7000 +2922 9692 +2922 8161 +2922 8937 +2922 8686 +2922 8828 +2923 4741 +2923 5415 +2923 5674 +2923 7527 +2923 5740 +2923 5266 +2923 4052 +2923 2956 +2923 7239 +2924 9699 +2924 8804 +2924 7591 +2924 7948 +2924 7343 +2924 4913 +2924 9650 +2924 4115 +2924 7097 +2924 7995 +2924 9598 +2924 9119 +2925 8321 +2925 5379 +2925 8229 +2925 5194 +2925 7212 +2925 8909 +2925 6287 +2925 8084 +2925 4821 +2925 6650 +2925 6782 +2926 4060 +2926 9091 +2926 6788 +2926 4517 +2926 7592 +2926 4716 +2926 3823 +2926 9612 +2926 5876 +2926 5338 +2926 6907 +2926 5148 +2926 6941 +2926 6718 +2926 8485 +2927 4064 +2927 6562 +2927 6152 +2927 3467 +2927 3564 +2927 8271 +2927 8080 +2927 6664 +2927 5623 +2927 4760 +2927 4538 +2927 9403 +2928 6626 +2928 5075 +2928 6538 +2928 5719 +2928 5186 +2928 6607 +2928 6387 +2928 4855 +2928 9144 +2928 3940 +2928 3583 +2928 7901 +2928 7551 +2929 8706 +2929 9612 +2929 4740 +2929 8475 +2929 4381 +2929 4385 +2929 8357 +2929 5167 +2929 5684 +2929 2973 +2929 4945 +2929 3922 +2929 7637 +2929 9689 +2929 4060 +2929 9693 +2929 7401 +2929 3053 +2929 5748 +2930 3937 +2930 8003 +2930 5029 +2930 9063 +2930 9098 +2930 7239 +2930 8908 +2930 8654 +2930 3570 +2930 4233 +2930 9562 +2930 8106 +2930 9407 +2931 6081 +2931 6658 +2931 5380 +2931 8230 +2931 4071 +2931 4013 +2931 3056 +2931 7217 +2931 8338 +2931 3606 +2931 8855 +2931 5884 +2931 2994 +2932 7303 +2932 9739 +2932 6286 +2932 7450 +2932 7835 +2932 8605 +2932 3113 +2932 9259 +2932 9159 +2932 5066 +2932 9936 +2932 4061 +2932 5865 +2932 3705 +2933 6779 +2933 6473 +2933 8586 +2933 3947 +2933 7628 +2933 5678 +2933 8911 +2933 9841 +2933 3605 +2933 6199 +2933 4345 +2933 9967 +2934 6038 +2934 4236 +2934 4374 +2934 8240 +2934 4646 +2934 4393 +2934 7600 +2934 4409 +2934 6602 +2934 3688 +2934 8298 +2934 7406 +2934 7920 +2934 8186 +2934 8573 +2935 5248 +2935 4499 +2935 3097 +2935 3872 +2935 2985 +2935 7666 +2935 4528 +2935 8076 +2935 8653 +2935 4815 +2935 3409 +2935 4050 +2935 4564 +2935 4774 +2935 8690 +2935 9203 +2935 6012 +2935 7294 +2935 4083 +2936 7041 +2936 6690 +2936 7595 +2936 4735 +2936 9277 +2936 7062 +2936 4023 +2936 4856 +2936 7961 +2936 9210 +2936 7772 +2936 6250 +2936 5982 +2937 4032 +2937 4935 +2937 9162 +2937 7079 +2937 4620 +2937 4624 +2937 6897 +2937 8873 +2937 3768 +2937 5721 +2937 9258 +2937 6399 +2938 9221 +2938 7495 +2938 9180 +2938 5708 +2938 4397 +2938 7854 +2938 6385 +2938 6267 +2938 5212 +2938 6558 +2938 3551 +2939 6881 +2939 9189 +2939 8838 +2939 7242 +2939 9015 +2939 7464 +2939 5172 +2939 7831 +2939 3839 +2939 5413 +2939 3754 +2939 8639 +2940 7297 +2940 8840 +2940 6422 +2940 5914 +2940 5274 +2940 7589 +2940 4390 +2940 4654 +2940 3397 +2940 4436 +2940 5461 +2940 6879 +2940 5600 +2940 7142 +2940 4212 +2940 7926 +2940 6648 +2941 8571 +2941 5350 +2941 8841 +2941 6826 +2941 7918 +2941 4592 +2941 9425 +2941 8683 +2941 8313 +2941 5307 +2941 6814 +2942 9095 +2942 5645 +2942 6164 +2942 7704 +2942 4261 +2942 8879 +2942 9525 +2942 3903 +2942 5443 +2942 3145 +2942 5579 +2942 8908 +2942 4308 +2942 8672 +2942 3056 +2942 9203 +2942 5364 +2942 7797 +2942 5247 +2943 7424 +2943 9761 +2943 5925 +2943 4356 +2943 3047 +2943 3185 +2943 7627 +2943 3469 +2943 4365 +2943 6165 +2943 9942 +2943 3769 +2943 7481 +2943 4349 +2943 7166 +2943 5381 +2944 6785 +2944 7106 +2944 4229 +2944 5894 +2944 4102 +2944 7241 +2944 3342 +2944 8837 +2944 8083 +2944 8309 +2944 2982 +2944 5422 +2944 8477 +2945 7527 +2945 5192 +2945 6442 +2945 3058 +2945 7986 +2945 9075 +2945 6421 +2945 5403 +2945 7580 +2945 6837 +2946 3488 +2946 3971 +2946 4072 +2946 5806 +2946 6256 +2946 3057 +2946 6869 +2946 5883 +2947 8078 +2947 4245 +2947 4886 +2947 4759 +2947 6936 +2947 6688 +2947 7846 +2947 4391 +2947 8763 +2947 7519 +2947 5856 +2947 6369 +2947 5859 +2947 3879 +2947 8814 +2947 3315 +2947 3071 +2948 5125 +2948 6666 +2948 6804 +2948 5662 +2948 6699 +2948 8620 +2948 8494 +2948 3120 +2948 3667 +2948 8499 +2948 4020 +2948 7966 +2948 8503 +2948 9026 +2948 8781 +2948 6611 +2948 6104 +2948 9946 +2948 3443 +2948 8318 +2948 5118 +2949 6914 +2949 7940 +2949 9068 +2949 9474 +2949 9105 +2949 9241 +2949 9476 +2949 9142 +2949 8377 +2949 6282 +2949 7486 +2949 3138 +2949 3781 +2949 7245 +2949 4192 +2949 4717 +2949 5743 +2949 3441 +2949 7540 +2949 8054 +2949 9207 +2949 6140 +2950 5219 +2950 5220 +2950 5704 +2950 9292 +2950 7757 +2950 7028 +2950 6363 +2950 3095 +2950 6969 +2950 8730 +2950 8863 +2951 4229 +2951 9654 +2951 9828 +2951 7973 +2951 9942 +2951 2969 +2951 7900 +2951 6815 +2952 7426 +2952 3719 +2952 6609 +2952 5305 +2952 5945 +2952 7311 +2952 8380 +2952 3357 +2953 5254 +2953 8077 +2953 7323 +2953 3491 +2953 5546 +2953 6574 +2953 6977 +2953 4301 +2953 6606 +2953 3725 +2953 3794 +2953 9690 +2953 4188 +2953 5086 +2953 4324 +2953 8562 +2953 6131 +2953 5880 +2953 9851 +2954 9732 +2954 3589 +2954 7304 +2954 5513 +2954 5642 +2954 7319 +2954 7842 +2954 6184 +2954 7084 +2954 4146 +2954 3252 +2954 9420 +2954 9048 +2954 5467 +2954 6880 +2954 6881 +2954 9706 +2954 7975 +2954 9340 +2955 9484 +2955 6544 +2955 8850 +2955 5152 +2955 5538 +2955 8355 +2955 4266 +2955 6464 +2955 5576 +2955 3191 +2955 4813 +2955 6738 +2955 6631 +2955 5872 +2955 3318 +2955 5111 +2955 5752 +2955 7677 +2955 8575 +2956 9217 +2956 3330 +2956 9488 +2956 7582 +2956 5535 +2956 7715 +2956 6054 +2956 7070 +2956 6367 +2956 4930 +2956 5955 +2956 5974 +2956 7519 +2956 7648 +2956 3196 +2956 5866 +2956 8811 +2956 9715 +2956 9845 +2956 4220 +2957 4007 +2957 9067 +2957 5614 +2957 6541 +2957 9520 +2957 4881 +2957 3289 +2957 8985 +2957 6906 +2957 8863 +2957 3615 +2958 3659 +2958 9995 +2958 3562 +2958 4268 +2958 6541 +2958 6224 +2958 7858 +2958 6099 +2958 7318 +2958 8119 +2958 3331 +2958 6175 +2959 6955 +2959 3884 +2959 4267 +2959 9757 +2959 9899 +2959 5425 +2959 8628 +2959 5823 +2959 8129 +2959 6619 +2959 6876 +2959 7267 +2959 3564 +2959 3951 +2959 6514 +2959 6572 +2960 6496 +2960 7106 +2960 3620 +2960 9958 +2960 9830 +2960 3886 +2960 9174 +2960 9178 +2960 3483 +2960 4506 +2961 7330 +2961 7877 +2961 4810 +2961 3246 +2961 4271 +2961 7536 +2961 9496 +2961 7796 +2961 7158 +2961 6744 +2961 3268 +2961 9226 +2961 9023 +2962 3806 +2962 4386 +2962 7395 +2962 7204 +2962 8549 +2962 4584 +2962 5033 +2962 8618 +2962 4834 +2962 5936 +2962 8723 +2962 9590 +2962 6877 +2962 7509 +2963 6144 +2963 7236 +2963 9895 +2963 7912 +2963 5258 +2963 8107 +2963 5234 +2963 9813 +2963 4144 +2963 9522 +2963 3829 +2963 3860 +2963 5974 +2963 8890 +2963 8917 +2964 4193 +2964 5378 +2964 7322 +2964 5132 +2964 7179 +2964 6252 +2964 8258 +2964 8655 +2964 3890 +2964 5939 +2964 4570 +2964 6575 +2964 4019 +2965 8352 +2965 7753 +2965 5319 +2965 6032 +2965 6714 +2965 3550 +2966 3216 +2966 8226 +2966 7624 +2966 6953 +2966 4450 +2966 6289 +2966 8498 +2966 4918 +2966 7832 +2966 9083 +2967 5504 +2967 5952 +2967 9540 +2967 6024 +2967 4876 +2967 7217 +2967 5342 +2967 5014 +2967 7256 +2967 8164 +2967 3290 +2967 7930 +2967 3199 +2968 6753 +2968 7298 +2968 5604 +2968 5996 +2968 8203 +2968 8141 +2968 5134 +2968 6543 +2968 7177 +2968 3162 +2968 5530 +2968 9983 +2969 7745 +2969 9731 +2969 4779 +2969 7640 +2969 5742 +2969 8466 +2969 9209 +2969 5204 +2969 4238 +2969 8985 +2969 4056 +2969 3972 +2969 5691 +2969 4444 +2969 7101 +2969 3903 +2970 6679 +2970 8340 +2970 3479 +2970 6811 +2970 5797 +2970 4525 +2970 5185 +2970 9546 +2970 3020 +2970 7258 +2970 7004 +2970 9315 +2970 5350 +2970 3560 +2970 6636 +2971 7682 +2971 4356 +2971 3215 +2971 5535 +2971 5420 +2971 3642 +2971 3013 +2971 5833 +2971 5706 +2971 6859 +2971 9809 +2971 4751 +2971 6876 +2971 9963 +2971 8428 +2971 9330 +2971 9471 +2972 3089 +2972 7497 +2972 8724 +2972 7759 +2972 4017 +2972 9498 +2972 8147 +2972 9844 +2972 5876 +2972 5076 +2972 6587 +2972 9434 +2973 3596 +2973 8973 +2973 5518 +2973 8471 +2973 4248 +2973 8222 +2973 3271 +2973 5918 +2973 5814 +2973 4514 +2973 8532 +2973 4566 +2973 6237 +2973 9571 +2973 8297 +2973 4976 +2973 6523 +2973 9342 +2973 7701 +2974 5984 +2974 6820 +2974 8581 +2974 4206 +2974 6894 +2974 6162 +2974 8270 +2974 5589 +2974 3705 +2974 4092 +2974 6813 +2974 4702 +2975 4250 +2975 9027 +2975 4581 +2975 9609 +2975 8395 +2975 7406 +2975 5584 +2975 4903 +2975 8786 +2975 9523 +2975 5291 +2975 6427 +2975 8477 +2976 4064 +2976 4546 +2976 7590 +2976 4490 +2976 4814 +2976 6960 +2976 9714 +2976 7315 +2976 5335 +2976 8760 +2976 6874 +2976 7036 +2976 3130 +2977 5314 +2977 3492 +2977 9253 +2977 3815 +2977 3497 +2977 9387 +2977 7054 +2977 4303 +2977 7797 +2977 7348 +2977 8829 +2977 7381 +2978 3264 +2978 8004 +2978 5925 +2978 6535 +2978 9673 +2978 9258 +2978 4429 +2978 8399 +2978 9201 +2978 4723 +2978 7028 +2978 7449 +2978 6457 +2978 8922 +2979 5124 +2979 5997 +2979 8415 +2979 6415 +2979 5074 +2979 9081 +2979 6681 +2979 3711 +2979 9337 +2979 5711 +2979 8925 +2979 4191 +2980 8739 +2980 9673 +2980 7147 +2980 6542 +2980 8948 +2980 3854 +2980 6456 +2980 9274 +2980 4956 +2980 8413 +2981 8064 +2981 8452 +2981 5541 +2981 7078 +2981 7721 +2981 6190 +2981 3475 +2981 3734 +2981 5689 +2981 5082 +2981 8315 +2981 5118 +2982 8709 +2982 8494 +2982 3110 +2982 6958 +2982 9519 +2982 3385 +2982 3935 +2982 6719 +2982 6083 +2982 5444 +2982 4178 +2982 4437 +2982 8663 +2982 4955 +2982 6623 +2982 4708 +2982 7794 +2983 9856 +2983 4494 +2983 7321 +2983 5786 +2983 6746 +2983 4902 +2983 5303 +2983 5944 +2983 8508 +2983 7875 +2983 5318 +2983 9421 +2983 7120 +2983 3161 +2983 4826 +2983 5216 +2983 6376 +2983 5866 +2983 6261 +2983 3690 +2984 8064 +2984 5248 +2984 6467 +2984 6088 +2984 8694 +2984 3916 +2984 4146 +2984 4419 +2984 3958 +2984 6936 +2984 9631 +2985 6171 +2985 8262 +2985 5672 +2985 7790 +2985 3503 +2985 7313 +2985 4242 +2985 3828 +2985 3990 +2985 9530 +2985 8955 +2985 6748 +2986 9328 +2986 9083 +2986 6990 +2986 9056 +2986 4106 +2986 7280 +2986 6545 +2986 8724 +2986 9655 +2986 5691 +2986 9962 +2986 8319 +2987 8322 +2987 3591 +2987 5649 +2987 5012 +2987 4892 +2987 5025 +2987 5027 +2987 3511 +2987 6969 +2987 8765 +2987 5315 +2987 5577 +2987 3283 +2987 7509 +2987 4321 +2987 5988 +2987 5733 +2987 5609 +2987 8697 +2988 9472 +2988 9350 +2988 6921 +2988 3597 +2988 5080 +2988 9365 +2988 8356 +2988 5670 +2988 5673 +2988 6831 +2988 7601 +2988 6488 +2988 4578 +2988 3432 +2988 6381 +2988 4594 +2988 3699 +2988 8568 +2989 5025 +2989 7235 +2989 9347 +2989 7300 +2989 7365 +2989 7275 +2989 4875 +2989 6350 +2989 5456 +2989 9902 +2989 4279 +2989 7064 +2989 9529 +2989 4541 +2989 4051 +2990 4866 +2990 9029 +2990 8444 +2990 5707 +2990 5122 +2990 3215 +2990 4723 +2990 6644 +2990 8693 +2990 6745 +2990 4638 +2990 3483 +2990 7004 +2990 9285 +2990 5503 +2991 6934 +2991 4033 +2991 8205 +2991 5518 +2991 4879 +2991 6422 +2991 7813 +2991 6816 +2991 4385 +2991 7848 +2991 3586 +2991 7229 +2991 4853 +2991 4384 +2991 9160 +2991 8719 +2991 6364 +2991 7925 +2991 5370 +2991 7547 +2992 8960 +2992 3077 +2992 5510 +2992 3468 +2992 6671 +2992 7314 +2992 4628 +2992 8025 +2992 3483 +2992 9769 +2992 5306 +2992 7099 +2992 5188 +2992 8909 +2992 5850 +2992 7641 +2992 3451 +2993 6272 +2993 9088 +2993 4694 +2993 5256 +2993 8592 +2993 5143 +2993 9496 +2993 8985 +2993 9126 +2993 4776 +2993 8617 +2993 6456 +2993 8523 +2993 5712 +2993 5972 +2993 3029 +2993 8662 +2993 7280 +2993 7284 +2993 5237 +2993 9976 +2994 6592 +2994 5185 +2994 8866 +2994 7105 +2994 3911 +2994 6828 +2994 4237 +2994 6542 +2994 4110 +2994 4859 +2994 5245 +2994 5886 +2994 8863 +2995 5003 +2995 7575 +2995 7878 +2995 7435 +2995 7154 +2995 8403 +2995 7188 +2995 6390 +2995 3511 +2995 5753 +2995 7386 +2996 3905 +2996 5512 +2996 8778 +2996 5003 +2996 7599 +2996 6035 +2996 6559 +2997 6960 +2997 7874 +2997 5281 +2997 3144 +2997 5900 +2997 3756 +2997 5408 +2997 5968 +2997 3408 +2997 3568 +2997 3224 +2997 5625 +2997 7135 +2998 7489 +2998 4802 +2998 8710 +2998 5479 +2998 4656 +2998 6513 +2998 8723 +2998 8757 +2998 6557 +2998 9428 +2998 6490 +2998 7227 +2998 5790 +2998 3165 +2998 3646 +2999 4613 +2999 8326 +2999 9996 +2999 4763 +2999 7069 +2999 8990 +2999 9627 +2999 8236 +2999 4527 +2999 5309 +2999 7358 +2999 8656 +2999 6486 +2999 5981 +2999 8421 +3000 9475 +3000 5542 +3000 8039 +3000 6378 +3000 5580 +3000 6158 +3000 8050 +3000 9365 +3000 4151 +3000 3896 +3000 9244 +3000 5354 +3000 6046 +3001 4895 +3001 8995 +3001 7387 +3001 6318 +3001 3727 +3001 5603 +3001 4693 +3001 4054 +3001 6051 +3001 8504 +3001 8282 +3001 3003 +3002 9665 +3002 4900 +3002 6887 +3002 9137 +3002 6901 +3002 9913 +3002 3388 +3002 6687 +3003 6713 +3003 5792 +3003 5282 +3003 8140 +3003 6886 +3003 3015 +3003 8678 +3003 8999 +3003 5676 +3003 9997 +3003 9780 +3003 6761 +3003 4932 +3003 9914 +3003 3037 +3004 5568 +3004 7204 +3004 5350 +3004 9217 +3004 9769 +3004 3431 +3004 8298 +3004 9880 +3004 6207 +3005 3492 +3005 6374 +3005 6537 +3005 3754 +3005 8738 +3005 6703 +3005 9265 +3005 7154 +3005 7870 +3005 6744 +3005 7012 +3005 4557 +3005 4879 +3005 6750 +3005 9477 +3006 8705 +3006 7427 +3006 5011 +3006 9859 +3006 5143 +3006 7192 +3006 4764 +3006 5539 +3006 6962 +3006 5427 +3006 7621 +3006 3022 +3006 3029 +3006 3806 +3006 3684 +3006 7270 +3006 3055 +3006 4085 +3007 9280 +3007 7072 +3007 6600 +3007 3786 +3007 4482 +3007 5358 +3007 3957 +3007 9367 +3007 4664 +3007 8441 +3007 9343 +3008 5903 +3008 3618 +3008 4746 +3008 6541 +3008 8240 +3008 3442 +3008 6004 +3008 9599 +3008 5180 +3008 3199 +3009 6274 +3009 8344 +3009 9633 +3009 6568 +3009 9399 +3009 6474 +3009 6334 +3009 4554 +3009 3144 +3009 7372 +3009 5842 +3009 4070 +3009 8553 +3009 5565 +3009 7932 +3010 7043 +3010 8455 +3010 6154 +3010 9870 +3010 7084 +3010 6066 +3010 4161 +3010 5186 +3010 5321 +3010 4172 +3010 6094 +3010 9298 +3010 7892 +3010 4056 +3010 5856 +3010 7396 +3010 3821 +3010 9972 +3010 6137 +3010 4986 +3010 4223 +3011 6850 +3011 9989 +3011 4359 +3011 3340 +3011 7888 +3011 9783 +3011 9437 +3011 5790 +3012 7291 +3012 5284 +3012 9925 +3012 6952 +3012 3990 +3012 7003 +3012 4055 +3012 3246 +3012 5745 +3012 6806 +3012 6871 +3012 9752 +3012 7396 +3012 4891 +3012 3101 +3012 9041 +3013 7818 +3013 3469 +3013 7709 +3013 7465 +3013 3115 +3013 5036 +3013 5295 +3013 8253 +3013 6846 +3013 3521 +3013 8438 +3013 3020 +3013 9593 +3013 3800 +3013 8044 +3013 8685 +3013 5618 +3013 5748 +3013 7416 +3014 5761 +3014 3888 +3014 5297 +3014 3603 +3014 5822 +3014 9526 +3014 6130 +3014 7943 +3014 8062 +3015 4451 +3015 7973 +3015 4807 +3015 3048 +3015 9065 +3015 5546 +3015 8748 +3015 5389 +3015 9454 +3015 3282 +3015 9130 +3015 4628 +3015 8221 +3016 4736 +3016 5040 +3016 8194 +3016 4713 +3016 8173 +3016 8174 +3016 5904 +3016 5240 +3016 3669 +3016 7990 +3016 6379 +3016 9656 +3016 7065 +3016 6539 +3016 6877 +3017 6176 +3017 9437 +3017 7494 +3017 3410 +3017 3023 +3017 5554 +3017 3157 +3017 4759 +3017 6489 +3017 7933 +3017 4837 +3018 3212 +3018 8338 +3018 9752 +3018 6553 +3018 3098 +3018 5021 +3018 8607 +3018 9640 +3018 8491 +3018 7725 +3018 9777 +3018 4150 +3018 4410 +3018 6633 +3018 4845 +3018 9076 +3018 6775 +3018 3192 +3019 7814 +3019 3471 +3019 3091 +3019 5158 +3019 4775 +3019 7982 +3019 8244 +3019 6348 +3019 4301 +3019 8031 +3019 3684 +3019 6525 +3019 9840 +3019 6389 +3019 9079 +3019 7421 +3020 3597 +3020 4761 +3020 9756 +3020 6434 +3020 6313 +3020 3242 +3020 3116 +3020 8241 +3020 8435 +3020 9143 +3020 5567 +3020 4178 +3020 5333 +3020 6742 +3020 9189 +3020 6637 +3020 3955 +3020 9844 +3021 7072 +3021 8130 +3021 5092 +3021 4807 +3021 8585 +3021 8621 +3021 4078 +3021 8899 +3021 4436 +3021 3445 +3021 9021 +3022 6753 +3022 6261 +3022 3529 +3022 4272 +3022 7195 +3022 8570 +3022 5535 +3023 7296 +3023 6805 +3023 4761 +3023 7582 +3023 4899 +3023 3236 +3023 8616 +3023 9641 +3023 5299 +3023 7495 +3023 9166 +3023 7760 +3023 5340 +3023 6622 +3023 6043 +3023 3624 +3023 7805 +3024 3686 +3024 4392 +3024 8330 +3024 5582 +3024 9232 +3024 5992 +3024 6195 +3024 8084 +3024 6038 +3024 9508 +3024 9834 +3025 6784 +3025 4355 +3025 3846 +3025 5514 +3025 4759 +3025 9111 +3025 6690 +3025 6059 +3025 6956 +3025 7100 +3025 5951 +3025 5707 +3025 7120 +3025 3423 +3025 7393 +3025 5106 +3025 3705 +3025 8827 +3026 5009 +3026 4624 +3026 9635 +3026 7300 +3026 9798 +3026 5350 +3026 5745 +3026 7496 +3026 9961 +3026 8843 +3026 9711 +3026 6032 +3026 6513 +3026 3442 +3026 6932 +3026 9402 +3026 4527 +3026 6364 +3026 8699 +3027 3585 +3027 4228 +3027 7313 +3027 6692 +3027 5930 +3027 8752 +3027 5473 +3027 7496 +3027 6734 +3027 7511 +3027 3933 +3027 3425 +3027 3175 +3027 3181 +3027 9464 +3028 3081 +3028 5003 +3028 4885 +3028 7575 +3028 5400 +3028 8348 +3028 9384 +3028 8493 +3028 4922 +3028 3409 +3028 5977 +3028 4648 +3028 9332 +3029 5891 +3029 6802 +3029 7449 +3029 7194 +3029 6046 +3029 3490 +3029 8240 +3029 6199 +3029 9016 +3029 8521 +3029 3918 +3029 7889 +3029 8049 +3029 5880 +3029 5245 +3030 5696 +3030 6659 +3030 5990 +3030 5825 +3030 5480 +3030 7979 +3030 5687 +3030 3852 +3030 8139 +3030 4715 +3030 7784 +3030 9308 +3030 5085 +3031 5761 +3031 6019 +3031 7439 +3031 8580 +3031 7835 +3031 3231 +3031 7840 +3031 7080 +3031 4138 +3031 5805 +3031 8750 +3031 6877 +3031 7728 +3031 4278 +3031 4797 +3031 4808 +3031 4428 +3031 9679 +3031 9297 +3031 6227 +3031 9893 +3031 5742 +3031 6767 +3031 6256 +3031 7921 +3032 8458 +3032 3857 +3032 5651 +3032 9750 +3032 5151 +3032 5154 +3032 7208 +3032 5169 +3032 8889 +3032 6203 +3032 5566 +3032 8640 +3032 6099 +3032 5468 +3032 4189 +3032 9509 +3032 4320 +3032 7651 +3033 4608 +3033 4499 +3033 4893 +3033 7328 +3033 5044 +3033 9525 +3033 8760 +3033 5438 +3033 5696 +3033 6218 +3033 6222 +3033 5841 +3033 5843 +3033 8789 +3033 3926 +3033 5467 +3033 9315 +3033 6888 +3033 8812 +3033 8943 +3034 9760 +3034 7460 +3034 7461 +3034 5703 +3034 8808 +3034 7627 +3034 6663 +3034 7764 +3034 8471 +3035 6913 +3035 4232 +3035 9101 +3035 7057 +3035 3098 +3035 9511 +3035 9525 +3035 3261 +3035 3139 +3035 6088 +3035 3793 +3035 6740 +3035 9182 +3035 8290 +3035 6258 +3035 3445 +3036 4483 +3036 9766 +3036 8643 +3036 4340 +3036 7267 +3036 6810 +3036 4667 +3036 3548 +3037 8896 +3037 9511 +3037 4566 +3037 8585 +3037 8650 +3037 6796 +3037 8013 +3037 3639 +3038 3810 +3038 4876 +3038 9511 +3038 6028 +3038 7370 +3038 4386 +3038 6960 +3038 6886 +3038 5300 +3038 7735 +3038 4930 +3039 4801 +3039 5570 +3039 5163 +3039 6852 +3039 4580 +3039 3079 +3039 9545 +3039 7243 +3039 7532 +3039 8941 +3039 3054 +3039 9517 +3039 7793 +3039 7446 +3039 6937 +3039 6382 +3039 9726 +3040 7044 +3040 7431 +3040 8075 +3040 3727 +3040 9878 +3040 4895 +3040 6322 +3040 6836 +3040 3514 +3040 8638 +3040 3903 +3040 3649 +3040 5960 +3040 6498 +3040 3305 +3041 6685 +3041 8496 +3041 9410 +3041 3557 +3041 6823 +3041 5971 +3041 8554 +3041 3671 +3041 5517 +3041 6863 +3041 7632 +3041 7253 +3041 5014 +3041 9993 +3041 7514 +3041 7580 +3042 7936 +3042 4480 +3042 4359 +3042 9887 +3042 6944 +3042 5295 +3042 9264 +3042 7473 +3042 8380 +3042 4807 +3042 8536 +3042 5337 +3042 7649 +3042 8930 +3042 4579 +3042 9444 +3042 6645 +3042 3576 +3043 5600 +3043 4000 +3043 5475 +3043 4232 +3043 6442 +3043 8050 +3043 6063 +3043 4370 +3043 6997 +3043 8342 +3043 5687 +3043 7577 +3043 4253 +3043 7422 +3044 5380 +3044 3174 +3044 9254 +3044 5927 +3044 9964 +3044 3245 +3044 3537 +3044 3826 +3044 4691 +3044 8213 +3044 7414 +3044 6935 +3044 3966 +3045 9264 +3045 5348 +3045 9868 +3045 4274 +3045 4494 +3045 8269 +3045 8560 +3045 9332 +3045 8558 +3045 3824 +3046 3741 +3046 3329 +3046 9993 +3046 9195 +3046 4109 +3046 9198 +3046 4977 +3046 7122 +3046 7061 +3046 9848 +3046 9824 +3046 3930 +3046 8717 +3047 6145 +3047 5730 +3047 9603 +3047 3749 +3047 3468 +3047 3500 +3047 3100 +3047 5475 +3047 8411 +3047 3479 +3047 7833 +3047 3386 +3047 8095 +3047 3388 +3048 9601 +3048 8971 +3048 3425 +3048 8850 +3048 6678 +3048 6814 +3048 8611 +3048 6581 +3048 4795 +3048 5183 +3048 5588 +3048 3926 +3048 4423 +3048 6120 +3048 6649 +3048 5754 +3048 6654 +3049 9536 +3049 8958 +3049 5986 +3049 7249 +3049 8106 +3049 9639 +3049 6797 +3049 9295 +3049 8368 +3049 4625 +3049 9155 +3049 9463 +3049 6552 +3049 8089 +3049 5722 +3049 9282 +3050 5250 +3050 9350 +3050 7438 +3050 7577 +3050 3482 +3050 7708 +3050 7844 +3050 3113 +3050 7484 +3050 9157 +3050 5958 +3050 5836 +3050 6233 +3050 4573 +3050 4967 +3050 6376 +3050 7100 +3050 7533 +3050 4599 +3050 6906 +3051 9120 +3051 8257 +3051 7429 +3051 5020 +3051 8818 +3051 8504 +3051 3161 +3051 6298 +3051 7131 +3051 5084 +3051 6652 +3051 6590 +3052 7649 +3052 5798 +3052 6892 +3052 9487 +3052 4784 +3052 4497 +3052 6355 +3052 7469 +3052 7766 +3052 5784 +3052 5465 +3052 6781 +3052 5886 +3053 6912 +3053 4894 +3053 6499 +3053 4165 +3053 8655 +3053 4404 +3053 8437 +3053 5178 +3053 6223 +3053 8782 +3053 9853 +3053 4158 +3053 8797 +3054 9600 +3054 4898 +3054 4165 +3054 4521 +3054 3602 +3054 9462 +3054 4440 +3054 4095 +3054 3068 +3055 9472 +3055 9473 +3055 9868 +3055 4885 +3055 7065 +3055 3877 +3055 5434 +3055 6723 +3055 6982 +3055 8523 +3055 9554 +3055 4696 +3055 9571 +3055 3686 +3055 8039 +3055 5870 +3056 6627 +3056 9637 +3056 7174 +3056 5673 +3056 3202 +3056 3213 +3056 5503 +3056 8914 +3056 9908 +3056 7369 +3056 5720 +3056 4294 +3056 3903 +3056 6021 +3057 9472 +3057 4103 +3057 5513 +3057 4301 +3057 4892 +3057 9760 +3057 6319 +3057 3510 +3057 4285 +3057 6724 +3057 9039 +3057 9171 +3057 8796 +3057 4595 +3057 6132 +3057 8829 +3058 6877 +3058 7205 +3058 8584 +3058 8854 +3058 8253 +3058 7477 +3058 8662 +3058 4763 +3058 8157 +3058 5310 +3059 7776 +3059 9858 +3059 4411 +3059 8989 +3059 9521 +3059 4775 +3059 7227 +3059 5561 +3059 7291 +3060 3488 +3060 5477 +3060 4450 +3060 8977 +3060 6029 +3060 9451 +3060 4720 +3060 9713 +3060 8916 +3060 3318 +3060 5084 +3061 3073 +3061 3847 +3061 8207 +3061 8087 +3061 3226 +3061 4769 +3061 6311 +3061 6572 +3061 4144 +3061 5945 +3061 6078 +3061 6593 +3061 4948 +3061 4438 +3061 9562 +3061 7906 +3061 5099 +3061 4607 +3062 7812 +3062 3859 +3062 3733 +3062 5534 +3062 6957 +3062 4014 +3062 9264 +3062 6574 +3062 6201 +3062 6610 +3062 4573 +3062 4717 +3062 5613 +3062 3952 +3062 7921 +3062 3577 +3062 6268 +3063 8457 +3063 9495 +3063 4765 +3063 3628 +3063 7335 +3063 8236 +3063 9777 +3063 9143 +3063 8504 +3063 8761 +3063 4413 +3063 9155 +3063 9034 +3063 6647 +3063 9591 +3063 9722 +3064 3760 +3064 4102 +3064 9097 +3064 4811 +3064 3406 +3064 3887 +3064 3632 +3064 8756 +3064 8022 +3064 6494 +3065 4130 +3065 7185 +3065 3857 +3065 9385 +3065 7367 +3065 3409 +3065 9807 +3065 9032 +3065 9251 +3065 6522 +3065 6507 +3065 8634 +3065 6207 +3066 9057 +3066 9796 +3066 8961 +3066 7432 +3066 9965 +3066 6352 +3066 6472 +3066 4818 +3066 4205 +3066 7428 +3066 6813 +3066 7422 +3067 3670 +3067 5129 +3067 4509 +3067 4007 +3067 3628 +3067 4654 +3067 7369 +3067 7755 +3067 4687 +3067 6614 +3067 9183 +3067 8558 +3067 5437 +3067 3828 +3068 4096 +3068 8844 +3068 4115 +3068 7454 +3068 5023 +3068 7459 +3068 5804 +3068 8631 +3068 5048 +3068 4799 +3068 8908 +3068 5972 +3068 6693 +3068 4969 +3068 3179 +3068 8301 +3068 5235 +3068 5958 +3068 4598 +3069 3873 +3069 6818 +3069 5859 +3069 8037 +3069 9510 +3069 8936 +3069 9794 +3069 8336 +3069 8472 +3069 5788 +3069 9887 +3070 9472 +3070 3722 +3070 7961 +3070 5147 +3070 7196 +3070 4767 +3070 7459 +3070 5032 +3070 9897 +3070 7855 +3070 5936 +3070 8767 +3070 9412 +3070 5750 +3070 5713 +3070 4051 +3070 4958 +3070 4370 +3070 4979 +3070 4598 +3070 9598 +3071 9441 +3071 3429 +3071 6118 +3071 9271 +3071 4845 +3071 5840 +3071 3858 +3071 5876 +3071 9400 +3071 9273 +3071 9247 +3071 9091 +3071 4639 +3072 9578 +3072 9260 +3072 3663 +3072 7728 +3072 5054 +3072 8695 +3072 6558 +3073 4354 +3073 5547 +3073 7052 +3073 5491 +3073 4024 +3073 9307 +3073 9578 +3074 9793 +3074 5570 +3074 9091 +3074 6486 +3074 4808 +3074 4716 +3074 8429 +3074 6677 +3074 8182 +3074 4826 +3074 8477 +3074 8639 +3075 8192 +3075 5584 +3075 8066 +3075 5670 +3075 7801 +3075 9737 +3075 4914 +3075 7568 +3075 6834 +3075 3156 +3075 5150 +3075 8280 +3075 3353 +3075 7197 +3075 6590 +3075 8702 +3076 8130 +3076 7362 +3076 7427 +3076 3883 +3076 3629 +3076 5326 +3076 5652 +3076 3711 +3076 5524 +3076 8027 +3076 3869 +3076 6326 +3077 9595 +3077 8371 +3077 8870 +3077 5095 +3077 7561 +3077 8369 +3077 5906 +3077 8020 +3077 5814 +3077 9880 +3077 3131 +3077 7035 +3077 3388 +3078 3529 +3078 6980 +3078 9126 +3078 3815 +3078 6332 +3078 5287 +3078 5815 +3078 7356 +3079 8064 +3079 3715 +3079 8839 +3079 4756 +3079 9505 +3079 5668 +3079 4268 +3079 5047 +3079 8763 +3079 8904 +3079 7896 +3079 7644 +3079 7009 +3079 8041 +3079 8953 +3079 5882 +3080 9472 +3080 7970 +3080 4529 +3080 9004 +3080 9778 +3080 4791 +3080 5180 +3080 5566 +3080 4673 +3080 8516 +3080 3797 +3080 7766 +3080 4976 +3080 6902 +3080 8445 +3081 7297 +3081 8996 +3081 3302 +3081 8775 +3081 7459 +3081 7082 +3081 7855 +3081 8018 +3081 4500 +3081 7031 +3081 4344 +3081 6335 +3081 6268 +3081 5210 +3082 4740 +3082 6793 +3082 5516 +3082 5517 +3082 9882 +3082 3872 +3082 7715 +3082 9640 +3082 5875 +3082 4023 +3082 4919 +3082 5714 +3082 6051 +3082 4195 +3082 3571 +3082 6004 +3082 8695 +3082 3833 +3083 7008 +3083 4865 +3083 3300 +3083 4161 +3083 6665 +3083 6450 +3083 8212 +3083 6169 +3083 8796 +3083 7166 +3084 3169 +3084 3747 +3084 5798 +3084 6561 +3084 6760 +3084 8299 +3084 9996 +3084 3151 +3084 8161 +3084 9560 +3084 7033 +3084 3389 +3084 9733 +3085 6662 +3085 9537 +3085 5000 +3085 4747 +3085 9104 +3085 6808 +3085 7326 +3085 3953 +3085 6321 +3085 4217 +3085 9147 +3085 9661 +3085 5600 +3085 8014 +3085 7760 +3085 3278 +3085 8534 +3085 5975 +3085 4832 +3085 8689 +3085 5237 +3085 4086 +3085 9976 +3085 5758 +3085 4821 +3086 5828 +3086 6150 +3086 5960 +3086 5246 +3086 6430 +3086 4853 +3087 5952 +3087 4901 +3087 5158 +3087 7911 +3087 6633 +3087 3115 +3087 5277 +3087 5734 +3087 8079 +3087 9328 +3087 3964 +3087 4886 +3087 7356 +3087 7037 +3087 3390 +3088 6401 +3088 5731 +3088 8422 +3088 9865 +3088 6251 +3088 9039 +3088 5936 +3088 3821 +3088 8521 +3088 4602 +3088 5756 +3088 4447 +3089 5249 +3089 7074 +3089 3653 +3089 8523 +3089 7154 +3089 4365 +3089 5486 +3089 4913 +3089 9074 +3089 9288 +3089 6777 +3089 7546 +3089 5303 +3090 9863 +3090 9371 +3090 5788 +3090 8734 +3090 4512 +3090 5794 +3090 6694 +3090 9246 +3090 7605 +3090 8374 +3090 8251 +3090 3104 +3090 7377 +3090 6887 +3090 3310 +3090 9073 +3090 7671 +3090 9849 +3090 3195 +3091 7009 +3091 3586 +3091 4004 +3091 7329 +3091 9799 +3091 3820 +3091 5325 +3091 6390 +3091 6587 +3092 6797 +3092 5064 +3092 3435 +3092 9166 +3092 8301 +3092 4180 +3092 4245 +3092 9686 +3092 7767 +3092 5176 +3093 4420 +3093 3625 +3093 4842 +3093 9398 +3093 3287 +3093 6488 +3093 3323 +3093 5277 +3093 9343 +3094 6149 +3094 4903 +3094 5437 +3094 3513 +3094 6298 +3095 9101 +3095 9231 +3095 7967 +3095 5303 +3095 9403 +3095 9674 +3095 7371 +3095 4059 +3095 6114 +3095 3684 +3095 5227 +3095 5874 +3095 8052 +3096 3522 +3096 8836 +3096 3398 +3096 8548 +3096 7949 +3096 8399 +3096 5872 +3096 9239 +3096 3332 +3096 9370 +3096 5499 +3096 7871 +3097 8842 +3097 7725 +3097 6968 +3097 4671 +3097 7106 +3097 4803 +3097 6475 +3097 8657 +3097 8153 +3097 5982 +3097 7263 +3097 5728 +3097 3304 +3097 9451 +3097 8435 +3097 8316 +3097 9087 +3098 9858 +3098 7822 +3098 4635 +3098 7585 +3098 9768 +3098 8876 +3098 6200 +3098 6201 +3098 8123 +3098 8484 +3098 6494 +3098 8687 +3098 6005 +3098 7545 +3099 7945 +3099 9489 +3099 3605 +3099 7065 +3099 9373 +3099 7723 +3099 7988 +3099 9269 +3099 6969 +3099 8250 +3099 9035 +3099 6229 +3099 6872 +3099 6750 +3100 5056 +3100 8032 +3100 7906 +3100 8036 +3100 8517 +3100 5126 +3100 3276 +3100 7441 +3100 6674 +3100 5491 +3100 4998 +3100 3929 +3100 8251 +3101 7171 +3101 3975 +3101 8201 +3101 7570 +3101 3229 +3101 7722 +3101 7618 +3101 3269 +3101 4427 +3101 9947 +3101 6502 +3101 8564 +3102 4457 +3102 3691 +3102 9391 +3102 7700 +3102 9941 +3102 9527 +3102 4308 +3102 5978 +3102 7069 +3102 4021 +3103 6757 +3103 3965 +3103 5800 +3103 4487 +3103 4910 +3103 5917 +3103 9905 +3103 4978 +3103 5358 +3103 7128 +3103 5629 +3103 4250 +3103 9525 +3104 3716 +3104 4761 +3104 7320 +3104 3865 +3104 8997 +3104 9256 +3104 6063 +3104 4150 +3104 5182 +3104 9824 +3104 4567 +3104 9435 +3104 4316 +3104 4576 +3104 8566 +3104 9982 +3105 4545 +3105 6658 +3105 4678 +3105 7178 +3105 6475 +3105 6914 +3105 9423 +3105 5744 +3105 5016 +3105 6038 +3105 7800 +3105 5381 +3106 3201 +3106 4614 +3106 9601 +3106 8466 +3106 8234 +3106 5036 +3106 7853 +3106 7990 +3106 3129 +3106 6461 +3106 9033 +3106 5068 +3106 6613 +3106 3943 +3106 3945 +3106 9981 +3107 7040 +3107 5762 +3107 4275 +3107 9602 +3107 7841 +3107 4261 +3107 9514 +3107 3628 +3107 9774 +3107 9903 +3107 4278 +3107 5566 +3107 8710 +3107 9940 +3107 4605 +3107 9201 +3107 9971 +3107 5496 +3107 6781 +3108 6960 +3108 6674 +3108 4813 +3108 7634 +3108 8341 +3108 3703 +3108 5143 +3108 6521 +3108 5013 +3109 4642 +3109 5371 +3109 7780 +3109 5639 +3109 7757 +3109 7709 +3109 8446 +3109 9077 +3109 5220 +3109 6172 +3109 4381 +3109 4479 +3110 5644 +3110 8974 +3110 8851 +3110 9647 +3110 6940 +3110 8736 +3110 9639 +3110 7727 +3110 4409 +3110 5053 +3110 9921 +3110 9413 +3110 4052 +3110 5335 +3110 5349 +3110 8938 +3110 3947 +3110 3452 +3111 9539 +3111 5188 +3111 8201 +3111 4650 +3111 6635 +3111 3486 +3111 9456 +3111 4690 +3111 3507 +3111 3668 +3111 3422 +3111 5174 +3111 9467 +3111 4508 +3111 6685 +3111 4917 +3112 4384 +3112 9901 +3112 6471 +3112 7044 +3112 9510 +3112 4423 +3112 3818 +3112 5490 +3112 7151 +3112 7313 +3112 7410 +3112 3701 +3112 9434 +3112 6717 +3112 7061 +3113 3748 +3113 5296 +3113 4638 +3113 9402 +3113 9980 +3113 3678 +3113 9381 +3114 9856 +3114 8353 +3114 5347 +3114 5799 +3114 6578 +3114 5803 +3114 6316 +3114 8754 +3114 4275 +3114 6901 +3114 4888 +3114 3291 +3114 4029 +3114 9407 +3115 8068 +3115 7813 +3115 8714 +3115 9617 +3115 5675 +3115 6446 +3115 5002 +3115 3784 +3115 6094 +3115 7378 +3115 9559 +3115 5851 +3115 3556 +3115 6373 +3115 9324 +3115 4333 +3115 6894 +3115 3184 +3116 5641 +3116 3119 +3116 7217 +3116 9139 +3116 9914 +3116 5053 +3116 4289 +3116 4854 +3116 9801 +3116 4558 +3116 9300 +3116 8022 +3116 8153 +3116 3422 +3116 3830 +3116 9727 +3116 7551 +3117 6342 +3117 8836 +3117 4551 +3117 6312 +3117 6185 +3117 5997 +3117 7781 +3117 6644 +3117 6457 +3117 4057 +3117 4188 +3117 3229 +3118 3611 +3118 9634 +3118 4443 +3118 7077 +3118 6191 +3118 9652 +3118 6453 +3118 8378 +3118 9792 +3118 8660 +3118 6613 +3118 3416 +3118 9690 +3118 9435 +3118 8444 +3118 9324 +3118 7535 +3118 3368 +3118 8948 +3118 8959 +3118 3708 +3119 8225 +3119 9575 +3119 4330 +3119 5323 +3119 4174 +3119 7026 +3119 3295 +3119 7862 +3119 6840 +3119 9563 +3119 9694 +3119 5215 +3120 8715 +3120 8599 +3120 5150 +3120 7843 +3120 9508 +3120 6195 +3120 8632 +3120 5062 +3120 3659 +3120 4433 +3120 6365 +3120 4958 +3120 9829 +3120 3195 +3121 6272 +3121 3329 +3121 9361 +3121 4246 +3121 7706 +3121 4773 +3121 8233 +3121 7981 +3121 4424 +3121 7347 +3121 7612 +3121 5697 +3121 3525 +3121 4433 +3121 6742 +3121 9318 +3122 5018 +3122 7984 +3122 9736 +3122 3894 +3122 3126 +3122 6600 +3122 3149 +3122 3282 +3122 8535 +3122 6641 +3122 6261 +3122 8314 +3122 6832 +3122 7039 +3123 5901 +3123 8102 +3123 3633 +3123 7229 +3123 8271 +3123 6865 +3123 9874 +3123 3229 +3123 8566 +3123 5566 +3123 7548 +3123 7390 +3124 3871 +3124 3234 +3124 9256 +3124 8194 +3124 8093 +3124 6610 +3124 8692 +3124 5269 +3124 7767 +3124 5050 +3124 8763 +3124 7293 +3124 5310 +3124 4703 +3125 4129 +3125 7490 +3125 6983 +3125 8151 +3125 6936 +3125 4783 +3125 7653 +3126 4610 +3126 5766 +3126 3470 +3126 5782 +3126 4632 +3126 6427 +3126 7454 +3126 8223 +3126 3489 +3126 5282 +3126 9255 +3126 9132 +3126 8117 +3126 5066 +3126 6904 +3126 8061 +3127 6663 +3127 7307 +3127 5650 +3127 9758 +3127 4258 +3127 7515 +3127 3742 +3127 9403 +3127 7605 +3127 3787 +3127 7246 +3127 5842 +3127 6995 +3127 8662 +3127 9056 +3127 4838 +3127 5010 +3127 7934 +3128 8589 +3128 7055 +3128 6810 +3128 9685 +3128 7353 +3128 4128 +3128 5828 +3128 4809 +3128 4640 +3128 3160 +3128 9434 +3128 6620 +3128 5475 +3128 5992 +3128 5738 +3128 5997 +3128 7411 +3128 3445 +3128 4010 +3128 5333 +3129 5280 +3129 5057 +3129 7387 +3129 7492 +3129 9510 +3129 4902 +3129 9488 +3129 6499 +3129 3351 +3129 9919 +3129 3487 +3130 6216 +3130 4330 +3130 9035 +3130 9615 +3130 6384 +3130 4648 +3130 5810 +3130 9555 +3130 7960 +3130 5050 +3130 9947 +3131 7788 +3131 3883 +3131 6732 +3131 4465 +3131 6961 +3131 6773 +3131 4381 +3132 5495 +3132 3313 +3132 3247 +3132 4216 +3132 3363 +3132 5460 +3132 9813 +3132 8539 +3132 8632 +3132 3449 +3132 3224 +3132 7259 +3132 7004 +3133 9301 +3133 7745 +3133 5347 +3133 7847 +3133 4202 +3133 4651 +3133 5952 +3133 7986 +3133 6740 +3133 8726 +3133 7226 +3133 4382 +3133 4735 +3134 8194 +3134 5858 +3134 5892 +3134 3208 +3134 9257 +3134 7668 +3134 5718 +3134 4991 +3135 8211 +3135 3264 +3135 7228 +3135 9931 +3135 5517 +3135 4254 +3135 6765 +3135 7795 +3135 8244 +3135 6878 +3135 6392 +3135 6041 +3135 8762 +3135 7644 +3135 5471 +3136 3394 +3136 7243 +3136 6980 +3136 7595 +3136 8172 +3136 9614 +3136 5795 +3136 4190 +3136 5401 +3136 5498 +3136 4349 +3137 8099 +3137 9964 +3137 9164 +3137 5838 +3137 6704 +3137 9361 +3137 7890 +3137 4887 +3137 8698 +3137 9212 +3137 3677 +3138 4579 +3138 5545 +3138 7371 +3138 3372 +3138 8368 +3138 6097 +3138 3670 +3138 6444 +3138 5108 +3138 7482 +3138 5051 +3138 5533 +3139 3360 +3139 3436 +3139 5654 +3139 3302 +3139 3785 +3139 7501 +3139 4397 +3139 3631 +3139 9968 +3139 6801 +3139 8852 +3139 7094 +3139 9565 +3140 6208 +3140 4756 +3140 9392 +3140 7858 +3140 8117 +3140 6071 +3140 9019 +3140 6081 +3140 3704 +3140 6490 +3140 4320 +3140 5348 +3140 6504 +3140 5618 +3140 8696 +3140 3450 +3140 7292 +3141 6155 +3141 7836 +3141 7075 +3141 8488 +3141 8873 +3141 6832 +3141 4533 +3141 7156 +3141 6977 +3141 9539 +3141 4235 +3141 5470 +3141 8932 +3141 4006 +3141 5224 +3141 9455 +3141 3184 +3141 4212 +3141 4601 +3141 4602 +3142 4416 +3142 6670 +3142 3225 +3142 5660 +3142 4125 +3142 3615 +3142 4133 +3142 5162 +3142 4531 +3142 7351 +3142 4797 +3142 6976 +3142 8523 +3142 8666 +3142 3934 +3142 9446 +3142 3693 +3142 8815 +3142 7542 +3142 9977 +3142 6906 +3142 7806 +3143 6033 +3143 7588 +3143 4871 +3143 4239 +3143 4817 +3143 6547 +3143 9781 +3143 8504 +3143 7920 +3143 4604 +3143 6717 +3144 3978 +3144 3988 +3144 7340 +3144 7620 +3144 7368 +3144 9418 +3144 9163 +3144 5328 +3144 3797 +3144 7390 +3144 8672 +3144 4332 +3144 4984 +3144 8084 +3144 3178 +3144 6613 +3145 9732 +3145 7052 +3145 6543 +3145 8340 +3145 6841 +3145 7233 +3145 5843 +3145 3285 +3145 7419 +3145 6123 +3145 7675 +3146 3876 +3146 8646 +3146 3558 +3146 6184 +3146 9706 +3146 9773 +3146 7886 +3146 9680 +3146 9364 +3146 8956 +3146 8925 +3147 5763 +3147 4869 +3147 9737 +3147 4106 +3147 3213 +3147 6928 +3147 5150 +3147 7332 +3147 8743 +3147 8745 +3147 5162 +3147 6063 +3147 8113 +3147 4403 +3147 5052 +3147 8541 +3147 7545 +3147 8444 +3148 9083 +3148 6789 +3148 5169 +3148 7030 +3148 7306 +3148 5131 +3148 4972 +3148 9549 +3148 9711 +3148 9552 +3148 9974 +3148 4978 +3148 8341 +3148 7670 +3148 7767 +3148 7295 +3148 4263 +3148 9279 +3149 8517 +3149 4871 +3149 3240 +3149 4874 +3149 3198 +3149 8276 +3149 3534 +3149 5815 +3149 4315 +3149 8188 +3149 4287 +3150 9264 +3150 5630 +3150 6881 +3150 7630 +3150 6543 +3150 6324 +3150 6328 +3150 9049 +3150 7418 +3150 5775 +3150 3996 +3150 8698 +3151 7990 +3151 9330 +3151 3408 +3151 4464 +3151 8722 +3151 3795 +3151 7765 +3151 5718 +3151 6044 +3152 8065 +3152 9987 +3152 6283 +3152 8848 +3152 6420 +3152 9504 +3152 4516 +3152 7214 +3152 6575 +3152 4275 +3152 7348 +3152 4798 +3152 6101 +3152 5089 +3152 7146 +3152 3309 +3152 9082 +3152 9982 +3153 4231 +3153 4239 +3153 9370 +3153 8700 +3153 3998 +3153 5671 +3153 8121 +3153 5950 +3153 3953 +3153 3911 +3153 7112 +3153 5211 +3153 6116 +3153 4453 +3153 8553 +3153 7149 +3153 4465 +3153 3958 +3153 6908 +3154 9747 +3154 5143 +3154 6707 +3154 8628 +3154 5940 +3154 7873 +3154 6471 +3154 8653 +3154 7374 +3154 3551 +3154 9571 +3154 3941 +3154 6251 +3154 8044 +3154 3952 +3154 7793 +3154 9591 +3154 3324 +3155 5669 +3155 5063 +3155 6344 +3155 3655 +3155 4011 +3155 5744 +3155 4497 +3155 8526 +3155 5291 +3155 9754 +3155 3547 +3155 8573 +3155 5535 +3156 7330 +3156 4259 +3156 8491 +3156 9323 +3156 9071 +3156 5876 +3156 5795 +3156 3323 +3156 5719 +3156 5178 +3156 5211 +3156 8730 +3156 9691 +3157 8485 +3157 3942 +3157 3271 +3157 6635 +3157 6445 +3157 8753 +3157 5939 +3157 7030 +3157 6966 +3157 6263 +3157 8166 +3157 6716 +3158 4994 +3158 8970 +3158 5890 +3158 7955 +3158 7454 +3158 5811 +3158 3521 +3158 3657 +3158 6355 +3158 9725 +3158 7918 +3158 5999 +3158 3312 +3158 7026 +3158 7543 +3158 8573 +3159 9089 +3159 7793 +3159 7361 +3159 6092 +3159 6855 +3159 5870 +3159 4239 +3159 4560 +3159 9841 +3159 9555 +3159 8153 +3159 8187 +3159 4821 +3160 6497 +3160 3817 +3160 6195 +3160 9651 +3160 5970 +3160 5518 +3160 7798 +3160 4439 +3160 7642 +3160 5309 +3161 7904 +3161 8804 +3161 6566 +3161 6599 +3161 4172 +3161 9066 +3161 5981 +3161 8913 +3161 6290 +3161 7860 +3161 8533 +3161 5558 +3161 8889 +3161 4223 +3161 4189 +3161 8767 +3162 5764 +3162 6661 +3162 4870 +3162 6664 +3162 4674 +3162 9626 +3162 9123 +3162 4902 +3162 8871 +3162 5162 +3162 5035 +3162 4919 +3162 7481 +3162 4282 +3162 4796 +3162 6210 +3162 6369 +3162 4330 +3162 8699 +3163 7302 +3163 9769 +3163 5035 +3163 5774 +3163 3507 +3163 9012 +3163 9719 +3163 9659 +3164 5120 +3164 7559 +3164 7847 +3164 4648 +3164 8105 +3164 6058 +3164 5174 +3164 6457 +3164 4167 +3164 6728 +3164 7114 +3164 3930 +3164 3300 +3164 4456 +3164 4090 +3164 5245 +3164 9173 +3165 3466 +3165 7702 +3165 9240 +3165 6689 +3165 9766 +3165 8250 +3165 8257 +3165 4676 +3165 8269 +3165 6350 +3165 8798 +3165 4323 +3165 4390 +3165 4075 +3165 8176 +3165 3569 +3165 7029 +3165 7420 +3166 4320 +3166 6242 +3166 8612 +3166 4134 +3166 6670 +3166 8303 +3166 5584 +3166 4178 +3166 4340 +3166 7420 +3167 4576 +3167 7552 +3167 9792 +3167 7115 +3167 8758 +3167 9801 +3167 6667 +3167 3436 +3167 8974 +3167 3732 +3167 7956 +3167 7769 +3167 8089 +3167 4859 +3168 4033 +3168 6308 +3168 7889 +3168 6952 +3168 5226 +3168 9006 +3168 9176 +3168 8024 +3168 7306 +3168 5887 +3169 9824 +3169 7777 +3169 5731 +3169 5380 +3169 7094 +3169 7559 +3169 3755 +3169 4078 +3169 3535 +3169 9185 +3169 8196 +3169 7147 +3169 9118 +3170 9396 +3170 9927 +3170 4732 +3170 9836 +3170 3698 +3170 8114 +3170 4115 +3170 3284 +3170 9070 +3170 7576 +3170 6164 +3170 7484 +3170 8671 +3171 7555 +3171 5257 +3171 5646 +3171 3733 +3171 4548 +3171 8483 +3171 9639 +3171 7978 +3171 9668 +3171 3640 +3171 6846 +3171 7236 +3171 3945 +3171 7660 +3171 3573 +3171 9334 +3172 9986 +3172 6287 +3172 4112 +3172 5528 +3172 6938 +3172 7581 +3172 4766 +3172 9384 +3172 6703 +3172 3383 +3172 6077 +3172 9804 +3172 8268 +3172 9186 +3172 9553 +3172 8925 +3172 5776 +3172 9826 +3172 8822 +3172 9465 +3172 8318 +3173 8203 +3173 7966 +3173 7463 +3173 8402 +3173 7595 +3173 3764 +3173 9781 +3173 8374 +3173 4916 +3173 5697 +3173 8914 +3173 5590 +3173 8565 +3173 7671 +3173 4985 +3174 3425 +3174 5605 +3174 4391 +3174 5610 +3174 7053 +3174 9005 +3174 7695 +3174 6869 +3174 9273 +3174 7353 +3174 3325 +3174 5470 +3175 3973 +3175 6538 +3175 7693 +3175 4885 +3175 9301 +3175 4060 +3175 9587 +3175 4406 +3175 5559 +3175 6076 +3175 9663 +3175 3776 +3175 8773 +3175 7882 +3175 4821 +3175 8534 +3175 4444 +3175 5987 +3175 8420 +3175 9061 +3175 9710 +3175 5619 +3175 5174 +3175 3669 +3176 9315 +3176 9349 +3176 9447 +3176 3797 +3176 6974 +3176 8421 +3176 6079 +3177 4336 +3177 4230 +3177 8134 +3177 9511 +3177 5609 +3177 6288 +3177 3315 +3177 5012 +3177 4437 +3177 4058 +3177 6587 +3177 6493 +3177 4030 +3178 5024 +3178 3820 +3178 4625 +3178 7552 +3178 6611 +3178 7433 +3178 7736 +3178 9530 +3178 3774 +3179 7330 +3179 4579 +3179 3222 +3179 9864 +3179 5161 +3179 8599 +3179 8141 +3179 7976 +3179 3603 +3179 5782 +3179 9592 +3179 7215 +3179 4019 +3179 4837 +3180 3968 +3180 9488 +3180 9379 +3180 6501 +3180 3242 +3180 3245 +3180 5296 +3180 5875 +3180 5556 +3180 6041 +3180 7000 +3180 6393 +3180 7995 +3180 4351 +3181 7429 +3181 6124 +3181 5003 +3181 6415 +3181 8351 +3181 8096 +3181 7844 +3181 8000 +3181 8268 +3181 7760 +3181 4693 +3181 5338 +3181 6882 +3181 4844 +3181 8942 +3181 7540 +3181 9850 +3182 7939 +3182 5004 +3182 8334 +3182 9122 +3182 7208 +3182 6443 +3182 8627 +3182 5812 +3182 6090 +3182 3342 +3182 3673 +3182 6876 +3182 4840 +3182 9469 +3183 7685 +3183 9998 +3183 6684 +3183 7198 +3183 5552 +3183 5941 +3183 3383 +3183 5692 +3183 7618 +3183 3254 +3183 7110 +3183 5454 +3183 4689 +3183 8147 +3183 9172 +3183 5993 +3183 5611 +3183 5239 +3183 7416 +3183 7165 +3183 6271 +3184 8704 +3184 3845 +3184 5137 +3184 8981 +3184 5918 +3184 4002 +3184 4132 +3184 8245 +3184 4022 +3184 4921 +3184 6074 +3184 8893 +3184 7116 +3184 8281 +3184 9947 +3184 5348 +3184 4591 +3184 8568 +3184 7164 +3185 8112 +3185 5963 +3185 3333 +3185 4811 +3185 6375 +3185 3432 +3185 4455 +3185 6348 +3185 9682 +3185 7130 +3185 9659 +3186 6025 +3186 6958 +3186 8091 +3186 3235 +3186 4551 +3186 8492 +3186 6702 +3186 7601 +3186 9148 +3186 8513 +3186 5442 +3186 6221 +3186 8657 +3186 6359 +3186 6360 +3186 5228 +3186 8821 +3186 4221 +3187 3203 +3187 8278 +3187 4109 +3187 5525 +3187 8086 +3187 3994 +3187 5402 +3187 6174 +3187 3744 +3187 8750 +3187 3887 +3187 7743 +3187 9280 +3187 5186 +3187 3657 +3187 8401 +3187 8149 +3187 7640 +3187 7776 +3187 5476 +3187 6758 +3187 6504 +3188 5691 +3188 3907 +3188 9604 +3188 6438 +3188 4649 +3188 7979 +3188 3788 +3188 4507 +3188 5375 +3189 5158 +3189 4081 +3189 8200 +3189 7474 +3189 9496 +3189 5364 +3189 5975 +3189 6072 +3189 5945 +3189 8986 +3189 6524 +3189 7066 +3190 3333 +3190 4870 +3190 6025 +3190 4494 +3190 8849 +3190 8069 +3190 5159 +3190 7721 +3190 9005 +3190 5935 +3190 4144 +3190 9012 +3190 7605 +3190 6325 +3190 6724 +3190 4045 +3190 9809 +3190 8925 +3190 3557 +3190 7273 +3190 7719 +3191 6806 +3191 3991 +3191 7324 +3191 8479 +3191 3622 +3191 7851 +3191 9540 +3191 7629 +3191 5581 +3191 3798 +3191 4967 +3191 7536 +3191 9973 +3191 7167 +3192 9756 +3192 5377 +3192 9541 +3192 7185 +3192 5481 +3192 8523 +3192 6125 +3192 6191 +3192 8170 +3192 7736 +3192 6010 +3192 6399 +3192 5918 +3193 8353 +3193 3275 +3193 4614 +3193 3303 +3193 9192 +3193 4201 +3193 3530 +3193 3755 +3193 4076 +3193 4557 +3193 4424 +3193 6131 +3193 6023 +3193 5853 +3194 3553 +3194 3843 +3194 5992 +3194 7145 +3194 6891 +3194 7165 +3194 5733 +3194 8018 +3194 6995 +3194 3957 +3194 4631 +3194 5850 +3194 9243 +3194 3962 +3195 8303 +3195 8104 +3195 3535 +3195 8696 +3195 5811 +3195 6807 +3195 5647 +3195 8062 +3196 3808 +3196 6244 +3196 4519 +3196 3585 +3196 8658 +3196 9843 +3196 7191 +3196 6105 +3196 8986 +3196 6110 +3196 8127 +3197 3204 +3197 8327 +3197 9354 +3197 6422 +3197 3866 +3197 7067 +3197 9890 +3197 7723 +3197 7093 +3197 4793 +3197 4286 +3197 5205 +3197 8028 +3197 5469 +3197 6115 +3198 4869 +3198 4495 +3198 4112 +3198 4885 +3198 8854 +3198 9509 +3198 6440 +3198 6061 +3198 4786 +3198 3380 +3198 6839 +3198 7992 +3198 7738 +3198 9153 +3198 7492 +3198 5320 +3198 7114 +3198 8409 +3198 3424 +3198 3813 +3198 9960 +3198 3304 +3198 8956 +3199 7009 +3199 7234 +3199 4267 +3199 5764 +3199 9925 +3199 4865 +3199 3304 +3199 5865 +3199 5066 +3199 8813 +3199 8503 +3199 9200 +3199 4147 +3199 5059 +3200 9610 +3200 4624 +3200 5917 +3200 3998 +3200 6688 +3200 5285 +3200 6580 +3200 7741 +3200 5317 +3200 7752 +3200 7114 +3200 4055 +3200 5089 +3200 8820 +3200 4214 +3201 7430 +3201 6185 +3201 6958 +3201 3900 +3201 5569 +3201 6006 +3201 7247 +3201 7505 +3201 5210 +3201 9691 +3201 8804 +3201 4852 +3201 4086 +3201 8056 +3202 5024 +3202 3361 +3202 4307 +3202 7558 +3202 6279 +3202 9769 +3202 5164 +3202 7549 +3202 8176 +3202 9363 +3202 4404 +3202 5053 +3202 6238 +3203 8065 +3203 8194 +3203 8582 +3203 7943 +3203 9458 +3203 8340 +3203 4633 +3203 7195 +3203 6818 +3203 3846 +3203 4141 +3203 7474 +3203 9783 +3203 9789 +3203 6261 +3203 9031 +3203 5193 +3203 4183 +3203 5466 +3203 9314 +3203 9317 +3203 8807 +3203 4074 +3203 9070 +3203 3825 +3204 8578 +3204 6030 +3204 5903 +3204 5527 +3204 7194 +3204 7992 +3204 9652 +3204 3958 +3204 5192 +3204 8164 +3204 9437 +3204 7780 +3204 4582 +3204 4722 +3204 5365 +3204 6646 +3205 8896 +3205 8934 +3205 9130 +3205 7084 +3205 8397 +3205 3726 +3205 5361 +3205 9651 +3205 7432 +3205 8792 +3205 7174 +3205 5659 +3205 5502 +3206 7567 +3206 9490 +3206 7199 +3206 9639 +3206 5161 +3206 7095 +3206 5562 +3206 5436 +3206 7107 +3206 3533 +3206 4829 +3206 4576 +3206 6371 +3206 6762 +3206 9330 +3206 7672 +3206 9595 +3207 8845 +3207 5390 +3207 8598 +3207 8614 +3207 5434 +3207 4417 +3207 4679 +3207 4427 +3207 5837 +3207 8538 +3207 8162 +3207 7524 +3207 4328 +3207 8809 +3207 3434 +3207 4332 +3207 6893 +3207 5502 +3208 9954 +3208 5155 +3208 8843 +3208 3915 +3208 4622 +3208 6991 +3208 9040 +3208 6787 +3208 6170 +3208 3998 +3209 8219 +3209 9321 +3209 7146 +3209 7852 +3209 5806 +3209 9905 +3209 6226 +3209 5204 +3209 3230 +3209 4571 +3209 4254 +3210 6688 +3210 5987 +3210 8998 +3210 9864 +3210 6921 +3210 5066 +3210 6059 +3210 5519 +3210 4084 +3210 5461 +3210 7209 +3210 5172 +3211 8641 +3211 8940 +3211 5380 +3211 7845 +3211 6407 +3211 5032 +3211 6313 +3211 8977 +3211 7250 +3212 6019 +3212 8709 +3212 7694 +3212 3472 +3212 5394 +3212 6676 +3212 7993 +3212 8898 +3212 6987 +3212 7129 +3212 9952 +3212 9707 +3212 9965 +3212 9082 +3213 4736 +3213 4758 +3213 9478 +3213 8589 +3213 6417 +3213 6422 +3213 3619 +3213 9862 +3213 6450 +3213 3509 +3213 3253 +3213 6465 +3213 5505 +3213 9723 +3213 4970 +3213 9202 +3213 9727 +3213 4351 +3214 6336 +3214 4321 +3214 4162 +3214 6851 +3214 5637 +3214 6469 +3214 7529 +3214 7083 +3214 5516 +3214 7778 +3214 8782 +3214 6264 +3214 5721 +3215 8770 +3215 8227 +3215 4198 +3215 4890 +3215 7101 +3215 4433 +3215 9742 +3215 9943 +3215 7869 +3215 4286 +3215 4191 +3216 3808 +3216 7171 +3216 6566 +3216 8668 +3216 3596 +3216 3981 +3216 9780 +3216 3580 +3216 9403 +3216 4764 +3216 6570 +3217 3488 +3217 6593 +3217 9443 +3217 7665 +3217 7560 +3217 3273 +3217 5947 +3217 8533 +3217 7113 +3217 3807 +3217 8348 +3217 8224 +3217 6943 +3218 4480 +3218 5697 +3218 3877 +3218 9862 +3218 4297 +3218 9131 +3218 7886 +3218 5748 +3218 8053 +3218 6998 +3218 7932 +3218 6430 +3219 4608 +3219 6793 +3219 3471 +3219 6164 +3219 5399 +3219 9248 +3219 6310 +3219 5558 +3219 9793 +3219 9037 +3219 5838 +3219 4688 +3219 6993 +3219 6992 +3219 3811 +3219 9967 +3219 9456 +3219 7794 +3219 7933 +3220 4704 +3220 7810 +3220 5185 +3220 9025 +3220 7376 +3220 3601 +3220 8692 +3220 8407 +3220 4347 +3220 3357 +3220 9173 +3221 6704 +3221 7810 +3221 9699 +3221 5673 +3221 9947 +3221 6985 +3221 6058 +3221 5107 +3221 7316 +3221 3960 +3221 4126 +3222 5091 +3222 4772 +3222 5285 +3222 6918 +3222 6503 +3222 4296 +3222 9892 +3222 9075 +3222 4232 +3222 6607 +3222 4824 +3222 7289 +3222 4987 +3222 5660 +3222 6099 +3223 8960 +3223 3842 +3223 6019 +3223 9104 +3223 4370 +3223 7571 +3223 9879 +3223 5660 +3223 5533 +3223 3293 +3223 6704 +3223 3266 +3223 5575 +3223 4061 +3223 5096 +3223 3603 +3223 3829 +3223 7038 +3224 8577 +3224 4033 +3224 4974 +3224 6022 +3224 4769 +3224 9866 +3224 6540 +3224 7502 +3224 8209 +3224 9859 +3224 4500 +3224 4085 +3224 7413 +3224 5208 +3224 8605 +3224 7839 +3225 9504 +3225 7479 +3225 4290 +3225 5509 +3225 6599 +3225 9352 +3225 9964 +3225 7472 +3225 9680 +3225 6515 +3225 6356 +3225 6293 +3225 9815 +3225 9215 +3226 3552 +3226 3906 +3226 5063 +3226 6731 +3226 5356 +3226 5070 +3226 4720 +3226 5488 +3226 5698 +3226 3546 +3226 5467 +3226 5823 +3226 3359 +3227 6593 +3227 7269 +3227 6924 +3227 8396 +3227 5170 +3227 6679 +3227 4602 +3227 9853 +3227 3269 +3228 5121 +3228 5238 +3228 7441 +3228 8465 +3228 9746 +3228 7567 +3228 3857 +3228 9305 +3228 7992 +3228 6809 +3228 9468 +3229 9990 +3229 5540 +3229 8359 +3229 9052 +3229 4404 +3229 4791 +3229 9539 +3229 8522 +3229 4430 +3229 3541 +3229 9946 +3229 4060 +3229 7534 +3230 9793 +3230 8612 +3230 3528 +3230 6699 +3230 4461 +3230 5614 +3230 5458 +3230 9237 +3230 9570 +3230 7228 +3230 8766 +3231 7392 +3231 7937 +3231 3511 +3231 5581 +3231 5907 +3231 5781 +3231 4956 +3231 6938 +3231 3583 +3232 6656 +3232 6422 +3232 9030 +3232 7656 +3232 4108 +3232 6602 +3232 9612 +3232 9645 +3232 4369 +3232 3315 +3232 5332 +3232 6454 +3232 8312 +3232 3407 +3232 8394 +3233 6946 +3233 6347 +3233 9937 +3233 4936 +3233 8617 +3233 5442 +3233 9026 +3233 7992 +3233 8272 +3233 4945 +3233 4472 +3233 8442 +3233 8029 +3233 7422 +3233 5919 +3234 7168 +3234 9353 +3234 7580 +3234 4513 +3234 3262 +3234 5216 +3234 8132 +3234 4933 +3234 8136 +3234 6871 +3234 9435 +3234 8543 +3234 8036 +3234 7399 +3234 6003 +3235 6299 +3235 3356 +3235 6429 +3235 4513 +3235 6311 +3235 9258 +3235 9900 +3235 5170 +3235 4683 +3235 8649 +3235 4322 +3235 4450 +3235 7267 +3235 9066 +3235 5484 +3235 9075 +3235 3574 +3235 9340 +3236 3329 +3236 6145 +3236 3734 +3236 7834 +3236 3611 +3236 5027 +3236 5034 +3236 5164 +3236 8237 +3236 3664 +3236 4569 +3236 8689 +3237 9148 +3237 7564 +3237 3759 +3237 4114 +3237 5557 +3237 4665 +3237 6714 +3237 7069 +3238 9868 +3238 8849 +3238 7578 +3238 3868 +3238 9247 +3238 8390 +3238 7856 +3238 3506 +3238 8518 +3238 6734 +3238 5456 +3238 3416 +3238 7845 +3238 6496 +3238 4579 +3238 3431 +3238 7020 +3238 3701 +3239 3395 +3239 5770 +3239 7148 +3239 8240 +3239 8722 +3239 8371 +3239 7318 +3239 7610 +3239 5306 +3239 6501 +3240 7808 +3240 8721 +3240 6294 +3240 7704 +3240 9766 +3240 3881 +3240 3889 +3240 4146 +3240 8892 +3240 8510 +3240 6849 +3240 9040 +3240 8798 +3240 9055 +3240 8528 +3240 8809 +3240 9450 +3240 6130 +3240 6774 +3240 7671 +3240 7547 +3240 8700 +3241 8321 +3241 8995 +3241 7830 +3241 9676 +3241 6287 +3241 3344 +3241 8436 +3241 8271 +3241 8511 +3242 8800 +3242 3488 +3242 7778 +3242 8324 +3242 6693 +3242 4134 +3242 6505 +3242 3917 +3242 9389 +3242 5166 +3242 9334 +3242 9157 +3242 5190 +3242 6461 +3243 3873 +3243 4217 +3243 8154 +3243 7196 +3243 8734 +3244 7058 +3244 9246 +3244 4393 +3244 8109 +3244 5038 +3244 7882 +3244 6983 +3244 7370 +3244 3804 +3244 7263 +3244 9068 +3244 8814 +3244 3700 +3244 6005 +3244 4854 +3244 6906 +3244 9727 +3245 9104 +3245 6851 +3245 4068 +3245 9478 +3245 8326 +3245 5981 +3245 3501 +3245 9677 +3245 3792 +3245 8178 +3245 6293 +3245 5942 +3245 8569 +3245 3742 +3245 5787 +3245 5595 +3246 6194 +3246 7366 +3246 7400 +3246 5994 +3246 7629 +3246 4658 +3246 6198 +3246 5113 +3246 8828 +3246 3914 +3247 9510 +3247 3690 +3247 9517 +3247 8433 +3247 4822 +3247 3831 +3247 8633 +3247 6749 +3248 8420 +3248 7879 +3248 9073 +3248 4440 +3248 5215 +3249 7318 +3249 6554 +3249 6685 +3249 7326 +3249 7327 +3249 3367 +3249 7603 +3249 8892 +3249 6465 +3249 4167 +3249 6607 +3249 7740 +3249 3692 +3249 6127 +3250 4096 +3250 8939 +3250 8324 +3250 7691 +3250 8982 +3250 8964 +3250 4257 +3250 5675 +3250 4275 +3250 5560 +3250 7868 +3250 4295 +3250 9417 +3250 3665 +3250 9170 +3250 4184 +3250 8169 +3250 5104 +3250 4085 +3250 4601 +3251 3876 +3251 5541 +3251 9638 +3251 4785 +3251 9740 +3251 5389 +3251 4440 +3251 8467 +3251 8984 +3251 7205 +3251 4447 +3252 5090 +3252 4578 +3252 4133 +3252 5030 +3252 9095 +3252 3591 +3252 7531 +3252 9090 +3252 7533 +3252 6161 +3252 3700 +3252 6839 +3252 8125 +3252 4517 +3253 4480 +3253 3552 +3253 4827 +3253 3588 +3253 7751 +3253 9545 +3253 4867 +3253 5557 +3253 7895 +3253 4539 +3253 8031 +3254 7684 +3254 8200 +3254 5227 +3254 4557 +3254 4592 +3254 4840 +3254 5827 +3254 7413 +3254 5594 +3254 6235 +3254 8232 +3254 7455 +3255 8768 +3255 6240 +3255 8003 +3255 7844 +3255 9542 +3255 8484 +3255 9896 +3255 4010 +3255 8110 +3255 8944 +3255 6225 +3255 6788 +3255 5655 +3255 3300 +3256 7181 +3256 8334 +3256 8081 +3256 4754 +3256 5909 +3256 7212 +3256 8244 +3256 8388 +3256 4046 +3256 3470 +3256 3799 +3256 6122 +3256 6769 +3257 8893 +3257 9508 +3257 7976 +3257 4078 +3257 9002 +3257 6767 +3257 4669 +3257 8158 +3257 6184 +3257 5853 +3257 8894 +3258 6144 +3258 3905 +3258 4667 +3258 5542 +3258 5820 +3258 7370 +3258 3470 +3258 9103 +3258 7388 +3258 3850 +3258 6648 +3258 5017 +3258 9980 +3258 5022 +3259 5984 +3259 6859 +3259 7748 +3259 9495 +3259 8439 +3259 9485 +3259 7472 +3259 3434 +3259 6613 +3259 6966 +3259 6775 +3259 7092 +3259 7355 +3259 7517 +3260 7042 +3260 7813 +3260 7716 +3260 3372 +3260 7217 +3260 4933 +3260 5449 +3260 7257 +3260 6876 +3260 5855 +3260 7274 +3260 4978 +3261 6203 +3261 6712 +3261 9771 +3261 4271 +3261 9864 +3261 3698 +3261 6292 +3261 6069 +3261 3679 +3261 7002 +3261 7454 +3262 3616 +3262 9292 +3262 5936 +3262 7986 +3262 4659 +3262 6169 +3262 7093 +3262 9433 +3262 4313 +3262 7481 +3263 8330 +3263 7697 +3263 3986 +3263 6298 +3263 6944 +3263 5928 +3263 6325 +3263 9147 +3263 5386 +3263 3520 +3263 6070 +3263 6474 +3263 7757 +3263 4051 +3263 4693 +3263 5212 +3263 7653 +3263 7776 +3263 3559 +3263 7273 +3263 3694 +3263 9843 +3263 8952 +3263 5881 +3264 9378 +3264 7875 +3264 4836 +3264 7141 +3264 3605 +3264 5391 +3264 8465 +3264 8019 +3264 8149 +3264 7991 +3264 8125 +3264 3486 +3265 5260 +3265 7821 +3265 5913 +3265 6958 +3265 7741 +3265 9925 +3265 5064 +3265 4748 +3265 8141 +3265 9172 +3265 4571 +3265 8285 +3265 3422 +3265 7779 +3265 9457 +3265 7666 +3266 3843 +3266 5157 +3266 3433 +3266 7714 +3266 4659 +3266 9300 +3266 5077 +3266 5687 +3266 8440 +3266 6003 +3266 3579 +3266 6878 +3267 8257 +3267 9894 +3267 3914 +3267 3851 +3267 7229 +3267 6160 +3267 8592 +3267 7382 +3267 7642 +3267 5375 +3267 7935 +3268 7552 +3268 9537 +3268 4738 +3268 4712 +3268 5916 +3268 5026 +3268 9103 +3268 9032 +3268 8788 +3268 8442 +3269 8162 +3269 3715 +3269 7752 +3269 6859 +3269 4043 +3269 4015 +3269 9616 +3269 7474 +3269 7699 +3269 6677 +3269 4575 +3269 9564 +3269 7822 +3269 3589 +3270 4385 +3270 3627 +3270 6116 +3270 9064 +3270 4843 +3270 4655 +3270 5938 +3270 6135 +3270 7305 +3271 6594 +3271 3549 +3271 4369 +3271 4136 +3271 9289 +3271 8424 +3271 5240 +3271 4594 +3271 6425 +3271 8696 +3271 8921 +3271 9498 +3271 5086 +3272 5377 +3272 4556 +3272 7660 +3272 5522 +3272 7124 +3272 5556 +3272 4988 +3272 9150 +3272 9407 +3273 8641 +3273 4523 +3273 6788 +3273 7365 +3273 7799 +3273 5409 +3273 5655 +3273 7801 +3273 5608 +3273 8724 +3273 9238 +3273 3479 +3274 4066 +3274 7397 +3274 9095 +3274 3304 +3274 6092 +3274 8429 +3274 8659 +3274 8307 +3274 3924 +3274 8030 +3274 3288 +3274 6203 +3274 5948 +3274 7188 +3274 7301 +3275 5403 +3275 4006 +3275 5129 +3275 6378 +3275 4223 +3275 4464 +3275 6868 +3275 7797 +3275 8152 +3275 7513 +3275 9499 +3275 4540 +3275 6058 +3275 5375 +3276 8640 +3276 7170 +3276 8585 +3276 8464 +3276 9383 +3276 3497 +3276 9139 +3276 8887 +3276 6208 +3276 3656 +3276 8151 +3276 4825 +3276 8285 +3276 4830 +3276 4961 +3276 9186 +3276 5603 +3276 9961 +3276 5489 +3277 4002 +3277 7841 +3277 7046 +3277 7079 +3277 5257 +3277 6059 +3277 9900 +3277 8607 +3277 4910 +3277 3951 +3277 9524 +3277 5848 +3277 8537 +3277 3739 +3278 7393 +3278 7812 +3278 5894 +3278 6664 +3278 4810 +3278 9841 +3278 4561 +3278 6852 +3278 7478 +3278 3323 +3279 9219 +3279 7191 +3279 8723 +3279 9238 +3279 6423 +3279 4514 +3279 4516 +3279 4147 +3279 7999 +3279 8771 +3279 4807 +3279 3407 +3279 4434 +3279 5469 +3279 8131 +3279 5230 +3279 7667 +3280 5408 +3280 5000 +3280 5357 +3280 4079 +3280 5555 +3280 4629 +3280 6550 +3280 7863 +3280 4536 +3280 6169 +3280 9338 +3280 3900 +3280 4821 +3281 3846 +3281 9459 +3281 8874 +3281 8395 +3281 7021 +3281 7120 +3281 4497 +3281 8306 +3281 3764 +3281 4501 +3281 7641 +3281 8596 +3281 6682 +3281 7835 +3281 8220 +3282 9929 +3282 3709 +3282 6065 +3282 7158 +3282 5975 +3282 4090 +3282 4250 +3282 3388 +3282 4058 +3282 9150 +3282 6559 +3283 5381 +3283 8339 +3283 3861 +3283 3862 +3283 4513 +3283 9895 +3283 5550 +3283 6574 +3283 7872 +3283 7776 +3283 4556 +3283 8289 +3283 4838 +3283 3731 +3283 3445 +3283 4091 +3284 9124 +3284 7366 +3284 4391 +3284 6026 +3284 5163 +3284 9602 +3284 4594 +3284 4853 +3284 4117 +3284 6087 +3284 5592 +3284 7161 +3284 8634 +3284 3871 +3285 9136 +3285 4635 +3285 8772 +3285 4454 +3285 5096 +3285 9616 +3285 8562 +3285 4472 +3285 5076 +3285 9947 +3285 8732 +3285 8637 +3285 4414 +3286 8585 +3286 6159 +3286 3694 +3286 7960 +3286 6852 +3286 7323 +3286 3364 +3286 3499 +3286 4418 +3286 4683 +3286 9412 +3286 8517 +3286 3526 +3286 5835 +3286 9036 +3286 8664 +3286 8810 +3286 7534 +3286 3652 +3286 7285 +3286 7799 +3286 9598 +3287 9858 +3287 7307 +3287 6274 +3287 4498 +3287 5399 +3287 3503 +3287 5667 +3287 5419 +3287 7343 +3287 3898 +3287 4419 +3287 9670 +3287 5579 +3287 9043 +3287 8027 +3287 3962 +3288 4699 +3288 4006 +3288 4778 +3288 3720 +3288 6382 +3288 7026 +3288 4283 +3288 6778 +3289 6051 +3289 8709 +3289 8487 +3289 3447 +3289 3997 +3289 5527 +3289 9007 +3289 7164 +3289 6237 +3290 5168 +3290 5092 +3290 5446 +3290 7911 +3290 8331 +3290 8530 +3290 8592 +3290 8088 +3290 4850 +3290 6739 +3290 6804 +3290 5272 +3291 7512 +3291 3586 +3291 8483 +3291 6469 +3291 3660 +3291 5196 +3291 9869 +3291 9320 +3291 8236 +3291 4821 +3291 9719 +3291 3992 +3291 4220 +3292 5377 +3292 9631 +3292 7079 +3292 7855 +3292 7733 +3292 9655 +3292 4540 +3292 7110 +3292 7122 +3292 7137 +3292 5458 +3292 4848 +3292 6133 +3292 7676 +3293 4353 +3293 3355 +3293 5395 +3293 9921 +3293 8000 +3293 7406 +3293 8932 +3293 5973 +3293 4216 +3293 5460 +3293 8635 +3294 9123 +3294 7685 +3294 6792 +3294 5353 +3294 9331 +3294 4948 +3294 4053 +3294 8119 +3294 6719 +3295 8777 +3295 6730 +3295 9068 +3295 5008 +3295 6545 +3295 6612 +3295 3326 +3295 3451 +3295 8829 +3295 4382 +3296 6529 +3296 5924 +3296 6342 +3296 3777 +3296 6281 +3296 9197 +3296 4559 +3296 5335 +3296 6745 +3296 7418 +3296 9753 +3297 4570 +3297 5216 +3297 5507 +3297 7621 +3297 6054 +3297 8938 +3297 5546 +3297 6443 +3297 8844 +3297 4013 +3297 4206 +3297 7695 +3297 6096 +3297 8899 +3297 5259 +3297 7655 +3297 3866 +3297 9853 +3297 5221 +3298 4928 +3298 5203 +3298 9092 +3298 8361 +3298 7271 +3298 6352 +3298 5489 +3298 6098 +3298 6899 +3298 7264 +3298 6313 +3298 5439 +3298 4538 +3299 7138 +3299 4805 +3299 8888 +3299 9869 +3299 3822 +3299 4589 +3299 3890 +3299 3319 +3299 5848 +3299 9122 +3300 9499 +3300 3771 +3300 9192 +3300 8716 +3300 8046 +3300 3311 +3300 4720 +3300 8584 +3300 9592 +3300 8569 +3300 5147 +3300 3326 +3301 7488 +3301 6311 +3301 8458 +3301 4589 +3301 5998 +3301 4175 +3301 4630 +3301 6394 +3301 7162 +3301 8795 +3302 6884 +3302 5575 +3302 8075 +3302 6060 +3302 7086 +3302 4881 +3302 4617 +3302 3349 +3302 4340 +3302 7515 +3302 3582 +3303 4848 +3303 8298 +3303 6669 +3303 9007 +3303 7664 +3303 7090 +3303 4532 +3303 8606 +3303 8507 +3303 5534 +3304 9739 +3304 3347 +3304 9755 +3304 7201 +3304 9894 +3304 5545 +3304 3372 +3304 5561 +3304 4413 +3304 3520 +3304 3788 +3304 4173 +3304 5844 +3304 5717 +3304 4703 +3304 8804 +3304 9747 +3304 7849 +3304 4858 +3305 4001 +3305 5378 +3305 8488 +3305 5070 +3305 5440 +3305 3440 +3305 8110 +3305 4023 +3305 6580 +3305 7612 +3306 7552 +3306 5249 +3306 4231 +3306 8204 +3306 8973 +3306 4510 +3306 5286 +3306 4146 +3306 5427 +3306 7995 +3306 9414 +3306 7637 +3306 3431 +3306 3687 +3306 6013 +3306 8818 +3306 6390 +3306 7801 +3307 6529 +3307 6278 +3307 7724 +3307 6165 +3307 4119 +3307 4207 +3307 7717 +3307 8753 +3307 7516 +3307 3884 +3307 8878 +3307 5808 +3307 4529 +3307 5171 +3307 8800 +3307 9411 +3307 7383 +3307 4828 +3307 4704 +3307 6882 +3307 7910 +3307 3311 +3307 7669 +3307 7165 +3307 5374 +3308 3915 +3308 8068 +3308 6533 +3308 7303 +3308 7433 +3308 3819 +3308 8306 +3308 4366 +3308 5650 +3308 8083 +3308 4317 +3309 3648 +3309 5442 +3309 8242 +3309 8134 +3309 6505 +3309 5258 +3309 6018 +3309 7279 +3309 6139 +3309 6196 +3309 6650 +3309 4762 +3310 7174 +3310 4234 +3310 6381 +3310 9617 +3310 4115 +3310 9240 +3310 4137 +3310 4398 +3310 5046 +3310 4813 +3310 9551 +3310 6608 +3310 7126 +3310 9052 +3310 5349 +3310 8294 +3310 8813 +3310 7929 +3311 6752 +3311 6305 +3311 9890 +3311 9238 +3311 8647 +3311 6241 +3311 8811 +3311 4014 +3311 9111 +3311 7510 +3311 7012 +3311 5979 +3312 8067 +3312 5518 +3312 4461 +3312 9749 +3312 3997 +3312 7328 +3312 4004 +3312 6568 +3312 7215 +3312 3505 +3312 6583 +3312 7739 +3312 7758 +3312 7759 +3312 7017 +3312 8429 +3312 4849 +3312 9592 +3313 8548 +3313 9030 +3313 8070 +3313 9969 +3313 4237 +3313 9134 +3313 4272 +3313 5745 +3313 4316 +3313 6620 +3313 5149 +3314 5888 +3314 6945 +3314 3691 +3314 9542 +3314 6156 +3314 3402 +3314 6859 +3314 7278 +3314 9039 +3314 8299 +3314 4309 +3314 8543 +3314 4479 +3315 6816 +3315 4129 +3315 3363 +3315 5796 +3315 3877 +3315 5798 +3315 4391 +3315 9388 +3315 9392 +3315 8632 +3315 7098 +3315 6977 +3315 7499 +3315 6096 +3315 6098 +3315 3414 +3315 6620 +3315 8669 +3315 8544 +3315 7782 +3315 8938 +3315 9383 +3316 9398 +3316 4961 +3316 7627 +3316 3436 +3316 5965 +3316 4526 +3316 5135 +3316 7344 +3316 8246 +3316 7031 +3316 5657 +3316 7643 +3316 5213 +3317 5280 +3317 4943 +3317 7109 +3317 6374 +3317 7274 +3317 7756 +3317 4913 +3317 6356 +3317 8469 +3317 3478 +3317 5721 +3317 9620 +3317 5981 +3317 5214 +3317 4799 +3318 3726 +3318 7567 +3318 5520 +3318 4888 +3318 4255 +3318 8995 +3318 4644 +3318 5542 +3318 7975 +3318 4426 +3318 5583 +3318 3670 +3318 3472 +3318 7911 +3318 8423 +3318 8050 +3318 3323 +3318 6780 +3319 6285 +3319 4495 +3319 6288 +3319 3608 +3319 6297 +3319 3621 +3319 5928 +3319 8235 +3319 7986 +3319 8120 +3319 6713 +3319 7501 +3319 9101 +3319 8029 +3319 6761 +3319 4461 +3319 3698 +3319 4092 +3319 4733 +3319 8447 +3320 8904 +3320 7691 +3320 5811 +3320 5079 +3320 8297 +3320 4154 +3320 5179 +3320 7903 +3320 3839 +3321 5271 +3321 7180 +3321 6928 +3321 6677 +3321 5721 +3321 9070 +3321 9510 +3321 4010 +3321 9787 +3321 6472 +3321 8665 +3321 8802 +3321 4330 +3321 7406 +3321 4629 +3322 6021 +3322 4625 +3322 4755 +3322 5908 +3322 8086 +3322 5274 +3322 3996 +3322 5027 +3322 5158 +3322 7208 +3322 3635 +3322 5598 +3322 8126 +3322 6351 +3322 6096 +3322 4473 +3322 3800 +3322 5854 +3322 9965 +3322 5616 +3322 3441 +3323 8708 +3323 5775 +3323 3419 +3323 9510 +3323 8231 +3323 4905 +3323 7212 +3323 8111 +3323 9523 +3323 4409 +3323 6335 +3323 5568 +3323 6857 +3323 5848 +3323 9945 +3323 7651 +3323 7398 +3323 4851 +3323 7977 +3323 9082 +3323 9852 +3323 9853 +3323 3711 +3324 8972 +3324 3736 +3324 6810 +3324 4388 +3324 8489 +3324 8754 +3324 5172 +3324 4542 +3324 9663 +3324 5448 +3324 3663 +3324 3664 +3324 4826 +3324 8158 +3324 4964 +3324 5488 +3324 5747 +3324 7156 +3325 5616 +3325 4259 +3325 8708 +3325 3622 +3325 3760 +3325 7508 +3325 3442 +3325 5973 +3325 6613 +3325 8411 +3325 5431 +3325 8571 +3325 4507 +3325 9629 +3325 8351 +3326 4619 +3326 8971 +3326 6052 +3326 4113 +3326 7623 +3326 5555 +3326 7443 +3326 9141 +3326 6294 +3326 4887 +3326 9497 +3326 4847 +3326 9180 +3326 6141 +3327 3744 +3327 8688 +3327 4683 +3327 9029 +3327 4808 +3327 7362 +3327 7048 +3327 4275 +3327 5235 +3327 4666 +3327 9563 +3327 6460 +3327 8735 +3328 6911 +3328 6581 +3328 9572 +3328 7561 +3328 8799 +3328 3342 +3328 5679 +3328 6771 +3328 4052 +3328 3861 +3328 5270 +3328 7081 +3328 9177 +3328 3706 +3328 5183 +3328 5692 +3328 6981 +3329 4619 +3329 7693 +3329 6159 +3329 3984 +3329 6034 +3329 6292 +3329 4757 +3329 5920 +3329 3772 +3329 9030 +3329 4170 +3329 6475 +3329 9807 +3329 9085 +3330 9443 +3330 3684 +3330 5350 +3330 5287 +3330 4143 +3330 4273 +3330 6993 +3330 8190 +3331 3873 +3331 9411 +3331 9316 +3331 9193 +3331 6765 +3331 8334 +3331 5873 +3331 7381 +3331 5112 +3332 3461 +3332 5003 +3332 4496 +3332 4881 +3332 8595 +3332 7829 +3332 5014 +3332 3611 +3332 7965 +3332 9861 +3332 7340 +3332 7856 +3332 4924 +3332 7617 +3332 6999 +3332 8154 +3332 5210 +3332 8539 +3332 7530 +3332 6136 +3333 6934 +3333 7063 +3333 6175 +3333 7585 +3333 7207 +3333 6835 +3333 8630 +3333 5693 +3333 6719 +3333 7640 +3333 7001 +3333 6749 +3333 4961 +3333 7011 +3333 9320 +3333 5496 +3333 5497 +3333 4476 +3334 8321 +3334 8338 +3334 4883 +3334 8340 +3334 5956 +3334 6585 +3334 8259 +3334 7498 +3334 4558 +3334 7309 +3334 4690 +3334 7894 +3334 5212 +3334 3602 +3334 9582 +3335 7297 +3335 7618 +3335 9412 +3335 7752 +3335 4228 +3335 6575 +3335 6457 +3335 9583 +3336 3608 +3336 9882 +3336 6181 +3336 6950 +3336 4268 +3336 4397 +3336 7215 +3336 8624 +3336 3391 +3336 5574 +3336 5878 +3336 5495 +3337 6530 +3337 6659 +3337 9228 +3337 8334 +3337 7953 +3337 5341 +3337 4632 +3337 7067 +3337 6687 +3337 6949 +3337 8879 +3337 5961 +3337 4305 +3337 5262 +3337 3557 +3337 8554 +3337 7151 +3337 7667 +3337 8181 +3338 4872 +3338 5258 +3338 9100 +3338 5013 +3338 8347 +3338 9887 +3338 7461 +3338 8616 +3338 9136 +3338 8114 +3338 3394 +3338 5848 +3338 4831 +3338 4324 +3338 3558 +3338 3665 +3338 3432 +3338 4465 +3338 9596 +3339 4388 +3339 9153 +3339 5731 +3339 6852 +3339 7048 +3339 5719 +3339 3979 +3339 9708 +3339 7725 +3339 4142 +3339 4657 +3339 9715 +3339 7863 +3339 4228 +3339 9882 +3340 5916 +3340 7965 +3340 4903 +3340 7354 +3340 8129 +3340 8386 +3340 9414 +3340 6477 +3340 9293 +3340 4307 +3340 8923 +3340 7932 +3341 4003 +3341 7687 +3341 9767 +3341 5356 +3341 9614 +3341 9584 +3341 8625 +3341 4722 +3341 7155 +3341 4263 +3341 8996 +3342 6530 +3342 5765 +3342 9108 +3342 5397 +3342 6430 +3342 6021 +3342 9127 +3342 8363 +3342 8112 +3342 9141 +3342 9655 +3342 3769 +3342 4805 +3342 6089 +3342 9038 +3342 7637 +3342 6369 +3342 7027 +3342 3835 +3342 3837 +3343 3553 +3343 4516 +3343 4805 +3343 4359 +3343 5580 +3343 5296 +3343 5297 +3343 3800 +3343 7316 +3343 3581 +3344 6593 +3344 6530 +3344 7251 +3344 3462 +3344 7015 +3344 4904 +3344 8368 +3344 3919 +3344 9423 +3344 7720 +3344 6569 +3344 8475 +3344 3421 +3345 5447 +3345 4842 +3345 4907 +3345 3631 +3345 4209 +3345 5993 +3346 6786 +3346 9096 +3346 5016 +3346 7580 +3346 8488 +3346 5551 +3346 8502 +3346 7095 +3346 9532 +3346 9789 +3346 5442 +3346 5706 +3346 8823 +3346 3405 +3346 7891 +3346 3438 +3346 3958 +3346 8055 +3346 9341 +3347 6433 +3347 7458 +3347 8742 +3347 6631 +3347 3657 +3347 7981 +3347 8880 +3347 5513 +3347 4792 +3347 7677 +3347 5404 +3347 8669 +3348 4765 +3348 8251 +3348 4837 +3348 3686 +3348 7207 +3348 9260 +3348 6749 +3348 6203 +3348 4733 +3348 6014 +3348 3941 +3349 5636 +3349 7304 +3349 5341 +3349 5657 +3349 3611 +3349 7588 +3349 4009 +3349 4701 +3349 4277 +3349 8372 +3349 8774 +3349 8648 +3349 7886 +3349 9424 +3349 3419 +3349 8925 +3349 8912 +3349 9956 +3349 7913 +3349 7159 +3349 6910 +3350 4578 +3350 3395 +3350 5573 +3350 4753 +3350 4044 +3350 7825 +3350 8345 +3350 8126 +3351 9824 +3351 8320 +3351 4902 +3351 6952 +3351 7817 +3351 9419 +3351 5324 +3351 8973 +3351 4367 +3351 7568 +3351 3923 +3351 5466 +3351 8367 +3351 8701 +3352 5504 +3352 4642 +3352 6309 +3352 9350 +3352 6921 +3352 6475 +3352 8588 +3352 3537 +3352 6482 +3352 6102 +3352 6200 +3352 5341 +3352 8766 +3353 8736 +3353 7071 +3353 7686 +3353 3689 +3353 9035 +3353 6226 +3353 9549 +3353 6898 +3353 6291 +3353 4052 +3353 6358 +3353 8568 +3353 8251 +3353 9980 +3353 5533 +3354 5986 +3354 9159 +3354 7468 +3354 9228 +3354 9039 +3354 7857 +3354 5458 +3354 4854 +3354 7225 +3354 6910 +3354 5215 +3355 3744 +3355 6465 +3355 8587 +3355 3406 +3355 6095 +3355 9970 +3355 3764 +3355 6586 +3355 9679 +3356 4099 +3356 5396 +3356 5641 +3356 8212 +3356 3357 +3356 5280 +3356 7977 +3356 8363 +3356 9654 +3356 3385 +3356 8397 +3356 6613 +3356 6358 +3356 5207 +3356 7641 +3356 5082 +3356 3551 +3356 4704 +3356 5101 +3356 8441 +3356 7803 +3356 6014 +3357 8642 +3357 3372 +3357 3535 +3357 9732 +3357 6332 +3357 6815 +3358 8032 +3358 9476 +3358 7590 +3358 7046 +3358 8649 +3358 3695 +3358 9872 +3358 7541 +3358 7576 +3358 9807 +3358 5531 +3358 5916 +3358 3749 +3359 3624 +3359 9670 +3359 8417 +3359 7880 +3359 9610 +3359 8594 +3359 5073 +3359 6290 +3359 5910 +3359 6456 +3359 4667 +3359 6588 +3359 4026 +3360 7489 +3360 9923 +3360 4240 +3360 4523 +3360 5026 +3360 9038 +3360 5187 +3360 5395 +3360 6036 +3360 3705 +3360 7453 +3361 4774 +3361 5607 +3361 9767 +3361 6055 +3361 6224 +3361 7317 +3361 7994 +3361 7195 +3361 8725 +3362 4740 +3362 5381 +3362 3757 +3362 7317 +3362 7082 +3362 6189 +3362 6831 +3362 5681 +3362 4028 +3362 9412 +3362 7000 +3362 4335 +3362 6387 +3362 7930 +3363 5642 +3363 8203 +3363 7316 +3363 8216 +3363 8775 +3363 8758 +3363 8388 +3363 6215 +3363 4300 +3363 9208 +3363 5750 +3363 4728 +3363 8441 +3364 8993 +3364 8258 +3364 4171 +3364 5346 +3364 6836 +3364 8501 +3364 8216 +3364 6490 +3364 6077 +3365 5232 +3365 3780 +3365 3557 +3365 9668 +3365 7720 +3365 6841 +3365 5200 +3365 3422 +3365 6133 +3365 5687 +3365 5880 +3365 7801 +3365 5850 +3366 4994 +3366 5608 +3366 8651 +3366 9486 +3366 3572 +3366 4014 +3366 6198 +3366 6871 +3366 5459 +3366 8677 +3367 4353 +3367 9559 +3367 3479 +3367 3639 +3367 7866 +3367 8644 +3367 6726 +3367 3537 +3367 6615 +3367 3676 +3367 7401 +3367 7278 +3367 4211 +3367 8950 +3367 5497 +3367 7807 +3368 3715 +3368 8965 +3368 6545 +3368 9236 +3368 7342 +3368 4898 +3368 3879 +3368 4272 +3368 8496 +3368 4178 +3368 4185 +3368 3952 +3368 7541 +3368 3477 +3369 5287 +3369 4848 +3369 7093 +3369 6838 +3369 3543 +3369 9208 +3369 8540 +3369 7477 +3370 9704 +3370 6119 +3370 5161 +3370 7783 +3370 5581 +3370 3886 +3370 8237 +3370 4720 +3370 5073 +3370 7058 +3370 5239 +3370 3641 +3370 8155 +3370 9564 +3370 8415 +3371 8096 +3371 7212 +3371 9962 +3371 5036 +3371 5805 +3371 7406 +3371 5810 +3371 4980 +3372 9569 +3372 7586 +3372 8160 +3372 7721 +3372 6284 +3372 6236 +3372 9553 +3372 9203 +3372 6380 +3372 5626 +3373 4032 +3373 7624 +3373 8773 +3373 7431 +3373 3786 +3373 7627 +3373 5964 +3373 7982 +3373 5936 +3373 9297 +3373 4627 +3373 6678 +3374 3552 +3374 4517 +3374 8983 +3374 8397 +3374 6464 +3374 5813 +3374 4885 +3374 5398 +3374 6005 +3374 8313 +3374 9984 +3374 6997 +3375 9472 +3375 4931 +3375 6929 +3375 6570 +3375 4813 +3375 4915 +3375 4821 +3375 8310 +3376 4865 +3376 5506 +3376 8198 +3376 5157 +3376 3761 +3376 5047 +3376 9415 +3376 5834 +3376 8247 +3376 3788 +3376 3419 +3376 9827 +3376 7532 +3376 9070 +3376 8304 +3376 6910 +3377 9792 +3377 5403 +3377 8452 +3377 8127 +3377 8678 +3377 5831 +3377 9806 +3377 6397 +3377 7729 +3377 9330 +3377 4891 +3377 3740 +3377 3805 +3377 7870 +3377 5215 +3378 3552 +3378 3755 +3378 3654 +3378 7016 +3378 5559 +3378 4237 +3378 8462 +3378 6033 +3378 8466 +3378 3682 +3378 7702 +3378 9045 +3378 6021 +3378 7898 +3378 3518 +3379 7777 +3379 8262 +3379 9613 +3379 8781 +3379 9552 +3379 7410 +3379 9404 +3380 6665 +3380 7691 +3380 9487 +3380 6953 +3380 4793 +3380 9788 +3380 6973 +3380 6857 +3380 9954 +3380 6627 +3380 7527 +3380 4202 +3380 6513 +3380 3958 +3380 8440 +3380 6139 +3380 4605 +3381 9300 +3381 5440 +3381 3558 +3381 8780 +3381 7885 +3381 6990 +3381 4909 +3381 7000 +3381 8306 +3381 6323 +3381 6036 +3381 6233 +3381 6551 +3381 7352 +3381 9369 +3381 7130 +3381 4475 +3382 4705 +3382 5442 +3382 3715 +3382 7653 +3382 7015 +3382 7623 +3382 8683 +3382 9517 +3382 5840 +3382 9265 +3382 4978 +3382 9128 +3382 3988 +3382 6854 +3382 7863 +3382 4794 +3382 9317 +3383 9314 +3383 3715 +3383 3388 +3383 5259 +3383 5580 +3383 9890 +3383 9005 +3383 4692 +3383 9050 +3383 6299 +3383 5274 +3384 7713 +3384 4547 +3384 4417 +3384 7280 +3384 7658 +3384 8043 +3384 8123 +3384 5166 +3384 9456 +3384 6296 +3384 6325 +3384 6391 +3384 5145 +3384 9818 +3384 5980 +3385 4225 +3385 4451 +3385 8329 +3385 6572 +3385 5901 +3385 5456 +3385 5299 +3385 5654 +3385 6668 +3386 8896 +3386 6209 +3386 9187 +3386 6020 +3386 3405 +3386 7825 +3386 6898 +3386 3536 +3386 4630 +3386 5335 +3386 3572 +3387 6660 +3387 6791 +3387 3723 +3387 9390 +3387 9499 +3387 3743 +3387 4386 +3387 7715 +3387 6830 +3387 5042 +3387 5191 +3387 7117 +3387 5718 +3387 8702 +3387 6520 +3387 3838 +3387 9727 +3388 5121 +3388 6148 +3388 7950 +3388 7590 +3388 6069 +3388 8907 +3388 8261 +3388 4936 +3388 8413 +3388 6250 +3388 9966 +3388 7287 +3388 9979 +3388 5116 +3389 7456 +3389 3874 +3389 9667 +3389 6102 +3389 9798 +3389 4233 +3389 4947 +3389 8276 +3389 7733 +3389 6902 +3389 8169 +3390 8992 +3390 4609 +3390 8947 +3390 5763 +3390 8165 +3390 7046 +3390 9196 +3390 4173 +3390 9487 +3390 9233 +3390 4050 +3390 4755 +3390 6935 +3390 9881 +3390 9948 +3390 3621 +3391 7842 +3391 6021 +3391 5478 +3391 5820 +3391 7597 +3391 9518 +3391 6397 +3391 6768 +3391 6334 +3391 9813 +3391 5808 +3391 5564 +3391 7613 +3391 9566 +3392 6792 +3392 9231 +3392 8723 +3392 4512 +3392 9893 +3392 8878 +3392 6332 +3392 4032 +3392 7364 +3392 5837 +3392 6991 +3392 4561 +3392 5715 +3392 5104 +3392 4856 +3392 7037 +3393 4960 +3393 9088 +3393 3542 +3393 5415 +3393 7848 +3393 5933 +3393 5071 +3393 6613 +3393 7286 +3393 6103 +3393 7481 +3393 5694 +3394 5440 +3394 9824 +3394 3717 +3394 3850 +3394 6987 +3394 8268 +3394 3793 +3394 6419 +3394 9721 +3394 4275 +3394 4575 +3395 5569 +3395 5685 +3395 4037 +3395 6919 +3395 7400 +3395 7627 +3395 9762 +3395 7662 +3395 7566 +3395 4415 +3395 5109 +3395 6615 +3396 8306 +3396 7299 +3396 9099 +3396 5388 +3396 5133 +3396 3997 +3396 4337 +3396 7864 +3396 5704 +3396 6373 +3396 7269 +3396 7277 +3396 4850 +3396 8439 +3397 5398 +3397 5187 +3397 5348 +3397 7784 +3397 3671 +3397 4811 +3397 4753 +3397 8501 +3397 4183 +3397 5290 +3397 7134 +3397 8991 +3398 9859 +3398 4225 +3398 7178 +3398 6644 +3398 6448 +3398 5553 +3398 8372 +3398 9781 +3398 3924 +3398 8189 +3398 4597 +3399 9701 +3399 4519 +3399 9966 +3399 6415 +3399 3475 +3399 9815 +3399 5145 +3400 8323 +3400 6533 +3400 3559 +3400 5035 +3400 9966 +3400 8625 +3400 3475 +3400 8889 +3401 4672 +3401 9379 +3401 4260 +3401 7525 +3401 8262 +3401 4679 +3401 5899 +3401 8396 +3401 4943 +3401 3728 +3401 6312 +3401 7506 +3401 4382 +3401 6678 +3401 4760 +3401 5757 +3401 9534 +3402 8203 +3402 7692 +3402 5007 +3402 7201 +3402 9003 +3402 8889 +3402 7483 +3402 7645 +3402 8038 +3402 8554 +3402 4716 +3402 9453 +3402 9456 +3403 4229 +3403 7266 +3403 8339 +3403 6950 +3403 6790 +3403 4008 +3403 8531 +3403 4811 +3403 8591 +3403 8819 +3403 7252 +3403 5981 +3403 7678 +3403 7909 +3404 4674 +3404 9350 +3404 7945 +3404 6546 +3404 4309 +3404 9526 +3404 4159 +3404 6271 +3405 6944 +3405 8465 +3405 7080 +3405 4110 +3405 9069 +3405 9742 +3405 4561 +3405 5205 +3405 9339 +3405 6844 +3406 3874 +3406 9350 +3406 9777 +3406 7211 +3406 6254 +3406 4751 +3406 4724 +3406 8244 +3406 8151 +3406 3745 +3407 6370 +3407 7812 +3407 9446 +3407 8136 +3407 4922 +3407 6643 +3407 6772 +3407 4888 +3407 8661 +3408 9221 +3408 8842 +3408 5745 +3408 4400 +3408 7602 +3408 7096 +3408 9273 +3408 4284 +3408 6981 +3408 3787 +3408 3412 +3408 5711 +3408 9187 +3408 7140 +3408 9325 +3408 7534 +3408 8048 +3408 6257 +3408 9970 +3408 9718 +3409 8322 +3409 4694 +3409 8969 +3409 4376 +3409 6819 +3409 7863 +3409 4280 +3409 9664 +3409 7106 +3409 4822 +3409 4441 +3409 3806 +3409 4579 +3409 8553 +3409 7799 +3409 8560 +3409 9466 +3410 7808 +3410 8545 +3410 5121 +3410 4550 +3410 4583 +3410 3562 +3410 7952 +3410 9844 +3410 3502 +3410 6044 +3410 4778 +3411 8992 +3411 9410 +3411 9339 +3411 6340 +3411 6572 +3411 7262 +3411 3564 +3411 8432 +3411 3631 +3411 7132 +3411 7092 +3411 7286 +3411 4983 +3411 6556 +3411 6654 +3412 3744 +3412 8289 +3412 5250 +3412 4612 +3412 9830 +3412 6892 +3412 4482 +3412 7597 +3412 4946 +3412 3934 +3412 8720 +3412 8311 +3412 3962 +3412 8837 +3413 9952 +3413 9156 +3413 5733 +3413 4263 +3413 4043 +3413 7339 +3413 3630 +3413 8143 +3413 5422 +3413 5461 +3413 3543 +3413 9255 +3413 9308 +3414 5256 +3414 5132 +3414 5030 +3414 7733 +3414 5408 +3414 8773 +3414 7247 +3414 4435 +3414 3800 +3414 7674 +3414 7035 +3415 5447 +3415 8806 +3415 7623 +3415 7923 +3415 8656 +3415 3823 +3415 3728 +3415 4721 +3415 9970 +3415 3924 +3415 5591 +3415 4983 +3415 6772 +3415 4573 +3416 5922 +3416 3875 +3416 6024 +3416 6506 +3416 6444 +3416 9072 +3416 3895 +3416 3540 +3416 4730 +3416 7946 +3416 6879 +3417 6144 +3417 9825 +3417 4322 +3417 9990 +3417 3782 +3417 9418 +3417 7852 +3417 7364 +3417 5810 +3417 7540 +3417 7992 +3417 9849 +3417 7100 +3418 6378 +3418 6166 +3418 5625 +3418 6073 +3418 6748 +3418 5470 +3419 6380 +3419 9994 +3419 5643 +3419 8974 +3419 9838 +3419 6564 +3419 3501 +3419 6836 +3419 6965 +3419 4292 +3419 3530 +3419 4174 +3419 8530 +3419 7139 +3419 8421 +3419 4714 +3419 8305 +3419 6131 +3419 6008 +3419 5631 +3420 8385 +3420 7749 +3420 5505 +3420 5262 +3420 5390 +3420 8561 +3420 7120 +3420 7953 +3420 5875 +3420 5748 +3420 9550 +3420 5142 +3421 3734 +3421 6795 +3421 9489 +3421 8726 +3421 6427 +3421 8220 +3421 6577 +3421 7221 +3421 6519 +3421 7122 +3421 8313 +3421 9449 +3421 8183 +3421 7544 +3422 9920 +3422 3523 +3422 5444 +3422 7877 +3422 8892 +3422 4199 +3422 4579 +3422 3737 +3422 4571 +3422 5436 +3422 8510 +3422 8748 +3423 8228 +3423 5141 +3423 9353 +3423 7783 +3423 5586 +3423 4719 +3423 3537 +3423 8978 +3423 9203 +3423 9972 +3423 3478 +3423 8426 +3423 4039 +3423 5564 +3423 4829 +3423 8095 +3424 6984 +3424 5774 +3424 6863 +3424 7025 +3424 8626 +3424 7091 +3424 7035 +3424 8189 +3425 4862 +3425 4356 +3425 4170 +3425 5389 +3425 6607 +3425 3504 +3425 3518 +3425 4471 +3425 8580 +3425 5391 +3425 3548 +3425 4693 +3426 5504 +3426 4834 +3426 9445 +3426 9622 +3426 6150 +3426 6929 +3426 4690 +3426 7083 +3426 3564 +3426 8082 +3426 3507 +3426 5846 +3426 7764 +3426 9147 +3426 7421 +3426 4414 +3426 8735 +3427 3840 +3427 5344 +3427 4580 +3427 9861 +3427 6374 +3427 7946 +3427 6891 +3427 7598 +3427 6741 +3427 4152 +3427 7161 +3427 5052 +3427 9662 +3428 4523 +3428 6734 +3428 7553 +3428 3447 +3428 7893 +3428 6835 +3428 6069 +3428 8297 +3428 8708 +3428 9481 +3428 6975 +3429 3975 +3429 6033 +3429 5665 +3429 6435 +3429 5930 +3429 7728 +3429 8251 +3429 7758 +3429 6497 +3429 7394 +3429 5605 +3429 7015 +3429 9582 +3429 8700 +3430 9666 +3430 7403 +3430 7530 +3430 8876 +3430 4354 +3430 9102 +3430 8240 +3430 8531 +3430 5172 +3430 3811 +3431 4102 +3431 7308 +3431 4369 +3431 8473 +3431 5036 +3431 6829 +3431 4282 +3431 4165 +3431 5067 +3431 4315 +3431 8286 +3431 9833 +3431 6895 +3431 3829 +3432 6793 +3432 6211 +3432 3608 +3432 4249 +3432 5805 +3432 8623 +3432 7730 +3432 4535 +3432 8378 +3432 7370 +3432 7626 +3432 5836 +3432 4685 +3432 7247 +3432 5080 +3432 4825 +3432 5871 +3432 5883 +3433 7635 +3433 7977 +3433 8266 +3433 8045 +3433 6190 +3433 6357 +3433 4280 +3433 9402 +3433 8191 +3433 4543 +3434 9091 +3434 8714 +3434 8217 +3434 6427 +3434 9131 +3434 3886 +3434 8376 +3434 5057 +3434 9803 +3434 3669 +3434 6358 +3434 4445 +3434 5986 +3434 6637 +3434 8693 +3434 3960 +3434 9599 +3435 7559 +3435 5132 +3435 6040 +3435 5280 +3435 3745 +3435 8483 +3435 5412 +3435 6437 +3435 7594 +3435 8455 +3435 4913 +3435 4926 +3435 9024 +3435 9169 +3435 8530 +3435 6612 +3435 6357 +3435 3515 +3435 4063 +3435 8547 +3435 7912 +3436 9872 +3436 6467 +3436 4164 +3436 6246 +3436 8583 +3436 3978 +3436 4205 +3436 8817 +3436 6612 +3436 3861 +3436 7174 +3436 6927 +3436 4348 +3436 6845 +3437 8868 +3437 3691 +3437 5996 +3437 9940 +3437 9501 +3437 5528 +3437 5554 +3437 3508 +3437 6965 +3437 5783 +3437 3565 +3437 7261 +3437 5855 +3438 8836 +3438 3588 +3438 5149 +3438 6302 +3438 5663 +3438 4515 +3438 8621 +3438 4921 +3438 9292 +3438 9182 +3438 8144 +3438 6372 +3438 9958 +3438 4327 +3438 8302 +3438 3835 +3438 9138 +3439 6910 +3439 3622 +3439 5388 +3439 7090 +3439 7086 +3439 4051 +3439 5438 +3439 9755 +3439 7516 +3439 6654 +3440 5539 +3440 6567 +3440 4425 +3440 5219 +3440 4679 +3440 8557 +3440 9135 +3440 8883 +3440 7027 +3440 9050 +3441 3458 +3441 9870 +3441 5011 +3441 5797 +3441 6055 +3441 9513 +3441 5301 +3441 5303 +3441 9916 +3441 8509 +3441 5703 +3441 9932 +3441 8149 +3441 7771 +3441 6398 +3442 5441 +3442 6723 +3442 9704 +3442 9257 +3442 4330 +3442 4301 +3442 7984 +3442 3537 +3442 8707 +3442 3446 +3442 8123 +3442 6876 +3443 7430 +3443 7178 +3443 5132 +3443 5023 +3443 3748 +3443 6855 +3443 9009 +3443 6983 +3443 5711 +3443 5362 +3443 9082 +3444 3842 +3444 6787 +3444 6614 +3444 5278 +3444 8992 +3444 4390 +3444 4145 +3444 9652 +3444 5189 +3444 8006 +3444 9038 +3444 9507 +3444 4309 +3444 8150 +3444 9181 +3444 3812 +3444 4327 +3444 3822 +3444 7536 +3444 8309 +3444 4728 +3444 6527 +3445 4513 +3445 4283 +3445 7908 +3445 5062 +3445 5735 +3445 5388 +3445 8187 +3445 9815 +3446 9744 +3446 4743 +3446 5128 +3446 9353 +3446 9451 +3446 8013 +3446 8366 +3446 7603 +3446 3540 +3446 7358 +3446 6934 +3446 4091 +3446 7733 +3447 3748 +3447 7318 +3447 7785 +3447 9003 +3447 3660 +3447 3981 +3447 3473 +3447 9177 +3447 9270 +3447 4631 +3447 6012 +3447 7229 +3447 6911 +3448 5795 +3448 5767 +3448 6380 +3448 5968 +3448 4083 +3448 5492 +3448 5272 +3448 4159 +3449 3555 +3449 5604 +3449 5703 +3449 7850 +3449 8396 +3449 8973 +3449 3887 +3449 6046 +3449 3961 +3449 4859 +3449 6399 +3450 4608 +3450 9761 +3450 7555 +3450 8881 +3450 9736 +3450 4969 +3450 5782 +3450 8773 +3450 8360 +3450 4594 +3450 4933 +3450 5460 +3450 6395 +3450 4249 +3451 8966 +3451 8463 +3451 5392 +3451 5267 +3451 7067 +3451 5324 +3451 9435 +3451 6756 +3451 6382 +3451 7407 +3451 6516 +3451 5366 +3452 9605 +3452 4102 +3452 7255 +3452 5783 +3452 9880 +3452 6813 +3452 8619 +3452 4916 +3452 5567 +3452 9411 +3452 6729 +3452 8927 +3452 5479 +3452 6781 +3452 7924 +3452 9338 +3453 8296 +3453 8012 +3453 9161 +3453 9133 +3453 4016 +3453 9041 +3453 6130 +3453 4692 +3453 9813 +3453 8571 +3453 3997 +3453 4626 +3454 9227 +3454 5906 +3454 5916 +3454 8109 +3454 3763 +3454 9914 +3454 6858 +3454 3917 +3454 6995 +3454 5222 +3454 9960 +3454 4207 +3454 7282 +3455 6720 +3455 5984 +3455 4872 +3455 5033 +3455 6410 +3455 4779 +3455 9586 +3455 5521 +3455 4466 +3455 4054 +3455 8232 +3455 5881 +3455 5402 +3455 6418 +3456 7680 +3456 8199 +3456 9104 +3456 7960 +3456 4761 +3456 6301 +3456 5924 +3456 7093 +3456 5567 +3456 4801 +3456 6723 +3456 4036 +3456 6864 +3456 5848 +3456 8027 +3456 7787 +3456 7166 +3457 5088 +3457 4769 +3457 3467 +3457 4777 +3457 9929 +3457 4843 +3457 8973 +3457 9488 +3457 5105 +3457 9270 +3457 3831 +3457 8377 +3457 5978 +3457 9276 +3458 4385 +3458 6050 +3458 6921 +3458 9224 +3458 5833 +3458 5191 +3458 4181 +3458 4759 +3458 8664 +3458 3866 +3458 9211 +3459 5377 +3459 5884 +3459 8685 +3459 9038 +3459 5135 +3459 3891 +3459 7381 +3459 7574 +3459 4088 +3459 6044 +3459 6877 +3459 3765 +3460 7296 +3460 4484 +3460 7176 +3460 4234 +3460 7325 +3460 5407 +3460 8866 +3460 4005 +3460 8614 +3460 6573 +3460 9649 +3460 4023 +3460 8256 +3460 9271 +3460 8278 +3460 5855 +3460 7010 +3460 9199 +3460 9851 +3461 8199 +3461 4623 +3461 3857 +3461 9492 +3461 3736 +3461 9498 +3461 5802 +3461 7218 +3461 4530 +3461 4419 +3461 5190 +3461 5339 +3461 4700 +3461 8701 +3462 4864 +3462 8461 +3462 5137 +3462 7959 +3462 5786 +3462 5021 +3462 9505 +3462 8746 +3462 9774 +3462 6589 +3462 9534 +3462 8127 +3462 6241 +3462 6863 +3462 9938 +3462 8152 +3462 4442 +3462 9582 +3463 7232 +3463 7362 +3463 9936 +3463 7282 +3463 8883 +3463 9589 +3463 5239 +3463 9147 +3463 4223 +3464 5129 +3464 7693 +3464 6672 +3464 7835 +3464 3999 +3464 6434 +3464 9766 +3464 7335 +3464 8233 +3464 8511 +3464 4946 +3464 8795 +3464 4830 +3464 9315 +3464 8932 +3464 3558 +3464 8041 +3464 6391 +3464 3963 +3465 4864 +3465 8591 +3465 6300 +3465 7459 +3465 5414 +3465 9201 +3465 9131 +3465 7980 +3465 9646 +3465 7732 +3465 8632 +3465 9791 +3465 9539 +3465 8900 +3465 5574 +3465 8009 +3465 4304 +3465 6356 +3465 7645 +3465 4722 +3465 6904 +3465 7930 +3466 7650 +3466 5347 +3466 8358 +3466 4394 +3466 6205 +3466 7727 +3466 9030 +3466 9029 +3466 7063 +3466 7865 +3466 3836 +3466 7775 +3467 8981 +3467 9111 +3467 7960 +3467 7065 +3467 4515 +3467 4527 +3467 6081 +3467 4424 +3467 3555 +3467 9063 +3467 8940 +3467 9854 +3468 8487 +3468 5509 +3468 8561 +3468 7921 +3468 3986 +3468 4483 +3468 5364 +3468 4393 +3468 4389 +3468 3964 +3468 5886 +3469 9991 +3469 9901 +3469 4911 +3469 7796 +3469 8887 +3469 4441 +3469 6458 +3469 5566 +3470 7584 +3470 4290 +3470 3907 +3470 4644 +3470 8806 +3470 4938 +3470 6547 +3470 8537 +3470 6713 +3470 9564 +3470 9724 +3470 7964 +3471 5248 +3471 4992 +3471 6818 +3471 9458 +3471 6834 +3471 9811 +3471 4942 +3471 3648 +3471 9025 +3472 9025 +3472 5072 +3472 9415 +3472 7849 +3472 8971 +3472 9008 +3472 7308 +3472 9715 +3472 9239 +3472 6681 +3473 4736 +3473 8449 +3473 5510 +3473 7433 +3473 9227 +3473 9228 +3473 7569 +3473 5142 +3473 8358 +3473 3751 +3473 4270 +3473 7109 +3473 6485 +3473 6885 +3473 5117 +3473 6391 +3473 3965 +3474 5700 +3474 5573 +3474 9447 +3474 4872 +3474 9801 +3474 8285 +3474 5839 +3474 7701 +3474 6102 +3474 4312 +3474 8026 +3474 7199 +3474 3997 +3475 3969 +3475 9858 +3475 9999 +3475 5264 +3475 3858 +3475 6051 +3475 8234 +3475 6973 +3475 8257 +3475 5954 +3475 3779 +3475 7255 +3475 9689 +3475 9440 +3475 4496 +3475 8803 +3475 8299 +3475 7660 +3475 6391 +3476 8199 +3476 4972 +3476 9995 +3476 5006 +3476 6306 +3476 5852 +3476 6061 +3476 7222 +3476 7873 +3476 8524 +3476 6475 +3476 6988 +3476 6479 +3476 8668 +3476 9822 +3476 7011 +3476 4711 +3476 9714 +3477 4459 +3477 8455 +3477 5015 +3477 9651 +3477 7667 +3477 4567 +3477 6951 +3477 5498 +3477 3932 +3477 4093 +3478 5441 +3478 6179 +3478 6628 +3478 7657 +3478 5738 +3478 6135 +3478 5402 +3478 4862 +3478 6623 +3479 6806 +3479 4232 +3479 6422 +3479 7839 +3479 6176 +3479 7971 +3479 8249 +3479 6080 +3479 7495 +3479 8813 +3480 5728 +3480 7656 +3480 6054 +3480 4392 +3480 7113 +3480 8074 +3480 6923 +3480 4531 +3480 4504 +3480 5587 +3480 5814 +3480 8947 +3480 7320 +3480 4984 +3480 9275 +3481 7042 +3481 3907 +3481 8484 +3481 6568 +3481 6028 +3481 3501 +3481 7951 +3481 3496 +3481 8722 +3481 6971 +3481 9591 +3481 6201 +3481 3643 +3481 4783 +3482 3936 +3482 5794 +3482 3747 +3482 4806 +3482 3623 +3482 6956 +3482 5005 +3482 9742 +3482 6639 +3482 6043 +3483 6277 +3483 7191 +3483 5403 +3483 9115 +3483 5556 +3483 4678 +3483 8521 +3483 4687 +3483 7259 +3483 6622 +3483 4196 +3483 6630 +3483 8430 +3483 4336 +3483 6651 +3484 4289 +3484 7269 +3484 7405 +3484 6707 +3484 6264 +3484 5050 +3484 9052 +3484 5882 +3484 5470 +3485 3553 +3485 6891 +3485 9260 +3485 6001 +3485 7253 +3485 9753 +3485 5809 +3485 5726 +3485 3903 +3486 7425 +3486 6499 +3486 7494 +3486 8166 +3486 6215 +3486 9345 +3486 9214 +3486 4647 +3486 6659 +3486 5163 +3486 4467 +3486 6787 +3486 8053 +3486 8583 +3487 9097 +3487 7459 +3487 5677 +3487 9151 +3487 8644 +3487 5580 +3487 9039 +3487 8655 +3487 8549 +3487 8171 +3487 4340 +3487 9466 +3487 8446 +3488 8707 +3488 5617 +3488 4052 +3488 8214 +3488 9785 +3489 5196 +3489 6413 +3489 4659 +3489 8020 +3489 6165 +3489 8347 +3489 9116 +3489 4125 +3490 4196 +3490 8966 +3490 5799 +3490 8551 +3490 4012 +3490 7602 +3491 4738 +3491 5651 +3491 6932 +3491 4650 +3491 8110 +3491 5935 +3491 9906 +3491 8755 +3491 8759 +3491 9786 +3491 7497 +3491 7886 +3491 4845 +3492 7935 +3492 4681 +3492 8647 +3492 9769 +3492 4834 +3492 6350 +3492 3941 +3492 4918 +3492 7549 +3492 3610 +3492 9727 +3492 3550 +3492 5861 +3493 7382 +3493 9889 +3493 5538 +3493 5023 +3493 4582 +3493 7830 +3493 6220 +3493 4430 +3493 4751 +3493 6640 +3493 8177 +3493 5042 +3493 3732 +3493 3546 +3493 5302 +3493 6800 +3493 4570 +3493 7295 +3494 4290 +3494 7686 +3494 5896 +3494 6729 +3494 8171 +3494 4782 +3494 5992 +3494 5557 +3494 4398 +3494 3647 +3495 5122 +3495 4773 +3495 3686 +3495 7820 +3495 8462 +3495 3512 +3495 4504 +3495 3897 +3495 7578 +3495 7486 +3495 7109 +3496 4192 +3496 5219 +3496 8678 +3496 7559 +3496 4009 +3496 6122 +3496 9779 +3496 8596 +3496 5461 +3496 4981 +3496 7612 +3497 4813 +3497 6339 +3497 4932 +3497 3814 +3497 8220 +3497 7531 +3497 4556 +3497 5229 +3497 6861 +3497 3803 +3497 5337 +3497 5563 +3497 9277 +3497 7071 +3498 4354 +3498 6787 +3498 7817 +3498 3860 +3498 7713 +3498 8233 +3498 9263 +3498 6835 +3498 5568 +3498 9671 +3498 7117 +3498 7250 +3498 8920 +3498 9567 +3498 6752 +3498 5345 +3498 3950 +3498 8176 +3498 9715 +3498 9469 +3499 5286 +3499 7370 +3499 7853 +3499 3572 +3499 9915 +3499 6557 +3499 5055 +3500 4864 +3500 9124 +3500 9288 +3500 6377 +3500 8522 +3500 5863 +3500 7790 +3500 6159 +3500 3793 +3500 8306 +3500 6871 +3500 9848 +3500 7290 +3500 5531 +3501 8770 +3501 5155 +3501 9382 +3501 5997 +3501 5704 +3501 3948 +3501 9005 +3501 9934 +3501 9584 +3501 4995 +3501 6702 +3501 7574 +3501 3503 +3501 8958 +3502 9741 +3502 9232 +3502 9363 +3502 8725 +3502 9504 +3502 6818 +3502 7337 +3502 7364 +3502 7109 +3502 8008 +3502 6157 +3502 4429 +3502 7246 +3502 9167 +3502 3746 +3502 7651 +3502 8296 +3502 8944 +3502 5617 +3502 5110 +3502 6780 +3503 6337 +3503 6083 +3503 9985 +3503 8163 +3503 9365 +3503 9492 +3503 4574 +3503 8863 +3504 5042 +3504 5474 +3504 9795 +3504 6080 +3504 5836 +3504 9649 +3504 6386 +3504 4371 +3504 8308 +3504 9300 +3504 5850 +3505 6272 +3505 9648 +3505 8411 +3505 9061 +3505 3527 +3505 4936 +3505 4316 +3505 6444 +3505 5065 +3505 5625 +3505 3995 +3505 6172 +3505 4795 +3506 4769 +3506 8964 +3506 9926 +3506 8071 +3506 5641 +3506 6314 +3506 3917 +3506 9006 +3506 7473 +3506 4435 +3506 9013 +3506 8438 +3507 5824 +3507 9889 +3507 5798 +3507 5298 +3507 7365 +3507 4936 +3507 5707 +3507 4578 +3507 9574 +3508 4992 +3508 9864 +3508 3979 +3508 3602 +3508 5782 +3508 6047 +3508 5283 +3508 4517 +3508 7846 +3508 8755 +3508 5218 +3508 4304 +3508 4443 +3508 8802 +3508 8701 +3509 4490 +3509 9742 +3509 5275 +3509 8739 +3509 6312 +3509 6727 +3509 9137 +3509 5300 +3509 9272 +3509 9412 +3509 5191 +3509 7897 +3509 8159 +3509 4716 +3509 8176 +3510 6289 +3510 8724 +3510 6421 +3510 9116 +3510 5410 +3510 4422 +3510 4776 +3510 8745 +3510 4535 +3510 5186 +3510 5899 +3510 7496 +3510 4170 +3510 3662 +3510 9429 +3510 8554 +3510 3565 +3510 7282 +3511 5504 +3511 9380 +3511 4260 +3511 4556 +3511 8780 +3511 8653 +3511 5198 +3511 5585 +3511 3732 +3511 7099 +3511 5182 +3512 6173 +3512 8354 +3512 8231 +3512 3886 +3512 5295 +3512 9649 +3512 3640 +3512 7617 +3512 8517 +3512 9542 +3512 5834 +3512 6927 +3512 4830 +3512 6367 +3512 7670 +3512 8956 +3512 7421 +3513 6274 +3513 5900 +3513 6018 +3513 6419 +3513 4762 +3513 8869 +3513 3758 +3513 7733 +3513 5062 +3513 7759 +3513 7136 +3513 4068 +3513 7147 +3513 6893 +3513 8063 +3514 4353 +3514 9860 +3514 5901 +3514 8341 +3514 7329 +3514 8866 +3514 9764 +3514 4528 +3514 4035 +3514 5711 +3514 3797 +3514 4186 +3514 7543 +3514 7674 +3515 6635 +3515 5659 +3515 4455 +3515 7865 +3515 7986 +3515 5828 +3515 6989 +3515 7763 +3515 4954 +3515 8924 +3515 7008 +3515 8977 +3515 4332 +3515 5617 +3515 3827 +3515 9978 +3515 6526 +3516 7042 +3516 5637 +3516 7318 +3516 5168 +3516 6963 +3516 7860 +3516 6965 +3516 5565 +3516 7744 +3516 9925 +3516 9166 +3516 8528 +3516 6866 +3516 5846 +3516 3674 +3516 9058 +3516 8063 +3517 4871 +3517 5911 +3517 4366 +3517 5008 +3517 7063 +3517 6426 +3517 8228 +3517 9015 +3517 8505 +3517 8255 +3517 8651 +3517 6982 +3517 5195 +3517 3550 +3517 5520 +3517 7280 +3517 5371 +3518 5607 +3518 7335 +3518 6386 +3518 7539 +3518 6292 +3518 5462 +3518 8729 +3518 7675 +3519 8960 +3519 8578 +3519 8978 +3519 8851 +3519 7700 +3519 6559 +3519 4904 +3519 7722 +3519 7730 +3519 7735 +3519 3911 +3519 7380 +3519 4825 +3519 9442 +3520 3735 +3520 4774 +3520 6722 +3520 9675 +3520 4684 +3520 7180 +3520 4818 +3520 6489 +3520 7265 +3520 9318 +3520 6379 +3520 9723 +3521 7298 +3521 4357 +3521 5516 +3521 7257 +3521 8349 +3521 5536 +3521 8609 +3521 5924 +3521 3987 +3521 5682 +3521 6324 +3521 4025 +3521 5436 +3521 9285 +3521 8775 +3521 4937 +3521 6099 +3521 8660 +3521 3934 +3521 9555 +3521 5246 +3521 5523 +3521 3957 +3521 4985 +3521 5971 +3521 4091 +3522 8964 +3522 7995 +3522 5388 +3522 9357 +3522 6893 +3522 3636 +3522 5685 +3522 5659 +3522 7261 +3522 9055 +3523 3940 +3523 5093 +3523 9259 +3523 5773 +3523 3917 +3523 7089 +3523 4030 +3523 9109 +3523 9215 +3523 8476 +3523 5053 +3524 7808 +3524 6080 +3524 9922 +3524 9851 +3524 6438 +3524 7185 +3524 6873 +3524 5233 +3524 6902 +3524 8345 +3524 7675 +3524 6589 +3525 9792 +3525 6402 +3525 5547 +3525 4356 +3525 8577 +3525 8531 +3525 9706 +3525 9867 +3525 8172 +3525 5943 +3525 3795 +3525 5332 +3525 9335 +3525 9820 +3526 3972 +3526 6314 +3526 8174 +3526 5495 +3526 7032 +3527 9220 +3527 9101 +3527 6543 +3527 9659 +3527 4593 +3527 6827 +3527 3757 +3527 5806 +3527 7867 +3527 6725 +3527 8912 +3527 8785 +3527 6971 +3527 8823 +3528 5857 +3528 4165 +3528 9459 +3528 6967 +3528 6702 +3528 8176 +3528 7985 +3528 7955 +3528 9278 +3528 9175 +3528 8827 +3529 4032 +3529 7010 +3529 9991 +3529 4298 +3529 9197 +3529 6543 +3529 5360 +3529 7258 +3529 9883 +3529 9738 +3529 8350 +3530 4997 +3530 7822 +3530 7704 +3530 8746 +3530 6065 +3530 6834 +3530 4403 +3530 6328 +3530 8383 +3530 9154 +3530 5188 +3530 9797 +3530 9159 +3530 5456 +3530 7252 +3530 6359 +3530 6873 +3530 8159 +3530 6642 +3530 4799 +3531 8714 +3531 3686 +3531 5996 +3531 6316 +3531 4494 +3531 9551 +3531 7921 +3531 7546 +3532 6824 +3532 3787 +3532 7757 +3532 4079 +3532 7762 +3532 9989 +3532 8854 +3532 4087 +3532 9016 +3532 8101 +3532 4767 +3532 4221 +3532 5605 +3533 8128 +3533 4260 +3533 4492 +3533 9804 +3533 7341 +3533 9049 +3533 7287 +3533 4728 +3533 9082 +3533 4997 +3534 8800 +3534 5776 +3534 5611 +3534 5540 +3534 4712 +3534 7115 +3534 6128 +3534 8466 +3534 3828 +3534 6839 +3534 4409 +3534 3643 +3534 5663 +3535 4111 +3535 5667 +3535 8833 +3535 7944 +3535 6477 +3535 8175 +3535 7601 +3535 8083 +3535 4180 +3535 9464 +3535 5566 +3535 5055 +3536 9771 +3536 4517 +3536 9094 +3536 5950 +3536 9387 +3536 8751 +3536 3824 +3536 9011 +3536 6740 +3536 7893 +3536 8888 +3536 4111 +3536 4362 +3536 3934 +3537 7825 +3537 6890 +3537 7469 +3537 9775 +3537 7092 +3537 7671 +3537 6116 +3537 8442 +3537 6683 +3537 6799 +3538 6788 +3538 8967 +3538 6541 +3538 9615 +3538 9791 +3538 9630 +3538 6559 +3538 4644 +3538 7208 +3538 5807 +3538 8120 +3538 6463 +3538 9847 +3538 6359 +3538 7514 +3538 9823 +3538 7913 +3538 9961 +3538 9979 +3539 3940 +3539 3753 +3539 9458 +3539 9040 +3539 4434 +3539 6515 +3539 4405 +3539 7419 +3539 4029 +3540 6438 +3540 6279 +3540 4649 +3540 7403 +3540 6123 +3540 8936 +3540 8206 +3540 4783 +3540 5143 +3540 5690 +3540 3639 +3540 8606 +3540 8127 +3541 4490 +3541 8721 +3541 8724 +3541 6677 +3541 6300 +3541 4293 +3541 8494 +3541 4143 +3541 5309 +3541 7743 +3541 7904 +3541 5317 +3541 6215 +3541 5451 +3541 4558 +3541 3807 +3541 9056 +3541 8804 +3542 5632 +3542 7330 +3542 5859 +3542 8388 +3542 9317 +3542 4266 +3542 4780 +3542 5742 +3542 5903 +3542 3985 +3542 7376 +3542 6564 +3542 8350 +3542 5509 +3543 6861 +3543 4131 +3543 7558 +3543 9351 +3543 4750 +3543 5389 +3543 4642 +3543 5239 +3543 6297 +3543 7930 +3543 3549 +3544 8990 +3544 4155 +3544 5060 +3544 9061 +3544 5990 +3544 8775 +3544 6311 +3544 4812 +3544 5782 +3544 9839 +3544 6110 +3544 9910 +3544 3607 +3544 7672 +3544 3578 +3544 4603 +3544 8828 +3544 6942 +3544 4437 +3545 3968 +3545 7392 +3545 5027 +3545 9510 +3545 4925 +3545 6009 +3545 4879 +3546 4161 +3546 5274 +3546 9412 +3546 8517 +3546 9650 +3546 5006 +3546 6896 +3546 9425 +3546 3699 +3546 9588 +3546 6582 +3546 4984 +3546 3674 +3547 6176 +3547 4496 +3547 9315 +3547 6917 +3547 9304 +3547 6138 +3547 7487 +3547 6108 +3547 7037 +3547 3551 +3548 8480 +3548 6978 +3548 4283 +3548 7690 +3548 9771 +3548 4206 +3548 6673 +3548 7545 +3548 7897 +3548 4991 +3549 6787 +3549 7047 +3549 4361 +3549 7956 +3549 8475 +3549 4640 +3549 8618 +3549 8120 +3549 5689 +3549 4154 +3549 6851 +3549 9558 +3549 9048 +3549 7646 +3549 7519 +3549 5219 +3549 8180 +3550 7493 +3550 4358 +3550 8877 +3550 9395 +3550 6906 +3550 8862 +3550 7893 +3551 8968 +3551 4106 +3551 4246 +3551 9245 +3551 5031 +3551 3869 +3551 4037 +3551 5703 +3551 6733 +3551 5082 +3551 6767 +3551 8307 +3552 6660 +3552 5638 +3552 3851 +3552 7701 +3552 8732 +3552 8112 +3552 6321 +3552 5429 +3552 5070 +3552 5841 +3552 3557 +3552 7410 +3552 3830 +3552 8823 +3552 4729 +3552 5757 +3552 9214 +3553 8832 +3553 4355 +3553 5703 +3553 7857 +3553 5330 +3553 9939 +3553 6974 +3554 5761 +3554 5771 +3554 6414 +3554 9617 +3554 3872 +3554 6562 +3554 5801 +3554 9770 +3554 6190 +3554 7605 +3554 5174 +3554 9534 +3554 7435 +3554 4168 +3554 9059 +3554 8553 +3554 3562 +3554 8441 +3555 7109 +3555 3916 +3555 9962 +3555 6380 +3555 8461 +3555 7439 +3555 8507 +3555 8735 +3556 8224 +3556 7808 +3556 9826 +3556 4035 +3556 9861 +3556 7038 +3556 8168 +3556 7147 +3556 8332 +3556 4334 +3556 9136 +3556 9202 +3556 7317 +3556 6713 +3556 8699 +3556 7773 +3556 5822 +3556 6949 +3557 7681 +3557 6915 +3557 7191 +3557 6051 +3557 5309 +3557 7359 +3557 8786 +3557 5847 +3557 9955 +3557 7788 +3557 6766 +3557 6519 +3558 8801 +3558 5123 +3558 8301 +3558 8365 +3558 8467 +3558 9397 +3558 6523 +3559 9056 +3559 7553 +3559 6211 +3559 9572 +3559 7240 +3559 5739 +3559 4589 +3559 4206 +3559 8143 +3559 6994 +3559 3835 +3560 5290 +3560 9099 +3560 6829 +3560 3662 +3560 7734 +3560 8088 +3560 7390 +3561 8594 +3561 3719 +3561 6575 +3561 9269 +3561 6585 +3561 7487 +3561 3657 +3561 6474 +3561 4562 +3561 4444 +3561 5213 +3561 8297 +3561 4331 +3561 8686 +3561 4340 +3562 6721 +3562 6823 +3562 9672 +3562 8073 +3562 8236 +3562 8045 +3562 4304 +3562 8824 +3562 7054 +3562 7822 +3563 7243 +3563 9881 +3563 6491 +3563 9660 +3564 6230 +3564 6815 +3564 6086 +3564 4007 +3564 7336 +3564 6327 +3564 7614 +3564 9924 +3564 7500 +3564 4946 +3564 3924 +3564 6233 +3564 6375 +3564 9578 +3564 3827 +3564 4863 +3565 8004 +3565 4516 +3565 5162 +3565 9772 +3565 5037 +3565 8671 +3565 6724 +3565 3654 +3565 8930 +3565 3598 +3565 5207 +3565 9567 +3565 7138 +3565 9954 +3565 7525 +3565 5350 +3565 4843 +3565 7916 +3565 4846 +3565 4991 +3566 4048 +3566 5603 +3566 9932 +3566 7525 +3566 7111 +3566 5036 +3566 4266 +3566 8815 +3566 6672 +3566 4979 +3566 6741 +3566 3958 +3566 4919 +3566 7450 +3566 9916 +3566 8735 +3567 4960 +3567 4192 +3567 3940 +3567 6661 +3567 4907 +3567 9258 +3567 7083 +3567 7853 +3567 9200 +3567 4471 +3567 7189 +3567 5975 +3567 7064 +3567 5579 +3567 7101 +3567 7902 +3568 9474 +3568 4756 +3568 6682 +3568 4396 +3568 7341 +3568 7215 +3568 5070 +3568 6610 +3568 8142 +3568 5340 +3568 6497 +3568 5625 +3568 7420 +3568 8959 +3569 5659 +3569 5232 +3569 9475 +3569 3781 +3569 8231 +3569 7880 +3569 4970 +3569 6192 +3569 4401 +3569 5399 +3569 7261 +3569 9279 +3570 5003 +3570 8211 +3570 9773 +3570 3760 +3570 8761 +3570 3772 +3570 6719 +3570 5970 +3570 5774 +3570 4441 +3570 9571 +3570 7677 +3570 5183 +3571 8544 +3571 9985 +3571 3715 +3571 6148 +3571 4806 +3571 8617 +3571 6224 +3571 4305 +3571 9300 +3571 6716 +3571 4860 +3572 5536 +3572 6912 +3572 4036 +3572 5957 +3572 9190 +3572 8519 +3572 7624 +3572 9037 +3572 3840 +3572 3826 +3572 3739 +3572 7710 +3572 7090 +3573 6689 +3573 5954 +3573 8644 +3573 9313 +3573 8872 +3573 3915 +3573 8973 +3573 6952 +3573 9716 +3573 4661 +3573 3991 +3573 9483 +3573 5956 +3573 3695 +3573 9383 +3573 5919 +3574 8330 +3574 7819 +3574 9709 +3574 8394 +3574 6986 +3574 9044 +3574 6117 +3574 4972 +3574 5870 +3574 8699 +3574 9981 +3575 4994 +3575 8715 +3575 7317 +3575 4128 +3575 9134 +3575 9396 +3575 7349 +3575 9660 +3575 7093 +3575 9031 +3575 6862 +3575 6746 +3575 5599 +3575 5755 +3575 5685 +3575 5107 +3575 9727 +3576 5891 +3576 9738 +3576 8462 +3576 8356 +3576 4645 +3576 3752 +3576 5041 +3576 9017 +3576 5946 +3576 4156 +3576 9541 +3576 8021 +3576 9942 +3576 6105 +3576 8763 +3576 5998 +3576 9969 +3577 5412 +3577 9189 +3577 8368 +3577 4660 +3577 5369 +3577 3675 +3577 8956 +3578 4050 +3578 8866 +3578 9507 +3578 9746 +3578 5349 +3578 6758 +3578 3752 +3578 6217 +3578 5130 +3578 9069 +3578 4782 +3578 7243 +3578 8331 +3578 7479 +3578 5882 +3578 3901 +3578 4389 +3578 8069 +3579 7072 +3579 4673 +3579 6276 +3579 3749 +3579 8715 +3579 5172 +3579 4376 +3579 4603 +3579 4349 +3579 7423 +3580 6838 +3580 9830 +3580 7985 +3580 9672 +3580 5705 +3580 4458 +3580 8781 +3580 7825 +3580 8786 +3580 3894 +3580 6073 +3580 3612 +3580 3645 +3581 5889 +3581 9284 +3581 9127 +3581 9118 +3581 6903 +3581 8445 +3581 8158 +3582 6757 +3582 8262 +3582 9480 +3582 6985 +3582 6508 +3582 7581 +3582 7952 +3582 5081 +3582 5875 +3582 4501 +3582 6519 +3582 4217 +3582 7226 +3583 7965 +3583 7409 +3583 5421 +3583 3763 +3583 7479 +3583 5946 +3583 5055 +3583 6988 +3583 7888 +3583 8794 +3583 6235 +3583 9572 +3583 5612 +3583 6510 +3583 7153 +3583 4348 +3584 9632 +3584 9968 +3584 5169 +3584 6667 +3584 5394 +3584 5808 +3584 8753 +3584 9010 +3584 8310 +3584 3648 +3584 5759 +3585 5902 +3585 5660 +3585 9139 +3585 5173 +3585 7097 +3585 4313 +3585 4341 +3585 5753 +3585 3708 +3586 5408 +3586 7681 +3586 5284 +3586 3717 +3586 9990 +3586 3724 +3586 7408 +3586 4373 +3586 6105 +3586 6106 +3587 8323 +3587 6662 +3587 6670 +3587 4625 +3587 3604 +3587 3611 +3587 6303 +3587 7605 +3587 5942 +3587 6969 +3587 9675 +3587 7502 +3587 4948 +3587 4494 +3587 4709 +3587 5611 +3587 6779 +3588 4034 +3588 5379 +3588 9668 +3588 6886 +3588 6502 +3588 4807 +3588 7404 +3588 5369 +3588 9839 +3588 3793 +3588 7000 +3588 8281 +3588 3898 +3589 9094 +3589 4885 +3589 6039 +3589 4648 +3589 8491 +3589 5684 +3589 6968 +3589 5691 +3589 6460 +3589 7470 +3589 4828 +3589 3679 +3589 9440 +3589 7141 +3589 7825 +3589 7803 +3590 9124 +3590 3847 +3590 6632 +3590 4696 +3590 4731 +3590 6397 +3591 7489 +3591 4450 +3591 4689 +3591 3944 +3591 9996 +3591 5645 +3591 6416 +3591 9848 +3591 6866 +3591 6579 +3591 8789 +3591 6440 +3591 5688 +3591 3763 +3591 6395 +3591 5436 +3592 6115 +3592 8004 +3592 4358 +3592 6054 +3592 7654 +3592 7116 +3592 5362 +3592 9775 +3592 7890 +3592 7485 +3592 4313 +3592 4527 +3592 9469 +3592 9268 +3593 9803 +3593 9487 +3593 6641 +3593 7094 +3593 9880 +3593 5980 +3593 8442 +3593 7966 +3594 7122 +3594 5154 +3594 5638 +3594 5094 +3594 3815 +3594 5768 +3594 4009 +3594 8365 +3594 9104 +3594 9832 +3594 7794 +3594 6186 +3594 5460 +3594 7735 +3594 7318 +3594 9913 +3594 6428 +3594 3946 +3595 3803 +3595 5252 +3595 5351 +3595 8604 +3595 6771 +3595 4316 +3595 6809 +3595 3919 +3595 7123 +3596 3720 +3596 7837 +3596 5806 +3596 5833 +3596 8890 +3596 7497 +3597 7552 +3597 4997 +3597 6120 +3597 7970 +3597 6160 +3597 4753 +3597 7666 +3597 4640 +3597 8814 +3597 9240 +3597 3961 +3598 4032 +3598 9574 +3598 8902 +3598 9705 +3598 6542 +3598 4625 +3598 4370 +3598 5560 +3598 9147 +3598 9126 +3598 9125 +3599 9792 +3599 8034 +3599 5892 +3599 4490 +3599 9581 +3599 3696 +3599 7348 +3599 7961 +3599 5306 +3599 6395 +3599 3804 +3600 6532 +3600 6983 +3600 5623 +3600 5967 +3600 6294 +3600 6617 +3600 6782 +3600 5087 +3601 7182 +3601 4495 +3601 6934 +3601 5031 +3601 9390 +3601 8386 +3601 5571 +3601 9703 +3601 3661 +3601 4695 +3601 8411 +3601 9575 +3601 7335 +3602 9860 +3602 4495 +3602 6178 +3602 6385 +3602 8365 +3602 7986 +3602 4792 +3602 5177 +3602 7237 +3602 6615 +3602 9944 +3602 8412 +3602 3680 +3602 4196 +3602 3942 +3602 8103 +3602 4337 +3603 8779 +3603 8747 +3603 6390 +3603 5773 +3603 6702 +3603 3853 +3603 8295 +3603 8660 +3603 7830 +3603 4540 +3604 7137 +3604 6147 +3604 6212 +3604 5861 +3604 4582 +3604 6497 +3604 5201 +3604 8579 +3604 6356 +3604 5497 +3604 6043 +3604 9383 +3604 6494 +3605 4352 +3605 6157 +3605 4110 +3605 9906 +3605 5528 +3605 6821 +3605 6443 +3605 4653 +3605 5938 +3605 8884 +3605 7861 +3605 7353 +3605 7098 +3605 4677 +3605 8006 +3605 8160 +3605 9196 +3605 8566 +3605 5115 +3606 9473 +3606 7432 +3606 5261 +3606 6160 +3606 8338 +3606 7315 +3606 7332 +3606 7336 +3606 7724 +3606 6455 +3606 8383 +3606 5473 +3606 7146 +3606 6802 +3607 5505 +3607 7132 +3607 4262 +3607 9033 +3607 9197 +3607 8838 +3607 5652 +3607 5465 +3607 5626 +3607 8954 +3607 4965 +3608 9814 +3608 5639 +3608 4889 +3608 6941 +3608 7328 +3608 4438 +3608 5817 +3608 9148 +3608 3906 +3608 8395 +3608 6229 +3608 6614 +3608 6360 +3608 5372 +3609 9538 +3609 4902 +3609 8299 +3609 5356 +3609 6472 +3609 4317 +3609 3611 +3609 8381 +3609 6143 +3610 7396 +3610 6405 +3610 4838 +3610 8426 +3610 9990 +3610 6174 +3610 9495 +3610 8349 +3610 4798 +3611 3845 +3611 9609 +3611 9495 +3611 4507 +3611 9117 +3611 4139 +3611 4408 +3611 8641 +3611 5573 +3611 8405 +3611 6907 +3611 5757 +3612 7425 +3612 4610 +3612 5645 +3612 5653 +3612 5798 +3612 9133 +3612 3714 +3612 8003 +3612 9029 +3612 8152 +3612 4701 +3612 4831 +3612 7525 +3612 7793 +3612 6264 +3613 7328 +3613 8996 +3613 6149 +3613 7943 +3613 7692 +3613 9519 +3613 6384 +3613 7827 +3613 5560 +3613 8570 +3613 8638 +3614 5633 +3614 5775 +3614 8850 +3614 3988 +3614 8220 +3614 7078 +3614 7597 +3614 8750 +3614 7537 +3614 9399 +3614 5698 +3614 4814 +3614 6617 +3614 7259 +3614 6620 +3614 9314 +3614 3750 +3614 4460 +3614 4849 +3614 8056 +3615 9248 +3615 3841 +3615 9314 +3615 3851 +3615 5572 +3615 7173 +3615 4874 +3615 6982 +3615 5624 +3615 8633 +3615 5754 +3615 3804 +3615 9214 +3616 5601 +3616 7235 +3616 5604 +3616 9382 +3616 5610 +3616 5867 +3616 6928 +3616 6064 +3616 6617 +3616 4061 +3617 6817 +3617 5282 +3617 4009 +3617 8971 +3617 9870 +3617 7890 +3617 5171 +3617 4308 +3617 5141 +3617 9303 +3617 8313 +3617 8540 +3617 7165 +3617 4149 +3618 4736 +3618 7175 +3618 8712 +3618 6545 +3618 9940 +3618 7063 +3618 4385 +3618 4657 +3618 4406 +3618 9913 +3618 6353 +3618 5458 +3618 7635 +3618 9428 +3618 6748 +3618 3806 +3618 5358 +3619 6532 +3619 6918 +3619 6824 +3619 4652 +3619 5518 +3619 7506 +3619 5784 +3619 7629 +3619 8892 +3620 8833 +3620 9858 +3620 7429 +3620 4510 +3620 3630 +3620 5167 +3620 7838 +3620 6601 +3620 4282 +3620 7357 +3620 7998 +3620 7496 +3620 4049 +3620 8919 +3620 4827 +3620 9308 +3620 5085 +3620 5457 +3620 9706 +3621 4106 +3621 6670 +3621 9882 +3621 9372 +3621 7847 +3621 4649 +3621 4658 +3621 3641 +3621 8032 +3621 9666 +3621 4680 +3621 9163 +3621 8156 +3621 6225 +3621 4335 +3622 5764 +3622 6411 +3622 7182 +3622 7325 +3622 5147 +3622 8757 +3622 7105 +3622 4939 +3622 9579 +3622 3823 +3622 8817 +3622 9847 +3622 4728 +3623 4481 +3623 4898 +3623 7382 +3623 7948 +3623 8001 +3623 3820 +3623 3818 +3623 9772 +3623 6210 +3623 3837 +3623 9104 +3623 4661 +3623 5494 +3623 3831 +3623 4664 +3623 5423 +3623 9436 +3623 8605 +3624 5131 +3624 8847 +3624 7828 +3624 4385 +3624 4514 +3624 4010 +3624 3755 +3624 7353 +3624 4925 +3624 9419 +3624 4567 +3624 7530 +3624 7338 +3625 5508 +3625 8070 +3625 5017 +3625 6938 +3625 3997 +3625 6430 +3625 8735 +3625 3879 +3625 7470 +3625 9519 +3625 5173 +3625 4155 +3625 5705 +3625 9802 +3625 7896 +3625 7786 +3625 5109 +3625 8182 +3625 5884 +3625 8573 +3626 5121 +3626 8972 +3626 6798 +3626 9748 +3626 7190 +3626 7208 +3626 3885 +3626 6065 +3626 4019 +3626 9013 +3626 6973 +3626 7241 +3626 8150 +3626 9688 +3626 3680 +3626 6891 +3626 5626 +3626 8701 +3627 8072 +3627 5199 +3627 7470 +3627 5391 +3627 7764 +3627 7570 +3627 7956 +3627 8494 +3627 4054 +3627 5844 +3627 6107 +3628 4230 +3628 6550 +3628 6553 +3628 8509 +3628 6225 +3628 6051 +3628 5726 +3628 5985 +3628 3939 +3628 8305 +3628 8053 +3628 9084 +3628 7549 +3629 8076 +3629 8334 +3629 9245 +3629 5665 +3629 4394 +3629 9923 +3629 9797 +3629 9670 +3629 9302 +3629 5609 +3629 9338 +3629 8319 +3629 9983 +3630 6721 +3630 8228 +3630 3953 +3630 8886 +3630 4439 +3630 4152 +3630 9210 +3630 6588 +3631 8002 +3631 4868 +3631 7076 +3631 5672 +3631 6705 +3631 7474 +3631 4794 +3631 7357 +3631 7232 +3631 9410 +3631 6599 +3631 5069 +3631 4964 +3631 5482 +3631 8941 +3631 7929 +3632 8673 +3632 3843 +3632 9724 +3632 4968 +3632 4989 +3632 7024 +3632 4430 +3632 7413 +3632 4697 +3632 3931 +3632 7837 +3632 6376 +3633 3776 +3633 9665 +3633 9763 +3633 9575 +3633 5640 +3633 8746 +3633 6567 +3633 7981 +3633 4277 +3633 8427 +3633 9885 +3634 4517 +3634 7335 +3634 4456 +3634 6409 +3634 4717 +3634 5679 +3634 7376 +3634 6739 +3634 3958 +3634 6135 +3634 9139 +3634 8479 +3635 9990 +3635 3654 +3635 7912 +3635 3884 +3635 5962 +3635 6347 +3635 4844 +3635 9006 +3635 8967 +3635 5969 +3635 4434 +3635 8153 +3635 7500 +3635 7364 +3635 8831 +3636 4369 +3636 5782 +3636 6295 +3636 9251 +3636 6310 +3636 7116 +3636 5842 +3636 5334 +3636 7129 +3636 6627 +3636 7660 +3636 9839 +3636 7165 +3636 8191 +3637 8619 +3637 7431 +3637 7454 +3637 7717 +3637 5929 +3637 8747 +3637 5684 +3637 6204 +3637 5566 +3637 9670 +3637 6995 +3637 6868 +3637 9567 +3637 6243 +3637 9193 +3637 8685 +3637 8688 +3637 7541 +3637 8055 +3638 4999 +3638 7058 +3638 5660 +3638 9506 +3638 7716 +3638 7717 +3638 6182 +3638 7855 +3638 9524 +3638 7093 +3638 5432 +3638 7502 +3638 6095 +3638 6227 +3638 8405 +3638 8278 +3638 9439 +3638 4334 +3638 4979 +3638 4855 +3639 6176 +3639 9600 +3639 5865 +3639 4877 +3639 5582 +3639 4369 +3639 3858 +3639 6999 +3639 4859 +3639 4799 +3640 5511 +3640 9224 +3640 8855 +3640 9496 +3640 8603 +3640 8867 +3640 8485 +3640 4390 +3640 4913 +3640 7866 +3640 9239 +3640 5572 +3640 6608 +3640 8529 +3640 5459 +3640 9816 +3640 6237 +3640 5473 +3640 7152 +3641 9532 +3641 4843 +3641 7759 +3641 9840 +3641 4659 +3641 9236 +3641 4201 +3641 6840 +3641 7291 +3641 4700 +3641 7357 +3642 4994 +3642 4102 +3642 8332 +3642 6161 +3642 8724 +3642 4133 +3642 5575 +3642 3917 +3642 8015 +3642 9437 +3642 4578 +3642 6372 +3642 9198 +3642 9462 +3642 4472 +3642 5372 +3643 4834 +3643 7557 +3643 7622 +3643 6343 +3643 4943 +3643 6553 +3643 4026 +3643 4155 +3643 7805 +3644 8987 +3644 7062 +3644 4076 +3644 9002 +3644 4524 +3644 9179 +3644 5725 +3644 3734 +3644 9051 +3644 4605 +3645 4614 +3645 4365 +3645 8852 +3645 7208 +3645 4142 +3645 7216 +3645 4663 +3645 6979 +3645 8119 +3645 9039 +3645 7889 +3645 5464 +3645 9305 +3645 7976 +3646 4231 +3646 7210 +3646 9002 +3646 5420 +3646 8624 +3646 5267 +3646 7412 +3646 4823 +3647 8068 +3647 4749 +3647 4494 +3647 8595 +3647 9622 +3647 8882 +3647 3895 +3647 7480 +3647 9020 +3647 5054 +3647 6219 +3647 7372 +3647 7905 +3648 6016 +3648 7176 +3648 7054 +3648 4377 +3648 9255 +3648 5548 +3648 8111 +3648 8113 +3648 7479 +3648 7480 +3648 4162 +3648 5187 +3648 4825 +3648 7657 +3648 9767 +3648 4092 +3649 7937 +3649 7044 +3649 4961 +3649 4938 +3649 6123 +3649 4844 +3649 5071 +3649 4784 +3649 4865 +3649 8515 +3649 6708 +3649 7318 +3649 5883 +3649 7024 +3650 8272 +3650 8707 +3650 7144 +3650 9047 +3650 9743 +3650 8240 +3650 7619 +3650 5077 +3650 8950 +3650 5407 +3651 6355 +3651 4264 +3651 4393 +3651 7338 +3651 9708 +3651 9583 +3651 5076 +3651 7606 +3651 5754 +3651 8367 +3651 4508 +3652 6914 +3652 7522 +3652 6383 +3652 6760 +3652 3954 +3652 6676 +3652 5566 +3652 8567 +3652 9918 +3653 6020 +3653 6536 +3653 3947 +3653 9420 +3653 9166 +3653 7696 +3653 7987 +3653 7636 +3653 8566 +3653 6360 +3653 6940 +3654 9411 +3654 6758 +3654 5363 +3654 7028 +3654 4629 +3654 4502 +3654 5881 +3654 6047 +3654 7452 +3654 4446 +3654 9087 +3655 8215 +3655 9889 +3655 4647 +3655 5936 +3655 6846 +3655 5543 +3655 4176 +3655 4053 +3655 4065 +3655 5989 +3655 6504 +3655 5995 +3655 7792 +3655 6385 +3655 8766 +3656 4113 +3656 5852 +3656 9479 +3656 8205 +3656 7847 +3656 6575 +3656 5169 +3656 6418 +3656 7603 +3656 4022 +3656 5592 +3656 4284 +3656 5438 +3657 6659 +3657 7885 +3657 4018 +3657 4914 +3658 9696 +3658 6958 +3658 6565 +3658 9928 +3658 6892 +3658 4683 +3658 7628 +3658 6286 +3658 5298 +3659 4102 +3659 4801 +3659 5655 +3659 6809 +3659 5543 +3659 7303 +3659 4673 +3659 7112 +3659 4172 +3659 6095 +3659 4310 +3659 7262 +3659 7905 +3659 7804 +3659 7293 +3659 3967 +3660 4193 +3660 6499 +3660 7940 +3660 7879 +3660 6665 +3660 7818 +3660 9879 +3660 9473 +3660 6318 +3660 6736 +3660 8062 +3660 5055 +3661 6369 +3661 4488 +3661 8970 +3661 7403 +3661 4052 +3661 3867 +3661 9055 +3662 8768 +3662 7905 +3662 3749 +3662 5777 +3662 7383 +3662 9656 +3662 4699 +3662 7998 +3662 6661 +3663 4929 +3663 6658 +3663 5859 +3663 6501 +3663 8648 +3663 5596 +3663 3701 +3663 6906 +3663 7004 +3664 4128 +3664 5893 +3664 8902 +3664 3708 +3664 7757 +3664 4489 +3664 7001 +3664 5083 +3665 4787 +3665 4768 +3665 4139 +3665 9261 +3665 5043 +3665 5057 +3665 3783 +3665 4565 +3665 8666 +3665 6491 +3665 6623 +3665 8160 +3665 5350 +3665 4464 +3665 9597 +3666 8896 +3666 5441 +3666 5125 +3666 6696 +3666 7278 +3666 8881 +3666 4946 +3666 8757 +3666 8121 +3666 8187 +3666 9885 +3666 7198 +3666 4799 +3667 5281 +3667 4386 +3667 6531 +3667 5030 +3667 3705 +3667 9229 +3667 6127 +3667 5200 +3667 5682 +3667 4663 +3667 6541 +3667 6873 +3667 9882 +3667 4315 +3668 9218 +3668 5643 +3668 8101 +3668 7346 +3668 6574 +3668 3890 +3668 5566 +3668 8903 +3668 8522 +3668 8400 +3668 6879 +3668 4706 +3668 4579 +3668 8806 +3668 4713 +3668 4589 +3669 5392 +3669 3999 +3669 6432 +3669 8483 +3669 8881 +3669 4666 +3669 7509 +3669 7257 +3669 6108 +3669 6880 +3669 5219 +3669 9321 +3669 7919 +3670 9600 +3670 6657 +3670 6787 +3670 5252 +3670 4362 +3670 5549 +3670 5934 +3670 5295 +3670 6324 +3670 5580 +3670 6098 +3670 4568 +3670 3684 +3670 6127 +3670 8697 +3671 9608 +3671 9866 +3671 7307 +3671 4889 +3671 8738 +3671 8488 +3671 8879 +3671 9275 +3671 9922 +3671 6083 +3671 5582 +3671 7153 +3672 7075 +3672 7050 +3672 4015 +3672 5908 +3672 5687 +3672 9304 +3672 6137 +3672 7194 +3672 4735 +3673 5636 +3673 5782 +3673 8615 +3673 4795 +3673 7238 +3673 5204 +3673 3929 +3673 7483 +3673 9193 +3673 7786 +3673 7660 +3673 4465 +3673 4970 +3673 5374 +3673 8575 +3674 4555 +3674 5527 +3674 3953 +3674 5660 +3674 7690 +3674 8235 +3674 5165 +3674 3823 +3674 7729 +3674 8367 +3674 5321 +3674 9145 +3674 5852 +3674 9343 +3675 3872 +3675 7371 +3675 5892 +3675 5831 +3675 7851 +3675 7308 +3675 6445 +3675 4206 +3675 3797 +3675 7126 +3675 7175 +3675 8826 +3675 6751 +3675 6619 +3675 6526 +3675 9151 +3676 6276 +3676 6413 +3676 8723 +3676 6809 +3676 9092 +3676 5659 +3676 7327 +3676 5924 +3676 4658 +3676 8507 +3676 9279 +3676 4803 +3676 4814 +3676 3810 +3676 9705 +3676 8938 +3676 6257 +3676 4083 +3676 4217 +3677 8738 +3677 9187 +3677 8470 +3677 9415 +3677 4523 +3677 7533 +3677 9295 +3677 9680 +3677 5459 +3677 7957 +3677 8406 +3678 9367 +3678 3993 +3678 6384 +3678 5541 +3678 6571 +3678 5185 +3678 8520 +3678 8650 +3678 4943 +3678 9043 +3678 9948 +3678 5984 +3678 7152 +3679 6761 +3679 9261 +3679 6589 +3679 6961 +3679 9043 +3679 9854 +3679 9434 +3679 6364 +3680 4738 +3680 5219 +3680 4518 +3680 9649 +3680 3709 +3680 6416 +3680 3926 +3680 7612 +3680 8010 +3680 8511 +3681 5259 +3681 6679 +3681 8216 +3681 8871 +3681 6451 +3681 6964 +3681 4034 +3681 9670 +3681 4040 +3681 5082 +3681 5399 +3681 5352 +3681 8297 +3682 6129 +3682 5637 +3682 4102 +3682 7785 +3682 4619 +3682 6764 +3682 8122 +3682 8209 +3682 7603 +3682 5302 +3682 9433 +3682 8249 +3682 4838 +3683 5185 +3683 8804 +3683 7497 +3683 5514 +3683 8459 +3683 9485 +3683 5614 +3683 3757 +3683 5648 +3683 8184 +3683 5011 +3683 9269 +3683 6763 +3683 5239 +3683 5647 +3683 8570 +3683 9180 +3683 4351 +3684 6280 +3684 3724 +3684 5142 +3684 9888 +3684 8483 +3684 5540 +3684 8748 +3684 9909 +3684 5814 +3684 6100 +3684 9944 +3684 5340 +3684 4447 +3684 5739 +3684 4975 +3685 7690 +3685 6285 +3685 7182 +3685 6166 +3685 4248 +3685 4271 +3685 7072 +3685 5537 +3685 8226 +3685 4827 +3685 3751 +3685 7855 +3685 7859 +3685 4798 +3685 9910 +3685 5960 +3685 3798 +3685 8697 +3685 4901 +3685 7783 +3685 4458 +3685 7663 +3685 9588 +3685 5623 +3685 6905 +3685 6394 +3686 8432 +3686 9059 +3686 8420 +3686 5425 +3686 7075 +3686 6745 +3686 8795 +3686 8316 +3686 8634 +3687 5237 +3687 7587 +3687 9287 +3687 7346 +3687 5773 +3687 9648 +3687 9973 +3687 3893 +3687 5465 +3687 8185 +3687 9967 +3687 5429 +3688 3852 +3688 8849 +3688 4883 +3688 3992 +3688 4378 +3688 4540 +3688 5163 +3688 6063 +3688 7091 +3688 4796 +3688 5181 +3688 6731 +3688 6995 +3688 9692 +3688 8040 +3688 8508 +3688 6382 +3688 9461 +3689 3742 +3689 8738 +3689 8743 +3689 4392 +3689 5550 +3689 6070 +3689 4285 +3689 8383 +3689 4194 +3689 7762 +3689 5079 +3689 9304 +3689 7010 +3689 4452 +3689 4841 +3689 8441 +3689 5116 +3690 3808 +3690 5315 +3690 4178 +3690 7049 +3690 6698 +3690 8524 +3690 7021 +3690 8333 +3690 9521 +3690 9653 +3690 9303 +3690 4152 +3690 6553 +3691 3947 +3691 7831 +3691 5405 +3691 3764 +3691 8376 +3691 5945 +3691 6458 +3691 7749 +3691 9037 +3691 6605 +3691 6101 +3691 5466 +3691 6752 +3691 7403 +3692 6499 +3692 7812 +3692 4988 +3692 6524 +3692 5100 +3692 9613 +3692 7183 +3692 4530 +3692 8021 +3692 8343 +3692 5659 +3692 5788 +3692 4246 +3692 6975 +3693 9332 +3693 8881 +3693 5930 +3693 5039 +3693 7314 +3693 5711 +3693 8923 +3693 5214 +3694 6305 +3694 5666 +3694 8038 +3694 6124 +3694 3824 +3694 9811 +3694 8600 +3694 8346 +3694 9309 +3695 9137 +3695 3913 +3695 4046 +3695 4144 +3695 6024 +3695 6322 +3695 6937 +3695 4348 +3695 6714 +3696 8194 +3696 4756 +3696 9371 +3696 5552 +3696 9906 +3696 5302 +3696 9657 +3696 6077 +3696 5310 +3696 3912 +3696 4570 +3696 5851 +3696 4317 +3696 8672 +3696 4328 +3696 9554 +3696 6255 +3696 8445 +3697 9347 +3697 4424 +3697 9353 +3697 6636 +3697 9551 +3697 7121 +3697 6548 +3697 9272 +3697 7032 +3697 9994 +3697 7498 +3698 9248 +3698 7969 +3698 6950 +3698 5991 +3698 8110 +3698 5073 +3698 8818 +3698 8819 +3698 8462 +3699 4936 +3699 9692 +3699 7306 +3699 5181 +3699 4472 +3699 9667 +3699 6750 +3699 5240 +3699 7727 +3699 8955 +3699 4540 +3699 4255 +3700 3977 +3700 4874 +3700 5274 +3700 7195 +3700 4267 +3700 7343 +3700 8513 +3700 7619 +3700 8390 +3700 4434 +3700 6103 +3700 8416 +3700 9185 +3700 4071 +3700 5234 +3700 7796 +3700 6901 +3700 7415 +3700 7035 +3700 7548 +3701 4165 +3701 4269 +3701 7184 +3701 9096 +3701 6165 +3701 6358 +3701 7833 +3702 6401 +3702 5250 +3702 8967 +3702 6475 +3702 7214 +3702 4307 +3702 5334 +3702 4951 +3702 4834 +3702 5466 +3702 7726 +3703 4962 +3703 5095 +3703 3916 +3703 9452 +3703 9340 +3703 4626 +3703 3941 +3703 8428 +3703 5892 +3703 5847 +3703 6372 +3703 6492 +3703 7685 +3704 6190 +3704 8993 +3704 9771 +3704 5563 +3704 4543 +3704 9431 +3704 4569 +3704 5341 +3704 4447 +3704 5439 +3705 5918 +3705 6687 +3705 8865 +3705 7459 +3705 8484 +3705 4527 +3705 6119 +3705 9148 +3705 3776 +3705 9935 +3705 5718 +3705 4055 +3705 3929 +3705 3802 +3705 7261 +3705 4065 +3706 9313 +3706 9699 +3706 4740 +3706 4814 +3706 8999 +3706 8617 +3706 6894 +3706 3888 +3706 5206 +3706 4219 +3706 8572 +3706 4718 +3707 4960 +3707 4609 +3707 6827 +3707 9222 +3707 5638 +3707 7687 +3707 9491 +3707 3787 +3707 5613 +3707 3923 +3707 3924 +3707 6357 +3707 6685 +3708 3936 +3708 6885 +3708 7718 +3708 6855 +3708 5820 +3708 8051 +3708 7861 +3708 9532 +3709 9601 +3709 7426 +3709 8323 +3709 5383 +3709 5390 +3709 8723 +3709 9370 +3709 4254 +3709 5029 +3709 3881 +3709 7094 +3709 5305 +3709 9417 +3709 8274 +3709 5077 +3709 6231 +3709 6754 +3709 6883 +3709 6119 +3709 6866 +3710 8994 +3710 4259 +3710 8654 +3710 7056 +3710 6519 +3710 5981 +3710 4165 +3710 6181 +3711 8897 +3711 6150 +3711 6790 +3711 7121 +3711 5034 +3711 4359 +3711 5772 +3711 7117 +3711 4433 +3711 6193 +3711 5396 +3711 7862 +3711 6682 +3711 8446 +3711 6879 +3712 5601 +3712 4130 +3712 7851 +3712 6980 +3712 8011 +3712 5229 +3712 9168 +3712 4625 +3712 9779 +3712 5014 +3712 5783 +3712 6116 +3712 5978 +3712 4063 +3713 7264 +3713 8632 +3713 4936 +3713 6709 +3713 4488 +3713 9075 +3713 4894 +3713 4118 +3713 7416 +3713 5435 +3713 4031 +3714 5314 +3714 4683 +3714 5894 +3714 6727 +3714 5033 +3714 4604 +3714 8879 +3714 4816 +3714 5368 +3714 3753 +3714 8745 +3714 9809 +3714 7709 +3715 5251 +3715 9239 +3715 7962 +3715 6556 +3715 5027 +3715 6181 +3715 7980 +3715 5809 +3715 8254 +3715 9410 +3715 5843 +3715 5853 +3715 5737 +3715 5867 +3715 9836 +3715 5871 +3716 7872 +3716 5252 +3716 9102 +3716 9883 +3716 6303 +3716 6949 +3716 6823 +3716 9391 +3716 6625 +3716 6202 +3716 8128 +3716 5857 +3716 9294 +3716 8399 +3716 8657 +3716 4516 +3716 7098 +3716 5601 +3716 4078 +3716 3832 +3716 8573 +3717 8257 +3717 5635 +3717 9604 +3717 3781 +3717 7976 +3717 8460 +3717 6947 +3717 8662 +3717 5528 +3717 9256 +3718 9984 +3718 9985 +3718 5635 +3718 4872 +3718 6979 +3718 5652 +3718 5187 +3718 4728 +3718 7766 +3718 8279 +3718 4578 +3718 6115 +3718 5359 +3718 5107 +3719 3778 +3719 6121 +3719 8426 +3719 9869 +3719 9656 +3719 8402 +3719 8136 +3719 5525 +3719 9112 +3719 5986 +3720 6272 +3720 6532 +3720 6641 +3720 6477 +3720 7117 +3720 8466 +3720 9889 +3720 9969 +3720 9252 +3720 7802 +3720 4252 +3721 7008 +3721 5606 +3721 6247 +3721 5576 +3721 6476 +3721 5749 +3721 8920 +3721 7284 +3721 9116 +3722 7073 +3722 5577 +3722 5607 +3722 8938 +3722 9319 +3722 8876 +3722 9102 +3722 9551 +3722 7350 +3722 6201 +3722 6010 +3722 5487 +3722 9950 +3723 6240 +3723 7077 +3723 9831 +3723 9546 +3723 4139 +3723 4401 +3723 9529 +3723 9269 +3723 5983 +3724 5067 +3724 5097 +3724 7500 +3724 8691 +3724 9655 +3724 8665 +3724 7772 +3724 7578 +3725 9753 +3725 9701 +3725 8364 +3725 7853 +3725 6281 +3725 7228 +3726 7199 +3726 6561 +3726 8493 +3726 4143 +3726 4151 +3726 6594 +3726 9161 +3726 4938 +3726 6997 +3726 4439 +3726 9688 +3726 4185 +3726 8292 +3726 9317 +3726 7661 +3727 6155 +3727 7824 +3727 3864 +3727 4504 +3727 6002 +3727 6194 +3727 6458 +3727 7613 +3727 7358 +3727 8928 +3727 5443 +3727 7369 +3727 5070 +3727 7887 +3727 4049 +3727 9045 +3727 8919 +3727 8281 +3727 8932 +3727 9838 +3727 6717 +3727 7282 +3728 5762 +3728 5530 +3728 8474 +3728 9765 +3728 4015 +3728 9268 +3728 3908 +3728 5966 +3728 5075 +3728 6616 +3728 8281 +3728 8929 +3728 5346 +3728 5614 +3728 7033 +3729 7055 +3729 9759 +3729 9527 +3729 9660 +3729 7486 +3729 7487 +3729 5581 +3729 7887 +3729 9556 +3729 9050 +3729 8294 +3729 6640 +3729 5105 +3729 4082 +3729 6516 +3729 8126 +3729 5500 +3730 6081 +3730 9508 +3730 3910 +3730 9713 +3730 5801 +3730 4234 +3730 6955 +3730 4780 +3730 5837 +3730 4593 +3730 6770 +3730 4666 +3730 7871 +3731 7300 +3731 8325 +3731 6164 +3731 4763 +3731 7581 +3731 7589 +3731 7484 +3731 8895 +3731 4855 +3731 9167 +3731 9302 +3731 9944 +3731 5086 +3731 6239 +3731 9826 +3731 4967 +3731 9193 +3731 6128 +3731 6775 +3732 4321 +3732 5315 +3732 8452 +3732 8072 +3732 9994 +3732 5687 +3732 9135 +3732 7043 +3732 5014 +3732 5368 +3732 3961 +3732 6280 +3732 8605 +3733 4118 +3733 4314 +3733 7706 +3733 6555 +3733 6938 +3733 5150 +3733 9503 +3733 4263 +3733 9784 +3733 5841 +3733 6106 +3733 5728 +3733 5223 +3734 4422 +3734 3818 +3734 6667 +3734 8024 +3734 5524 +3734 3895 +3734 9340 +3735 6561 +3735 6792 +3735 8809 +3735 4391 +3735 8843 +3735 4783 +3735 3828 +3735 9433 +3735 7743 +3735 8571 +3735 5756 +3735 8122 +3735 7518 +3735 9237 +3736 4897 +3736 7266 +3736 8934 +3736 6664 +3736 9966 +3736 8179 +3736 7772 +3736 4349 +3736 6718 +3737 4101 +3737 9868 +3737 9103 +3737 4378 +3737 6306 +3737 5797 +3737 8487 +3737 5704 +3737 6313 +3737 3758 +3737 4145 +3737 9822 +3737 5567 +3737 9153 +3737 8005 +3737 6854 +3737 5195 +3737 7264 +3737 8550 +3737 7399 +3737 4199 +3737 4845 +3737 9917 +3737 9256 +3738 4836 +3738 4389 +3738 7688 +3738 5577 +3738 7887 +3738 5938 +3738 9299 +3738 7509 +3738 5353 +3738 9156 +3738 9052 +3738 6077 +3739 8065 +3739 6914 +3739 5092 +3739 8677 +3739 8265 +3739 5131 +3739 9356 +3739 9614 +3739 8081 +3739 9779 +3739 3862 +3739 6105 +3739 5982 +3739 9157 +3740 9248 +3740 8816 +3740 6567 +3740 5297 +3740 4941 +3740 9390 +3740 4527 +3740 7792 +3740 8608 +3740 8790 +3740 4856 +3740 7390 +3740 8959 +3741 4385 +3741 4258 +3741 4035 +3741 7908 +3741 7429 +3741 8513 +3741 9384 +3741 8111 +3741 4209 +3741 8372 +3741 8660 +3741 9114 +3741 3808 +3741 7651 +3742 4871 +3742 5913 +3742 9013 +3742 4022 +3742 4030 +3742 6080 +3742 6326 +3742 9418 +3742 6235 +3742 8413 +3742 9952 +3742 7398 +3742 8552 +3742 9066 +3742 6129 +3743 7488 +3743 5796 +3743 9163 +3743 7470 +3743 8110 +3743 3802 +3743 7005 +3744 9361 +3744 9110 +3744 4391 +3744 7207 +3744 4668 +3744 9930 +3744 4173 +3744 4960 +3744 7029 +3745 8096 +3745 8866 +3745 6053 +3745 9767 +3745 3756 +3745 3959 +3745 3837 +3745 7429 +3746 7780 +3746 3942 +3746 5158 +3746 5225 +3746 5611 +3746 8396 +3746 9775 +3746 4656 +3746 8817 +3746 5496 +3746 5882 +3746 4762 +3746 4741 +3747 9730 +3747 9818 +3747 5221 +3747 6823 +3747 6941 +3747 3823 +3747 9717 +3747 7990 +3747 5039 +3747 8029 +3748 8324 +3748 9353 +3748 4427 +3748 6540 +3748 8909 +3748 6830 +3748 5617 +3748 5202 +3748 4405 +3748 7098 +3748 7002 +3748 8735 +3749 6018 +3749 6918 +3749 9992 +3749 8970 +3749 5393 +3749 4499 +3749 6423 +3749 8861 +3749 6946 +3749 5540 +3749 6715 +3749 9020 +3749 4545 +3749 8652 +3749 7766 +3749 7527 +3749 8444 +3749 6256 +3749 9847 +3749 3960 +3749 5116 +3750 3971 +3750 6150 +3750 8842 +3750 7949 +3750 9742 +3750 5523 +3750 8601 +3750 9500 +3750 9757 +3750 9013 +3750 7095 +3750 5453 +3750 9166 +3750 5332 +3750 8818 +3750 5235 +3750 4479 +3751 8451 +3751 4744 +3751 9610 +3751 5371 +3751 6299 +3751 6709 +3751 9531 +3751 7131 +3751 5218 +3751 9596 +3751 8573 +3752 6798 +3752 5664 +3752 7718 +3752 4908 +3752 8878 +3752 9135 +3752 9781 +3752 5053 +3752 3911 +3752 5586 +3752 8930 +3752 8018 +3752 4990 +3753 5251 +3753 7237 +3753 9427 +3753 5964 +3753 6316 +3753 7773 +3753 6736 +3753 7508 +3753 6838 +3753 4285 +3754 5890 +3754 9383 +3754 5224 +3754 6475 +3754 9742 +3754 4925 +3754 9008 +3754 9368 +3754 9242 +3754 8883 +3754 6071 +3754 9625 +3754 9018 +3755 4230 +3755 9346 +3755 5483 +3755 3861 +3755 5462 +3755 9895 +3755 5179 +3755 3772 +3755 5566 +3756 5307 +3756 4712 +3756 9116 +3756 8427 +3756 4749 +3756 4496 +3756 4273 +3756 8434 +3756 9332 +3756 4695 +3756 3903 +3757 9223 +3757 3768 +3757 7098 +3757 5960 +3757 7258 +3757 5083 +3757 7904 +3757 5349 +3757 7661 +3757 4852 +3757 6522 +3758 5216 +3758 5890 +3758 9451 +3758 9318 +3758 8296 +3758 4663 +3758 4941 +3758 8590 +3758 4797 +3758 7888 +3758 5086 +3758 5979 +3758 9597 +3758 8479 +3759 5883 +3759 4036 +3759 4267 +3759 4530 +3759 8496 +3759 6322 +3759 5427 +3759 9620 +3759 3861 +3759 9052 +3759 7285 +3760 4246 +3760 6684 +3760 8350 +3760 7204 +3760 7336 +3760 8362 +3760 7154 +3760 4530 +3760 8760 +3760 5183 +3760 9840 +3760 7778 +3760 8114 +3760 5094 +3760 7912 +3760 7408 +3760 9206 +3761 3844 +3761 5519 +3761 5396 +3761 4759 +3761 5403 +3761 7454 +3761 8621 +3761 3890 +3761 9918 +3761 9426 +3761 7128 +3761 8542 +3761 5729 +3761 6498 +3761 6908 +3761 9837 +3761 6006 +3761 9723 +3761 4988 +3762 6530 +3762 7531 +3762 6535 +3762 7688 +3762 8988 +3762 9127 +3762 9522 +3762 7748 +3762 5320 +3762 6601 +3762 6879 +3762 5091 +3762 7273 +3762 7147 +3762 8338 +3762 6511 +3762 6897 +3762 5492 +3762 3834 +3763 7019 +3763 6252 +3763 9838 +3763 6109 +3763 4784 +3763 8691 +3763 8916 +3763 3865 +3763 7546 +3763 3802 +3764 4610 +3764 4999 +3764 6937 +3764 9377 +3764 8489 +3764 4650 +3764 5548 +3764 9268 +3764 6720 +3764 7617 +3764 8010 +3764 6236 +3764 7784 +3764 4336 +3764 9642 +3764 6399 +3765 8840 +3765 6801 +3765 5507 +3765 5665 +3765 8634 +3765 7363 +3765 4550 +3765 9288 +3765 8524 +3765 6231 +3765 7004 +3765 4325 +3765 9706 +3765 9081 +3766 8256 +3766 8672 +3766 8962 +3766 9702 +3766 7911 +3766 6025 +3766 8011 +3766 9619 +3766 5344 +3766 9683 +3766 8473 +3766 9178 +3766 8444 +3766 9023 +3767 6859 +3767 4452 +3767 5989 +3767 7494 +3767 5020 +3767 7083 +3767 3852 +3767 8081 +3767 8085 +3767 9320 +3767 6684 +3767 3838 +3768 4803 +3768 7334 +3768 6209 +3768 7281 +3768 7123 +3768 4664 +3768 6491 +3768 7962 +3768 5119 +3769 8962 +3769 7173 +3769 6280 +3769 7306 +3769 4365 +3769 6680 +3769 9499 +3769 9122 +3769 4005 +3769 7856 +3769 9971 +3769 7476 +3769 3897 +3769 4032 +3769 4291 +3769 8647 +3769 6219 +3769 7630 +3769 7386 +3769 8805 +3769 7930 +3769 4735 +3770 6530 +3770 8835 +3770 5732 +3770 6950 +3770 4294 +3770 6419 +3770 5193 +3770 6414 +3770 7667 +3770 5222 +3770 5620 +3771 8320 +3771 6914 +3771 5861 +3771 9929 +3771 7243 +3771 4844 +3771 7570 +3771 4624 +3771 6642 +3771 5309 +3771 7774 +3771 9599 +3772 8064 +3772 4737 +3772 5253 +3772 5512 +3772 4516 +3772 7728 +3772 9011 +3772 6461 +3772 7268 +3772 4078 +3773 5474 +3773 7003 +3773 6453 +3773 4774 +3773 9897 +3773 7242 +3773 8285 +3773 6286 +3773 9039 +3773 4497 +3773 7698 +3773 6862 +3773 4982 +3773 5879 +3773 4511 +3773 6300 +3773 4541 +3773 6815 +3774 9732 +3774 8858 +3774 7969 +3774 9780 +3774 6454 +3774 6199 +3774 8651 +3774 7380 +3774 4701 +3774 8034 +3774 9580 +3774 7662 +3774 8818 +3774 5626 +3775 9441 +3775 6886 +3775 5185 +3775 8231 +3775 6253 +3775 9006 +3775 6735 +3775 3919 +3775 9438 +3776 6945 +3776 5410 +3776 6760 +3776 4175 +3776 6832 +3776 8213 +3776 6877 +3776 3797 +3777 6048 +3777 7905 +3777 5064 +3777 9516 +3777 6634 +3777 5511 +3777 5298 +3777 4512 +3777 6036 +3778 6347 +3778 6571 +3778 7340 +3778 8815 +3778 7184 +3778 8028 +3779 6498 +3779 6149 +3779 6247 +3779 6090 +3779 6567 +3779 5775 +3779 4916 +3779 8760 +3779 7987 +3779 4348 +3779 6245 +3780 4310 +3780 4761 +3780 7987 +3780 7348 +3780 9142 +3780 6971 +3780 4678 +3780 9163 +3780 4687 +3780 8402 +3780 5219 +3780 6870 +3780 4729 +3780 4963 +3780 9075 +3780 8507 +3781 7723 +3781 6692 +3781 9831 +3781 6984 +3781 7881 +3781 7076 +3781 8473 +3781 4703 +3781 6079 +3781 8830 +3781 4965 +3782 5505 +3782 9223 +3782 7351 +3782 7636 +3782 9485 +3782 9049 +3782 7055 +3782 8496 +3782 7217 +3782 6067 +3782 8980 +3782 8982 +3782 4471 +3782 7450 +3782 9263 +3782 7518 +3783 4259 +3783 8164 +3783 8424 +3783 9289 +3783 4683 +3783 8788 +3783 7669 +3783 9654 +3783 5305 +3784 9859 +3784 7301 +3784 4191 +3784 8782 +3784 7829 +3784 4725 +3784 7013 +3784 6136 +3784 9695 +3785 4194 +3785 9512 +3785 6098 +3785 5779 +3785 9942 +3785 7099 +3785 9085 +3786 9343 +3786 8361 +3786 6093 +3786 5810 +3786 5213 +3786 6898 +3786 9811 +3786 5206 +3786 9336 +3786 6346 +3786 6203 +3786 9741 +3786 5930 +3787 8335 +3787 7187 +3787 5529 +3787 7066 +3787 5807 +3787 8243 +3787 6080 +3787 4546 +3787 6731 +3787 8535 +3787 7402 +3787 6380 +3788 7555 +3788 6406 +3788 8315 +3788 5223 +3788 7122 +3788 6363 +3788 4278 +3788 8347 +3788 6780 +3788 9822 +3789 4128 +3789 7073 +3789 5059 +3789 8230 +3789 5654 +3789 9580 +3789 9104 +3789 8754 +3789 8276 +3789 7061 +3790 4101 +3790 8201 +3790 5648 +3790 8721 +3790 9879 +3790 4655 +3790 9517 +3790 7855 +3790 5682 +3790 5172 +3790 4792 +3790 4538 +3790 6210 +3790 9173 +3790 7384 +3790 5978 +3790 4833 +3790 6503 +3791 9408 +3791 6292 +3791 8472 +3791 6041 +3791 5793 +3791 4663 +3791 6592 +3791 6723 +3791 4933 +3791 4683 +3791 5094 +3791 7665 +3791 6132 +3791 5268 +3791 9547 +3792 6434 +3792 6343 +3792 8616 +3792 4139 +3792 4430 +3792 5714 +3792 6772 +3792 8405 +3792 9750 +3792 8825 +3792 4220 +3793 7303 +3793 5645 +3793 8368 +3793 7736 +3793 6545 +3793 5176 +3793 9272 +3793 6683 +3793 7581 +3793 6687 +3794 8674 +3794 5029 +3794 9927 +3794 4584 +3794 4456 +3794 9925 +3794 4441 +3794 6427 +3794 9085 +3794 4798 +3794 5893 +3795 7556 +3795 7590 +3795 7369 +3795 9964 +3795 7788 +3795 7214 +3795 5461 +3795 6329 +3795 7727 +3795 9083 +3796 9088 +3796 7808 +3796 6790 +3796 8755 +3796 7349 +3796 9146 +3796 4939 +3796 4174 +3796 5076 +3796 9948 +3796 5254 +3796 5474 +3796 8431 +3796 6517 +3796 9855 +3797 5888 +3797 4635 +3797 3872 +3797 8494 +3797 5423 +3797 8632 +3797 4815 +3797 9172 +3797 8926 +3797 8930 +3797 9832 +3797 5614 +3797 5615 +3797 8570 +3798 9569 +3798 8162 +3798 6947 +3798 6244 +3798 7591 +3798 8745 +3798 7303 +3798 8110 +3798 7989 +3798 5860 +3798 8897 +3798 6815 +3799 4994 +3799 5252 +3799 4488 +3799 4366 +3799 9625 +3799 9759 +3799 8614 +3799 8262 +3799 6859 +3799 9251 +3799 8158 +3799 6270 +3800 9120 +3800 5187 +3800 4403 +3800 5358 +3800 4433 +3800 8019 +3800 4116 +3800 7503 +3800 6620 +3800 5565 +3800 9171 +3801 4225 +3801 9858 +3801 5819 +3801 5126 +3801 6441 +3801 7658 +3801 9456 +3801 9295 +3801 7476 +3801 5976 +3801 6708 +3802 5120 +3802 4243 +3802 8213 +3802 4257 +3802 4386 +3802 3833 +3802 6191 +3802 7225 +3802 6716 +3802 5186 +3802 3911 +3802 4711 +3802 4983 +3803 5512 +3803 7451 +3803 8992 +3803 8109 +3803 5937 +3803 6815 +3803 8516 +3803 4300 +3803 4823 +3803 8164 +3803 6502 +3803 8849 +3803 3950 +3803 8818 +3803 4605 +3804 5509 +3804 7178 +3804 8076 +3804 7729 +3804 5160 +3804 7217 +3804 5303 +3804 6584 +3804 6458 +3804 6983 +3804 7627 +3804 5330 +3804 7138 +3804 7665 +3804 7412 +3804 5113 +3805 6540 +3805 7569 +3805 4762 +3805 4511 +3805 3874 +3805 5420 +3805 9142 +3805 9150 +3805 5972 +3805 6997 +3805 9442 +3805 4071 +3805 5494 +3805 5500 +3805 6781 +3806 6283 +3806 8590 +3806 9115 +3806 6302 +3806 5929 +3806 5703 +3806 6061 +3806 8925 +3806 6843 +3806 6079 +3806 4422 +3806 5447 +3806 4573 +3806 4333 +3807 5739 +3807 8577 +3807 3907 +3807 8359 +3807 5180 +3807 7089 +3807 5456 +3807 6994 +3807 6563 +3807 8982 +3807 6138 +3807 7324 +3807 6463 +3808 6930 +3808 6163 +3808 9376 +3808 7366 +3808 7212 +3808 7857 +3808 4147 +3808 9014 +3808 6586 +3808 4128 +3808 9284 +3808 7118 +3808 4946 +3808 6999 +3808 9298 +3809 4800 +3809 5537 +3809 7660 +3809 3854 +3809 3833 +3809 9694 +3810 6827 +3810 4420 +3810 6422 +3810 7729 +3810 9323 +3810 5294 +3810 6065 +3811 5028 +3811 6821 +3811 9736 +3811 8328 +3811 9164 +3811 5966 +3811 4849 +3811 5651 +3811 7028 +3811 4854 +3811 9338 +3811 5222 +3811 3813 +3812 8353 +3812 8226 +3812 8561 +3812 8968 +3812 9130 +3812 4715 +3812 5873 +3812 7478 +3812 7256 +3813 4614 +3813 7432 +3813 4618 +3813 8087 +3813 4395 +3813 6966 +3813 9400 +3813 9424 +3813 7135 +3813 8929 +3813 8930 +3813 8037 +3813 7531 +3813 4340 +3813 8183 +3813 4345 +3813 9598 +3814 6848 +3814 8227 +3814 7211 +3814 5836 +3814 5389 +3814 5454 +3814 5936 +3814 8803 +3814 8276 +3814 9758 +3814 4585 +3814 5375 +3814 4606 +3814 5109 +3815 5750 +3815 6213 +3815 7207 +3815 9674 +3815 6349 +3815 9774 +3815 6157 +3815 5814 +3815 8157 +3815 6811 +3815 8029 +3815 7391 +3816 7299 +3816 8460 +3816 6175 +3816 6582 +3816 5692 +3816 4235 +3816 8004 +3816 6480 +3816 5208 +3816 4709 +3816 3821 +3816 6889 +3816 6013 +3817 7238 +3817 6695 +3817 7432 +3817 3885 +3817 7310 +3817 9327 +3817 5320 +3817 8789 +3817 5878 +3817 8701 +3817 9694 +3818 4694 +3818 6966 +3818 4937 +3818 6919 +3818 4174 +3818 4653 +3818 5878 +3818 8311 +3818 5241 +3818 8767 +3819 6147 +3819 7052 +3819 8207 +3819 7701 +3819 4517 +3819 4536 +3819 8012 +3819 5326 +3819 4816 +3819 9681 +3819 5852 +3819 9951 +3819 6759 +3819 5611 +3819 9338 +3820 8207 +3820 7569 +3820 3992 +3820 8096 +3820 8482 +3820 4516 +3820 4282 +3820 7101 +3820 4802 +3820 6867 +3820 8281 +3820 7901 +3820 7147 +3820 9708 +3820 6895 +3820 6135 +3821 5765 +3821 8463 +3821 4242 +3821 6950 +3821 8488 +3821 4910 +3821 9022 +3821 5645 +3821 5082 +3822 7042 +3822 8427 +3822 5549 +3822 9406 +3822 8470 +3822 8188 +3822 5781 +3823 6624 +3823 8162 +3823 7524 +3823 5831 +3823 6506 +3823 8781 +3823 5871 +3823 8629 +3823 3990 +3823 7608 +3823 6297 +3824 7234 +3824 8069 +3824 6216 +3824 5418 +3824 5847 +3824 8077 +3824 6941 +3824 5602 +3824 9605 +3824 5846 +3824 6589 +3825 7554 +3825 5896 +3825 5513 +3825 4525 +3825 5524 +3825 4255 +3825 7490 +3825 8518 +3825 7753 +3825 5835 +3825 4172 +3825 5457 +3825 5972 +3825 7001 +3825 8411 +3825 7915 +3825 9201 +3825 6138 +3826 4161 +3826 4807 +3826 8907 +3826 5103 +3826 9681 +3826 6099 +3826 9717 +3826 4185 +3826 5592 +3826 4851 +3826 8666 +3826 6031 +3826 4638 +3826 7263 +3827 5072 +3827 6148 +3827 4774 +3827 5100 +3827 6861 +3827 6031 +3827 4976 +3827 6284 +3827 9917 +3827 6431 +3828 8848 +3828 8213 +3828 5277 +3828 8607 +3828 5794 +3828 4267 +3828 8638 +3828 5825 +3828 5068 +3828 5196 +3828 3929 +3828 8411 +3828 5343 +3828 8419 +3828 7147 +3828 9716 +3828 5033 +3828 4862 +3829 6532 +3829 9993 +3829 5679 +3829 4240 +3829 6001 +3829 5618 +3829 6069 +3829 6710 +3829 7133 +3830 8929 +3830 6051 +3830 6263 +3830 5381 +3830 9665 +3830 8969 +3830 5483 +3830 7918 +3830 9135 +3830 5169 +3830 6526 +3830 9244 +3830 4062 +3830 9151 +3831 8591 +3831 9170 +3831 9046 +3831 8921 +3831 6136 +3831 6009 +3831 7517 +3831 8574 +3832 4225 +3832 8835 +3832 8972 +3832 5278 +3832 5702 +3832 9417 +3832 5837 +3832 8593 +3832 6266 +3832 7421 +3833 5760 +3833 4489 +3833 5264 +3833 9232 +3833 3888 +3833 7500 +3833 7883 +3833 9164 +3833 6097 +3833 8187 +3833 7782 +3833 4336 +3833 9201 +3833 4987 +3834 5057 +3834 5498 +3834 7245 +3834 5268 +3834 9973 +3834 4023 +3834 4025 +3834 7643 +3834 7996 +3834 9469 +3834 6207 +3835 9889 +3835 9636 +3835 5884 +3835 7753 +3835 6158 +3835 5767 +3835 9715 +3835 4777 +3835 7189 +3836 5249 +3836 4226 +3836 5508 +3836 8356 +3836 9126 +3836 8877 +3836 8705 +3836 8503 +3836 9539 +3836 9677 +3836 5590 +3836 8797 +3836 8555 +3836 8687 +3836 9201 +3836 8313 +3836 5371 +3837 5312 +3837 4546 +3837 3977 +3837 4621 +3837 5198 +3837 7341 +3837 9824 +3837 5052 +3837 7902 +3838 7808 +3838 6786 +3838 6541 +3838 5533 +3838 9374 +3838 4905 +3838 5434 +3838 5696 +3838 5322 +3838 8143 +3838 9562 +3838 6240 +3838 7524 +3838 9831 +3838 5227 +3838 8045 +3838 6653 +3838 7157 +3838 4605 +3839 8448 +3839 3970 +3839 5733 +3839 4615 +3839 9000 +3839 7369 +3839 5799 +3839 9260 +3839 7029 +3839 6553 +3839 9823 +3840 8196 +3840 8333 +3840 7444 +3840 6939 +3840 4521 +3840 7985 +3840 4540 +3840 6718 +3840 7888 +3840 9681 +3840 7651 +3840 4345 +3840 6493 +3840 9825 +3840 6420 +3841 4289 +3841 4771 +3841 7368 +3841 6889 +3841 8560 +3841 5145 +3841 5597 +3842 6272 +3842 6919 +3842 5135 +3842 5410 +3842 3882 +3842 5174 +3842 9672 +3842 5193 +3842 8394 +3842 6861 +3842 4174 +3842 6984 +3842 7513 +3842 4571 +3842 7264 +3842 8178 +3842 9339 +3843 7171 +3843 9093 +3843 3947 +3843 4639 +3843 7205 +3843 9384 +3843 6702 +3843 6447 +3843 9795 +3843 7375 +3843 9052 +3843 4321 +3843 7909 +3843 4843 +3843 5103 +3843 8177 +3844 7938 +3844 4511 +3844 6435 +3844 4006 +3844 9004 +3844 7472 +3844 5945 +3844 7886 +3844 9935 +3844 8797 +3844 5856 +3844 4208 +3844 4849 +3844 5753 +3845 5595 +3845 8007 +3845 6793 +3845 4619 +3845 5377 +3845 9539 +3845 9396 +3846 6928 +3846 8853 +3846 7449 +3846 4253 +3846 9378 +3846 8946 +3846 9919 +3846 9033 +3846 6475 +3846 5202 +3846 6370 +3846 6384 +3846 3989 +3847 8321 +3847 8923 +3847 6725 +3847 8134 +3847 8545 +3847 8317 +3847 9040 +3847 5043 +3847 8784 +3847 5503 +3847 9386 +3847 4383 +3848 9440 +3848 5730 +3848 6564 +3848 8005 +3848 6056 +3848 9482 +3848 4204 +3848 9933 +3848 6045 +3848 6779 +3848 4851 +3848 5044 +3848 7189 +3848 8126 +3849 7492 +3849 5569 +3849 9896 +3849 8748 +3849 9239 +3849 6732 +3849 5367 +3849 7793 +3849 7958 +3849 6460 +3849 8664 +3849 7323 +3849 5532 +3850 7492 +3850 7813 +3850 9069 +3850 8112 +3850 8018 +3850 9460 +3850 5597 +3851 7493 +3851 7815 +3851 8180 +3851 4853 +3851 4025 +3851 5594 +3851 5787 +3851 4445 +3851 4894 +3852 6272 +3852 7649 +3852 7427 +3852 8452 +3852 4678 +3852 6249 +3852 6379 +3852 4460 +3852 5396 +3852 9376 +3853 8967 +3853 5529 +3853 6943 +3853 7332 +3853 4262 +3853 7095 +3853 7227 +3853 6865 +3853 5330 +3853 4772 +3853 5986 +3853 9833 +3853 7933 +3853 7167 +3854 7712 +3854 4067 +3854 7692 +3854 4304 +3854 8353 +3854 7320 +3854 4260 +3854 7484 +3854 8476 +3854 9086 +3855 6407 +3855 9731 +3855 7013 +3855 4264 +3855 5676 +3855 5447 +3855 7122 +3855 9111 +3855 8218 +3855 6043 +3855 8604 +3855 7098 +3855 4062 +3855 4831 +3856 8598 +3856 7464 +3856 6153 +3856 3997 +3856 6097 +3856 4349 +3856 4212 +3856 9014 +3856 7741 +3857 8205 +3857 5016 +3857 4772 +3857 7068 +3857 4406 +3857 8905 +3857 9674 +3857 7627 +3857 5841 +3857 5972 +3857 9308 +3857 5220 +3857 4582 +3857 9455 +3858 4480 +3858 8031 +3858 5576 +3858 6511 +3858 9832 +3858 7634 +3858 7030 +3858 7387 +3859 5376 +3859 6747 +3859 4197 +3859 9541 +3859 5590 +3859 8585 +3859 9750 +3859 8395 +3859 5261 +3859 6040 +3859 4242 +3859 8153 +3859 6169 +3859 7898 +3859 7551 +3859 5010 +3859 7237 +3860 4486 +3860 6537 +3860 6932 +3860 7195 +3860 5813 +3860 4153 +3860 6461 +3860 8787 +3860 4180 +3860 4056 +3860 9183 +3860 8422 +3860 5102 +3860 6639 +3860 4093 +3861 8329 +3861 7562 +3861 4878 +3861 5412 +3861 7846 +3861 7985 +3861 7731 +3861 3978 +3861 7645 +3861 4323 +3861 4980 +3862 6086 +3862 9421 +3862 9041 +3862 9330 +3862 5204 +3862 5820 +3863 4496 +3863 9571 +3863 5014 +3863 5190 +3863 4508 +3863 5801 +3863 8528 +3863 5202 +3863 5882 +3863 6592 +3863 6614 +3863 6953 +3863 6138 +3863 4058 +3863 8521 +3864 9312 +3864 9179 +3864 4901 +3864 4552 +3864 5737 +3864 4555 +3864 6578 +3864 4351 +3864 7154 +3864 6869 +3864 9336 +3864 5146 +3864 4955 +3864 5317 +3865 4672 +3865 9931 +3865 9447 +3865 6092 +3865 7116 +3865 3917 +3865 8240 +3865 9012 +3865 5691 +3865 5475 +3866 5158 +3866 6283 +3866 5519 +3866 5584 +3866 9204 +3866 4668 +3867 5891 +3867 6151 +3867 6177 +3867 7852 +3867 8621 +3867 4727 +3867 8524 +3867 5079 +3867 5216 +3867 9700 +3867 5745 +3867 9719 +3868 8069 +3868 4777 +3868 4205 +3868 9582 +3868 6413 +3868 7568 +3868 5875 +3868 4602 +3869 4493 +3869 9363 +3869 8346 +3869 5793 +3869 7589 +3869 6319 +3869 9781 +3869 8052 +3869 7868 +3869 8518 +3869 9031 +3869 5846 +3869 6762 +3869 4083 +3869 5621 +3869 7801 +3869 5755 +3869 4714 +3870 8758 +3870 8326 +3870 9543 +3870 6345 +3870 6067 +3870 8790 +3871 4134 +3871 4841 +3871 6252 +3871 8110 +3871 7951 +3871 4853 +3871 8553 +3871 7641 +3871 6367 +3872 5121 +3872 4069 +3872 6022 +3872 5008 +3872 6745 +3872 7487 +3872 9467 +3872 4773 +3873 7558 +3873 9865 +3873 9994 +3873 7116 +3873 5198 +3873 8433 +3873 8267 +3873 5716 +3873 8630 +3873 6121 +3873 8154 +3873 8586 +3874 8073 +3874 5485 +3874 8465 +3874 4244 +3874 9117 +3874 6179 +3874 9125 +3874 5414 +3874 5303 +3874 5791 +3874 9797 +3874 8904 +3874 7638 +3874 8685 +3874 4316 +3874 5925 +3874 8682 +3874 8319 +3875 4608 +3875 5217 +3875 5353 +3875 7083 +3875 7923 +3875 5209 +3875 9498 +3876 5610 +3876 4834 +3876 8875 +3876 5801 +3876 8783 +3876 9264 +3876 5009 +3876 4915 +3876 6167 +3876 7672 +3876 7320 +3876 7907 +3876 4220 +3877 8484 +3877 7421 +3877 6348 +3877 9629 +3877 4670 +3877 9087 +3878 4367 +3878 9625 +3878 4505 +3878 7079 +3878 6846 +3878 7615 +3878 7753 +3878 4176 +3878 4180 +3878 4569 +3878 4316 +3878 8420 +3878 7269 +3878 5694 +3878 6650 +3878 6909 +3879 5756 +3879 6812 +3879 4196 +3879 6795 +3879 7064 +3879 7563 +3879 9911 +3879 5592 +3879 9948 +3879 5950 +3879 8553 +3880 8832 +3880 6112 +3880 5351 +3880 7528 +3880 9993 +3880 9869 +3880 6575 +3880 9907 +3880 7286 +3880 7881 +3880 5146 +3880 3983 +3880 6044 +3881 5411 +3881 8932 +3881 5381 +3881 8233 +3881 6570 +3881 4108 +3881 9968 +3881 3985 +3881 7260 +3881 5116 +3881 4158 +3882 4128 +3882 4227 +3882 8257 +3882 8806 +3882 4937 +3882 5553 +3882 8084 +3882 7029 +3882 8854 +3882 8666 +3882 8977 +3882 8029 +3883 4866 +3883 8460 +3883 3996 +3883 7986 +3883 6975 +3883 7876 +3883 5063 +3883 6476 +3883 6622 +3883 9824 +3883 7782 +3883 8941 +3883 5887 +3883 5375 +3884 6624 +3884 7202 +3884 6020 +3884 5769 +3884 5784 +3884 7204 +3884 5178 +3884 7324 +3884 5789 +3884 9886 +3885 5537 +3885 4162 +3885 9763 +3885 7254 +3885 4935 +3885 8424 +3885 9846 +3885 9257 +3885 8792 +3885 6909 +3886 4227 +3886 8333 +3886 8984 +3886 5544 +3886 6060 +3886 9907 +3886 8503 +3886 7252 +3886 9942 +3886 8279 +3886 4069 +3886 4072 +3886 6639 +3886 5744 +3886 8313 +3887 4361 +3887 9997 +3887 8211 +3887 9496 +3887 6042 +3887 7072 +3887 8360 +3887 4010 +3887 7855 +3887 9926 +3887 4427 +3887 9549 +3887 6541 +3887 7255 +3887 5336 +3887 7266 +3887 6378 +3887 4008 +3887 5631 +3888 8451 +3888 4740 +3888 4069 +3888 8972 +3888 5167 +3888 8870 +3889 9442 +3889 5924 +3889 4521 +3889 4589 +3889 8110 +3889 6417 +3889 6803 +3889 5557 +3889 5705 +3889 9753 +3889 5980 +3889 7965 +3889 3902 +3889 7391 +3890 6528 +3890 9377 +3890 4746 +3890 4748 +3890 7509 +3890 6574 +3890 7760 +3890 8470 +3890 7800 +3890 8652 +3890 5534 +3891 6732 +3891 8674 +3891 9554 +3891 9954 +3891 4139 +3891 7122 +3891 7886 +3891 8689 +3891 9300 +3891 6681 +3891 6015 +3892 9299 +3892 9670 +3892 7560 +3892 5468 +3892 5931 +3892 5709 +3892 5934 +3892 9808 +3892 6674 +3892 5875 +3892 8980 +3892 6318 +3892 7035 +3893 6758 +3893 9682 +3893 7765 +3893 6525 +3893 4849 +3893 7092 +3893 5720 +3893 8948 +3893 8218 +3893 4730 +3893 8831 +3894 6305 +3894 4643 +3894 4777 +3894 9452 +3894 7358 +3894 4021 +3894 4790 +3894 6777 +3894 8219 +3894 6619 +3894 6716 +3895 4000 +3895 4671 +3895 5019 +3895 6212 +3895 5558 +3895 9958 +3895 9607 +3895 4939 +3895 7469 +3895 7890 +3895 8278 +3895 9572 +3895 5854 +3895 5503 +3896 5171 +3896 5155 +3896 6244 +3896 4600 +3896 5478 +3896 4974 +3896 5424 +3896 4789 +3896 5075 +3896 5397 +3896 7517 +3897 7579 +3897 4516 +3897 8742 +3897 8488 +3897 4159 +3897 8003 +3897 3937 +3897 4182 +3897 7643 +3897 4957 +3897 7137 +3897 3938 +3897 5606 +3897 7537 +3897 4117 +3897 8062 +3898 8484 +3898 7014 +3898 7304 +3898 9912 +3898 5107 +3898 4150 +3898 9624 +3898 4703 +3898 6653 +3899 4772 +3899 8197 +3899 5095 +3899 7434 +3899 5675 +3899 4269 +3899 4590 +3899 6193 +3899 5604 +3899 8344 +3899 3961 +3899 6842 +3900 4704 +3900 8065 +3900 4764 +3900 4367 +3900 7320 +3900 8348 +3900 4531 +3900 9973 +3900 8117 +3900 4506 +3900 7804 +3901 6816 +3901 8226 +3901 5927 +3901 7340 +3901 8683 +3901 6924 +3901 6573 +3901 9777 +3901 4246 +3901 4900 +3901 8132 +3901 9189 +3901 7199 +3902 6400 +3902 8135 +3902 9192 +3902 5225 +3902 5547 +3902 9245 +3902 4141 +3902 5341 +3902 8536 +3902 6233 +3902 4541 +3902 7773 +3903 7168 +3903 7434 +3903 5789 +3903 9122 +3903 5083 +3903 6571 +3903 7469 +3903 9008 +3903 9077 +3903 4433 +3903 7640 +3903 8283 +3903 8797 +3903 4094 +3903 5626 +3904 4576 +3904 5792 +3904 9499 +3904 6725 +3904 4326 +3904 7271 +3904 6349 +3904 4942 +3904 6893 +3904 8017 +3904 7315 +3904 5367 +3904 6812 +3905 5636 +3905 5775 +3905 4393 +3905 4270 +3905 4407 +3905 6714 +3905 8160 +3905 4066 +3905 7148 +3905 6394 +3905 4477 +3906 8161 +3906 8898 +3906 9603 +3906 4390 +3906 5288 +3906 9855 +3907 9643 +3907 6023 +3907 6282 +3907 4112 +3907 5405 +3907 5707 +3907 5224 +3908 5506 +3908 3974 +3908 4744 +3908 5132 +3908 4248 +3908 7078 +3908 9587 +3908 4148 +3908 6456 +3908 4667 +3908 7619 +3908 6213 +3908 5196 +3908 8930 +3908 4727 +3908 9469 +3909 6657 +3909 7266 +3909 7395 +3909 9959 +3909 6219 +3909 6000 +3909 8755 +3909 6771 +3909 9430 +3909 9591 +3909 5850 +3910 4259 +3910 7046 +3910 4776 +3910 6921 +3910 4947 +3910 5748 +3910 5161 +3910 5271 +3910 5336 +3910 9914 +3910 7869 +3911 8437 +3911 4293 +3911 5065 +3911 5134 +3911 3933 +3911 8690 +3911 4723 +3911 8446 +3911 7638 +3911 9914 +3911 7390 +3912 4768 +3912 9250 +3912 5705 +3912 5978 +3912 6074 +3912 5235 +3912 6480 +3912 7770 +3912 8912 +3912 8058 +3912 5790 +3913 4676 +3913 6794 +3913 6605 +3913 4367 +3913 6580 +3913 5412 +3913 4922 +3914 5643 +3914 7832 +3914 5148 +3914 9631 +3914 5152 +3914 6572 +3914 5685 +3914 8245 +3914 4599 +3914 5332 +3914 8553 +3914 7148 +3914 7798 +3914 4089 +3914 6014 +3915 4163 +3915 5979 +3915 7766 +3915 9798 +3915 8010 +3915 7261 +3915 4947 +3915 7926 +3915 4600 +3915 5061 +3916 4977 +3916 5602 +3916 9127 +3916 5196 +3916 8429 +3916 5265 +3916 5490 +3916 8917 +3916 7295 +3916 5693 +3916 6175 +3917 9874 +3917 5795 +3917 8104 +3917 7478 +3917 9401 +3917 8893 +3917 4802 +3917 4165 +3917 8782 +3917 8288 +3917 7540 +3917 5372 +3917 7677 +3918 6084 +3918 7269 +3918 9217 +3918 5737 +3918 8364 +3918 4429 +3918 7824 +3918 8581 +3919 8386 +3919 6373 +3919 6441 +3919 9842 +3919 5301 +3919 6518 +3919 8250 +3919 9029 +3920 6147 +3920 5014 +3920 4360 +3920 4234 +3920 8337 +3920 5907 +3920 6427 +3920 5027 +3920 6436 +3920 8746 +3920 8119 +3920 8250 +3920 9149 +3920 4161 +3920 5034 +3920 7679 +3921 8580 +3921 6661 +3921 6286 +3921 4880 +3921 4759 +3921 6813 +3921 6060 +3921 4269 +3921 7368 +3921 4169 +3921 9171 +3921 8405 +3921 7383 +3921 5848 +3921 9563 +3921 7522 +3921 5222 +3921 7526 +3921 5868 +3921 9709 +3921 6651 +3922 9478 +3922 9940 +3922 4422 +3922 6407 +3922 4625 +3922 4170 +3922 6955 +3922 8588 +3922 8526 +3922 5779 +3922 7572 +3922 5206 +3922 4281 +3922 5016 +3922 9657 +3923 9216 +3923 8848 +3923 7189 +3923 6550 +3923 7706 +3923 7335 +3923 8238 +3923 5304 +3923 7389 +3923 9700 +3923 4331 +3923 4591 +3924 5760 +3924 5898 +3924 4994 +3924 7950 +3924 8026 +3924 3999 +3924 4768 +3924 4009 +3924 6325 +3924 6490 +3924 7268 +3924 4341 +3924 8570 +3925 4722 +3925 5066 +3925 4119 +3925 4472 +3925 5275 +3925 7786 +3925 5758 +3926 9122 +3926 5806 +3926 6970 +3926 8274 +3926 8535 +3926 9820 +3926 4830 +3926 7908 +3926 5354 +3926 4818 +3926 4462 +3926 7034 +3926 7165 +3927 9282 +3927 6659 +3927 9065 +3927 9898 +3927 6699 +3927 8946 +3927 4529 +3927 7697 +3927 8915 +3927 4148 +3927 7605 +3927 7787 +3927 4024 +3927 6330 +3927 8543 +3927 5567 +3928 7904 +3928 9284 +3928 4774 +3928 7091 +3928 4916 +3928 5109 +3928 7830 +3928 5337 +3929 5955 +3929 9796 +3929 8838 +3929 7538 +3929 7696 +3929 7154 +3929 8508 +3929 6847 +3930 6945 +3930 5602 +3930 9719 +3930 7913 +3930 9034 +3930 5932 +3930 8529 +3930 7764 +3930 5751 +3930 7098 +3930 7818 +3931 7971 +3931 9649 +3931 8824 +3931 5804 +3931 6705 +3931 6034 +3931 8652 +3931 7607 +3931 5580 +3931 5434 +3931 5452 +3932 8992 +3932 9948 +3932 9882 +3932 7271 +3932 6600 +3932 5993 +3932 6567 +3932 5265 +3932 8071 +3932 9044 +3932 8523 +3932 6333 +3933 4034 +3933 9571 +3933 9573 +3933 4681 +3933 5290 +3933 3948 +3933 4269 +3933 4784 +3933 4403 +3933 4980 +3933 7990 +3933 6479 +3933 3996 +3933 9341 +3934 6795 +3934 8602 +3934 6950 +3934 5789 +3934 9920 +3934 7643 +3934 5727 +3934 8530 +3934 5235 +3935 4359 +3935 5772 +3935 9620 +3935 5658 +3935 7687 +3935 7991 +3935 8892 +3935 8640 +3935 7366 +3935 9424 +3935 6490 +3935 9819 +3935 4158 +3935 5625 +3936 5061 +3936 7366 +3936 6961 +3936 6984 +3936 4268 +3936 5994 +3936 5839 +3936 5521 +3936 8276 +3936 8405 +3936 3980 +3936 4731 +3937 9988 +3937 8837 +3937 5223 +3937 4110 +3937 9589 +3937 7385 +3937 6619 +3937 7934 +3937 3999 +3938 9230 +3938 4508 +3938 4123 +3938 8499 +3938 4024 +3938 6204 +3938 5578 +3938 9680 +3938 8544 +3938 6881 +3938 8808 +3938 3953 +3939 9025 +3939 5602 +3939 5592 +3939 6056 +3939 5672 +3939 6130 +3939 5555 +3939 7639 +3939 4216 +3939 9118 +3940 9865 +3940 4620 +3940 8591 +3940 9749 +3940 7987 +3940 4028 +3940 6599 +3940 5458 +3940 9060 +3940 9449 +3940 4597 +3940 8572 +3941 4357 +3941 7943 +3941 7053 +3941 7187 +3941 9135 +3941 7215 +3941 6209 +3941 6339 +3941 9463 +3941 9294 +3941 9057 +3941 4199 +3941 5612 +3941 8561 +3941 6514 +3941 6515 +3941 5628 +3942 7424 +3942 7942 +3942 4006 +3942 7499 +3942 4012 +3942 9374 +3942 5135 +3942 7089 +3942 9683 +3942 6141 +3943 4352 +3943 8320 +3943 4619 +3943 6161 +3943 7450 +3943 5790 +3943 4912 +3943 8886 +3943 8149 +3943 7511 +3943 6364 +3943 8542 +3943 4063 +3943 9959 +3943 7660 +3943 7194 +3944 9886 +3944 6820 +3944 7336 +3944 8554 +3944 6801 +3944 5622 +3944 6408 +3945 6656 +3945 8077 +3945 4759 +3945 5273 +3945 9882 +3945 9264 +3945 6536 +3945 6205 +3945 5313 +3945 9029 +3945 4679 +3945 9556 +3945 8028 +3945 7322 +3945 3962 +3945 8059 +3946 6498 +3946 5127 +3946 8521 +3946 8971 +3946 5836 +3946 6097 +3946 5303 +3946 6876 +3946 4189 +3946 9054 +3947 6145 +3947 7783 +3947 9640 +3947 9031 +3947 8622 +3947 8943 +3947 9704 +3947 5367 +3947 4763 +3947 8380 +3948 6777 +3948 8854 +3948 9765 +3948 9004 +3948 6453 +3948 4920 +3948 6482 +3948 4442 +3948 7646 +3948 6890 +3948 4458 +3948 7289 +3948 4330 +3948 8959 +3949 6722 +3949 4005 +3949 4935 +3949 9320 +3949 7307 +3949 6380 +3949 7665 +3949 6614 +3949 6135 +3949 7611 +3950 7807 +3950 9407 +3950 9455 +3950 6424 +3950 8757 +3950 5593 +3950 3994 +3950 9436 +3950 4542 +3951 4704 +3951 8836 +3951 8326 +3951 9095 +3951 6426 +3951 8432 +3951 6933 +3951 9718 +3951 5722 +3951 8623 +3951 4703 +3952 7874 +3952 6979 +3952 6985 +3952 6459 +3952 6955 +3952 6739 +3952 4340 +3952 5817 +3952 8924 +3953 7990 +3953 4801 +3953 7746 +3953 7606 +3953 4169 +3953 9067 +3953 8049 +3953 3957 +3953 7417 +3953 4221 +3954 8943 +3954 5521 +3954 7483 +3954 6493 +3954 6782 +3955 8384 +3955 6789 +3955 7949 +3955 9490 +3955 5688 +3955 8387 +3955 4804 +3955 8012 +3955 6747 +3955 4579 +3955 6611 +3955 5878 +3955 9595 +3955 6141 +3956 4642 +3956 6374 +3956 5412 +3956 6091 +3956 6926 +3956 6457 +3956 9432 +3956 8249 +3956 5306 +3956 7387 +3956 4156 +3957 4321 +3957 9707 +3957 8651 +3957 9932 +3957 4721 +3957 5406 +3957 9854 +3957 4638 +3957 4382 +3958 9479 +3958 5015 +3958 5677 +3958 4014 +3958 6749 +3958 7224 +3958 6487 +3958 8152 +3958 8157 +3958 4459 +3958 4078 +3958 4776 +3958 5882 +3959 6304 +3959 4265 +3959 8458 +3959 7975 +3959 9998 +3959 4367 +3959 4978 +3959 5557 +3959 9743 +3959 9019 +3959 9759 +3960 9282 +3960 9575 +3960 6084 +3960 6310 +3960 4489 +3960 7470 +3960 5959 +3960 8767 +3961 6657 +3961 4107 +3961 6531 +3961 8856 +3961 7077 +3961 5161 +3961 8248 +3961 9148 +3961 6224 +3961 9175 +3961 7004 +3961 5739 +3961 9715 +3961 4756 +3961 9726 +3962 7852 +3962 6380 +3962 9517 +3962 9717 +3962 5972 +3962 7775 +3963 3972 +3963 8454 +3963 7916 +3963 7107 +3963 5163 +3963 5037 +3963 6454 +3963 6456 +3963 4803 +3963 5839 +3963 4577 +3963 8427 +3963 5740 +3963 4206 +3963 6645 +3963 6650 +3964 7680 +3964 9541 +3964 4619 +3964 4942 +3964 8304 +3964 5140 +3964 7093 +3964 4633 +3964 7540 +3965 4400 +3965 9379 +3965 5617 +3965 8330 +3965 7213 +3965 6639 +3965 4176 +3965 5458 +3965 4083 +3965 8024 +3965 8602 +3965 5851 +3965 4412 +3966 7022 +3966 9344 +3966 8226 +3966 5507 +3966 6277 +3966 9928 +3966 9546 +3966 6222 +3966 8368 +3966 7752 +3966 5079 +3966 7739 +3967 9858 +3967 6532 +3967 5531 +3967 6430 +3967 9640 +3967 8368 +3967 9522 +3967 8632 +3967 8267 +3967 6980 +3967 4556 +3967 4943 +3967 8528 +3967 6873 +3967 5455 +3967 5990 +3967 5754 +3967 4095 +3968 9601 +3968 8485 +3968 7237 +3968 5882 +3968 5227 +3968 6117 +3968 7325 +3968 7226 +3968 5019 +3968 7837 +3968 8479 +3969 4512 +3969 7110 +3969 8268 +3969 9034 +3969 7411 +3969 8334 +3969 4720 +3969 7945 +3969 8345 +3969 4232 +3969 9854 +3970 5122 +3970 5384 +3970 9097 +3970 5388 +3970 6925 +3970 4756 +3970 6939 +3970 7199 +3970 5416 +3970 5322 +3970 8400 +3970 5461 +3970 9302 +3970 7649 +3970 7654 +3970 9069 +3970 9074 +3970 6395 +3971 8580 +3971 7307 +3971 6427 +3971 6832 +3971 9397 +3971 6588 +3971 4811 +3971 5323 +3971 5839 +3971 7767 +3971 7129 +3971 5215 +3971 8102 +3971 6012 +3972 6402 +3972 6419 +3972 5911 +3972 9664 +3972 6858 +3972 6223 +3972 7122 +3972 8660 +3972 8022 +3972 7385 +3972 8540 +3972 4085 +3973 8640 +3973 9443 +3973 8534 +3973 8499 +3973 6474 +3973 4044 +3973 4622 +3973 7665 +3973 6275 +3973 8405 +3973 8539 +3973 6523 +3974 8582 +3974 4296 +3974 6313 +3974 5527 +3974 7034 +3974 7600 +3974 6268 +3974 9909 +3974 4873 +3974 4666 +3974 6588 +3974 7645 +3975 7441 +3975 5153 +3975 4457 +3975 9804 +3975 7375 +3975 8088 +3975 5428 +3975 4537 +3975 9370 +3975 8703 +3976 8130 +3976 5606 +3976 7214 +3976 7631 +3976 8980 +3976 8085 +3976 9942 +3976 7288 +3976 5212 +3976 7805 +3977 7520 +3977 7713 +3977 9284 +3977 4641 +3977 4072 +3977 5099 +3977 7568 +3977 7025 +3977 6674 +3977 7860 +3977 5852 +3978 7686 +3978 9736 +3978 5385 +3978 5262 +3978 4244 +3978 8731 +3978 4271 +3978 7262 +3978 9785 +3978 6069 +3978 5850 +3978 6249 +3978 9840 +3978 7416 +3979 8643 +3979 7473 +3979 9449 +3979 7786 +3979 4908 +3979 7687 +3979 3984 +3979 8593 +3979 4699 +3979 9852 +3979 7069 +3980 4416 +3980 6504 +3980 7401 +3980 9547 +3980 7733 +3980 7193 +3980 4665 +3980 5277 +3981 6785 +3981 4610 +3981 4874 +3981 6302 +3981 7845 +3981 7384 +3981 4160 +3981 6979 +3981 7753 +3981 8162 +3981 7377 +3981 7001 +3981 9954 +3981 5481 +3981 9327 +3981 9713 +3982 8966 +3982 8393 +3982 6450 +3982 6601 +3983 7840 +3983 5921 +3983 6083 +3983 7972 +3983 8456 +3983 9066 +3983 7916 +3983 5837 +3983 7927 +3983 8339 +3983 4820 +3983 4641 +3984 4967 +3984 4490 +3984 4270 +3984 9104 +3984 5608 +3984 7539 +3984 6202 +3984 9726 +3984 5119 +3985 9857 +3985 5901 +3985 7329 +3985 9714 +3985 9774 +3985 7220 +3985 9782 +3985 7201 +3985 7884 +3985 8151 +3985 7645 +3985 5347 +3985 7026 +3986 6400 +3986 8097 +3986 4517 +3986 6010 +3986 4849 +3986 6668 +3986 4661 +3986 9430 +3986 8954 +3986 9690 +3986 5342 +3987 5314 +3987 7205 +3987 6629 +3987 4272 +3987 9810 +3987 4211 +3987 4276 +3987 7029 +3987 9849 +3987 9305 +3987 6301 +3988 4992 +3988 7362 +3988 4036 +3988 6626 +3988 3998 +3988 4091 +3989 4553 +3989 5275 +3989 6079 +3990 7022 +3990 9954 +3990 4100 +3990 7916 +3990 7089 +3990 9645 +3990 8578 +3990 4721 +3990 9874 +3990 8275 +3990 7246 +3990 5499 +3991 6018 +3991 7942 +3991 7304 +3991 7080 +3991 5693 +3991 9790 +3991 4683 +3991 5836 +3991 6862 +3991 8659 +3991 8159 +3991 6373 +3991 8690 +3991 8435 +3991 4990 +3991 9464 +3991 7547 +3991 4222 +3991 4949 +3992 4737 +3992 5508 +3992 6189 +3992 4642 +3992 4516 +3992 7334 +3992 5933 +3992 4031 +3992 4931 +3992 9033 +3992 5194 +3992 5330 +3992 6489 +3992 8030 +3992 8930 +3993 6528 +3993 5506 +3993 8584 +3993 4300 +3993 5258 +3993 8578 +3993 6289 +3993 9336 +3993 9401 +3994 6276 +3994 6501 +3994 4138 +3994 7852 +3994 8655 +3994 7408 +3994 5073 +3995 9067 +3995 8834 +3995 5859 +3995 4838 +3995 8523 +3995 9826 +3995 7183 +3995 4720 +3995 7254 +3995 9239 +3995 6364 +3995 6943 +3996 6669 +3996 8848 +3996 8213 +3996 8154 +3996 7331 +3996 6778 +3996 6317 +3996 8639 +3996 6219 +3996 7632 +3996 4951 +3996 5737 +3996 4076 +3997 9877 +3997 5318 +3997 4014 +3997 6968 +3997 6204 +3997 9795 +3997 9167 +3997 8165 +3997 5608 +3997 4980 +3997 9685 +3998 5067 +3998 4277 +3998 8088 +3999 7812 +3999 7688 +3999 4368 +3999 9620 +3999 8729 +3999 4903 +3999 5309 +3999 8921 +3999 9434 +3999 5979 +3999 8328 +4000 4521 +4000 9769 +4000 8997 +4000 9990 +4000 5898 +4000 8902 +4000 6043 +4000 6909 +4000 9566 +4000 7301 +4001 5920 +4001 4293 +4001 6957 +4001 9126 +4001 4458 +4001 5565 +4001 7537 +4001 4593 +4001 5239 +4001 6137 +4001 7263 +4001 8817 +4001 9662 +4001 8479 +4002 4225 +4002 6533 +4002 5265 +4002 4242 +4002 4755 +4002 9110 +4002 7173 +4002 8743 +4002 5932 +4002 5807 +4002 9267 +4002 9119 +4002 7232 +4002 9537 +4002 7494 +4002 9801 +4002 9935 +4002 5458 +4002 6489 +4002 6755 +4002 5357 +4003 6912 +4003 6177 +4003 6992 +4003 4870 +4003 5160 +4003 4455 +4003 9996 +4003 9006 +4003 8660 +4003 8406 +4003 9756 +4003 4542 +4003 5478 +4004 9591 +4004 6860 +4004 6870 +4004 6639 +4004 6523 +4004 5692 +4005 8390 +4005 4866 +4005 5094 +4005 7624 +4005 7431 +4005 7726 +4006 9996 +4006 7312 +4006 6939 +4006 4647 +4006 4398 +4006 7859 +4006 4538 +4006 8387 +4006 8902 +4006 4041 +4006 6743 +4006 7533 +4006 6514 +4007 7171 +4007 9865 +4007 5905 +4007 9751 +4007 6316 +4007 5679 +4007 4659 +4007 9017 +4007 6720 +4007 6340 +4007 4497 +4007 5101 +4007 7925 +4007 5111 +4008 4491 +4008 6288 +4008 5267 +4008 5269 +4008 8983 +4008 4120 +4008 6320 +4008 4936 +4008 6610 +4008 9684 +4008 5591 +4008 9819 +4008 7778 +4008 6115 +4008 5330 +4009 7831 +4009 6685 +4009 4770 +4009 7978 +4009 8364 +4009 7597 +4009 6965 +4009 7610 +4009 5955 +4009 8161 +4009 7897 +4009 4699 +4009 6115 +4010 6664 +4010 5259 +4010 6420 +4010 6432 +4010 6957 +4010 7099 +4010 5440 +4010 6092 +4010 4958 +4010 6886 +4010 5800 +4010 7155 +4010 5365 +4011 8192 +4011 7042 +4011 7683 +4011 4754 +4011 9347 +4011 7190 +4011 6562 +4011 5703 +4011 4398 +4011 8499 +4011 5689 +4011 6330 +4011 5950 +4011 4799 +4011 6342 +4011 6855 +4011 9084 +4011 5484 +4011 4604 +4012 4620 +4012 8269 +4012 8975 +4012 4557 +4012 6692 +4012 7336 +4012 4943 +4012 9941 +4012 6358 +4012 6359 +4012 5081 +4012 9067 +4012 6896 +4012 8571 +4012 5885 +4012 6271 +4013 4192 +4013 7943 +4013 7273 +4013 4695 +4013 6707 +4013 7637 +4013 8662 +4013 8248 +4013 4920 +4013 6682 +4013 5917 +4013 4862 +4013 7509 +4014 6848 +4014 8203 +4014 4421 +4014 8861 +4014 4426 +4014 6859 +4014 4962 +4014 8818 +4014 5811 +4014 9943 +4014 5788 +4014 4095 +4015 5781 +4015 6217 +4015 7119 +4015 8274 +4015 8285 +4015 7312 +4015 8938 +4015 6507 +4015 5110 +4016 7427 +4016 8710 +4016 9740 +4016 6383 +4016 7724 +4016 9502 +4016 7874 +4016 8133 +4016 8014 +4016 8543 +4016 5502 +4017 7458 +4017 7299 +4017 7815 +4017 7593 +4017 6379 +4017 9389 +4017 5107 +4017 5749 +4017 6484 +4017 9789 +4018 6176 +4018 5092 +4018 7941 +4018 7496 +4018 7625 +4018 6653 +4018 9493 +4018 8218 +4018 8495 +4019 6272 +4019 5610 +4019 9443 +4019 7077 +4019 5638 +4019 4446 +4019 8621 +4019 7875 +4019 9406 +4019 8793 +4019 4445 +4020 5761 +4020 9218 +4020 8705 +4020 7688 +4020 6417 +4020 7323 +4020 9258 +4020 4523 +4020 9014 +4020 9528 +4020 4538 +4020 6211 +4020 8269 +4020 6862 +4020 4965 +4020 5990 +4020 4326 +4020 5364 +4020 4344 +4021 7174 +4021 8599 +4021 7064 +4021 6555 +4021 6305 +4021 9767 +4021 4536 +4021 5433 +4021 7100 +4021 5444 +4021 5712 +4021 6226 +4021 4188 +4021 5731 +4021 8935 +4021 8427 +4022 7943 +4022 4620 +4022 4238 +4022 4118 +4022 5271 +4022 9374 +4022 5151 +4022 5792 +4022 4652 +4022 7923 +4022 7484 +4022 8645 +4022 8777 +4022 5200 +4022 5849 +4022 7692 +4022 8429 +4022 8690 +4022 4723 +4022 4212 +4022 9341 +4023 9986 +4023 7558 +4023 9624 +4023 8328 +4023 9783 +4023 7370 +4023 9290 +4023 7287 +4023 7899 +4023 5731 +4023 5735 +4023 4328 +4024 4996 +4024 4623 +4024 5778 +4024 7107 +4024 4638 +4024 8121 +4024 6112 +4024 6339 +4024 9797 +4024 8910 +4024 4431 +4024 7395 +4024 9818 +4024 9307 +4024 5219 +4024 6759 +4024 8946 +4024 7032 +4025 6656 +4025 5255 +4025 6929 +4025 9502 +4025 8249 +4025 4747 +4025 5854 +4025 7035 +4025 9453 +4025 6523 +4025 6910 +4026 5888 +4026 8707 +4026 8648 +4026 7336 +4026 7225 +4026 8250 +4026 4541 +4027 9504 +4027 5602 +4027 8872 +4027 7008 +4027 8744 +4027 5522 +4027 7996 +4027 4095 +4028 9697 +4028 9188 +4028 7717 +4028 4833 +4028 4476 +4028 8620 +4028 5433 +4028 7164 +4028 4126 +4029 9990 +4029 7455 +4029 5922 +4029 5285 +4029 8121 +4029 4670 +4029 4165 +4029 7497 +4029 5773 +4029 6865 +4029 9173 +4029 8159 +4029 7904 +4029 5475 +4029 4177 +4029 8552 +4029 9333 +4029 5759 +4030 8462 +4030 6552 +4030 7452 +4030 4639 +4030 4130 +4030 7976 +4030 9565 +4030 8142 +4030 9172 +4030 4061 +4030 7148 +4030 9456 +4031 7232 +4031 5699 +4031 4196 +4031 6149 +4031 4838 +4031 6588 +4031 8875 +4031 7084 +4031 8527 +4031 8853 +4031 4510 +4032 9803 +4032 5603 +4032 9294 +4032 8120 +4032 9647 +4032 4925 +4032 7614 +4033 9245 +4033 8334 +4033 4239 +4033 5114 +4033 6865 +4033 5955 +4033 5656 +4033 6937 +4033 7130 +4033 8639 +4034 5381 +4034 8454 +4034 5925 +4034 6700 +4034 4274 +4034 9782 +4034 8640 +4034 9921 +4034 5958 +4034 4828 +4034 7546 +4034 5984 +4034 8166 +4034 9848 +4034 5882 +4035 7810 +4035 8355 +4035 4229 +4035 8327 +4035 9392 +4035 8468 +4035 5719 +4035 8313 +4035 5180 +4036 6466 +4036 9786 +4036 9925 +4036 4680 +4036 7340 +4036 7564 +4036 7756 +4036 6165 +4036 7255 +4036 6329 +4036 6203 +4036 9660 +4037 4353 +4037 6145 +4037 6083 +4037 8990 +4037 8377 +4037 4285 +4037 9534 +4037 9919 +4037 4955 +4037 6243 +4037 5489 +4037 9459 +4038 7269 +4038 4329 +4038 8172 +4038 9550 +4038 6510 +4038 9033 +4038 8795 +4039 7394 +4039 5155 +4039 4902 +4039 5509 +4039 8588 +4039 8363 +4039 5644 +4039 7599 +4039 4883 +4039 4180 +4039 8652 +4039 9814 +4039 9204 +4039 5695 +4039 4956 +4040 7009 +4040 5122 +4040 4585 +4040 8772 +4040 5029 +4040 5961 +4040 6754 +4040 6286 +4040 7156 +4040 7161 +4040 7832 +4040 7225 +4040 7835 +4040 9564 +4040 9183 +4041 9856 +4041 9504 +4041 5398 +4041 5831 +4041 8840 +4041 5225 +4041 8710 +4041 4140 +4041 8654 +4041 4493 +4041 6632 +4041 5750 +4041 8120 +4041 6719 +4041 8987 +4041 4828 +4041 9535 +4042 4107 +4042 6420 +4042 8727 +4042 4379 +4042 4649 +4042 4790 +4042 6096 +4042 4690 +4042 9176 +4042 7782 +4042 8422 +4042 8808 +4042 9710 +4042 4082 +4042 9897 +4042 5417 +4042 7423 +4043 4352 +4043 4492 +4043 6809 +4043 5916 +4043 6943 +4043 5409 +4043 7216 +4043 5938 +4043 9271 +4043 9274 +4043 6468 +4043 9034 +4043 8651 +4043 7630 +4043 6609 +4043 4576 +4043 5473 +4043 8337 +4043 7661 +4043 6638 +4043 8048 +4043 5497 +4044 6658 +4044 9763 +4044 9351 +4044 7561 +4044 5482 +4044 7697 +4044 5005 +4044 8942 +4044 7570 +4044 9436 +4044 4181 +4044 8233 +4044 6777 +4044 8313 +4044 8605 +4044 5823 +4045 6689 +4045 6162 +4045 9284 +4045 4968 +4045 9133 +4045 9646 +4045 6706 +4045 5460 +4046 6533 +4046 4628 +4046 8475 +4046 6175 +4046 6191 +4046 9149 +4046 8126 +4046 4551 +4046 5452 +4046 5325 +4046 6102 +4046 5084 +4046 9446 +4046 6257 +4047 6592 +4047 9089 +4047 6742 +4047 5225 +4047 5456 +4047 4372 +4047 8791 +4047 4760 +4047 5620 +4047 6294 +4048 6571 +4048 4102 +4048 7431 +4048 5128 +4048 8589 +4048 8838 +4048 8234 +4048 9777 +4048 9527 +4048 4150 +4048 4686 +4048 8533 +4048 7894 +4048 7647 +4048 6258 +4048 6644 +4048 7803 +4049 6818 +4049 6891 +4049 4839 +4049 5079 +4049 9685 +4049 7831 +4049 9732 +4050 7428 +4050 4614 +4050 9871 +4050 9503 +4050 5294 +4050 5041 +4050 8895 +4050 8902 +4050 8533 +4050 5595 +4050 8287 +4051 7042 +4051 5507 +4051 6284 +4051 9620 +4051 7455 +4051 4265 +4051 5164 +4051 5449 +4051 5070 +4051 7510 +4051 4314 +4051 8027 +4051 8040 +4051 5993 +4051 7658 +4052 7062 +4052 9882 +4052 5020 +4052 7347 +4052 9546 +4052 9278 +4052 6858 +4052 9946 +4052 8156 +4052 9789 +4052 9453 +4052 4981 +4052 5883 +4053 8724 +4053 5145 +4053 9248 +4053 8754 +4053 4537 +4053 6860 +4053 7894 +4053 8671 +4053 9064 +4053 4074 +4053 9835 +4053 9325 +4054 9088 +4054 6690 +4054 5865 +4054 4526 +4054 9763 +4054 8395 +4054 4888 +4054 4827 +4054 5067 +4055 8600 +4055 8220 +4055 8230 +4055 6837 +4055 5687 +4055 9528 +4055 4927 +4055 6992 +4055 5073 +4055 4473 +4055 9692 +4055 9829 +4055 5880 +4056 5387 +4056 9230 +4056 6031 +4056 9114 +4056 5169 +4056 9514 +4056 7223 +4056 7678 +4056 9793 +4056 8520 +4056 6482 +4056 9563 +4056 8549 +4056 4582 +4056 8429 +4056 9598 +4056 5674 +4057 9376 +4057 5284 +4057 5830 +4057 8327 +4057 6376 +4057 5710 +4057 7000 +4057 4371 +4057 5621 +4058 8086 +4058 7574 +4058 9863 +4058 7315 +4058 8597 +4058 5654 +4058 7962 +4058 9888 +4058 7462 +4058 6459 +4058 6165 +4058 7995 +4058 6628 +4058 8303 +4058 7411 +4059 8931 +4059 4740 +4059 4872 +4059 7054 +4059 7793 +4059 5940 +4059 5464 +4060 4512 +4060 9103 +4060 5833 +4060 9322 +4060 9735 +4060 4172 +4060 9234 +4060 5427 +4060 7189 +4061 7719 +4061 6925 +4061 9488 +4061 5395 +4061 9883 +4061 4259 +4061 9902 +4061 5168 +4061 8643 +4061 9798 +4061 4828 +4061 8035 +4061 9579 +4061 8571 +4061 5884 +4062 9620 +4062 9035 +4062 6797 +4062 9013 +4062 7448 +4062 8772 +4062 7419 +4062 9950 +4062 9252 +4063 6017 +4063 8197 +4063 5766 +4063 7618 +4063 4461 +4063 5547 +4063 4396 +4063 5820 +4063 8512 +4063 5570 +4063 4166 +4063 6368 +4063 5094 +4063 6634 +4063 7917 +4063 5487 +4063 9458 +4064 7810 +4064 4998 +4064 7402 +4064 8907 +4064 5203 +4064 7374 +4064 7065 +4064 7386 +4065 5650 +4065 8212 +4065 7458 +4065 5668 +4065 9919 +4065 9634 +4065 6868 +4065 4949 +4065 5720 +4065 9424 +4065 9956 +4065 9578 +4065 6252 +4065 4213 +4065 9596 +4066 4490 +4066 8460 +4066 6045 +4066 5538 +4066 4153 +4066 5308 +4066 5444 +4066 9925 +4066 8685 +4066 6908 +4067 5344 +4067 6245 +4067 9418 +4067 8911 +4067 6290 +4067 8387 +4067 8661 +4067 5948 +4067 4382 +4068 5761 +4068 5382 +4068 9357 +4068 7585 +4068 6067 +4068 9662 +4068 5829 +4068 9416 +4068 7639 +4068 6874 +4068 4449 +4068 4987 +4068 9703 +4068 5110 +4068 4219 +4068 9983 +4069 8768 +4069 7370 +4069 7213 +4069 5517 +4069 5875 +4069 7956 +4069 8380 +4069 9968 +4070 8481 +4070 7112 +4070 8455 +4070 5395 +4070 8116 +4070 9786 +4070 9022 +4070 5791 +4071 5519 +4071 4242 +4071 6821 +4071 7209 +4071 8368 +4071 6712 +4071 7744 +4071 8696 +4071 6490 +4071 8543 +4071 8299 +4071 5880 +4071 9598 +4071 6527 +4072 9249 +4072 6597 +4072 8808 +4072 4939 +4072 9943 +4072 4469 +4072 8951 +4072 4377 +4072 9498 +4072 6463 +4072 6106 +4072 7497 +4072 7615 +4073 5986 +4073 7075 +4073 9286 +4073 5192 +4073 7914 +4073 8002 +4073 7855 +4073 7952 +4073 8977 +4073 7347 +4073 5615 +4073 5496 +4073 5340 +4073 4938 +4074 9538 +4074 9361 +4074 5646 +4074 5967 +4074 4980 +4074 5777 +4074 6361 +4074 5050 +4074 7323 +4074 4732 +4074 5758 +4075 6167 +4075 7074 +4075 7975 +4075 7084 +4075 4144 +4075 8373 +4075 4539 +4075 8396 +4075 6742 +4075 6107 +4075 9694 +4075 5983 +4075 7909 +4075 9318 +4075 7401 +4075 5496 +4075 5371 +4076 4416 +4076 6340 +4076 9253 +4076 9830 +4076 8329 +4076 7117 +4076 4367 +4076 9104 +4076 9363 +4076 4952 +4076 8858 +4076 5921 +4076 9214 +4077 6784 +4077 8875 +4077 5634 +4077 9873 +4077 8730 +4077 5787 +4077 8988 +4077 8359 +4077 9771 +4077 5941 +4077 6004 +4077 5307 +4077 7740 +4077 7615 +4077 9794 +4077 8262 +4077 9690 +4077 8412 +4077 5173 +4077 9324 +4077 4852 +4077 6265 +4077 7551 +4078 7617 +4078 4167 +4078 7244 +4078 7117 +4078 4657 +4078 7644 +4078 6774 +4079 6976 +4079 8929 +4079 5514 +4079 9325 +4079 4915 +4079 7832 +4079 4131 +4079 4636 +4079 4832 +4079 6079 +4080 6976 +4080 4513 +4080 8483 +4080 5288 +4080 8547 +4080 4719 +4080 4307 +4080 8598 +4080 8695 +4080 5945 +4080 9303 +4080 4287 +4081 7265 +4081 8201 +4081 5835 +4081 4717 +4081 5326 +4081 8461 +4081 9618 +4081 4563 +4081 7410 +4081 7542 +4081 6931 +4081 4633 +4081 9327 +4081 9919 +4082 7043 +4082 5733 +4082 7398 +4082 5864 +4082 7817 +4082 8721 +4082 9810 +4082 9395 +4082 8472 +4082 9849 +4082 9435 +4082 6814 +4083 9355 +4083 6699 +4083 7212 +4083 9773 +4083 6714 +4083 9410 +4083 4296 +4083 4553 +4083 6351 +4083 6264 +4083 4317 +4083 6752 +4083 4838 +4083 4204 +4084 7808 +4084 7786 +4084 5356 +4084 8084 +4084 8987 +4084 9116 +4085 4771 +4085 5546 +4085 9268 +4085 7877 +4085 7131 +4085 7146 +4085 9070 +4085 5885 +4085 6900 +4085 5756 +4085 4349 +4086 5931 +4086 4110 +4086 6072 +4086 8979 +4086 7598 +4086 6607 +4086 4604 +4086 4597 +4087 9601 +4087 9378 +4087 5091 +4087 8773 +4087 6534 +4087 7207 +4087 9894 +4087 8497 +4087 5751 +4087 7611 +4087 5914 +4087 9594 +4087 5402 +4087 8702 +4087 4165 +4088 9092 +4088 4744 +4088 4258 +4088 9635 +4088 7204 +4088 8754 +4088 9459 +4088 6067 +4088 7502 +4088 5085 +4088 8927 +4088 9842 +4088 9587 +4088 7030 +4088 7166 +4089 8960 +4089 7873 +4089 7040 +4089 6884 +4089 7069 +4089 4563 +4089 8748 +4089 7668 +4089 4367 +4089 8456 +4089 9459 +4089 4756 +4089 5653 +4089 6743 +4089 4541 +4089 6746 +4089 4829 +4090 5376 +4090 8979 +4090 5666 +4090 9768 +4090 6108 +4090 8460 +4090 5039 +4090 4744 +4090 4694 +4090 8185 +4090 5688 +4091 8329 +4091 6922 +4091 8077 +4091 7961 +4091 7329 +4091 5930 +4091 8111 +4091 6320 +4091 5939 +4091 7105 +4091 6482 +4091 9904 +4091 5726 +4091 5752 +4091 7934 +4092 6793 +4092 5132 +4092 4109 +4092 4889 +4092 9507 +4092 5924 +4092 6174 +4092 5823 +4092 4290 +4092 7240 +4092 5739 +4092 7279 +4092 4216 +4092 9977 +4093 6084 +4093 4486 +4093 5703 +4093 8815 +4093 4978 +4093 6710 +4093 7992 +4093 7070 +4093 7637 +4094 6296 +4094 4122 +4094 9888 +4094 8743 +4094 7095 +4094 9281 +4094 4425 +4094 6731 +4094 5331 +4094 4585 +4094 8556 +4094 9713 +4094 4860 +4094 9855 +4095 8677 +4095 5896 +4095 6229 +4095 7162 +4096 6466 +4096 7303 +4096 5847 +4096 9069 +4096 8655 +4096 7592 +4096 6775 +4096 4284 +4097 4395 +4097 4879 +4097 6531 +4097 7323 +4097 6064 +4097 4115 +4097 7371 +4097 6355 +4097 9175 +4097 8356 +4097 8538 +4097 5601 +4097 5867 +4097 9324 +4097 7411 +4098 6115 +4098 8804 +4098 7367 +4098 4839 +4098 5197 +4098 9517 +4098 6478 +4098 4271 +4098 7280 +4098 6935 +4098 6287 +4098 9139 +4099 7684 +4099 9093 +4099 9190 +4099 7985 +4099 7594 +4099 7501 +4099 7791 +4099 8432 +4099 6129 +4099 6132 +4099 8310 +4099 8922 +4099 5743 +4100 6914 +4100 6280 +4100 6665 +4100 7827 +4100 5017 +4100 4653 +4100 8390 +4100 5623 +4100 5594 +4100 9053 +4100 4832 +4100 4706 +4100 5863 +4100 6381 +4100 9198 +4100 5872 +4100 6774 +4100 7039 +4101 5089 +4101 8034 +4101 8772 +4101 7686 +4101 6278 +4101 9041 +4101 5704 +4101 5232 +4101 7985 +4101 7975 +4101 5105 +4101 7127 +4101 7581 +4101 8446 +4102 6017 +4102 9094 +4102 5769 +4102 4754 +4102 6447 +4102 7472 +4102 9795 +4102 7885 +4102 8541 +4103 7739 +4103 7142 +4103 9033 +4103 7466 +4103 5646 +4103 4431 +4103 7898 +4103 6587 +4103 5531 +4103 7422 +4103 5919 +4104 9006 +4104 5800 +4104 7980 +4104 9802 +4104 5964 +4104 5869 +4104 6478 +4104 9299 +4104 4148 +4104 5257 +4104 8698 +4104 5787 +4104 9758 +4105 9698 +4105 6309 +4105 8646 +4105 9799 +4105 5640 +4105 6085 +4105 7981 +4105 5455 +4105 5616 +4105 4657 +4105 8466 +4105 7086 +4105 8666 +4105 9903 +4105 5343 +4106 5984 +4106 8315 +4106 8676 +4106 5255 +4106 9736 +4106 4910 +4106 8189 +4106 9523 +4106 4724 +4106 8891 +4106 9021 +4107 6721 +4107 9605 +4107 7793 +4107 8456 +4107 4234 +4107 8623 +4107 6481 +4107 5662 +4107 7672 +4107 9278 +4108 7008 +4108 9060 +4108 6981 +4108 9639 +4108 9384 +4108 6988 +4108 5421 +4108 7790 +4108 7249 +4108 5961 +4108 8371 +4108 8393 +4108 4570 +4108 4383 +4109 4353 +4109 9612 +4109 5390 +4109 7188 +4109 8346 +4109 4644 +4109 5669 +4109 8636 +4109 4163 +4109 6472 +4109 6732 +4109 6613 +4109 7136 +4109 6763 +4109 7934 +4110 7951 +4110 7066 +4110 6050 +4110 8103 +4110 7981 +4110 4919 +4110 4935 +4110 8915 +4110 8412 +4110 7394 +4110 6759 +4111 9836 +4111 9772 +4111 6317 +4111 6995 +4111 8271 +4111 9009 +4111 5074 +4111 9395 +4111 6575 +4111 6873 +4111 4730 +4111 7551 +4111 9759 +4112 4576 +4112 9476 +4112 6757 +4112 5993 +4112 9581 +4112 7438 +4112 5871 +4112 8628 +4112 5014 +4112 4444 +4112 4810 +4112 4223 +4113 6016 +4113 9733 +4113 6253 +4113 8342 +4113 9190 +4113 6427 +4113 5276 +4113 9640 +4113 4787 +4113 9541 +4113 7759 +4113 7890 +4113 9358 +4113 8921 +4113 4191 +4113 8420 +4113 4838 +4113 6761 +4113 6130 +4114 6491 +4114 7044 +4114 7782 +4114 6952 +4114 9453 +4114 7326 +4114 7856 +4114 7107 +4114 7796 +4114 6198 +4114 6876 +4114 8254 +4114 7711 +4115 7040 +4115 9993 +4115 9228 +4115 9102 +4115 7456 +4115 9511 +4115 5431 +4115 8252 +4115 9661 +4115 9665 +4115 6602 +4115 9174 +4115 4439 +4115 4315 +4115 5998 +4115 9840 +4115 5622 +4116 8515 +4116 6031 +4116 5382 +4116 9063 +4116 9160 +4116 9833 +4116 9615 +4116 5584 +4116 6756 +4116 4595 +4116 9849 +4117 8096 +4117 8774 +4117 6342 +4117 4614 +4117 7568 +4117 6137 +4117 8987 +4117 9468 +4117 5088 +4118 6146 +4118 6212 +4118 5931 +4118 9839 +4118 7257 +4118 6364 +4118 6270 +4118 6399 +4119 9063 +4119 4523 +4119 4482 +4119 5038 +4119 4186 +4120 9092 +4120 6518 +4120 7334 +4120 6501 +4120 4746 +4120 5357 +4120 9832 +4120 4563 +4120 8469 +4120 9110 +4120 6463 +4121 6656 +4121 9251 +4121 4972 +4121 7661 +4121 7598 +4121 6221 +4121 6544 +4121 4488 +4121 6674 +4121 6243 +4121 7060 +4121 7950 +4121 7963 +4122 6185 +4122 7661 +4122 4413 +4122 7283 +4122 5620 +4122 6899 +4122 4509 +4122 7898 +4122 7323 +4122 6142 +4123 9760 +4123 5040 +4123 9120 +4123 6358 +4123 9096 +4123 8528 +4123 5299 +4123 5750 +4123 4247 +4123 7641 +4123 6362 +4123 6780 +4123 4994 +4123 9637 +4124 9089 +4124 7075 +4124 8178 +4124 8413 +4124 6139 +4124 5116 +4124 7005 +4125 9120 +4125 9195 +4125 8132 +4125 5505 +4125 6313 +4125 7115 +4125 5837 +4125 8528 +4125 8856 +4125 8309 +4125 9658 +4125 6362 +4125 5872 +4126 7106 +4126 9285 +4126 4924 +4126 5816 +4126 5961 +4126 8750 +4126 9585 +4126 4529 +4126 7603 +4126 5561 +4126 9400 +4127 7170 +4127 6820 +4127 5159 +4127 8457 +4127 4203 +4127 8911 +4127 8821 +4127 6102 +4127 7288 +4127 4251 +4127 5788 +4127 7614 +4127 4789 +4128 8969 +4128 8335 +4128 8119 +4128 7519 +4128 4551 +4128 8013 +4128 4305 +4128 5214 +4128 4837 +4128 6766 +4129 7953 +4129 6931 +4129 7322 +4129 6948 +4129 9385 +4129 7093 +4129 6869 +4129 4568 +4129 4323 +4129 6381 +4129 7165 +4129 6782 +4130 7042 +4130 6416 +4130 9628 +4130 9517 +4130 8520 +4130 8276 +4130 9049 +4130 4829 +4130 5392 +4130 5477 +4130 9321 +4130 4471 +4130 6264 +4131 4580 +4131 8517 +4131 8488 +4131 5835 +4131 9879 +4131 8466 +4131 6904 +4131 5881 +4131 8122 +4131 4252 +4131 9118 +4132 5697 +4132 5602 +4132 8840 +4132 4554 +4132 6706 +4132 5224 +4132 4404 +4132 6426 +4132 6334 +4132 7583 +4133 7779 +4133 8396 +4133 6509 +4133 6222 +4133 9645 +4133 5555 +4133 8302 +4133 8346 +4133 6491 +4134 4224 +4134 7170 +4134 7490 +4134 9104 +4134 4246 +4134 8096 +4134 7846 +4134 6320 +4134 7217 +4134 7859 +4134 6584 +4134 5951 +4134 9794 +4134 6479 +4134 7020 +4134 5997 +4134 5489 +4134 6900 +4134 5566 +4134 6266 +4134 6719 +4135 6408 +4135 7914 +4135 4808 +4135 8136 +4135 5939 +4135 6484 +4135 9629 +4135 6879 +4136 5376 +4136 8273 +4136 7334 +4136 8872 +4136 7180 +4136 9213 +4136 9650 +4136 5460 +4136 7226 +4136 8954 +4136 9438 +4136 5429 +4137 5446 +4137 9768 +4137 8974 +4137 5590 +4137 9847 +4137 6874 +4137 6204 +4137 8954 +4138 9934 +4138 4898 +4138 4806 +4138 6737 +4138 6626 +4138 7534 +4138 8765 +4138 8499 +4138 8590 +4138 9685 +4138 6006 +4138 5818 +4138 6395 +4138 7901 +4139 6801 +4139 4883 +4139 8521 +4139 8941 +4139 4753 +4139 6293 +4139 7288 +4139 8605 +4139 5535 +4140 6848 +4140 5698 +4140 7139 +4140 9412 +4140 7048 +4140 6890 +4140 8080 +4140 8977 +4140 6579 +4140 5590 +4140 8746 +4141 9472 +4141 4517 +4141 4902 +4141 6834 +4141 4578 +4141 7094 +4141 6745 +4141 8314 +4141 6749 +4141 7797 +4142 5478 +4142 9520 +4142 8849 +4142 6037 +4142 7671 +4142 6585 +4142 5499 +4143 8784 +4143 6731 +4143 8390 +4143 9897 +4143 5291 +4143 7565 +4143 7759 +4143 7715 +4143 6151 +4143 6396 +4143 8621 +4144 5764 +4144 9069 +4144 7564 +4144 4877 +4144 4750 +4144 4179 +4144 5140 +4144 7988 +4144 7386 +4144 7067 +4145 7553 +4145 8968 +4145 5869 +4145 5166 +4145 5940 +4145 9159 +4145 7887 +4145 6542 +4145 4445 +4145 5215 +4145 4579 +4145 9197 +4145 5884 +4146 8704 +4146 9097 +4146 4640 +4146 9508 +4146 9253 +4146 4906 +4146 5806 +4146 9401 +4146 9667 +4146 6610 +4146 7511 +4146 8153 +4146 9947 +4146 4317 +4146 4339 +4147 4232 +4147 9226 +4147 9101 +4147 7449 +4147 6203 +4147 9741 +4147 9545 +4147 8141 +4147 9043 +4147 8416 +4147 6498 +4147 4336 +4147 8050 +4147 8439 +4148 5761 +4148 5256 +4148 6537 +4148 9642 +4148 7889 +4148 7219 +4148 4444 +4148 8831 +4149 5890 +4149 8350 +4149 5544 +4149 5302 +4149 4425 +4149 9417 +4149 9930 +4149 9165 +4149 5074 +4149 7390 +4149 4711 +4149 9066 +4149 7663 +4149 8689 +4149 8573 +4150 7555 +4150 7940 +4150 6792 +4150 6161 +4150 5533 +4150 7082 +4150 8881 +4150 4788 +4150 7364 +4150 4691 +4150 8804 +4150 4458 +4150 9579 +4150 7412 +4151 8608 +4151 7329 +4151 6884 +4151 7821 +4151 7056 +4151 5170 +4151 9626 +4151 7866 +4152 5331 +4152 9446 +4152 4489 +4152 9581 +4152 8432 +4152 6371 +4152 6133 +4152 6648 +4152 4313 +4152 5659 +4152 4178 +4153 5021 +4153 7621 +4153 8371 +4153 6709 +4153 9785 +4153 8509 +4153 8510 +4153 9035 +4153 5069 +4153 4302 +4153 5200 +4153 8661 +4153 9963 +4153 4474 +4153 6140 +4154 7068 +4154 8496 +4154 4467 +4154 5047 +4154 4539 +4154 6839 +4154 8652 +4154 9172 +4154 6367 +4154 8307 +4154 6776 +4154 6740 +4154 8955 +4154 9340 +4155 8641 +4155 8773 +4155 8532 +4155 8363 +4155 6988 +4155 9827 +4155 6644 +4155 8252 +4155 7902 +4156 7493 +4156 7783 +4156 6410 +4156 5515 +4156 5421 +4156 5553 +4156 5937 +4157 7131 +4157 4650 +4157 7022 +4157 8978 +4157 4249 +4157 5531 +4157 7388 +4158 5099 +4158 9676 +4158 8558 +4158 4660 +4158 4439 +4158 7736 +4158 6095 +4159 9237 +4159 7468 +4159 5426 +4159 7347 +4159 9910 +4159 8890 +4159 7616 +4159 9928 +4159 9168 +4159 7641 +4159 7386 +4159 8399 +4159 9956 +4159 7143 +4159 6890 +4160 8704 +4160 8324 +4160 6791 +4160 8718 +4160 6547 +4160 4501 +4160 4510 +4160 6818 +4160 8625 +4160 7601 +4160 5687 +4160 9156 +4160 7651 +4160 5348 +4160 8295 +4160 5743 +4160 4984 +4161 6405 +4161 9736 +4161 9198 +4161 5403 +4161 9838 +4161 5031 +4161 6327 +4161 7102 +4161 6873 +4161 6110 +4161 9191 +4161 5614 +4161 8432 +4161 8177 +4161 7285 +4162 4632 +4162 4657 +4162 8299 +4162 6476 +4162 9360 +4162 4338 +4162 6654 +4162 8151 +4162 4568 +4162 8570 +4162 8606 +4163 8771 +4163 6823 +4163 4723 +4163 7309 +4163 8567 +4163 5049 +4163 7806 +4164 8160 +4164 9571 +4164 7077 +4164 6984 +4164 7433 +4164 7400 +4164 5974 +4164 8695 +4164 9917 +4164 7295 +4165 7820 +4165 7454 +4165 6563 +4165 5707 +4165 6735 +4165 4824 +4165 9050 +4165 4449 +4165 7912 +4165 9191 +4165 7532 +4165 8552 +4166 7456 +4166 8387 +4166 9846 +4166 8550 +4166 5387 +4166 7339 +4166 5470 +4166 9878 +4166 9304 +4166 6909 +4166 5406 +4167 8961 +4167 9110 +4167 9246 +4167 8480 +4167 7343 +4167 7089 +4167 6464 +4167 7750 +4167 4958 +4167 5601 +4167 8936 +4167 6906 +4167 9595 +4167 9212 +4168 4224 +4168 7949 +4168 5144 +4168 9236 +4168 8726 +4168 8088 +4168 6184 +4168 6194 +4168 5687 +4168 7865 +4168 9539 +4168 9800 +4168 8522 +4168 9419 +4168 4947 +4168 6260 +4168 6645 +4168 7028 +4169 9494 +4169 7204 +4169 6709 +4169 8133 +4169 9158 +4169 7372 +4169 4432 +4169 6240 +4169 6498 +4169 5604 +4169 4970 +4169 8691 +4170 9282 +4170 9475 +4170 8617 +4170 4684 +4170 7829 +4170 8884 +4170 8821 +4170 6905 +4170 8572 +4170 5213 +4170 6687 +4171 6114 +4171 9443 +4171 6757 +4171 4391 +4171 7522 +4171 5813 +4171 4468 +4171 7221 +4171 7414 +4171 9412 +4171 6394 +4171 6395 +4171 7804 +4171 7966 +4172 6488 +4172 8391 +4172 8553 +4172 8268 +4172 7346 +4172 9647 +4172 5208 +4172 5715 +4172 4819 +4172 4853 +4172 7864 +4173 9251 +4173 8195 +4173 7620 +4173 6401 +4173 5135 +4173 5267 +4173 8180 +4173 8885 +4173 7705 +4173 9677 +4173 4636 +4174 6161 +4174 8739 +4174 4538 +4174 5307 +4174 9663 +4174 7136 +4174 8518 +4174 8649 +4174 9037 +4174 5583 +4174 8017 +4174 7762 +4174 8280 +4174 6758 +4174 7313 +4174 4586 +4174 7408 +4174 7286 +4175 4194 +4175 8644 +4175 4454 +4175 9607 +4175 4650 +4175 6130 +4175 5650 +4175 6100 +4175 7035 +4175 6556 +4176 5121 +4176 9608 +4176 8499 +4176 5148 +4176 7357 +4176 7728 +4176 5363 +4176 9461 +4176 8058 +4176 7131 +4176 9564 +4176 5566 +4177 5383 +4177 7826 +4177 9737 +4177 6506 +4177 4719 +4177 7789 +4177 8765 +4177 8495 +4177 4381 +4177 4856 +4177 9206 +4177 5368 +4177 7131 +4178 4353 +4178 8891 +4178 9893 +4178 9286 +4178 5288 +4178 8427 +4178 6463 +4178 5651 +4178 9989 +4178 7126 +4178 6585 +4178 9403 +4179 8708 +4179 8714 +4179 5260 +4179 5524 +4179 9109 +4179 5275 +4179 5416 +4179 5673 +4179 7210 +4179 4907 +4179 8767 +4179 5059 +4179 7365 +4179 5446 +4179 5862 +4179 7286 +4179 9463 +4179 4989 +4180 7536 +4180 4715 +4180 6728 +4180 8329 +4180 6759 +4180 7220 +4180 6211 +4180 5115 +4180 9980 +4180 7614 +4180 7167 +4181 8351 +4181 6758 +4181 5895 +4181 6984 +4181 8936 +4181 5709 +4181 9399 +4181 6744 +4181 7290 +4181 9948 +4181 9757 +4181 6751 +4182 6020 +4182 5737 +4182 9084 +4182 8426 +4182 6219 +4182 9037 +4182 6574 +4182 6927 +4182 6216 +4182 6323 +4182 7543 +4182 6556 +4182 9310 +4183 5505 +4183 7178 +4183 8334 +4183 6552 +4183 8611 +4183 7337 +4183 4233 +4183 7225 +4183 4362 +4183 4550 +4183 5074 +4183 6117 +4183 9078 +4183 8442 +4184 8802 +4184 7331 +4184 9028 +4184 5865 +4184 9706 +4184 7692 +4184 6288 +4184 5362 +4184 9653 +4184 8826 +4184 5685 +4185 8640 +4185 4923 +4185 7077 +4185 6549 +4185 7896 +4185 4474 +4185 9979 +4185 8181 +4186 5761 +4186 5915 +4186 7204 +4186 4267 +4186 7853 +4186 9886 +4186 6330 +4186 4677 +4186 8922 +4186 7390 +4186 7137 +4186 5098 +4186 8951 +4187 8452 +4187 9096 +4187 7977 +4187 9519 +4187 6085 +4187 5449 +4187 7754 +4187 8523 +4187 8144 +4187 5593 +4187 4967 +4187 8690 +4187 9590 +4188 9091 +4188 7303 +4188 6280 +4188 7435 +4188 4494 +4188 5777 +4188 9493 +4188 4886 +4188 5399 +4188 4642 +4188 8491 +4188 9055 +4188 7112 +4188 5471 +4188 8019 +4188 6612 +4188 8290 +4189 8861 +4189 7200 +4189 9896 +4189 9263 +4189 7282 +4189 9366 +4189 7895 +4189 8538 +4189 6621 +4190 4359 +4190 5655 +4190 7833 +4190 4252 +4190 8865 +4190 5940 +4190 5022 +4190 9406 +4190 4678 +4190 7752 +4190 6995 +4190 6357 +4190 7781 +4190 7144 +4190 4713 +4190 7532 +4190 8829 +4190 5887 +4191 9601 +4191 9879 +4191 6935 +4191 9502 +4191 8993 +4191 5288 +4191 4680 +4191 9650 +4191 9118 +4191 4676 +4191 5318 +4191 4423 +4191 5193 +4191 8141 +4191 4433 +4191 4951 +4191 7644 +4191 4957 +4191 5482 +4191 5356 +4192 7431 +4192 6282 +4192 8589 +4192 9645 +4192 8979 +4192 7317 +4192 8224 +4192 8866 +4192 6444 +4192 8768 +4192 7127 +4192 7001 +4192 5594 +4192 6363 +4192 8156 +4192 9068 +4192 7668 +4193 7200 +4193 4386 +4193 5923 +4193 7524 +4193 4876 +4193 5805 +4193 8461 +4193 7299 +4193 9173 +4193 7193 +4193 6201 +4193 7356 +4194 8968 +4194 8329 +4194 7179 +4194 7594 +4194 9520 +4194 5553 +4194 8501 +4194 4792 +4194 9277 +4194 8117 +4194 4686 +4194 4324 +4194 9589 +4194 8828 +4194 4221 +4195 6369 +4195 9058 +4195 8227 +4195 7269 +4195 4486 +4195 5761 +4195 9256 +4195 7435 +4195 7660 +4195 6886 +4195 6227 +4195 7843 +4195 7320 +4195 5406 +4195 8589 +4196 7163 +4196 9195 +4196 5133 +4196 5934 +4196 6765 +4196 7281 +4196 5745 +4196 4504 +4196 7871 +4197 6176 +4197 9675 +4197 6726 +4197 7015 +4197 7082 +4197 5831 +4197 5743 +4197 7998 +4197 6170 +4197 8335 +4197 6074 +4198 9731 +4198 8840 +4198 6165 +4198 8986 +4198 4896 +4198 7459 +4198 6069 +4198 8246 +4198 4539 +4198 4288 +4198 6855 +4198 5847 +4198 7265 +4198 9963 +4198 5996 +4198 5756 +4199 5953 +4199 4438 +4199 8391 +4199 9545 +4199 4727 +4199 5177 +4199 6957 +4199 7537 +4199 9585 +4199 8211 +4199 7861 +4199 8726 +4199 6426 +4199 7963 +4199 9516 +4199 8677 +4200 5893 +4200 7304 +4200 5780 +4200 9768 +4200 6187 +4200 8504 +4200 4679 +4200 5083 +4200 8803 +4200 8805 +4200 4464 +4200 6271 +4201 9408 +4201 7297 +4201 9794 +4201 8865 +4201 7010 +4201 5646 +4201 9303 +4201 5819 +4201 9276 +4202 8864 +4202 7825 +4202 7399 +4202 7405 +4202 9105 +4202 6326 +4202 9464 +4202 9370 +4202 9179 +4202 8108 +4202 5054 +4203 6315 +4203 4232 +4203 8586 +4203 9067 +4203 5827 +4203 9625 +4204 9451 +4204 8358 +4204 8647 +4204 5738 +4204 4651 +4204 6075 +4204 8033 +4204 6289 +4204 4755 +4204 6805 +4204 9855 +4204 8380 +4205 5088 +4205 7491 +4205 6428 +4205 9613 +4205 8881 +4205 8827 +4205 9658 +4205 5228 +4205 9834 +4206 9473 +4206 7181 +4206 4643 +4206 7723 +4206 8260 +4206 8401 +4206 5716 +4206 9442 +4206 7015 +4206 9971 +4206 6654 +4207 7811 +4207 6156 +4207 6030 +4207 6929 +4207 6567 +4207 7731 +4207 6612 +4207 5902 +4207 9438 +4207 8799 +4207 8165 +4207 6637 +4208 9473 +4208 7689 +4208 8085 +4208 4378 +4208 4653 +4208 6447 +4208 4273 +4208 9286 +4208 9423 +4208 9556 +4208 9579 +4208 5996 +4208 4392 +4208 6264 +4209 8772 +4209 9960 +4209 9604 +4209 6992 +4209 6038 +4209 5438 +4209 4886 +4209 6200 +4209 9753 +4209 6526 +4210 8583 +4210 4802 +4210 8462 +4210 6672 +4210 9010 +4210 6718 +4210 7490 +4210 9796 +4210 7624 +4210 9304 +4210 9564 +4210 8290 +4210 5987 +4210 6377 +4210 4334 +4210 8304 +4210 9593 +4210 7162 +4211 9922 +4211 7523 +4211 9310 +4211 9457 +4211 7706 +4211 9563 +4211 9116 +4211 9117 +4212 4489 +4212 9627 +4212 6441 +4212 6702 +4212 7732 +4212 5175 +4212 6464 +4212 6724 +4212 8525 +4212 9806 +4212 5477 +4212 6903 +4213 6017 +4213 9803 +4213 6724 +4213 7004 +4213 6322 +4213 6551 +4213 9496 +4213 5175 +4213 7707 +4213 8156 +4213 9533 +4214 6454 +4214 8005 +4214 6825 +4214 9890 +4214 6479 +4214 5136 +4214 5261 +4214 8991 +4215 5379 +4215 6948 +4215 5990 +4215 6792 +4215 5350 +4215 5356 +4215 8333 +4215 5744 +4215 9171 +4215 5241 +4215 7738 +4215 6971 +4215 6844 +4216 6982 +4216 7495 +4216 4794 +4216 5916 +4216 7858 +4216 7822 +4216 9776 +4216 6739 +4216 6995 +4216 9143 +4216 9434 +4216 4701 +4216 8542 +4217 6691 +4217 9028 +4217 8998 +4217 5963 +4217 6219 +4217 8332 +4217 7373 +4217 6360 +4217 7640 +4217 6811 +4218 5508 +4218 8965 +4218 6930 +4218 7834 +4218 4892 +4218 8234 +4218 5683 +4218 5437 +4218 8772 +4218 5701 +4218 5711 +4218 9042 +4218 7904 +4218 8310 +4218 4474 +4218 7932 +4219 8291 +4219 6657 +4219 7470 +4219 5085 +4219 5681 +4219 4884 +4219 5944 +4219 4996 +4219 9599 +4220 9604 +4220 9096 +4220 5258 +4220 6210 +4220 7700 +4220 8357 +4220 6838 +4220 7095 +4220 4418 +4220 9801 +4220 8017 +4220 6102 +4220 9176 +4220 6771 +4220 8566 +4220 6775 +4220 8186 +4220 8830 +4221 7915 +4221 4974 +4221 4497 +4221 4995 +4221 5176 +4221 5659 +4221 7646 +4222 7393 +4222 8957 +4222 4740 +4222 7223 +4222 5239 +4222 4783 +4222 5265 +4222 6548 +4222 6199 +4222 6922 +4222 9850 +4222 7535 +4222 9054 +4222 6789 +4223 7939 +4223 4876 +4223 9623 +4223 7470 +4223 7741 +4223 9278 +4223 7744 +4223 9910 +4223 5582 +4223 6992 +4223 4314 +4223 9406 +4223 5110 +4223 6522 +4224 6040 +4224 9235 +4224 4974 +4224 6429 +4224 4386 +4224 9766 +4224 5187 +4224 5470 +4224 9578 +4224 6773 +4225 6308 +4225 5771 +4225 5263 +4225 9745 +4225 6301 +4225 6690 +4225 9892 +4225 8361 +4225 5941 +4225 7096 +4225 6084 +4225 9553 +4225 6614 +4225 7269 +4225 6632 +4225 8810 +4225 7033 +4225 4861 +4226 8002 +4226 4229 +4226 8735 +4226 5991 +4226 4489 +4226 5116 +4226 6382 +4226 9039 +4226 9714 +4226 9429 +4226 8533 +4226 8662 +4226 6423 +4226 4444 +4226 9695 +4227 6716 +4227 9251 +4227 8293 +4227 8588 +4227 6029 +4227 4975 +4227 9983 +4227 8634 +4227 6159 +4227 8031 +4228 4632 +4228 9774 +4228 5687 +4228 8761 +4228 5180 +4228 9661 +4228 6850 +4228 6233 +4228 7007 +4229 6281 +4229 6043 +4229 7339 +4229 8757 +4229 9271 +4229 7742 +4229 8257 +4229 9422 +4229 6506 +4229 7187 +4229 9210 +4229 9215 +4230 8160 +4230 8547 +4230 7046 +4230 8796 +4230 5646 +4230 8118 +4230 9532 +4230 5917 +4231 4994 +4231 4406 +4231 7397 +4231 5672 +4231 4616 +4231 9449 +4231 9127 +4231 5214 +4231 7888 +4231 6868 +4231 6421 +4231 4325 +4231 6197 +4232 7945 +4232 6297 +4232 5670 +4232 6825 +4232 9394 +4232 8755 +4232 6992 +4232 5474 +4232 4713 +4232 6767 +4232 8681 +4232 8639 +4233 9056 +4233 6955 +4233 4644 +4233 7717 +4233 8232 +4233 6665 +4233 5291 +4233 4366 +4233 8968 +4233 4568 +4233 7075 +4233 8788 +4233 4918 +4233 4472 +4233 5660 +4234 6656 +4234 7169 +4234 6297 +4234 4394 +4234 7424 +4234 5167 +4234 9652 +4234 5049 +4234 9151 +4234 8902 +4234 9687 +4234 5990 +4234 6761 +4234 6507 +4234 9328 +4234 7414 +4234 7289 +4234 7290 +4234 4735 +4235 6091 +4235 9390 +4235 7638 +4235 9727 +4235 6044 +4235 5693 +4235 6974 +4235 6815 +4236 5248 +4236 5636 +4236 9877 +4236 9756 +4236 8733 +4236 6686 +4236 6000 +4236 5286 +4236 7847 +4236 4924 +4236 9801 +4236 7372 +4236 5974 +4236 4958 +4236 9439 +4236 7525 +4236 6777 +4236 5629 +4237 7458 +4237 6915 +4237 5381 +4237 9990 +4237 9033 +4237 6129 +4237 7879 +4237 5359 +4237 6097 +4237 4276 +4237 7729 +4238 5008 +4238 8965 +4238 8729 +4238 6196 +4238 7992 +4238 9268 +4238 9048 +4238 8929 +4238 6503 +4238 9455 +4238 7925 +4238 6911 +4239 7938 +4239 6926 +4239 7440 +4239 5296 +4239 8371 +4239 9801 +4239 4538 +4239 5436 +4239 8125 +4239 6988 +4239 7628 +4239 8908 +4239 6478 +4239 5845 +4239 8156 +4239 4331 +4239 6381 +4239 5238 +4239 7674 +4239 7420 +4240 4250 +4240 9372 +4240 5923 +4240 7077 +4240 5031 +4240 9002 +4240 7085 +4240 4658 +4240 7351 +4240 6717 +4240 4420 +4240 6341 +4240 9164 +4240 6479 +4240 9812 +4240 8920 +4240 9067 +4240 5491 +4240 4598 +4240 6905 +4241 6337 +4241 9766 +4241 6443 +4241 9871 +4241 7568 +4241 9297 +4241 9778 +4241 8143 +4242 7936 +4242 9864 +4242 9234 +4242 4639 +4242 7722 +4242 7967 +4242 7504 +4242 8533 +4242 6885 +4242 9850 +4242 5546 +4243 8642 +4243 6314 +4243 4432 +4243 6834 +4243 8724 +4243 8917 +4243 5979 +4244 8160 +4244 4673 +4244 8387 +4244 9639 +4244 9608 +4244 8683 +4244 4968 +4244 8594 +4244 6195 +4244 7350 +4244 8248 +4244 6169 +4244 9818 +4244 4945 +4244 7263 +4245 4484 +4245 6771 +4245 4776 +4245 5001 +4245 4599 +4245 5677 +4245 8909 +4245 4884 +4245 6327 +4245 8516 +4245 7419 +4245 6844 +4246 5538 +4246 9123 +4246 4422 +4246 8423 +4246 6568 +4246 5738 +4246 6099 +4246 7828 +4246 5239 +4247 6435 +4247 4853 +4247 5637 +4247 8841 +4247 5471 +4248 7393 +4248 4647 +4248 6671 +4248 9970 +4248 8478 +4248 4344 +4248 5118 +4249 6912 +4249 8458 +4249 8722 +4249 7064 +4249 4266 +4249 6443 +4249 8629 +4249 9973 +4249 8266 +4249 8652 +4249 8910 +4249 8917 +4249 5230 +4249 5366 +4250 6274 +4250 8965 +4250 5778 +4250 5025 +4250 4515 +4250 6328 +4250 6472 +4250 4685 +4250 4441 +4250 8927 +4250 8804 +4250 8684 +4250 5239 +4250 6906 +4251 8395 +4251 6569 +4251 7210 +4251 4841 +4251 4493 +4251 7120 +4251 4377 +4251 8725 +4251 8330 +4251 7735 +4251 5240 +4251 7999 +4251 9916 +4251 4958 +4252 8579 +4252 6154 +4252 7199 +4252 5792 +4252 9530 +4252 8507 +4252 4490 +4252 6592 +4252 7328 +4252 5447 +4252 4425 +4252 9679 +4252 6097 +4252 5595 +4252 7483 +4252 7669 +4253 6657 +4253 4989 +4253 5836 +4253 5258 +4253 5612 +4253 8143 +4253 6896 +4253 9681 +4253 4443 +4253 6205 +4253 8637 +4254 8336 +4254 5313 +4254 6953 +4254 4385 +4254 7600 +4254 5364 +4254 4373 +4254 4713 +4254 7504 +4255 7297 +4255 4737 +4255 7063 +4255 6798 +4255 7967 +4255 9121 +4255 8101 +4255 9787 +4255 7249 +4255 9561 +4255 9965 +4255 7407 +4255 4338 +4256 4739 +4256 6534 +4256 4380 +4256 8862 +4256 7981 +4256 9903 +4256 7600 +4256 7607 +4256 7251 +4256 4703 +4256 9699 +4256 6373 +4256 7143 +4256 7666 +4256 6910 +4257 4320 +4257 6405 +4257 8305 +4257 4663 +4257 7540 +4257 4533 +4257 9238 +4257 6007 +4257 5127 +4257 7289 +4257 8410 +4257 7931 +4257 5468 +4258 6480 +4258 4836 +4258 8197 +4258 6759 +4258 4778 +4258 9103 +4258 6576 +4258 5915 +4259 7552 +4259 4490 +4259 9742 +4259 4654 +4259 5038 +4259 5428 +4259 5302 +4259 6469 +4259 7024 +4260 4867 +4260 8725 +4260 6295 +4260 7196 +4260 7593 +4260 6969 +4260 9788 +4260 6216 +4260 6474 +4260 8013 +4260 4695 +4260 6365 +4260 9823 +4260 9452 +4260 6765 +4260 6649 +4260 4734 +4261 4598 +4261 4551 +4261 9133 +4261 4334 +4261 7249 +4261 9236 +4261 5878 +4261 4279 +4261 8858 +4262 8387 +4262 4485 +4262 7601 +4262 7320 +4262 6682 +4263 8275 +4263 6787 +4263 4323 +4263 9716 +4263 4276 +4263 6614 +4263 9987 +4264 5056 +4264 7851 +4264 8742 +4264 6927 +4264 8816 +4264 4771 +4264 6709 +4264 8505 +4264 4411 +4265 9104 +4265 5680 +4265 6306 +4265 8195 +4265 5288 +4265 4908 +4265 9930 +4265 4467 +4265 5808 +4265 5305 +4265 4732 +4265 8126 +4265 7327 +4266 5537 +4266 8686 +4266 5908 +4266 9350 +4266 4652 +4266 9133 +4266 4432 +4266 9107 +4266 5983 +4266 8764 +4267 6539 +4267 5527 +4267 6699 +4267 6957 +4267 9269 +4267 5953 +4267 8900 +4267 4808 +4267 9933 +4267 4820 +4267 5206 +4267 5849 +4267 7535 +4268 7683 +4268 9025 +4268 8495 +4268 8360 +4268 5297 +4268 5875 +4268 9396 +4268 7166 +4268 4911 +4268 7900 +4268 5470 +4268 5407 +4269 4882 +4269 6572 +4269 6840 +4269 5186 +4269 9287 +4269 5462 +4269 5985 +4269 7531 +4269 5356 +4269 4973 +4269 7027 +4269 8442 +4270 4372 +4270 4999 +4270 4845 +4270 9969 +4270 5427 +4270 7252 +4270 4722 +4270 6105 +4271 7173 +4271 5177 +4271 7887 +4271 9546 +4271 6741 +4271 7382 +4271 4823 +4271 7227 +4271 8990 +4271 8191 +4272 5602 +4272 4771 +4272 5316 +4272 7560 +4272 5291 +4272 6285 +4272 4784 +4272 6227 +4272 6516 +4272 7610 +4272 8156 +4272 9278 +4273 7786 +4273 4331 +4273 8236 +4273 5453 +4273 5773 +4273 6133 +4273 7062 +4273 6967 +4273 8826 +4273 6591 +4273 8094 +4273 8543 +4274 5248 +4274 4485 +4274 8387 +4274 9112 +4274 9626 +4274 6683 +4274 7685 +4274 8688 +4274 8362 +4274 7990 +4274 4791 +4274 5184 +4274 7875 +4274 9306 +4274 4976 +4274 4978 +4274 5501 +4275 8839 +4275 6050 +4275 9969 +4275 5803 +4275 7229 +4275 5960 +4275 6092 +4275 7587 +4275 5223 +4275 7536 +4275 9201 +4276 4577 +4276 6946 +4276 5860 +4276 5052 +4276 8458 +4276 4427 +4276 6611 +4276 8142 +4276 8148 +4276 6446 +4276 8461 +4276 6073 +4276 9148 +4277 8227 +4277 8163 +4277 7807 +4277 7011 +4277 4915 +4277 6840 +4277 9339 +4277 7967 +4278 9216 +4278 4483 +4278 8932 +4278 5350 +4278 5641 +4278 5833 +4278 5391 +4278 8536 +4278 6276 +4279 6151 +4279 5512 +4279 5146 +4279 8606 +4279 5279 +4279 7982 +4279 8763 +4279 9407 +4279 9305 +4279 7008 +4279 7138 +4279 7660 +4279 9328 +4279 9336 +4280 5696 +4280 6421 +4280 5416 +4280 7625 +4280 8023 +4280 5390 +4280 7224 +4280 8101 +4280 6117 +4280 6974 +4281 6986 +4281 7372 +4281 4749 +4281 8334 +4281 9972 +4281 6965 +4281 7830 +4281 6708 +4281 5242 +4281 8180 +4282 6149 +4282 9877 +4282 5915 +4282 9374 +4282 5445 +4282 7081 +4282 7221 +4282 8631 +4282 6859 +4282 9947 +4282 7392 +4282 9340 +4282 7977 +4283 6244 +4283 8934 +4283 7399 +4283 5900 +4283 4562 +4283 7669 +4283 7228 +4283 4605 +4283 9630 +4284 4932 +4284 5404 +4284 6688 +4284 9286 +4284 8361 +4284 9514 +4284 6315 +4284 5444 +4284 7240 +4284 7124 +4284 5213 +4284 4836 +4284 9276 +4284 4460 +4285 4707 +4285 4295 +4285 5514 +4285 4519 +4285 4910 +4285 7933 +4285 8925 +4286 5696 +4286 7041 +4286 5798 +4286 9544 +4286 4521 +4286 4298 +4286 5646 +4286 5296 +4286 6419 +4286 4601 +4286 8187 +4286 5886 +4287 5384 +4287 7817 +4287 8854 +4287 7853 +4287 5807 +4287 9951 +4287 5311 +4287 6156 +4287 9291 +4287 6477 +4287 9426 +4287 6751 +4287 7527 +4287 9454 +4287 7804 +4288 8704 +4288 8678 +4288 6662 +4288 9257 +4288 5261 +4288 6702 +4288 6671 +4288 7537 +4288 6583 +4288 9144 +4288 5529 +4288 7119 +4288 5855 +4289 9348 +4289 8619 +4289 4536 +4289 8250 +4289 5820 +4289 4801 +4289 8773 +4289 6218 +4289 8293 +4289 7271 +4289 6890 +4289 5367 +4290 5890 +4290 5280 +4290 8246 +4290 7361 +4290 6728 +4290 5072 +4290 9947 +4290 6236 +4290 9441 +4290 4725 +4291 5536 +4291 6756 +4291 5910 +4291 7491 +4291 6001 +4291 7443 +4291 5049 +4291 9209 +4291 6075 +4291 5533 +4292 5837 +4292 8373 +4292 6849 +4292 8809 +4292 8263 +4292 8815 +4292 6448 +4292 9298 +4292 9459 +4292 8949 +4292 5114 +4292 7004 +4293 4810 +4293 6379 +4293 9363 +4293 7606 +4293 6430 +4294 8976 +4294 9353 +4294 6443 +4294 8940 +4294 7085 +4294 7630 +4294 4348 +4294 5718 +4294 7923 +4294 7700 +4294 9852 +4295 8192 +4295 7449 +4295 7962 +4295 4634 +4295 9842 +4295 4533 +4295 6073 +4295 8001 +4295 5319 +4295 6088 +4295 9939 +4295 9559 +4295 4838 +4295 6508 +4295 7922 +4295 5331 +4296 8259 +4296 9351 +4296 5070 +4296 6473 +4296 7819 +4296 7587 +4296 9998 +4296 6525 +4296 5457 +4296 7578 +4296 4956 +4296 4541 +4296 9406 +4297 7849 +4297 8618 +4297 5612 +4297 9750 +4297 6569 +4297 7768 +4297 6938 +4297 4394 +4297 5898 +4298 8542 +4298 6225 +4298 6342 +4298 9799 +4298 9800 +4298 9386 +4298 8972 +4298 6573 +4298 8562 +4298 7925 +4298 9961 +4298 6808 +4298 7674 +4298 9834 +4299 8321 +4299 5668 +4299 6662 +4299 4359 +4299 5705 +4299 6446 +4299 9939 +4299 9697 +4299 5289 +4299 8027 +4299 6070 +4300 5817 +4300 5666 +4300 7080 +4300 6825 +4300 6289 +4300 7955 +4300 8297 +4300 5338 +4300 6035 +4301 6601 +4301 5412 +4301 8916 +4301 5365 +4301 6428 +4301 5687 +4301 8796 +4301 7627 +4302 4641 +4302 7620 +4302 8679 +4302 5067 +4302 7442 +4302 7796 +4302 4750 +4302 5206 +4302 5464 +4302 4633 +4302 7387 +4302 6718 +4303 8736 +4303 9173 +4303 8781 +4303 7150 +4303 6736 +4303 4889 +4303 7002 +4303 5343 +4304 5138 +4304 7324 +4304 9892 +4304 5798 +4304 8368 +4304 6582 +4304 4666 +4304 5820 +4304 7491 +4304 6732 +4304 6612 +4304 7900 +4304 8043 +4305 5421 +4305 6846 +4305 6064 +4305 5147 +4305 6061 +4305 4528 +4305 5791 +4305 4926 +4305 6976 +4305 4682 +4305 5458 +4305 8295 +4305 4721 +4305 7029 +4306 6565 +4306 4870 +4306 7905 +4306 5961 +4306 6510 +4306 9006 +4306 5973 +4306 6235 +4306 6972 +4306 4926 +4306 4473 +4307 7265 +4307 7723 +4307 7748 +4307 8263 +4307 8324 +4307 7964 +4308 9728 +4308 5256 +4308 5152 +4308 8755 +4308 7998 +4308 6468 +4308 5065 +4308 7115 +4308 6221 +4308 6236 +4308 8422 +4308 4841 +4309 6177 +4309 8131 +4309 9412 +4309 6567 +4309 9101 +4309 6314 +4309 9277 +4309 5389 +4309 9743 +4309 5853 +4309 7829 +4309 6834 +4309 5305 +4309 7572 +4310 4994 +4310 4491 +4310 8233 +4310 8202 +4310 8042 +4310 8502 +4310 6392 +4310 5579 +4310 7613 +4311 4998 +4311 6855 +4311 8009 +4311 4554 +4311 5291 +4311 6799 +4311 4977 +4311 7893 +4311 8457 +4311 8698 +4312 5895 +4312 9910 +4312 9023 +4312 6080 +4312 6730 +4312 7758 +4312 5968 +4312 8788 +4312 8922 +4313 9761 +4313 7618 +4313 9445 +4313 6828 +4313 5582 +4313 9359 +4313 7217 +4313 4431 +4313 9907 +4313 4665 +4314 9185 +4314 4740 +4314 6582 +4314 4513 +4314 8581 +4314 7305 +4314 8722 +4314 8180 +4314 5078 +4314 8969 +4314 8595 +4314 7007 +4315 7304 +4315 9488 +4315 5777 +4315 6426 +4315 6641 +4315 9361 +4315 6965 +4315 7607 +4315 7480 +4315 5726 +4315 7792 +4315 6654 +4315 7550 +4316 8080 +4316 7058 +4316 6166 +4316 8153 +4316 7833 +4316 7451 +4316 5178 +4316 9205 +4316 6474 +4316 9807 +4316 9940 +4316 7385 +4316 9699 +4316 7781 +4316 5223 +4316 6633 +4316 9324 +4316 5236 +4316 8309 +4316 7166 +4317 6788 +4317 9746 +4317 5141 +4317 4379 +4317 5662 +4317 6949 +4317 5421 +4317 7773 +4317 8916 +4317 9942 +4317 5853 +4317 6504 +4317 4591 +4317 4986 +4318 4720 +4318 9179 +4318 6954 +4318 8908 +4318 8627 +4318 8813 +4318 6227 +4318 7316 +4318 4981 +4318 4728 +4318 4859 +4318 8635 +4318 8767 +4319 7175 +4319 9693 +4319 8969 +4319 6956 +4319 4701 +4319 8274 +4319 5363 +4319 8858 +4319 9967 +4319 5309 +4320 8832 +4320 4898 +4320 6854 +4320 9033 +4320 8205 +4320 8909 +4320 8691 +4320 7637 +4320 8553 +4320 8393 +4321 6790 +4321 8257 +4321 9995 +4321 5133 +4321 4495 +4321 7701 +4321 5400 +4321 8865 +4321 6438 +4321 8501 +4321 9404 +4321 8385 +4321 7874 +4321 9926 +4321 5577 +4321 5591 +4321 7129 +4321 4446 +4321 4586 +4322 4863 +4322 9441 +4322 7330 +4322 6053 +4322 8198 +4322 6441 +4322 7298 +4322 8125 +4322 5105 +4322 9173 +4322 7158 +4322 6945 +4322 7260 +4322 9789 +4322 8479 +4323 5516 +4323 7505 +4323 7219 +4323 8656 +4323 8855 +4323 5273 +4323 5333 +4324 6893 +4324 6951 +4324 5417 +4324 6060 +4324 7854 +4324 8879 +4324 6970 +4324 6603 +4324 8014 +4324 6735 +4324 6235 +4324 7277 +4324 8943 +4325 8712 +4325 9994 +4325 4872 +4325 7567 +4325 8468 +4325 9374 +4325 6433 +4325 9009 +4325 7859 +4325 8252 +4325 8458 +4325 5568 +4325 8609 +4325 8650 +4325 5263 +4325 7656 +4325 5100 +4325 8046 +4325 5362 +4325 9598 +4326 9825 +4326 8194 +4326 9747 +4326 8581 +4326 7654 +4326 6665 +4326 7589 +4326 5703 +4326 5804 +4326 5421 +4326 7214 +4326 5136 +4326 8051 +4326 9045 +4326 6810 +4326 8807 +4327 5997 +4327 7976 +4327 5806 +4327 6009 +4327 9104 +4327 9015 +4327 7572 +4327 5909 +4327 8854 +4327 4695 +4327 7775 +4328 5637 +4328 7280 +4328 8484 +4328 5286 +4328 5291 +4328 8384 +4328 9031 +4328 8650 +4328 6478 +4328 8164 +4328 4860 +4328 9470 +4329 6921 +4329 9485 +4329 9614 +4329 9490 +4329 8609 +4329 4518 +4329 8363 +4329 7984 +4329 7613 +4329 7634 +4329 8918 +4329 8154 +4329 5736 +4329 9961 +4329 8811 +4329 5247 +4329 5503 +4330 7942 +4330 6808 +4330 8618 +4330 9039 +4330 7895 +4330 7866 +4330 9194 +4330 7034 +4330 6911 +4331 4962 +4331 9221 +4331 5256 +4331 6667 +4331 7747 +4331 9942 +4331 7476 +4331 8506 +4331 8005 +4332 4899 +4332 9948 +4332 9383 +4332 5097 +4332 9488 +4332 5658 +4332 7772 +4333 6656 +4333 6146 +4333 4587 +4333 6810 +4333 6047 +4333 7213 +4333 6574 +4333 7144 +4333 9579 +4333 7029 +4333 5750 +4334 4800 +4334 9792 +4334 5602 +4334 5121 +4334 9929 +4334 7531 +4334 9900 +4334 8877 +4334 6862 +4334 8656 +4334 6417 +4334 9204 +4334 6537 +4334 7684 +4334 6970 +4335 4368 +4335 7575 +4335 9498 +4335 9626 +4335 4384 +4335 5922 +4335 8105 +4335 9905 +4335 7104 +4335 5448 +4335 9694 +4335 7907 +4335 6898 +4335 7673 +4336 4620 +4336 5908 +4336 5654 +4336 4381 +4336 6179 +4336 5672 +4336 5689 +4336 8770 +4336 9176 +4336 5853 +4336 8670 +4336 4840 +4336 4468 +4336 6525 +4337 6660 +4337 9236 +4337 4373 +4337 7330 +4337 9897 +4337 7093 +4337 6724 +4337 9680 +4337 9451 +4337 5231 +4337 5492 +4337 8827 +4338 5891 +4338 8501 +4338 6924 +4338 9646 +4338 5167 +4338 8785 +4338 5362 +4338 6164 +4338 4725 +4338 7414 +4339 8332 +4339 8333 +4339 8592 +4339 5535 +4339 8996 +4339 8620 +4339 9518 +4339 6962 +4339 8883 +4339 8123 +4339 7744 +4339 7878 +4339 8269 +4339 4828 +4339 7524 +4339 9703 +4339 5105 +4339 8695 +4340 7744 +4340 7948 +4340 7713 +4340 9136 +4340 9277 +4340 6080 +4340 7286 +4340 8775 +4340 5977 +4340 4702 +4340 6626 +4340 7907 +4340 9713 +4340 8438 +4340 6263 +4340 5627 +4341 8219 +4341 6796 +4341 6767 +4341 7797 +4341 4435 +4341 5974 +4341 7575 +4341 6931 +4341 5755 +4341 4376 +4342 9121 +4342 9922 +4342 7108 +4342 5478 +4342 9339 +4342 7212 +4342 7522 +4342 7119 +4342 7251 +4342 8899 +4342 6165 +4342 4580 +4342 7834 +4342 9983 +4343 7136 +4343 9792 +4343 6434 +4343 5057 +4343 4768 +4343 7438 +4343 6803 +4343 6742 +4343 6809 +4343 8319 +4343 8796 +4343 5343 +4343 5983 +4344 6794 +4344 8976 +4344 5531 +4344 8993 +4344 6342 +4344 7508 +4344 7774 +4344 7519 +4344 8420 +4344 7783 +4344 8691 +4344 4713 +4345 5467 +4345 5063 +4345 8535 +4345 8140 +4345 5934 +4345 6863 +4345 5518 +4345 7063 +4345 5053 +4346 5186 +4346 5795 +4346 7012 +4346 5703 +4346 8816 +4346 9656 +4346 7252 +4346 9713 +4346 9430 +4346 8329 +4346 7770 +4346 9886 +4346 9061 +4347 9691 +4347 9352 +4347 7882 +4347 9037 +4347 7182 +4347 9841 +4347 7189 +4347 8023 +4347 7476 +4348 4491 +4348 6801 +4348 6545 +4348 8223 +4348 7489 +4348 8133 +4348 4938 +4348 9550 +4348 5583 +4348 5234 +4348 5110 +4348 6137 +4349 7259 +4349 8332 +4349 5518 +4349 8802 +4349 7576 +4349 6041 +4349 7098 +4350 9568 +4350 8032 +4350 5156 +4350 9153 +4350 6176 +4350 9198 +4350 7700 +4350 9367 +4350 7421 +4351 5763 +4351 9222 +4351 5607 +4351 5492 +4351 6378 +4351 4622 +4351 6232 +4351 8020 +4351 5812 +4351 9626 +4351 4735 +4351 6525 +4352 7041 +4352 4750 +4352 8723 +4352 7965 +4352 9247 +4352 8225 +4352 9506 +4352 5027 +4352 4773 +4352 8999 +4352 7726 +4352 7605 +4352 8886 +4352 5953 +4352 7490 +4352 9037 +4352 5344 +4352 4712 +4352 7924 +4353 7296 +4353 9234 +4353 7829 +4353 4996 +4353 7590 +4353 7592 +4353 4662 +4353 5687 +4353 8650 +4353 5582 +4353 8654 +4353 6487 +4353 6882 +4353 9188 +4353 6633 +4353 5865 +4354 9291 +4354 6479 +4354 9302 +4354 5627 +4354 9724 +4355 9749 +4355 5142 +4355 9754 +4355 7332 +4355 4538 +4355 5307 +4355 9150 +4355 8138 +4355 9455 +4355 5361 +4355 5753 +4355 7037 +4356 8352 +4356 5799 +4356 7912 +4356 8320 +4356 9585 +4356 7250 +4357 6618 +4357 5827 +4357 8989 +4357 6757 +4357 9462 +4357 9615 +4357 6198 +4357 4730 +4357 7903 +4358 4587 +4358 9186 +4358 9735 +4358 7150 +4358 7147 +4358 9838 +4358 9039 +4358 9776 +4358 8177 +4358 4853 +4358 9492 +4358 8597 +4358 7417 +4358 6235 +4358 9884 +4358 7925 +4359 7172 +4359 5259 +4359 6164 +4359 8470 +4359 8528 +4359 9308 +4359 7018 +4359 9835 +4360 5200 +4360 7819 +4360 7076 +4360 6085 +4360 8585 +4360 5738 +4360 7534 +4360 9972 +4360 9621 +4360 5688 +4360 6105 +4360 6492 +4360 4446 +4361 9920 +4361 9436 +4361 6483 +4361 9614 +4361 6417 +4361 7955 +4361 7574 +4361 7959 +4361 4763 +4361 7582 +4362 9461 +4362 4437 +4362 9962 +4362 5995 +4362 7399 +4362 4465 +4362 6962 +4362 7251 +4362 4501 +4362 7901 +4362 9653 +4363 6721 +4363 5091 +4363 9830 +4363 5735 +4363 4810 +4363 6728 +4363 7094 +4363 8472 +4363 6393 +4364 5125 +4364 7814 +4364 5770 +4364 7341 +4364 8817 +4364 9458 +4364 8277 +4364 6710 +4364 6713 +4364 8441 +4364 7866 +4364 5429 +4364 6557 +4365 8461 +4365 6546 +4365 8983 +4365 7846 +4365 9387 +4365 5293 +4365 6848 +4365 9290 +4365 7628 +4365 9428 +4365 9173 +4365 7909 +4365 9574 +4365 7441 +4365 7281 +4365 4467 +4365 4863 +4366 4864 +4366 9965 +4366 7687 +4366 8349 +4366 8226 +4366 8102 +4366 4781 +4366 7086 +4366 6707 +4366 4788 +4366 6719 +4366 9293 +4366 6994 +4366 8275 +4366 6868 +4366 6485 +4366 4841 +4366 8437 +4367 7329 +4367 7207 +4367 5564 +4367 6462 +4367 9023 +4367 6596 +4367 6868 +4367 6114 +4367 9960 +4367 9962 +4367 8816 +4367 6001 +4367 7670 +4368 7809 +4368 5190 +4368 9292 +4368 6477 +4368 6095 +4368 5072 +4368 4785 +4368 9268 +4368 6505 +4368 5369 +4369 9091 +4369 7304 +4369 6940 +4369 9629 +4369 7090 +4369 8500 +4369 7105 +4369 9157 +4369 9652 +4369 6355 +4369 8928 +4369 6516 +4369 5370 +4370 9428 +4370 8776 +4370 7177 +4370 8139 +4370 4396 +4370 4500 +4370 9529 +4371 8944 +4371 5030 +4371 5457 +4371 9130 +4371 8235 +4371 5036 +4371 6126 +4371 5182 +4371 6231 +4371 6107 +4371 5374 +4372 8763 +4372 5910 +4372 6516 +4372 9494 +4372 5979 +4372 7038 +4372 9183 +4373 5495 +4373 6634 +4373 7723 +4373 8546 +4373 8239 +4373 6834 +4373 5107 +4373 7348 +4373 5063 +4373 6313 +4373 4473 +4373 7641 +4373 9994 +4374 8224 +4374 9836 +4374 5350 +4374 9031 +4374 8492 +4374 6091 +4374 5452 +4374 7761 +4374 4730 +4374 8123 +4374 4637 +4374 9447 +4375 8321 +4375 5658 +4375 4811 +4375 8461 +4375 6360 +4375 8406 +4375 5432 +4375 6234 +4375 4924 +4375 4639 +4376 9537 +4376 5922 +4376 5220 +4376 7621 +4376 5441 +4376 5610 +4376 7470 +4376 8561 +4376 6483 +4376 6779 +4376 8727 +4376 7962 +4376 8634 +4376 9541 +4377 5641 +4377 7945 +4377 9874 +4377 7451 +4377 8480 +4377 5298 +4377 9404 +4377 6975 +4377 5957 +4377 4554 +4377 4823 +4377 5232 +4377 8178 +4378 6620 +4378 7466 +4378 8941 +4378 6417 +4378 8851 +4378 5645 +4378 9534 +4379 8385 +4379 6754 +4379 5347 +4379 9348 +4379 9447 +4379 9532 +4379 4903 +4379 7859 +4379 5880 +4379 8474 +4379 4796 +4379 6602 +4380 5028 +4380 9130 +4380 6705 +4380 8522 +4380 9547 +4380 9612 +4380 9485 +4380 9711 +4380 4758 +4380 4599 +4380 6724 +4380 7708 +4380 7242 +4381 7025 +4381 5486 +4381 8397 +4381 4559 +4381 8689 +4381 4789 +4381 7798 +4381 9337 +4381 5273 +4381 5882 +4381 6300 +4382 7172 +4382 8846 +4382 5147 +4382 6300 +4382 4388 +4382 7846 +4382 7343 +4382 5041 +4382 5819 +4382 7308 +4382 9561 +4382 6491 +4382 7542 +4382 6506 +4382 9963 +4382 5238 +4382 4985 +4383 6052 +4383 7813 +4383 6646 +4383 4423 +4383 9165 +4383 8654 +4383 9432 +4383 7300 +4383 9268 +4383 5525 +4383 6806 +4383 8440 +4383 5050 +4383 5470 +4384 6416 +4384 4908 +4384 8551 +4384 6542 +4384 8600 +4384 8622 +4384 5160 +4384 4824 +4384 8730 +4384 4475 +4384 4668 +4384 5839 +4385 6548 +4385 8995 +4385 7332 +4385 5286 +4385 7468 +4385 6993 +4385 6484 +4385 6756 +4385 8566 +4385 7551 +4386 6274 +4386 7179 +4386 9616 +4386 9500 +4386 9018 +4386 4548 +4386 9041 +4386 6998 +4386 8923 +4386 6609 +4386 4972 +4386 6290 +4386 4854 +4387 7076 +4387 8197 +4387 5641 +4387 9935 +4387 8304 +4387 6213 +4387 4533 +4387 5405 +4387 9630 +4388 6145 +4388 7845 +4388 5353 +4388 6252 +4388 9601 +4388 5996 +4388 8820 +4388 8600 +4388 4604 +4389 5762 +4389 6830 +4389 9634 +4389 8272 +4389 7405 +4389 7102 +4389 7799 +4389 7198 +4389 8511 +4390 4489 +4390 7051 +4390 9487 +4390 5906 +4390 8476 +4390 9502 +4390 5545 +4390 7211 +4390 9900 +4390 5427 +4390 4795 +4390 7742 +4390 8908 +4390 7695 +4390 4583 +4390 7660 +4390 5950 +4391 8081 +4391 7836 +4391 4644 +4391 9385 +4391 9002 +4391 4787 +4391 7861 +4391 4800 +4391 4682 +4391 6904 +4391 5230 +4391 9592 +4392 7970 +4392 9028 +4392 7851 +4392 7213 +4392 7982 +4392 4723 +4393 7572 +4393 9007 +4393 9522 +4393 5939 +4393 9289 +4393 6229 +4393 9330 +4393 5879 +4394 5291 +4394 4995 +4394 7705 +4394 8868 +4394 9769 +4394 6443 +4394 9388 +4394 9655 +4394 6841 +4394 4545 +4394 6980 +4394 9543 +4394 6222 +4394 8676 +4394 8037 +4394 5820 +4394 4458 +4394 6902 +4394 6392 +4395 9673 +4395 9196 +4395 9328 +4395 5791 +4396 8075 +4396 8974 +4396 7187 +4396 6422 +4396 6429 +4396 5407 +4396 5416 +4396 6452 +4396 6964 +4396 9027 +4396 4682 +4396 5978 +4396 7546 +4397 9888 +4397 6502 +4397 5705 +4397 6060 +4397 5838 +4397 7613 +4397 9840 +4397 6010 +4397 6655 +4398 6559 +4398 7024 +4398 7732 +4398 9914 +4398 5822 +4398 8645 +4398 4810 +4398 4690 +4398 5077 +4398 5468 +4398 9566 +4398 8944 +4398 7031 +4398 9726 +4399 5315 +4399 8612 +4399 5669 +4399 4998 +4399 8337 +4399 6697 +4399 6507 +4399 4977 +4399 7197 +4399 7934 +4400 9502 +4400 8269 +4400 5966 +4400 7889 +4400 5042 +4400 8919 +4400 5339 +4400 9416 +4401 6464 +4401 4961 +4401 6667 +4401 5318 +4401 8071 +4401 5033 +4401 5931 +4401 5175 +4401 8608 +4401 4759 +4401 7780 +4401 9545 +4401 4894 +4401 5439 +4402 4768 +4402 8806 +4402 8490 +4402 4780 +4402 7214 +4402 8466 +4402 7029 +4402 8695 +4403 6432 +4403 8673 +4403 9955 +4403 4614 +4403 5001 +4403 7918 +4403 9381 +4403 9081 +4403 6265 +4404 7939 +4404 5130 +4404 7695 +4404 6509 +4404 4505 +4404 6043 +4404 7343 +4404 4535 +4404 7351 +4404 9380 +4404 4592 +4404 8305 +4404 8063 +4405 5223 +4405 8435 +4405 8626 +4405 7379 +4405 6934 +4405 9275 +4405 6302 +4406 9217 +4406 8290 +4406 6626 +4406 9070 +4406 6606 +4406 8827 +4406 4930 +4407 5024 +4407 6891 +4407 8422 +4407 8456 +4407 7019 +4407 6284 +4407 5195 +4407 7411 +4407 7068 +4407 6941 +4407 9534 +4407 7231 +4408 9147 +4408 9366 +4408 8558 +4408 7411 +4408 5108 +4408 6709 +4408 7094 +4408 8185 +4408 5503 +4408 8148 +4408 9502 +4409 7441 +4409 9629 +4409 6045 +4409 5930 +4409 8235 +4409 7739 +4409 4939 +4409 6086 +4409 6473 +4409 5707 +4409 6237 +4409 6244 +4409 5629 +4409 9854 +4410 9539 +4410 9545 +4410 6412 +4410 7438 +4410 8751 +4410 9840 +4410 9651 +4410 7862 +4410 8009 +4410 6857 +4410 5755 +4411 9665 +4411 6053 +4411 4935 +4411 5326 +4411 9523 +4411 6740 +4411 7572 +4411 7485 +4412 4668 +4412 6059 +4412 4662 +4412 5435 +4412 7740 +4412 9789 +4412 5055 +4412 5568 +4412 8132 +4412 7499 +4412 7632 +4412 5969 +4412 7122 +4412 8920 +4412 6373 +4412 4979 +4412 6121 +4412 8316 +4413 8737 +4413 8994 +4413 7845 +4413 6086 +4413 8239 +4413 6339 +4413 9910 +4413 8374 +4413 8090 +4413 4735 +4414 8864 +4414 5104 +4414 9571 +4414 9509 +4414 8998 +4414 5761 +4414 5580 +4414 4685 +4414 7023 +4414 6998 +4414 5911 +4414 7354 +4414 4901 +4415 9984 +4415 5280 +4415 9766 +4415 8969 +4415 7146 +4415 5835 +4415 9004 +4415 4685 +4415 8723 +4415 5076 +4415 5430 +4415 9578 +4415 8734 +4415 5151 +4416 7787 +4416 7334 +4416 9324 +4416 8270 +4416 7210 +4416 8851 +4416 9949 +4417 9994 +4417 7441 +4417 4906 +4417 9388 +4417 9913 +4417 5315 +4417 8269 +4417 7503 +4417 8167 +4417 6386 +4417 9080 +4418 6097 +4418 6920 +4418 7800 +4418 6346 +4418 5135 +4418 6739 +4418 4597 +4418 7640 +4419 5056 +4419 5059 +4419 5028 +4419 7077 +4419 7272 +4419 8943 +4419 4852 +4419 9014 +4419 9336 +4420 5020 +4420 9905 +4420 6197 +4420 7095 +4420 6713 +4420 4674 +4420 8271 +4420 5076 +4420 7006 +4420 4960 +4420 8935 +4420 9967 +4420 8959 +4421 9712 +4421 7854 +4421 9509 +4421 9545 +4421 8362 +4421 5963 +4421 5039 +4421 7824 +4421 9042 +4421 9013 +4421 4923 +4421 9693 +4421 6878 +4421 7199 +4422 5378 +4422 6039 +4422 6469 +4422 7841 +4422 7603 +4422 8517 +4422 9415 +4422 8008 +4422 4827 +4422 4714 +4422 7026 +4422 7288 +4422 9977 +4422 5883 +4422 6524 +4422 7166 +4422 6549 +4423 5665 +4423 4578 +4423 9316 +4423 5798 +4423 6375 +4423 6510 +4423 9045 +4423 6646 +4423 6807 +4423 9273 +4423 5178 +4424 9527 +4424 5000 +4424 4909 +4424 8119 +4424 4534 +4424 9348 +4424 9725 +4424 6653 +4424 7391 +4425 5344 +4425 7204 +4425 5004 +4425 9165 +4425 7343 +4425 5969 +4425 6750 +4426 9762 +4426 5507 +4426 8943 +4426 4837 +4426 6097 +4426 5768 +4426 9230 +4426 5771 +4426 5007 +4426 7432 +4426 4979 +4426 6073 +4426 7221 +4427 9686 +4427 7442 +4427 7963 +4427 5918 +4427 7456 +4427 7410 +4427 5556 +4427 4797 +4427 6847 +4427 9286 +4427 8010 +4427 7636 +4427 5334 +4427 9764 +4427 6237 +4427 5204 +4428 5792 +4428 7808 +4428 6651 +4428 7780 +4428 7973 +4428 9934 +4428 8206 +4428 7088 +4428 7410 +4428 4446 +4428 8346 +4428 4927 +4428 8638 +4429 9472 +4429 8406 +4429 7209 +4429 8331 +4429 5616 +4429 9973 +4429 5334 +4429 7451 +4429 7359 +4430 5859 +4430 4614 +4430 5772 +4430 8556 +4430 7597 +4430 8238 +4430 9981 +4430 7313 +4430 6617 +4430 5807 +4431 5441 +4431 7652 +4431 6310 +4431 9190 +4431 8109 +4431 7420 +4431 4786 +4431 6867 +4431 8117 +4431 8157 +4431 6302 +4431 4895 +4432 8384 +4432 9025 +4432 6146 +4432 7217 +4432 4717 +4432 9262 +4432 6065 +4432 8314 +4432 8565 +4432 4672 +4432 6849 +4432 7601 +4433 8322 +4433 8585 +4433 8488 +4433 6110 +4433 9972 +4433 8775 +4433 5072 +4433 5342 +4433 9204 +4434 7841 +4434 8548 +4434 6598 +4434 9642 +4434 9451 +4434 9437 +4434 6998 +4434 5367 +4435 9988 +4435 7447 +4435 4511 +4435 6968 +4435 6214 +4435 8150 +4435 5598 +4435 6883 +4435 9957 +4435 4847 +4436 8929 +4436 8327 +4436 5450 +4436 7326 +4436 6632 +4436 5973 +4436 4889 +4436 8605 +4436 5342 +4437 8096 +4437 4928 +4437 5461 +4437 5736 +4437 7628 +4437 5964 +4437 6368 +4437 9832 +4437 8052 +4437 7989 +4437 8410 +4437 9854 +4437 5695 +4438 6274 +4438 5507 +4438 7184 +4438 6569 +4438 8251 +4438 5190 +4438 8267 +4438 6738 +4438 6999 +4438 7913 +4438 8692 +4438 4991 +4439 8965 +4439 6288 +4439 5777 +4439 5665 +4439 8617 +4439 4907 +4439 9652 +4439 9928 +4439 4939 +4439 5964 +4439 7155 +4439 5749 +4439 8825 +4440 5000 +4440 7107 +4440 5143 +4440 8096 +4440 7594 +4440 8494 +4440 9333 +4440 6467 +4440 8789 +4440 8410 +4440 7521 +4440 6626 +4440 6124 +4440 5749 +4441 9222 +4441 6560 +4441 6704 +4441 4920 +4441 8633 +4441 6459 +4441 8647 +4441 5195 +4441 6368 +4441 5729 +4441 6247 +4441 9713 +4441 9331 +4441 8055 +4442 9244 +4442 7863 +4442 9528 +4442 8400 +4442 9044 +4442 8864 +4442 5993 +4442 4845 +4442 5108 +4442 6761 +4443 5376 +4443 6656 +4443 9097 +4443 8344 +4443 7708 +4443 5544 +4443 7990 +4443 4920 +4443 9658 +4443 7350 +4443 9680 +4443 7121 +4443 9429 +4443 9440 +4443 8178 +4443 5630 +4444 6784 +4444 9433 +4444 9648 +4444 6564 +4444 9520 +4444 6321 +4444 6708 +4444 4446 +4444 5048 +4444 5940 +4444 5715 +4444 6585 +4444 6233 +4444 6382 +4444 6639 +4444 7152 +4444 8955 +4444 9342 +4445 9740 +4445 4511 +4445 6433 +4445 6581 +4445 6459 +4445 9664 +4445 8770 +4445 8005 +4445 8141 +4445 8718 +4445 8666 +4445 7387 +4445 7774 +4445 5563 +4445 7268 +4445 6118 +4445 5650 +4445 5651 +4445 6815 +4446 7078 +4446 6177 +4446 6191 +4446 9437 +4446 8094 +4446 7007 +4447 8610 +4447 8291 +4447 5830 +4447 4514 +4447 6126 +4447 7954 +4448 5889 +4448 9964 +4448 5389 +4448 6799 +4448 9744 +4448 9554 +4448 7223 +4448 8888 +4448 8570 +4448 9053 +4449 5771 +4449 5392 +4449 5658 +4449 8237 +4449 8125 +4449 7371 +4449 8015 +4449 6738 +4449 9939 +4449 6492 +4449 9696 +4449 9313 +4449 5352 +4449 8952 +4449 7422 +4450 7782 +4450 9187 +4450 8249 +4450 8683 +4451 4707 +4451 7428 +4451 7353 +4451 5256 +4451 5979 +4451 9175 +4451 9804 +4451 8903 +4451 5863 +4451 8277 +4451 6231 +4451 9071 +4451 5405 +4452 5729 +4452 4843 +4452 8070 +4452 8296 +4452 6698 +4452 9271 +4452 6989 +4452 5525 +4452 9622 +4452 5210 +4452 8157 +4453 8320 +4453 6917 +4453 7304 +4453 7326 +4453 5024 +4453 6568 +4453 9515 +4453 9812 +4453 4571 +4453 6237 +4453 9438 +4453 7264 +4453 6372 +4453 5100 +4453 5800 +4453 8955 +4454 9824 +4454 5772 +4454 5430 +4454 5222 +4454 9964 +4454 6854 +4454 8446 +4454 9783 +4454 9052 +4454 7357 +4455 8803 +4455 9867 +4455 5507 +4455 9293 +4455 4849 +4455 7839 +4456 8961 +4456 6674 +4456 4590 +4456 8617 +4456 5826 +4456 9782 +4456 9039 +4456 6745 +4456 5083 +4456 9710 +4456 5110 +4457 9153 +4457 5001 +4457 5195 +4457 8318 +4457 6926 +4457 7447 +4457 6172 +4458 9344 +4458 9492 +4458 7834 +4458 7919 +4458 9248 +4458 8610 +4458 7075 +4458 7214 +4458 5552 +4458 8371 +4458 5040 +4458 8528 +4458 7135 +4458 9825 +4458 5476 +4458 7398 +4458 8809 +4458 8043 +4458 5485 +4458 5743 +4458 5623 +4458 4730 +4458 9723 +4459 9477 +4459 7313 +4459 8210 +4459 6299 +4459 7200 +4459 9252 +4459 5801 +4459 5053 +4459 8274 +4459 8404 +4459 8792 +4459 7132 +4459 6751 +4459 5862 +4459 9958 +4459 9969 +4459 5877 +4460 9217 +4460 8739 +4460 5734 +4460 8071 +4460 8327 +4460 8081 +4460 5877 +4460 8645 +4461 7776 +4461 5474 +4461 6469 +4461 9062 +4461 4808 +4461 4649 +4461 7722 +4461 8109 +4461 9679 +4461 8241 +4461 8820 +4461 9272 +4461 8889 +4461 6490 +4461 5797 +4462 9056 +4462 6911 +4462 6193 +4462 8298 +4462 4823 +4462 4877 +4462 5616 +4462 6673 +4462 9870 +4462 6392 +4463 8470 +4463 7718 +4463 4775 +4463 6088 +4463 5227 +4463 7727 +4463 5553 +4463 8243 +4463 8085 +4463 5305 +4463 8379 +4463 6101 +4464 9093 +4464 5766 +4464 4615 +4464 4495 +4464 5511 +4464 8223 +4464 6049 +4464 6182 +4464 6827 +4464 6072 +4464 8639 +4464 5996 +4464 5055 +4465 6918 +4465 6677 +4465 6209 +4465 4941 +4465 9171 +4465 6490 +4465 7657 +4465 9329 +4465 6611 +4465 4471 +4465 5781 +4466 5952 +4466 5220 +4466 7527 +4466 8208 +4466 5336 +4467 6787 +4467 7310 +4467 9498 +4467 6051 +4467 6832 +4467 9843 +4467 5435 +4467 5826 +4467 8393 +4467 7530 +4467 8787 +4467 8575 +4468 7376 +4468 8773 +4468 5030 +4468 5649 +4468 5194 +4468 9579 +4468 7181 +4468 8653 +4468 7033 +4468 5338 +4469 8353 +4469 7779 +4469 5168 +4469 4759 +4469 6182 +4469 9455 +4469 7768 +4469 6264 +4469 7672 +4469 8477 +4469 9853 +4470 5089 +4470 5794 +4470 6693 +4470 4616 +4470 5865 +4470 7832 +4470 9710 +4470 9359 +4470 6353 +4470 4627 +4470 6714 +4470 9321 +4470 8094 +4470 7391 +4471 4674 +4471 9644 +4471 7988 +4471 9321 +4471 4923 +4472 6533 +4472 4497 +4472 6153 +4472 7611 +4472 5181 +4472 9792 +4472 5955 +4472 6342 +4472 8903 +4472 7735 +4472 5068 +4472 4580 +4472 7417 +4472 5370 +4473 8719 +4473 9749 +4473 9075 +4473 5308 +4473 7676 +4473 5610 +4473 4718 +4473 8435 +4473 4860 +4473 7038 +4473 9599 +4474 9815 +4474 9745 +4474 7571 +4474 7449 +4474 5789 +4474 5060 +4474 8023 +4474 8037 +4474 6383 +4474 6896 +4475 9664 +4475 6894 +4475 5998 +4475 4481 +4475 4689 +4475 5045 +4475 7642 +4475 4701 +4476 6854 +4476 6023 +4476 6396 +4476 7847 +4476 5745 +4476 9717 +4477 5519 +4477 7173 +4477 9574 +4477 6387 +4477 6599 +4477 6776 +4477 9268 +4477 6873 +4477 4571 +4477 5726 +4478 7331 +4478 4675 +4478 9956 +4478 6854 +4478 7718 +4478 7405 +4478 4972 +4478 6221 +4478 7855 +4478 5459 +4478 9774 +4478 4937 +4478 8571 +4478 5852 +4478 7581 +4478 9886 +4478 8197 +4479 9093 +4479 5641 +4479 7826 +4479 5788 +4479 5766 +4479 5309 +4479 5182 +4479 4804 +4479 8778 +4479 8556 +4479 9709 +4479 6894 +4479 9457 +4479 8179 +4479 7797 +4479 8826 +4479 5629 +4480 9360 +4480 9497 +4480 4767 +4480 8135 +4480 7263 +4480 6973 +4480 5953 +4480 9157 +4480 9277 +4480 7519 +4480 8976 +4480 6755 +4480 5093 +4480 6255 +4480 9084 +4480 6270 +4481 6018 +4481 8967 +4481 6402 +4481 7960 +4481 8222 +4481 5919 +4481 6181 +4481 7334 +4481 8750 +4481 5167 +4481 6588 +4481 4540 +4481 6250 +4482 6017 +4482 9506 +4482 6507 +4482 5750 +4482 5831 +4482 9579 +4482 5393 +4482 8209 +4482 8673 +4482 6452 +4482 7228 +4482 6842 +4483 8742 +4483 5640 +4483 7820 +4483 7181 +4483 9422 +4483 4567 +4483 5468 +4483 9342 +4484 4743 +4484 9435 +4484 6632 +4484 9670 +4484 9768 +4484 5640 +4484 8203 +4484 6162 +4484 6783 +4484 4816 +4484 9748 +4484 7899 +4484 8988 +4484 4574 +4484 9215 +4485 9347 +4485 7621 +4485 4934 +4485 5906 +4485 4590 +4485 6671 +4485 4656 +4485 6737 +4485 9300 +4485 8917 +4485 5815 +4485 7577 +4485 9306 +4485 9119 +4485 8426 +4485 4783 +4486 6625 +4486 8936 +4486 8426 +4486 7739 +4486 9680 +4486 9551 +4486 8208 +4486 9759 +4486 9723 +4486 8127 +4487 9443 +4487 5315 +4487 7243 +4487 4994 +4487 9277 +4487 6196 +4487 5847 +4487 5688 +4487 5244 +4487 6461 +4488 6529 +4488 9733 +4488 9479 +4488 7711 +4488 9388 +4488 5679 +4488 8897 +4488 7237 +4488 5832 +4488 7882 +4488 8308 +4489 8320 +4489 5061 +4489 6696 +4489 7785 +4489 5104 +4489 7964 +4489 7901 +4490 4501 +4490 5786 +4490 8226 +4490 6831 +4490 7113 +4490 7374 +4490 4566 +4490 4605 +4490 9429 +4491 5211 +4491 7463 +4491 8488 +4491 8491 +4491 6893 +4491 6285 +4491 8718 +4491 4717 +4491 9778 +4491 7699 +4491 9906 +4491 9315 +4491 6715 +4492 8160 +4492 6214 +4492 9902 +4492 7427 +4492 9240 +4492 9087 +4493 9228 +4493 5030 +4493 6451 +4493 6327 +4493 6458 +4493 4542 +4493 6353 +4493 4836 +4493 9434 +4493 7133 +4493 8575 +4494 6216 +4494 5441 +4494 8487 +4494 8353 +4494 9685 +4494 4601 +4494 6585 +4494 6540 +4494 6203 +4494 7367 +4495 7202 +4495 5830 +4495 6739 +4495 6810 +4495 8245 +4495 8078 +4496 5251 +4496 8719 +4496 7573 +4496 7837 +4496 9374 +4496 9247 +4496 5536 +4496 6472 +4496 8242 +4496 8639 +4496 9416 +4496 7121 +4496 5467 +4496 4574 +4496 6885 +4496 9322 +4496 7798 +4496 9725 +4496 9365 +4497 8134 +4497 6011 +4497 8486 +4497 6632 +4497 6311 +4497 6383 +4497 7762 +4497 9525 +4497 5881 +4498 7170 +4498 8058 +4498 8523 +4498 8788 +4498 8120 +4498 4638 +4498 9724 +4498 5245 +4498 6558 +4498 5013 +4499 6177 +4499 8482 +4499 7725 +4499 7586 +4499 9349 +4500 5059 +4500 7702 +4500 4842 +4500 8559 +4500 5267 +4500 9046 +4500 7963 +4500 5214 +4501 4630 +4501 9256 +4501 7986 +4501 5683 +4501 8127 +4501 6488 +4501 9180 +4501 9828 +4501 7672 +4502 6689 +4502 7587 +4502 5764 +4502 6918 +4502 9671 +4502 9484 +4502 4686 +4502 6160 +4502 5625 +4502 5019 +4503 9900 +4503 7878 +4503 8169 +4503 9641 +4503 5196 +4503 5293 +4503 4597 +4503 5209 +4503 9098 +4504 8453 +4504 5520 +4504 5908 +4504 9380 +4504 7858 +4504 6708 +4504 6589 +4504 9024 +4504 7235 +4504 8301 +4504 8063 +4505 8960 +4505 4801 +4505 4967 +4505 4943 +4505 8113 +4505 6005 +4505 9969 +4505 7402 +4505 5567 +4506 8960 +4506 9474 +4506 7427 +4506 9487 +4506 5522 +4506 5789 +4506 4901 +4506 9515 +4506 6693 +4506 8221 +4506 6089 +4506 5076 +4506 5081 +4506 5855 +4507 8320 +4507 6530 +4507 4617 +4507 8714 +4507 9612 +4507 7955 +4507 8366 +4507 7871 +4507 4676 +4507 5852 +4507 6242 +4507 6633 +4507 6641 +4507 9971 +4507 7285 +4508 5078 +4508 6826 +4508 4588 +4508 5069 +4508 8976 +4508 8979 +4508 7352 +4508 7707 +4509 8584 +4509 5645 +4509 9487 +4509 6672 +4509 6932 +4509 8600 +4509 8985 +4509 7838 +4509 4802 +4509 4808 +4509 4689 +4509 5845 +4509 5718 +4509 7249 +4510 7557 +4510 5902 +4510 5923 +4510 6955 +4510 6573 +4510 7219 +4510 5560 +4510 9409 +4510 5069 +4510 7520 +4510 9186 +4510 9701 +4510 5358 +4510 5236 +4511 7560 +4511 4631 +4511 7069 +4511 7712 +4511 6561 +4511 4771 +4511 6493 +4511 5939 +4511 8643 +4511 8168 +4511 8811 +4511 4600 +4511 8313 +4511 5630 +4512 5899 +4512 6546 +4512 9668 +4512 5019 +4512 6688 +4512 5028 +4512 4912 +4512 6065 +4512 7218 +4512 5302 +4512 6340 +4512 4696 +4512 9307 +4512 6620 +4512 4703 +4512 4962 +4512 6244 +4512 8436 +4512 7292 +4513 6403 +4513 6405 +4513 7942 +4513 6408 +4513 7314 +4513 8624 +4513 7091 +4513 5694 +4513 5848 +4513 7641 +4513 8669 +4513 8686 +4513 5882 +4513 9341 +4513 6911 +4514 5648 +4514 8103 +4514 8681 +4514 8529 +4514 5522 +4514 7605 +4514 7734 +4514 9993 +4514 6509 +4515 6560 +4515 6658 +4515 8706 +4515 8133 +4515 8081 +4515 8073 +4515 6223 +4515 5392 +4515 9095 +4515 7727 +4515 4732 +4515 8989 +4516 4741 +4516 5646 +4516 5266 +4516 8616 +4516 4532 +4516 5966 +4516 6365 +4516 6244 +4516 5614 +4516 6262 +4516 7422 +4516 8191 +4517 4726 +4517 9881 +4517 9499 +4517 5823 +4518 9568 +4518 7473 +4518 6056 +4518 9898 +4518 5551 +4518 8215 +4518 7352 +4518 7450 +4518 7295 +4518 5050 +4518 7230 +4518 5567 +4519 8900 +4519 7109 +4519 7272 +4519 8396 +4519 9450 +4519 7180 +4519 5074 +4519 4935 +4519 7252 +4519 7125 +4519 6073 +4519 8286 +4519 7518 +4520 8195 +4520 6667 +4520 7314 +4520 7188 +4520 5422 +4520 7077 +4520 8366 +4520 5938 +4520 8629 +4520 5046 +4520 7358 +4520 7499 +4520 7254 +4520 9695 +4520 8940 +4521 9669 +4521 7912 +4521 8653 +4521 7534 +4521 5558 +4521 4859 +4521 5567 +4522 9922 +4522 4710 +4522 5128 +4522 9968 +4522 4883 +4522 7701 +4522 6425 +4522 9845 +4523 8972 +4523 8472 +4523 6684 +4523 7452 +4523 8493 +4523 8005 +4523 8037 +4523 8807 +4523 8430 +4523 8307 +4523 8436 +4523 9471 +4524 6880 +4524 5560 +4524 8241 +4524 7792 +4524 4658 +4524 6611 +4524 5559 +4524 9048 +4524 7227 +4525 6406 +4525 6669 +4525 7320 +4525 9500 +4525 5037 +4525 9658 +4525 6075 +4525 6590 +4525 6217 +4525 4816 +4525 5981 +4525 9700 +4525 8938 +4526 4580 +4526 7626 +4526 7074 +4526 5356 +4526 5197 +4526 6645 +4526 6909 +4526 6943 +4527 9794 +4527 4835 +4527 8549 +4527 4870 +4527 8622 +4527 4911 +4527 5236 +4527 9819 +4527 5436 +4528 5892 +4528 9484 +4528 6826 +4528 5164 +4528 6702 +4528 8759 +4528 4798 +4528 9547 +4528 7633 +4528 5011 +4528 5879 +4528 9208 +4528 6654 +4529 7039 +4529 4998 +4529 4923 +4529 4744 +4529 6985 +4529 9964 +4529 5485 +4529 5870 +4529 7314 +4529 7102 +4529 6296 +4529 6745 +4529 7679 +4530 5606 +4530 5514 +4530 4684 +4530 5074 +4530 8166 +4530 7836 +4531 5384 +4531 9795 +4531 8070 +4531 6001 +4531 8370 +4531 7051 +4531 8881 +4531 7346 +4531 7550 +4531 4537 +4531 9850 +4531 9915 +4531 8444 +4532 5281 +4532 8267 +4532 9161 +4532 6733 +4532 5870 +4532 7673 +4532 5398 +4532 5047 +4532 9784 +4532 7006 +4533 9867 +4533 8261 +4533 6305 +4533 6497 +4533 7344 +4533 5685 +4533 8889 +4533 5441 +4533 6851 +4533 9043 +4533 8661 +4533 5345 +4533 9916 +4533 7166 +4533 5242 +4534 8384 +4534 7393 +4534 4900 +4534 8266 +4534 8204 +4534 5232 +4534 9239 +4534 5630 +4535 4962 +4535 5736 +4535 4615 +4535 5879 +4535 6744 +4535 7412 +4535 8637 +4535 4734 +4536 8965 +4536 7233 +4536 8974 +4536 6417 +4536 9762 +4536 6055 +4536 8105 +4536 8130 +4536 9561 +4536 8028 +4536 6567 +4536 4966 +4536 4849 +4536 6526 +4537 9283 +4537 9115 +4537 5787 +4537 8965 +4537 7114 +4537 6795 +4537 8620 +4537 9294 +4537 8867 +4537 9130 +4537 7414 +4537 7707 +4537 6719 +4538 9604 +4538 5866 +4538 5326 +4538 5426 +4538 4693 +4538 8920 +4538 7293 +4539 6468 +4539 4843 +4539 6989 +4539 6321 +4539 7314 +4539 9491 +4539 7978 +4539 5189 +4540 8960 +4540 7826 +4540 6420 +4540 7703 +4540 5792 +4540 5921 +4540 5674 +4540 9650 +4540 8501 +4540 9273 +4540 8906 +4540 5200 +4540 7778 +4540 8550 +4540 5364 +4540 7035 +4541 6048 +4541 4730 +4541 4966 +4541 6377 +4541 5676 +4541 9647 +4541 6201 +4542 8454 +4542 9741 +4542 7701 +4542 8871 +4542 6185 +4542 6980 +4542 6221 +4542 5714 +4542 7256 +4542 5092 +4542 7911 +4542 8305 +4543 6656 +4543 6144 +4543 6882 +4543 8901 +4543 8363 +4543 6402 +4543 9999 +4543 7048 +4543 9430 +4543 8729 +4543 6794 +4544 5411 +4544 8807 +4544 9737 +4544 4906 +4544 6964 +4544 8629 +4544 7255 +4544 6586 +4545 7301 +4545 9512 +4545 6727 +4545 8387 +4545 7506 +4545 9304 +4545 7003 +4545 9697 +4545 7014 +4545 8309 +4545 8056 +4546 4651 +4546 5323 +4546 5001 +4546 4621 +4546 6999 +4546 6611 +4546 9785 +4546 4571 +4547 9959 +4547 6893 +4547 4948 +4547 9493 +4547 9918 +4547 8095 +4548 5345 +4548 5643 +4548 9998 +4548 4848 +4548 5098 +4548 7118 +4548 6656 +4548 9752 +4548 6297 +4548 8394 +4549 9188 +4549 8176 +4549 9446 +4549 6855 +4549 5643 +4549 5006 +4549 7247 +4549 8913 +4549 5234 +4549 8307 +4549 4595 +4549 6276 +4549 6977 +4549 5286 +4550 7280 +4550 4776 +4550 8311 +4550 5549 +4550 5358 +4550 5338 +4550 5372 +4550 6970 +4551 6149 +4551 9737 +4551 6157 +4551 5145 +4551 6941 +4551 5284 +4551 4792 +4551 6201 +4551 7303 +4551 9279 +4551 7371 +4551 7634 +4551 5595 +4551 9953 +4551 6370 +4551 4818 +4552 6469 +4552 7476 +4552 7508 +4552 5780 +4552 7478 +4552 5348 +4552 4638 +4553 4965 +4553 7270 +4553 9450 +4553 9202 +4553 7895 +4553 6904 +4553 5375 +4554 4672 +4554 8834 +4554 6171 +4554 9350 +4554 6753 +4554 8040 +4554 9162 +4554 9780 +4554 6478 +4554 9816 +4554 5595 +4555 7556 +4555 7238 +4555 6183 +4555 9547 +4555 8078 +4555 6073 +4555 6011 +4555 7037 +4555 8735 +4556 4994 +4556 5660 +4556 7462 +4556 8497 +4556 5043 +4556 7998 +4556 8512 +4556 6983 +4556 5988 +4556 5221 +4556 5225 +4556 8044 +4557 7172 +4557 7429 +4557 6193 +4557 8512 +4557 5569 +4557 4936 +4557 6861 +4557 9685 +4557 4827 +4557 5089 +4557 6135 +4558 5760 +4558 4998 +4558 6439 +4558 5010 +4558 9874 +4558 7161 +4558 6137 +4558 8604 +4558 6489 +4559 5995 +4559 7049 +4559 9102 +4559 9238 +4559 9752 +4559 6207 +4559 6596 +4559 8665 +4559 9963 +4559 5617 +4559 5106 +4559 7413 +4559 9305 +4560 4865 +4560 8898 +4560 4835 +4560 6054 +4560 7473 +4560 5181 +4561 9247 +4561 8138 +4561 9067 +4561 8300 +4561 4688 +4561 6482 +4561 5557 +4561 9148 +4561 7861 +4562 7137 +4562 9435 +4562 9030 +4562 5815 +4562 9548 +4562 4688 +4562 8370 +4562 7124 +4562 9623 +4562 6559 +4562 8752 +4563 9321 +4563 5264 +4563 5990 +4563 8187 +4563 5303 +4563 8341 +4564 6272 +4564 9366 +4564 7965 +4564 6305 +4564 6939 +4564 7716 +4564 9642 +4564 5442 +4564 6852 +4564 5192 +4564 5966 +4564 9827 +4564 5604 +4564 8429 +4564 9074 +4564 5111 +4565 5220 +4565 7663 +4565 7383 +4565 8826 +4565 5980 +4566 6145 +4566 9421 +4566 5517 +4566 9650 +4566 6587 +4566 6474 +4566 7230 +4566 8149 +4567 9988 +4567 7746 +4567 8990 +4567 9375 +4567 7594 +4567 9646 +4567 9014 +4567 9408 +4567 8513 +4567 5698 +4567 4943 +4567 5354 +4567 5099 +4567 5243 +4568 4960 +4568 5163 +4568 8012 +4568 4910 +4568 8089 +4568 5138 +4568 6579 +4568 8769 +4568 7767 +4568 7532 +4568 7037 +4569 8646 +4569 6023 +4569 5191 +4569 7185 +4569 9235 +4569 6548 +4569 8373 +4569 9172 +4569 7921 +4569 6300 +4569 4597 +4570 7687 +4570 7567 +4570 8611 +4570 5670 +4570 9007 +4570 7226 +4570 8006 +4570 6855 +4570 8122 +4570 4705 +4570 6695 +4570 9748 +4571 9216 +4571 9222 +4571 7704 +4571 9527 +4571 8385 +4571 6599 +4571 7892 +4571 9793 +4571 8819 +4572 5290 +4572 7403 +4572 9309 +4572 8473 +4572 8474 +4572 9437 +4572 8446 +4573 6209 +4573 5252 +4573 9030 +4573 8716 +4573 6724 +4573 6364 +4573 7773 +4573 9534 +4574 8320 +4574 8325 +4574 7563 +4574 9882 +4574 6255 +4574 8613 +4574 8486 +4574 9639 +4574 9136 +4574 9137 +4574 8759 +4574 8523 +4574 9552 +4574 8625 +4574 7654 +4574 5736 +4574 7792 +4574 6391 +4575 8800 +4575 8672 +4575 5563 +4575 4581 +4575 5382 +4575 7143 +4575 9024 +4575 5639 +4575 7202 +4575 8018 +4575 7448 +4575 7321 +4575 6270 +4575 4587 +4576 8897 +4576 7056 +4576 6560 +4576 6446 +4576 5931 +4576 6572 +4576 6062 +4576 6842 +4576 4801 +4576 7568 +4576 9068 +4577 6152 +4577 7573 +4577 8985 +4577 8345 +4577 5658 +4577 4639 +4577 5409 +4577 9640 +4577 7979 +4577 8365 +4577 8531 +4577 7176 +4577 7141 +4577 7019 +4577 5104 +4577 5107 +4578 8582 +4578 8084 +4578 6808 +4578 8223 +4578 7329 +4578 5155 +4578 8123 +4578 7010 +4578 8679 +4578 8942 +4578 6641 +4578 6517 +4578 7807 +4579 9986 +4579 8963 +4579 5381 +4579 5900 +4579 6671 +4579 7446 +4579 5534 +4579 7971 +4579 9391 +4579 8129 +4579 7235 +4579 8148 +4579 6225 +4579 4984 +4580 5126 +4580 9609 +4580 9837 +4580 7194 +4580 5405 +4580 7076 +4580 6062 +4580 6575 +4580 7987 +4580 5178 +4580 8908 +4580 8788 +4580 9167 +4580 8554 +4580 5101 +4580 6004 +4581 5664 +4581 7521 +4581 4612 +4581 8716 +4581 6380 +4581 5040 +4581 9411 +4581 8697 +4581 7225 +4581 4604 +4581 6685 +4581 7678 +4582 7434 +4582 6031 +4582 7313 +4582 8979 +4582 6559 +4582 8097 +4582 9520 +4582 5436 +4582 9791 +4582 8514 +4582 5573 +4582 9676 +4582 6093 +4582 6760 +4582 7026 +4582 4599 +4583 6017 +4583 6338 +4583 7169 +4583 9127 +4583 6760 +4583 4972 +4583 7907 +4583 7797 +4583 8314 +4583 6683 +4584 7296 +4584 8673 +4584 8210 +4584 6565 +4584 7367 +4584 8272 +4584 4630 +4584 9963 +4584 9569 +4584 6058 +4584 9236 +4584 6455 +4585 4929 +4585 7966 +4585 7110 +4585 7398 +4585 9068 +4585 5037 +4585 5122 +4585 4913 +4585 9747 +4585 9111 +4585 5663 +4586 7554 +4586 5649 +4586 5528 +4586 6937 +4586 4894 +4586 7970 +4586 9141 +4586 7905 +4586 7883 +4586 8396 +4586 6864 +4586 8661 +4586 8537 +4586 4957 +4586 8165 +4586 9321 +4586 5741 +4586 9328 +4587 7936 +4587 7681 +4587 6914 +4587 9861 +4587 8192 +4587 8718 +4587 8223 +4587 5542 +4587 9392 +4587 8885 +4587 7225 +4587 5053 +4587 9284 +4587 5453 +4587 8149 +4587 7901 +4587 9766 +4587 6762 +4587 5356 +4587 6127 +4587 8689 +4588 5794 +4588 5640 +4588 6730 +4588 4684 +4588 6800 +4588 6984 +4588 8163 +4588 9365 +4588 9498 +4588 9455 +4588 9948 +4588 9823 +4589 6848 +4589 4697 +4589 5775 +4589 8018 +4589 5140 +4589 9974 +4589 9623 +4589 8920 +4589 7994 +4590 6539 +4590 8208 +4590 8209 +4590 7444 +4590 7574 +4590 9372 +4590 7727 +4590 8368 +4590 5555 +4590 6069 +4590 9408 +4590 5831 +4590 5457 +4590 6995 +4590 6870 +4590 4698 +4591 4641 +4591 5572 +4591 7799 +4591 5072 +4591 5393 +4591 6935 +4591 8804 +4591 9231 +4592 6541 +4592 7702 +4592 6696 +4592 9659 +4592 6208 +4592 5452 +4592 5714 +4592 6748 +4592 7611 +4592 8804 +4592 9720 +4592 5247 +4593 7210 +4593 4877 +4593 7955 +4593 9167 +4593 5308 +4593 7391 +4594 8384 +4594 4993 +4594 8355 +4594 9667 +4594 8006 +4594 7654 +4594 5833 +4594 9004 +4594 7377 +4594 5498 +4594 7546 +4595 7138 +4595 9733 +4595 8705 +4595 6855 +4595 5933 +4595 8973 +4595 7920 +4595 9938 +4595 8277 +4595 8622 +4596 9610 +4596 7915 +4596 6511 +4596 7267 +4596 7924 +4596 8735 +4596 8539 +4596 7588 +4597 9479 +4597 4620 +4597 5267 +4597 6174 +4597 7077 +4597 8129 +4597 5346 +4597 6735 +4597 8538 +4597 6370 +4597 6897 +4597 7419 +4597 8702 +4598 6784 +4598 8323 +4598 4999 +4598 5782 +4598 7844 +4598 6053 +4598 8509 +4598 8008 +4598 6626 +4598 6006 +4599 9948 +4599 6469 +4599 9449 +4599 4717 +4599 7667 +4599 7416 +4599 5275 +4599 8956 +4599 5534 +4599 6641 +4600 5377 +4600 6903 +4600 4892 +4600 4638 +4600 7718 +4600 5929 +4600 6700 +4600 6211 +4600 8262 +4600 9032 +4600 6732 +4600 7247 +4600 6228 +4600 7898 +4600 9286 +4600 5981 +4600 8810 +4601 6020 +4601 9098 +4601 5522 +4601 9366 +4601 4889 +4601 8384 +4601 5960 +4601 6994 +4601 7395 +4601 6868 +4601 4824 +4601 8922 +4601 7526 +4601 6248 +4601 6162 +4602 8528 +4602 8098 +4602 5060 +4602 9912 +4602 6841 +4602 6143 +4603 6244 +4603 7463 +4603 4617 +4603 9034 +4603 9515 +4603 7693 +4603 7805 +4603 7888 +4603 6394 +4603 6332 +4603 8746 +4603 9727 +4604 7493 +4604 6504 +4604 9260 +4604 8305 +4604 7289 +4604 5371 +4604 4766 +4604 8607 +4605 8899 +4605 4644 +4605 6323 +4605 9297 +4605 6279 +4605 9390 +4605 5392 +4605 7715 +4605 6706 +4605 8723 +4605 7061 +4605 4933 +4605 6839 +4606 6241 +4606 7120 +4606 8549 +4606 7591 +4606 9164 +4606 5901 +4606 6646 +4606 7736 +4606 5497 +4606 6526 +4607 8962 +4607 7665 +4607 9548 +4607 9804 +4607 9806 +4607 9359 +4607 5808 +4607 9361 +4607 7287 +4607 6525 +4607 4639 +4608 5990 +4608 7176 +4608 6954 +4608 4922 +4608 8130 +4608 6575 +4608 5009 +4608 8440 +4608 8731 +4608 8253 +4609 8066 +4609 7334 +4609 5703 +4609 9328 +4609 6865 +4609 8818 +4609 7956 +4609 9927 +4609 5943 +4609 8897 +4609 8893 +4610 8724 +4610 7959 +4610 8903 +4610 8018 +4610 7017 +4610 7407 +4610 5497 +4610 5631 +4611 5179 +4611 7621 +4611 5389 +4611 9053 +4611 7440 +4611 8978 +4611 9141 +4611 7578 +4611 4859 +4611 8797 +4611 5822 +4612 9865 +4612 7434 +4612 5648 +4612 7038 +4612 5462 +4612 4986 +4612 8571 +4612 4702 +4612 4741 +4613 9234 +4613 6436 +4613 6045 +4613 5993 +4613 9134 +4613 7949 +4613 9550 +4613 5624 +4613 9277 +4614 6273 +4614 7941 +4614 5006 +4614 8094 +4614 8768 +4614 5826 +4614 5070 +4614 9054 +4614 6513 +4614 8308 +4615 7106 +4615 6275 +4615 8081 +4615 9970 +4615 8148 +4615 7801 +4615 7466 +4616 8483 +4616 9510 +4616 8583 +4616 6226 +4616 9261 +4616 7826 +4616 9987 +4616 6551 +4616 5946 +4616 7195 +4616 9212 +4617 5256 +4617 7419 +4617 5020 +4617 5607 +4617 8651 +4617 4716 +4617 5678 +4617 5776 +4617 4622 +4617 9516 +4618 8674 +4618 7907 +4618 8431 +4618 8432 +4619 9984 +4619 8419 +4619 8516 +4619 5766 +4619 6959 +4619 7090 +4619 7639 +4619 6494 +4620 5901 +4620 5520 +4620 7190 +4620 7841 +4620 8249 +4620 5954 +4620 6345 +4620 4963 +4620 9685 +4620 9437 +4620 8547 +4620 9069 +4620 9839 +4621 7813 +4621 6693 +4621 8358 +4621 7083 +4621 8643 +4621 6475 +4621 6606 +4621 5989 +4621 7718 +4621 8681 +4621 9326 +4621 8147 +4621 8553 +4622 7619 +4622 5479 +4622 7434 +4622 8910 +4622 5876 +4622 5806 +4622 9688 +4622 8859 +4622 5701 +4623 7521 +4623 8453 +4623 7881 +4623 7981 +4623 5585 +4623 8339 +4623 8054 +4623 9531 +4623 9149 +4624 6764 +4624 8384 +4624 5223 +4624 4875 +4624 9964 +4624 7569 +4624 5113 +4625 6678 +4625 8601 +4625 8345 +4625 6452 +4625 7737 +4625 4796 +4625 6095 +4625 6246 +4625 5748 +4626 6112 +4626 4802 +4626 8420 +4626 5159 +4626 4653 +4626 8740 +4626 9976 +4626 9074 +4626 7381 +4626 8548 +4626 6780 +4626 9758 +4627 6051 +4627 6565 +4627 9995 +4627 5810 +4627 8563 +4627 6521 +4627 6815 +4628 5248 +4628 7819 +4628 5638 +4628 7466 +4628 5356 +4628 5647 +4628 9533 +4628 8917 +4628 5501 +4628 8702 +4629 8816 +4629 9099 +4629 9323 +4629 7541 +4629 7800 +4629 8666 +4629 4794 +4630 5542 +4630 8457 +4630 8644 +4630 7376 +4630 8535 +4630 9785 +4630 8094 +4631 7200 +4631 6883 +4631 8779 +4631 8946 +4631 8267 +4631 5074 +4631 6549 +4631 5145 +4632 8228 +4632 6245 +4632 7591 +4632 9217 +4632 7690 +4632 7851 +4632 7501 +4632 8698 +4632 8126 +4633 7429 +4633 8875 +4633 4652 +4633 5456 +4633 8820 +4633 9239 +4633 7288 +4633 9209 +4633 6247 +4633 8106 +4633 9809 +4634 5755 +4634 9998 +4634 9234 +4634 5843 +4634 7573 +4634 7881 +4634 8440 +4634 4924 +4634 8635 +4634 7999 +4635 7680 +4635 7813 +4635 9240 +4635 8865 +4635 6308 +4635 6181 +4635 6696 +4635 7594 +4635 9287 +4635 8754 +4635 4659 +4635 5557 +4635 6089 +4635 6093 +4635 8526 +4635 9296 +4635 8917 +4635 5724 +4635 5094 +4636 5696 +4636 7333 +4636 9969 +4636 6954 +4636 7598 +4636 8657 +4636 5271 +4636 9112 +4636 9594 +4636 5820 +4637 5952 +4637 6721 +4637 6818 +4637 6883 +4637 9259 +4637 9100 +4637 4685 +4637 6478 +4637 5840 +4637 7121 +4637 9187 +4637 7107 +4638 7182 +4638 6689 +4638 7230 +4638 9672 +4638 7415 +4638 8929 +4638 7787 +4638 9022 +4638 7593 +4638 8058 +4639 8964 +4639 6922 +4639 5136 +4639 9120 +4639 6438 +4639 9905 +4639 9305 +4639 9189 +4639 5990 +4639 9064 +4639 8430 +4640 6924 +4640 9615 +4640 6194 +4640 7717 +4640 8232 +4640 8496 +4640 6967 +4640 5945 +4640 6026 +4640 7358 +4640 8800 +4640 9538 +4640 8015 +4640 8032 +4640 8808 +4640 9968 +4641 4993 +4641 4869 +4641 6920 +4641 6541 +4641 5143 +4641 5147 +4641 9093 +4641 7205 +4641 9001 +4641 8370 +4641 7351 +4641 9019 +4641 7104 +4641 9287 +4641 8009 +4641 6742 +4641 8164 +4641 8427 +4641 8306 +4641 8057 +4641 6269 +4642 9732 +4642 9502 +4642 5171 +4642 9948 +4642 6835 +4642 4661 +4642 9785 +4642 7100 +4642 6865 +4642 5208 +4642 8414 +4642 6240 +4642 9450 +4642 8946 +4642 9717 +4643 5398 +4643 5091 +4643 8982 +4643 6339 +4643 8360 +4643 6988 +4643 7878 +4643 8428 +4643 4980 +4643 9582 +4643 6934 +4643 9785 +4644 7175 +4644 6803 +4644 5269 +4644 5401 +4644 7744 +4644 7121 +4644 7671 +4645 9624 +4645 6531 +4645 9095 +4645 5656 +4645 4889 +4645 6552 +4645 5178 +4645 4926 +4645 5088 +4645 9828 +4645 6417 +4645 5870 +4645 4733 +4645 9855 +4646 5543 +4646 7340 +4646 8588 +4646 8208 +4646 7609 +4646 9690 +4646 5627 +4647 9476 +4647 5002 +4647 6669 +4647 6707 +4647 5139 +4647 8388 +4647 4892 +4648 6145 +4648 8546 +4648 5035 +4648 5363 +4648 6508 +4648 6380 +4648 8054 +4648 9785 +4648 6841 +4648 7645 +4649 7824 +4649 4843 +4649 9996 +4649 5420 +4649 8153 +4649 4926 +4650 9814 +4650 5542 +4650 5031 +4650 8780 +4650 6930 +4650 9202 +4650 9366 +4651 7296 +4651 6838 +4651 7142 +4651 5778 +4651 9685 +4651 5110 +4651 9689 +4651 4870 +4652 5379 +4652 9222 +4652 8736 +4652 7734 +4652 6587 +4652 6974 +4652 5969 +4652 4712 +4652 9720 +4652 6267 +4652 7292 +4653 9888 +4653 5572 +4653 8033 +4653 6280 +4653 9353 +4653 5904 +4653 6967 +4653 6971 +4653 8156 +4654 8993 +4654 8643 +4654 8494 +4654 7719 +4654 8874 +4654 5265 +4654 8830 +4654 4725 +4655 4802 +4655 9146 +4655 6148 +4655 5206 +4655 4809 +4655 9986 +4655 8957 +4655 8881 +4655 9334 +4655 7318 +4655 4824 +4655 5433 +4655 7994 +4655 6461 +4656 7552 +4656 5157 +4656 5478 +4656 9194 +4656 7341 +4656 9108 +4656 5111 +4656 7226 +4656 6879 +4657 6016 +4657 8677 +4657 8759 +4657 9516 +4657 6005 +4657 8471 +4657 6075 +4657 9757 +4657 7486 +4658 9481 +4658 7322 +4658 9884 +4658 7962 +4658 8098 +4658 8485 +4658 8245 +4658 8248 +4658 5063 +4658 7144 +4659 5524 +4659 5401 +4659 6820 +4659 6310 +4659 6188 +4659 9901 +4659 6703 +4659 8496 +4659 5814 +4659 8503 +4659 9035 +4659 7502 +4659 9296 +4659 5084 +4659 9185 +4659 8674 +4659 7081 +4660 9485 +4660 9998 +4660 6690 +4660 8178 +4660 7728 +4660 7730 +4660 7370 +4660 7629 +4660 6632 +4660 5483 +4660 9200 +4660 6130 +4660 8307 +4661 9411 +4661 5194 +4661 7051 +4661 9040 +4661 5393 +4661 6485 +4661 9967 +4661 6623 +4662 9248 +4662 9665 +4662 6924 +4662 5057 +4662 8119 +4662 5423 +4662 7293 +4662 7733 +4662 6779 +4662 9597 +4662 7963 +4663 7202 +4663 4868 +4663 9472 +4663 5848 +4663 4985 +4664 9602 +4664 6152 +4664 5802 +4664 6023 +4664 5837 +4664 8566 +4664 7480 +4665 7851 +4665 8356 +4665 5259 +4665 7057 +4665 8020 +4665 5855 +4666 6400 +4666 9992 +4666 9098 +4666 7185 +4666 5406 +4666 9519 +4666 8115 +4666 6838 +4666 6367 +4666 7679 +4667 7041 +4667 6025 +4667 9560 +4667 8854 +4667 7585 +4667 9381 +4667 5185 +4667 6868 +4667 6458 +4667 7288 +4668 9760 +4668 6148 +4668 9573 +4668 8986 +4668 9266 +4668 7023 +4668 9397 +4668 8277 +4668 9782 +4668 6541 +4668 5348 +4668 9018 +4668 7423 +4669 9614 +4669 5905 +4669 6696 +4669 5548 +4669 4916 +4669 7349 +4669 7872 +4669 8740 +4669 5859 +4670 5901 +4670 8591 +4670 5522 +4670 6557 +4670 8096 +4670 9650 +4670 4807 +4670 8020 +4670 6757 +4670 6880 +4670 7670 +4671 4744 +4671 8588 +4671 6832 +4671 5304 +4671 7867 +4671 5312 +4671 8538 +4671 9200 +4671 9078 +4671 5243 +4672 7680 +4672 5651 +4672 7836 +4672 6689 +4672 6437 +4672 9262 +4672 9910 +4672 8654 +4672 5074 +4672 8918 +4672 6494 +4672 7483 +4672 6897 +4672 4862 +4673 6800 +4673 5759 +4673 9631 +4673 6304 +4673 8742 +4673 7341 +4673 8669 +4673 5808 +4673 6205 +4673 7878 +4673 9947 +4673 9949 +4673 5117 +4674 9351 +4674 9102 +4674 5693 +4674 9790 +4674 6720 +4674 7750 +4674 8662 +4674 8795 +4674 7163 +4675 7714 +4675 9167 +4675 5578 +4675 4685 +4675 6557 +4675 8786 +4675 8126 +4675 9015 +4675 9465 +4675 7131 +4675 9340 +4675 6685 +4675 8927 +4676 8225 +4676 8273 +4676 4870 +4676 5351 +4676 7997 +4676 4755 +4676 5590 +4676 8378 +4676 6843 +4677 5480 +4677 5099 +4677 6031 +4677 6548 +4677 7574 +4677 8665 +4678 6317 +4678 7086 +4678 9519 +4678 9924 +4678 5061 +4678 5959 +4678 7052 +4678 8174 +4678 8056 +4679 8834 +4679 5646 +4679 7661 +4679 5532 +4679 5413 +4679 5677 +4679 8239 +4679 9904 +4679 9908 +4679 7761 +4679 8476 +4679 5207 +4679 8934 +4679 7917 +4680 6713 +4680 9334 +4680 9735 +4680 5974 +4680 5755 +4680 7870 +4681 7296 +4681 5347 +4681 4875 +4681 8637 +4681 7536 +4681 6883 +4681 4696 +4681 5370 +4681 9210 +4681 5534 +4682 7339 +4682 5847 +4682 6893 +4682 5326 +4682 5159 +4682 6516 +4682 5284 +4682 8598 +4682 8793 +4682 7613 +4682 7093 +4683 5132 +4683 7938 +4683 7200 +4683 6310 +4683 5544 +4683 8501 +4683 8383 +4683 9067 +4683 6764 +4683 9327 +4683 6646 +4683 6008 +4684 8840 +4684 6284 +4684 7106 +4684 7442 +4684 4889 +4684 9120 +4684 7462 +4684 7210 +4684 7345 +4684 9272 +4684 9660 +4684 8127 +4684 8384 +4684 7746 +4684 6467 +4684 9672 +4684 7497 +4684 6619 +4684 7407 +4684 8694 +4685 5385 +4685 9303 +4685 9870 +4685 7329 +4685 6562 +4685 8487 +4685 6589 +4685 5449 +4685 7258 +4685 8417 +4685 6004 +4685 4857 +4686 8003 +4686 7114 +4686 5881 +4686 6636 +4686 6965 +4686 9939 +4686 8119 +4686 4857 +4686 5884 +4686 5194 +4686 6494 +4687 9601 +4687 9478 +4687 4750 +4687 7440 +4687 9745 +4687 6674 +4687 7076 +4687 9645 +4687 8934 +4688 7332 +4688 9381 +4688 6950 +4688 6800 +4688 6388 +4688 8534 +4688 5177 +4688 6994 +4688 9117 +4688 9374 +4688 9429 +4689 5024 +4689 5275 +4689 9118 +4689 6416 +4689 5774 +4689 9726 +4690 8473 +4690 4944 +4690 4828 +4690 8554 +4690 8171 +4690 7280 +4690 7161 +4690 6122 +4691 8417 +4691 4994 +4691 5846 +4691 5793 +4691 6124 +4691 6199 +4691 5432 +4691 5660 +4692 5696 +4692 9601 +4692 5191 +4692 6151 +4692 9200 +4692 5747 +4692 7953 +4692 6780 +4692 6462 +4692 7647 +4693 9736 +4693 9612 +4693 7699 +4693 8741 +4693 6712 +4693 4923 +4693 6977 +4693 5702 +4693 5833 +4693 9563 +4693 5158 +4694 9313 +4694 4706 +4694 6916 +4694 5770 +4694 6283 +4694 9887 +4695 8744 +4695 9901 +4695 9855 +4695 6137 +4695 4986 +4695 7167 +4695 9405 +4695 9694 +4695 4703 +4696 5696 +4696 4930 +4696 5969 +4696 8364 +4696 8141 +4696 4814 +4696 9389 +4696 8016 +4696 9329 +4696 7033 +4696 7601 +4697 7849 +4697 9809 +4697 9074 +4697 6324 +4697 8376 +4697 7226 +4697 5130 +4698 7009 +4698 9155 +4698 7185 +4698 9128 +4698 7274 +4698 9356 +4698 8270 +4698 9806 +4698 6751 +4699 9894 +4699 5415 +4699 6312 +4699 6250 +4699 6062 +4699 5231 +4699 7800 +4699 8311 +4699 6331 +4700 6272 +4700 9189 +4700 6796 +4700 8349 +4700 5842 +4701 9088 +4701 9860 +4701 5382 +4701 7712 +4701 7085 +4701 9904 +4701 9558 +4701 7640 +4701 6364 +4701 7661 +4701 9328 +4702 9280 +4702 6161 +4702 9700 +4702 5617 +4702 4886 +4702 9897 +4702 7352 +4702 4889 +4702 6756 +4702 4893 +4703 6926 +4703 8724 +4703 6039 +4703 7577 +4703 5659 +4703 5020 +4703 6823 +4703 7728 +4703 4787 +4703 6816 +4703 6245 +4703 5502 +4703 8319 +4704 9092 +4704 5752 +4704 6446 +4704 8655 +4704 7312 +4704 8328 +4704 4850 +4704 7448 +4704 5615 +4704 8222 +4705 6789 +4705 5148 +4705 6998 +4705 7860 +4705 7515 +4706 7055 +4706 9494 +4706 5529 +4706 5408 +4706 5287 +4706 5804 +4706 7840 +4706 9917 +4706 8224 +4706 8007 +4706 7498 +4706 8275 +4706 9559 +4706 5851 +4706 7393 +4706 9972 +4706 8567 +4706 8697 +4707 6657 +4707 7717 +4707 7591 +4707 9833 +4707 5002 +4707 4715 +4707 8285 +4707 8529 +4707 9974 +4707 6825 +4707 5272 +4707 7897 +4707 9563 +4707 8859 +4708 6880 +4708 8517 +4708 6087 +4708 8616 +4708 5837 +4708 8440 +4708 7322 +4708 9583 +4708 9021 +4708 9855 +4709 6049 +4709 9412 +4709 9670 +4709 8593 +4709 4971 +4709 5358 +4709 8527 +4709 4904 +4709 5813 +4709 8313 +4709 9436 +4709 8541 +4709 8878 +4710 9771 +4710 6381 +4710 7856 +4710 6578 +4711 8321 +4711 5895 +4711 9416 +4711 6300 +4711 9133 +4711 6888 +4711 4815 +4711 4968 +4711 7452 +4711 6108 +4712 7852 +4712 5259 +4712 7441 +4712 8210 +4712 6558 +4712 4774 +4712 5942 +4712 4933 +4712 8647 +4712 9055 +4712 7650 +4713 9994 +4713 9048 +4713 9621 +4713 7345 +4713 6900 +4713 9537 +4713 8898 +4713 4832 +4713 9321 +4713 8436 +4714 8182 +4714 5291 +4714 8692 +4714 5902 +4714 5423 +4714 9618 +4714 6958 +4714 6516 +4714 8735 +4715 4934 +4715 6792 +4715 8426 +4715 5070 +4715 5711 +4715 9617 +4715 7540 +4715 8731 +4715 8079 +4715 5149 +4715 9759 +4716 7971 +4716 8074 +4716 6895 +4716 7701 +4716 7677 +4716 6000 +4716 9055 +4716 6875 +4717 7169 +4717 5122 +4717 6174 +4717 9260 +4717 5423 +4717 5044 +4717 5303 +4717 5048 +4717 5715 +4717 5861 +4717 8425 +4718 6626 +4718 8389 +4718 7558 +4718 7017 +4718 6348 +4718 7917 +4718 7150 +4718 5807 +4718 5714 +4718 7579 +4718 9500 +4718 7006 +4719 5891 +4719 9627 +4719 9761 +4719 5166 +4719 5682 +4719 9147 +4719 9921 +4719 6113 +4719 5091 +4719 6377 +4719 6259 +4719 6906 +4719 8702 +4720 8323 +4720 6800 +4720 9639 +4720 7902 +4720 5559 +4720 6101 +4720 8167 +4720 8685 +4720 4974 +4720 8440 +4720 4860 +4721 7874 +4721 7555 +4721 7236 +4721 7816 +4721 8557 +4721 9517 +4721 7513 +4721 6970 +4722 8941 +4722 8758 +4722 4967 +4722 8046 +4722 4847 +4722 8656 +4722 8950 +4722 6775 +4722 8088 +4722 8762 +4722 8957 +4723 5392 +4723 4765 +4723 7587 +4723 5287 +4723 6364 +4723 9293 +4723 5966 +4723 5346 +4723 7910 +4723 8744 +4723 6775 +4724 6280 +4724 7312 +4724 8724 +4724 9629 +4724 5664 +4724 7074 +4724 6950 +4724 8488 +4724 7475 +4724 7993 +4724 8762 +4724 7487 +4724 7370 +4724 9560 +4724 9695 +4724 9446 +4724 7029 +4724 6783 +4725 9281 +4725 7054 +4725 6729 +4725 9311 +4725 5164 +4725 5805 +4725 9134 +4725 9655 +4725 7737 +4726 5507 +4726 8258 +4726 9871 +4726 5011 +4726 6552 +4726 8987 +4726 5153 +4726 5158 +4726 7470 +4726 6722 +4726 6600 +4726 5324 +4726 4963 +4726 8230 +4726 8062 +4727 6627 +4727 9477 +4727 9130 +4727 7916 +4727 4845 +4727 4754 +4727 7827 +4727 5205 +4727 7492 +4727 5711 +4728 8068 +4728 6664 +4728 8713 +4728 5766 +4728 6553 +4728 6716 +4728 4957 +4729 4963 +4729 9063 +4729 6888 +4729 5769 +4729 5612 +4729 9870 +4729 5492 +4729 9529 +4730 6658 +4730 6160 +4730 5921 +4730 9634 +4730 8231 +4730 8875 +4730 8119 +4730 6074 +4730 9412 +4730 9030 +4730 8908 +4730 7410 +4730 9845 +4730 7545 +4730 8828 +4731 9826 +4731 6344 +4731 8137 +4731 5162 +4731 8555 +4731 6956 +4731 8046 +4731 7568 +4732 5380 +4732 8938 +4732 6380 +4732 6349 +4732 7048 +4732 6930 +4732 9705 +4732 5785 +4732 7037 +4732 7903 +4733 8960 +4733 8839 +4733 7826 +4733 8999 +4733 5164 +4733 9037 +4733 7888 +4733 6227 +4733 4831 +4733 9698 +4733 5482 +4733 5755 +4733 8445 +4733 9343 +4734 8325 +4734 5712 +4734 9785 +4734 4984 +4734 9572 +4734 6639 +4734 7807 +4735 9858 +4735 8067 +4735 9617 +4735 7581 +4735 7842 +4735 5423 +4735 6090 +4735 5581 +4735 7003 +4735 8676 +4735 6780 +4735 9854 +4736 4738 +4736 6282 +4736 5652 +4736 9368 +4736 6964 +4736 4939 +4736 8782 +4736 9424 +4736 7134 +4736 6880 +4736 5693 +4736 9712 +4736 6004 +4736 5880 +4736 7804 +4737 7104 +4737 6496 +4737 6246 +4737 6192 +4737 6836 +4737 7575 +4737 7092 +4737 6068 +4738 5220 +4738 5061 +4738 8747 +4738 8879 +4738 7250 +4738 8933 +4738 8948 +4738 6900 +4738 5342 +4739 4999 +4739 5262 +4739 8470 +4739 8986 +4739 6707 +4739 7099 +4739 5440 +4739 9287 +4739 9801 +4739 5195 +4739 9303 +4739 6288 +4739 8447 +4740 9366 +4740 5895 +4740 9367 +4740 9642 +4740 7348 +4741 9638 +4741 5259 +4741 9969 +4741 6130 +4741 7347 +4741 6999 +4742 8325 +4742 7208 +4742 7020 +4742 7853 +4742 9107 +4742 8984 +4742 5146 +4742 8795 +4742 8220 +4742 8853 +4743 8067 +4743 9234 +4743 7060 +4743 6169 +4743 6299 +4743 5149 +4743 6694 +4743 6952 +4743 5932 +4743 6323 +4743 5833 +4743 7737 +4743 7104 +4743 4748 +4743 6871 +4743 9455 +4743 7802 +4744 9720 +4744 7316 +4744 8501 +4744 5078 +4744 6972 +4745 4996 +4745 6855 +4745 8744 +4745 6057 +4745 8906 +4745 6637 +4745 8717 +4745 5780 +4745 5577 +4745 9657 +4745 7453 +4745 6142 +4746 7141 +4746 7535 +4746 4917 +4746 6574 +4746 5628 +4746 6047 +4747 8769 +4747 6856 +4747 8845 +4747 9741 +4747 8853 +4747 8183 +4748 5023 +4748 9328 +4748 8400 +4748 7130 +4748 8923 +4749 8965 +4749 5382 +4749 6805 +4749 7988 +4749 6942 +4749 5675 +4749 5934 +4749 5684 +4749 5304 +4749 7737 +4749 6851 +4749 4856 +4749 6997 +4749 9945 +4749 9577 +4749 6637 +4749 6377 +4749 7163 +4750 5569 +4750 6721 +4750 5267 +4750 7380 +4750 5877 +4750 7894 +4750 9210 +4751 8763 +4751 8746 +4751 6221 +4751 9773 +4751 6097 +4751 6356 +4751 9432 +4752 6308 +4752 8391 +4752 9616 +4752 9812 +4752 7550 +4753 5064 +4753 8298 +4753 9425 +4753 8136 +4753 7829 +4753 5418 +4754 9505 +4754 9634 +4754 7686 +4754 6728 +4754 9642 +4754 7659 +4754 5104 +4754 9912 +4754 9371 +4754 6589 +4755 9221 +4755 5031 +4755 6928 +4755 6018 +4755 6095 +4755 5968 +4755 8377 +4755 4943 +4755 8122 +4755 9886 +4756 8965 +4756 5138 +4756 7059 +4756 6564 +4756 6963 +4756 7611 +4756 6212 +4756 9029 +4756 7367 +4756 9677 +4756 6225 +4756 9170 +4756 7383 +4757 6243 +4757 8327 +4757 9834 +4757 9645 +4757 8367 +4757 9777 +4757 7475 +4757 6869 +4757 6745 +4758 8363 +4758 8676 +4758 8677 +4758 9895 +4758 8074 +4758 6515 +4758 9269 +4758 6680 +4758 8283 +4759 8837 +4759 8713 +4759 8847 +4759 8835 +4759 6043 +4759 5405 +4759 8385 +4759 8011 +4759 5328 +4759 5460 +4759 8407 +4759 9809 +4759 8302 +4759 7926 +4760 7426 +4760 6523 +4760 6789 +4760 5577 +4760 7723 +4760 6860 +4760 6477 +4760 6703 +4760 6415 +4760 9943 +4760 6393 +4760 8859 +4761 6209 +4761 5520 +4761 9412 +4761 7335 +4761 6441 +4761 8532 +4761 5990 +4761 4978 +4761 9203 +4762 9456 +4762 6467 +4762 6660 +4762 5894 +4762 5286 +4762 5537 +4762 9608 +4762 6441 +4762 6273 +4762 7856 +4762 8246 +4762 9118 +4763 9987 +4763 6021 +4763 8907 +4763 9934 +4763 7572 +4763 6521 +4763 8691 +4763 9971 +4763 9823 +4764 8013 +4764 5262 +4764 6810 +4765 8309 +4765 7665 +4765 8498 +4765 8630 +4765 7895 +4765 7257 +4765 5533 +4765 9118 +4765 7455 +4766 5280 +4766 5697 +4766 6028 +4766 7182 +4766 6336 +4766 6910 +4766 9091 +4766 9562 +4766 5515 +4766 8573 +4767 5901 +4767 5732 +4767 7143 +4767 6025 +4767 5261 +4767 9677 +4767 6837 +4767 9530 +4768 8836 +4768 7314 +4768 5173 +4768 5304 +4768 8391 +4768 5197 +4768 7125 +4768 9823 +4768 5986 +4768 8687 +4768 9842 +4768 9459 +4768 7416 +4769 7809 +4769 8421 +4769 8010 +4769 6604 +4769 7935 +4770 7853 +4770 6860 +4770 8653 +4770 6512 +4770 5393 +4770 9973 +4770 6921 +4770 7224 +4770 5564 +4770 9565 +4770 6430 +4770 7679 +4771 6788 +4771 4902 +4771 7847 +4771 5097 +4771 8044 +4771 7407 +4771 9137 +4771 4788 +4771 9496 +4771 9978 +4771 7384 +4771 6015 +4772 9248 +4772 8161 +4772 8794 +4772 5931 +4772 7183 +4772 8725 +4772 4890 +4772 6141 +4773 8320 +4773 9396 +4773 9205 +4773 8214 +4773 9879 +4773 5404 +4773 7902 +4773 9887 +4774 7873 +4774 8208 +4774 4935 +4774 9522 +4774 9398 +4774 9531 +4774 6844 +4774 5311 +4774 7495 +4774 7780 +4774 8427 +4774 9069 +4774 9336 +4775 9120 +4775 9857 +4775 8834 +4775 9635 +4775 7716 +4775 7912 +4775 6987 +4775 4909 +4775 9262 +4775 5140 +4775 5781 +4775 5654 +4775 6360 +4775 8634 +4775 9564 +4776 7235 +4776 6789 +4776 9321 +4776 5837 +4776 7789 +4776 7670 +4776 8261 +4777 4992 +4777 6547 +4777 6814 +4777 5919 +4777 4901 +4777 4779 +4777 8541 +4777 7487 +4777 6467 +4777 7606 +4777 5065 +4777 9682 +4777 6230 +4777 7514 +4777 6803 +4777 6781 +4778 5041 +4778 9509 +4778 6726 +4778 8265 +4778 9319 +4778 5749 +4778 4822 +4778 4985 +4779 7039 +4779 8102 +4779 9841 +4779 8234 +4779 4942 +4779 7697 +4779 7278 +4779 6519 +4779 5372 +4779 5287 +4779 5310 +4779 5407 +4780 9525 +4780 5814 +4780 7353 +4780 5056 +4780 8264 +4780 5834 +4780 9810 +4780 5598 +4780 6889 +4780 7662 +4780 8058 +4781 7360 +4781 6092 +4781 5833 +4781 8847 +4781 8722 +4781 8402 +4781 4787 +4781 8439 +4781 6362 +4781 8188 +4781 6906 +4782 7008 +4782 7809 +4782 8836 +4782 5285 +4782 5614 +4782 7761 +4782 8274 +4782 7445 +4782 6909 +4783 8705 +4783 7703 +4783 8377 +4783 5832 +4783 9424 +4783 8537 +4784 7433 +4784 5653 +4784 6490 +4784 5805 +4784 9650 +4784 9783 +4784 4795 +4784 7641 +4784 7002 +4784 5859 +4785 8005 +4785 7887 +4785 8592 +4785 7082 +4785 7124 +4785 9078 +4785 9401 +4786 8545 +4786 6145 +4786 7113 +4786 4880 +4786 6985 +4786 8506 +4787 8578 +4787 8324 +4787 5125 +4787 4881 +4787 7410 +4787 5972 +4787 7419 +4788 9857 +4788 9476 +4788 9410 +4788 7602 +4788 8888 +4788 7102 +4788 6210 +4788 9539 +4788 9668 +4788 8262 +4788 5584 +4788 8919 +4788 6891 +4788 6643 +4788 7670 +4789 8571 +4789 5477 +4789 7815 +4789 9193 +4789 6858 +4789 8369 +4789 9746 +4789 7541 +4789 9818 +4789 6008 +4789 8031 +4790 5312 +4790 6416 +4790 9090 +4790 8934 +4790 4967 +4790 4954 +4790 6013 +4790 6640 +4790 8210 +4790 5114 +4790 5418 +4791 7653 +4791 9703 +4791 9136 +4791 6643 +4791 7574 +4791 8375 +4791 5818 +4791 7836 +4792 4807 +4792 7443 +4792 5570 +4792 5701 +4792 8985 +4792 5818 +4792 6975 +4793 7394 +4793 6467 +4793 7940 +4793 5381 +4793 5481 +4793 6765 +4793 9228 +4793 6946 +4793 7503 +4793 9744 +4793 6385 +4793 9300 +4793 8053 +4793 5718 +4793 7413 +4793 6459 +4793 8799 +4794 7060 +4794 9110 +4794 8604 +4794 5660 +4794 7085 +4794 9273 +4794 5565 +4794 5696 +4794 7842 +4794 7262 +4794 6116 +4794 4966 +4794 7786 +4794 9586 +4794 8185 +4794 9214 +4795 6031 +4795 5666 +4795 8747 +4795 8112 +4795 7732 +4795 8128 +4795 4930 +4795 4803 +4795 6597 +4795 5219 +4795 8548 +4795 8186 +4796 6785 +4796 5770 +4796 6828 +4796 5359 +4796 9361 +4796 6737 +4796 8089 +4796 5084 +4797 5283 +4797 6087 +4797 8247 +4797 9455 +4797 8240 +4797 6097 +4797 9108 +4797 5813 +4797 7155 +4797 9237 +4798 8705 +4798 7842 +4798 6444 +4798 8629 +4798 6711 +4798 8264 +4798 6101 +4798 7769 +4798 5264 +4798 4971 +4798 9938 +4798 5498 +4798 9470 +4799 6443 +4799 9611 +4799 6286 +4799 6425 +4799 6298 +4799 7733 +4799 6431 +4799 8381 +4799 6477 +4799 9684 +4799 7637 +4799 9048 +4799 9177 +4799 5596 +4799 6652 +4800 7760 +4800 9559 +4800 9123 +4800 8356 +4800 7109 +4800 9930 +4800 8183 +4800 5752 +4800 8660 +4800 6104 +4800 5722 +4800 6877 +4801 9120 +4801 7396 +4801 7560 +4801 7561 +4801 5294 +4801 5233 +4801 9234 +4801 5559 +4802 8772 +4802 6166 +4802 5671 +4802 5872 +4802 5105 +4802 7014 +4802 7487 +4803 7076 +4803 8552 +4803 5610 +4803 9326 +4803 4855 +4803 8401 +4803 6166 +4803 9757 +4803 6239 +4804 8410 +4804 8098 +4804 9030 +4804 8403 +4804 6761 +4804 9002 +4804 8556 +4804 7565 +4804 7027 +4804 7586 +4804 9010 +4804 7155 +4804 5847 +4804 7034 +4804 5951 +4805 8931 +4805 8423 +4805 6063 +4805 7984 +4805 6464 +4805 8698 +4806 5409 +4806 6436 +4806 6471 +4806 9103 +4806 5208 +4806 6266 +4806 7991 +4806 7096 +4806 8061 +4807 9348 +4807 5021 +4807 6824 +4807 6959 +4807 7217 +4807 6198 +4807 5450 +4807 9725 +4808 9864 +4808 6274 +4808 8590 +4808 6178 +4808 8236 +4808 6334 +4808 6361 +4808 9321 +4808 5098 +4808 5867 +4809 9664 +4809 6881 +4809 8067 +4809 4937 +4809 5195 +4809 5740 +4809 9807 +4809 6555 +4809 5396 +4809 9497 +4809 9148 +4809 5246 +4809 8735 +4810 9216 +4810 8081 +4810 4886 +4810 6689 +4810 5929 +4810 6711 +4810 7101 +4810 9281 +4810 7622 +4810 5588 +4810 9704 +4810 8435 +4810 8056 +4811 7680 +4811 6659 +4811 6282 +4811 5061 +4811 6312 +4811 6830 +4811 5423 +4811 6715 +4811 9406 +4811 8138 +4811 5469 +4811 7399 +4811 6260 +4811 7806 +4812 5286 +4812 7252 +4812 8169 +4812 9290 +4812 5637 +4812 5147 +4812 6346 +4812 7901 +4812 9919 +4813 5251 +4813 5255 +4813 5522 +4813 5652 +4813 5916 +4813 6946 +4813 6056 +4813 6709 +4813 7225 +4813 7234 +4813 6340 +4813 7498 +4813 6610 +4813 7127 +4813 7640 +4813 6362 +4813 9695 +4814 4865 +4814 8964 +4814 5650 +4814 5144 +4814 8366 +4814 9523 +4814 7620 +4814 6987 +4814 8786 +4814 7380 +4814 8542 +4814 8938 +4814 6767 +4814 7418 +4815 8737 +4815 5315 +4815 5221 +4815 5190 +4815 7393 +4815 6256 +4815 9403 +4815 8508 +4815 7646 +4815 8447 +4816 9152 +4816 9218 +4816 9990 +4816 8584 +4816 5769 +4816 8731 +4816 6491 +4816 5030 +4816 9137 +4816 5435 +4816 7103 +4816 7232 +4816 8900 +4816 4854 +4816 7497 +4816 5455 +4816 7639 +4816 7521 +4816 7144 +4816 7919 +4816 7565 +4817 6240 +4817 7074 +4817 6117 +4817 8395 +4817 9453 +4817 6203 +4817 9682 +4817 9763 +4817 8345 +4817 8263 +4817 5595 +4817 9945 +4817 9917 +4818 4835 +4818 8869 +4818 9116 +4818 6055 +4818 4898 +4818 7342 +4818 6861 +4818 6076 +4819 6123 +4819 7556 +4819 5638 +4819 9742 +4819 8086 +4819 6810 +4819 8356 +4819 8102 +4819 5295 +4819 5301 +4819 6075 +4819 5952 +4819 7333 +4819 8288 +4819 8294 +4819 7787 +4819 6782 +4819 7545 +4819 7038 +4820 7936 +4820 7553 +4820 6028 +4820 7319 +4820 7609 +4820 6724 +4820 8266 +4820 9422 +4820 5077 +4820 9944 +4820 5112 +4820 8149 +4821 8587 +4821 7845 +4821 9005 +4821 7360 +4821 6081 +4821 5285 +4821 5477 +4821 4975 +4821 9215 +4822 8294 +4822 6385 +4822 8616 +4822 6575 +4823 5793 +4823 5003 +4823 5387 +4823 5843 +4823 8828 +4823 6878 +4824 9475 +4824 9094 +4824 6029 +4824 6288 +4824 7447 +4824 6937 +4824 9501 +4824 8359 +4824 9513 +4824 5427 +4824 5082 +4824 5614 +4824 7539 +4824 7028 +4825 4961 +4825 5539 +4825 6537 +4825 9381 +4825 7581 +4825 8541 +4825 6970 +4825 5151 +4826 8448 +4826 6341 +4826 8326 +4826 5514 +4826 6726 +4826 5613 +4826 7183 +4826 6768 +4826 9594 +4826 5405 +4826 6974 +4827 6848 +4827 5252 +4827 7054 +4827 6674 +4827 5559 +4827 5436 +4828 6435 +4828 9542 +4828 9068 +4828 7714 +4828 5262 +4828 6613 +4829 5186 +4829 8324 +4829 5990 +4829 5447 +4829 8627 +4829 8952 +4829 5117 +4829 9022 +4830 4878 +4830 8207 +4830 7452 +4830 5278 +4830 9891 +4830 7304 +4830 5045 +4830 9782 +4830 5951 +4830 7874 +4830 7500 +4830 6606 +4830 8291 +4830 5864 +4830 8566 +4830 8315 +4831 9217 +4831 9445 +4831 6866 +4831 7726 +4831 8126 +4831 8822 +4831 7736 +4831 9753 +4831 8762 +4832 7875 +4832 8804 +4832 7116 +4832 5519 +4832 5685 +4832 9403 +4832 4860 +4833 7554 +4833 5003 +4833 7885 +4833 5016 +4833 8608 +4833 6568 +4833 8376 +4833 5701 +4833 9805 +4833 6735 +4833 6868 +4833 7010 +4833 9570 +4833 8306 +4833 8187 +4834 8931 +4834 9063 +4834 6478 +4834 7727 +4834 6735 +4835 5603 +4835 5622 +4835 5319 +4835 7528 +4835 5667 +4835 9780 +4835 7830 +4835 5679 +4835 9853 +4835 9311 +4836 9493 +4836 5911 +4836 4915 +4836 8507 +4836 8127 +4836 6735 +4836 8017 +4836 9052 +4836 4923 +4836 6756 +4836 8037 +4836 5350 +4837 5569 +4837 5090 +4837 6762 +4837 6508 +4837 8046 +4837 9431 +4837 6932 +4837 6811 +4837 7580 +4837 5117 +4838 5817 +4838 8901 +4838 7816 +4838 5677 +4838 6927 +4838 8767 +4838 5054 +4839 7907 +4839 5060 +4839 9865 +4839 8845 +4839 6255 +4839 9648 +4839 6163 +4839 9750 +4839 8764 +4839 8351 +4840 8329 +4840 5916 +4840 7079 +4840 7108 +4840 8267 +4840 8143 +4840 8918 +4840 5471 +4840 8678 +4840 9973 +4840 5751 +4841 6530 +4841 6312 +4841 4910 +4841 9776 +4841 8906 +4841 8651 +4841 6178 +4841 5718 +4841 8279 +4841 7640 +4841 6265 +4842 6107 +4842 7174 +4842 5255 +4842 7882 +4842 6542 +4842 8820 +4842 5070 +4842 9049 +4842 5080 +4842 8948 +4842 8735 +4843 4993 +4843 7298 +4843 8961 +4843 9615 +4843 9254 +4843 5415 +4843 7105 +4843 5581 +4843 7257 +4843 8306 +4843 6778 +4843 4860 +4844 6147 +4844 8117 +4844 5418 +4844 7979 +4844 9806 +4844 7734 +4844 6616 +4844 9853 +4844 7103 +4845 6531 +4845 5774 +4845 5396 +4845 6046 +4845 9542 +4845 6957 +4845 7494 +4845 8014 +4845 6747 +4845 6397 +4845 7290 +4845 8829 +4846 6976 +4846 9442 +4846 8778 +4846 5963 +4846 6956 +4846 7950 +4846 6256 +4846 9598 +4847 8772 +4847 5682 +4847 8520 +4847 6173 +4847 8125 +4847 6057 +4847 8818 +4847 7252 +4847 6485 +4847 5335 +4847 9176 +4847 6068 +4847 5594 +4847 9469 +4848 6786 +4848 6171 +4848 8223 +4848 9905 +4848 6332 +4848 8523 +4848 7778 +4848 8191 +4848 6525 +4849 9104 +4849 5165 +4849 6150 +4849 7410 +4849 7054 +4849 9645 +4849 6991 +4849 8766 +4850 6147 +4850 7940 +4850 8713 +4850 5139 +4850 9634 +4850 9774 +4850 6325 +4850 8674 +4850 9956 +4850 8872 +4850 8952 +4851 4927 +4851 8507 +4851 7813 +4851 9491 +4851 9835 +4851 7918 +4851 6323 +4851 8766 +4851 5146 +4851 7068 +4852 8102 +4852 5231 +4852 8338 +4852 6259 +4852 5556 +4852 9723 +4853 6267 +4853 6374 +4853 7277 +4853 7027 +4853 9230 +4853 5912 +4854 8512 +4854 5016 +4854 6052 +4854 7981 +4854 8157 +4854 9909 +4854 6076 +4854 8000 +4854 7761 +4854 9435 +4854 7389 +4854 9651 +4854 6506 +4854 8171 +4854 5228 +4855 9222 +4855 7306 +4855 7694 +4855 9540 +4855 5979 +4855 7719 +4855 8232 +4855 8746 +4855 8388 +4855 7509 +4855 8923 +4855 7848 +4855 9332 +4855 9721 +4856 5292 +4856 5963 +4856 6283 +4856 8975 +4856 5970 +4856 5379 +4856 5334 +4856 4987 +4857 6150 +4857 5802 +4857 5389 +4857 4914 +4857 5523 +4857 4981 +4857 9471 +4858 8758 +4858 6785 +4858 7947 +4858 8907 +4858 9674 +4858 7531 +4858 6832 +4858 8724 +4858 8725 +4858 7478 +4858 6681 +4858 7292 +4858 8234 +4859 6789 +4859 6663 +4859 7172 +4859 8996 +4859 5931 +4859 8109 +4859 6594 +4859 6369 +4859 9335 +4860 7170 +4860 7824 +4860 5909 +4860 5381 +4860 6315 +4860 7728 +4860 7880 +4860 8024 +4860 8039 +4860 9577 +4860 8941 +4860 7145 +4860 7679 +4861 6979 +4861 7716 +4861 9544 +4861 5219 +4861 9023 +4862 8119 +4862 8644 +4862 8901 +4862 5574 +4862 9032 +4862 8906 +4862 6606 +4862 8527 +4862 8400 +4862 9300 +4862 6106 +4862 5087 +4862 5220 +4862 9449 +4862 5356 +4862 8687 +4862 9715 +4862 7925 +4862 7286 +4863 9697 +4863 7075 +4863 9637 +4863 9001 +4863 7543 +4863 7413 +4864 5755 +4864 6503 +4864 7432 +4864 7789 +4864 6692 +4864 5786 +4864 9852 +4865 9362 +4865 6810 +4865 5411 +4865 8360 +4865 5434 +4865 7841 +4865 7885 +4865 5967 +4865 5336 +4865 7009 +4865 9328 +4865 7419 +4866 8710 +4866 5903 +4866 8727 +4866 9376 +4866 5421 +4866 9780 +4866 5941 +4866 5920 +4866 8525 +4866 8781 +4866 7142 +4866 5225 +4866 5366 +4867 7809 +4867 6022 +4867 5136 +4867 8807 +4867 9708 +4867 9261 +4867 6190 +4867 8112 +4867 5715 +4867 6196 +4867 6237 +4867 6366 +4868 7714 +4868 9655 +4868 5190 +4868 8432 +4868 5003 +4868 5485 +4868 9744 +4868 9267 +4868 8088 +4868 9501 +4868 6046 +4868 5733 +4869 8628 +4869 4898 +4869 6171 +4869 5806 +4869 7111 +4869 6441 +4869 5218 +4869 8244 +4869 5845 +4869 5561 +4869 9087 +4869 7551 +4870 7839 +4870 6428 +4870 8970 +4870 9671 +4870 5727 +4870 7803 +4870 9529 +4870 8026 +4870 9563 +4870 5756 +4871 6658 +4871 5264 +4871 7827 +4871 6166 +4871 6820 +4871 9767 +4871 5289 +4871 5162 +4871 8237 +4871 8885 +4871 7615 +4871 6992 +4871 8739 +4871 8298 +4871 6778 +4872 6144 +4872 9985 +4872 9609 +4872 5015 +4872 7991 +4872 6072 +4872 7646 +4872 6718 +4873 7556 +4873 6533 +4873 8616 +4873 9110 +4873 9593 +4873 9660 +4874 8352 +4874 8004 +4874 6537 +4874 4939 +4874 8530 +4874 7257 +4875 8966 +4875 8082 +4875 6426 +4875 9626 +4875 9507 +4875 5174 +4875 7391 +4875 5479 +4875 5242 +4876 9183 +4876 5039 +4876 9075 +4876 6424 +4876 6767 +4876 4956 +4877 5943 +4877 8740 +4877 9502 +4878 9090 +4878 8845 +4878 9627 +4878 5278 +4878 8997 +4878 7630 +4878 6496 +4878 7142 +4878 5864 +4878 6764 +4878 6265 +4879 9697 +4879 9163 +4879 6821 +4879 6343 +4879 9546 +4879 6796 +4879 9455 +4879 7796 +4879 5496 +4879 7900 +4880 8134 +4880 5961 +4880 5226 +4880 5394 +4880 8048 +4880 6609 +4880 8311 +4880 5433 +4880 7549 +4880 9854 +4881 7715 +4881 9254 +4881 8531 +4881 5223 +4881 6190 +4881 6928 +4882 8801 +4882 7306 +4882 5259 +4882 8492 +4882 6063 +4882 9910 +4882 8713 +4882 8556 +4883 5824 +4883 5146 +4883 9380 +4883 8616 +4883 7478 +4883 4921 +4883 6588 +4883 6720 +4883 9538 +4883 8902 +4883 6476 +4883 8908 +4883 8672 +4883 9060 +4883 6520 +4883 6653 +4884 7811 +4884 6504 +4884 6314 +4884 9101 +4884 8072 +4884 7178 +4884 9911 +4884 9401 +4884 7646 +4885 6496 +4885 7302 +4885 9342 +4885 7928 +4885 8605 +4885 8734 +4885 8607 +4886 8990 +4886 5917 +4886 6854 +4886 9928 +4886 7729 +4886 7155 +4886 8374 +4886 7383 +4886 9656 +4887 6850 +4887 8582 +4887 9866 +4887 8622 +4887 7924 +4887 4951 +4887 4893 +4887 7870 +4888 6338 +4888 7811 +4888 9444 +4888 6902 +4888 8617 +4888 9901 +4888 8427 +4888 7989 +4888 5993 +4888 8185 +4888 9909 +4889 7561 +4889 7703 +4889 7086 +4889 6835 +4889 4931 +4889 7753 +4889 9421 +4889 9043 +4889 9209 +4889 5209 +4889 9961 +4889 8939 +4890 8706 +4890 5786 +4890 9004 +4890 9901 +4890 6575 +4890 5820 +4890 6903 +4890 9292 +4890 5970 +4890 9615 +4890 8672 +4890 9065 +4890 7662 +4890 6773 +4890 8439 +4890 6267 +4890 8701 +4891 5826 +4891 5211 +4891 8812 +4891 8974 +4891 8400 +4891 6226 +4891 9582 +4891 8233 +4891 8922 +4891 8763 +4892 9099 +4892 9875 +4892 5319 +4892 7007 +4893 5298 +4893 5086 +4893 8108 +4893 5555 +4893 8829 +4893 7603 +4893 6356 +4893 9325 +4893 8024 +4893 9017 +4893 5852 +4894 9571 +4894 6725 +4894 5772 +4894 6669 +4894 8512 +4894 7761 +4894 8146 +4894 8633 +4894 6034 +4894 5183 +4895 5669 +4895 9098 +4895 5647 +4895 5839 +4895 7967 +4896 6592 +4896 9889 +4896 9046 +4896 9930 +4896 8076 +4896 6157 +4896 6287 +4896 7920 +4896 5042 +4896 7731 +4896 8656 +4896 8896 +4896 7226 +4896 9741 +4896 7290 +4897 8617 +4897 9068 +4897 5389 +4897 8111 +4897 8368 +4897 6377 +4897 5242 +4897 6843 +4898 9414 +4898 7464 +4898 6704 +4898 8529 +4898 5567 +4898 5529 +4898 7099 +4899 5960 +4899 9290 +4899 6445 +4899 9168 +4899 8049 +4899 9300 +4899 9141 +4899 7032 +4899 9677 +4899 8949 +4900 6467 +4900 5222 +4900 7239 +4900 9575 +4900 7053 +4900 9647 +4900 5810 +4900 7715 +4900 6228 +4900 9897 +4900 8798 +4901 6816 +4901 6887 +4901 7626 +4901 6284 +4901 4910 +4901 7024 +4901 5681 +4901 7282 +4902 6305 +4902 7210 +4902 6961 +4902 6202 +4902 9668 +4902 8930 +4902 9450 +4903 9864 +4903 7692 +4903 7582 +4903 7963 +4903 8880 +4903 7735 +4903 7993 +4903 6588 +4903 6467 +4903 7492 +4903 5325 +4903 9808 +4903 6997 +4903 9448 +4903 6250 +4903 4974 +4903 9077 +4903 9083 +4904 6096 +4904 5829 +4904 8287 +4904 7763 +4904 5403 +4904 7903 +4905 7171 +4905 5130 +4905 7708 +4905 6557 +4905 7458 +4905 6565 +4905 9777 +4905 8476 +4905 6828 +4905 9649 +4905 9803 +4905 8660 +4905 7261 +4905 9824 +4905 8289 +4905 7923 +4905 9085 +4906 7963 +4906 5797 +4906 7282 +4906 5869 +4906 9615 +4906 5209 +4906 6876 +4906 6269 +4906 7737 +4907 8896 +4907 7649 +4907 6018 +4907 5155 +4907 9862 +4907 8647 +4907 6444 +4907 6956 +4907 6766 +4907 6292 +4907 5685 +4907 9438 +4908 5611 +4908 7940 +4908 5877 +4908 7254 +4908 7385 +4908 6551 +4909 9748 +4909 5274 +4909 6438 +4909 8252 +4909 6965 +4909 9664 +4909 8268 +4909 7387 +4909 6364 +4909 5630 +4910 5011 +4910 8474 +4910 5661 +4910 9250 +4910 7205 +4910 5851 +4910 8549 +4910 8567 +4911 5507 +4911 8651 +4911 6095 +4911 9072 +4911 7637 +4911 6071 +4911 6411 +4911 5487 +4911 6591 +4912 9222 +4912 9097 +4912 6308 +4912 9389 +4912 7860 +4912 4920 +4912 6586 +4912 7103 +4912 7748 +4912 5191 +4912 5968 +4912 7653 +4912 9845 +4912 6138 +4913 8064 +4913 7949 +4913 7314 +4913 8596 +4913 9514 +4913 7211 +4913 6327 +4913 6974 +4913 5567 +4913 8257 +4913 5572 +4913 5710 +4913 6967 +4913 6240 +4913 9828 +4913 6382 +4914 5418 +4914 7474 +4914 7859 +4914 5946 +4914 7391 +4914 9158 +4914 5464 +4914 9311 +4914 7273 +4914 5880 +4914 7165 +4914 4990 +4915 6854 +4915 5511 +4915 8650 +4915 8286 +4915 6542 +4915 6353 +4915 7762 +4915 6419 +4915 5621 +4915 8214 +4915 5137 +4915 6203 +4915 7379 +4915 7249 +4916 6370 +4916 5316 +4916 6153 +4916 6507 +4916 6492 +4916 7826 +4916 8485 +4917 7475 +4917 9271 +4917 7248 +4917 7762 +4917 6323 +4917 7863 +4917 8554 +4917 9887 +4918 5920 +4918 7254 +4918 6090 +4918 9323 +4918 5327 +4918 8561 +4918 5652 +4918 7006 +4918 5403 +4918 7839 +4919 5838 +4919 7491 +4919 5006 +4919 8749 +4919 8451 +4919 8983 +4919 9497 +4920 5670 +4920 7463 +4920 5294 +4920 7570 +4920 6007 +4920 7344 +4921 9089 +4921 6626 +4921 7535 +4921 8050 +4921 7551 +4921 9209 +4921 5822 +4922 9953 +4922 9591 +4922 6922 +4922 8043 +4922 7599 +4922 7642 +4923 9344 +4923 5642 +4923 9238 +4923 5158 +4923 9909 +4923 6083 +4923 9158 +4923 7016 +4923 8359 +4924 8707 +4924 6660 +4924 5795 +4924 6311 +4924 8883 +4924 8758 +4924 6425 +4924 6094 +4924 5454 +4924 6377 +4924 7289 +4924 6396 +4924 5758 +4925 8075 +4925 9484 +4925 7822 +4925 5668 +4925 6577 +4925 6200 +4925 8382 +4925 9057 +4925 5357 +4925 6903 +4925 7294 +4926 5056 +4926 8386 +4926 6470 +4926 6483 +4926 9317 +4926 6367 +4927 9025 +4927 5474 +4927 8964 +4927 9164 +4927 8779 +4927 5740 +4927 8770 +4927 8072 +4927 7610 +4927 8125 +4927 9854 +4928 8641 +4928 7651 +4928 8742 +4928 5230 +4928 5480 +4928 8714 +4928 6514 +4928 5486 +4928 8655 +4928 5960 +4928 5848 +4928 5810 +4928 7832 +4928 6554 +4928 4956 +4929 7494 +4929 4976 +4929 9741 +4929 8404 +4929 6398 +4929 5740 +4929 7451 +4929 8798 +4930 8064 +4930 7460 +4930 9223 +4930 8106 +4930 9035 +4930 7342 +4930 9295 +4930 7931 +4930 8187 +4930 7997 +4930 5662 +4931 5392 +4931 9120 +4931 8355 +4931 9896 +4931 8888 +4931 9017 +4931 7490 +4931 9930 +4931 5218 +4931 7119 +4931 7522 +4931 8742 +4931 5745 +4932 6885 +4932 7910 +4932 9864 +4932 5282 +4932 7895 +4932 8834 +4932 8754 +4932 7347 +4932 6109 +4933 6123 +4933 8342 +4933 7195 +4933 8125 +4933 6336 +4933 5569 +4933 6595 +4933 5333 +4933 6649 +4933 7259 +4933 9706 +4933 5227 +4933 7792 +4933 7934 +4934 9280 +4934 9473 +4934 8027 +4934 6564 +4934 9031 +4934 5421 +4934 9646 +4934 6799 +4934 9619 +4934 6742 +4935 5874 +4935 7722 +4935 7853 +4935 8530 +4935 5454 +4935 9590 +4935 6265 +4935 8184 +4936 7690 +4936 6035 +4936 5034 +4936 7732 +4936 9281 +4936 6738 +4936 8672 +4936 7275 +4936 8565 +4936 7414 +4936 8825 +4936 9214 +4937 5385 +4937 5046 +4937 6460 +4937 8005 +4937 6223 +4937 7252 +4937 6231 +4937 7779 +4937 8172 +4937 6642 +4937 6132 +4937 5247 +4937 8316 +4937 9045 +4938 9953 +4938 4996 +4938 7270 +4938 8717 +4938 8371 +4938 8542 +4938 9685 +4939 9600 +4939 9686 +4939 6636 +4939 9384 +4939 5118 +4939 8927 +4940 6699 +4940 8077 +4940 9197 +4940 7569 +4940 5973 +4940 9243 +4940 9432 +4940 5109 +4941 5056 +4941 5603 +4941 5727 +4941 7556 +4941 6133 +4941 6623 +4941 7322 +4941 9723 +4941 8853 +4941 6879 +4942 9980 +4942 8585 +4942 9694 +4942 7135 +4942 9578 +4943 8455 +4943 8748 +4943 9994 +4943 8849 +4943 9507 +4943 5156 +4943 9642 +4943 7851 +4943 9518 +4943 6976 +4943 8900 +4943 7843 +4943 8673 +4943 9449 +4943 5880 +4944 9546 +4944 7373 +4944 8794 +4944 5231 +4945 8665 +4945 8419 +4945 7217 +4945 8295 +4945 9161 +4945 8434 +4945 9489 +4945 7602 +4945 9940 +4945 5846 +4945 8823 +4945 9631 +4945 9919 +4946 6625 +4946 7780 +4946 6387 +4946 8527 +4946 8185 +4946 9677 +4946 8733 +4946 5342 +4947 5155 +4947 6759 +4947 4969 +4947 7144 +4947 7499 +4947 7101 +4947 7998 +4947 7871 +4948 6561 +4948 9698 +4948 8904 +4948 6445 +4948 9815 +4949 9216 +4949 7944 +4949 6924 +4949 5267 +4949 8873 +4949 8432 +4949 6357 +4949 6359 +4949 9693 +4949 9963 +4949 8444 +4950 8512 +4950 5408 +4950 9686 +4950 8806 +4950 9638 +4950 9340 +4950 9739 +4950 8783 +4950 8570 +4950 9404 +4950 8997 +4951 7072 +4951 5573 +4951 8455 +4951 7048 +4951 6731 +4951 8140 +4951 6766 +4951 6095 +4951 8430 +4951 5175 +4952 5890 +4952 5348 +4952 5350 +4952 5994 +4952 7234 +4952 9645 +4952 9520 +4952 9171 +4952 5625 +4952 9946 +4952 5546 +4952 5375 +4953 5313 +4953 7812 +4953 6541 +4953 5040 +4953 5428 +4953 7701 +4953 8340 +4953 9053 +4953 9247 +4954 5779 +4954 5032 +4954 5546 +4954 5170 +4954 6707 +4954 9427 +4954 9557 +4954 6618 +4954 6203 +4954 8445 +4955 6759 +4955 9865 +4955 7756 +4955 5039 +4955 5362 +4955 7796 +4955 9334 +4955 9950 +4956 8713 +4956 5771 +4956 8355 +4956 6567 +4956 5961 +4956 8649 +4956 7894 +4956 7272 +4956 8171 +4956 6765 +4956 7153 +4956 7924 +4957 5449 +4957 5099 +4957 6126 +4957 9423 +4957 8755 +4957 5593 +4957 6842 +4957 7327 +4957 5791 +4958 6081 +4958 7957 +4958 7834 +4958 6053 +4958 7489 +4958 9807 +4958 9680 +4958 8547 +4958 7268 +4958 8936 +4958 7019 +4958 9770 +4959 8934 +4959 9031 +4959 8297 +4959 7946 +4959 7725 +4959 8435 +4959 7828 +4959 5339 +4960 5025 +4960 7170 +4960 6116 +4960 7144 +4960 5065 +4960 7632 +4960 8026 +4960 6175 +4961 6016 +4961 8584 +4961 5675 +4961 7607 +4961 9544 +4961 6620 +4961 6757 +4961 5232 +4962 8471 +4962 5228 +4962 6125 +4962 5901 +4962 5585 +4962 7701 +4963 7296 +4963 6990 +4963 9745 +4963 9527 +4963 6014 +4964 7424 +4964 5552 +4964 6053 +4964 8873 +4964 8906 +4964 8107 +4964 5792 +4964 9136 +4964 8948 +4964 9341 +4964 7775 +4964 6077 +4964 6494 +4965 9283 +4965 9411 +4965 5402 +4966 5408 +4966 7649 +4966 7885 +4966 9128 +4966 6415 +4966 8179 +4966 9748 +4966 6900 +4966 8215 +4966 7931 +4966 8668 +4966 9438 +4967 5139 +4967 8307 +4967 5110 +4967 8660 +4967 5749 +4967 9269 +4968 8960 +4968 6531 +4968 5407 +4968 6433 +4968 8872 +4968 6579 +4968 9054 +4968 8375 +4968 9150 +4968 9537 +4968 9377 +4968 6736 +4968 5470 +4968 5094 +4968 7527 +4968 7134 +4968 9128 +4969 8385 +4969 8595 +4969 6634 +4969 5814 +4969 8150 +4969 5144 +4970 9860 +4970 5125 +4970 9862 +4970 7927 +4970 8206 +4970 9746 +4970 7543 +4970 8824 +4971 7520 +4971 6886 +4971 7498 +4971 9133 +4971 8958 +4971 9971 +4971 7732 +4971 8921 +4971 7672 +4971 7289 +4972 5163 +4972 8323 +4972 7946 +4972 8779 +4972 6648 +4972 7474 +4972 8147 +4973 7330 +4973 6184 +4973 7746 +4973 7829 +4973 6487 +4973 8030 +4974 5512 +4974 9753 +4974 7837 +4974 5793 +4974 5298 +4974 8394 +4974 6477 +4974 9061 +4974 5996 +4974 6254 +4974 9072 +4975 8258 +4975 8232 +4975 7083 +4975 7339 +4975 6131 +4975 7477 +4975 9892 +4975 8282 +4975 9021 +4975 9887 +4976 8091 +4976 7458 +4976 6948 +4976 6322 +4976 9264 +4976 6961 +4976 8159 +4976 5437 +4976 8405 +4976 7646 +4976 6630 +4976 7142 +4976 6774 +4976 8441 +4976 6143 +4977 6408 +4977 6793 +4977 8985 +4977 5019 +4977 6815 +4977 6310 +4977 8365 +4977 6054 +4977 7236 +4977 5832 +4977 7625 +4977 8787 +4977 8165 +4977 8299 +4977 7535 +4977 7167 +4978 9352 +4978 5011 +4978 9109 +4978 6967 +4978 8762 +4978 8278 +4978 8283 +4978 5216 +4978 6891 +4978 5010 +4978 7414 +4978 5112 +4978 6905 +4979 8204 +4979 9365 +4979 5564 +4979 6721 +4979 9797 +4979 8656 +4979 7378 +4979 8277 +4979 8920 +4979 7907 +4979 9556 +4979 5302 +4980 6946 +4980 5293 +4980 5748 +4980 6332 +4980 8897 +4980 6723 +4980 9928 +4980 9939 +4980 6229 +4980 6238 +4980 6243 +4980 9452 +4980 9588 +4981 8268 +4981 8812 +4981 7917 +4981 9936 +4981 6098 +4981 9013 +4981 5814 +4981 7991 +4981 8696 +4981 8890 +4981 7899 +4981 6426 +4982 6433 +4982 7205 +4982 9446 +4982 5671 +4982 8764 +4982 8199 +4982 7437 +4982 8402 +4982 9715 +4982 7209 +4982 5652 +4982 5660 +4983 6390 +4983 5159 +4983 6940 +4983 9163 +4983 6798 +4983 5525 +4983 8101 +4984 8841 +4984 9226 +4984 8850 +4984 8470 +4984 5295 +4984 9381 +4984 7177 +4984 7227 +4984 6215 +4984 8534 +4984 8926 +4984 5094 +4984 9514 +4985 4993 +4985 9102 +4985 9578 +4985 9887 +4985 5811 +4985 9278 +4985 7618 +4985 6345 +4986 6406 +4986 8722 +4986 8724 +4986 7720 +4986 7081 +4986 9437 +4986 9652 +4986 6332 +4986 7111 +4986 7759 +4986 6876 +4986 6365 +4987 9218 +4987 5747 +4987 8263 +4987 9480 +4987 5742 +4987 5557 +4987 5981 +4988 5572 +4988 7689 +4988 9516 +4988 8689 +4988 6835 +4988 9783 +4988 6328 +4988 5659 +4989 6911 +4989 9923 +4989 5596 +4989 7215 +4989 7442 +4989 8342 +4989 6075 +4989 6844 +4989 5983 +4990 8966 +4990 7367 +4990 8508 +4990 8170 +4990 6603 +4990 9490 +4990 5230 +4990 5583 +4990 5062 +4990 8247 +4990 7535 +4990 6782 +4990 7551 +4991 5008 +4991 6996 +4991 6810 +4991 6735 +4991 5503 +4992 7456 +4992 9728 +4992 5955 +4992 8806 +4992 8778 +4992 7246 +4992 5009 +4992 8195 +4992 8020 +4992 8117 +4992 5750 +4992 6654 +4993 6528 +4993 6786 +4993 5509 +4993 6668 +4993 5926 +4993 5031 +4993 9390 +4993 6218 +4993 5197 +4993 8406 +4993 7077 +4993 6506 +4993 6640 +4993 6909 +4993 7422 +4994 8322 +4994 9986 +4994 8083 +4994 9516 +4994 8008 +4994 8118 +4994 9019 +4994 6860 +4994 9741 +4994 8146 +4994 9940 +4994 7025 +4995 5031 +4995 5231 +4995 8600 +4995 7599 +4995 5119 +4996 7171 +4996 9360 +4996 9373 +4996 6943 +4996 8865 +4996 6188 +4996 5945 +4996 5188 +4996 8286 +4996 7657 +4996 8559 +4996 7929 +4997 6892 +4997 9642 +4997 9612 +4997 6129 +4997 8213 +4997 5241 +4997 7003 +4997 6012 +4997 6525 +4997 9694 +4998 8960 +4998 5505 +4998 6158 +4998 8475 +4998 6952 +4998 6324 +4998 9921 +4998 7886 +4998 5074 +4998 9934 +4998 5489 +4999 5269 +4999 8633 +4999 5155 +4999 7556 +4999 5751 +4999 9087 +4999 5844 +5000 6112 +5000 8929 +5000 5890 +5000 8101 +5000 9736 +5000 8493 +5000 7730 +5000 9174 +5000 7038 +5000 8965 +5001 7690 +5001 7455 +5001 5922 +5001 7846 +5001 7750 +5001 8779 +5001 8268 +5001 5464 +5001 7907 +5001 5755 +5001 9340 +5001 7805 +5002 9764 +5002 9766 +5002 5704 +5002 5390 +5002 6226 +5002 7571 +5002 8084 +5002 7925 +5002 6536 +5002 7930 +5002 5755 +5002 9562 +5002 7997 +5003 7754 +5003 9739 +5003 6026 +5003 5775 +5003 6288 +5003 8369 +5003 5432 +5003 8376 +5003 8599 +5004 5186 +5004 8231 +5004 7464 +5004 5231 +5004 9516 +5004 7119 +5004 7225 +5004 9175 +5004 9081 +5004 8091 +5004 9919 +5005 7328 +5005 8001 +5005 8567 +5005 8647 +5005 7302 +5005 8980 +5005 8286 +5005 9559 +5005 6846 +5006 5473 +5006 8900 +5006 6252 +5006 6474 +5006 5068 +5006 5456 +5006 6302 +5006 5428 +5006 5563 +5007 5890 +5007 5699 +5007 6949 +5007 5820 +5007 5035 +5007 6769 +5007 9842 +5007 7668 +5007 8060 +5007 5950 +5008 5559 +5008 6459 +5008 9796 +5008 6223 +5008 8400 +5008 7507 +5008 8926 +5008 6375 +5008 8295 +5008 9844 +5008 5366 +5009 8861 +5009 6818 +5009 8227 +5009 7094 +5009 6975 +5009 7884 +5009 8889 +5009 9182 +5009 5351 +5009 8808 +5010 7778 +5010 8100 +5010 7627 +5010 5486 +5010 8740 +5010 9820 +5010 5854 +5010 7775 +5011 5135 +5011 8849 +5011 9877 +5011 6681 +5011 7984 +5011 7989 +5011 5944 +5011 8993 +5011 8524 +5011 6993 +5011 8671 +5011 5088 +5011 6627 +5012 9989 +5012 9606 +5012 5329 +5012 9586 +5012 6036 +5012 9182 +5012 9562 +5012 7775 +5012 7098 +5012 7358 +5012 5791 +5013 8963 +5013 5063 +5013 7214 +5013 9540 +5013 6527 +5014 7590 +5014 6945 +5014 9386 +5014 7042 +5014 5710 +5014 8344 +5014 9017 +5014 8479 +5015 7395 +5015 7524 +5015 6894 +5015 8085 +5015 9209 +5015 9531 +5015 9220 +5016 9211 +5016 8708 +5016 7286 +5016 6663 +5016 8787 +5016 5940 +5016 9017 +5016 9471 +5016 9375 +5017 7520 +5017 5773 +5017 8051 +5017 7892 +5018 8932 +5018 5142 +5018 7785 +5018 6799 +5018 7510 +5018 5623 +5018 6778 +5018 8796 +5018 8762 +5019 8331 +5019 6414 +5019 8335 +5019 8123 +5019 6603 +5019 9807 +5019 8021 +5019 9830 +5019 9705 +5019 9840 +5019 6514 +5019 5119 +5020 9536 +5020 6884 +5020 6471 +5020 5195 +5020 5676 +5020 9199 +5020 5328 +5020 8581 +5020 7802 +5020 7035 +5020 8927 +5021 9761 +5021 5966 +5021 5673 +5021 9847 +5021 6863 +5021 8560 +5021 6009 +5021 7314 +5021 5495 +5021 6040 +5022 6179 +5022 6587 +5022 5062 +5022 8744 +5022 5577 +5022 5587 +5022 6704 +5022 7985 +5022 8563 +5022 9435 +5022 9418 +5022 9563 +5022 8922 +5023 8580 +5023 8458 +5023 5780 +5023 7979 +5023 7596 +5023 9917 +5023 5962 +5023 8017 +5023 9685 +5023 8039 +5023 9194 +5023 5753 +5023 9342 +5024 5896 +5024 9033 +5024 9781 +5024 9448 +5024 9747 +5024 9652 +5024 9949 +5024 6331 +5024 7069 +5024 7487 +5025 8721 +5025 7068 +5025 8641 +5025 8164 +5025 5116 +5025 5109 +5025 7547 +5026 7041 +5026 9276 +5026 8365 +5026 6478 +5026 8023 +5026 9881 +5026 8100 +5026 7772 +5026 8253 +5026 8414 +5027 8725 +5027 9002 +5027 5294 +5027 9009 +5027 8763 +5027 6010 +5027 8698 +5027 7931 +5027 9587 +5027 9083 +5028 6001 +5028 6056 +5028 6352 +5028 9295 +5028 7784 +5029 8322 +5029 5988 +5029 5447 +5029 8107 +5029 6726 +5029 5869 +5029 5810 +5029 6109 +5030 9489 +5030 5171 +5030 8359 +5030 6236 +5030 6323 +5030 6206 +5030 6976 +5030 6362 +5030 9948 +5030 7914 +5030 5996 +5030 5869 +5030 8947 +5030 8957 +5031 5512 +5031 8218 +5031 8611 +5031 8869 +5031 5160 +5031 8753 +5031 9923 +5031 7749 +5031 8523 +5031 7678 +5032 6980 +5032 6310 +5032 6760 +5032 8590 +5032 9711 +5032 5950 +5032 7254 +5032 8668 +5032 6970 +5033 7681 +5033 8259 +5033 5228 +5033 7830 +5033 7929 +5033 9498 +5034 8256 +5034 5121 +5034 9122 +5034 8756 +5034 6707 +5034 7956 +5034 7799 +5034 7768 +5034 5721 +5034 6203 +5035 8065 +5035 6594 +5035 5539 +5035 6757 +5035 8993 +5035 7466 +5035 5842 +5035 8696 +5036 7558 +5036 8204 +5036 6157 +5036 9490 +5036 5398 +5036 9370 +5036 5296 +5036 5812 +5036 9540 +5036 9553 +5036 6487 +5036 5977 +5036 9956 +5037 9440 +5037 7648 +5037 7301 +5037 7073 +5037 7254 +5037 6106 +5037 6173 +5038 5924 +5038 9637 +5038 8907 +5038 9575 +5038 9608 +5038 8951 +5038 9901 +5038 7229 +5038 9647 +5038 9497 +5038 9092 +5038 5981 +5038 8326 +5039 5760 +5039 5640 +5039 5641 +5039 6279 +5039 5407 +5039 6062 +5039 8240 +5039 8883 +5039 7870 +5039 8642 +5039 9424 +5039 5112 +5040 5506 +5040 8443 +5040 8548 +5040 6499 +5040 9904 +5040 7070 +5041 6532 +5041 7468 +5041 6895 +5041 5361 +5041 7283 +5041 5397 +5041 5302 +5041 7332 +5041 9551 +5041 6013 +5041 8405 +5042 5923 +5042 6209 +5042 8385 +5042 7089 +5042 6137 +5042 5882 +5042 8063 +5043 7937 +5043 8067 +5043 5126 +5043 6028 +5043 8193 +5043 5544 +5043 5417 +5043 8374 +5043 5183 +5043 7094 +5043 6982 +5043 5465 +5043 5474 +5043 9572 +5043 8425 +5043 9000 +5044 6465 +5044 6594 +5044 7845 +5044 6120 +5044 8734 +5044 5548 +5044 5295 +5044 8689 +5044 9903 +5044 7790 +5044 5087 +5045 5606 +5045 5638 +5045 7560 +5045 5422 +5045 8924 +5046 7947 +5046 5746 +5046 8055 +5046 6361 +5047 5281 +5047 8676 +5047 7333 +5047 5830 +5047 7431 +5047 6498 +5047 7666 +5047 6425 +5047 5341 +5048 5543 +5048 5233 +5048 8043 +5048 7503 +5048 7221 +5048 6399 +5048 6047 +5049 9416 +5049 8681 +5049 9896 +5049 6978 +5049 5083 +5049 8792 +5049 7417 +5049 5179 +5050 5507 +5050 7174 +5050 9229 +5050 6086 +5050 7983 +5050 7347 +5050 5685 +5050 7350 +5050 9030 +5050 5080 +5050 9126 +5050 7270 +5050 6763 +5050 5877 +5050 8828 +5051 9506 +5051 8580 +5051 9321 +5051 5458 +5051 6643 +5051 9940 +5051 8286 +5052 8009 +5052 6701 +5052 5392 +5052 6641 +5052 8566 +5052 5114 +5052 9676 +5052 7998 +5053 6854 +5053 6439 +5053 9879 +5053 7042 +5053 5395 +5053 6311 +5053 9465 +5053 7770 +5054 8871 +5054 5576 +5054 5638 +5054 6703 +5054 6303 +5055 9026 +5055 6699 +5055 5990 +5055 6650 +5055 9871 +5056 9472 +5056 7840 +5056 5152 +5056 6056 +5056 7420 +5056 9928 +5056 8349 +5056 7560 +5056 7546 +5056 5114 +5056 8381 +5057 7906 +5057 6502 +5057 7080 +5057 7628 +5057 9186 +5057 8146 +5057 7283 +5057 7156 +5057 6773 +5057 9209 +5057 5341 +5058 6992 +5058 8683 +5058 8102 +5058 5191 +5058 5292 +5058 9712 +5058 5620 +5058 9044 +5058 5433 +5058 5503 +5059 5313 +5059 9411 +5059 7111 +5059 7657 +5059 7502 +5059 5843 +5059 7896 +5059 7675 +5059 9871 +5059 5342 +5060 7392 +5060 8675 +5060 6616 +5060 9640 +5060 6889 +5060 8627 +5060 5585 +5060 6450 +5060 7673 +5060 9955 +5060 5406 +5061 7169 +5061 7044 +5061 8331 +5061 5537 +5061 8384 +5061 8900 +5061 8138 +5061 8924 +5061 6621 +5061 9312 +5062 9096 +5062 8985 +5062 6683 +5062 9774 +5062 5168 +5062 6204 +5062 9175 +5062 9048 +5062 5724 +5062 5216 +5062 5881 +5063 8257 +5063 7723 +5063 7943 +5063 5386 +5063 7343 +5063 5667 +5063 8121 +5063 9272 +5063 7389 +5064 7808 +5064 8323 +5064 6916 +5064 6275 +5064 5418 +5064 6787 +5064 8375 +5064 5308 +5064 9040 +5064 7265 +5064 5497 +5065 8936 +5065 9451 +5065 6381 +5065 9553 +5065 6994 +5065 5651 +5065 8598 +5066 8001 +5066 5125 +5066 5558 +5066 6221 +5066 9070 +5066 9457 +5066 5501 +5066 9438 +5067 6208 +5067 9151 +5067 9828 +5067 9674 +5067 9618 +5067 5811 +5067 6006 +5067 9787 +5067 6140 +5067 5343 +5068 6020 +5068 7824 +5068 8979 +5068 6814 +5068 8480 +5068 7080 +5068 7219 +5068 9269 +5068 9789 +5068 5195 +5068 7883 +5068 5608 +5069 9409 +5069 9207 +5069 8172 +5069 7166 +5069 6903 +5069 9467 +5069 5717 +5070 8832 +5070 5376 +5070 7787 +5070 6662 +5070 6160 +5070 7621 +5070 5486 +5071 6689 +5071 6306 +5071 8643 +5071 5610 +5071 7207 +5071 8881 +5071 8563 +5071 5763 +5071 8789 +5071 5526 +5071 5144 +5071 8475 +5071 7260 +5071 7126 +5072 7813 +5072 5640 +5072 7575 +5072 9356 +5072 9491 +5072 6254 +5072 5151 +5072 7975 +5072 9128 +5072 5935 +5072 7504 +5072 9815 +5073 7013 +5073 8191 +5073 5933 +5073 7376 +5073 6509 +5073 5618 +5073 6419 +5073 7541 +5073 8495 +5073 7996 +5073 7221 +5074 5380 +5074 7548 +5074 7244 +5074 6226 +5074 9550 +5074 9724 +5075 5432 +5075 8419 +5075 6340 +5075 5768 +5075 8459 +5075 6166 +5075 5528 +5075 5508 +5075 6020 +5075 8927 +5075 8879 +5075 7487 +5076 8855 +5076 6431 +5076 7221 +5076 5453 +5076 8563 +5076 9791 +5076 6229 +5077 9957 +5077 7753 +5077 5328 +5077 5400 +5077 9495 +5077 9178 +5077 6812 +5077 7165 +5077 5470 +5077 8098 +5078 5985 +5078 5603 +5078 6225 +5078 6824 +5078 5546 +5078 9227 +5078 6034 +5078 5921 +5078 8264 +5078 5370 +5079 8842 +5079 5902 +5079 8214 +5079 9495 +5079 8476 +5079 5917 +5079 6688 +5079 8129 +5079 7632 +5079 6994 +5079 5911 +5079 8693 +5080 9538 +5080 8163 +5080 8388 +5080 6597 +5080 8268 +5080 7149 +5080 6414 +5080 6545 +5080 6644 +5080 5208 +5081 7200 +5081 9858 +5081 9221 +5081 6797 +5081 9039 +5081 7798 +5081 8508 +5081 9790 +5082 9921 +5082 8909 +5082 7817 +5082 6776 +5082 8333 +5082 9715 +5082 9015 +5082 6949 +5083 7702 +5083 5410 +5083 7096 +5083 7376 +5083 6609 +5083 7005 +5083 6369 +5083 8829 +5084 6091 +5084 7367 +5084 7144 +5084 6602 +5084 8909 +5084 6575 +5084 5459 +5084 8790 +5084 9581 +5084 8158 +5084 7327 +5085 5409 +5085 6075 +5085 5654 +5085 5391 +5085 9113 +5085 7385 +5085 8540 +5085 8310 +5085 7870 +5086 8199 +5086 6872 +5086 7724 +5086 6065 +5086 6709 +5086 6409 +5086 6122 +5086 5112 +5087 5132 +5087 9130 +5087 5427 +5087 7466 +5087 7964 +5088 8320 +5088 5148 +5088 6813 +5088 7204 +5088 8230 +5088 8604 +5088 7083 +5088 7214 +5088 6173 +5088 8370 +5088 7605 +5088 6200 +5088 9274 +5088 8380 +5088 6467 +5088 8280 +5088 8158 +5088 6369 +5088 8804 +5089 5238 +5090 5313 +5090 8802 +5090 5481 +5090 7022 +5090 6066 +5090 8155 +5090 7710 +5091 9152 +5091 8161 +5091 9545 +5091 7507 +5091 7723 +5091 5496 +5091 5567 +5091 7359 +5092 8777 +5092 6027 +5092 7182 +5092 6837 +5092 5366 +5092 5495 +5092 6716 +5093 7592 +5093 8183 +5094 5406 +5094 7839 +5094 8865 +5094 6974 +5094 6752 +5094 6851 +5094 6472 +5094 8402 +5094 9312 +5094 6242 +5094 5355 +5094 5749 +5094 6271 +5095 6048 +5095 8704 +5095 7842 +5095 5413 +5095 8646 +5095 9527 +5095 5343 +5095 5474 +5095 6224 +5095 5430 +5095 6128 +5095 7993 +5095 9546 +5095 6237 +5096 8096 +5096 9060 +5096 6987 +5096 7308 +5096 9967 +5096 5176 +5096 7219 +5096 8181 +5096 9464 +5096 6425 +5096 7647 +5097 8992 +5097 6372 +5097 6702 +5097 9209 +5097 9164 +5097 6669 +5097 5847 +5097 7417 +5097 5179 +5097 9757 +5097 6399 +5098 6817 +5098 8484 +5098 9513 +5098 6187 +5098 8434 +5098 6043 +5098 6204 +5098 7775 +5099 7616 +5099 8833 +5099 8485 +5099 8385 +5099 5739 +5099 5868 +5099 7917 +5099 5725 +5099 6510 +5100 7318 +5100 6057 +5100 7083 +5100 7340 +5100 6454 +5100 8120 +5100 8648 +5100 9048 +5100 5210 +5100 6375 +5100 7790 +5100 9590 +5101 5635 +5101 9029 +5101 6388 +5101 9087 +5101 6748 +5101 5238 +5101 7263 +5102 7840 +5102 8320 +5102 9250 +5102 9275 +5102 7670 +5102 9772 +5102 9133 +5102 8782 +5102 9423 +5102 7272 +5102 9365 +5102 5403 +5102 6878 +5103 6914 +5103 8563 +5103 7212 +5103 7373 +5103 5519 +5103 5968 +5103 7763 +5103 7901 +5103 8254 +5103 7155 +5104 9224 +5104 5775 +5104 6299 +5104 9246 +5104 5414 +5104 7345 +5104 8408 +5104 8178 +5104 7032 +5105 6940 +5105 6444 +5105 9724 +5105 5309 +5105 8897 +5105 9804 +5105 6225 +5105 9312 +5105 7289 +5105 6140 +5106 5313 +5106 7202 +5106 9539 +5106 6817 +5106 6727 +5106 7668 +5106 9246 +5107 6082 +5107 6859 +5107 6888 +5107 5261 +5107 6510 +5107 5396 +5107 7035 +5107 9823 +5108 5509 +5108 9914 +5108 5798 +5108 9368 +5108 6165 +5108 5903 +5108 5850 +5109 7106 +5109 5238 +5109 9319 +5109 7639 +5109 8802 +5109 9230 +5109 9522 +5109 8201 +5109 7030 +5109 9527 +5109 9882 +5110 7265 +5110 7493 +5110 5606 +5110 7105 +5110 9879 +5110 7638 +5110 7927 +5110 6910 +5110 9382 +5111 9570 +5111 6629 +5111 7656 +5111 9611 +5111 8076 +5111 9933 +5111 8594 +5112 7493 +5112 9512 +5112 8782 +5112 8680 +5112 6617 +5112 8285 +5112 7461 +5113 5861 +5113 8646 +5113 9161 +5113 6154 +5113 8876 +5113 8820 +5113 5211 +5113 6653 +5113 7805 +5114 7424 +5114 9670 +5114 6342 +5114 9416 +5114 6514 +5114 5780 +5114 6948 +5114 5949 +5115 9632 +5115 7073 +5115 5220 +5115 5222 +5115 7937 +5115 8010 +5115 9388 +5115 7405 +5115 6225 +5115 8918 +5115 6809 +5115 5180 +5116 5920 +5116 8675 +5116 5474 +5116 8814 +5116 6647 +5116 7993 +5116 8698 +5116 8636 +5116 6398 +5116 6917 +5117 9008 +5117 6914 +5117 7178 +5117 8567 +5117 7906 +5117 9934 +5117 8750 +5117 6016 +5117 7385 +5117 5147 +5117 7039 +5118 6312 +5118 5487 +5118 8818 +5118 6067 +5118 9334 +5118 7063 +5118 8015 +5118 6973 +5119 8977 +5119 8858 +5119 9247 +5119 7841 +5119 8389 +5119 7502 +5119 8417 +5119 5860 +5119 7783 +5119 8808 +5119 8681 +5119 7931 +5120 8256 +5120 5778 +5120 8260 +5120 5637 +5120 9941 +5120 7025 +5120 6674 +5120 7411 +5120 7957 +5120 5973 +5120 7923 +5120 9503 +5120 8634 +5120 8597 +5121 6792 +5121 8974 +5121 9368 +5121 9840 +5121 8637 +5121 5951 +5121 5831 +5121 9290 +5121 5605 +5121 9574 +5121 9068 +5121 7408 +5122 6679 +5122 5533 +5122 7217 +5122 7372 +5122 9062 +5122 5613 +5122 6516 +5123 9777 +5123 5958 +5123 6577 +5123 8553 +5123 7850 +5123 8328 +5123 9747 +5123 7567 +5123 8431 +5123 9563 +5123 5384 +5124 8243 +5124 7746 +5124 8935 +5124 7114 +5124 8815 +5124 9043 +5124 5621 +5124 8125 +5125 9229 +5125 7953 +5125 8373 +5125 7348 +5125 8262 +5125 8800 +5125 8291 +5126 8211 +5126 6178 +5126 6949 +5126 9384 +5126 9193 +5126 9620 +5126 8779 +5126 6223 +5126 6995 +5126 6484 +5126 5269 +5126 7134 +5127 7842 +5127 7588 +5127 9256 +5127 9129 +5127 8241 +5127 5174 +5127 7991 +5127 9911 +5127 9821 +5127 7524 +5127 6895 +5128 8334 +5128 5520 +5128 5780 +5128 5273 +5128 9003 +5128 8109 +5128 6709 +5128 9019 +5128 6211 +5128 7880 +5128 6223 +5128 6610 +5128 8411 +5128 8689 +5129 7619 +5129 8164 +5129 5445 +5129 9673 +5129 9137 +5129 7988 +5129 8639 +5129 5592 +5129 9727 +5130 9602 +5130 8067 +5130 7821 +5130 6817 +5130 6832 +5130 5958 +5130 6862 +5130 8916 +5130 8792 +5130 6237 +5131 7459 +5131 8773 +5131 5894 +5131 5742 +5131 6792 +5132 5639 +5132 8213 +5132 6172 +5132 6048 +5132 6085 +5132 8147 +5132 5853 +5132 6494 +5132 5862 +5133 7531 +5133 9875 +5133 7795 +5133 6261 +5133 6649 +5133 6687 +5134 7296 +5134 6641 +5134 8092 +5134 9763 +5134 6104 +5134 9462 +5134 7627 +5134 6847 +5135 9729 +5135 5912 +5135 6047 +5135 7588 +5135 7593 +5135 6316 +5135 8377 +5135 8641 +5135 8781 +5135 7760 +5135 8273 +5135 6329 +5135 6876 +5135 6641 +5136 6532 +5136 6373 +5136 7909 +5136 6667 +5136 6546 +5136 6275 +5136 7285 +5136 9146 +5137 5312 +5137 6898 +5137 8372 +5137 9982 +5137 8662 +5137 9879 +5137 9402 +5137 8636 +5138 5488 +5138 9956 +5138 9861 +5138 9505 +5138 7095 +5138 7727 +5138 7958 +5138 5991 +5138 9725 +5139 8451 +5139 7182 +5139 8222 +5139 8901 +5139 7840 +5139 6206 +5139 9285 +5139 9040 +5139 8531 +5140 9350 +5140 7783 +5140 8106 +5140 5358 +5140 8113 +5140 6773 +5140 7350 +5140 7002 +5141 7238 +5141 7756 +5141 7083 +5141 5164 +5141 7501 +5141 9870 +5141 8431 +5141 9592 +5141 6137 +5142 7234 +5142 9322 +5142 8354 +5142 5787 +5143 8452 +5143 6810 +5143 5276 +5143 8627 +5143 5304 +5143 8397 +5143 9183 +5143 5363 +5143 6525 +5144 7680 +5144 7553 +5144 9625 +5144 7450 +5144 7208 +5144 7483 +5144 9404 +5144 6208 +5144 9421 +5144 6361 +5144 5594 +5144 6877 +5144 7921 +5144 7161 +5144 8830 +5145 6533 +5145 7579 +5145 8319 +5146 6464 +5146 5757 +5146 6130 +5146 9684 +5146 7922 +5146 7965 +5146 8813 +5147 7761 +5147 5249 +5147 7660 +5147 6042 +5147 7582 +5147 7095 +5147 5498 +5148 9750 +5148 7964 +5148 7843 +5148 6948 +5148 6070 +5148 9662 +5148 8531 +5148 8118 +5148 8559 +5148 8528 +5148 7155 +5149 8345 +5149 7077 +5149 6964 +5149 9525 +5149 9803 +5149 9169 +5149 6612 +5149 7518 +5149 9960 +5149 8301 +5150 5830 +5150 6823 +5150 5768 +5150 5161 +5150 9386 +5150 5389 +5150 8974 +5150 7951 +5150 7063 +5150 7866 +5150 8381 +5150 9301 +5151 6153 +5151 9234 +5151 7826 +5151 6020 +5151 9647 +5151 5306 +5151 5317 +5151 8522 +5151 8652 +5151 7021 +5151 7156 +5152 6720 +5152 9893 +5152 7398 +5152 5480 +5152 8496 +5152 9235 +5152 7704 +5152 6489 +5153 6784 +5153 6543 +5153 6032 +5153 6803 +5153 8472 +5153 8863 +5153 9200 +5153 9781 +5153 5559 +5153 6971 +5153 7886 +5153 6608 +5153 6000 +5153 6035 +5153 7802 +5153 9212 +5154 8193 +5154 8392 +5154 5481 +5154 5708 +5154 6626 +5154 6608 +5154 6418 +5154 6904 +5154 5753 +5154 7738 +5154 7966 +5155 5633 +5155 7946 +5155 6295 +5155 7074 +5155 7851 +5155 9262 +5155 6966 +5155 8763 +5155 5701 +5155 5738 +5156 9824 +5156 5988 +5156 8935 +5156 6954 +5156 7531 +5156 9166 +5156 9299 +5156 8918 +5156 6202 +5157 6433 +5157 8007 +5157 9000 +5157 5735 +5157 6092 +5157 7757 +5157 7153 +5157 7892 +5157 8475 +5157 7487 +5157 7391 +5158 9728 +5158 5764 +5158 6922 +5158 9868 +5158 9618 +5158 6683 +5158 6047 +5158 8867 +5158 7844 +5158 7336 +5158 5688 +5158 6333 +5158 9699 +5158 5737 +5158 7919 +5158 6007 +5158 8185 +5158 7679 +5159 9494 +5159 8675 +5159 9960 +5159 6572 +5159 8971 +5159 6764 +5159 8565 +5159 5273 +5159 6613 +5160 6977 +5160 6275 +5160 6308 +5160 7131 +5160 8850 +5160 5815 +5160 5593 +5160 9051 +5160 8604 +5160 6621 +5161 6669 +5161 9614 +5161 5443 +5161 6406 +5161 6185 +5161 7348 +5161 8125 +5161 6925 +5161 8286 +5161 6895 +5162 9735 +5162 7432 +5162 7562 +5162 7693 +5162 8484 +5162 6399 +5162 9141 +5162 7492 +5162 6225 +5162 6883 +5162 8675 +5162 5884 +5162 5747 +5162 7676 +5163 6667 +5163 8646 +5163 8782 +5163 6991 +5163 6997 +5163 9303 +5163 7393 +5163 7141 +5163 8047 +5163 9203 +5163 5621 +5163 6263 +5164 5923 +5164 7852 +5164 8333 +5164 5809 +5164 9177 +5164 7159 +5164 5209 +5165 8859 +5165 8095 +5165 9519 +5165 8642 +5165 5700 +5165 9553 +5165 5726 +5165 8040 +5165 6007 +5165 8825 +5166 7425 +5166 9892 +5166 7721 +5166 9838 +5166 5945 +5166 7652 +5166 6970 +5166 9647 +5166 5759 +5167 8656 +5167 5762 +5167 8067 +5167 8232 +5167 5717 +5167 7467 +5167 6170 +5168 5635 +5168 8075 +5168 6669 +5168 8980 +5168 9638 +5168 8496 +5168 9012 +5168 6668 +5168 9934 +5168 5200 +5169 6529 +5169 5639 +5169 9224 +5169 6810 +5169 6065 +5169 7869 +5169 5573 +5169 6602 +5169 9043 +5169 7385 +5169 6110 +5169 5219 +5170 7302 +5170 8726 +5170 5919 +5170 8742 +5170 6844 +5170 6726 +5170 6219 +5170 6348 +5170 5968 +5170 6737 +5170 6228 +5170 6357 +5170 8797 +5170 6759 +5170 6260 +5171 9601 +5171 6022 +5171 5256 +5171 5654 +5171 8475 +5171 6443 +5171 9649 +5171 5833 +5171 9059 +5171 9701 +5171 9213 +5172 5804 +5172 7667 +5172 7988 +5172 6581 +5172 5688 +5172 9912 +5172 7640 +5172 9947 +5172 7778 +5172 7163 +5172 5349 +5172 6251 +5173 6435 +5173 8074 +5173 7215 +5173 9960 +5173 8707 +5173 9655 +5173 9466 +5173 9658 +5173 7005 +5173 6554 +5173 8703 +5174 6305 +5174 7499 +5174 8673 +5174 9372 +5174 5405 +5174 6447 +5174 7803 +5174 7418 +5175 8704 +5175 8837 +5175 7436 +5175 6030 +5175 7183 +5175 9760 +5175 7336 +5175 6704 +5175 6901 +5175 5449 +5175 6353 +5175 8404 +5175 6362 +5175 9568 +5175 5745 +5175 8050 +5175 9727 +5176 6628 +5176 7109 +5176 9513 +5176 7979 +5176 9615 +5176 6808 +5176 9055 +5177 5601 +5177 9526 +5177 6599 +5177 8856 +5177 6828 +5177 6456 +5177 9366 +5177 9695 +5177 9308 +5177 6431 +5178 6024 +5178 7690 +5178 6923 +5178 5262 +5178 5417 +5178 8504 +5178 8249 +5178 8636 +5178 5472 +5178 7284 +5179 9490 +5179 5292 +5179 8881 +5179 8882 +5179 9787 +5179 5698 +5179 9309 +5179 7530 +5179 5617 +5180 6027 +5180 5388 +5180 8730 +5180 7462 +5180 9001 +5180 6960 +5180 8887 +5180 9784 +5180 7247 +5180 6916 +5180 5213 +5180 8950 +5180 6441 +5181 8482 +5181 5939 +5181 6678 +5181 9225 +5181 7539 +5181 6032 +5181 8116 +5181 7545 +5181 5884 +5181 9021 +5182 9992 +5182 5779 +5182 5535 +5182 6025 +5182 7864 +5182 8607 +5182 9037 +5182 6587 +5182 7790 +5182 7699 +5182 8190 +5182 9854 +5183 7536 +5183 5355 +5183 9484 +5183 5197 +5183 9790 +5183 9247 +5184 8065 +5184 8007 +5184 7496 +5184 9546 +5184 9110 +5184 7031 +5184 9370 +5184 8385 +5184 6525 +5184 5695 +5185 7824 +5185 7971 +5185 7140 +5185 7758 +5185 7989 +5185 6582 +5185 9719 +5186 9225 +5186 8514 +5186 6713 +5186 5190 +5186 7370 +5186 6229 +5186 6239 +5186 9201 +5186 7157 +5186 9463 +5187 7040 +5187 8547 +5187 6652 +5187 6229 +5187 6223 +5188 5523 +5188 9455 +5188 9841 +5188 9459 +5188 6901 +5189 8176 +5189 9989 +5189 9640 +5189 8778 +5189 5483 +5189 9745 +5189 5392 +5189 9256 +5189 9083 +5189 6141 +5190 5795 +5190 5413 +5190 9774 +5190 5298 +5190 9651 +5190 6596 +5190 5453 +5190 8656 +5190 8792 +5190 5340 +5190 8160 +5190 7024 +5190 9471 +5190 6781 +5190 7167 +5191 7302 +5191 9738 +5191 7186 +5191 6040 +5191 7716 +5191 7601 +5191 6325 +5191 9019 +5191 8185 +5192 8704 +5192 5769 +5192 7306 +5192 8960 +5192 7846 +5192 7083 +5192 7984 +5192 9533 +5192 6847 +5192 6863 +5192 8540 +5192 9610 +5192 9701 +5192 9704 +5192 5869 +5193 8832 +5193 6629 +5193 9998 +5193 8048 +5193 8723 +5193 8411 +5193 5302 +5193 7544 +5194 6336 +5194 8077 +5194 9102 +5194 9622 +5194 5534 +5194 6196 +5194 6488 +5194 7641 +5194 5724 +5194 8049 +5195 9240 +5195 5793 +5195 5291 +5195 9935 +5195 7508 +5195 9829 +5195 7655 +5195 9584 +5196 6276 +5196 6412 +5196 7829 +5196 8220 +5196 7454 +5196 8736 +5196 5410 +5196 6950 +5196 8625 +5196 9157 +5196 9940 +5196 5598 +5196 7906 +5196 5743 +5196 5885 +5197 6916 +5197 8598 +5197 5606 +5197 6896 +5197 8950 +5197 5209 +5197 8798 +5198 9440 +5198 9958 +5198 5565 +5198 9392 +5198 8371 +5198 7925 +5199 6529 +5199 8162 +5199 8809 +5199 9461 +5199 6108 +5199 5387 +5199 8437 +5200 8097 +5200 8263 +5200 7109 +5200 7730 +5200 8886 +5200 8346 +5200 5757 +5201 5696 +5201 6851 +5201 9426 +5201 9968 +5201 9329 +5201 5331 +5201 8348 +5201 7609 +5202 6812 +5202 7840 +5202 6180 +5202 8744 +5202 9010 +5202 7561 +5202 6342 +5202 8780 +5202 5841 +5202 7258 +5202 6367 +5202 9836 +5202 9843 +5202 6646 +5203 9057 +5203 9495 +5203 6519 +5203 6480 +5203 7761 +5203 9592 +5203 6746 +5203 9631 +5203 7351 +5203 6431 +5204 5263 +5204 8081 +5204 8979 +5204 5808 +5204 8625 +5204 9780 +5204 6582 +5204 9664 +5204 6104 +5204 9188 +5204 8294 +5204 8316 +5204 5629 +5205 5314 +5205 8934 +5205 9514 +5205 6967 +5205 6860 +5205 5410 +5205 6447 +5205 8242 +5205 8346 +5205 7791 +5205 5949 +5205 8383 +5206 6593 +5206 5636 +5206 9217 +5206 8300 +5206 7059 +5206 6038 +5206 5679 +5206 6213 +5207 6971 +5207 7398 +5207 6666 +5207 6711 +5207 8686 +5207 7512 +5207 8955 +5208 9665 +5208 8451 +5208 8518 +5208 7081 +5208 6447 +5208 9721 +5209 7257 +5209 5210 +5209 8219 +5209 8989 +5209 8173 +5210 8840 +5210 9997 +5210 6686 +5210 7976 +5210 6320 +5210 8350 +5210 5944 +5210 5437 +5210 9925 +5210 9547 +5210 9678 +5210 5587 +5210 6874 +5210 9570 +5210 6629 +5210 6375 +5210 9711 +5210 8821 +5210 5622 +5210 6527 +5211 5504 +5211 8980 +5211 7468 +5211 7856 +5211 7188 +5211 6975 +5211 9930 +5211 9703 +5211 6524 +5212 8953 +5212 5601 +5212 9573 +5212 6801 +5212 8876 +5212 5323 +5212 9040 +5212 7153 +5212 9238 +5212 6263 +5212 8361 +5213 7937 +5213 9234 +5213 5268 +5213 7190 +5213 6938 +5213 6569 +5213 9024 +5213 9665 +5213 8269 +5213 9567 +5213 9061 +5213 7279 +5213 9849 +5213 7419 +5213 6525 +5214 7698 +5214 5919 +5214 7457 +5214 8115 +5214 7485 +5214 9663 +5214 5452 +5214 6747 +5214 9820 +5214 6264 +5215 6432 +5215 5735 +5215 7080 +5215 5971 +5215 8830 +5215 9929 +5215 5592 +5215 6905 +5215 6396 +5215 7070 +5216 7329 +5216 5931 +5216 7044 +5216 8327 +5216 5295 +5216 8753 +5216 6742 +5216 9400 +5217 6852 +5217 7590 +5217 5576 +5217 7306 +5217 6348 +5217 8462 +5217 9008 +5217 8146 +5217 8643 +5217 6292 +5217 7802 +5217 8906 +5218 8195 +5218 7569 +5218 6693 +5218 6072 +5218 6973 +5218 9918 +5218 7234 +5218 6740 +5218 7893 +5218 9469 +5219 7787 +5219 8902 +5219 5547 +5219 7629 +5219 9992 +5219 6365 +5219 6744 +5220 9704 +5220 6762 +5220 6540 +5220 9134 +5220 7602 +5220 8851 +5220 8823 +5220 8153 +5221 7428 +5221 8746 +5221 9251 +5221 5526 +5222 9283 +5222 8841 +5222 7875 +5222 5962 +5222 8011 +5222 6606 +5222 6692 +5222 7150 +5222 7800 +5222 5628 +5223 6785 +5223 7812 +5223 8840 +5223 8196 +5223 8732 +5223 6188 +5223 9902 +5223 8456 +5223 7733 +5223 9015 +5223 5564 +5223 6988 +5223 9580 +5223 8290 +5223 6248 +5223 7916 +5224 8224 +5224 8998 +5224 7718 +5224 7053 +5224 6034 +5224 9716 +5224 6484 +5224 5565 +5224 8959 +5225 5508 +5225 5902 +5225 9237 +5225 8358 +5225 8487 +5225 9384 +5225 7338 +5225 7598 +5225 5946 +5225 8003 +5225 8142 +5225 9452 +5225 7668 +5225 7545 +5225 9082 +5225 8699 +5225 8874 +5226 9363 +5226 9237 +5226 9500 +5226 8989 +5226 9634 +5226 5413 +5226 9774 +5226 8498 +5226 6451 +5226 7350 +5226 6988 +5226 9037 +5226 9553 +5226 5842 +5226 8670 +5226 8055 +5226 6270 +5227 7813 +5227 7688 +5227 9102 +5227 6839 +5227 6242 +5227 6370 +5227 9964 +5227 6390 +5228 9891 +5228 8395 +5228 6989 +5228 5327 +5228 8995 +5228 8677 +5228 7142 +5228 9323 +5228 5488 +5228 6385 +5228 8953 +5228 9596 +5228 6142 +5229 6112 +5229 7203 +5229 8805 +5229 7142 +5229 8092 +5229 7341 +5229 5941 +5229 6106 +5229 8444 +5229 7421 +5230 9792 +5230 8178 +5230 8336 +5230 6859 +5230 7917 +5230 9876 +5230 5588 +5230 5625 +5230 6137 +5230 6876 +5230 9181 +5231 8908 +5231 8390 +5231 9254 +5231 9729 +5231 5969 +5231 7710 +5231 9367 +5231 7960 +5231 9148 +5231 9246 +5232 7083 +5232 9390 +5232 6576 +5232 6163 +5232 7700 +5232 8024 +5232 5564 +5232 7774 +5233 7398 +5233 7174 +5233 7212 +5233 8936 +5233 9740 +5233 9037 +5233 8497 +5233 7989 +5233 6169 +5233 9179 +5234 8586 +5234 9231 +5234 5778 +5234 8815 +5234 8759 +5234 6968 +5234 6118 +5234 5567 +5234 6232 +5234 7011 +5234 6245 +5234 7162 +5234 8957 +5234 6271 +5235 9732 +5235 5389 +5235 8467 +5235 8474 +5235 9511 +5235 9666 +5235 5942 +5235 9543 +5235 5320 +5235 7373 +5235 9816 +5235 8283 +5235 8423 +5236 9414 +5236 5602 +5236 8941 +5236 6852 +5236 6565 +5236 7119 +5236 5929 +5236 8067 +5236 9300 +5236 6786 +5236 5239 +5236 8088 +5236 7738 +5236 9467 +5236 9663 +5237 8530 +5237 8338 +5237 6834 +5238 8677 +5238 5254 +5238 7145 +5238 8138 +5238 5419 +5238 6097 +5239 9480 +5239 9228 +5239 7567 +5239 5796 +5239 7333 +5239 8998 +5239 6185 +5239 6964 +5239 7989 +5239 9014 +5239 8250 +5239 8029 +5239 6263 +5240 5728 +5240 5698 +5240 9124 +5240 7726 +5240 9106 +5240 5269 +5240 9370 +5241 6881 +5241 8482 +5241 5835 +5241 8164 +5241 9066 +5241 6607 +5241 5845 +5241 6650 +5241 5967 +5241 8733 +5241 5701 +5242 8995 +5242 8006 +5242 7644 +5242 7310 +5242 9813 +5242 5663 +5242 6270 +5242 7839 +5243 5899 +5243 6921 +5243 6967 +5243 5613 +5243 5902 +5243 6579 +5243 7642 +5243 8415 +5244 6977 +5244 7116 +5244 6126 +5244 6352 +5244 9905 +5244 5619 +5244 6004 +5244 7662 +5244 8254 +5245 7809 +5245 8130 +5245 6779 +5245 5318 +5245 5736 +5245 7308 +5245 9390 +5245 7406 +5245 7446 +5245 7831 +5245 8848 +5246 8834 +5246 8454 +5246 6563 +5246 9259 +5246 8877 +5246 8629 +5246 6461 +5246 8056 +5246 8018 +5246 6105 +5246 8162 +5246 8946 +5246 9080 +5247 9209 +5247 7105 +5247 8484 +5247 8935 +5247 6093 +5247 6030 +5247 5519 +5247 8584 +5247 9936 +5247 9143 +5247 6332 +5247 8062 +5248 7108 +5248 9093 +5248 8748 +5248 9774 +5248 9777 +5248 9434 +5248 6735 +5248 8702 +5248 9951 +5249 7234 +5249 8868 +5249 5917 +5249 7120 +5249 6484 +5249 6488 +5249 6740 +5249 6298 +5249 8094 +5250 7105 +5250 8449 +5250 8877 +5250 9806 +5250 5327 +5250 7253 +5250 7551 +5251 6498 +5251 7820 +5251 5342 +5251 9718 +5251 7416 +5251 9305 +5251 7772 +5252 5892 +5252 9580 +5252 5646 +5252 9236 +5252 6170 +5252 6703 +5252 6690 +5252 7846 +5252 7468 +5252 7087 +5252 7347 +5252 8116 +5252 6454 +5252 8780 +5252 9708 +5253 8897 +5253 7523 +5253 5637 +5253 6892 +5253 6765 +5253 6606 +5253 9487 +5253 8817 +5253 9445 +5253 5914 +5254 8675 +5254 7780 +5254 7132 +5254 6986 +5254 8063 +5255 5762 +5255 8967 +5255 6924 +5255 9116 +5255 7591 +5255 5545 +5255 8234 +5255 6331 +5255 6853 +5255 9926 +5255 7637 +5255 9696 +5255 5488 +5255 9973 +5256 6403 +5256 6034 +5256 6000 +5256 7723 +5256 9963 +5256 8527 +5256 6993 +5256 9043 +5256 5466 +5256 6256 +5256 7409 +5256 8690 +5256 7031 +5256 9725 +5257 8984 +5257 6176 +5257 7594 +5257 8772 +5257 6225 +5257 8542 +5257 7145 +5257 5486 +5257 7792 +5257 7794 +5258 9996 +5258 8761 +5258 8509 +5258 7241 +5258 8147 +5258 5335 +5258 9705 +5258 8940 +5258 6001 +5258 8307 +5258 9335 +5259 8962 +5259 9610 +5259 5779 +5259 8980 +5259 9502 +5259 9389 +5259 8635 +5259 7614 +5259 9808 +5259 5843 +5259 7142 +5259 8692 +5259 9723 +5260 8404 +5260 8999 +5260 8169 +5260 7627 +5260 9004 +5260 9650 +5260 5620 +5260 5271 +5260 5432 +5260 8473 +5260 9149 +5261 8321 +5261 7809 +5261 6679 +5261 8612 +5261 5806 +5261 7878 +5261 8794 +5261 7139 +5261 7268 +5261 9192 +5261 6385 +5261 7798 +5261 8314 +5262 5378 +5262 6662 +5262 8853 +5262 7451 +5262 8225 +5262 8869 +5262 6964 +5262 6738 +5262 6361 +5262 9835 +5263 8231 +5263 5890 +5263 8232 +5263 8853 +5263 9655 +5263 8312 +5263 7865 +5263 9693 +5263 6879 +5264 8192 +5264 6156 +5264 9376 +5264 9894 +5264 6065 +5264 7606 +5264 9016 +5264 8380 +5264 9961 +5264 9414 +5264 7658 +5264 5355 +5264 7025 +5264 9065 +5265 9376 +5265 9074 +5265 8124 +5265 6562 +5265 8733 +5265 8978 +5265 9203 +5265 5624 +5265 7483 +5265 9405 +5265 5279 +5266 7190 +5266 6297 +5266 7463 +5266 8117 +5266 9530 +5266 6459 +5266 9285 +5266 8013 +5266 6349 +5266 7505 +5266 7507 +5266 7259 +5266 9461 +5266 5622 +5267 5396 +5267 8328 +5267 6159 +5267 5528 +5267 6298 +5267 7323 +5267 6300 +5267 5663 +5267 6048 +5267 9379 +5267 8101 +5267 6316 +5267 8750 +5267 9523 +5267 6709 +5267 8884 +5267 7371 +5267 8016 +5267 7156 +5267 9337 +5268 8836 +5268 9735 +5268 8594 +5268 5915 +5268 7328 +5268 8873 +5268 5938 +5268 9671 +5268 9805 +5268 8142 +5268 7591 +5269 6022 +5269 9359 +5269 6304 +5269 6971 +5269 6855 +5269 7120 +5269 6367 +5269 9580 +5269 6511 +5269 6391 +5270 5538 +5270 7781 +5270 7949 +5270 7184 +5270 9960 +5270 6334 +5271 9236 +5271 6935 +5271 5531 +5271 8777 +5271 9291 +5271 5713 +5271 9173 +5271 8408 +5271 5731 +5271 8680 +5271 6505 +5272 9095 +5272 5769 +5272 8591 +5272 8981 +5272 8603 +5272 7083 +5272 7227 +5272 9321 +5272 9194 +5273 6929 +5273 7707 +5273 9501 +5273 6190 +5273 6579 +5273 7243 +5273 5963 +5273 8669 +5273 9342 +5274 6884 +5274 7526 +5274 8255 +5274 6796 +5274 9585 +5274 8270 +5274 9978 +5275 8195 +5275 8595 +5275 6167 +5275 7330 +5275 8995 +5275 8745 +5275 9264 +5275 6592 +5275 9031 +5275 5458 +5275 7392 +5275 9059 +5275 9703 +5275 7403 +5276 9988 +5276 6031 +5276 6298 +5276 7068 +5276 9633 +5276 8391 +5276 6446 +5276 6218 +5276 8767 +5276 8146 +5276 9231 +5276 5350 +5276 8295 +5276 7661 +5276 6129 +5276 5627 +5277 8259 +5277 6628 +5277 7751 +5277 7817 +5277 9903 +5277 8534 +5277 7543 +5277 6296 +5277 9091 +5277 5918 +5278 8942 +5278 8006 +5278 6151 +5278 9905 +5279 5474 +5279 5802 +5279 9773 +5279 9716 +5279 5398 +5279 5880 +5280 5389 +5280 6169 +5280 6355 +5280 6357 +5280 9179 +5280 7646 +5280 7405 +5280 9458 +5281 7435 +5281 8276 +5281 7255 +5281 7156 +5281 8063 +5282 9666 +5282 9563 +5282 6518 +5282 5474 +5282 7823 +5282 7698 +5282 7908 +5282 6139 +5283 5763 +5283 7194 +5283 7334 +5283 7218 +5283 8007 +5283 7502 +5283 7717 +5283 7535 +5283 9589 +5283 5753 +5284 7041 +5284 9614 +5284 9892 +5284 8903 +5284 6481 +5284 9575 +5284 8040 +5284 8951 +5285 9483 +5285 9533 +5285 9780 +5285 5821 +5285 6110 +5286 6404 +5286 5651 +5286 7407 +5286 6440 +5286 8252 +5286 9419 +5286 7804 +5286 7791 +5286 7666 +5286 8696 +5286 8060 +5287 6048 +5287 8637 +5287 7241 +5287 9674 +5287 8015 +5287 6745 +5287 7393 +5287 7524 +5287 7762 +5288 7554 +5288 9237 +5288 6679 +5288 8217 +5288 7326 +5288 6437 +5288 9130 +5288 7344 +5288 5598 +5288 8248 +5288 8415 +5288 7875 +5288 6094 +5288 5342 +5288 9828 +5289 6688 +5289 7556 +5289 8717 +5289 8974 +5289 9497 +5289 5912 +5289 9668 +5289 5851 +5290 5954 +5290 7845 +5290 6311 +5290 5933 +5290 9908 +5290 5570 +5290 9810 +5290 5459 +5290 8404 +5290 9565 +5290 7401 +5290 6256 +5290 9845 +5290 9598 +5291 5568 +5291 7534 +5291 6901 +5292 6945 +5292 9315 +5292 6024 +5292 7055 +5292 7888 +5292 8910 +5292 5431 +5293 6016 +5293 6374 +5293 8363 +5293 6796 +5293 6350 +5293 7634 +5293 8722 +5293 9308 +5293 8869 +5294 7874 +5294 7362 +5294 7179 +5294 5634 +5294 6289 +5294 6002 +5294 9781 +5294 8954 +5294 9503 +5295 8868 +5295 8373 +5295 8642 +5295 5320 +5295 8294 +5295 9715 +5295 6652 +5295 8573 +5295 8191 +5296 9090 +5296 8203 +5296 6092 +5296 9390 +5296 8112 +5296 9015 +5296 8757 +5296 8409 +5296 9470 +5297 6688 +5297 9291 +5297 7152 +5297 8118 +5297 8191 +5298 7715 +5298 8877 +5298 7231 +5298 5826 +5298 9796 +5298 7886 +5298 8142 +5298 6494 +5299 6054 +5299 6982 +5299 6205 +5299 6089 +5299 7850 +5299 7885 +5299 8591 +5299 9137 +5299 9015 +5299 6575 +5299 7484 +5300 9601 +5300 6675 +5300 7706 +5300 5922 +5300 6199 +5300 6841 +5300 9034 +5300 8258 +5301 9905 +5301 6642 +5301 6098 +5302 7745 +5302 8870 +5302 7830 +5302 7356 +5302 6397 +5303 9319 +5303 6771 +5303 6069 +5303 6294 +5303 9210 +5304 6371 +5304 9385 +5304 6804 +5304 5843 +5304 8921 +5304 7965 +5305 6963 +5305 9825 +5305 5514 +5305 7149 +5305 8590 +5305 9521 +5305 5586 +5305 9172 +5305 7385 +5305 5756 +5306 5411 +5306 9986 +5306 7689 +5306 6153 +5306 7214 +5306 6928 +5306 7505 +5306 6066 +5306 9801 +5306 6588 +5306 8798 +5307 8833 +5307 8958 +5307 7213 +5307 7087 +5307 5521 +5307 5841 +5307 8493 +5307 5550 +5307 7515 +5307 8765 +5307 7518 +5308 7299 +5308 9421 +5308 7816 +5308 7671 +5308 6284 +5308 7821 +5308 9808 +5308 7218 +5308 7619 +5308 5943 +5308 8063 +5309 5763 +5309 5790 +5309 9248 +5309 6212 +5309 9669 +5309 8282 +5309 9053 +5309 8544 +5309 5733 +5310 9008 +5310 5355 +5310 7782 +5310 8167 +5310 9913 +5310 7566 +5310 8471 +5310 9561 +5311 7361 +5311 9103 +5311 5989 +5311 8609 +5311 9484 +5311 9847 +5311 7768 +5311 8731 +5312 6011 +5312 5604 +5312 7273 +5312 8946 +5312 7130 +5312 6271 +5312 9884 +5313 6021 +5313 7686 +5313 9479 +5313 7833 +5313 8363 +5313 6576 +5313 7749 +5313 8660 +5313 7402 +5313 5999 +5313 5744 +5314 7718 +5314 6673 +5314 5378 +5314 8427 +5314 6242 +5314 5423 +5314 5456 +5314 6237 +5315 5872 +5315 8119 +5315 9842 +5315 6047 +5316 9700 +5316 5605 +5316 8322 +5316 7313 +5316 8774 +5316 9998 +5316 7706 +5317 8160 +5317 8133 +5317 8137 +5317 5671 +5317 7276 +5317 7535 +5317 6382 +5317 7347 +5317 6261 +5318 6661 +5318 9626 +5318 6127 +5318 7730 +5318 5434 +5318 5452 +5318 8013 +5318 9303 +5318 8288 +5318 9075 +5319 9544 +5319 9900 +5319 8813 +5319 9677 +5319 8917 +5319 5654 +5319 8569 +5320 6273 +5320 8865 +5320 7817 +5320 7946 +5320 8073 +5320 7729 +5320 7801 +5320 8731 +5321 8471 +5321 6105 +5321 7746 +5321 6225 +5321 7249 +5321 5394 +5321 5382 +5321 6864 +5321 7111 +5321 7321 +5321 9887 +5322 9899 +5322 9310 +5322 9405 +5322 8752 +5322 6257 +5322 6283 +5322 6362 +5322 7931 +5322 8637 +5323 7424 +5323 8836 +5323 6538 +5323 9731 +5323 5908 +5323 7861 +5323 7354 +5323 9161 +5323 5848 +5323 5988 +5323 8295 +5323 6889 +5324 6241 +5324 8578 +5324 7623 +5324 5602 +5324 7119 +5324 5840 +5324 7415 +5325 9601 +5325 5604 +5325 7082 +5325 5867 +5325 8745 +5325 7012 +5325 8572 +5325 8874 +5326 8173 +5326 8154 +5326 9948 +5326 5406 +5327 8001 +5327 5769 +5327 5484 +5327 7725 +5327 6574 +5327 8847 +5327 8496 +5327 6066 +5327 7608 +5328 6210 +5328 5676 +5328 7120 +5328 5878 +5328 9115 +5328 9950 +5329 5889 +5329 6850 +5329 9484 +5329 7106 +5329 9233 +5329 8693 +5329 6588 +5329 8733 +5330 6178 +5330 7627 +5330 7219 +5330 9978 +5330 9429 +5331 7237 +5331 7484 +5331 9674 +5331 8791 +5331 9507 +5331 6071 +5331 8795 +5332 7873 +5332 7243 +5332 9376 +5332 9325 +5332 7918 +5332 6095 +5332 9873 +5332 8590 +5332 8430 +5332 6786 +5332 9022 +5333 8273 +5333 6025 +5333 8977 +5333 6685 +5333 5810 +5333 6068 +5333 7754 +5333 6734 +5333 8783 +5333 5587 +5333 7772 +5333 8161 +5333 6376 +5333 9460 +5334 6563 +5334 6568 +5334 7209 +5334 8761 +5334 7114 +5334 9559 +5334 5852 +5334 9188 +5334 5491 +5335 5633 +5335 7683 +5335 9607 +5335 6542 +5335 9363 +5335 8597 +5335 8625 +5335 7346 +5335 5973 +5335 7638 +5335 9820 +5335 7529 +5335 8444 +5336 9963 +5336 8199 +5336 7598 +5336 8606 +5336 5655 +5336 8062 +5337 7556 +5337 8930 +5337 9098 +5337 8674 +5337 5661 +5337 8661 +5337 8041 +5337 6649 +5337 8474 +5338 6694 +5338 9493 +5338 9752 +5338 8860 +5339 9952 +5339 7593 +5339 7589 +5339 7534 +5339 9683 +5339 7438 +5339 8809 +5339 8537 +5339 8666 +5339 8190 +5340 9605 +5340 9550 +5340 8723 +5340 5368 +5340 7611 +5341 7424 +5341 9766 +5341 7889 +5341 8659 +5341 6759 +5341 6639 +5341 6138 +5342 6541 +5342 9379 +5342 8124 +5342 9536 +5342 6083 +5342 8519 +5342 8521 +5342 5730 +5342 6182 +5342 6639 +5342 9078 +5342 6136 +5342 8788 +5343 6273 +5343 9620 +5343 6812 +5343 7210 +5343 7731 +5343 7867 +5343 7371 +5343 6856 +5343 7242 +5343 9058 +5343 6226 +5343 8153 +5343 7035 +5344 6307 +5344 9837 +5344 5765 +5344 6545 +5344 9045 +5344 7785 +5344 8003 +5344 9791 +5344 5629 +5345 9985 +5345 6660 +5345 7817 +5345 6036 +5345 7189 +5345 8726 +5345 6788 +5345 6573 +5345 6963 +5345 7614 +5345 6088 +5345 8907 +5345 9297 +5345 9940 +5345 7137 +5345 7550 +5345 9598 +5346 8066 +5346 6288 +5346 7059 +5346 8019 +5347 6472 +5347 5637 +5347 9800 +5347 6921 +5347 9814 +5347 9752 +5347 9818 +5347 7146 +5347 9754 +5348 7760 +5348 6759 +5348 6600 +5348 7178 +5348 7234 +5348 9360 +5348 5855 +5349 8738 +5349 9028 +5349 7153 +5349 8424 +5349 8937 +5349 9101 +5349 6609 +5349 7317 +5350 5654 +5350 6933 +5350 5534 +5350 8257 +5350 6038 +5350 7768 +5350 8664 +5350 6389 +5350 8572 +5351 8035 +5351 6924 +5351 5449 +5351 9070 +5351 9650 +5351 9693 +5352 6281 +5352 7405 +5352 6255 +5352 7124 +5352 7417 +5352 9921 +5352 8766 +5353 6912 +5353 8667 +5353 9742 +5353 8239 +5353 7139 +5353 9940 +5353 9278 +5353 7003 +5353 9948 +5353 9723 +5354 7043 +5354 7894 +5354 6535 +5354 5515 +5354 6291 +5354 6943 +5354 7281 +5354 7480 +5354 9677 +5354 8165 +5354 6142 +5355 7712 +5355 9347 +5355 7149 +5355 8831 +5355 5841 +5355 9715 +5355 9726 +5355 6742 +5355 9723 +5355 7804 +5355 6815 +5356 8451 +5356 8986 +5356 9504 +5356 7586 +5356 5818 +5356 7115 +5356 7002 +5356 8802 +5357 8225 +5357 6026 +5357 6516 +5357 5717 +5357 6044 +5357 6362 +5358 7949 +5358 9114 +5358 6082 +5358 7498 +5358 6888 +5358 5622 +5359 8550 +5359 6695 +5359 8754 +5360 9633 +5360 8306 +5360 6698 +5360 6759 +5360 6578 +5360 7406 +5360 6162 +5360 5717 +5360 5561 +5360 6489 +5360 6031 +5360 8509 +5361 9414 +5361 9127 +5361 8519 +5361 9473 +5361 6797 +5361 5712 +5361 9074 +5361 6549 +5361 5897 +5361 7160 +5362 7104 +5362 9218 +5362 9485 +5362 5711 +5362 9176 +5362 8343 +5362 5786 +5363 6056 +5363 7786 +5363 8555 +5363 6797 +5363 6647 +5363 5914 +5363 5402 +5363 7484 +5363 5725 +5363 9029 +5364 9348 +5364 7686 +5364 8218 +5364 6790 +5364 7966 +5364 5817 +5364 9799 +5364 5454 +5364 6364 +5364 7787 +5364 6648 +5364 6655 +5365 7170 +5365 6883 +5365 6821 +5365 6449 +5365 8937 +5365 9457 +5365 7547 +5365 6973 +5365 5567 +5366 6784 +5366 7562 +5366 6733 +5366 8271 +5366 9169 +5366 6838 +5366 8542 +5366 7263 +5367 8353 +5367 7865 +5367 8781 +5367 9679 +5367 8923 +5367 7138 +5367 8163 +5367 5868 +5367 8958 +5368 8975 +5368 5381 +5368 5798 +5368 6856 +5368 9602 +5368 6946 +5368 5421 +5368 7794 +5368 7864 +5368 7867 +5369 6422 +5369 5668 +5369 9644 +5369 5458 +5369 8915 +5369 6256 +5369 7665 +5370 5775 +5370 9246 +5370 5920 +5370 6769 +5370 8111 +5370 7089 +5370 5563 +5370 7501 +5370 6742 +5370 7403 +5370 7665 +5371 9600 +5371 6445 +5371 7983 +5371 8242 +5371 9928 +5371 9675 +5371 5980 +5371 6890 +5371 8381 +5372 5643 +5372 6181 +5372 5941 +5372 5433 +5372 8252 +5372 7366 +5372 6482 +5372 7508 +5372 5465 +5372 7266 +5372 6247 +5372 9455 +5373 8576 +5373 5477 +5373 8679 +5373 7607 +5373 7341 +5373 6159 +5373 7378 +5373 9780 +5373 8757 +5373 6102 +5373 5741 +5374 6105 +5374 9369 +5374 8734 +5374 6687 +5374 5666 +5374 8242 +5374 6558 +5374 6845 +5374 8396 +5374 9424 +5374 8276 +5374 5478 +5374 5739 +5374 6520 +5375 6368 +5375 9992 +5375 5838 +5375 7860 +5375 9273 +5375 5481 +5375 6009 +5376 7268 +5376 6492 +5376 6263 +5376 6509 +5376 7693 +5376 9969 +5376 8050 +5376 6006 +5376 7323 +5377 6880 +5377 9234 +5377 7315 +5377 6390 +5377 8791 +5377 5944 +5377 6458 +5377 8472 +5378 5473 +5378 8194 +5378 6245 +5378 6156 +5378 9262 +5378 8329 +5378 5908 +5378 8799 +5379 6552 +5379 7967 +5379 9761 +5379 6818 +5379 6094 +5379 9432 +5379 8037 +5379 5874 +5379 5748 +5379 5884 +5380 8712 +5380 7193 +5380 9912 +5380 8378 +5380 8383 +5380 7882 +5380 8533 +5380 6616 +5380 9950 +5380 8546 +5380 8551 +5380 6512 +5380 7285 +5380 9215 +5381 7808 +5381 7075 +5381 8635 +5381 8006 +5381 7374 +5381 9044 +5381 9705 +5381 8553 +5382 7589 +5382 6279 +5382 7562 +5382 8080 +5382 8755 +5382 7158 +5382 5786 +5382 8990 +5382 8374 +5383 9665 +5383 9636 +5383 8394 +5383 9293 +5383 7608 +5383 6770 +5383 7146 +5383 7103 +5384 9090 +5384 6298 +5384 6818 +5384 9773 +5384 9138 +5384 8888 +5384 8003 +5384 6734 +5384 8787 +5384 6881 +5384 6756 +5384 7531 +5384 8190 +5385 9219 +5385 7578 +5385 8871 +5385 8120 +5385 7248 +5385 8376 +5385 6370 +5385 5864 +5385 5753 +5385 5755 +5386 7427 +5386 9225 +5386 9101 +5386 5406 +5386 9906 +5386 7070 +5386 9161 +5386 6852 +5386 9673 +5386 9271 +5386 8145 +5386 8166 +5386 5612 +5386 8183 +5387 9856 +5387 7939 +5387 7109 +5387 8023 +5387 9682 +5387 5716 +5387 7286 +5387 8521 +5387 9855 +5388 9860 +5388 6560 +5388 7842 +5388 9900 +5388 5424 +5388 5447 +5388 8397 +5388 5455 +5388 6614 +5388 7774 +5389 7692 +5389 9134 +5389 8269 +5389 6763 +5389 8698 +5389 9343 +5390 6784 +5390 6657 +5390 9299 +5390 6537 +5390 9029 +5390 8903 +5390 7465 +5390 6418 +5390 8211 +5390 5961 +5391 7435 +5391 7827 +5391 9322 +5391 9663 +5391 9669 +5391 5838 +5391 5600 +5391 7165 +5391 6644 +5391 8954 +5391 5629 +5392 7829 +5392 8766 +5392 5921 +5392 8785 +5392 8414 +5392 8439 +5393 6514 +5393 8811 +5393 6189 +5393 8664 +5393 8914 +5393 7045 +5393 9567 +5393 6058 +5394 6059 +5394 7429 +5394 6599 +5394 7178 +5394 8721 +5394 6522 +5394 7230 +5395 8352 +5395 7107 +5395 9609 +5395 5827 +5395 9081 +5395 6037 +5395 9815 +5395 5433 +5395 9951 +5395 6972 +5396 9856 +5396 9349 +5396 7560 +5396 7208 +5396 5929 +5396 8239 +5396 5705 +5396 9919 +5396 7621 +5396 5591 +5396 9817 +5397 7074 +5397 8323 +5397 5832 +5397 8363 +5397 8428 +5397 7170 +5397 9293 +5397 6769 +5397 7122 +5397 9523 +5397 6519 +5397 5498 +5397 5916 +5398 6316 +5398 6042 +5398 6194 +5398 6215 +5398 5969 +5398 7642 +5398 5609 +5398 6765 +5398 7066 +5398 8637 +5398 6385 +5399 6182 +5399 5537 +5399 8877 +5399 7150 +5399 7055 +5400 8961 +5400 9928 +5400 8508 +5400 9130 +5400 7374 +5400 5800 +5400 7669 +5400 9718 +5400 9352 +5400 5788 +5401 7567 +5401 6546 +5401 8760 +5401 7631 +5401 9296 +5401 6101 +5401 9689 +5401 6628 +5401 7141 +5401 9450 +5401 5488 +5401 8051 +5402 6674 +5402 7064 +5402 6946 +5402 7858 +5402 6476 +5402 5922 +5402 8526 +5402 7124 +5402 6101 +5402 7404 +5402 8941 +5403 8417 +5403 9681 +5403 9582 +5403 7321 +5404 8513 +5404 6372 +5404 7953 +5404 6196 +5404 9560 +5405 8962 +5405 7688 +5405 7095 +5405 8456 +5405 8499 +5405 5845 +5405 9060 +5405 5905 +5405 6997 +5406 7436 +5406 7824 +5406 9668 +5406 6049 +5406 7472 +5406 5442 +5406 7771 +5406 6623 +5406 6501 +5406 9844 +5406 6645 +5406 5499 +5407 7008 +5407 9156 +5407 7346 +5407 5891 +5407 8027 +5407 9920 +5407 7198 +5407 7167 +5408 6160 +5408 6037 +5408 8728 +5408 8610 +5408 9656 +5408 6466 +5408 6260 +5409 7529 +5409 9212 +5409 7221 +5410 6884 +5410 6055 +5410 7208 +5410 6855 +5410 6156 +5410 8206 +5410 8861 +5410 8204 +5410 8212 +5410 8758 +5410 9945 +5410 6685 +5411 7942 +5411 7660 +5411 7066 +5411 6006 +5411 9946 +5411 6014 +5412 8719 +5412 7060 +5412 5660 +5412 7464 +5412 6058 +5412 5949 +5412 9445 +5412 8447 +5413 6091 +5413 6541 +5413 7065 +5413 8082 +5413 6389 +5413 6326 +5413 5465 +5414 6042 +5414 6177 +5414 5922 +5414 6439 +5414 6315 +5414 6974 +5414 9807 +5414 9940 +5414 9692 +5414 5615 +5414 8951 +5414 6653 +5415 9505 +5415 9158 +5415 8557 +5415 9635 +5415 9945 +5416 5440 +5416 8096 +5416 6811 +5416 9655 +5416 6285 +5416 5967 +5416 8369 +5416 7415 +5416 5620 +5416 8795 +5416 8765 +5417 8864 +5417 6691 +5417 9062 +5417 7789 +5417 9615 +5417 8723 +5417 6421 +5417 8216 +5417 8059 +5417 9821 +5418 9520 +5418 5805 +5418 7101 +5418 6846 +5418 7382 +5418 9177 +5418 9179 +5418 7070 +5419 9824 +5419 9057 +5419 6456 +5419 8476 +5420 6785 +5420 9258 +5420 7318 +5420 8503 +5420 7995 +5420 8892 +5421 9880 +5421 7587 +5421 8100 +5421 8365 +5421 8499 +5421 7373 +5421 7887 +5421 5586 +5421 7779 +5421 7792 +5421 5716 +5422 8771 +5422 9703 +5422 8618 +5422 9223 +5422 9307 +5422 6559 +5422 7739 +5423 8751 +5423 5683 +5423 9270 +5423 9459 +5423 5716 +5423 7639 +5423 7390 +5423 9327 +5423 7412 +5423 6907 +5424 7586 +5424 5803 +5424 7525 +5424 8171 +5424 8209 +5424 7346 +5425 6816 +5425 5474 +5425 7012 +5425 7781 +5425 9542 +5425 8391 +5425 9033 +5425 9186 +5425 9678 +5425 8593 +5425 9397 +5425 7753 +5425 8279 +5426 9835 +5426 9741 +5426 6812 +5426 9119 +5426 9409 +5426 6347 +5426 6609 +5426 9048 +5426 6873 +5426 6752 +5426 9443 +5426 8298 +5426 9195 +5426 6258 +5426 5954 +5427 6657 +5427 5773 +5427 9872 +5427 7825 +5427 8852 +5427 9777 +5427 8524 +5427 6733 +5427 5582 +5427 7374 +5427 6877 +5427 5994 +5427 8943 +5427 6101 +5428 6000 +5428 7973 +5428 5590 +5428 6253 +5428 8558 +5428 9456 +5428 8181 +5428 8406 +5428 7483 +5428 8863 +5429 7680 +5429 8088 +5429 9263 +5429 9649 +5429 5812 +5429 7999 +5429 6599 +5429 7246 +5429 8177 +5430 6282 +5430 7276 +5430 9272 +5430 9658 +5430 7515 +5431 5860 +5431 8453 +5431 6823 +5431 5737 +5431 7978 +5431 9403 +5432 9995 +5432 9136 +5432 6501 +5433 6727 +5433 7211 +5433 8354 +5433 7810 +5433 9646 +5433 9426 +5433 8782 +5433 5622 +5433 9115 +5433 7679 +5434 6665 +5434 6794 +5434 6808 +5434 6556 +5434 9908 +5434 7036 +5435 8683 +5435 9611 +5435 6596 +5435 6178 +5435 8767 +5435 6464 +5435 8535 +5435 6759 +5435 5620 +5436 7429 +5436 7056 +5436 6825 +5436 6622 +5436 6326 +5436 7761 +5436 8719 +5436 6003 +5436 7934 +5437 6018 +5437 9929 +5437 8522 +5437 5966 +5437 7257 +5437 6881 +5437 5736 +5437 7913 +5437 9581 +5437 6897 +5437 8307 +5437 9449 +5438 6343 +5438 6956 +5438 7601 +5438 9652 +5438 7134 +5438 7959 +5438 6555 +5438 5660 +5438 7998 +5439 5926 +5439 6250 +5439 8971 +5439 7278 +5439 5818 +5439 6619 +5439 7402 +5440 8935 +5440 8135 +5440 9032 +5440 9310 +5440 9117 +5440 7542 +5440 9273 +5441 7907 +5441 6086 +5441 6825 +5441 9132 +5441 8146 +5441 9646 +5441 9749 +5441 9791 +5442 8232 +5442 5642 +5442 8286 +5443 9728 +5443 9666 +5443 9160 +5443 6826 +5443 9228 +5443 8623 +5443 9848 +5443 5976 +5443 8458 +5443 6863 +5443 9788 +5444 9920 +5444 7203 +5444 7332 +5444 6662 +5444 8190 +5444 7576 +5445 9888 +5445 6341 +5445 8872 +5445 9395 +5445 8216 +5445 6137 +5445 6685 +5446 9299 +5446 6235 +5446 6358 +5446 8358 +5446 9033 +5446 6674 +5446 6318 +5446 5723 +5446 5916 +5446 5693 +5446 7518 +5447 5506 +5447 9873 +5447 9491 +5447 7446 +5447 7458 +5447 9013 +5447 9403 +5447 6466 +5447 8392 +5447 6007 +5447 5879 +5447 9709 +5448 9920 +5448 7332 +5448 9540 +5448 6972 +5448 7872 +5448 9310 +5448 9178 +5448 9205 +5449 7772 +5449 5739 +5449 6316 +5449 7951 +5449 6388 +5450 6305 +5450 9987 +5450 5797 +5450 5736 +5450 9546 +5450 8656 +5450 8648 +5450 9191 +5450 9689 +5450 9629 +5450 7902 +5450 6885 +5451 8321 +5451 6914 +5451 5604 +5451 8808 +5451 7375 +5451 9136 +5451 8209 +5451 8210 +5451 9626 +5451 6011 +5452 7687 +5452 9227 +5452 9357 +5452 7186 +5452 6557 +5452 6047 +5452 8630 +5452 8394 +5452 5955 +5452 6983 +5452 6730 +5452 5590 +5453 6353 +5453 7239 +5453 6466 +5453 6221 +5453 6222 +5453 8111 +5453 6455 +5453 9428 +5453 7069 +5453 5757 +5454 8434 +5454 7161 +5454 8733 +5454 9855 +5455 6402 +5455 8324 +5455 8582 +5455 6791 +5455 7846 +5455 7853 +5455 6703 +5455 9016 +5455 5461 +5455 8281 +5455 8157 +5455 6003 +5456 8069 +5456 5783 +5456 9118 +5456 8994 +5456 9772 +5456 7342 +5456 7223 +5456 5701 +5456 7751 +5456 8904 +5456 6746 +5456 9962 +5456 6265 +5457 9280 +5457 8966 +5457 9833 +5457 6296 +5457 9517 +5457 5711 +5457 5816 +5457 9434 +5457 6555 +5457 9661 +5458 7937 +5458 9096 +5458 7698 +5458 8868 +5458 6573 +5458 8879 +5458 8508 +5458 6600 +5458 7247 +5458 9462 +5459 9827 +5459 5958 +5459 8650 +5459 8174 +5459 8662 +5459 8411 +5459 7391 +5460 7561 +5460 6545 +5460 6290 +5460 6550 +5460 6174 +5460 6440 +5460 7081 +5460 7598 +5460 6718 +5460 6979 +5460 7158 +5460 6988 +5460 6477 +5460 8958 +5461 9216 +5461 6146 +5461 8549 +5461 9153 +5461 7019 +5461 9644 +5461 6327 +5461 9210 +5461 7027 +5461 6205 +5461 5957 +5462 6803 +5462 6164 +5462 8349 +5462 7070 +5462 9265 +5462 7086 +5462 5937 +5462 9139 +5462 8418 +5462 8682 +5462 8818 +5462 8695 +5462 6906 +5463 7392 +5463 6763 +5463 7851 +5463 7597 +5463 7633 +5463 8020 +5463 8729 +5464 7203 +5464 9028 +5464 9174 +5464 5574 +5464 7881 +5464 7858 +5464 6742 +5464 9754 +5464 8411 +5465 9923 +5465 9098 +5465 9549 +5465 5646 +5465 7878 +5465 9859 +5465 5486 +5465 8415 +5465 7013 +5466 5819 +5466 8303 +5466 8367 +5466 7054 +5466 9391 +5466 7280 +5466 7217 +5466 8411 +5466 9307 +5466 5532 +5466 5725 +5466 9073 +5467 8075 +5467 7698 +5467 8274 +5467 5847 +5467 5848 +5467 6778 +5467 7839 +5468 8869 +5468 6567 +5468 6152 +5468 7787 +5468 8071 +5468 7967 +5468 5520 +5468 7000 +5468 5875 +5468 9664 +5468 7237 +5469 6150 +5469 7691 +5469 6050 +5469 7718 +5469 6952 +5469 5549 +5469 7731 +5469 9654 +5469 8646 +5469 7628 +5469 8784 +5469 6639 +5470 6657 +5470 6194 +5470 8630 +5470 6583 +5470 7230 +5470 9026 +5470 7373 +5470 7293 +5471 5623 +5471 6410 +5471 6173 +5471 9864 +5471 8372 +5471 7957 +5471 9596 +5471 8797 +5472 8385 +5472 9345 +5472 7596 +5472 6027 +5472 5832 +5472 9267 +5472 5590 +5472 8029 +5473 5633 +5473 8457 +5473 5634 +5473 8210 +5473 9494 +5473 8474 +5473 7071 +5473 9130 +5473 5933 +5473 7984 +5473 5823 +5473 8645 +5473 7369 +5473 9822 +5473 8055 +5473 7674 +5473 7210 +5474 6794 +5474 7309 +5474 8848 +5474 9363 +5474 9632 +5474 7074 +5474 8499 +5474 8607 +5474 8641 +5474 9675 +5474 9804 +5474 5663 +5474 5593 +5474 8950 +5474 7419 +5474 8831 +5475 9954 +5475 5669 +5475 7142 +5475 9288 +5475 6414 +5475 5789 +5475 5552 +5475 9074 +5475 7029 +5475 8474 +5476 8581 +5476 7814 +5476 9099 +5476 6964 +5476 8026 +5477 9225 +5477 5545 +5477 6314 +5477 9263 +5477 6194 +5477 7497 +5477 9801 +5477 6990 +5477 8535 +5477 8409 +5477 9580 +5477 7286 +5477 6525 +5478 7074 +5478 8708 +5478 8486 +5478 8233 +5478 9452 +5478 7790 +5478 5850 +5478 7583 +5478 5626 +5479 5858 +5479 7011 +5479 7301 +5479 7942 +5479 8619 +5479 7675 +5480 6532 +5480 9127 +5480 9389 +5480 9198 +5480 7056 +5480 8608 +5480 9171 +5481 7937 +5481 6043 +5481 8480 +5481 8609 +5481 9262 +5481 9675 +5481 6095 +5481 8377 +5481 5726 +5481 7393 +5481 5989 +5481 8873 +5482 7296 +5482 9925 +5482 5606 +5482 5852 +5482 7736 +5482 8262 +5482 6072 +5482 6747 +5482 8959 +5483 9608 +5483 6155 +5483 8790 +5483 6071 +5483 9757 +5484 9922 +5484 7939 +5484 6979 +5484 7401 +5484 5741 +5484 6222 +5484 8114 +5484 7606 +5484 9914 +5484 8574 +5485 8928 +5485 9489 +5485 5610 +5485 7933 +5485 6869 +5485 6936 +5485 7400 +5485 6506 +5486 5539 +5486 8873 +5486 5770 +5486 6545 +5486 9521 +5486 8760 +5486 8088 +5487 6082 +5487 8423 +5487 7298 +5487 6644 +5487 6453 +5487 5875 +5487 9272 +5487 8251 +5488 6816 +5488 6844 +5488 6766 +5488 9008 +5488 8216 +5488 7251 +5488 7732 +5488 6201 +5489 9387 +5489 6106 +5489 9490 +5489 9795 +5489 5749 +5489 8019 +5489 9274 +5490 7046 +5490 6537 +5490 8592 +5490 7197 +5490 6307 +5490 6698 +5490 7087 +5490 9865 +5490 8520 +5490 6380 +5490 7547 +5490 6314 +5491 7553 +5491 9410 +5491 9549 +5491 8227 +5491 9167 +5491 9697 +5491 5665 +5491 7510 +5491 7767 +5491 7450 +5492 7745 +5492 9924 +5492 7750 +5492 7501 +5492 8039 +5492 9562 +5492 7263 +5492 9405 +5493 7813 +5493 5638 +5493 9736 +5493 7308 +5493 5798 +5493 9780 +5493 6848 +5493 8901 +5493 7255 +5493 5597 +5493 7141 +5493 9440 +5493 7650 +5493 7651 +5493 6118 +5493 6374 +5493 8063 +5494 6588 +5494 8971 +5494 7661 +5494 8271 +5494 8116 +5494 6681 +5494 7346 +5494 9084 +5494 6622 +5495 8420 +5495 8297 +5495 9373 +5495 6900 +5495 9148 +5496 5901 +5496 7968 +5496 8115 +5496 6476 +5496 6434 +5496 7715 +5496 8916 +5496 6874 +5496 6116 +5496 8432 +5496 6515 +5497 7947 +5497 5506 +5497 8990 +5497 6701 +5497 6728 +5497 7860 +5497 8384 +5497 9302 +5497 7264 +5497 6117 +5497 7402 +5497 9965 +5497 7406 +5497 9967 +5497 8694 +5497 9850 +5498 6690 +5498 6907 +5498 6731 +5498 6381 +5498 8590 +5498 6482 +5498 7511 +5498 5946 +5498 9109 +5499 5889 +5499 6659 +5499 9603 +5499 9365 +5499 9633 +5499 5809 +5499 8773 +5499 6217 +5499 9438 +5499 7784 +5499 9837 +5499 9975 +5500 7909 +5500 8326 +5500 5902 +5500 8595 +5500 8309 +5500 6327 +5500 5595 +5500 7966 +5501 7688 +5501 9741 +5501 8590 +5501 8342 +5501 5783 +5501 8746 +5501 5931 +5501 5567 +5501 9170 +5501 6614 +5501 7145 +5501 6269 +5501 5746 +5501 5751 +5501 9981 +5502 5856 +5502 7568 +5502 8587 +5502 7527 +5502 5979 +5502 8711 +5502 6933 +5502 9629 +5503 6401 +5503 9233 +5503 8221 +5503 7690 +5503 7862 +5503 9926 +5503 8911 +5503 6357 +5503 7645 +5503 8043 +5504 8783 +5504 6677 +5504 7125 +5504 6271 +5504 6525 +5504 7902 +5504 9759 +5505 7970 +5505 5957 +5505 6792 +5505 5736 +5505 5681 +5505 7997 +5505 9765 +5506 8736 +5506 7937 +5506 8205 +5506 9362 +5506 7412 +5506 6614 +5507 7490 +5507 6805 +5507 7078 +5507 6073 +5507 7482 +5507 7648 +5507 5826 +5507 9565 +5507 8634 +5507 9696 +5508 5535 +5508 8995 +5508 8879 +5508 7347 +5508 7355 +5508 7459 +5508 5733 +5508 6004 +5508 7166 +5509 7510 +5509 9120 +5509 7083 +5509 7729 +5509 9146 +5509 8138 +5509 7119 +5509 9684 +5509 9053 +5509 9954 +5509 7415 +5510 8100 +5510 7494 +5510 6764 +5510 6996 +5510 6873 +5510 9981 +5511 8705 +5511 8035 +5511 8943 +5511 9774 +5511 9780 +5511 6416 +5511 6395 +5511 6457 +5511 9178 +5511 9135 +5512 6276 +5512 9606 +5512 9103 +5512 9049 +5512 6552 +5512 9264 +5512 8627 +5512 7243 +5512 7769 +5512 7788 +5512 8701 +5513 9474 +5513 7687 +5513 9993 +5513 6558 +5513 6942 +5513 8892 +5513 8517 +5513 9161 +5513 5982 +5513 7156 +5514 6684 +5514 8568 +5514 9903 +5514 7985 +5514 6838 +5514 8802 +5514 7653 +5514 9320 +5514 9976 +5514 7549 +5515 7692 +5515 6050 +5515 8495 +5515 9394 +5515 5918 +5515 9163 +5515 6094 +5515 6097 +5515 8121 +5515 8172 +5515 7162 +5516 6596 +5516 6309 +5516 9484 +5516 8206 +5516 7631 +5516 9110 +5516 8860 +5516 7006 +5517 6915 +5517 8453 +5517 5523 +5517 9364 +5517 7959 +5517 7584 +5517 6947 +5517 6057 +5517 8115 +5517 9140 +5517 5942 +5517 9174 +5517 7355 +5517 9035 +5518 7298 +5518 7236 +5518 7253 +5518 8025 +5518 7650 +5518 9699 +5518 6630 +5518 8045 +5518 9462 +5518 8570 +5519 8663 +5519 9100 +5519 9880 +5519 6429 +5519 5676 +5519 6837 +5519 7110 +5519 9463 +5519 8151 +5519 8048 +5519 9203 +5519 5879 +5520 7680 +5520 8988 +5520 6194 +5520 5561 +5520 6479 +5520 7151 +5520 9717 +5521 9765 +5521 8225 +5521 7629 +5521 9646 +5521 8945 +5521 8724 +5521 8533 +5521 6998 +5521 8118 +5522 6327 +5522 8127 +5522 9153 +5522 9795 +5522 8004 +5522 9039 +5522 9705 +5522 7281 +5522 8568 +5523 7214 +5523 8295 +5524 8706 +5524 6546 +5524 7897 +5524 7340 +5524 9522 +5524 7122 +5524 7001 +5524 7023 +5525 9182 +5525 7852 +5525 8692 +5525 5621 +5525 8476 +5525 7294 +5526 9515 +5526 5868 +5526 8073 +5526 9034 +5526 8971 +5526 8940 +5526 9583 +5526 6896 +5526 9755 +5526 9052 +5527 7152 +5527 8517 +5527 5813 +5527 8918 +5527 7228 +5528 6666 +5528 7835 +5528 8325 +5528 7072 +5528 6056 +5528 7337 +5528 9002 +5528 9146 +5528 8124 +5528 9669 +5528 7007 +5528 9319 +5528 5608 +5528 8179 +5528 6775 +5528 8189 +5528 6527 +5529 9197 +5529 9362 +5529 7714 +5529 9524 +5529 7759 +5529 6746 +5529 7998 +5530 7556 +5530 7314 +5530 9554 +5530 7252 +5530 5851 +5531 8192 +5531 6906 +5531 9068 +5531 8754 +5531 8470 +5531 8639 +5532 9056 +5532 5763 +5532 6604 +5532 9427 +5532 7081 +5532 9916 +5532 9662 +5533 8734 +5533 7975 +5533 9010 +5533 7737 +5533 6592 +5533 8400 +5533 9693 +5533 6367 +5533 8691 +5533 8693 +5533 7419 +5534 8198 +5534 6972 +5534 9541 +5534 7629 +5534 9295 +5534 9808 +5534 5971 +5534 9955 +5534 8794 +5534 9316 +5534 5871 +5534 8177 +5535 8987 +5535 7326 +5535 8483 +5535 9252 +5535 9267 +5535 9274 +5535 8508 +5535 5696 +5535 5834 +5535 6992 +5535 8789 +5536 7241 +5536 9034 +5536 5935 +5536 7875 +5536 8152 +5536 6835 +5536 6552 +5536 6488 +5536 5807 +5536 7453 +5536 8638 +5537 8680 +5537 7474 +5537 8106 +5537 9980 +5537 6559 +5538 6315 +5538 9737 +5538 6730 +5538 8898 +5538 6252 +5539 6504 +5539 9385 +5539 5834 +5539 9775 +5539 7417 +5539 8795 +5539 5887 +5540 9093 +5540 9480 +5540 6805 +5540 9634 +5540 8619 +5540 5814 +5540 9150 +5540 7285 +5540 8864 +5540 8909 +5540 6485 +5540 8160 +5540 6631 +5540 7740 +5540 8432 +5541 9929 +5541 8539 +5541 8109 +5541 9683 +5541 9970 +5541 7358 +5541 8886 +5541 6903 +5542 7958 +5542 6164 +5542 7332 +5542 9513 +5542 8621 +5542 5577 +5542 8520 +5542 7010 +5542 8557 +5542 7408 +5542 6775 +5542 8184 +5542 7039 +5543 9459 +5543 5736 +5543 7178 +5543 9132 +5543 8237 +5543 8241 +5543 5943 +5543 7166 +5544 9174 +5544 6183 +5544 6449 +5544 9106 +5544 5622 +5544 5719 +5544 5816 +5544 7731 +5545 9409 +5545 8546 +5545 8772 +5545 7622 +5545 7920 +5545 7336 +5545 9874 +5545 6056 +5545 5977 +5546 5696 +5546 5785 +5546 9884 +5546 6691 +5546 8485 +5546 8632 +5546 5939 +5546 9403 +5546 8254 +5546 9664 +5546 9815 +5546 6621 +5546 7010 +5546 7403 +5547 6643 +5547 5967 +5548 9430 +5548 8411 +5548 8837 +5548 9813 +5548 9845 +5549 8130 +5549 9102 +5549 6417 +5549 8941 +5549 5678 +5549 6513 +5549 5810 +5549 6254 +5549 6486 +5549 9342 +5550 7489 +5550 6219 +5550 9420 +5550 6289 +5550 9531 +5551 9352 +5551 7658 +5551 8785 +5551 8437 +5551 7863 +5551 8932 +5551 7518 +5552 5767 +5552 6162 +5552 9283 +5552 7218 +5552 9659 +5552 7625 +5552 8654 +5552 7768 +5552 7532 +5553 8451 +5553 6149 +5553 6306 +5553 6986 +5553 9390 +5553 7250 +5553 9871 +5553 9950 +5553 8341 +5554 7520 +5554 6499 +5554 7300 +5554 6246 +5554 7086 +5554 6643 +5554 9904 +5554 8946 +5554 8867 +5554 5859 +5554 7413 +5554 6679 +5554 5977 +5554 8190 +5554 6143 +5555 9698 +5555 7230 +5555 9260 +5555 9325 +5555 9137 +5555 9667 +5555 9940 +5555 7765 +5555 6639 +5555 9982 +5555 9183 +5556 6843 +5556 8016 +5556 8757 +5556 8216 +5557 9670 +5557 5621 +5557 5775 +5557 6591 +5557 7474 +5557 8886 +5557 9693 +5557 7679 +5558 8330 +5558 9547 +5558 7091 +5559 8966 +5559 8489 +5559 9132 +5559 7474 +5559 7859 +5559 7742 +5559 5951 +5559 6628 +5560 7266 +5560 9956 +5560 8103 +5560 6410 +5560 9223 +5560 9021 +5560 7732 +5560 9556 +5560 7294 +5560 9844 +5560 9787 +5561 8324 +5561 7951 +5561 7446 +5561 6296 +5561 8226 +5561 8615 +5561 7467 +5561 7603 +5561 7865 +5561 6849 +5561 7382 +5561 7385 +5561 8953 +5561 9215 +5562 7466 +5562 7517 +5562 6789 +5562 6067 +5562 9588 +5562 5653 +5562 6489 +5562 8426 +5562 5914 +5563 7321 +5563 8609 +5563 6052 +5563 9802 +5563 8791 +5563 7951 +5563 7945 +5563 6905 +5564 7777 +5564 8491 +5564 6135 +5564 8025 +5564 5919 +5565 9665 +5565 9486 +5565 6438 +5565 8743 +5565 6577 +5565 9522 +5565 7241 +5565 6608 +5565 8145 +5565 5843 +5565 9806 +5565 8684 +5565 7021 +5565 7029 +5566 9233 +5566 9514 +5566 5950 +5566 8263 +5566 8152 +5566 8155 +5566 5724 +5566 8287 +5566 9701 +5566 6890 +5566 7150 +5566 8188 +5567 7559 +5567 7946 +5567 8497 +5567 7606 +5567 6855 +5567 9296 +5567 6756 +5567 9190 +5567 6567 +5568 7307 +5568 7917 +5568 7954 +5568 8987 +5568 7070 +5568 7602 +5568 5819 +5568 9164 +5568 6861 +5568 6509 +5569 9602 +5569 9480 +5569 8265 +5569 6670 +5569 5877 +5569 5686 +5569 7831 +5569 6617 +5569 6702 +5570 6148 +5570 8974 +5570 6167 +5570 8089 +5570 6959 +5570 5670 +5570 6301 +5570 8031 +5570 6078 +5570 8262 +5570 9803 +5570 7125 +5570 8279 +5570 5855 +5570 6843 +5571 8005 +5571 9867 +5571 6802 +5571 6574 +5571 7951 +5571 9236 +5571 7991 +5571 8056 +5571 9213 +5572 6347 +5572 7405 +5572 9582 +5572 7320 +5572 5689 +5572 9903 +5572 9119 +5573 9541 +5573 7783 +5573 8615 +5573 9551 +5573 9808 +5573 6387 +5574 7616 +5574 9564 +5574 9927 +5574 8302 +5574 6574 +5574 6334 +5574 5634 +5574 9624 +5574 5630 +5575 9607 +5575 7453 +5575 8307 +5575 9498 +5575 9983 +5575 5759 +5576 5952 +5576 7966 +5576 6083 +5576 9582 +5576 9200 +5576 9244 +5576 7998 +5577 8128 +5577 7266 +5577 6955 +5577 6698 +5577 6638 +5577 7248 +5577 5809 +5577 9651 +5577 7645 +5578 7983 +5578 8747 +5578 9950 +5578 9627 +5578 7383 +5578 7255 +5578 8607 +5578 8028 +5578 5950 +5578 9759 +5579 8907 +5579 7052 +5579 7503 +5579 8355 +5579 9750 +5579 6745 +5579 6311 +5580 8962 +5580 7780 +5580 6374 +5580 9674 +5580 5740 +5580 9826 +5580 6715 +5581 5894 +5581 6151 +5581 8211 +5581 9003 +5581 9902 +5581 5808 +5581 5943 +5581 7745 +5581 7762 +5581 6309 +5581 8183 +5582 8834 +5582 6535 +5582 9609 +5582 8685 +5582 7954 +5582 8728 +5582 8120 +5582 9145 +5582 8139 +5582 6112 +5582 9958 +5582 6248 +5583 9504 +5583 8937 +5583 6796 +5583 9661 +5583 6900 +5583 8120 +5583 8477 +5584 8087 +5584 6295 +5584 5793 +5584 8117 +5584 6708 +5584 6844 +5584 8168 +5584 5742 +5584 7291 +5584 8573 +5585 7653 +5585 7692 +5585 6380 +5585 7256 +5585 9458 +5585 8470 +5585 8504 +5586 7137 +5586 9769 +5586 9181 +5586 9105 +5586 9454 +5586 7991 +5586 9146 +5586 8763 +5586 8893 +5587 6547 +5587 6296 +5587 7705 +5587 5669 +5587 6332 +5587 5703 +5587 8652 +5587 7374 +5587 8411 +5587 9711 +5587 7285 +5587 9471 +5588 7297 +5588 8354 +5588 9795 +5588 9925 +5588 7667 +5588 7408 +5588 5745 +5588 6003 +5588 5605 +5589 9731 +5589 8420 +5589 9413 +5589 9031 +5589 5707 +5589 5860 +5589 9268 +5589 8955 +5589 7081 +5589 6047 +5590 9219 +5590 8267 +5590 7886 +5590 9237 +5590 6232 +5590 6876 +5590 6973 +5590 8645 +5591 7168 +5591 7873 +5591 7266 +5591 7017 +5591 6570 +5591 6027 +5591 7343 +5591 7605 +5591 7261 +5592 7841 +5592 6436 +5592 7860 +5592 9908 +5592 6352 +5592 6738 +5592 9427 +5592 9430 +5592 6364 +5592 7262 +5592 5731 +5592 7250 +5592 9720 +5592 9212 +5593 5955 +5593 8329 +5593 7239 +5593 6934 +5593 9463 +5594 6113 +5594 7107 +5594 7142 +5594 7403 +5594 7308 +5594 7227 +5594 8792 +5594 7811 +5594 6135 +5594 9775 +5595 5892 +5595 7825 +5595 7324 +5595 7813 +5595 6178 +5595 6961 +5595 7860 +5595 8534 +5595 5606 +5595 5881 +5596 6258 +5596 7344 +5596 7833 +5596 7096 +5596 9657 +5596 8762 +5596 8095 +5596 8829 +5597 7136 +5597 6651 +5597 9577 +5597 6862 +5597 5971 +5597 9653 +5597 6201 +5597 6203 +5598 5633 +5598 8837 +5598 9746 +5598 7192 +5598 9242 +5598 7071 +5598 9903 +5598 5821 +5598 7618 +5598 6990 +5598 6737 +5598 8301 +5598 6640 +5598 8567 +5599 9840 +5599 7187 +5599 6741 +5599 5727 +5600 7012 +5600 7558 +5600 8876 +5600 7157 +5600 9599 +5601 8667 +5601 5668 +5601 8668 +5601 9004 +5601 9716 +5601 8637 +5601 9304 +5601 6363 +5601 8288 +5601 9445 +5601 9844 +5601 8441 +5602 8583 +5602 6792 +5602 9582 +5602 6132 +5602 8507 +5602 8520 +5602 8523 +5602 8032 +5602 9321 +5602 7800 +5603 6406 +5603 7305 +5603 9997 +5603 6043 +5603 8225 +5603 8866 +5603 6951 +5603 5808 +5603 8756 +5603 7864 +5603 7878 +5603 6601 +5603 6797 +5603 6864 +5603 9309 +5603 7394 +5603 9444 +5603 7912 +5603 7038 +5604 8448 +5604 6286 +5604 6319 +5604 9278 +5604 7122 +5604 9436 +5604 7391 +5605 8842 +5605 9771 +5605 7782 +5605 7790 +5605 7949 +5605 9522 +5605 6682 +5605 6340 +5605 9191 +5605 9706 +5605 9189 +5606 6278 +5606 5910 +5606 8996 +5606 6057 +5606 6218 +5606 6977 +5606 9671 +5606 9418 +5606 9165 +5606 7635 +5606 7768 +5606 8019 +5607 8844 +5607 8540 +5608 8835 +5608 8714 +5608 9944 +5608 6450 +5608 7862 +5608 6170 +5608 7017 +5609 8960 +5609 6922 +5609 5645 +5609 8209 +5609 5924 +5609 9267 +5609 8286 +5609 6456 +5609 9789 +5609 8899 +5609 5828 +5609 7514 +5609 5982 +5609 7423 +5610 6178 +5610 6212 +5610 8052 +5610 6804 +5610 7831 +5610 8132 +5610 7941 +5611 6112 +5611 9654 +5611 7784 +5611 6377 +5611 9544 +5611 7176 +5611 8879 +5611 6664 +5611 9184 +5611 9377 +5612 6425 +5612 9242 +5612 7711 +5612 6316 +5612 8635 +5612 5949 +5612 9663 +5612 7752 +5612 6091 +5612 7131 +5612 7267 +5612 5862 +5613 5686 +5613 8934 +5613 8360 +5613 9423 +5613 5910 +5613 6131 +5613 6069 +5613 5722 +5613 9545 +5614 6924 +5614 9106 +5614 7187 +5614 6085 +5614 8638 +5614 8096 +5614 7877 +5614 8412 +5614 6123 +5614 7919 +5614 7920 +5614 6131 +5615 7873 +5615 6888 +5615 9930 +5615 6124 +5615 6025 +5615 9593 +5615 9247 +5616 7618 +5616 5810 +5616 7348 +5616 9045 +5616 9622 +5616 5865 +5616 8126 +5617 8615 +5617 9068 +5617 9619 +5617 9550 +5617 9102 +5618 9824 +5618 7823 +5618 6007 +5618 8893 +5618 6463 +5619 5761 +5619 5890 +5619 7619 +5619 9092 +5619 6285 +5619 9454 +5619 7856 +5619 6931 +5619 9716 +5619 6424 +5619 6900 +5619 7674 +5619 9308 +5619 9834 +5620 9696 +5620 8736 +5620 8923 +5620 6935 +5620 6990 +5620 5732 +5620 7620 +5620 6231 +5620 9306 +5620 7484 +5621 8272 +5621 6001 +5621 8082 +5621 6773 +5621 7351 +5621 8415 +5621 6332 +5621 6781 +5622 5952 +5622 5668 +5622 7783 +5622 9772 +5622 6794 +5622 8463 +5622 8401 +5623 9558 +5623 5643 +5623 6468 +5623 7708 +5623 7458 +5623 7984 +5623 9698 +5623 8499 +5623 8631 +5623 9792 +5623 8260 +5623 7266 +5623 6486 +5623 6102 +5623 5998 +5623 8943 +5623 6385 +5623 6007 +5624 7456 +5624 6051 +5624 7336 +5624 7628 +5624 6860 +5624 8622 +5624 7857 +5624 8150 +5624 9496 +5624 6041 +5624 9146 +5624 9060 +5625 6414 +5625 9362 +5625 8506 +5626 7041 +5626 6562 +5626 7490 +5626 8180 +5626 9786 +5626 9822 +5627 9090 +5627 6163 +5627 8478 +5627 9133 +5627 7727 +5627 6960 +5627 7096 +5627 7359 +5627 7625 +5627 8397 +5627 7437 +5627 8659 +5627 9444 +5627 9324 +5627 7917 +5627 7539 +5627 7289 +5628 8103 +5628 7632 +5628 8696 +5628 8970 +5628 7839 +5629 9603 +5629 8339 +5629 8997 +5629 6709 +5629 5820 +5629 7513 +5630 8400 +5630 5745 +5630 9232 +5630 5862 +5630 6134 +5630 7575 +5630 6818 +5630 8866 +5631 9281 +5631 9538 +5631 9064 +5631 5804 +5631 6769 +5631 6966 +5631 6140 +5631 8189 +5631 6334 +5631 7807 +5632 7489 +5632 6188 +5632 7024 +5632 9617 +5632 7605 +5633 8686 +5633 7953 +5634 7009 +5634 6917 +5634 8581 +5634 9321 +5634 7246 +5634 9776 +5634 7125 +5634 6073 +5635 8160 +5635 6306 +5635 9415 +5635 5742 +5635 8883 +5635 9652 +5635 6254 +5635 5989 +5636 8867 +5636 8292 +5636 7974 +5636 7178 +5636 7949 +5636 9812 +5636 8419 +5636 9813 +5636 9284 +5636 7370 +5636 8126 +5637 7228 +5637 6506 +5637 6283 +5637 6798 +5637 7532 +5637 5865 +5637 9982 +5638 5791 +5638 9533 +5638 5958 +5638 9325 +5638 7409 +5638 6905 +5639 6784 +5639 9100 +5639 9116 +5639 8742 +5639 7592 +5639 7857 +5639 8147 +5639 8038 +5639 8172 +5639 8308 +5639 6651 +5640 9157 +5640 6509 +5640 9903 +5640 7309 +5640 6259 +5640 7864 +5640 9677 +5640 6479 +5641 8706 +5641 9256 +5641 7625 +5641 8529 +5641 8436 +5641 8251 +5641 5726 +5642 6098 +5642 9863 +5642 8105 +5642 6284 +5642 6466 +5642 5934 +5642 7663 +5642 7504 +5642 8387 +5642 9242 +5643 7042 +5643 9496 +5643 7982 +5643 9791 +5643 8008 +5643 7374 +5643 8400 +5643 6995 +5643 8022 +5643 9308 +5643 7141 +5643 9075 +5643 6774 +5644 5750 +5644 8360 +5644 7047 +5644 9265 +5644 7091 +5644 9620 +5644 6037 +5644 6902 +5644 8024 +5644 7772 +5644 9726 +5644 6821 +5645 8323 +5645 9734 +5645 7436 +5645 8973 +5645 7574 +5645 6424 +5645 8864 +5645 7101 +5645 9928 +5645 8738 +5645 6738 +5645 8544 +5645 6241 +5645 9443 +5645 8938 +5645 8820 +5646 6502 +5646 7626 +5646 9996 +5646 8045 +5646 7598 +5646 9145 +5646 9881 +5646 9477 +5647 5825 +5647 7787 +5647 6861 +5647 9873 +5647 5842 +5647 7292 +5647 8734 +5648 9602 +5648 7813 +5648 8970 +5648 5655 +5648 8101 +5648 8876 +5648 7351 +5648 9400 +5648 9913 +5648 5716 +5649 5778 +5649 7583 +5649 8744 +5649 9665 +5649 9159 +5649 9677 +5649 8431 +5650 8582 +5650 6792 +5650 7436 +5650 9252 +5650 7083 +5650 6702 +5650 6598 +5650 6995 +5650 5732 +5650 9828 +5650 7142 +5650 7279 +5650 6643 +5650 9077 +5651 8161 +5651 7335 +5651 6762 +5651 6252 +5651 9213 +5651 9514 +5651 8510 +5652 6147 +5652 9104 +5652 6438 +5652 8359 +5652 7977 +5652 7865 +5652 8519 +5652 9557 +5652 9199 +5652 9337 +5653 6976 +5653 7328 +5653 6343 +5653 9226 +5653 9392 +5653 5805 +5653 6642 +5653 9874 +5653 8702 +5654 7582 +5654 8225 +5654 9251 +5654 8180 +5654 6461 +5654 8898 +5654 6858 +5654 5862 +5654 8685 +5655 8707 +5655 7957 +5655 9646 +5655 9011 +5655 9027 +5655 9285 +5655 5983 +5655 6647 +5656 9122 +5656 8387 +5656 5924 +5656 6700 +5656 7607 +5656 9038 +5656 5843 +5656 9274 +5656 7099 +5656 8574 +5656 9535 +5657 9479 +5657 9652 +5657 8436 +5657 8543 +5658 8450 +5658 9755 +5658 6444 +5658 6843 +5658 6720 +5658 6095 +5658 9693 +5658 9982 +5659 7616 +5659 9088 +5659 8228 +5659 9133 +5659 9198 +5659 8659 +5659 8343 +5660 7175 +5660 8335 +5660 7568 +5660 8604 +5660 7976 +5660 6956 +5660 8533 +5660 8289 +5660 8041 +5660 9587 +5661 6049 +5661 6735 +5661 9328 +5661 6510 +5661 9781 +5661 8438 +5661 6736 +5662 9797 +5662 7176 +5662 7505 +5662 9556 +5662 9341 +5662 7862 +5662 7675 +5663 8715 +5663 6924 +5663 7437 +5663 9877 +5663 5787 +5663 7153 +5663 7743 +5663 6234 +5663 9963 +5663 8319 +5664 6498 +5664 9539 +5664 9028 +5664 7333 +5664 9510 +5664 7759 +5664 8468 +5664 9709 +5664 6831 +5664 8040 +5665 7507 +5665 9069 +5665 9049 +5665 6970 +5665 9903 +5665 6586 +5665 6335 +5666 7554 +5666 9123 +5666 8552 +5666 8045 +5666 6830 +5666 6736 +5666 6450 +5666 6012 +5666 8026 +5667 9734 +5667 6667 +5667 8206 +5667 9618 +5667 7827 +5667 7830 +5667 9639 +5667 9780 +5667 7502 +5667 7525 +5667 9448 +5667 8692 +5667 6398 +5668 8486 +5668 9739 +5668 9008 +5668 7665 +5668 7499 +5668 6107 +5669 7395 +5669 7458 +5669 7464 +5669 7212 +5669 8115 +5669 9913 +5669 9933 +5669 5735 +5669 8812 +5670 7459 +5670 9129 +5670 9151 +5670 8314 +5670 9439 +5671 6210 +5671 5965 +5671 9135 +5671 9368 +5671 8637 +5671 7774 +5671 6879 +5672 8740 +5672 7813 +5672 7818 +5672 8183 +5672 6604 +5672 5805 +5672 7023 +5672 6066 +5672 5910 +5672 6002 +5672 9551 +5672 6398 +5672 6207 +5673 7776 +5673 7878 +5673 9377 +5673 5993 +5673 9492 +5673 7833 +5673 9083 +5674 9243 +5674 8037 +5674 6670 +5674 6322 +5674 7444 +5674 7416 +5675 9378 +5675 5771 +5675 6596 +5675 6390 +5675 9227 +5675 6006 +5676 9347 +5676 9989 +5676 8988 +5676 6386 +5676 6071 +5676 7357 +5676 6084 +5676 7624 +5676 7536 +5676 8946 +5676 8823 +5677 8834 +5677 8740 +5677 6771 +5677 6003 +5677 9213 +5677 7039 +5678 7844 +5678 9893 +5678 8426 +5678 9351 +5678 8347 +5679 8267 +5679 7309 +5679 8398 +5679 7311 +5679 9427 +5679 7267 +5679 8987 +5679 8741 +5680 8865 +5680 6946 +5680 9156 +5680 9096 +5680 7132 +5680 6972 +5681 7010 +5681 7589 +5681 6566 +5681 7306 +5681 8908 +5681 8194 +5681 6638 +5681 8398 +5681 7007 +5681 6291 +5681 5752 +5681 6570 +5682 6432 +5682 8389 +5682 9521 +5682 8617 +5682 9354 +5682 6509 +5682 9458 +5682 8155 +5682 7804 +5683 8386 +5683 8936 +5683 8809 +5683 5783 +5683 6737 +5683 9395 +5683 8127 +5684 7303 +5684 7950 +5684 6297 +5684 6170 +5684 6711 +5684 7227 +5684 8586 +5684 7157 +5684 6413 +5684 7252 +5684 9461 +5684 7615 +5685 6284 +5685 7707 +5685 6687 +5685 9014 +5685 6456 +5685 7378 +5685 8920 +5685 9179 +5685 6255 +5685 9715 +5685 6518 +5685 7420 +5686 6320 +5686 9909 +5686 6874 +5687 9729 +5687 6423 +5687 7962 +5687 9243 +5687 6433 +5687 6811 +5687 8000 +5687 8641 +5687 7107 +5687 8388 +5687 8523 +5687 9944 +5687 8805 +5687 6266 +5688 9609 +5688 6285 +5688 8593 +5688 7448 +5688 7332 +5688 6821 +5688 9293 +5688 7765 +5688 9431 +5688 8031 +5688 7399 +5688 8943 +5688 8304 +5689 7956 +5689 8860 +5689 9119 +5689 8492 +5689 6840 +5689 9025 +5689 7889 +5689 7894 +5689 6999 +5689 8160 +5690 9435 +5690 9924 +5690 7947 +5690 7888 +5690 8376 +5690 9625 +5691 8326 +5691 7179 +5691 8472 +5691 7337 +5691 5805 +5691 9034 +5691 5860 +5691 8678 +5691 8429 +5691 6389 +5691 6137 +5691 8700 +5692 8031 +5692 6819 +5692 8008 +5692 6995 +5692 9907 +5692 9399 +5692 7091 +5692 9791 +5692 9949 +5692 7166 +5693 6081 +5693 8853 +5693 8267 +5693 7862 +5693 5720 +5693 6073 +5694 9122 +5694 9152 +5694 6895 +5694 9784 +5694 8376 +5695 8202 +5695 6802 +5695 6426 +5695 7722 +5695 6062 +5695 7863 +5695 8647 +5695 7633 +5695 6746 +5695 8288 +5695 8420 +5695 8300 +5696 5765 +5696 8718 +5696 9105 +5696 9408 +5696 8770 +5696 9581 +5697 7299 +5697 9706 +5697 9583 +5697 6259 +5697 6655 +5698 6528 +5698 6577 +5698 8883 +5698 7862 +5698 8127 +5698 8386 +5698 5830 +5698 8296 +5698 6014 +5699 9632 +5699 9028 +5699 9225 +5699 6254 +5699 5840 +5699 9189 +5699 7957 +5699 7805 +5700 6656 +5700 9953 +5700 8805 +5700 9706 +5700 7413 +5700 9305 +5700 8889 +5700 9402 +5700 8284 +5700 8437 +5701 7308 +5701 6942 +5701 7967 +5701 6564 +5701 7349 +5701 7638 +5701 7521 +5701 5866 +5701 8305 +5701 6116 +5702 8962 +5702 9335 +5702 9263 +5702 9175 +5702 8983 +5702 7065 +5702 6008 +5703 9104 +5703 6813 +5703 6564 +5703 5961 +5703 6730 +5703 9676 +5703 7019 +5704 7012 +5704 6053 +5704 7484 +5704 8781 +5704 8816 +5704 8148 +5704 7860 +5704 6910 +5705 9046 +5705 6412 +5705 7703 +5705 6299 +5705 8325 +5705 9647 +5705 8128 +5705 7234 +5705 8643 +5705 8662 +5705 8933 +5705 6763 +5705 7417 +5706 7460 +5706 5992 +5706 9389 +5706 6894 +5706 9852 +5707 6403 +5707 6285 +5707 6042 +5707 6046 +5707 7841 +5707 9768 +5707 8880 +5707 7346 +5707 8639 +5707 7630 +5707 7259 +5707 6512 +5708 8898 +5708 7371 +5708 9107 +5708 5963 +5708 7765 +5708 5719 +5708 8732 +5708 9630 +5709 8192 +5709 8963 +5709 8197 +5709 9735 +5709 9987 +5709 6808 +5709 7727 +5709 8506 +5709 5832 +5709 6866 +5709 7394 +5709 6121 +5709 6009 +5710 6419 +5710 9744 +5710 7443 +5710 7833 +5710 8095 +5710 9509 +5710 8623 +5710 6449 +5710 8633 +5710 6589 +5710 6732 +5710 7637 +5710 8407 +5710 9021 +5710 8595 +5710 9726 +5711 6808 +5711 7323 +5711 7213 +5711 9136 +5711 7474 +5711 7479 +5711 9272 +5711 9659 +5711 7109 +5711 6216 +5711 9015 +5711 7133 +5711 8421 +5711 6760 +5711 6655 +5712 8676 +5712 6277 +5712 8240 +5712 8630 +5712 6138 +5712 6527 +5713 9474 +5713 8643 +5713 6804 +5713 7957 +5713 9881 +5713 7460 +5713 7082 +5713 6023 +5713 8515 +5713 7621 +5713 8185 +5713 8821 +5713 7542 +5714 7852 +5714 9997 +5714 6168 +5714 9372 +5714 6052 +5714 8871 +5714 7466 +5714 6444 +5714 6968 +5714 9689 +5714 8673 +5714 9209 +5715 5760 +5715 5732 +5715 7521 +5715 7533 +5715 8737 +5715 6979 +5715 8827 +5716 6594 +5716 8644 +5716 8613 +5716 9992 +5716 6964 +5716 7068 +5716 9533 +5716 9182 +5717 8758 +5717 9602 +5717 5765 +5717 6844 +5717 6935 +5717 9550 +5717 9712 +5717 7183 +5717 7254 +5717 6903 +5717 9656 +5717 6223 +5717 5884 +5717 9834 +5718 9728 +5718 6913 +5718 8708 +5718 7559 +5718 8852 +5718 6179 +5718 7279 +5718 7665 +5719 7044 +5719 9638 +5719 7082 +5719 9643 +5719 6575 +5719 6901 +5719 8501 +5719 8348 +5719 9214 +5720 8352 +5720 7235 +5720 9765 +5720 6577 +5720 6120 +5720 9198 +5720 9806 +5720 7190 +5720 9144 +5720 7934 +5720 5957 +5721 7939 +5721 7963 +5721 8728 +5721 9108 +5721 7566 +5721 6870 +5721 8120 +5721 5722 +5721 9148 +5721 8382 +5722 7056 +5722 8963 +5722 8582 +5722 7559 +5722 6569 +5722 7751 +5722 9694 +5722 6715 +5722 7549 +5722 7742 +5723 9344 +5723 7268 +5723 7570 +5723 9079 +5723 9144 +5724 7490 +5724 9731 +5724 7461 +5724 7371 +5724 8235 +5724 7261 +5724 8754 +5724 8950 +5724 7513 +5724 7636 +5725 7905 +5725 9395 +5725 9671 +5725 7336 +5725 8563 +5725 6798 +5725 6418 +5725 7639 +5725 8527 +5725 7551 +5726 5987 +5726 9798 +5726 8301 +5726 6862 +5726 9493 +5726 7415 +5726 7692 +5727 8990 +5727 6306 +5727 7210 +5727 6970 +5727 9795 +5727 8789 +5727 9954 +5727 7779 +5728 8480 +5728 8452 +5728 7238 +5728 6855 +5728 8200 +5728 9440 +5728 8402 +5728 8407 +5728 9596 +5728 8350 +5729 6946 +5729 8067 +5729 7127 +5729 7842 +5729 5934 +5729 7823 +5729 5751 +5729 9083 +5730 6934 +5730 8612 +5730 8999 +5730 6190 +5730 7087 +5730 8533 +5730 9706 +5730 7151 +5730 8695 +5731 7300 +5731 6936 +5731 5789 +5731 9898 +5731 6456 +5731 9783 +5731 7903 +5731 8933 +5731 8425 +5732 7430 +5732 7015 +5732 6477 +5732 9167 +5732 7408 +5732 7347 +5732 7702 +5732 7063 +5732 9817 +5732 6842 +5732 7163 +5733 6818 +5733 8901 +5733 7467 +5733 6128 +5733 6806 +5733 7865 +5733 9689 +5734 7408 +5734 6289 +5734 7465 +5734 9770 +5734 9195 +5734 6320 +5734 8113 +5734 9972 +5734 8457 +5734 9643 +5734 9341 +5735 6608 +5735 8490 +5735 8139 +5735 6384 +5735 9394 +5735 8692 +5735 8378 +5735 9403 +5736 8091 +5736 6584 +5736 7375 +5736 8672 +5736 8426 +5736 6002 +5737 9106 +5737 8859 +5737 8239 +5737 6962 +5737 7868 +5737 8388 +5737 7887 +5737 5847 +5737 6236 +5737 9186 +5737 7779 +5737 8338 +5737 8432 +5737 7288 +5737 6143 +5738 7040 +5738 6761 +5738 8549 +5738 5959 +5738 7082 +5738 9517 +5738 9238 +5738 6345 +5738 8155 +5738 8158 +5739 6665 +5739 8729 +5739 6298 +5739 8990 +5739 9526 +5739 6153 +5739 7878 +5739 6855 +5739 7543 +5739 8022 +5739 8923 +5739 5980 +5739 9056 +5740 5825 +5740 7300 +5740 8552 +5740 8201 +5740 8020 +5740 6078 +5741 7396 +5741 6666 +5741 7764 +5741 6774 +5741 6729 +5742 8320 +5742 8520 +5742 8015 +5743 7299 +5743 9223 +5743 7021 +5743 9902 +5743 7443 +5743 8398 +5743 7898 +5743 8895 +5743 8970 +5744 8960 +5744 7044 +5744 9445 +5744 7308 +5744 6037 +5744 9272 +5744 9625 +5744 7676 +5745 7056 +5745 7882 +5745 7088 +5745 7348 +5745 6455 +5745 7613 +5745 6590 +5745 9415 +5745 6984 +5745 8268 +5745 8928 +5745 9323 +5745 9082 +5746 7489 +5746 7023 +5746 9990 +5746 7137 +5746 8778 +5746 9198 +5746 9871 +5746 8883 +5746 7768 +5746 6015 +5746 8959 +5747 8740 +5747 9065 +5747 6775 +5747 8829 +5747 9489 +5748 9504 +5748 6017 +5748 7271 +5748 8860 +5749 8007 +5749 9292 +5749 8870 +5749 5973 +5749 6806 +5749 6425 +5749 8316 +5750 6445 +5750 7443 +5750 7420 +5750 5823 +5751 7950 +5751 8413 +5751 9808 +5751 7126 +5751 6903 +5751 7871 +5752 6160 +5752 8605 +5752 6896 +5752 6699 +5752 8765 +5752 6969 +5752 9035 +5752 9427 +5752 9818 +5752 7516 +5752 9851 +5752 6901 +5753 8964 +5753 7068 +5753 9117 +5753 8457 +5753 7233 +5753 8299 +5753 9971 +5753 7804 +5754 7937 +5754 7492 +5754 8426 +5754 9230 +5754 7123 +5754 9652 +5754 9054 +5755 7335 +5755 9770 +5755 7991 +5755 7154 +5755 8948 +5755 8506 +5756 8226 +5756 7461 +5756 9387 +5756 8627 +5756 9399 +5756 6100 +5756 7258 +5756 8952 +5757 9610 +5757 6694 +5757 9915 +5757 7491 +5757 8661 +5757 9566 +5757 9311 +5757 6013 +5758 8544 +5758 9639 +5758 7723 +5758 9518 +5758 6399 +5759 8069 +5759 9640 +5759 7499 +5759 8461 +5759 8142 +5759 8596 +5759 9166 +5759 8188 +5760 7365 +5760 7847 +5760 6985 +5760 6188 +5760 9776 +5760 8658 +5760 8504 +5760 6749 +5761 8712 +5761 7697 +5761 8138 +5761 6604 +5761 8530 +5761 7137 +5761 6638 +5761 9724 +5762 6465 +5762 5864 +5762 9399 +5762 8513 +5762 7822 +5762 7122 +5762 6071 +5762 7335 +5762 5917 +5763 8608 +5763 8003 +5763 7047 +5763 6031 +5763 9871 +5763 8766 +5764 7755 +5764 7182 +5764 5844 +5764 7862 +5764 8600 +5764 6111 +5764 9050 +5765 8325 +5765 7789 +5765 7448 +5765 7715 +5765 6565 +5765 7227 +5765 7112 +5765 9893 +5765 9721 +5765 6270 +5766 5968 +5766 8939 +5766 8659 +5766 9044 +5766 8997 +5766 7094 +5766 8088 +5766 6426 +5766 7964 +5767 6434 +5767 8131 +5767 6788 +5767 8840 +5767 8905 +5767 8812 +5767 9712 +5767 5809 +5767 6812 +5767 7965 +5768 7008 +5768 6465 +5768 9511 +5768 6249 +5768 8491 +5768 7759 +5768 8436 +5768 8938 +5768 7165 +5769 7441 +5769 7955 +5769 8853 +5769 6561 +5769 9010 +5769 5940 +5769 8758 +5769 7097 +5769 7363 +5769 6987 +5769 7769 +5769 7516 +5769 9700 +5770 6208 +5770 8327 +5770 6508 +5770 8210 +5770 8079 +5770 7698 +5770 9311 +5771 8610 +5771 6045 +5772 9958 +5772 6093 +5772 8494 +5772 8406 +5772 7960 +5773 9088 +5773 6081 +5773 9764 +5773 7183 +5773 9406 +5773 9081 +5773 7897 +5773 9596 +5773 7934 +5774 6785 +5774 7509 +5774 7452 +5775 6296 +5775 9627 +5775 6818 +5775 6180 +5775 8773 +5775 9037 +5775 8143 +5775 7420 +5776 7810 +5776 7820 +5776 7832 +5776 8605 +5776 6706 +5776 9403 +5776 9558 +5776 7396 +5776 6369 +5776 8808 +5776 6644 +5776 8317 +5777 8585 +5777 7053 +5777 8861 +5777 9630 +5777 9887 +5777 7729 +5777 6863 +5777 7640 +5777 8292 +5777 8294 +5777 8942 +5778 9229 +5778 8720 +5778 8860 +5778 7840 +5778 8758 +5778 8510 +5778 9795 +5778 7878 +5778 5959 +5778 8535 +5778 8313 +5778 8446 +5779 7183 +5779 6178 +5779 9129 +5779 7729 +5779 9282 +5779 8390 +5779 8534 +5779 6624 +5779 7268 +5779 6635 +5779 9589 +5779 9851 +5780 9127 +5780 9804 +5780 6836 +5780 6841 +5780 7133 +5781 5867 +5781 6022 +5781 9769 +5781 6448 +5781 6709 +5781 5974 +5781 8154 +5782 6338 +5782 9315 +5782 8743 +5782 7697 +5782 9653 +5782 9562 +5783 7970 +5783 8675 +5783 6311 +5783 9677 +5783 8398 +5783 8787 +5784 6240 +5784 7116 +5784 7144 +5784 6153 +5784 8855 +5784 7350 +5785 9728 +5785 7177 +5785 9755 +5785 5790 +5785 6086 +5785 6620 +5785 7087 +5785 7485 +5785 9790 +5785 8390 +5785 5852 +5785 9320 +5785 9964 +5786 8087 +5786 6177 +5786 9250 +5786 6052 +5786 8107 +5786 9004 +5786 9517 +5786 7098 +5786 6999 +5786 6251 +5786 9329 +5786 7545 +5787 8233 +5787 9524 +5787 5943 +5787 7739 +5787 5980 +5787 9822 +5787 5864 +5788 6410 +5788 9745 +5788 7577 +5788 9138 +5788 6850 +5788 9034 +5788 9452 +5788 7540 +5789 6464 +5789 9610 +5789 7490 +5789 8516 +5789 9735 +5789 8712 +5789 8554 +5789 6677 +5789 8122 +5789 6750 +5790 6272 +5790 7169 +5790 8479 +5790 9415 +5790 9036 +5790 8270 +5790 9551 +5790 9427 +5790 6228 +5790 9820 +5790 9586 +5790 8566 +5790 7292 +5791 5934 +5791 6833 +5791 8663 +5791 9182 +5791 6141 +5792 7490 +5792 9507 +5792 6191 +5792 8213 +5792 9430 +5792 6487 +5792 9277 +5793 8833 +5793 9353 +5793 8210 +5793 6315 +5793 8494 +5793 8377 +5793 7099 +5793 5972 +5793 8412 +5793 8293 +5794 9760 +5794 7140 +5794 8709 +5794 5863 +5794 7724 +5794 7261 +5794 7696 +5794 8021 +5795 8256 +5795 9858 +5795 7155 +5795 6057 +5795 6260 +5795 8091 +5795 8732 +5796 9430 +5796 7301 +5796 9318 +5796 8361 +5796 9870 +5796 5904 +5796 8017 +5796 6194 +5796 9750 +5796 7770 +5796 7003 +5796 8924 +5796 6205 +5796 8894 +5797 9536 +5797 7042 +5797 8722 +5797 9908 +5797 7616 +5797 6904 +5798 9818 +5798 8230 +5798 5801 +5798 9644 +5798 6961 +5798 9791 +5798 5954 +5798 8136 +5798 9936 +5798 8922 +5798 7026 +5798 6134 +5799 6593 +5799 8209 +5799 7829 +5799 9732 +5799 5916 +5799 9508 +5799 7085 +5799 8752 +5799 9662 +5799 8769 +5799 7972 +5799 9315 +5800 8616 +5800 9463 +5800 6013 +5801 9826 +5801 9104 +5801 6436 +5801 9286 +5801 6374 +5801 6381 +5801 8462 +5801 9391 +5801 8403 +5801 5877 +5801 8603 +5801 9021 +5802 6401 +5802 9284 +5802 6189 +5802 8637 +5802 6712 +5802 6834 +5802 6452 +5802 5814 +5802 7161 +5802 9693 +5803 9511 +5803 7241 +5803 6759 +5803 7692 +5803 9199 +5803 6068 +5803 6293 +5803 7305 +5803 8126 +5803 8991 +5804 8323 +5804 9774 +5804 8882 +5804 6259 +5804 7996 +5804 6855 +5804 9050 +5804 9695 +5804 8168 +5804 9203 +5805 6735 +5805 6547 +5805 8535 +5805 7400 +5805 8956 +5805 8010 +5805 7870 +5806 9197 +5806 8561 +5806 6933 +5806 7593 +5806 9082 +5807 7243 +5807 8786 +5807 8247 +5807 6557 +5807 6014 +5808 5893 +5808 8806 +5808 6799 +5808 5968 +5808 8397 +5808 5919 +5809 8452 +5809 9128 +5809 8499 +5809 7887 +5809 9553 +5809 8466 +5809 6851 +5809 8579 +5809 8154 +5810 6404 +5810 6345 +5810 7034 +5810 7093 +5811 8371 +5811 9229 +5811 9876 +5811 6428 +5811 7328 +5811 7074 +5811 6821 +5811 7007 +5811 8807 +5811 5997 +5811 8687 +5812 6276 +5812 9544 +5812 7179 +5812 7598 +5812 9928 +5812 6135 +5812 6248 +5812 7039 +5813 9602 +5813 8005 +5813 6759 +5813 7272 +5813 6589 +5813 8507 +5814 7906 +5814 6279 +5814 9674 +5814 9944 +5814 6825 +5814 8814 +5815 9863 +5815 9719 +5815 6829 +5815 9736 +5815 7252 +5815 8693 +5815 7227 +5815 9754 +5815 8702 +5816 8977 +5816 8861 +5816 5841 +5817 7746 +5817 8908 +5817 9293 +5817 8510 +5817 9238 +5817 7423 +5818 7298 +5818 9229 +5818 9527 +5818 6719 +5818 6982 +5818 8780 +5818 8589 +5818 8639 +5819 6370 +5819 6251 +5819 7841 +5819 5960 +5819 6217 +5819 9418 +5819 9995 +5819 7132 +5819 8481 +5819 7822 +5819 8766 +5820 7074 +5820 7971 +5820 6057 +5820 9021 +5820 9187 +5820 6503 +5821 6976 +5821 8321 +5821 8292 +5821 9997 +5821 9934 +5821 7119 +5821 9071 +5822 9025 +5822 6696 +5822 6474 +5822 8742 +5822 8226 +5822 9139 +5822 8600 +5822 8379 +5823 8210 +5823 9619 +5823 7070 +5823 9904 +5823 9387 +5823 8624 +5823 7601 +5823 7352 +5823 9077 +5823 7616 +5823 8258 +5823 6744 +5824 7040 +5824 9955 +5824 6854 +5824 6087 +5824 8766 +5825 9467 +5825 8455 +5825 9418 +5825 6457 +5825 7099 +5826 7695 +5826 5876 +5826 9048 +5826 6461 +5826 7455 +5827 8782 +5827 6757 +5827 6802 +5827 7508 +5827 7190 +5827 6116 +5827 9951 +5828 6325 +5828 7982 +5828 8355 +5828 9134 +5828 6453 +5828 6606 +5828 9555 +5828 7132 +5828 6182 +5828 7292 +5828 7573 +5829 6305 +5829 6761 +5829 7947 +5829 7981 +5829 8781 +5829 8566 +5829 9145 +5829 6361 +5829 8476 +5830 7135 +5830 9670 +5830 9400 +5830 6133 +5830 6543 +5831 6296 +5831 8894 +5831 7882 +5831 8532 +5831 7125 +5831 6617 +5831 6885 +5831 6253 +5831 9812 +5831 8699 +5832 9861 +5832 8743 +5832 7851 +5832 6094 +5832 7791 +5832 6004 +5832 6715 +5832 6204 +5833 8581 +5833 7458 +5833 9018 +5833 7459 +5833 8672 +5833 8674 +5834 8304 +5834 7363 +5834 8233 +5834 9147 +5834 7442 +5834 7129 +5834 8733 +5834 7359 +5835 5892 +5835 6629 +5835 6790 +5835 8071 +5835 6860 +5835 6127 +5835 6484 +5835 8981 +5835 8055 +5835 8351 +5835 8219 +5836 6368 +5836 7589 +5836 6740 +5836 7512 +5837 7424 +5837 6365 +5837 6221 +5837 6702 +5837 8545 +5838 9600 +5838 6673 +5838 9364 +5838 8086 +5838 9689 +5838 6940 +5838 8221 +5838 8864 +5838 8234 +5838 9138 +5838 9543 +5838 8788 +5838 9854 +5839 5984 +5839 7771 +5839 6507 +5839 6783 +5839 7118 +5839 8575 +5840 6188 +5840 6787 +5840 9393 +5841 7184 +5841 8343 +5841 8994 +5841 9537 +5841 8259 +5841 6479 +5841 9423 +5841 9184 +5841 6257 +5841 9462 +5841 9212 +5842 7339 +5842 8456 +5842 7203 +5842 7848 +5842 7488 +5842 9421 +5842 9917 +5842 6898 +5843 6304 +5843 8902 +5843 7509 +5843 9176 +5843 8939 +5843 8447 +5844 8651 +5844 9796 +5844 6725 +5844 6246 +5844 6662 +5844 8210 +5844 6205 +5844 6469 +5845 7457 +5845 9020 +5845 7113 +5845 7639 +5845 7770 +5845 5853 +5845 8798 +5845 7137 +5845 6883 +5845 6628 +5845 7398 +5846 8609 +5846 7973 +5846 8412 +5846 9386 +5846 8075 +5846 7524 +5846 7455 +5847 6150 +5847 5904 +5847 7449 +5848 8074 +5848 8398 +5848 8525 +5848 6992 +5848 9556 +5848 7901 +5848 8032 +5848 8936 +5848 7027 +5848 8575 +5849 8736 +5849 7362 +5849 8296 +5849 6956 +5849 6370 +5849 9263 +5849 7281 +5850 7810 +5850 7021 +5850 8739 +5850 7274 +5851 6373 +5851 8679 +5851 7369 +5851 7035 +5852 9095 +5852 9993 +5852 8893 +5852 8132 +5852 8530 +5852 8551 +5852 6889 +5852 7281 +5853 6418 +5853 8219 +5853 5973 +5853 5945 +5853 8383 +5853 7621 +5853 9417 +5853 7121 +5853 7252 +5853 8176 +5853 8957 +5854 7776 +5854 9345 +5854 7366 +5854 7530 +5854 7662 +5854 5884 +5854 8458 +5855 8301 +5855 6937 +5855 7201 +5855 6087 +5855 9908 +5855 6070 +5855 7233 +5855 9121 +5855 9417 +5856 7050 +5856 6823 +5856 8494 +5856 8119 +5856 6210 +5856 7120 +5856 9553 +5856 9427 +5856 6623 +5857 6601 +5857 9897 +5857 5895 +5857 7343 +5857 8442 +5858 9858 +5858 9732 +5858 8473 +5858 9882 +5858 9761 +5858 7774 +5858 8509 +5858 6581 +5858 9280 +5858 8353 +5858 7132 +5858 8030 +5858 7906 +5858 7930 +5858 6142 +5859 9222 +5859 7573 +5859 6050 +5859 8631 +5859 8772 +5859 6605 +5859 9555 +5859 6140 +5859 6781 +5860 8839 +5860 6989 +5860 6672 +5860 8824 +5860 7898 +5860 9660 +5861 6528 +5861 7908 +5861 8012 +5861 7979 +5861 7949 +5861 8884 +5861 6104 +5861 9020 +5862 7941 +5862 8614 +5862 8711 +5862 6191 +5862 9928 +5862 7960 +5862 7323 +5863 8923 +5863 7524 +5863 8847 +5863 5968 +5863 9882 +5863 9403 +5863 8131 +5864 9219 +5864 7312 +5864 6169 +5864 7715 +5864 7590 +5864 9132 +5864 9910 +5864 6979 +5864 9798 +5864 6855 +5864 6482 +5864 6233 +5864 7145 +5864 8189 +5865 8592 +5865 6042 +5865 6580 +5865 9375 +5865 7741 +5865 8420 +5865 7143 +5865 6515 +5866 7803 +5866 7984 +5866 5944 +5866 7451 +5867 9440 +5867 9937 +5867 6333 +5868 8937 +5868 7306 +5868 8760 +5868 7225 +5868 7290 +5868 9372 +5868 5937 +5869 8486 +5869 7373 +5869 8057 +5869 9488 +5869 6905 +5869 9499 +5870 8965 +5870 9240 +5870 7791 +5870 6687 +5870 6179 +5870 7370 +5870 9035 +5870 7374 +5870 9042 +5870 5978 +5870 8429 +5870 6905 +5871 6373 +5871 6186 +5871 7468 +5871 8304 +5871 6035 +5871 7669 +5871 9686 +5871 9083 +5871 7594 +5872 6180 +5872 6297 +5872 8239 +5872 6428 +5873 6251 +5873 6377 +5873 7035 +5873 7468 +5873 9614 +5873 7021 +5873 8082 +5873 8275 +5873 8154 +5873 7003 +5873 8282 +5874 9414 +5874 7727 +5874 8208 +5874 7025 +5874 7388 +5875 5893 +5875 8900 +5875 8345 +5875 7068 +5875 7069 +5875 9910 +5875 9663 +5875 6860 +5875 7030 +5875 8829 +5876 7843 +5876 6180 +5876 6065 +5876 6259 +5876 8981 +5876 7702 +5876 9815 +5876 7551 +5877 8598 +5877 9238 +5877 9764 +5877 9266 +5877 9527 +5877 8001 +5877 9929 +5877 8266 +5877 9934 +5878 8102 +5878 9127 +5878 9006 +5878 6320 +5878 8082 +5878 8215 +5878 6938 +5878 6943 +5878 9919 +5878 7135 +5879 7267 +5879 5963 +5879 6136 +5879 9887 +5880 7104 +5880 9225 +5880 7178 +5880 9733 +5881 6784 +5881 8195 +5881 9233 +5881 7052 +5881 6547 +5881 6420 +5882 9776 +5882 5907 +5882 8286 +5883 6179 +5883 9161 +5883 6603 +5883 7438 +5883 9266 +5884 9862 +5884 9486 +5884 8243 +5884 6468 +5884 6348 +5885 7492 +5885 9158 +5885 8235 +5885 8333 +5885 9389 +5885 9887 +5886 6145 +5886 8868 +5886 7526 +5886 6791 +5886 6375 +5886 6257 +5886 7350 +5886 7098 +5886 8351 +5887 6950 +5887 7532 +5887 7506 +5887 6138 +5887 8731 +5888 9184 +5888 6210 +5888 9351 +5888 7309 +5888 7215 +5888 7893 +5888 9532 +5888 9400 +5888 9689 +5888 9615 +5888 6588 +5889 6011 +5889 9609 +5889 7179 +5889 5949 +5889 6965 +5889 6456 +5889 8058 +5891 9199 +5891 7966 +5891 5920 +5891 8246 +5891 8265 +5891 7758 +5891 9423 +5891 9170 +5891 6646 +5892 7730 +5892 8640 +5892 9410 +5892 8399 +5892 9952 +5892 8934 +5892 8551 +5892 6510 +5892 8689 +5892 7538 +5892 7932 +5893 8486 +5893 7718 +5893 7084 +5893 8144 +5893 7886 +5893 8956 +5893 7045 +5894 6112 +5894 8005 +5894 7208 +5894 7820 +5895 8677 +5895 6508 +5895 8173 +5895 9009 +5895 7263 +5896 6752 +5896 9147 +5896 8773 +5896 9344 +5896 6125 +5896 8207 +5896 6592 +5896 8888 +5896 9805 +5897 6259 +5897 9702 +5897 8136 +5897 9095 +5897 8146 +5897 9782 +5897 9175 +5897 8312 +5897 6939 +5897 6367 +5898 9157 +5898 9565 +5898 8949 +5899 5957 +5899 8908 +5899 8815 +5899 9138 +5899 9528 +5899 9465 +5899 6014 +5900 6454 +5900 6111 +5901 8087 +5901 9913 +5901 7631 +5901 9170 +5901 7380 +5901 7313 +5901 9639 +5901 8433 +5901 6645 +5901 6356 +5902 9256 +5902 9648 +5902 7827 +5902 8790 +5902 5944 +5902 8474 +5903 7442 +5903 7576 +5903 6176 +5903 8237 +5903 7369 +5903 6821 +5903 8299 +5903 8997 +5903 9979 +5904 9824 +5904 9335 +5904 7852 +5904 8285 +5904 8857 +5904 9302 +5904 6139 +5904 6716 +5904 6717 +5904 6879 +5905 8963 +5905 8324 +5905 7909 +5905 8598 +5905 8108 +5905 9642 +5905 6284 +5905 9423 +5905 6947 +5905 7640 +5905 7076 +5905 8586 +5906 7137 +5906 9793 +5906 8553 +5906 7023 +5906 7314 +5906 6803 +5906 6518 +5906 9385 +5907 9219 +5907 9879 +5907 6682 +5907 7198 +5907 9819 +5907 9640 +5907 7851 +5907 7219 +5907 6967 +5907 9027 +5907 7787 +5907 7661 +5908 6435 +5908 9542 +5908 7718 +5908 9908 +5908 7804 +5908 7199 +5909 8325 +5909 9740 +5909 9104 +5909 9499 +5909 9116 +5909 7325 +5909 5931 +5909 6062 +5909 7994 +5909 9915 +5909 9791 +5909 9164 +5909 7779 +5909 9321 +5909 7533 +5909 8558 +5909 7535 +5910 6336 +5910 8357 +5910 7205 +5910 9905 +5910 5970 +5910 6520 +5910 8896 +5910 7583 +5911 8160 +5911 6977 +5911 9259 +5911 6436 +5911 6696 +5911 6585 +5912 6080 +5912 7041 +5912 6245 +5912 6699 +5912 7761 +5912 9113 +5912 6463 +5913 8709 +5913 8550 +5913 7693 +5913 9317 +5913 9073 +5913 8823 +5913 7992 +5913 8601 +5913 6714 +5913 6645 +5914 8811 +5914 6663 +5914 9832 +5914 8087 +5914 6096 +5914 9524 +5914 9845 +5914 9334 +5915 9892 +5915 6250 +5915 8779 +5915 9742 +5915 6861 +5915 7602 +5915 9752 +5916 9998 +5916 7725 +5916 9390 +5916 6599 +5916 7398 +5916 8871 +5916 8559 +5916 6137 +5917 7361 +5917 9288 +5917 8366 +5917 6093 +5917 7504 +5917 7124 +5917 7126 +5917 9686 +5918 7946 +5918 6455 +5918 6201 +5918 7484 +5918 9025 +5918 6130 +5918 8447 +5919 8984 +5919 6050 +5919 6871 +5919 8673 +5919 6127 +5919 9468 +5920 8323 +5920 9302 +5920 8362 +5920 7655 +5920 6106 +5920 8370 +5920 7415 +5920 7068 +5921 6658 +5921 6156 +5921 6193 +5921 6214 +5921 7530 +5921 7155 +5921 8952 +5922 8644 +5922 6383 +5922 6079 +5923 8585 +5923 8888 +5923 7745 +5923 9041 +5923 7146 +5923 7416 +5923 9341 +5924 9753 +5924 6827 +5924 8622 +5924 9139 +5924 6328 +5924 8280 +5924 5982 +5925 7585 +5925 7844 +5925 9996 +5925 8757 +5925 6860 +5925 9975 +5925 8124 +5926 6368 +5926 7520 +5926 9379 +5926 6757 +5926 5931 +5926 5930 +5926 9355 +5926 7756 +5926 8209 +5926 6325 +5926 6137 +5926 7096 +5926 9035 +5926 5949 +5927 6022 +5927 9480 +5927 6417 +5927 9884 +5927 8231 +5927 7816 +5927 9147 +5927 9584 +5927 7927 +5927 6778 +5927 8061 +5928 9814 +5928 6857 +5928 8106 +5928 8939 +5928 9455 +5928 8696 +5928 9723 +5928 6622 +5929 8641 +5929 8715 +5929 7151 +5929 9234 +5929 8666 +5929 6621 +5930 6368 +5930 6631 +5930 7463 +5930 6632 +5930 6380 +5931 6024 +5931 6688 +5931 9002 +5931 6076 +5931 9409 +5931 9539 +5931 8261 +5931 9679 +5931 6884 +5931 7542 +5932 7433 +5932 7946 +5932 6681 +5932 9384 +5932 6068 +5932 9289 +5932 9686 +5932 8164 +5932 8293 +5932 7782 +5932 8955 +5933 6126 +5933 8332 +5933 6316 +5933 9680 +5933 9557 +5933 7606 +5933 7514 +5933 8571 +5933 8860 +5934 7087 +5934 8658 +5934 7151 +5934 9749 +5934 8027 +5934 6364 +5935 7554 +5935 5962 +5935 8082 +5935 9269 +5935 6395 +5935 5946 +5935 9950 +5936 8192 +5936 9477 +5936 8333 +5936 7055 +5936 7458 +5936 7721 +5936 9915 +5936 8765 +5936 6738 +5936 6610 +5937 6883 +5937 9860 +5937 8978 +5937 7662 +5937 6009 +5937 6746 +5938 8069 +5938 6535 +5938 8207 +5938 9136 +5938 9015 +5938 8653 +5938 8781 +5938 7002 +5938 8043 +5938 9326 +5938 9073 +5939 7618 +5939 8618 +5939 6434 +5939 8482 +5939 8047 +5939 9264 +5940 8977 +5940 6747 +5940 7844 +5940 8242 +5940 6845 +5940 6336 +5940 7887 +5940 8465 +5940 8684 +5940 7789 +5940 9712 +5940 9970 +5941 8722 +5941 6122 +5941 8622 +5941 7152 +5941 8338 +5941 7699 +5941 6709 +5941 9879 +5941 8979 +5941 6489 +5942 8108 +5942 7319 +5942 9885 +5942 9637 +5942 7468 +5942 8244 +5942 6199 +5942 7997 +5942 8898 +5942 9846 +5943 9736 +5943 7330 +5943 9403 +5943 7741 +5943 7386 +5943 6622 +5943 9448 +5943 6768 +5943 8189 +5944 7907 +5944 8421 +5944 8819 +5944 8109 +5944 7472 +5944 8746 +5945 9248 +5945 6244 +5945 8695 +5945 7162 +5945 5948 +5946 8324 +5946 6761 +5946 7436 +5946 8090 +5946 8314 +5946 7231 +5947 7089 +5947 9698 +5947 8338 +5947 7242 +5947 9282 +5947 9711 +5947 8121 +5947 9625 +5947 7289 +5947 7675 +5947 7978 +5947 9951 +5947 8569 +5948 9800 +5948 8312 +5948 9631 +5949 8225 +5949 7113 +5949 8970 +5949 8497 +5949 6931 +5949 8479 +5950 9896 +5950 6759 +5950 6236 +5950 6510 +5950 8952 +5950 6047 +5951 7329 +5951 8904 +5951 7370 +5951 9559 +5951 5999 +5951 9649 +5951 7178 +5951 6420 +5952 6200 +5952 8024 +5952 7646 +5952 6687 +5953 8007 +5953 9195 +5953 8658 +5953 7026 +5953 9505 +5953 9178 +5954 8928 +5954 9929 +5954 7787 +5954 7092 +5954 9705 +5955 9635 +5955 8583 +5955 6233 +5955 6339 +5955 8873 +5955 6011 +5956 8132 +5956 7241 +5956 8267 +5956 6828 +5956 6959 +5956 9936 +5956 8373 +5957 7816 +5957 7949 +5957 7698 +5957 6300 +5957 6175 +5957 6812 +5957 8491 +5957 9007 +5957 8501 +5957 7237 +5957 8049 +5957 8698 +5957 9598 +5957 9471 +5958 7048 +5958 7004 +5958 9165 +5958 6644 +5958 7727 +5958 7673 +5958 7631 +5958 6018 +5959 6496 +5959 9667 +5959 7812 +5959 6742 +5959 6803 +5959 6836 +5959 6870 +5959 9689 +5960 8577 +5960 7876 +5960 9874 +5960 8179 +5961 7827 +5961 6819 +5961 6620 +5961 7611 +5961 7118 +5961 7906 +5961 6387 +5961 6395 +5962 7950 +5962 7825 +5962 6419 +5962 8350 +5962 7228 +5962 7628 +5962 9311 +5962 7013 +5962 9322 +5962 7923 +5962 7676 +5962 9341 +5963 7168 +5963 8833 +5963 8325 +5963 9107 +5963 8614 +5963 9256 +5963 8882 +5963 8889 +5963 9918 +5963 6080 +5963 7648 +5963 8187 +5964 9221 +5964 8972 +5964 7492 +5964 6052 +5964 8229 +5964 6706 +5964 9011 +5964 7235 +5964 8260 +5964 9287 +5964 6605 +5964 6762 +5964 7019 +5964 6397 +5965 6753 +5965 7706 +5965 9608 +5965 9481 +5965 9612 +5965 8781 +5965 9390 +5965 8407 +5965 7098 +5965 7037 +5966 6806 +5966 7175 +5966 6155 +5966 9875 +5966 6944 +5966 8365 +5966 6969 +5966 9670 +5966 7138 +5966 6892 +5966 8687 +5967 7554 +5967 9476 +5967 9510 +5967 6704 +5967 8248 +5967 8995 +5967 7359 +5967 6253 +5968 7379 +5968 6506 +5968 6930 +5968 8397 +5968 9194 +5968 7220 +5968 8541 +5969 7108 +5969 7959 +5969 9625 +5969 6971 +5969 8220 +5969 7806 +5970 6946 +5970 9195 +5970 6886 +5970 8808 +5970 9834 +5970 9739 +5971 6114 +5971 6822 +5971 7851 +5971 7892 +5971 8122 +5971 7612 +5972 9537 +5972 7746 +5972 9323 +5972 6817 +5972 6661 +5972 9480 +5972 9660 +5972 7489 +5972 9933 +5972 7514 +5973 9457 +5973 8857 +5973 8443 +5974 7812 +5974 9350 +5974 9256 +5974 6493 +5974 8497 +5974 8543 +5974 9410 +5974 8029 +5974 7647 +5974 9576 +5974 6764 +5975 9921 +5975 7906 +5975 6791 +5975 6325 +5975 9390 +5975 7374 +5975 8970 +5975 8469 +5976 8066 +5976 7560 +5976 9968 +5976 9396 +5976 9782 +5976 9945 +5976 9689 +5976 9286 +5976 9725 +5977 7511 +5977 9059 +5977 7527 +5977 6249 +5977 6986 +5977 7851 +5977 6050 +5977 9225 +5977 7153 +5977 7250 +5977 6643 +5977 7994 +5977 7050 +5978 9221 +5978 6280 +5978 8844 +5978 6309 +5978 9282 +5978 7623 +5978 8779 +5978 8672 +5978 7779 +5978 9829 +5979 8228 +5979 8486 +5979 8516 +5979 9439 +5979 6369 +5979 9964 +5979 7663 +5980 8194 +5980 9347 +5980 6929 +5980 8752 +5980 9971 +5980 6040 +5980 9053 +5981 9828 +5981 7864 +5981 9284 +5981 8093 +5982 8843 +5982 8597 +5982 7202 +5982 6299 +5982 9288 +5982 9555 +5982 7152 +5982 7927 +5982 9449 +5983 7333 +5983 7145 +5983 6608 +5983 8671 +5983 9913 +5983 6015 +5984 6478 +5984 7760 +5984 8114 +5984 6483 +5984 6100 +5984 9078 +5984 9625 +5985 6550 +5985 9094 +5985 9383 +5985 6452 +5985 9726 +5985 8741 +5986 8077 +5986 6936 +5986 8347 +5986 8872 +5986 6061 +5986 9264 +5986 6209 +5986 9869 +5986 9315 +5986 6885 +5986 9256 +5986 9854 +5987 6272 +5987 6528 +5987 7848 +5987 7561 +5987 5998 +5987 8019 +5987 7543 +5987 9529 +5987 9915 +5988 6114 +5988 8130 +5988 8290 +5988 7534 +5988 9167 +5988 8914 +5988 9811 +5988 7540 +5988 6223 +5988 8090 +5989 7458 +5989 6691 +5989 7877 +5989 7302 +5989 8231 +5989 6969 +5989 9113 +5989 7837 +5990 9748 +5990 8988 +5990 6319 +5990 7353 +5990 6731 +5990 8270 +5990 8527 +5990 7025 +5991 6017 +5991 7484 +5991 7500 +5991 6776 +5991 6712 +5991 9791 +5992 9458 +5992 8214 +5992 6937 +5992 8602 +5992 9337 +5992 8093 +5992 6110 +5992 7455 +5993 6278 +5993 7833 +5993 9499 +5993 6045 +5993 6575 +5993 8778 +5993 9807 +5994 7793 +5994 6226 +5994 6747 +5994 9854 +5995 8841 +5995 7949 +5995 9070 +5995 9075 +5995 8919 +5995 7385 +5995 6474 +5996 6791 +5996 7438 +5996 6032 +5996 8480 +5996 9408 +5996 6869 +5996 8169 +5996 6518 +5996 6265 +5997 8192 +5997 6061 +5997 6019 +5997 6950 +5997 6599 +5997 9261 +5997 9713 +5997 7785 +5997 6691 +5998 6401 +5998 9111 +5998 7961 +5998 8368 +5998 7226 +5998 8125 +5998 9410 +5998 8133 +5998 7249 +5998 9703 +5998 8441 +5999 9035 +5999 6308 +5999 7851 +5999 9737 +5999 6155 +5999 7699 +5999 8323 +5999 7979 +5999 8475 +5999 6526 +6000 9357 +6000 8012 +6000 6696 +6000 6089 +6000 9434 +6001 9222 +6001 8979 +6001 6948 +6001 9534 +6001 9919 +6001 9715 +6001 7933 +6002 9787 +6002 8620 +6002 8399 +6002 7696 +6002 7034 +6002 7643 +6003 9638 +6003 8405 +6003 9119 +6004 6765 +6004 7442 +6004 7575 +6004 9920 +6004 7110 +6004 9424 +6004 8676 +6004 8701 +6005 7312 +6005 9473 +6005 7531 +6005 8719 +6005 6768 +6005 7858 +6005 6670 +6005 9879 +6005 6140 +6005 8890 +6006 6917 +6006 6413 +6006 9872 +6006 9617 +6006 9109 +6006 7452 +6006 8521 +6006 9822 +6006 9827 +6006 8426 +6006 8051 +6006 7927 +6006 6293 +6007 9953 +6007 6962 +6007 8861 +6007 8467 +6007 9754 +6007 8219 +6007 8957 +6007 8191 +6008 8097 +6008 6244 +6008 9958 +6008 6408 +6008 7804 +6008 6059 +6008 8718 +6008 6258 +6008 7859 +6008 8695 +6008 7609 +6008 7164 +6008 6109 +6008 6773 +6009 8601 +6009 9447 +6009 8649 +6009 9195 +6009 6675 +6009 9721 +6010 8234 +6010 8043 +6010 7189 +6010 8570 +6010 7562 +6011 7585 +6011 6916 +6011 6568 +6011 9163 +6011 7336 +6011 6235 +6012 6753 +6012 8515 +6012 7076 +6012 7207 +6012 6441 +6012 6455 +6012 6807 +6012 6193 +6012 6994 +6012 7926 +6012 9835 +6013 8455 +6013 7203 +6013 8998 +6013 8250 +6013 9796 +6013 8393 +6013 8659 +6013 7510 +6013 7204 +6013 9574 +6014 9230 +6014 8341 +6014 6809 +6014 6895 +6014 9888 +6014 9267 +6014 7608 +6014 8637 +6014 8248 +6014 8793 +6014 7271 +6015 7315 +6015 9383 +6015 7474 +6015 7354 +6015 7263 +6015 6720 +6015 7625 +6015 8784 +6015 9048 +6015 8299 +6015 6386 +6015 6527 +6015 9215 +6016 7760 +6016 7348 +6016 6231 +6016 6521 +6017 8073 +6017 9230 +6017 6918 +6017 8764 +6017 7229 +6017 7999 +6017 8931 +6017 8806 +6017 7537 +6017 6911 +6018 7843 +6018 7815 +6018 8360 +6018 7786 +6018 9911 +6018 6189 +6018 8956 +6019 9664 +6019 8196 +6019 8295 +6019 9611 +6019 8946 +6019 6023 +6019 6206 +6019 7588 +6019 7156 +6019 9566 +6020 6408 +6020 7470 +6020 7100 +6020 9025 +6020 7801 +6020 8162 +6020 9960 +6020 8825 +6020 8573 +6021 9827 +6021 6503 +6021 9352 +6021 9992 +6021 7892 +6021 9726 +6021 8956 +6021 9342 +6022 6528 +6022 9989 +6022 7274 +6022 8301 +6022 8462 +6022 6223 +6022 7496 +6022 9330 +6022 6738 +6022 8035 +6022 6877 +6023 7266 +6023 8662 +6023 8648 +6023 8060 +6023 6547 +6023 9593 +6023 9406 +6024 9550 +6024 7344 +6024 8818 +6024 7132 +6025 9216 +6025 9476 +6025 9107 +6025 6689 +6025 9244 +6025 8257 +6025 6726 +6025 8285 +6025 7396 +6025 6639 +6026 9795 +6026 8068 +6026 7013 +6026 6823 +6026 9770 +6026 7154 +6026 6035 +6026 7541 +6026 9913 +6026 7962 +6026 9765 +6027 9728 +6027 9172 +6027 7817 +6028 6312 +6028 9225 +6028 8335 +6028 9776 +6028 7673 +6029 8512 +6029 6053 +6029 8460 +6029 7276 +6029 8633 +6030 8452 +6030 8205 +6030 9008 +6030 9489 +6031 6991 +6031 6043 +6031 9756 +6031 9551 +6031 6270 +6031 7891 +6031 8601 +6032 6054 +6032 8625 +6032 9103 +6032 7089 +6032 6420 +6032 6587 +6032 8510 +6033 9859 +6033 8972 +6033 6574 +6033 7536 +6033 7576 +6033 6548 +6033 6708 +6034 6976 +6034 9060 +6034 6497 +6034 7345 +6034 7976 +6034 8227 +6034 6746 +6035 9103 +6035 7839 +6035 9645 +6035 9266 +6035 9157 +6035 9036 +6035 9423 +6035 8152 +6035 9436 +6035 8546 +6036 6454 +6036 6469 +6036 9350 +6036 7369 +6036 9302 +6036 6552 +6036 8858 +6036 6079 +6037 9420 +6037 8106 +6037 8814 +6037 9105 +6037 7699 +6037 7929 +6038 9605 +6038 7272 +6038 9364 +6039 6634 +6039 9869 +6039 9660 +6040 7459 +6040 6189 +6040 8773 +6040 9030 +6040 6217 +6040 7288 +6040 8101 +6040 9691 +6041 7525 +6041 8295 +6041 6828 +6041 8014 +6041 8189 +6041 8720 +6041 9883 +6041 7835 +6041 8958 +6042 8770 +6042 9351 +6042 8652 +6042 7309 +6042 6467 +6042 6900 +6042 9814 +6042 9560 +6042 8851 +6042 7109 +6043 8451 +6043 6539 +6043 7308 +6043 6307 +6043 8494 +6043 7606 +6043 8517 +6043 8021 +6043 8664 +6043 8676 +6044 9922 +6044 7053 +6044 7316 +6044 8184 +6044 9209 +6045 8704 +6045 6406 +6045 6924 +6045 9796 +6045 9759 +6045 6177 +6045 7621 +6045 6251 +6046 7558 +6046 8968 +6046 9482 +6046 9873 +6046 6713 +6047 6180 +6047 6949 +6047 8008 +6047 9164 +6047 9198 +6048 7566 +6048 8476 +6048 9142 +6048 7738 +6048 9932 +6048 8658 +6048 8678 +6048 6098 +6049 7652 +6049 7721 +6049 9901 +6049 7826 +6049 7516 +6049 6333 +6049 7422 +6050 9633 +6050 6438 +6050 6378 +6050 9229 +6050 7089 +6050 9794 +6050 9567 +6051 8716 +6051 6927 +6051 9780 +6051 7610 +6051 8527 +6051 7504 +6051 8154 +6051 6250 +6051 9197 +6051 9202 +6052 8396 +6052 7562 +6052 9198 +6052 6581 +6053 7178 +6053 7058 +6053 6955 +6053 7437 +6053 6106 +6053 7484 +6054 9376 +6054 6435 +6054 9894 +6054 7648 +6054 7653 +6054 6763 +6054 8813 +6054 7038 +6055 8101 +6055 6123 +6055 9570 +6055 8237 +6055 6489 +6055 9535 +6056 6944 +6056 8160 +6056 8199 +6056 9995 +6056 9603 +6056 9801 +6056 6103 +6056 8259 +6057 6758 +6057 8012 +6057 7346 +6057 7868 +6057 6181 +6058 7074 +6058 7845 +6058 8200 +6058 8112 +6058 6550 +6058 7447 +6058 7035 +6058 8829 +6059 8967 +6059 7347 +6059 6410 +6059 8397 +6059 8918 +6059 9317 +6059 8700 +6059 8318 +6060 7104 +6060 8514 +6060 8291 +6060 8584 +6060 9554 +6060 8002 +6060 6486 +6061 6422 +6061 9375 +6061 8361 +6061 7866 +6061 9569 +6061 6118 +6061 7270 +6061 8425 +6061 6382 +6061 9847 +6061 6521 +6061 9727 +6062 7056 +6062 6967 +6062 9917 +6062 7763 +6062 8719 +6062 8031 +6062 6766 +6062 7795 +6062 6650 +6062 6397 +6063 6791 +6063 9487 +6063 9109 +6063 7196 +6063 9259 +6063 8364 +6063 8621 +6063 9656 +6063 8993 +6063 7661 +6064 6113 +6064 7884 +6064 9642 +6064 8060 +6065 8582 +6065 7559 +6065 6408 +6065 9098 +6065 9871 +6065 6938 +6065 7585 +6065 7480 +6065 7610 +6065 6088 +6065 7783 +6065 8184 +6066 8449 +6066 6634 +6066 9618 +6066 8252 +6066 7262 +6066 6586 +6067 7652 +6067 9253 +6067 8254 +6067 7501 +6067 8761 +6068 9416 +6068 9647 +6068 7668 +6068 7084 +6068 7369 +6068 7419 +6068 6140 +6068 6270 +6069 8711 +6069 6413 +6069 8283 +6069 7751 +6069 9173 +6069 9179 +6069 8417 +6069 9570 +6069 9330 +6070 7201 +6070 7912 +6070 9703 +6070 8430 +6070 8174 +6071 7363 +6071 7857 +6071 8409 +6071 7289 +6071 9215 +6071 7964 +6071 9469 +6071 6878 +6071 9439 +6072 8928 +6072 9415 +6072 8976 +6072 8451 +6072 6291 +6072 7068 +6072 9789 +6073 8081 +6073 9883 +6073 9050 +6073 9903 +6073 9526 +6073 9025 +6073 8779 +6073 9814 +6073 7441 +6073 8937 +6073 9327 +6074 7136 +6074 9765 +6074 7527 +6074 8942 +6074 7709 +6075 6914 +6075 8337 +6075 8086 +6075 7907 +6075 6183 +6075 7086 +6075 7988 +6075 8538 +6075 9441 +6075 9699 +6075 8550 +6075 7142 +6075 6767 +6075 7285 +6076 9185 +6076 6722 +6076 7525 +6076 7889 +6076 9199 +6076 6865 +6076 6302 +6076 8121 +6076 9948 +6076 7093 +6077 8897 +6077 6467 +6077 6361 +6077 8178 +6077 9763 +6077 9398 +6077 6839 +6077 7485 +6078 7824 +6078 8387 +6078 6409 +6078 7978 +6078 9655 +6078 6903 +6078 6586 +6078 6986 +6079 8233 +6079 7927 +6079 7341 +6079 6935 +6079 9041 +6079 6206 +6079 6231 +6079 8155 +6079 6847 +6080 8846 +6080 7196 +6080 6193 +6080 7720 +6080 8860 +6080 6571 +6080 6195 +6080 8387 +6080 9398 +6080 7240 +6080 6356 +6080 6631 +6080 8146 +6081 8642 +6081 8778 +6081 8271 +6081 8273 +6081 9332 +6081 6738 +6081 9464 +6081 9695 +6082 9762 +6082 6148 +6082 7468 +6082 7650 +6082 9489 +6082 6612 +6082 8280 +6082 8922 +6082 8181 +6083 6563 +6083 9125 +6083 7495 +6083 7179 +6083 7763 +6083 9785 +6084 8455 +6084 8936 +6084 9804 +6084 7783 +6084 9106 +6084 8494 +6084 8110 +6084 9529 +6084 7006 +6085 9091 +6085 9363 +6085 6873 +6085 7836 +6085 6194 +6085 9932 +6085 7760 +6085 6742 +6085 6622 +6085 9192 +6086 7936 +6086 8463 +6086 8217 +6086 6304 +6086 8756 +6086 8376 +6086 6723 +6086 8267 +6086 7757 +6086 7892 +6087 6272 +6087 8384 +6087 8962 +6087 8619 +6087 7651 +6087 8296 +6088 7557 +6088 9869 +6088 7957 +6088 8086 +6088 7323 +6088 9249 +6088 6500 +6088 9574 +6088 8062 +6088 8311 +6088 6526 +6089 7504 +6089 9698 +6089 6405 +6089 9173 +6089 7973 +6089 8286 +6090 7298 +6090 9219 +6090 9606 +6090 9098 +6090 8716 +6090 7067 +6090 6686 +6090 7099 +6090 6876 +6090 7914 +6090 6765 +6090 9726 +6091 7340 +6091 6925 +6091 8627 +6091 9784 +6091 7097 +6091 8954 +6092 9440 +6092 7969 +6092 7522 +6092 6724 +6092 9030 +6092 8559 +6092 6314 +6092 8506 +6093 7072 +6093 7137 +6093 8580 +6093 7201 +6093 8136 +6093 7388 +6093 6188 +6093 9619 +6093 8984 +6094 8332 +6094 7566 +6094 9616 +6094 8223 +6094 6969 +6094 6781 +6094 9707 +6095 7808 +6095 6273 +6095 6443 +6095 7354 +6095 7368 +6095 8316 +6096 6849 +6096 7347 +6096 8236 +6096 7117 +6096 8272 +6096 7537 +6096 9820 +6097 6730 +6097 9024 +6097 9283 +6097 9162 +6097 8405 +6097 8052 +6097 6904 +6098 6976 +6098 8579 +6098 9120 +6098 8121 +6098 7006 +6099 9483 +6099 9124 +6099 9389 +6099 9913 +6099 9541 +6099 8401 +6099 9827 +6099 7407 +6099 6513 +6099 6776 +6099 7164 +6099 8957 +6099 9983 +6100 7576 +6100 7171 +6100 7494 +6100 8422 +6100 9896 +6100 9048 +6100 6888 +6100 7736 +6100 9983 +6101 9115 +6101 6735 +6101 9321 +6101 7148 +6101 7278 +6101 9077 +6101 6646 +6101 9599 +6102 6531 +6102 8878 +6102 8358 +6102 8456 +6102 6408 +6102 7694 +6103 8576 +6103 9755 +6103 6925 +6103 7918 +6103 8623 +6103 9011 +6103 6293 +6103 7383 +6103 8768 +6103 8351 +6104 8490 +6104 8637 +6104 8048 +6104 7731 +6104 9650 +6104 9655 +6105 7428 +6105 7391 +6105 7143 +6105 8559 +6105 6256 +6106 8887 +6106 6203 +6106 7328 +6106 6993 +6106 8790 +6106 9311 +6106 9076 +6107 9449 +6108 9126 +6108 9767 +6108 6572 +6108 9909 +6109 8042 +6109 9868 +6109 6660 +6109 7950 +6109 8605 +6110 9288 +6110 9135 +6110 9394 +6110 6147 +6110 6457 +6110 7824 +6110 7326 +6111 8514 +6111 8427 +6111 9284 +6111 9160 +6111 7603 +6111 6711 +6111 7806 +6112 9895 +6112 8649 +6112 8685 +6112 6803 +6112 9651 +6113 9603 +6113 6729 +6113 7799 +6113 7132 +6113 9949 +6114 7686 +6114 6577 +6114 9775 +6114 6833 +6114 9159 +6114 9424 +6114 6232 +6114 9314 +6115 8201 +6115 9869 +6115 9877 +6115 6317 +6115 6998 +6115 6368 +6115 8830 +6116 9347 +6116 7942 +6116 6186 +6116 6460 +6116 8768 +6116 8542 +6116 6512 +6117 7362 +6117 7205 +6117 8241 +6117 8531 +6117 7141 +6117 8473 +6118 6617 +6118 6379 +6118 8533 +6118 8183 +6118 6311 +6118 8821 +6118 9657 +6118 6777 +6118 8699 +6119 9472 +6119 8849 +6119 6300 +6119 7468 +6119 6457 +6119 7870 +6119 6219 +6119 6496 +6119 9831 +6119 7402 +6119 8574 +6120 7737 +6120 7671 +6120 7825 +6120 6483 +6120 8309 +6120 8055 +6120 8248 +6121 6712 +6121 9346 +6121 6640 +6121 7845 +6121 8819 +6121 6199 +6121 8538 +6121 8090 +6121 7999 +6122 9184 +6122 7831 +6122 7220 +6122 7383 +6123 6496 +6123 6305 +6123 9508 +6123 8613 +6123 8934 +6123 7594 +6123 9708 +6123 9796 +6123 6330 +6123 7932 +6124 9543 +6124 7508 +6124 6682 +6124 9279 +6124 7294 +6124 6239 +6125 9158 +6125 6504 +6125 8139 +6125 6447 +6125 9520 +6125 6741 +6125 9943 +6125 7195 +6125 7004 +6125 6847 +6126 8257 +6126 7912 +6126 7154 +6126 9618 +6126 8221 +6126 6878 +6126 9171 +6127 6659 +6127 9797 +6127 7725 +6127 7823 +6127 7824 +6127 9725 +6127 9917 +6128 7682 +6128 7945 +6128 7572 +6128 7832 +6128 8357 +6128 7224 +6128 6339 +6128 7626 +6128 8664 +6128 9822 +6128 9195 +6128 9917 +6128 8434 +6128 6135 +6128 8826 +6129 6918 +6129 6569 +6129 7334 +6129 7727 +6129 9008 +6129 6229 +6129 9692 +6129 9975 +6129 6655 +6130 7137 +6130 8898 +6130 7429 +6130 6856 +6130 7767 +6130 9503 +6131 7437 +6131 7149 +6131 7698 +6131 9876 +6131 7830 +6131 8215 +6131 8886 +6131 6585 +6131 9920 +6131 9925 +6131 8161 +6131 9681 +6131 7633 +6131 8300 +6131 9333 +6131 7935 +6132 7436 +6132 7570 +6132 6293 +6132 8729 +6132 6651 +6132 7836 +6133 9248 +6133 7939 +6133 6567 +6133 7788 +6133 9619 +6133 8309 +6134 9202 +6134 8011 +6134 9229 +6134 6640 +6134 6289 +6134 9362 +6134 8500 +6134 7604 +6134 7322 +6134 8410 +6134 7007 +6135 8205 +6135 9105 +6135 9250 +6135 7851 +6135 7611 +6136 8683 +6136 8914 +6136 7731 +6136 6302 +6136 8660 +6136 8479 +6137 7591 +6137 7726 +6137 6729 +6137 9162 +6137 9561 +6137 6506 +6137 6268 +6138 6849 +6138 7448 +6138 7091 +6138 6367 +6138 9161 +6138 6858 +6138 9431 +6138 9460 +6138 7418 +6138 7039 +6139 8064 +6139 6895 +6139 6812 +6139 6687 +6139 8752 +6139 6451 +6139 7511 +6140 9986 +6140 8708 +6140 9610 +6140 8080 +6140 9520 +6140 7493 +6140 9850 +6141 9928 +6141 9298 +6141 8432 +6141 8901 +6142 6437 +6142 9046 +6142 9071 +6142 6257 +6142 6996 +6142 7446 +6142 9359 +6142 9980 +6143 7393 +6143 8450 +6143 6978 +6143 9910 +6143 7292 +6143 8541 +6144 7554 +6144 7941 +6144 9354 +6144 9708 +6144 8258 +6144 6450 +6144 8599 +6145 9440 +6145 8302 +6145 6184 +6145 8146 +6145 7608 +6145 9796 +6145 7868 +6145 7935 +6146 8293 +6146 7306 +6146 8593 +6146 9684 +6146 8117 +6147 8201 +6147 6203 +6147 8636 +6147 7487 +6147 6372 +6147 7539 +6147 6775 +6147 6932 +6148 6369 +6148 9094 +6148 7047 +6148 7159 +6148 9550 +6149 9314 +6149 8761 +6149 7540 +6149 8756 +6149 7605 +6149 7045 +6150 9991 +6150 8081 +6150 6975 +6150 7635 +6150 9044 +6150 9358 +6150 6632 +6150 8042 +6150 6183 +6150 7153 +6151 6212 +6151 8461 +6151 6513 +6151 7912 +6151 7065 +6151 7324 +6152 7053 +6152 9747 +6152 9256 +6152 6833 +6152 7741 +6152 8770 +6152 8391 +6152 9934 +6152 9689 +6152 8668 +6152 7902 +6152 8799 +6152 6903 +6152 7290 +6153 8589 +6153 7096 +6153 6341 +6153 9426 +6153 6612 +6153 9432 +6153 8421 +6153 6759 +6153 6260 +6153 9428 +6154 6356 +6154 7508 +6154 7131 +6155 7435 +6155 6928 +6155 7226 +6155 9241 +6155 8698 +6155 7965 +6156 9649 +6156 6839 +6157 7943 +6157 8587 +6157 6799 +6157 6215 +6157 7687 +6157 8624 +6157 6878 +6157 8648 +6157 7992 +6157 7652 +6157 8173 +6157 7418 +6158 6595 +6158 7944 +6158 9609 +6158 8813 +6158 9618 +6158 9204 +6158 8543 +6159 6633 +6159 7563 +6160 9750 +6160 6172 +6160 7466 +6160 8748 +6160 9011 +6160 8383 +6160 8006 +6160 6477 +6160 9678 +6160 8286 +6160 9086 +6161 8340 +6161 8388 +6161 9960 +6161 6548 +6161 9397 +6162 7491 +6162 7076 +6162 8518 +6162 7751 +6162 6380 +6162 6670 +6162 9305 +6163 8706 +6163 6806 +6163 9378 +6163 6440 +6163 6346 +6163 7371 +6163 9424 +6163 6611 +6163 7526 +6163 9322 +6163 7405 +6164 7067 +6164 8509 +6164 7492 +6164 8152 +6164 7262 +6164 7667 +6165 9195 +6165 8074 +6165 8722 +6165 6174 +6165 7588 +6165 8512 +6165 8644 +6165 9669 +6165 7139 +6166 7107 +6166 8242 +6166 8374 +6166 9529 +6166 9917 +6166 9549 +6166 6606 +6166 7140 +6166 9319 +6166 7149 +6166 7164 +6167 8196 +6167 9523 +6167 8665 +6167 6875 +6167 7137 +6167 6370 +6167 7141 +6167 9334 +6167 6268 +6167 7037 +6168 9761 +6168 7587 +6168 9633 +6168 7996 +6168 8304 +6168 7697 +6168 7066 +6168 6877 +6169 8840 +6169 6807 +6169 6689 +6169 9658 +6169 9077 +6169 8899 +6169 8815 +6169 7285 +6170 7769 +6170 8233 +6170 9486 +6170 6515 +6170 8537 +6170 9743 +6170 7789 +6171 9602 +6171 8199 +6171 7085 +6171 9395 +6171 9812 +6171 9499 +6172 7296 +6172 8448 +6172 8619 +6172 9649 +6172 7859 +6172 7110 +6172 8651 +6172 8922 +6172 6695 +6172 6765 +6172 8701 +6173 8738 +6173 8611 +6173 9297 +6173 8173 +6173 8752 +6173 9971 +6173 7189 +6173 9048 +6173 7707 +6174 6626 +6174 6849 +6174 9610 +6174 9616 +6174 8671 +6174 9943 +6175 6432 +6175 7919 +6175 8817 +6175 6809 +6175 6479 +6176 9233 +6176 7456 +6176 7201 +6176 9133 +6176 8116 +6176 9786 +6176 9408 +6176 9711 +6177 8307 +6177 9875 +6177 7543 +6178 9696 +6178 7684 +6178 7621 +6178 7883 +6178 7598 +6179 8076 +6179 7959 +6179 6585 +6179 9290 +6179 7884 +6179 9723 +6179 7526 +6179 6886 +6179 7018 +6180 9595 +6180 9223 +6180 9544 +6180 6663 +6180 7982 +6180 8084 +6180 9210 +6180 8687 +6180 9982 +6181 8098 +6181 9277 +6181 7598 +6181 6671 +6181 8946 +6181 9331 +6181 9498 +6182 8550 +6182 7080 +6182 6343 +6182 6543 +6182 7992 +6183 7904 +6183 7879 +6183 6620 +6183 7726 +6183 9304 +6183 6873 +6183 8700 +6183 9337 +6184 7586 +6184 8327 +6184 8075 +6184 6573 +6184 9785 +6184 9885 +6185 9121 +6185 9826 +6185 8806 +6185 7048 +6185 9098 +6185 9933 +6185 8437 +6185 6744 +6185 9320 +6185 6933 +6186 8763 +6186 8923 +6186 8557 +6186 6995 +6187 8357 +6187 6588 +6187 7085 +6187 7118 +6187 8082 +6187 8174 +6187 9230 +6187 6879 +6188 6311 +6188 9321 +6188 7178 +6188 6668 +6188 6270 +6188 7246 +6188 8053 +6188 7992 +6188 8885 +6189 8914 +6189 9730 +6189 7575 +6189 7375 +6189 9783 +6189 8349 +6189 7166 +6190 7460 +6190 7623 +6190 6481 +6190 9729 +6190 7907 +6190 8340 +6190 6276 +6190 7610 +6190 6653 +6191 6789 +6191 8678 +6191 8777 +6191 8515 +6191 9424 +6191 7922 +6191 6934 +6192 6583 +6192 6661 +6192 7594 +6192 8822 +6192 9776 +6192 8406 +6192 8222 +6193 9378 +6193 9324 +6193 7714 +6193 9230 +6193 6929 +6193 6644 +6193 9757 +6193 8030 +6194 8999 +6194 8631 +6194 8379 +6194 8511 +6194 8759 +6194 7134 +6194 6501 +6194 9312 +6194 6509 +6194 7929 +6195 8743 +6195 6381 +6195 6363 +6196 6349 +6196 7373 +6196 6769 +6196 6889 +6196 9613 +6196 7772 +6196 7764 +6196 9593 +6197 6496 +6197 6448 +6197 7338 +6197 9037 +6197 6416 +6197 6334 +6197 7549 +6197 7675 +6198 8487 +6198 8689 +6198 8782 +6198 6903 +6198 9854 +6199 8257 +6199 7701 +6199 9116 +6199 8129 +6199 8929 +6200 6786 +6200 9379 +6200 8785 +6200 9963 +6200 9174 +6200 6507 +6201 9223 +6201 6807 +6201 7690 +6201 8006 +6201 8790 +6201 8938 +6201 7277 +6201 7666 +6202 9904 +6202 8515 +6202 9921 +6202 8264 +6202 9288 +6202 8601 +6202 9530 +6203 6656 +6203 8617 +6203 6571 +6203 8266 +6203 7367 +6203 7119 +6203 7390 +6203 7267 +6203 8317 +6203 8318 +6204 6945 +6204 9890 +6204 7941 +6204 9099 +6204 9644 +6204 6360 +6204 7484 +6204 6268 +6204 7422 +6205 9486 +6205 9361 +6205 7187 +6205 8857 +6205 6821 +6205 9445 +6206 6721 +6206 9411 +6206 7687 +6206 8905 +6206 7507 +6206 7758 +6206 6961 +6206 7098 +6206 9564 +6206 6909 +6206 6527 +6207 9441 +6207 8771 +6207 6273 +6207 7240 +6207 9084 +6207 6478 +6207 9901 +6207 7246 +6207 9421 +6207 6563 +6207 7988 +6207 7445 +6207 9398 +6207 7595 +6208 6720 +6208 9185 +6208 7485 +6208 9585 +6208 6773 +6208 7931 +6208 6398 +6209 7192 +6209 8731 +6209 7328 +6209 9920 +6209 7109 +6209 9932 +6209 7641 +6210 9363 +6210 8985 +6210 7460 +6210 6438 +6210 7475 +6210 8253 +6210 6607 +6210 9705 +6210 6508 +6210 6333 +6210 8059 +6211 7749 +6211 9959 +6211 8682 +6211 8616 +6211 8632 +6212 8757 +6212 7393 +6212 9922 +6212 7651 +6212 9622 +6212 7214 +6212 8144 +6212 7246 +6212 7295 +6213 9474 +6213 6533 +6213 9929 +6213 6990 +6213 8367 +6213 6965 +6213 8248 +6213 8260 +6213 6671 +6213 8604 +6213 9342 +6214 7618 +6214 8838 +6214 6919 +6214 8819 +6214 9225 +6214 6482 +6214 8151 +6214 7391 +6215 7937 +6215 6788 +6215 9114 +6215 6473 +6215 7755 +6215 8940 +6216 8132 +6216 7413 +6216 8630 +6216 7608 +6216 8431 +6216 8285 +6216 7582 +6217 6913 +6217 7314 +6217 6695 +6217 6383 +6217 8652 +6217 8520 +6217 9173 +6217 8318 +6218 8896 +6218 8966 +6218 7624 +6218 7819 +6218 9846 +6218 6555 +6218 7967 +6219 7571 +6219 8600 +6219 9394 +6219 9039 +6219 7129 +6219 6503 +6219 8057 +6219 7743 +6220 8033 +6220 8898 +6220 9547 +6220 9030 +6220 8459 +6220 7505 +6220 9651 +6220 9976 +6221 7177 +6221 8654 +6221 9551 +6221 6711 +6221 8507 +6222 9736 +6222 7337 +6222 8471 +6222 9837 +6222 7183 +6222 8968 +6222 6516 +6222 8407 +6222 7961 +6222 9850 +6222 9307 +6222 7903 +6223 6545 +6223 6682 +6223 6567 +6223 7342 +6223 9904 +6223 7758 +6223 8914 +6223 6615 +6223 8162 +6223 9833 +6223 6513 +6223 9084 +6224 9956 +6224 8232 +6224 8521 +6224 8415 +6224 9501 +6224 8223 +6225 6408 +6225 8108 +6225 8778 +6225 9696 +6225 8551 +6226 7819 +6226 6924 +6226 8853 +6226 8855 +6226 7728 +6226 6328 +6226 9921 +6226 9926 +6226 9944 +6226 8308 +6227 8352 +6227 6404 +6227 7134 +6227 8793 +6227 9500 +6228 7179 +6228 9845 +6228 6745 +6228 8218 +6228 6980 +6229 6415 +6229 7570 +6229 9512 +6229 6955 +6229 9005 +6229 9903 +6229 6580 +6229 9461 +6229 8270 +6229 7651 +6229 7925 +6229 9850 +6229 8191 +6230 9867 +6230 9221 +6230 8939 +6230 7218 +6230 7186 +6230 9782 +6230 6601 +6230 7000 +6230 6942 +6231 8932 +6231 9605 +6231 6507 +6231 8943 +6231 7222 +6231 8252 +6232 6403 +6232 9765 +6232 7506 +6232 8046 +6232 7249 +6232 6452 +6232 7573 +6232 8023 +6233 8578 +6233 9478 +6233 7339 +6234 9787 +6234 6259 +6234 9380 +6234 8263 +6234 7816 +6234 6922 +6234 8880 +6234 6747 +6234 7669 +6235 9734 +6235 7639 +6235 8616 +6235 8489 +6235 8883 +6235 9908 +6235 6347 +6235 7895 +6235 7652 +6235 7295 +6236 8336 +6236 6813 +6236 6942 +6236 7469 +6236 9394 +6236 8115 +6236 6457 +6236 6648 +6237 7685 +6237 6669 +6237 6417 +6237 6320 +6237 9796 +6237 7136 +6238 8732 +6238 8071 +6238 6700 +6238 8686 +6238 7281 +6238 8363 +6238 9175 +6238 6587 +6238 7146 +6238 6302 +6238 6847 +6239 7847 +6239 9720 +6239 7608 +6239 6297 +6240 8033 +6240 6563 +6240 7800 +6240 6476 +6240 8859 +6240 7420 +6241 9185 +6241 6843 +6241 7783 +6241 6667 +6241 8590 +6241 8370 +6241 9338 +6242 9972 +6242 6396 +6243 6920 +6243 9482 +6243 6451 +6244 9884 +6244 8394 +6244 8565 +6244 9201 +6244 9973 +6244 9978 +6244 7195 +6244 8511 +6245 8710 +6245 6670 +6245 9756 +6245 9636 +6245 7277 +6245 8438 +6245 7031 +6246 9187 +6246 7524 +6246 7943 +6246 7785 +6246 8690 +6246 8933 +6246 9694 +6247 9174 +6247 9610 +6247 9964 +6247 8046 +6247 9462 +6247 7319 +6247 6872 +6248 9183 +6248 7335 +6248 6965 +6248 9271 +6249 9216 +6249 7609 +6249 6329 +6249 8793 +6249 9980 +6249 8880 +6249 7778 +6250 7057 +6250 9759 +6250 8756 +6250 8128 +6250 8388 +6250 8464 +6250 9186 +6250 8559 +6250 8180 +6250 9592 +6250 6393 +6251 7618 +6251 9429 +6251 6406 +6251 8747 +6251 7027 +6251 9652 +6251 8277 +6251 8025 +6252 8326 +6252 8331 +6252 6548 +6252 7831 +6252 8613 +6252 7361 +6252 9794 +6252 8008 +6252 8169 +6252 9194 +6253 6753 +6253 9069 +6253 6736 +6253 7348 +6253 6900 +6253 9014 +6253 8589 +6254 8194 +6254 6339 +6254 9262 +6254 7862 +6254 8529 +6254 7664 +6254 9716 +6255 7072 +6255 7425 +6255 7169 +6255 8325 +6255 7560 +6255 9605 +6255 7743 +6256 7418 +6257 7042 +6257 8345 +6257 9758 +6257 8356 +6257 9652 +6257 6456 +6257 6593 +6257 7109 +6257 7152 +6257 6386 +6257 8443 +6258 9313 +6258 7076 +6258 9446 +6258 7569 +6258 7319 +6259 9345 +6259 8748 +6259 9235 +6259 6384 +6259 7592 +6259 9130 +6259 9775 +6259 9533 +6259 9278 +6259 7257 +6259 7897 +6259 9584 +6260 8780 +6260 8009 +6260 9516 +6260 8173 +6260 8622 +6260 7247 +6260 6651 +6261 7235 +6261 8872 +6261 8140 +6261 8820 +6261 7737 +6261 8276 +6261 9733 +6262 8291 +6262 6981 +6262 7526 +6262 7848 +6262 6694 +6262 9710 +6262 7581 +6262 9910 +6262 9050 +6262 8347 +6262 9277 +6262 7263 +6263 9500 +6263 8867 +6263 8262 +6263 7120 +6263 7398 +6263 9981 +6264 7265 +6264 9891 +6264 7155 +6264 8661 +6265 7329 +6265 7362 +6265 8140 +6265 9446 +6265 8362 +6265 8756 +6265 9910 +6265 8472 +6266 7760 +6266 9790 +6267 7173 +6267 7639 +6267 7180 +6267 8463 +6267 7825 +6267 6418 +6267 6810 +6267 8098 +6267 8893 +6267 6733 +6267 9296 +6267 7386 +6267 6877 +6267 7648 +6267 9191 +6267 7019 +6267 9465 +6268 9496 +6268 7719 +6268 7088 +6268 9141 +6268 8003 +6268 8526 +6268 9296 +6268 9830 +6269 9888 +6269 8451 +6269 7267 +6269 9511 +6269 7976 +6269 7694 +6269 7408 +6269 8951 +6270 7691 +6270 8206 +6270 6420 +6270 7322 +6270 8483 +6270 7246 +6270 6520 +6271 8545 +6271 9162 +6271 6481 +6271 7957 +6271 8630 +6271 7481 +6271 6425 +6272 8069 +6272 9474 +6272 6312 +6272 9913 +6272 8121 +6273 9589 +6273 7432 +6273 8498 +6273 7540 +6273 8373 +6273 6424 +6273 8223 +6274 7552 +6274 8649 +6274 9707 +6274 9395 +6274 9174 +6274 9723 +6274 7108 +6275 8328 +6275 6984 +6275 9019 +6275 7198 +6276 9348 +6276 7839 +6276 8764 +6276 8804 +6276 7656 +6276 9964 +6276 9071 +6276 7161 +6277 9702 +6277 8691 +6277 9684 +6277 9687 +6277 7871 +6277 9885 +6277 6623 +6278 9771 +6278 6967 +6278 7901 +6279 9418 +6279 7019 +6279 9937 +6280 9094 +6280 8588 +6280 9515 +6280 8204 +6280 6671 +6280 7313 +6280 8086 +6280 7736 +6280 7725 +6281 7360 +6281 9729 +6281 7368 +6281 8636 +6281 7495 +6281 9052 +6282 7779 +6282 8325 +6282 9278 +6282 8395 +6282 8723 +6282 7259 +6282 9790 +6283 6293 +6283 6554 +6283 6558 +6283 7457 +6283 7508 +6283 7144 +6283 9066 +6284 6661 +6284 8711 +6284 8719 +6284 6703 +6284 9270 +6284 7863 +6284 9026 +6284 7370 +6284 9953 +6284 7267 +6284 7530 +6284 8319 +6285 8326 +6285 6633 +6285 6637 +6285 9192 +6285 7506 +6285 6377 +6285 7352 +6286 7328 +6286 9825 +6286 9195 +6286 9228 +6286 8431 +6286 8383 +6287 8706 +6287 9742 +6287 6672 +6287 7598 +6287 9248 +6287 9645 +6287 8248 +6287 6338 +6287 8776 +6287 7507 +6287 8149 +6287 6870 +6287 9057 +6287 9190 +6287 9711 +6287 9597 +6288 7590 +6288 8491 +6288 8620 +6288 7213 +6288 7857 +6288 9652 +6288 7480 +6288 8034 +6288 8805 +6288 7161 +6289 7813 +6289 9245 +6289 6564 +6289 9923 +6289 8517 +6289 8264 +6289 9035 +6289 8548 +6289 9331 +6289 9082 +6290 9642 +6290 8270 +6290 8250 +6290 8298 +6290 9822 +6291 8456 +6291 9353 +6291 6794 +6291 7219 +6291 7242 +6291 7134 +6292 9952 +6292 6889 +6292 9834 +6292 8461 +6292 6831 +6292 6544 +6292 9919 +6293 8705 +6293 9987 +6293 9772 +6293 6318 +6293 8375 +6293 7156 +6293 9545 +6293 8923 +6293 9195 +6293 9843 +6293 9847 +6294 7203 +6294 6916 +6294 9893 +6294 7249 +6294 9195 +6294 8302 +6294 7415 +6294 9650 +6295 7975 +6295 8269 +6295 8274 +6295 8054 +6295 9215 +6295 9534 +6295 7839 +6296 9826 +6296 9889 +6296 8136 +6296 9834 +6296 9838 +6296 9552 +6296 9775 +6297 8663 +6297 6552 +6297 9245 +6297 7844 +6297 9400 +6297 7761 +6297 9697 +6297 7793 +6297 7930 +6298 9475 +6298 6924 +6298 8744 +6298 9786 +6298 6357 +6298 8918 +6299 7169 +6299 7467 +6299 9773 +6299 7293 +6299 6689 +6299 8122 +6299 8636 +6299 9914 +6300 8967 +6300 8870 +6300 9938 +6300 8659 +6300 7017 +6300 7542 +6300 9080 +6301 9984 +6301 9602 +6301 7812 +6301 7962 +6301 7790 +6301 8592 +6301 7926 +6301 6328 +6301 8540 +6301 9405 +6302 8099 +6302 7588 +6302 6577 +6302 7862 +6302 7482 +6302 8763 +6303 7488 +6303 7972 +6303 6505 +6303 8427 +6303 7572 +6303 6398 +6303 8598 +6303 7641 +6303 9142 +6303 8442 +6304 9312 +6304 8356 +6304 8168 +6304 7245 +6304 9940 +6304 6404 +6305 9494 +6305 6684 +6305 9414 +6305 9897 +6305 9651 +6305 6584 +6305 7613 +6305 8385 +6305 6741 +6305 7539 +6306 6405 +6306 7207 +6306 6961 +6306 7163 +6306 8441 +6306 7960 +6306 6366 +6307 7745 +6307 8550 +6307 6433 +6307 9138 +6307 9619 +6307 9846 +6307 6744 +6307 8540 +6308 9632 +6308 8292 +6308 9906 +6308 9939 +6308 7183 +6309 7464 +6309 9391 +6309 7251 +6309 8502 +6309 9687 +6309 9246 +6310 8258 +6310 6787 +6310 9589 +6310 6709 +6310 6633 +6310 9464 +6310 8091 +6311 8841 +6311 7959 +6311 8589 +6311 6547 +6311 6678 +6311 9967 +6311 9886 +6311 6592 +6311 9162 +6311 9327 +6312 6656 +6312 6406 +6312 7193 +6312 8283 +6312 8766 +6312 6597 +6313 6821 +6313 9959 +6313 9645 +6313 6350 +6313 7183 +6313 8508 +6313 9020 +6313 9758 +6314 9728 +6314 6986 +6314 6836 +6314 8863 +6315 7431 +6315 6601 +6315 6986 +6315 7373 +6315 7285 +6315 6590 +6315 7224 +6315 6602 +6316 6826 +6316 8663 +6316 7543 +6317 7302 +6317 7692 +6317 7853 +6317 8469 +6317 8473 +6317 9722 +6317 6885 +6318 7496 +6318 7758 +6318 8469 +6318 8759 +6318 8218 +6318 7166 +6319 9828 +6319 9608 +6319 6538 +6319 8846 +6319 8560 +6319 8371 +6319 9741 +6319 6839 +6319 8740 +6319 8943 +6320 9862 +6320 9297 +6320 6347 +6320 8986 +6320 8799 +6320 6524 +6321 6754 +6321 8490 +6321 8302 +6321 7311 +6321 8881 +6321 8438 +6321 9463 +6322 8129 +6322 8675 +6322 7013 +6322 8850 +6322 6388 +6322 9370 +6322 8125 +6322 8862 +6322 8383 +6323 8992 +6323 7328 +6323 7528 +6324 6820 +6324 6641 +6324 6507 +6324 6351 +6324 8881 +6324 8703 +6324 9564 +6324 9247 +6325 8711 +6325 6922 +6325 7564 +6325 6819 +6325 6565 +6325 9170 +6325 6645 +6325 8767 +6326 9128 +6326 6571 +6326 8605 +6326 8228 +6326 8219 +6326 9213 +6327 8674 +6327 7875 +6327 9921 +6327 7789 +6327 7995 +6327 9692 +6327 8671 +6328 7705 +6328 8099 +6328 7848 +6328 9283 +6328 7522 +6328 9768 +6328 6518 +6328 7929 +6329 6753 +6329 9230 +6329 7281 +6329 7484 +6330 7911 +6330 7146 +6330 8995 +6330 9272 +6330 7482 +6331 9953 +6331 7504 +6331 7634 +6331 7133 +6331 9727 +6332 8577 +6332 8222 +6332 9775 +6332 7350 +6332 9783 +6332 9529 +6332 9676 +6332 9844 +6332 7126 +6332 7912 +6332 9586 +6332 6648 +6333 9955 +6333 7205 +6333 9703 +6333 8201 +6333 7274 +6333 9937 +6333 9396 +6333 7674 +6333 9413 +6334 7670 +6334 8367 +6334 9392 +6334 9842 +6335 9536 +6335 9489 +6335 6844 +6335 8542 +6336 9872 +6336 7829 +6336 9367 +6336 7516 +6336 9389 +6336 9781 +6336 6483 +6336 8155 +6336 7004 +6336 8929 +6336 9714 +6337 7077 +6337 7145 +6337 7950 +6337 7549 +6338 8389 +6338 6722 +6338 9732 +6338 9670 +6338 6537 +6338 9645 +6338 6661 +6338 8909 +6338 6448 +6338 7889 +6338 6837 +6338 6806 +6338 7804 +6339 8000 +6339 8775 +6339 7665 +6339 6898 +6339 7891 +6339 9742 +6339 8639 +6339 6622 +6340 8214 +6340 9881 +6340 6823 +6340 9006 +6340 9409 +6340 7111 +6340 9160 +6340 7113 +6340 6864 +6340 6651 +6340 8316 +6341 9424 +6341 7842 +6341 6631 +6341 6633 +6341 8430 +6341 8244 +6341 6686 +6342 9899 +6342 8764 +6342 7145 +6342 7064 +6342 9930 +6343 9346 +6343 9733 +6343 8076 +6343 6801 +6343 9539 +6343 9419 +6343 9036 +6343 7569 +6343 9967 +6343 9205 +6344 6625 +6344 7419 +6344 7893 +6344 7414 +6344 9015 +6345 8386 +6345 7272 +6345 8620 +6345 8364 +6345 7533 +6345 6931 +6346 8512 +6346 7264 +6346 8843 +6346 6948 +6346 9064 +6346 7598 +6346 9288 +6346 8479 +6347 8739 +6347 6908 +6347 6891 +6347 8648 +6347 7523 +6347 6626 +6347 7843 +6347 9307 +6347 9150 +6348 7206 +6348 9618 +6348 7779 +6348 6680 +6349 6950 +6349 9224 +6349 6825 +6349 9868 +6349 9619 +6349 9551 +6349 8251 +6350 9518 +6350 9764 +6350 6522 +6350 7006 +6351 8802 +6351 9063 +6351 8424 +6351 7498 +6351 9581 +6351 8488 +6351 9909 +6351 9816 +6351 6408 +6352 6368 +6352 8897 +6352 9670 +6352 9742 +6352 6928 +6352 7422 +6353 9093 +6353 8790 +6353 9101 +6353 8472 +6353 6589 +6353 6941 +6354 9410 +6354 8870 +6354 6658 +6354 9615 +6354 6386 +6354 7956 +6354 9691 +6354 6978 +6354 8766 +6355 7298 +6355 6537 +6355 7691 +6355 6541 +6355 7182 +6355 7845 +6355 8894 +6355 6729 +6355 8913 +6355 9301 +6355 8793 +6356 9114 +6356 6456 +6356 6861 +6356 6733 +6356 9684 +6356 8684 +6356 8191 +6357 9267 +6357 7704 +6358 9601 +6358 7067 +6358 6468 +6358 9165 +6358 9455 +6358 9941 +6358 8022 +6358 8777 +6358 9404 +6358 7902 +6359 7059 +6359 7335 +6359 9232 +6359 9240 +6359 7859 +6359 8500 +6359 9272 +6359 9146 +6359 9116 +6360 7046 +6360 9993 +6360 6838 +6360 8529 +6360 9187 +6360 7014 +6360 9068 +6360 9333 +6360 7671 +6361 9230 +6361 6821 +6361 9262 +6361 8369 +6361 6973 +6361 9150 +6361 9279 +6361 6722 +6361 6724 +6361 7776 +6361 9457 +6362 8974 +6362 9311 +6362 9405 +6362 7654 +6362 9455 +6363 9160 +6363 6761 +6363 8920 +6363 9403 +6363 8958 +6364 7840 +6364 9253 +6364 8864 +6364 8923 +6364 8697 +6365 8707 +6365 8457 +6365 8081 +6365 8480 +6365 8098 +6365 9253 +6365 8490 +6365 9787 +6365 8903 +6365 9949 +6365 7653 +6365 8830 +6366 6658 +6366 8709 +6366 9448 +6366 9340 +6366 9584 +6367 6892 +6367 9226 +6367 9373 +6367 7002 +6367 9843 +6367 6581 +6368 6824 +6368 6918 +6368 7160 +6369 6400 +6369 7454 +6369 6589 +6369 9969 +6370 9988 +6370 9488 +6370 7825 +6370 9751 +6370 9990 +6370 6568 +6370 7605 +6370 8520 +6371 6657 +6371 7285 +6371 9832 +6371 8138 +6371 6412 +6371 8111 +6371 8304 +6371 9175 +6371 8991 +6371 7580 +6371 8069 +6372 7042 +6372 7721 +6372 9278 +6372 7022 +6372 7409 +6372 8054 +6373 8709 +6373 7629 +6374 8635 +6374 7740 +6374 9303 +6374 9338 +6374 8936 +6374 6890 +6374 6384 +6375 7626 +6375 7890 +6375 6884 +6375 7672 +6376 6660 +6376 9896 +6376 6905 +6376 8782 +6376 6546 +6376 8759 +6376 8764 +6377 9352 +6377 9587 +6377 7247 +6377 7614 +6378 6913 +6378 9507 +6378 7372 +6378 9565 +6378 8918 +6378 7903 +6378 9950 +6379 6917 +6379 8454 +6379 9101 +6379 9108 +6379 8995 +6379 9709 +6380 7469 +6380 7869 +6380 6741 +6380 9051 +6380 6878 +6381 6388 +6381 6457 +6382 6656 +6382 6549 +6382 7702 +6382 7974 +6382 8362 +6382 8620 +6382 7491 +6382 8403 +6382 6841 +6382 7142 +6382 6781 +6382 8958 +6382 8959 +6383 6984 +6383 8605 +6383 8547 +6383 8053 +6383 6873 +6383 8452 +6383 9435 +6384 8132 +6384 7114 +6384 9401 +6384 7964 +6384 8869 +6385 6925 +6385 6680 +6385 7097 +6385 7640 +6385 8932 +6385 7014 +6385 6638 +6385 8953 +6386 8195 +6386 8641 +6386 6923 +6386 8998 +6386 8362 +6386 8907 +6386 9703 +6387 9448 +6387 6477 +6387 7965 +6387 9200 +6388 8832 +6388 8321 +6388 9608 +6388 7704 +6388 9532 +6388 9283 +6388 9288 +6388 7391 +6388 8843 +6389 8163 +6389 8060 +6389 7275 +6389 7662 +6389 9104 +6389 9746 +6390 6891 +6390 7787 +6390 8219 +6390 7712 +6390 9889 +6390 7618 +6390 6669 +6390 7123 +6390 9941 +6390 7266 +6390 8048 +6391 8738 +6391 6772 +6391 8981 +6392 8582 +6392 7334 +6392 9271 +6392 8024 +6393 8613 +6394 7139 +6394 7204 +6394 6474 +6394 9612 +6394 7446 +6394 7353 +6394 7198 +6395 6476 +6395 7726 +6395 8350 +6396 7160 +6396 8906 +6396 9906 +6396 6623 +6396 8949 +6396 9654 +6396 6552 +6396 6970 +6397 8458 +6397 8464 +6397 9499 +6397 9676 +6397 9189 +6397 8556 +6397 8822 +6397 9337 +6397 9084 +6398 7234 +6398 9480 +6398 9399 +6398 6931 +6398 6554 +6399 8608 +6399 9417 +6399 8876 +6399 9732 +6399 7003 +6400 8977 +6400 7047 +6400 9838 +6400 7121 +6400 8697 +6400 7707 +6401 9665 +6401 8578 +6401 8566 +6401 7641 +6401 9302 +6402 9440 +6402 6854 +6402 9479 +6402 6634 +6402 9999 +6402 6609 +6402 9187 +6402 8024 +6402 6937 +6402 6750 +6403 8417 +6403 7939 +6403 9223 +6403 9404 +6403 8310 +6403 8954 +6403 7195 +6403 9535 +6404 9728 +6404 8027 +6404 9611 +6404 9932 +6404 7150 +6404 7958 +6404 6425 +6404 7391 +6404 7292 +6404 8895 +6405 9350 +6405 8720 +6405 8977 +6405 9719 +6405 9017 +6405 7039 +6406 8713 +6406 9477 +6406 7566 +6406 9936 +6406 8184 +6406 7465 +6407 8835 +6407 8741 +6407 9318 +6407 9705 +6407 6707 +6407 9853 +6408 6731 +6408 8607 +6408 9060 +6409 7273 +6409 9878 +6410 8579 +6410 9363 +6410 8229 +6410 7155 +6411 8007 +6411 9553 +6411 9845 +6411 8918 +6411 8477 +6411 8789 +6412 8673 +6412 7652 +6412 9869 +6412 9650 +6412 7830 +6412 8920 +6413 9473 +6413 9872 +6413 8453 +6413 8492 +6413 7089 +6413 7872 +6413 6855 +6413 9679 +6413 9557 +6413 9827 +6413 8551 +6413 9202 +6413 8563 +6413 7999 +6414 9985 +6414 8866 +6414 7813 +6414 8265 +6414 8504 +6415 9058 +6415 8486 +6415 8489 +6415 9213 +6415 9404 +6415 7677 +6416 8523 +6416 9171 +6416 6519 +6416 9944 +6417 7668 +6417 7956 +6417 6489 +6417 9757 +6417 8447 +6418 6420 +6418 8982 +6418 6689 +6418 7593 +6418 9520 +6418 8121 +6418 8703 +6418 7546 +6418 9598 +6419 8454 +6419 7330 +6419 7336 +6419 7238 +6419 7239 +6419 7628 +6419 7772 +6420 8933 +6420 8537 +6420 9999 +6421 8707 +6421 8582 +6421 7821 +6421 8049 +6421 8502 +6421 8314 +6421 8783 +6421 9628 +6422 8546 +6422 8771 +6422 7397 +6422 8640 +6423 9282 +6423 7909 +6423 9377 +6423 6728 +6423 7946 +6423 9419 +6423 7340 +6423 7406 +6423 7943 +6423 8984 +6423 8255 +6424 9667 +6424 8426 +6424 7182 +6424 9782 +6424 7482 +6425 7559 +6425 6537 +6425 9539 +6425 9551 +6425 6614 +6425 6618 +6425 7264 +6425 9058 +6425 6647 +6425 7032 +6425 9082 +6426 8966 +6426 9003 +6426 8627 +6426 6453 +6426 9047 +6426 8665 +6426 9201 +6426 6868 +6427 8970 +6427 8203 +6427 7711 +6427 9735 +6427 7878 +6427 9674 +6427 8268 +6427 9310 +6427 9190 +6427 7527 +6427 8182 +6428 8208 +6428 7826 +6428 7194 +6428 8082 +6428 8479 +6428 7995 +6428 9532 +6428 6975 +6428 6466 +6428 7107 +6428 7247 +6428 7763 +6428 9428 +6428 7637 +6428 7905 +6428 7161 +6429 8774 +6429 7121 +6429 6931 +6429 9692 +6429 8541 +6430 8014 +6430 7978 +6430 8907 +6430 7186 +6430 9610 +6431 7311 +6432 9058 +6432 8469 +6432 8234 +6432 8023 +6432 8082 +6432 8304 +6432 9753 +6432 9742 +6433 8872 +6433 7313 +6433 7193 +6433 7007 +6433 8092 +6433 6590 +6434 7939 +6434 6761 +6434 9579 +6434 7592 +6434 9654 +6434 8891 +6435 9696 +6435 9073 +6435 9610 +6435 8471 +6435 9555 +6435 8329 +6435 9785 +6435 8730 +6436 7280 +6436 6445 +6436 8529 +6436 6895 +6436 8848 +6436 6846 +6436 7433 +6437 7618 +6437 8649 +6437 6794 +6437 6861 +6437 7825 +6437 8900 +6437 9719 +6437 7128 +6437 6441 +6437 6907 +6438 7406 +6438 6664 +6438 9529 +6439 9738 +6439 8974 +6439 7730 +6439 9652 +6439 6969 +6439 8396 +6439 7121 +6439 7376 +6439 8700 +6440 8091 +6440 7753 +6440 6448 +6440 8409 +6440 9626 +6440 8027 +6441 7305 +6441 9482 +6441 7036 +6441 9238 +6441 6460 +6441 9098 +6441 8282 +6442 8035 +6442 8388 +6442 8517 +6442 7528 +6442 8611 +6442 9699 +6442 8733 +6442 7231 +6443 7811 +6443 9659 +6443 7495 +6443 9073 +6443 9435 +6443 9754 +6443 7919 +6443 9340 +6444 6914 +6444 7441 +6444 9508 +6444 9511 +6444 7858 +6444 7229 +6444 7108 +6444 7240 +6444 8777 +6444 7505 +6444 6626 +6444 8315 +6445 8196 +6445 9626 +6445 7472 +6445 8890 +6445 6587 +6445 7108 +6445 9298 +6445 7254 +6445 8028 +6445 8941 +6445 8696 +6445 7418 +6446 8225 +6446 7750 +6446 9377 +6446 8460 +6446 8664 +6447 6845 +6447 7122 +6447 8559 +6447 8187 +6448 8256 +6448 8609 +6448 7955 +6448 7222 +6448 8632 +6448 9308 +6449 6727 +6449 8172 +6449 7949 +6449 7732 +6450 8709 +6450 8650 +6450 8658 +6450 9011 +6450 8088 +6450 7642 +6450 6779 +6450 8029 +6451 8416 +6451 7049 +6451 7608 +6451 8050 +6451 7831 +6451 9689 +6452 9419 +6452 9712 +6452 7825 +6452 8370 +6452 7512 +6452 6995 +6453 9870 +6453 9103 +6453 9506 +6453 9170 +6453 7251 +6453 9966 +6453 8692 +6453 9595 +6454 8998 +6454 6567 +6454 9546 +6454 8402 +6454 7770 +6454 6619 +6454 8162 +6454 7395 +6454 9457 +6454 9236 +6455 9107 +6455 9494 +6456 7569 +6456 8851 +6456 7469 +6456 8499 +6456 8892 +6456 6983 +6456 7375 +6456 8790 +6456 9785 +6456 9909 +6457 7429 +6457 8117 +6457 9664 +6457 6471 +6457 6743 +6457 8290 +6457 9199 +6457 7166 +6458 7874 +6458 9608 +6458 8021 +6458 9494 +6458 9212 +6459 8997 +6459 9576 +6459 7446 +6459 6519 +6459 6874 +6460 6927 +6460 6938 +6460 7718 +6460 8232 +6460 9770 +6460 9646 +6460 7622 +6460 8922 +6460 6765 +6460 6638 +6461 7427 +6461 9738 +6461 7321 +6461 7196 +6461 7726 +6461 9060 +6461 9837 +6462 8897 +6462 7402 +6462 7534 +6463 8485 +6463 9290 +6463 8665 +6463 9092 +6463 7487 +6464 8939 +6464 9892 +6464 6664 +6464 8169 +6464 7276 +6464 8622 +6464 8054 +6464 7480 +6464 7614 +6465 7771 +6465 7015 +6465 8297 +6465 9767 +6465 9807 +6465 7202 +6465 7036 +6465 9707 +6466 9124 +6466 9261 +6466 9531 +6466 8653 +6466 7387 +6466 9311 +6466 7013 +6466 9196 +6466 7664 +6466 7421 +6467 9560 +6467 7828 +6467 7346 +6467 6619 +6467 7036 +6467 8318 +6468 7650 +6468 6924 +6468 8493 +6468 9455 +6468 6579 +6469 9987 +6469 7319 +6469 8479 +6469 8371 +6469 7223 +6469 8915 +6469 8042 +6469 7291 +6469 9471 +6470 7781 +6470 6735 +6470 6772 +6471 8448 +6471 8274 +6471 8882 +6471 6714 +6471 7647 +6472 9858 +6472 6597 +6472 9996 +6472 9035 +6472 7091 +6473 9120 +6473 8683 +6473 7378 +6473 7283 +6473 8438 +6473 7871 +6473 9629 +6474 9360 +6474 7443 +6474 7828 +6474 8236 +6474 7887 +6474 7632 +6474 7384 +6474 8557 +6474 9205 +6474 8694 +6475 6691 +6475 9742 +6475 7306 +6475 7829 +6475 7900 +6476 7807 +6476 8125 +6476 8663 +6476 9496 +6476 7351 +6476 7621 +6477 8085 +6477 7321 +6477 6713 +6477 7484 +6477 8133 +6477 6990 +6477 8419 +6477 9963 +6478 6533 +6478 9159 +6478 6604 +6478 8656 +6478 9169 +6478 7379 +6478 8030 +6478 9854 +6479 8209 +6479 9235 +6479 6946 +6479 7637 +6479 8547 +6479 7415 +6479 8062 +6480 7904 +6480 9537 +6480 9508 +6480 9456 +6480 9938 +6480 7070 +6480 8560 +6480 8473 +6480 7325 +6480 7400 +6481 9344 +6481 8811 +6481 8943 +6481 6872 +6481 6839 +6481 7576 +6481 7321 +6482 8580 +6482 7301 +6482 9735 +6482 8208 +6482 7586 +6482 7616 +6482 8778 +6482 7900 +6482 9821 +6482 9956 +6482 8813 +6483 9123 +6483 8901 +6483 7814 +6483 8190 +6483 7759 +6483 8465 +6483 8565 +6483 9177 +6483 7580 +6484 6945 +6484 8290 +6484 9569 +6484 8712 +6484 8856 +6484 8170 +6484 8895 +6485 6903 +6485 6574 +6485 7603 +6485 9892 +6485 8958 +6486 8834 +6486 9551 +6486 8825 +6486 8444 +6487 6947 +6487 7941 +6487 8149 +6487 6640 +6487 9630 +6487 7733 +6488 8068 +6488 7691 +6488 8848 +6488 6673 +6488 7192 +6488 7978 +6488 6964 +6488 6711 +6488 7866 +6488 8253 +6488 9031 +6488 7125 +6488 7114 +6488 6763 +6488 7421 +6488 7801 +6489 8208 +6489 8521 +6489 9282 +6489 8073 +6489 7067 +6489 9481 +6490 9232 +6490 9348 +6490 6823 +6490 9587 +6490 7225 +6490 7832 +6490 9306 +6491 6536 +6491 9802 +6491 7522 +6491 8703 +6491 7870 +6491 8319 +6492 6592 +6492 7520 +6492 6663 +6492 9518 +6492 8341 +6492 7704 +6492 8218 +6492 6654 +6493 6943 +6493 7082 +6493 8944 +6493 8436 +6493 6783 +6493 8406 +6493 8667 +6493 9919 +6494 7197 +6494 7713 +6494 6837 +6494 8010 +6494 7243 +6494 7034 +6495 8116 +6495 7317 +6495 6938 +6496 7077 +6496 8969 +6496 6506 +6496 6791 +6496 7700 +6496 9428 +6496 7035 +6496 7869 +6496 8479 +6497 7288 +6497 9936 +6497 8788 +6497 7610 +6497 7320 +6498 7817 +6498 7616 +6498 9544 +6498 7655 +6498 9580 +6499 7916 +6499 9070 +6499 6846 +6499 8639 +6499 9887 +6499 8445 +6499 9631 +6500 8459 +6500 8205 +6500 7885 +6500 9682 +6500 9910 +6500 9624 +6500 8242 +6500 9727 +6501 9364 +6501 7717 +6501 7135 +6501 7373 +6501 7077 +6501 7662 +6501 8980 +6502 8527 +6502 7158 +6502 7256 +6502 7356 +6502 8164 +6503 9666 +6503 9414 +6503 9020 +6503 7370 +6503 9170 +6503 6541 +6503 8016 +6503 8498 +6503 8852 +6503 7271 +6503 8476 +6503 9150 +6504 9218 +6504 7043 +6504 6584 +6504 8901 +6504 9804 +6504 8150 +6504 8313 +6505 6944 +6505 8460 +6505 8364 +6505 7307 +6505 8266 +6505 7702 +6506 7093 +6506 8601 +6506 7716 +6506 6975 +6506 9419 +6506 9801 +6506 6987 +6506 7891 +6506 9636 +6506 7006 +6506 8673 +6507 6924 +6507 9878 +6507 8896 +6507 9177 +6507 9451 +6507 9324 +6507 7933 +6508 7848 +6508 6828 +6508 7914 +6508 9900 +6508 8116 +6508 7946 +6508 8731 +6508 7325 +6508 7525 +6509 8337 +6509 7200 +6509 9766 +6509 8492 +6509 6974 +6509 9160 +6509 7655 +6509 9447 +6509 7160 +6510 7450 +6510 8747 +6510 8435 +6510 8116 +6511 7873 +6511 9442 +6511 8011 +6511 9301 +6511 7993 +6511 9883 +6511 9918 +6512 7648 +6512 7241 +6512 7212 +6512 6542 +6512 9113 +6512 9729 +6512 9897 +6512 9710 +6512 9978 +6513 9364 +6513 8086 +6513 8248 +6513 6724 +6513 7478 +6513 9562 +6513 9309 +6513 7140 +6514 8849 +6514 7450 +6514 9900 +6514 7602 +6514 7732 +6514 8654 +6514 8928 +6514 8429 +6514 8046 +6514 7283 +6514 9334 +6515 6984 +6515 7248 +6515 7032 +6515 8820 +6515 8187 +6515 6780 +6516 8192 +6516 9731 +6516 9226 +6516 8844 +6516 9543 +6516 7024 +6516 8189 +6517 7650 +6517 7396 +6517 9032 +6517 7817 +6517 9205 +6517 9330 +6517 9523 +6517 9558 +6518 7020 +6518 8793 +6518 6563 +6518 9481 +6518 9402 +6518 9056 +6518 9049 +6518 7648 +6518 8804 +6518 7787 +6518 8537 +6519 9480 +6519 6545 +6519 9750 +6519 7328 +6519 7090 +6519 7537 +6520 9666 +6520 7460 +6520 9297 +6520 6988 +6520 8856 +6520 7371 +6520 9848 +6520 7314 +6520 9699 +6520 7161 +6521 8704 +6521 8931 +6521 6952 +6521 7792 +6521 6900 +6522 7818 +6522 9613 +6522 8979 +6522 6576 +6522 8356 +6522 8368 +6522 7986 +6522 8650 +6522 7391 +6522 9056 +6522 8045 +6523 6755 +6523 7399 +6523 9418 +6523 9877 +6523 7670 +6523 7514 +6524 8166 +6524 8360 +6524 7081 +6524 9523 +6524 9400 +6524 6589 +6525 9477 +6525 8328 +6525 9750 +6525 9282 +6525 6982 +6525 7242 +6526 9570 +6526 7893 +6526 6903 +6526 9474 +6527 7426 +6527 9476 +6527 9226 +6527 9245 +6527 7843 +6527 9009 +6527 7227 +6527 8262 +6527 6881 +6527 8529 +6527 9813 +6527 8790 +6527 6622 +6527 9057 +6527 9335 +6528 6626 +6528 7996 +6528 8335 +6528 8752 +6528 7705 +6528 9221 +6528 8341 +6529 9672 +6529 7786 +6529 6636 +6529 7154 +6529 7990 +6529 9807 +6529 6652 +6529 7400 +6529 8127 +6530 8835 +6530 7301 +6530 9356 +6530 7447 +6530 9053 +6530 8166 +6530 8570 +6531 6861 +6531 9699 +6531 8429 +6532 8963 +6532 6966 +6532 9938 +6532 7380 +6532 9463 +6532 7508 +6532 8827 +6532 8426 +6532 8222 +6533 8162 +6533 8483 +6533 8935 +6533 9065 +6534 8392 +6534 6611 +6534 6902 +6534 6801 +6535 7941 +6535 9555 +6535 7102 +6535 8376 +6535 9150 +6536 9571 +6536 7557 +6536 8041 +6536 8428 +6536 9180 +6536 8954 +6537 6984 +6537 7182 +6537 8440 +6538 9344 +6538 9384 +6538 6605 +6538 6581 +6539 6752 +6539 9515 +6539 6634 +6539 8886 +6539 6589 +6540 8928 +6540 9377 +6540 7555 +6540 6885 +6540 7946 +6540 9781 +6541 8713 +6541 7820 +6541 7317 +6541 6817 +6541 8780 +6541 7077 +6541 9958 +6541 7803 +6542 8325 +6542 9773 +6542 6852 +6542 8666 +6542 9150 +6543 9507 +6543 7627 +6543 6588 +6544 8741 +6544 7829 +6545 9856 +6545 9984 +6545 8461 +6545 7918 +6545 8472 +6545 9908 +6545 9555 +6546 6674 +6546 8222 +6546 8623 +6546 7601 +6546 7484 +6546 7565 +6546 9043 +6546 7509 +6546 7933 +6547 6788 +6547 7927 +6547 9425 +6547 7640 +6547 9595 +6548 7296 +6548 8973 +6548 8869 +6548 9384 +6548 9103 +6548 9171 +6548 7668 +6548 8441 +6548 9073 +6549 9904 +6549 8273 +6549 8692 +6549 9919 +6550 7315 +6550 7576 +6550 9898 +6550 8750 +6550 9527 +6550 8766 +6550 6595 +6550 9949 +6550 8298 +6550 8696 +6551 6852 +6551 7943 +6551 7786 +6551 8730 +6551 9822 +6552 9990 +6552 9353 +6552 7962 +6552 8609 +6552 8631 +6552 8693 +6552 7913 +6553 6598 +6553 7637 +6553 9708 +6553 7342 +6553 7861 +6553 7295 +6554 7271 +6554 8680 +6554 8883 +6554 6805 +6554 7800 +6554 9531 +6554 9246 +6555 9792 +6555 9605 +6555 8080 +6555 8640 +6555 9286 +6555 8527 +6555 6993 +6555 8291 +6555 9964 +6555 6909 +6556 9261 +6556 9106 +6556 8275 +6556 6750 +6557 6732 +6557 8943 +6557 9115 +6558 6571 +6558 6886 +6558 9065 +6558 9778 +6558 7278 +6558 7549 +6558 8499 +6558 6613 +6558 8342 +6558 9755 +6558 8154 +6559 7818 +6559 9389 +6559 8493 +6559 7090 +6559 9449 +6559 8310 +6560 9329 +6560 7011 +6561 6660 +6561 7951 +6561 8723 +6561 7002 +6561 8764 +6562 6929 +6562 6942 +6562 8115 +6562 7988 +6562 9400 +6562 8008 +6562 9181 +6562 7785 +6562 7146 +6563 8680 +6563 7339 +6563 6739 +6563 8856 +6563 8795 +6563 9770 +6564 9361 +6564 8732 +6564 7476 +6564 9654 +6564 8504 +6564 7357 +6564 8649 +6564 9428 +6564 6624 +6565 7182 +6565 9644 +6565 8005 +6565 8286 +6565 8417 +6565 7145 +6565 8682 +6565 8703 +6566 6923 +6566 8460 +6566 8725 +6566 7451 +6566 7965 +6566 7600 +6566 9254 +6566 6576 +6566 8898 +6566 7415 +6567 7820 +6567 8226 +6567 8567 +6568 9760 +6568 7163 +6568 6797 +6568 8077 +6568 7122 +6568 9043 +6568 8656 +6568 9854 +6568 9663 +6569 8395 +6569 9188 +6569 8459 +6569 9036 +6569 8093 +6570 7129 +6570 7876 +6570 7941 +6570 8519 +6570 7562 +6570 9228 +6570 9298 +6570 8147 +6570 9189 +6570 8154 +6570 8783 +6570 8170 +6571 7470 +6571 9371 +6571 7728 +6571 9428 +6571 7384 +6571 8819 +6571 9718 +6571 6903 +6572 8323 +6572 9098 +6572 7443 +6572 7870 +6572 8403 +6572 7390 +6572 9955 +6572 8939 +6572 9087 +6573 8849 +6573 7212 +6573 8172 +6573 9202 +6573 6744 +6574 7958 +6574 8767 +6574 9086 +6575 7360 +6575 8641 +6575 7574 +6576 8480 +6576 7010 +6576 7301 +6576 9256 +6576 8105 +6576 7634 +6576 9781 +6576 9209 +6577 9516 +6577 7357 +6577 9662 +6577 8265 +6577 6860 +6577 7631 +6577 9056 +6577 8558 +6577 9720 +6577 8957 +6578 9460 +6578 8297 +6578 8459 +6578 8908 +6578 6638 +6578 8116 +6579 8864 +6579 9912 +6579 8016 +6579 7064 +6579 8277 +6579 6934 +6579 9591 +6579 9247 +6580 9310 +6580 8787 +6580 8308 +6580 7625 +6580 8793 +6580 7711 +6581 8713 +6581 9899 +6581 6869 +6582 6688 +6582 8131 +6582 8993 +6582 9097 +6582 9706 +6582 7946 +6582 8018 +6583 9633 +6583 7313 +6583 9553 +6583 9975 +6583 7161 +6583 6844 +6584 7256 +6584 7468 +6584 9805 +6584 9846 +6584 7800 +6584 8441 +6585 6794 +6585 7053 +6585 6682 +6585 7461 +6585 9262 +6585 6987 +6585 9094 +6585 9689 +6585 8288 +6586 9187 +6586 7332 +6586 7885 +6586 7747 +6586 7646 +6587 6793 +6587 7441 +6587 6937 +6587 8987 +6587 7332 +6587 6604 +6587 6989 +6587 7787 +6588 7815 +6588 9517 +6588 8623 +6588 6877 +6588 7011 +6589 7811 +6589 8593 +6589 9513 +6589 7241 +6589 7665 +6590 7828 +6590 7446 +6590 9242 +6590 7920 +6590 9891 +6590 6699 +6590 6629 +6590 7656 +6590 7792 +6590 9843 +6590 8185 +6591 9161 +6591 7308 +6591 9872 +6591 8195 +6591 8851 +6591 7542 +6591 7161 +6591 9967 +6592 7853 +6592 7092 +6593 8322 +6593 8683 +6593 6692 +6593 8809 +6593 9899 +6593 9762 +6593 9709 +6593 8337 +6593 7605 +6594 7600 +6594 7333 +6594 9638 +6594 9788 +6594 8153 +6594 9178 +6594 7260 +6595 7364 +6595 8582 +6595 8842 +6595 8464 +6595 7111 +6595 9693 +6596 8707 +6596 8452 +6596 8074 +6596 9749 +6596 9393 +6596 8765 +6596 7753 +6596 7275 +6596 8442 +6597 6656 +6597 6795 +6597 8813 +6597 6928 +6597 7377 +6597 9687 +6597 7324 +6598 9525 +6598 9949 +6598 9717 +6598 8567 +6598 8698 +6598 9343 +6599 9253 +6599 9809 +6600 6844 +6600 6839 +6600 8204 +6600 8308 +6600 7863 +6601 7264 +6601 9179 +6601 8767 +6602 9883 +6602 8222 +6602 8996 +6602 6720 +6602 7890 +6602 6748 +6602 8432 +6602 7699 +6602 7164 +6603 8835 +6603 9395 +6603 6849 +6603 6610 +6603 9304 +6603 8282 +6603 7899 +6603 9830 +6603 8429 +6603 9972 +6603 9979 +6603 7038 +6604 8099 +6604 9640 +6604 7440 +6604 9654 +6605 9739 +6605 8967 +6605 6958 +6605 6851 +6605 9161 +6606 7908 +6606 7798 +6606 9873 +6606 7028 +6606 8118 +6606 9407 +6607 8640 +6607 8097 +6607 8392 +6607 8557 +6607 7828 +6607 8662 +6607 7042 +6607 9431 +6608 8294 +6608 9771 +6608 8146 +6608 8407 +6608 8671 +6609 7360 +6609 8801 +6609 8964 +6609 9248 +6609 9590 +6609 7744 +6609 8932 +6609 8954 +6610 9858 +6610 9615 +6610 9876 +6610 8634 +6610 8773 +6610 9837 +6610 6769 +6610 8959 +6611 8070 +6611 9864 +6611 8081 +6611 7837 +6611 8734 +6611 7075 +6611 9897 +6611 6701 +6611 8510 +6611 9669 +6611 8918 +6611 7257 +6611 8801 +6612 9863 +6612 6959 +6612 6985 +6612 8394 +6612 7254 +6612 6880 +6613 8713 +6613 8600 +6613 9264 +6613 7817 +6613 9164 +6613 8020 +6613 7912 +6614 9864 +6614 7703 +6614 7194 +6614 7368 +6614 9295 +6614 7764 +6614 8563 +6615 7227 +6615 7095 +6616 6818 +6616 7492 +6616 9044 +6616 7103 +6616 6943 +6617 7992 +6617 9752 +6617 8990 +6617 6968 +6617 6843 +6617 8639 +6617 8157 +6617 8184 +6617 8574 +6618 8684 +6618 8409 +6619 8266 +6619 7742 +6619 8122 +6619 8847 +6619 9822 +6620 9097 +6620 9613 +6620 7195 +6620 8476 +6620 7587 +6620 9545 +6620 6843 +6620 6868 +6620 9185 +6620 9698 +6620 7275 +6620 6654 +6621 9057 +6621 9649 +6621 6888 +6621 6957 +6621 9017 +6621 9019 +6622 8735 +6622 6742 +6622 9963 +6622 8210 +6622 6744 +6622 8511 +6623 8036 +6623 8748 +6623 8112 +6623 7188 +6623 8794 +6624 8555 +6624 6788 +6624 6899 +6624 8852 +6624 8117 +6624 8084 +6624 8068 +6624 7551 +6625 7298 +6625 6796 +6625 9230 +6625 9231 +6625 8717 +6625 8539 +6625 7966 +6626 8109 +6626 9796 +6626 7367 +6626 7293 +6627 8211 +6627 6672 +6627 8459 +6627 8645 +6627 9226 +6627 9748 +6627 8242 +6627 7381 +6627 9980 +6627 6750 +6628 8068 +6628 9590 +6628 9846 +6628 8623 +6628 7409 +6628 9746 +6629 8868 +6629 8745 +6629 8486 +6629 7905 +6629 8780 +6629 7539 +6629 7445 +6629 7449 +6630 7552 +6630 9858 +6630 6801 +6630 8017 +6630 9910 +6630 7415 +6630 9977 +6631 8202 +6631 8367 +6631 9822 +6632 8066 +6632 8963 +6632 9993 +6632 8332 +6632 8469 +6632 8646 +6632 8986 +6632 7934 +6632 7423 +6633 8992 +6633 6850 +6633 8227 +6633 8996 +6633 8332 +6633 8886 +6633 9337 +6633 9151 +6634 9057 +6634 8069 +6634 8013 +6634 8312 +6634 8888 +6634 7099 +6634 7581 +6635 8138 +6635 6676 +6635 7285 +6636 9890 +6636 9957 +6636 7142 +6636 9281 +6636 7724 +6636 8045 +6636 8338 +6637 8793 +6637 7815 +6637 8149 +6637 7190 +6637 6841 +6638 8092 +6638 8077 +6638 7521 +6638 7376 +6638 9521 +6638 7063 +6638 8539 +6639 6665 +6639 6765 +6639 7843 +6639 7209 +6639 7486 +6639 9527 +6639 8015 +6639 7134 +6639 9835 +6639 9810 +6640 9473 +6640 7719 +6640 7175 +6641 9570 +6641 8111 +6641 7348 +6641 7740 +6641 7658 +6641 8044 +6641 8060 +6642 7872 +6642 7778 +6642 7971 +6642 7687 +6642 9065 +6642 7250 +6642 7222 +6642 7369 +6643 8960 +6643 7426 +6643 9093 +6643 8989 +6643 7110 +6643 9032 +6643 6879 +6644 8196 +6644 9373 +6644 9246 +6644 9001 +6644 8370 +6644 7893 +6644 7294 +6645 7681 +6645 9221 +6645 7051 +6645 9117 +6645 7326 +6645 9118 +6645 9920 +6645 8898 +6645 7774 +6645 8294 +6645 9067 +6645 8698 +6646 8747 +6646 7940 +6646 8351 +6646 8888 +6646 9531 +6646 8912 +6646 6772 +6647 7816 +6647 8556 +6647 7628 +6647 8447 +6648 7970 +6648 9699 +6648 8517 +6648 8999 +6648 9555 +6648 6892 +6648 7694 +6648 8815 +6649 7131 +6649 9425 +6649 9179 +6649 8913 +6649 9042 +6649 8723 +6649 9588 +6649 8964 +6649 8186 +6649 7835 +6649 7644 +6650 7680 +6650 8813 +6650 7697 +6650 9363 +6650 9504 +6650 9074 +6650 9780 +6650 7503 +6650 9558 +6650 7907 +6650 8421 +6650 7026 +6650 8956 +6651 7557 +6651 7366 +6651 8455 +6651 7208 +6651 9258 +6651 7684 +6651 9047 +6652 8334 +6652 8211 +6652 9753 +6652 7586 +6652 7490 +6652 8645 +6652 9692 +6652 6883 +6652 9459 +6652 7287 +6653 9539 +6653 9125 +6653 8626 +6653 7351 +6653 7422 +6654 7838 +6654 6944 +6654 8415 +6654 7876 +6654 8904 +6654 9550 +6654 8404 +6654 7647 +6654 7031 +6654 7930 +6654 9727 +6655 9284 +6655 9827 +6655 8180 +6656 7057 +6656 8752 +6656 7990 +6656 9406 +6657 9873 +6657 7064 +6657 8355 +6657 8763 +6657 9550 +6657 6991 +6657 7768 +6657 9436 +6657 8420 +6657 9702 +6657 8687 +6657 8563 +6658 7827 +6658 7085 +6658 7987 +6658 7896 +6658 7276 +6658 7929 +6659 8579 +6659 9734 +6659 8594 +6659 8047 +6659 9371 +6659 8870 +6659 7619 +6659 9056 +6660 7057 +6660 6681 +6660 6822 +6660 9394 +6660 9910 +6660 8645 +6660 9451 +6660 8573 +6660 8062 +6661 8341 +6661 7994 +6661 7871 +6661 8647 +6662 7531 +6662 7332 +6662 6789 +6662 9574 +6662 6766 +6662 8464 +6662 9685 +6663 9504 +6663 7200 +6663 6915 +6663 9221 +6663 8861 +6663 7281 +6663 7188 +6663 7743 +6663 9853 +6663 9967 +6664 8527 +6664 8718 +6665 7232 +6665 9704 +6665 8586 +6665 8812 +6665 7632 +6665 8945 +6665 8260 +6665 8221 +6666 6794 +6666 7436 +6666 7277 +6666 7188 +6666 9389 +6666 6839 +6666 7226 +6666 7891 +6666 7768 +6666 7395 +6666 7030 +6667 7883 +6667 8305 +6667 8406 +6667 9996 +6667 8430 +6667 8815 +6667 9070 +6667 8888 +6668 7714 +6668 7928 +6668 9957 +6668 7401 +6668 8952 +6668 7288 +6668 6781 +6669 8704 +6669 7825 +6669 6955 +6669 6737 +6669 8462 +6669 8921 +6669 9952 +6670 6914 +6670 7691 +6670 9218 +6670 9110 +6670 8885 +6670 9410 +6670 9946 +6670 8978 +6671 7552 +6671 8205 +6671 8179 +6671 9531 +6671 7871 +6671 7880 +6671 9561 +6671 7004 +6671 7531 +6672 6797 +6672 7703 +6672 8089 +6672 9631 +6672 7857 +6672 6792 +6672 7502 +6672 7250 +6672 8057 +6673 8071 +6673 7180 +6673 9506 +6673 8686 +6673 9871 +6673 8659 +6673 9989 +6674 8708 +6674 7438 +6674 7859 +6674 6876 +6674 7019 +6674 9874 +6674 9211 +6675 8484 +6675 7129 +6675 7710 +6675 8575 +6676 7530 +6676 6863 +6676 7056 +6677 9223 +6677 6804 +6677 7200 +6677 8305 +6677 8177 +6678 9322 +6678 7191 +6678 8887 +6679 8851 +6679 8602 +6679 7583 +6679 7082 +6679 8236 +6679 7726 +6679 7855 +6679 8646 +6679 9843 +6679 9973 +6680 9835 +6680 7692 +6680 6990 +6680 7796 +6680 6985 +6680 7160 +6680 8703 +6681 7142 +6681 7788 +6681 9123 +6681 6870 +6681 7576 +6682 9476 +6682 9860 +6682 9674 +6682 6872 +6682 9446 +6682 8555 +6682 6769 +6683 7942 +6683 7703 +6683 6965 +6683 8987 +6684 7940 +6684 9992 +6684 9773 +6684 8995 +6684 6700 +6684 8237 +6684 9785 +6684 8003 +6684 8908 +6684 9166 +6684 8355 +6684 7258 +6684 7263 +6684 9186 +6685 6929 +6685 7092 +6685 7607 +6686 7386 +6686 7434 +6686 8300 +6686 8367 +6686 9299 +6686 9816 +6686 7252 +6686 9647 +6686 8220 +6686 9054 +6687 6946 +6687 7771 +6687 8583 +6687 9769 +6687 9322 +6687 6700 +6687 7831 +6687 9275 +6689 8452 +6689 9318 +6689 9414 +6690 9803 +6690 9998 +6690 7739 +6690 9053 +6690 7646 +6690 9791 +6691 8834 +6691 8271 +6691 7984 +6691 6870 +6691 8025 +6692 8002 +6692 8233 +6692 8188 +6692 7670 +6692 8150 +6692 8473 +6693 9746 +6693 6714 +6693 9566 +6693 7779 +6693 7411 +6693 9514 +6693 9215 +6694 9730 +6695 7969 +6695 7821 +6696 8805 +6696 9612 +6696 8989 +6696 8247 +6696 8242 +6697 7969 +6697 8240 +6697 9160 +6697 7960 +6697 9682 +6697 9878 +6697 9496 +6697 7642 +6698 8803 +6698 9957 +6698 8361 +6698 9327 +6698 9625 +6698 7930 +6698 7644 +6699 6918 +6699 8842 +6699 9164 +6699 7839 +6699 8140 +6699 8912 +6699 9838 +6699 7545 +6699 9723 +6700 9508 +6700 8934 +6700 7095 +6700 8794 +6701 6876 +6701 9073 +6701 6802 +6701 8788 +6701 9013 +6701 9079 +6702 8772 +6702 7943 +6702 9900 +6702 9296 +6702 8377 +6703 7426 +6703 8584 +6703 9748 +6703 8095 +6703 9274 +6703 9288 +6703 8980 +6703 7675 +6704 8071 +6704 7305 +6704 8394 +6704 8620 +6704 9378 +6704 7641 +6704 9941 +6704 7195 +6705 7830 +6705 9681 +6705 9191 +6705 9890 +6705 9454 +6705 8561 +6705 7903 +6705 6901 +6706 7233 +6706 7579 +6706 7603 +6706 9706 +6706 7312 +6706 8854 +6706 7707 +6706 8733 +6706 6878 +6707 8992 +6707 7597 +6707 9181 +6707 8112 +6707 6841 +6707 8250 +6707 6972 +6707 9537 +6707 8775 +6707 7112 +6707 7628 +6708 9861 +6708 7328 +6708 8997 +6708 6954 +6708 9515 +6708 9389 +6708 7091 +6708 6836 +6708 8885 +6708 7999 +6708 9181 +6708 7393 +6708 6885 +6709 9728 +6709 8460 +6709 7991 +6709 8897 +6709 7381 +6709 8796 +6709 6756 +6710 8161 +6710 7779 +6710 9990 +6710 8173 +6710 9082 +6710 8942 +6710 7057 +6710 9463 +6710 6970 +6710 8015 +6711 9154 +6711 8521 +6711 6968 +6711 9970 +6711 9716 +6711 9397 +6711 7613 +6712 9931 +6712 9708 +6712 7730 +6712 8981 +6712 7834 +6713 7055 +6713 6800 +6713 9134 +6713 7863 +6713 7508 +6713 8804 +6713 8060 +6714 9604 +6714 8329 +6714 6946 +6714 7460 +6714 8502 +6714 9023 +6714 6857 +6714 9803 +6714 8031 +6714 8801 +6714 7285 +6715 9378 +6715 7491 +6715 9832 +6715 8268 +6715 7427 +6715 9428 +6715 7394 +6715 7352 +6715 7348 +6716 7172 +6716 8722 +6716 8469 +6716 8357 +6716 9904 +6716 9292 +6716 8420 +6717 8962 +6717 7818 +6717 8715 +6717 8729 +6717 8099 +6717 7859 +6717 6837 +6717 7113 +6717 9272 +6717 9028 +6717 9689 +6717 6874 +6717 9056 +6718 9638 +6718 7676 +6718 7409 +6718 7698 +6718 7349 +6719 9110 +6719 7061 +6719 8830 +6720 8523 +6720 8747 +6720 8925 +6721 9508 +6721 8551 +6721 7158 +6721 9623 +6722 8744 +6722 7784 +6722 8904 +6722 7005 +6722 9361 +6722 7764 +6723 8673 +6723 9123 +6723 8883 +6723 8821 +6723 8469 +6724 9735 +6724 6925 +6724 8873 +6724 9004 +6724 8881 +6724 6839 +6724 7488 +6724 6979 +6724 7632 +6724 7760 +6724 9451 +6724 8695 +6725 9702 +6725 9873 +6725 7837 +6725 8971 +6725 8652 +6725 9425 +6725 9150 +6725 8319 +6726 7071 +6727 8096 +6727 9859 +6727 6797 +6727 7376 +6727 7734 +6727 9213 +6728 8365 +6728 8087 +6728 8567 +6728 6777 +6728 6910 +6729 7811 +6729 7687 +6729 6798 +6729 9359 +6729 8235 +6729 9133 +6729 8895 +6729 9281 +6729 8523 +6729 9426 +6729 8719 +6729 8019 +6730 8718 +6730 7255 +6730 9208 +6730 9437 +6731 8597 +6731 6944 +6731 6964 +6731 6845 +6731 9073 +6732 8898 +6732 8406 +6732 8694 +6732 7665 +6732 8915 +6732 7356 +6732 8094 +6733 8288 +6733 8464 +6733 9201 +6733 9010 +6733 8214 +6733 8540 +6734 8588 +6734 7075 +6734 9642 +6734 9006 +6734 8372 +6734 9272 +6734 9688 +6734 8809 +6734 8300 +6735 9353 +6735 9248 +6735 9144 +6735 8384 +6735 8929 +6735 7025 +6735 9279 +6736 8549 +6736 8459 +6736 7196 +6736 9599 +6737 9938 +6737 7524 +6737 6789 +6737 7373 +6737 8752 +6737 9208 +6738 7357 +6738 6754 +6738 9203 +6738 6906 +6738 8574 +6739 9984 +6739 7874 +6739 6982 +6739 9928 +6739 8681 +6739 6891 +6739 7318 +6739 8569 +6740 6959 +6740 9549 +6740 9567 +6740 7022 +6740 8434 +6740 8182 +6741 8864 +6741 7620 +6741 7015 +6741 9131 +6741 9063 +6741 9173 +6741 7737 +6741 9164 +6742 6928 +6742 8755 +6742 7964 +6742 6835 +6742 8268 +6742 9424 +6742 9811 +6743 9318 +6743 8839 +6743 7791 +6743 8114 +6743 7059 +6743 9337 +6744 7733 +6744 6852 +6744 8312 +6744 7250 +6744 7639 +6745 9856 +6745 8325 +6745 9124 +6745 6761 +6745 7926 +6746 7392 +6746 9264 +6746 8258 +6746 9731 +6746 9932 +6746 9999 +6746 7225 +6746 9849 +6747 9752 +6747 6962 +6747 7732 +6747 8128 +6747 7005 +6747 8556 +6748 9611 +6748 9876 +6748 8093 +6748 8875 +6748 9634 +6748 7118 +6748 9825 +6748 8691 +6749 7246 +6749 9396 +6749 9595 +6749 9372 +6749 8062 +6750 9729 +6750 7493 +6750 7837 +6750 9149 +6750 8503 +6750 7583 +6751 9216 +6751 8571 +6751 7725 +6751 8664 +6752 8195 +6752 7250 +6752 9624 +6752 6995 +6752 7259 +6753 7585 +6753 8724 +6753 7758 +6753 9953 +6753 8944 +6754 9032 +6754 8685 +6754 7598 +6754 8529 +6754 8446 +6754 7288 +6754 9881 +6755 7044 +6755 8425 +6755 6826 +6755 8845 +6755 8051 +6755 8180 +6755 7256 +6756 8067 +6756 7559 +6756 9239 +6756 8369 +6756 9547 +6756 9453 +6756 9974 +6756 6781 +6757 8046 +6757 9750 +6757 8920 +6757 8110 +6757 9326 +6758 9219 +6758 8973 +6758 7826 +6758 9647 +6758 8886 +6758 8895 +6758 7872 +6758 7250 +6758 9106 +6758 8952 +6759 9931 +6759 7147 +6759 7663 +6759 7800 +6759 9905 +6759 8317 +6760 7832 +6760 8351 +6760 7344 +6760 9380 +6760 8623 +6760 8368 +6760 9343 +6761 7049 +6761 9019 +6761 7154 +6761 8563 +6761 7548 +6762 8583 +6762 9611 +6762 6949 +6762 8382 +6762 7840 +6762 9941 +6762 9431 +6762 9060 +6762 8944 +6763 9856 +6763 9060 +6763 8491 +6763 8426 +6763 6931 +6763 7733 +6763 8489 +6763 8153 +6763 8669 +6764 9728 +6764 9104 +6764 7547 +6764 9513 +6764 8969 +6764 7930 +6764 9919 +6765 8323 +6765 9499 +6765 7457 +6765 8668 +6765 9656 +6765 7261 +6765 6882 +6765 7278 +6765 8951 +6766 7692 +6766 7694 +6766 8350 +6766 8122 +6766 7052 +6767 8709 +6767 7500 +6767 7146 +6767 9108 +6767 9587 +6767 9494 +6767 7325 +6768 9485 +6768 8847 +6768 8865 +6768 7214 +6768 8504 +6768 9085 +6769 9958 +6769 9330 +6769 9110 +6769 9079 +6769 8980 +6769 7253 +6770 9536 +6770 6819 +6770 8680 +6770 7371 +6770 6962 +6771 7493 +6771 6942 +6771 7472 +6771 9660 +6771 8518 +6771 7762 +6771 8924 +6771 8926 +6771 7394 +6771 9704 +6771 9071 +6772 9776 +6772 8459 +6772 7815 +6772 7823 +6772 7668 +6772 7866 +6772 7612 +6772 8127 +6773 7814 +6773 8072 +6773 7307 +6773 9497 +6773 8351 +6773 8945 +6773 9526 +6773 7868 +6773 8894 +6773 8776 +6773 7376 +6773 9835 +6773 8687 +6774 7171 +6774 8597 +6774 8964 +6774 9626 +6774 8123 +6774 7789 +6774 6977 +6774 8530 +6774 9558 +6774 8690 +6774 8951 +6774 8697 +6775 7178 +6775 9881 +6775 8226 +6775 8105 +6775 7612 +6775 6981 +6775 9041 +6775 7932 +6776 9531 +6776 9481 +6776 7066 +6777 9833 +6777 8848 +6777 7441 +6777 9128 +6777 6905 +6778 9989 +6778 8724 +6778 8736 +6778 7974 +6778 9775 +6778 9020 +6778 7537 +6778 7029 +6779 8071 +6779 7051 +6779 7967 +6779 9283 +6779 7494 +6779 9676 +6779 8694 +6780 9664 +6780 9003 +6780 8368 +6780 9038 +6781 9989 +6781 8087 +6781 9511 +6781 9936 +6781 8786 +6781 9812 +6781 9559 +6781 7770 +6781 8018 +6781 9727 +6782 8480 +6782 8838 +6782 8234 +6782 7335 +6782 7095 +6782 7931 +6782 9980 +6782 9130 +6783 8452 +6783 9742 +6783 7985 +6783 7506 +6783 9551 +6784 7520 +6784 9076 +6784 8732 +6785 9984 +6785 9763 +6785 8100 +6785 8262 +6785 8581 +6785 7535 +6785 8680 +6785 7315 +6785 9620 +6786 8448 +6786 8259 +6786 7212 +6786 9627 +6786 7805 +6787 7830 +6787 9522 +6787 6930 +6787 9209 +6787 8083 +6787 9206 +6788 7682 +6788 7312 +6788 9617 +6788 9256 +6788 7730 +6788 7356 +6788 8653 +6788 8911 +6788 8950 +6789 7937 +6789 8777 +6789 8276 +6789 9580 +6789 8558 +6789 8268 +6790 9056 +6790 9249 +6790 7879 +6790 7639 +6790 8056 +6790 7261 +6791 7707 +6791 8614 +6791 7281 +6791 7977 +6791 7633 +6792 8069 +6792 8977 +6792 7075 +6792 8869 +6792 9776 +6792 8766 +6792 8541 +6792 6890 +6793 7643 +6793 9963 +6793 9711 +6793 8623 +6793 9278 +6794 7957 +6794 9943 +6794 9148 +6794 7274 +6795 8845 +6795 8468 +6795 6981 +6795 7449 +6795 7070 +6795 7173 +6796 9492 +6796 7833 +6796 8362 +6796 9923 +6796 9160 +6796 9296 +6796 6909 +6797 9761 +6797 8465 +6797 8073 +6797 8730 +6798 9461 +6798 9735 +6798 7918 +6798 7781 +6798 7509 +6799 7526 +6799 8551 +6799 8140 +6799 7020 +6799 8015 +6799 9499 +6800 8322 +6800 8324 +6800 9742 +6800 7149 +6800 9879 +6800 8747 +6800 8247 +6800 6851 +6800 9284 +6800 9319 +6800 8813 +6801 9522 +6801 8547 +6801 8295 +6801 9405 +6802 7106 +6802 8259 +6802 9240 +6802 9241 +6803 7817 +6803 7193 +6803 9805 +6803 7515 +6803 9061 +6803 7909 +6803 9339 +6804 9872 +6804 7778 +6804 8493 +6804 8432 +6805 8193 +6805 7300 +6805 8014 +6805 7954 +6805 8596 +6805 6893 +6805 8951 +6806 7874 +6806 6886 +6806 7271 +6806 8809 +6806 8772 +6807 7204 +6807 9771 +6807 7087 +6807 9804 +6807 8039 +6807 7018 +6808 6914 +6808 8000 +6808 7821 +6808 9310 +6808 9840 +6808 7033 +6809 7681 +6809 7593 +6809 9197 +6809 8348 +6809 7203 +6809 7156 +6809 8601 +6810 7302 +6810 7824 +6810 8724 +6810 9978 +6811 8767 +6811 7676 +6812 9248 +6812 9440 +6812 9821 +6812 7409 +6812 8693 +6812 7153 +6813 8034 +6813 7857 +6813 8459 +6813 6830 +6814 6843 +6814 9222 +6814 8648 +6814 9692 +6814 7816 +6814 9677 +6814 8206 +6814 9622 +6815 7818 +6815 8717 +6815 9870 +6815 9687 +6815 8813 +6816 9330 +6816 9585 +6816 7049 +6816 7790 +6816 8604 +6817 8195 +6817 8177 +6817 8912 +6817 7711 +6818 9089 +6818 8088 +6818 7608 +6818 9531 +6818 8764 +6818 9666 +6818 9709 +6818 9715 +6818 9333 +6818 8575 +6819 8897 +6819 7977 +6819 7762 +6820 7847 +6820 7240 +6820 9279 +6820 8586 +6820 9644 +6820 9357 +6820 8974 +6820 9777 +6820 7175 +6820 9371 +6821 9305 +6821 6875 +6821 9821 +6821 7871 +6822 9280 +6822 7943 +6822 9452 +6822 7726 +6822 8309 +6822 9892 +6823 9728 +6823 8988 +6823 8866 +6823 7337 +6823 8877 +6823 8151 +6823 9719 +6823 8189 +6824 7874 +6824 9691 +6824 9167 +6824 9192 +6824 7958 +6824 7318 +6825 8726 +6825 6865 +6826 9863 +6826 9480 +6826 8843 +6826 9503 +6826 8610 +6826 9891 +6826 9775 +6826 6833 +6826 7355 +6826 8906 +6826 8656 +6826 7413 +6827 6916 +6827 7845 +6827 7143 +6827 8810 +6827 7470 +6827 8393 +6828 7297 +6828 6928 +6828 6839 +6828 7101 +6828 7497 +6828 8141 +6828 8675 +6828 7407 +6828 8309 +6829 8205 +6829 9774 +6829 7196 +6830 7076 +6830 8619 +6830 7565 +6830 7824 +6830 7793 +6830 9938 +6830 8441 +6831 9057 +6831 9093 +6831 7413 +6832 6889 +6832 9389 +6832 7629 +6832 9844 +6832 9557 +6832 7864 +6832 8126 +6833 9761 +6833 9673 +6833 7018 +6833 8226 +6833 8093 +6833 8337 +6833 7988 +6833 8889 +6833 8378 +6833 9051 +6834 9606 +6834 8714 +6834 9744 +6834 9760 +6834 7735 +6834 9925 +6834 8280 +6835 7420 +6835 8172 +6835 8205 +6835 7421 +6835 7453 +6835 8573 +6836 8469 +6836 6943 +6836 9000 +6836 8362 +6836 9007 +6836 7743 +6836 7006 +6836 9721 +6837 8976 +6837 9003 +6837 7984 +6837 9532 +6837 9013 +6837 8132 +6837 9548 +6837 7134 +6837 8550 +6837 7019 +6837 9718 +6838 8066 +6838 7537 +6838 7529 +6838 9293 +6838 8337 +6839 6917 +6839 8984 +6839 7065 +6839 9517 +6839 7899 +6839 8171 +6839 9214 +6840 8353 +6840 9733 +6840 6857 +6840 7517 +6840 7030 +6840 9033 +6841 8514 +6841 7309 +6841 6928 +6841 7507 +6841 8186 +6842 8933 +6842 8428 +6842 9587 +6842 7477 +6842 8598 +6842 9467 +6842 7292 +6843 7261 +6843 9497 +6843 9930 +6844 8896 +6844 7651 +6844 9451 +6844 7359 +6845 7975 +6845 8300 +6845 7991 +6845 9694 +6845 8217 +6846 7037 +6846 8730 +6846 7987 +6846 9014 +6846 7865 +6846 7618 +6846 6882 +6846 7010 +6846 7407 +6846 8569 +6846 8700 +6847 7588 +6847 7590 +6847 7667 +6847 8825 +6847 9912 +6847 9075 +6847 7325 +6848 7432 +6848 7192 +6848 8878 +6848 9427 +6848 7009 +6848 7271 +6848 9939 +6848 7030 +6849 9061 +6849 8871 +6849 8206 +6849 8434 +6849 9011 +6849 6869 +6849 7259 +6850 7907 +6850 8869 +6850 9969 +6850 8712 +6850 8074 +6850 8972 +6850 8173 +6850 7308 +6850 7097 +6850 9245 +6851 7975 +6852 7810 +6852 8466 +6852 9530 +6852 9158 +6852 8648 +6852 8676 +6852 8937 +6852 8916 +6853 9664 +6853 7073 +6853 9289 +6853 8202 +6853 8405 +6853 9663 +6853 7422 +6854 9127 +6854 7993 +6854 6981 +6854 8905 +6854 7372 +6854 6874 +6854 7475 +6854 9511 +6854 9836 +6855 9119 +6855 8879 +6855 9353 +6855 9300 +6855 9465 +6856 8243 +6856 8546 +6856 7204 +6856 9100 +6856 9043 +6856 8492 +6856 7601 +6856 8211 +6856 9045 +6857 9698 +6857 7529 +6857 8267 +6857 8850 +6857 7091 +6857 7034 +6857 8830 +6857 7813 +6858 9376 +6858 9800 +6858 9970 +6858 7864 +6858 7577 +6858 7963 +6859 7041 +6859 9217 +6859 7953 +6859 7585 +6859 9776 +6859 8124 +6859 7869 +6859 8575 +6860 9698 +6860 9876 +6860 9145 +6861 8488 +6861 9645 +6861 9135 +6861 9699 +6861 8940 +6861 8958 +6862 8098 +6862 6990 +6862 8093 +6862 8190 +6862 7257 +6862 9307 +6862 9301 +6863 9873 +6863 7581 +6863 9389 +6863 8893 +6863 9810 +6863 8662 +6863 9815 +6863 8543 +6863 7663 +6863 7743 +6864 7488 +6864 9698 +6864 8259 +6864 7787 +6864 8561 +6864 9859 +6864 7604 +6864 7556 +6864 8959 +6865 9275 +6865 9408 +6865 7133 +6865 8162 +6865 8176 +6866 6944 +6866 9580 +6866 8329 +6866 9047 +6866 8110 +6866 8625 +6866 6969 +6866 9851 +6867 7019 +6867 7404 +6867 8685 +6867 8189 +6868 9061 +6868 7188 +6868 7501 +6868 9613 +6868 7773 +6869 9737 +6869 8917 +6870 8103 +6870 8503 +6870 8249 +6870 7775 +6870 8294 +6870 9067 +6870 9199 +6870 9590 +6870 8952 +6871 9579 +6871 7541 +6871 9499 +6872 9092 +6872 7301 +6872 9837 +6872 8285 +6872 9456 +6872 9363 +6872 8314 +6872 9893 +6873 8873 +6873 8907 +6873 8525 +6873 7127 +6873 8792 +6873 8440 +6873 7935 +6874 8813 +6874 9048 +6874 9046 +6874 9029 +6874 7887 +6874 8191 +6875 9923 +6875 7762 +6875 7738 +6875 8255 +6876 7191 +6876 8730 +6876 9034 +6876 9426 +6876 8920 +6876 9827 +6876 9204 +6877 9875 +6877 9006 +6877 9395 +6877 8656 +6878 7840 +6878 8934 +6878 7981 +6878 7155 +6878 8669 +6879 8206 +6879 9529 +6879 8552 +6880 8899 +6880 7536 +6880 9432 +6880 8157 +6880 9054 +6881 9664 +6881 8591 +6881 9904 +6881 8766 +6881 8512 +6881 7627 +6881 9697 +6881 8060 +6882 7810 +6882 7623 +6882 8144 +6883 9860 +6883 9190 +6883 8452 +6883 6998 +6883 7428 +6884 9712 +6884 8424 +6884 7964 +6884 7056 +6884 8656 +6884 7030 +6884 7655 +6885 9251 +6885 9575 +6885 8467 +6885 7319 +6886 8319 +6886 7458 +6886 7749 +6886 9356 +6886 9422 +6886 8054 +6887 7424 +6887 9927 +6887 8819 +6888 8263 +6888 9198 +6888 8298 +6888 9127 +6888 6989 +6888 8430 +6888 9402 +6889 8978 +6889 9372 +6889 8093 +6889 7719 +6889 7099 +6889 8261 +6889 9415 +6889 9554 +6889 7922 +6890 7712 +6890 9889 +6890 8151 +6891 7922 +6891 7275 +6891 9714 +6891 7348 +6891 6996 +6891 7066 +6891 7754 +6891 7550 +6892 7297 +6892 7938 +6892 9872 +6892 9267 +6892 9148 +6892 8772 +6892 9551 +6892 6999 +6892 8419 +6892 7271 +6892 9063 +6893 9760 +6893 7650 +6893 9450 +6893 6930 +6893 9495 +6894 8868 +6894 8458 +6894 8482 +6894 8047 +6894 8019 +6895 6924 +6895 8213 +6895 6940 +6895 6976 +6895 9548 +6895 7650 +6895 9321 +6895 8426 +6895 9590 +6895 8575 +6896 8475 +6896 8861 +6896 7841 +6896 8234 +6896 8244 +6896 8118 +6896 9025 +6896 7624 +6896 7006 +6897 7235 +6897 9357 +6897 6930 +6897 9237 +6898 7824 +6898 8667 +6898 8782 +6898 8784 +6898 8280 +6898 7643 +6898 9360 +6898 8809 +6898 7799 +6898 9463 +6899 8321 +6899 8199 +6899 9899 +6899 7181 +6899 9201 +6899 7971 +6899 8855 +6899 9337 +6899 9498 +6900 7453 +6900 9509 +6900 7479 +6900 9146 +6901 7073 +6901 7599 +6901 7958 +6901 8666 +6901 9821 +6901 8693 +6902 8192 +6902 7555 +6902 7566 +6902 7683 +6902 8198 +6902 8170 +6902 8939 +6902 7662 +6902 9200 +6902 8701 +6903 7436 +6903 7327 +6903 8525 +6903 9555 +6904 7534 +6904 9781 +6904 9465 +6905 8325 +6905 7959 +6905 9112 +6905 9265 +6905 8758 +6905 9290 +6905 7795 +6905 6908 +6905 7039 +6906 8840 +6906 8329 +6906 7712 +6906 8651 +6906 8671 +6906 7654 +6906 9831 +6906 7021 +6907 8074 +6907 8755 +6907 9485 +6907 9497 +6907 8764 +6907 8261 +6908 9495 +6908 8233 +6908 8491 +6908 9144 +6908 7501 +6908 8785 +6908 9441 +6908 7142 +6908 9578 +6908 9968 +6908 9086 +6909 8219 +6909 7014 +6909 9993 +6909 9535 +6909 7484 +6909 8681 +6909 7039 +6910 7362 +6910 8196 +6910 9928 +6911 9633 +6911 7475 +6911 6933 +6911 7997 +6912 7042 +6912 9235 +6912 9624 +6912 8099 +6912 7357 +6912 8692 +6912 8057 +6913 8449 +6913 7170 +6913 7237 +6913 9257 +6913 8934 +6913 6966 +6913 7471 +6914 9875 +6914 9035 +6914 8656 +6914 9837 +6915 8833 +6915 7846 +6915 9510 +6915 9964 +6915 8212 +6915 8921 +6915 7259 +6916 8576 +6916 8100 +6916 7813 +6916 9563 +6916 8328 +6917 7466 +6917 8555 +6917 8045 +6917 7025 +6918 8348 +6918 7095 +6918 9029 +6918 9810 +6918 8029 +6918 9439 +6918 7266 +6918 8677 +6918 7161 +6919 8038 +6919 7341 +6919 9593 +6919 8634 +6919 7695 +6920 7786 +6920 8766 +6920 9233 +6920 9364 +6920 8247 +6921 9860 +6921 9395 +6921 9822 +6921 8138 +6921 7754 +6921 7764 +6921 8798 +6921 8444 +6922 7077 +6922 9656 +6922 9158 +6922 8531 +6922 9689 +6922 9439 +6922 9065 +6922 7802 +6923 8632 +6923 8426 +6923 9515 +6923 8370 +6923 7379 +6923 8468 +6923 7774 +6924 9738 +6924 8998 +6924 7962 +6924 9065 +6924 9325 +6924 7160 +6924 7422 +6925 9760 +6925 9317 +6925 9260 +6925 9231 +6925 9225 +6925 7716 +6925 8797 +6926 7344 +6926 6929 +6926 9241 +6926 8728 +6927 8800 +6927 9538 +6927 8933 +6927 7017 +6927 7195 +6927 7999 +6928 8418 +6928 7038 +6929 7099 +6929 7579 +6930 7841 +6930 7623 +6930 9672 +6930 9063 +6930 8608 +6930 8542 +6931 9479 +6931 8077 +6931 8979 +6931 7928 +6931 8217 +6931 7731 +6932 9252 +6932 8549 +6932 8555 +6932 7628 +6932 7086 +6932 9869 +6932 8691 +6932 7044 +6932 8229 +6933 9041 +6933 7625 +6933 9607 +6933 9777 +6933 8466 +6933 9807 +6933 9215 +6934 7048 +6934 7449 +6934 7345 +6934 9778 +6934 8757 +6934 9541 +6934 7387 +6934 7022 +6934 8053 +6935 7319 +6935 9641 +6935 6975 +6935 7630 +6935 7384 +6935 8286 +6935 9322 +6935 7037 +6936 8425 +6936 7562 +6936 6992 +6936 9787 +6937 8983 +6937 7448 +6937 9373 +6937 7592 +6937 9458 +6937 9393 +6937 7269 +6937 7268 +6937 9586 +6937 9078 +6937 9978 +6938 7313 +6938 9257 +6938 9394 +6938 7603 +6938 8413 +6938 9588 +6939 9185 +6939 9987 +6939 7476 +6939 9897 +6939 9323 +6939 7663 +6939 9805 +6940 7821 +6940 7077 +6940 8871 +6940 7366 +6940 8519 +6940 9305 +6940 8924 +6940 9126 +6940 9063 +6940 8939 +6941 9218 +6941 7321 +6941 7961 +6941 9561 +6941 9637 +6941 8627 +6941 7122 +6941 8665 +6942 9610 +6942 9356 +6942 7070 +6942 9782 +6942 8646 +6942 8528 +6942 7775 +6942 7014 +6942 7656 +6942 7406 +6942 7283 +6943 9101 +6943 7337 +6943 7084 +6943 9280 +6943 8182 +6943 9039 +6943 8678 +6943 9577 +6944 9874 +6944 7491 +6944 7598 +6944 9138 +6944 9143 +6944 9018 +6944 7363 +6944 9808 +6944 9183 +6944 7162 +6945 8807 +6945 9896 +6945 9319 +6945 9373 +6945 8543 +6946 8470 +6946 7704 +6946 7718 +6946 7730 +6946 7455 +6946 9806 +6946 8285 +6946 8557 +6946 7535 +6946 9078 +6946 7294 +6947 8420 +6947 7191 +6947 8497 +6947 8372 +6947 7801 +6947 7065 +6948 8990 +6948 8364 +6948 7487 +6948 7375 +6948 7513 +6948 7391 +6949 9216 +6949 7178 +6949 9614 +6949 7213 +6949 8625 +6949 6973 +6949 7776 +6950 8351 +6950 8226 +6950 8241 +6950 8264 +6950 8525 +6950 9807 +6950 8797 +6950 9719 +6951 8627 +6951 7332 +6951 8364 +6951 7933 +6951 9619 +6951 8596 +6951 8854 +6951 9759 +6952 9536 +6952 7689 +6952 9580 +6952 8318 +6953 9953 +6953 9995 +6953 9460 +6953 7259 +6953 7736 +6953 7252 +6953 7965 +6954 8905 +6954 9453 +6954 8336 +6954 9503 +6955 7392 +6955 8097 +6955 9314 +6955 8931 +6955 7849 +6955 8116 +6956 9536 +6956 9148 +6957 9174 +6957 8329 +6957 7439 +6957 7989 +6957 8894 +6957 8639 +6957 8129 +6957 8771 +6957 7376 +6957 8022 +6957 8935 +6958 8333 +6958 8853 +6958 8886 +6958 8895 +6959 8832 +6959 9267 +6959 7630 +6959 8915 +6959 8281 +6959 8796 +6959 9082 +6960 8834 +6960 9691 +6960 9256 +6960 7298 +6960 7149 +6960 8019 +6960 7608 +6961 9390 +6961 8855 +6961 8733 +6961 7342 +6961 9395 +6961 7739 +6961 8002 +6961 8771 +6961 8132 +6961 8931 +6961 7021 +6962 7771 +6962 9733 +6962 9992 +6962 8747 +6962 9833 +6962 7453 +6963 8234 +6963 9079 +6963 7121 +6963 6974 +6963 8823 +6963 9625 +6963 9947 +6963 8126 +6964 9991 +6964 9404 +6964 8778 +6964 7756 +6965 9245 +6965 9760 +6965 7844 +6965 8018 +6965 7382 +6965 9959 +6965 9711 +6965 7283 +6966 7207 +6966 7856 +6966 7995 +6966 7616 +6966 8139 +6966 9188 +6967 8300 +6967 7884 +6967 8333 +6967 8070 +6968 9353 +6968 8218 +6968 8482 +6968 7988 +6968 9784 +6968 7358 +6968 8389 +6968 7390 +6969 9796 +6969 8772 +6970 8845 +6970 9231 +6970 7210 +6970 8113 +6970 9674 +6970 6997 +6970 8805 +6970 8042 +6970 9429 +6971 9985 +6971 9253 +6971 8626 +6971 9788 +6971 9406 +6971 9026 +6971 8353 +6971 6997 +6971 9058 +6972 8368 +6972 9606 +6972 7015 +6972 8553 +6972 7918 +6972 9903 +6972 8464 +6972 7785 +6972 7167 +6973 7831 +6973 8872 +6973 9130 +6973 7734 +6973 8525 +6973 9808 +6973 9692 +6973 9453 +6974 9219 +6974 9998 +6974 9761 +6974 7389 +6974 7784 +6974 8043 +6975 8194 +6975 9443 +6975 8436 +6975 9365 +6975 7670 +6975 7803 +6976 7786 +6976 7970 +6976 7731 +6976 8723 +6976 9555 +6977 9487 +6977 8607 +6977 8381 +6977 7363 +6977 7250 +6977 9946 +6977 7013 +6977 7160 +6978 8773 +6978 7624 +6978 7228 +6978 9772 +6978 9453 +6978 7828 +6978 8219 +6978 8229 +6978 7710 +6979 7472 +6979 8560 +6979 8263 +6979 7313 +6979 8082 +6979 7283 +6979 9272 +6979 8719 +6980 7870 +6980 8079 +6980 8891 +6980 9354 +6981 8361 +6981 8011 +6981 8013 +6981 9882 +6981 8827 +6982 7616 +6982 8306 +6982 8528 +6982 9873 +6982 8660 +6982 7868 +6983 8162 +6983 7331 +6983 8308 +6983 9785 +6983 8857 +6984 7468 +6984 9904 +6984 8755 +6984 9280 +6984 8415 +6984 7418 +6985 7117 +6985 9262 +6985 8692 +6985 9468 +6986 9707 +6986 7748 +6986 7851 +6986 9671 +6986 8082 +6986 8179 +6986 9147 +6987 9220 +6987 8216 +6987 9518 +6987 7777 +6987 8525 +6987 9045 +6987 9697 +6987 8802 +6987 7537 +6987 9586 +6988 9942 +6988 7543 +6989 8461 +6989 7587 +6989 8103 +6989 7235 +6989 8388 +6989 9417 +6989 9952 +6989 9191 +6989 7535 +6989 9847 +6990 9604 +6990 8785 +6990 9810 +6990 7507 +6990 8915 +6990 7285 +6991 8999 +6991 7884 +6991 9079 +6991 8444 +6992 9863 +6992 8847 +6992 9260 +6992 7235 +6992 7882 +6992 9420 +6992 8156 +6992 9953 +6992 9322 +6992 7288 +6993 8837 +6993 9415 +6993 8425 +6993 8913 +6993 8598 +6994 9025 +6994 7178 +6994 9272 +6994 7000 +6994 8219 +6995 9154 +6995 7365 +6995 9798 +6995 9711 +6996 9508 +6996 8915 +6996 7924 +6996 8317 +6997 9664 +6997 9924 +6997 9683 +6997 8789 +6997 7903 +6997 8809 +6997 8379 +6998 9382 +6998 8327 +6998 8158 +6998 8620 +6998 9954 +6998 8286 +6998 8727 +6998 9308 +6998 7838 +6999 8599 +7000 7415 +7000 7557 +7000 8395 +7000 9932 +7000 7824 +7000 8376 +7001 9415 +7001 9897 +7001 9164 +7001 7725 +7001 8693 +7001 9943 +7001 9215 +7002 8048 +7002 7586 +7002 8841 +7002 7053 +7003 7040 +7003 9730 +7003 9995 +7003 8205 +7003 8848 +7003 9851 +7003 8253 +7004 8232 +7004 8109 +7004 9648 +7004 7865 +7004 7116 +7004 7247 +7004 8785 +7004 7015 +7005 7432 +7005 7689 +7005 9500 +7005 8484 +7005 7856 +7005 8038 +7005 8829 +7006 8448 +7006 9729 +7006 9120 +7006 8993 +7006 8754 +7006 7154 +7006 7160 +7007 9395 +7007 9273 +7007 8894 +7007 8528 +7007 7636 +7007 8674 +7007 7665 +7007 7290 +7008 9600 +7008 8357 +7008 7591 +7008 9923 +7008 7494 +7008 9324 +7008 9585 +7009 9429 +7009 7392 +7009 7471 +7009 7184 +7009 8498 +7009 9684 +7009 9174 +7009 7439 +7010 7938 +7010 9230 +7010 8985 +7010 7473 +7010 7082 +7010 7100 +7010 9926 +7010 9675 +7010 7287 +7011 9985 +7011 8326 +7011 7017 +7011 7068 +7011 8814 +7011 8336 +7011 9395 +7011 7033 +7011 7936 +7011 8223 +7012 8641 +7012 9037 +7012 9788 +7012 8029 +7013 7049 +7013 9373 +7013 9140 +7013 7882 +7013 9044 +7013 9950 +7014 8722 +7015 9864 +7015 9883 +7015 9438 +7015 7912 +7015 9061 +7016 9248 +7016 9826 +7016 8325 +7016 9672 +7016 7436 +7016 9996 +7016 9704 +7016 9083 +7016 7197 +7017 9018 +7017 8636 +7017 8258 +7017 8662 +7017 7279 +7017 9713 +7017 9470 +7018 9185 +7018 8888 +7018 7736 +7018 7766 +7019 9107 +7019 8104 +7019 9530 +7019 8004 +7019 7022 +7019 7802 +7020 8064 +7020 7044 +7020 9671 +7020 8234 +7020 9261 +7020 8301 +7020 9747 +7021 9729 +7021 9365 +7021 7733 +7021 7353 +7021 7233 +7021 8939 +7021 7156 +7021 8191 +7022 7905 +7022 9384 +7022 8970 +7022 7661 +7022 8528 +7022 8979 +7022 9936 +7023 8657 +7023 7378 +7023 7187 +7023 8571 +7023 9884 +7024 8577 +7024 9845 +7024 7081 +7024 7450 +7025 7207 +7025 9840 +7026 8016 +7026 7731 +7026 7668 +7026 7413 +7026 9492 +7026 8021 +7026 7551 +7027 9498 +7027 8859 +7027 9885 +7027 7456 +7027 7254 +7027 9306 +7027 7290 +7027 8828 +7028 9121 +7028 8483 +7028 8513 +7028 7474 +7028 9785 +7028 9565 +7029 9364 +7029 9116 +7029 7709 +7029 9886 +7029 8513 +7030 7849 +7030 7661 +7030 9839 +7030 8310 +7030 7722 +7031 7460 +7031 8586 +7031 7504 +7031 8438 +7031 7354 +7032 8617 +7032 7241 +7032 9715 +7032 7062 +7032 8553 +7032 8239 +7032 7167 +7033 9528 +7033 8587 +7033 9110 +7033 7400 +7033 9406 +7033 8671 +7034 8032 +7034 8256 +7034 7140 +7034 7538 +7034 9972 +7034 8693 +7035 8708 +7035 9356 +7035 9485 +7035 7960 +7035 7325 +7035 7455 +7035 7202 +7035 8113 +7035 7084 +7035 8501 +7035 7352 +7035 8671 +7035 8254 +7035 9669 +7035 8904 +7035 8556 +7036 8897 +7036 9258 +7036 9964 +7037 8322 +7037 8590 +7037 9422 +7037 8529 +7037 7890 +7037 7546 +7037 8191 +7038 7562 +7038 7586 +7038 8926 +7038 9828 +7038 8946 +7038 8693 +7038 9983 +7039 8243 +7039 9297 +7039 8530 +7039 9716 +7040 8611 +7040 9141 +7040 8571 +7040 8149 +7041 8450 +7041 8844 +7041 9132 +7041 8370 +7041 8015 +7041 8145 +7041 7641 +7042 7818 +7042 8592 +7042 9375 +7042 9553 +7042 7381 +7042 8674 +7043 7887 +7043 9684 +7043 9979 +7043 9822 +7044 8192 +7044 9489 +7044 8356 +7044 9737 +7044 9020 +7044 7499 +7044 7900 +7044 7334 +7044 7157 +7045 8163 +7045 7975 +7045 8361 +7045 9397 +7045 7625 +7045 7769 +7046 7882 +7046 8665 +7046 9435 +7046 9961 +7047 7713 +7047 8828 +7047 7695 +7048 9453 +7048 9233 +7048 9138 +7049 7338 +7050 9514 +7050 8654 +7050 7438 +7051 8387 +7051 7844 +7051 8590 +7051 8307 +7051 7418 +7052 9636 +7052 7589 +7052 7312 +7052 8294 +7052 7261 +7052 9054 +7053 8932 +7053 8330 +7053 9481 +7053 7859 +7054 7189 +7054 8733 +7054 7855 +7054 8241 +7054 7219 +7054 7864 +7054 8760 +7054 7384 +7054 7675 +7055 7152 +7055 7944 +7055 9930 +7055 8820 +7055 7350 +7056 8555 +7056 9548 +7057 8192 +7057 9452 +7057 7244 +7057 7410 +7057 9534 +7057 8766 +7057 7837 +7058 8973 +7058 9744 +7058 7882 +7059 7521 +7059 7798 +7059 7249 +7059 7241 +7059 8042 +7059 8171 +7059 7822 +7059 8944 +7060 8513 +7060 8554 +7060 9335 +7060 7374 +7060 7764 +7060 7926 +7060 7567 +7060 8894 +7061 9600 +7061 7266 +7061 9007 +7061 8017 +7061 9965 +7062 9251 +7062 8048 +7062 8891 +7062 8094 +7063 7939 +7063 9501 +7063 8737 +7063 7487 +7063 8823 +7064 9387 +7064 9205 +7064 9213 +7065 8594 +7065 8005 +7065 9637 +7065 8939 +7065 9082 +7066 8871 +7067 9824 +7067 8098 +7067 8066 +7067 9105 +7067 9944 +7067 9788 +7068 7190 +7068 9116 +7068 8734 +7068 9386 +7068 9675 +7068 9302 +7069 9380 +7069 7342 +7070 7076 +7070 8876 +7070 7257 +7070 7133 +7070 7318 +7071 9795 +7071 7335 +7071 9131 +7071 9682 +7071 8451 +7071 7265 +7071 7512 +7071 7641 +7071 7771 +7072 7424 +7072 8465 +7072 8854 +7072 7713 +7072 8118 +7072 9553 +7073 9347 +7073 7941 +7073 8838 +7073 9367 +7073 8409 +7073 7133 +7074 7947 +7074 8625 +7074 8640 +7074 7640 +7074 8678 +7074 7530 +7075 7582 +7075 8381 +7075 8446 +7076 9745 +7076 9715 +7076 8025 +7076 8120 +7076 9119 +7077 8454 +7077 9359 +7077 7875 +7077 7319 +7077 9413 +7077 8417 +7077 9000 +7078 8736 +7078 9733 +7078 8359 +7078 8937 +7078 8876 +7078 9651 +7078 7889 +7078 9411 +7078 8697 +7079 9318 +7079 8472 +7079 8247 +7079 9400 +7079 7764 +7079 9514 +7080 9992 +7080 7949 +7080 7951 +7080 8084 +7080 7109 +7080 8120 +7080 8393 +7080 7801 +7081 9473 +7081 7559 +7081 8718 +7081 8098 +7081 8632 +7081 7099 +7081 7359 +7082 9905 +7082 7096 +7082 9659 +7082 8163 +7082 8823 +7083 9261 +7083 7482 +7083 7486 +7083 9951 +7084 7913 +7084 7279 +7084 8978 +7084 9885 +7085 7168 +7085 7438 +7085 8946 +7086 7705 +7086 8771 +7086 7261 +7086 8945 +7086 7919 +7087 8837 +7087 7239 +7087 7463 +7087 9104 +7087 8821 +7087 9022 +7088 8354 +7088 7691 +7088 9904 +7088 8212 +7088 7459 +7088 9367 +7088 7620 +7089 7318 +7089 9259 +7089 9262 +7089 9657 +7089 9530 +7089 7106 +7089 9292 +7089 8660 +7089 8028 +7089 9078 +7090 8651 +7090 7248 +7090 9488 +7090 7985 +7090 9621 +7090 9527 +7090 7370 +7090 9949 +7091 8544 +7091 9278 +7092 7821 +7092 7795 +7093 9707 +7093 7795 +7093 9689 +7094 9606 +7094 7214 +7094 8378 +7095 8074 +7095 7741 +7095 8565 +7095 8338 +7096 9728 +7096 7179 +7096 9646 +7096 9055 +7097 8367 +7097 7954 +7097 9204 +7097 8598 +7097 7645 +7098 9637 +7098 9134 +7098 8898 +7098 7491 +7098 8546 +7098 9574 +7099 7558 +7099 8621 +7099 8501 +7099 9052 +7099 8285 +7099 9694 +7099 9956 +7099 8572 +7100 9517 +7100 7233 +7100 8460 +7100 9613 +7100 8913 +7100 7945 +7100 8284 +7101 9520 +7101 8772 +7101 9292 +7101 7583 +7102 7584 +7102 7977 +7102 9356 +7102 8146 +7102 8343 +7102 7545 +7103 9248 +7103 7498 +7103 9932 +7103 8568 +7103 8441 +7103 9567 +7104 9859 +7104 9180 +7104 7462 +7104 7689 +7104 8795 +7104 8508 +7104 8957 +7105 8355 +7105 7274 +7105 7437 +7105 8148 +7105 8181 +7106 7446 +7106 8856 +7106 8410 +7106 9461 +7106 7623 +7106 8784 +7106 8666 +7106 8160 +7107 7409 +7107 7690 +7107 8613 +7108 8842 +7108 9487 +7108 9897 +7108 8756 +7108 8512 +7108 9295 +7108 9308 +7108 7287 +7109 8360 +7109 7625 +7109 7781 +7109 9001 +7110 8343 +7110 8228 +7110 9912 +7110 7617 +7110 9158 +7110 7117 +7111 9668 +7111 8941 +7111 7122 +7111 8405 +7111 9174 +7112 7427 +7112 7212 +7112 9253 +7113 9475 +7113 8301 +7113 9716 +7113 8922 +7113 7789 +7114 7524 +7114 9876 +7115 7266 +7115 9802 +7115 7745 +7115 9163 +7115 9677 +7115 7856 +7115 7669 +7115 8085 +7115 8505 +7115 8475 +7115 8158 +7116 7505 +7116 8592 +7116 8663 +7116 8165 +7117 9120 +7117 9413 +7117 9991 +7118 9559 +7118 9770 +7118 8624 +7118 8663 +7118 9498 +7119 9285 +7119 7176 +7119 9599 +7119 8501 +7120 9378 +7120 8869 +7120 9766 +7120 7999 +7120 8782 +7120 9309 +7121 9527 +7121 9147 +7121 9029 +7121 9427 +7121 9202 +7122 9484 +7122 9755 +7122 7221 +7122 7610 +7122 8134 +7122 8908 +7122 8654 +7122 8810 +7122 8814 +7122 9854 +7123 7436 +7123 8315 +7123 7740 +7124 9190 +7124 9941 +7125 9990 +7125 9215 +7125 8670 +7126 9770 +7126 8427 +7126 9492 +7126 7914 +7127 7587 +7127 9288 +7127 9417 +7127 8145 +7128 8134 +7128 8299 +7128 8077 +7128 8239 +7128 8720 +7128 9860 +7128 8122 +7128 7318 +7129 9000 +7129 8494 +7129 9143 +7129 8090 +7129 8988 +7129 9139 +7129 8959 +7130 7234 +7130 9896 +7130 8724 +7131 7173 +7131 9552 +7131 8356 +7131 8497 +7131 7992 +7131 7284 +7131 7483 +7131 7668 +7132 8076 +7132 9442 +7132 9535 +7132 9794 +7132 8034 +7132 7524 +7133 9951 +7133 9752 +7133 7786 +7133 9290 +7134 7152 +7134 9924 +7134 9609 +7134 8781 +7134 7408 +7134 9214 +7135 9408 +7135 8192 +7135 9322 +7135 9201 +7135 8413 +7135 8180 +7135 9718 +7135 9404 +7136 8716 +7136 8334 +7136 8209 +7136 8239 +7136 9667 +7136 9300 +7136 7137 +7136 8162 +7136 7549 +7137 8961 +7137 9620 +7137 9524 +7137 8386 +7137 8673 +7137 9044 +7137 8943 +7138 8865 +7138 7458 +7138 7191 +7138 7887 +7138 9741 +7139 8109 +7139 9354 +7139 7757 +7139 8569 +7140 9610 +7140 9870 +7140 9370 +7140 7358 +7140 8258 +7140 7877 +7140 7240 +7140 8119 +7141 7811 +7141 7861 +7141 9016 +7141 7485 +7141 7493 +7141 9936 +7142 7728 +7142 7503 +7142 9695 +7142 7915 +7142 8942 +7143 7205 +7143 9255 +7143 7945 +7143 8524 +7143 7741 +7143 9811 +7143 8989 +7144 8219 +7144 8472 +7144 9787 +7144 9052 +7145 9058 +7145 7557 +7145 7858 +7145 9916 +7145 9790 +7146 7205 +7146 7391 +7146 8933 +7146 8183 +7147 8832 +7147 8327 +7147 8714 +7147 9619 +7147 9786 +7147 7619 +7147 9433 +7147 9183 +7147 7799 +7147 7290 +7148 8902 +7148 7362 +7148 8445 +7148 7667 +7148 7572 +7148 7734 +7148 8191 +7148 7805 +7149 8849 +7149 8039 +7149 9610 +7149 9175 +7149 7492 +7149 9167 +7150 7692 +7150 8941 +7150 8146 +7150 7510 +7150 9787 +7151 7627 +7151 9097 +7151 9432 +7151 9816 +7152 7180 +7152 8496 +7152 9263 +7152 7512 +7152 8985 +7152 9115 +7152 9055 +7153 9729 +7153 7893 +7153 9177 +7154 8971 +7154 9268 +7154 9052 +7155 9561 +7155 9542 +7155 7543 +7156 7597 +7156 8222 +7156 8621 +7156 7345 +7156 9141 +7156 7486 +7156 8521 +7156 9176 +7156 7784 +7157 8027 +7157 8804 +7157 8280 +7157 7705 +7157 9885 +7158 9130 +7158 9355 +7158 8002 +7158 7533 +7158 9744 +7159 8100 +7159 9679 +7159 8378 +7160 7691 +7160 9104 +7160 9372 +7160 7976 +7160 7473 +7160 7509 +7160 7644 +7160 7408 +7161 8065 +7161 8993 +7161 9280 +7161 8296 +7161 8692 +7161 8313 +7162 7841 +7162 7843 +7162 8481 +7162 8560 +7162 9521 +7162 7669 +7162 7589 +7163 7683 +7163 7318 +7163 7355 +7163 9741 +7163 9566 +7164 7463 +7164 9610 +7164 7278 +7164 9423 +7164 7762 +7164 7670 +7164 7547 +7165 8103 +7165 9127 +7165 7736 +7165 9944 +7165 8946 +7166 8627 +7166 8417 +7166 8166 +7166 9079 +7166 9212 +7167 9475 +7167 7466 +7167 8673 +7167 9382 +7167 9959 +7168 7750 +7168 9830 +7168 9737 +7168 8465 +7168 8404 +7168 7285 +7169 9380 +7169 9862 +7169 9929 +7169 7499 +7169 8533 +7169 7599 +7169 7450 +7169 8197 +7170 8832 +7170 7342 +7170 9160 +7170 8148 +7171 8487 +7171 8123 +7171 8088 +7171 9956 +7171 9596 +7171 9311 +7172 9697 +7172 8225 +7172 9928 +7172 8038 +7172 9755 +7172 8861 +7173 8747 +7173 9359 +7173 8484 +7173 7759 +7173 7614 +7174 9730 +7174 9436 +7175 9221 +7175 8096 +7175 9392 +7175 7984 +7175 7731 +7175 7391 +7175 7509 +7175 8534 +7175 8976 +7176 9792 +7176 8393 +7176 9298 +7176 8881 +7176 7986 +7176 9816 +7176 9214 +7177 8002 +7177 7256 +7178 9160 +7178 9844 +7179 8677 +7179 8407 +7179 8874 +7180 8230 +7180 7275 +7180 7993 +7180 8366 +7180 8338 +7180 9908 +7180 8574 +7181 9745 +7181 8991 +7181 9381 +7181 7334 +7181 7214 +7181 8121 +7181 8161 +7181 8310 +7182 7808 +7182 7575 +7182 7842 +7182 8615 +7182 9907 +7182 8500 +7182 8412 +7183 7304 +7183 7689 +7183 9116 +7183 8638 +7183 8398 +7183 7911 +7184 9851 +7184 7876 +7184 7815 +7184 7305 +7184 7629 +7184 7682 +7184 8630 +7185 8683 +7185 8916 +7185 7867 +7186 9286 +7186 8619 +7186 8271 +7187 9991 +7187 8412 +7187 8153 +7187 8255 +7188 9509 +7188 8357 +7188 7945 +7188 9685 +7188 7764 +7189 9700 +7189 9189 +7189 9288 +7189 9951 +7190 7248 +7190 7216 +7190 9521 +7190 7931 +7191 8036 +7191 7863 +7191 7611 +7191 9882 +7191 7482 +7191 7493 +7192 9986 +7192 8265 +7192 8109 +7192 9203 +7192 9780 +7192 8026 +7193 7815 +7193 8091 +7193 8386 +7193 9924 +7193 8409 +7193 8667 +7193 7778 +7193 9187 +7193 9197 +7193 7538 +7193 9207 +7194 8747 +7194 9656 +7195 9382 +7195 8796 +7195 9942 +7195 8043 +7196 8064 +7196 8873 +7196 7229 +7197 8946 +7197 9544 +7197 7629 +7197 8077 +7197 7411 +7197 8790 +7197 7832 +7197 9663 +7198 9957 +7198 8879 +7199 8656 +7199 8465 +7199 9254 +7199 9145 +7199 8692 +7199 9114 +7200 7267 +7200 7685 +7200 8919 +7200 8688 +7201 9898 +7201 7944 +7201 8783 +7201 8400 +7201 9432 +7201 9448 +7201 8797 +7202 7592 +7202 8645 +7202 8234 +7202 7715 +7202 8411 +7203 8768 +7203 9425 +7203 8395 +7203 8955 +7203 7345 +7203 7987 +7203 8027 +7203 8670 +7204 8208 +7204 8519 +7204 8024 +7204 8308 +7205 8967 +7205 9731 +7205 9131 +7205 8904 +7205 8525 +7205 8677 +7205 8938 +7205 8433 +7205 9207 +7205 8317 +7206 9600 +7206 8552 +7206 7749 +7206 9414 +7206 7501 +7206 8275 +7206 8547 +7206 8722 +7206 9588 +7206 9978 +7207 8201 +7207 9626 +7207 7583 +7207 8280 +7207 9468 +7208 9896 +7208 7360 +7208 7674 +7208 8170 +7208 9336 +7208 9980 +7209 9794 +7209 8403 +7209 9833 +7209 8450 +7209 8051 +7209 8090 +7210 8218 +7210 8479 +7210 7842 +7210 9511 +7210 7723 +7210 8498 +7210 9924 +7210 7610 +7210 8928 +7210 7789 +7211 7556 +7211 7559 +7211 7252 +7212 8967 +7212 7279 +7212 9928 +7212 9137 +7212 7383 +7213 8288 +7214 9354 +7214 8347 +7214 8252 +7215 9332 +7215 7836 +7215 8829 +7216 8642 +7216 8139 +7216 9956 +7216 7336 +7216 7593 +7216 9625 +7217 9137 +7217 8268 +7217 7882 +7217 9675 +7217 9569 +7217 9199 +7217 9719 +7217 7419 +7218 9702 +7218 7636 +7218 7923 +7218 8479 +7219 7306 +7219 7829 +7219 7330 +7219 9772 +7219 7903 +7219 9190 +7219 8953 +7219 7547 +7219 8700 +7220 8355 +7220 8996 +7220 8302 +7220 8315 +7220 8602 +7221 9092 +7221 8072 +7221 8713 +7221 8738 +7221 8369 +7221 8564 +7222 9961 +7222 7815 +7222 9544 +7222 9784 +7223 7750 +7223 9248 +7223 7500 +7223 7686 +7223 8652 +7223 8469 +7223 7871 +7224 8865 +7224 9819 +7224 9061 +7224 7303 +7224 8370 +7224 9529 +7224 9435 +7224 7582 +7225 9122 +7225 8600 +7225 7481 +7226 7558 +7226 9507 +7226 9700 +7226 7919 +7226 7667 +7227 9441 +7227 9904 +7227 8342 +7227 8477 +7228 8296 +7228 8811 +7228 9832 +7228 7758 +7228 9781 +7228 8022 +7229 8448 +7229 9395 +7229 8910 +7229 9006 +7229 7263 +7230 8470 +7230 9989 +7230 7883 +7230 9330 +7231 8791 +7231 7441 +7231 9695 +7232 8492 +7232 9779 +7232 9557 +7232 7803 +7232 7964 +7232 8542 +7233 7971 +7233 8711 +7233 8520 +7233 8828 +7233 8211 +7234 7395 +7234 9270 +7234 9799 +7234 7307 +7234 8929 +7234 8857 +7234 8314 +7234 9727 +7235 7610 +7235 8411 +7235 8298 +7235 9969 +7235 8656 +7235 9845 +7236 9805 +7236 9206 +7237 9877 +7237 8983 +7237 9117 +7237 8236 +7237 9653 +7237 7738 +7237 9278 +7237 8130 +7237 9284 +7237 7372 +7237 8168 +7238 7416 +7238 7612 +7238 7485 +7239 9153 +7239 7361 +7239 9182 +7239 9193 +7239 7276 +7239 9374 +7239 9449 +7239 7652 +7239 7495 +7239 9886 +7240 9810 +7240 9462 +7240 8122 +7240 8763 +7240 9470 +7241 7492 +7241 9032 +7241 8914 +7241 8925 +7241 7364 +7242 9506 +7242 9899 +7242 9994 +7242 9586 +7243 7969 +7243 9516 +7243 7967 +7244 8740 +7244 9180 +7244 8660 +7244 9430 +7244 8151 +7245 9157 +7245 8016 +7245 8266 +7246 8082 +7246 9273 +7246 7616 +7246 9801 +7246 9043 +7246 9176 +7246 8157 +7246 7670 +7247 8636 +7247 8999 +7247 9074 +7247 7989 +7247 8408 +7247 8050 +7247 7679 +7248 8324 +7248 8231 +7248 7598 +7248 7759 +7249 7432 +7249 9325 +7249 9013 +7250 9357 +7250 7580 +7250 7470 +7250 7878 +7250 9430 +7250 9461 +7252 9089 +7252 7687 +7252 9615 +7252 8479 +7252 8227 +7252 8500 +7252 8185 +7253 9667 +7253 8646 +7253 7406 +7253 8177 +7253 8785 +7253 8343 +7254 9706 +7255 7357 +7255 9556 +7255 7261 +7256 9948 +7256 8330 +7256 9111 +7256 7733 +7256 8060 +7256 9450 +7257 8449 +7257 9781 +7257 9165 +7257 8174 +7257 7800 +7258 9920 +7258 7918 +7258 8835 +7258 9030 +7258 8492 +7258 8654 +7258 7768 +7258 7771 +7258 7869 +7259 8655 +7259 9555 +7259 9429 +7259 8423 +7259 8310 +7260 9130 +7260 7727 +7260 7795 +7260 7508 +7260 9109 +7261 9749 +7261 8641 +7261 9172 +7261 7787 +7261 8687 +7261 9082 +7262 7367 +7262 7868 +7262 9276 +7262 9265 +7262 9205 +7262 8950 +7262 7611 +7262 8924 +7263 9626 +7263 9971 +7263 7738 +7263 9303 +7263 8421 +7263 8084 +7263 8317 +7264 9862 +7264 8541 +7264 9624 +7264 7450 +7265 9280 +7265 8484 +7265 7746 +7265 8146 +7265 8933 +7265 9706 +7265 9717 +7266 8718 +7266 7314 +7266 7962 +7266 7676 +7266 7677 +7267 9228 +7267 9426 +7268 8601 +7268 8106 +7268 8136 +7268 9421 +7268 8041 +7268 8938 +7269 8518 +7269 8435 +7269 9078 +7269 9695 +7270 7520 +7270 8490 +7270 9870 +7270 8720 +7270 8113 +7270 9588 +7271 8327 +7271 9750 +7271 8219 +7271 7589 +7271 7603 +7271 9335 +7272 8038 +7272 9996 +7272 9517 +7272 7983 +7272 9426 +7272 7628 +7272 7422 +7273 9990 +7273 9930 +7273 9295 +7273 7547 +7273 7869 +7274 8337 +7275 9444 +7275 9845 +7275 9277 +7275 7496 +7275 7775 +7276 8394 +7276 9042 +7277 9297 +7277 9969 +7277 9588 +7277 7767 +7277 7946 +7277 8030 +7277 9925 +7278 8642 +7278 8197 +7278 8951 +7278 7838 +7279 9346 +7279 8471 +7279 8363 +7279 9018 +7279 9155 +7279 9680 +7279 8537 +7279 8035 +7279 9445 +7279 9843 +7279 9972 +7279 7548 +7280 9898 +7280 8637 +7280 8385 +7280 9948 +7280 9707 +7280 7416 +7281 8195 +7281 7922 +7281 9948 +7281 8696 +7282 7925 +7283 7640 +7283 8006 +7283 7887 +7283 8381 +7283 8431 +7283 8317 +7284 9872 +7284 7781 +7284 8177 +7284 8332 +7284 8845 +7284 9903 +7284 7606 +7284 8348 +7285 7957 +7285 7319 +7285 8737 +7285 8098 +7285 8503 +7285 8005 +7285 8916 +7286 7847 +7286 8791 +7286 9043 +7286 8349 +7286 7678 +7287 7361 +7287 7794 +7287 8409 +7287 8601 +7288 9896 +7288 7658 +7288 8271 +7288 8944 +7288 8705 +7288 9583 +7289 8996 +7289 9110 +7289 7607 +7289 9427 +7289 9279 +7290 9452 +7290 8075 +7290 8847 +7290 8156 +7290 8637 +7290 8522 +7290 8397 +7290 7890 +7290 9436 +7290 7522 +7290 7526 +7290 9833 +7290 9045 +7291 7374 +7291 9041 +7291 7954 +7292 9748 +7292 8487 +7292 9790 +7292 8231 +7292 9456 +7293 9269 +7293 8888 +7293 9796 +7293 7496 +7293 9037 +7293 8018 +7293 8682 +7293 9967 +7293 7540 +7294 7872 +7294 9491 +7294 7721 +7294 8690 +7294 9662 +7294 9706 +7294 8304 +7294 8442 +7294 7677 +7295 7582 +7295 7972 +7295 8370 +7295 9937 +7295 9171 +7295 7514 +7295 9058 +7295 9148 +7295 9196 +7295 8703 +7296 9489 +7296 8097 +7296 8994 +7296 9789 +7296 8017 +7296 8698 +7296 8430 +7297 8578 +7297 9898 +7297 8176 +7297 9585 +7297 8403 +7297 8694 +7297 7385 +7297 9562 +7297 9914 +7298 7611 +7298 7509 +7298 9688 +7298 9043 +7298 8057 +7299 8455 +7299 7308 +7299 8878 +7299 8480 +7299 8881 +7299 9256 +7299 9515 +7299 9271 +7299 9937 +7299 8791 +7299 9452 +7299 9841 +7300 9186 +7300 9820 +7300 9364 +7300 7545 +7300 9103 +7300 8380 +7300 8477 +7301 9829 +7301 7566 +7301 8656 +7301 8659 +7301 8247 +7301 7930 +7302 8905 +7302 8490 +7302 8626 +7302 9552 +7302 9379 +7302 9366 +7302 8055 +7302 9656 +7302 9695 +7303 9575 +7303 7465 +7303 8494 +7303 9240 +7303 9817 +7304 8199 +7304 7827 +7304 9769 +7304 9543 +7304 7656 +7304 8172 +7305 8673 +7305 7329 +7305 8654 +7305 8731 +7305 8990 +7306 8556 +7306 8464 +7306 9492 +7306 9370 +7306 9247 +7306 7817 +7306 9793 +7306 8826 +7307 9216 +7307 7839 +7307 8103 +7307 8118 +7307 9677 +7307 7394 +7307 7651 +7308 8088 +7308 7964 +7308 9651 +7308 9419 +7308 9796 +7308 8654 +7309 8325 +7309 8101 +7309 7558 +7309 8521 +7309 8914 +7309 7321 +7309 8767 +7310 8227 +7310 8519 +7310 8173 +7310 7985 +7310 9433 +7310 8051 +7310 9171 +7311 7680 +7311 9350 +7311 7698 +7311 8893 +7312 9194 +7312 7702 +7312 8023 +7312 9700 +7312 8996 +7312 9439 +7313 7819 +7313 9503 +7313 7610 +7313 8762 +7313 8319 +7314 8091 +7314 7723 +7314 7393 +7314 9829 +7314 9593 +7315 9478 +7315 7689 +7315 9752 +7315 9389 +7315 8752 +7315 8387 +7315 9054 +7315 9062 +7315 9328 +7316 8173 +7316 9438 +7316 7331 +7316 7678 +7317 7873 +7317 8213 +7317 9404 +7317 9405 +7317 9568 +7317 9924 +7317 7367 +7317 9319 +7318 7939 +7318 9507 +7318 7875 +7318 9669 +7318 7913 +7318 8916 +7318 8445 +7319 9088 +7319 8709 +7319 8847 +7319 9589 +7319 8159 +7319 8177 +7320 8675 +7320 8712 +7320 8585 +7320 7763 +7321 9092 +7321 9221 +7321 8593 +7321 7978 +7321 7650 +7321 9956 +7322 8288 +7322 7571 +7322 9518 +7322 8173 +7322 8883 +7323 8448 +7323 8970 +7323 8589 +7323 8645 +7323 8411 +7323 8171 +7323 8176 +7323 9458 +7323 9469 +7324 9699 +7324 8070 +7324 9042 +7324 9555 +7324 7734 +7325 8136 +7325 8973 +7326 7425 +7326 9501 +7326 9404 +7326 7776 +7326 8167 +7327 9169 +7327 9239 +7327 9645 +7327 9264 +7327 7849 +7327 8183 +7327 9028 +7327 9529 +7328 9487 +7328 8142 +7328 9935 +7328 9427 +7328 8811 +7328 8019 +7328 9467 +7329 8728 +7329 8751 +7329 7885 +7329 9431 +7329 9179 +7329 7787 +7330 8315 +7330 8819 +7330 8660 +7330 7481 +7331 9213 +7331 9327 +7331 8753 +7332 8842 +7332 8004 +7332 8095 +7332 8129 +7332 9824 +7333 8672 +7333 9861 +7333 8508 +7333 9582 +7333 7537 +7333 9974 +7333 7418 +7333 7498 +7334 7685 +7334 9364 +7334 8365 +7334 8636 +7334 9284 +7335 9681 +7336 9113 +7336 9885 +7336 8237 +7336 8366 +7336 7389 +7336 7392 +7336 7407 +7336 9204 +7337 9737 +7337 9968 +7337 9714 +7337 9721 +7337 7674 +7338 9856 +7338 8909 +7338 8151 +7338 8062 +7339 8738 +7339 9019 +7339 8573 +7340 7817 +7340 9482 +7340 8881 +7340 8771 +7340 8885 +7340 9082 +7340 9684 +7341 7589 +7341 8509 +7341 8314 +7341 9637 +7341 8954 +7341 8699 +7342 8852 +7342 8879 +7342 8603 +7342 9900 +7342 9520 +7342 8635 +7342 9790 +7342 7360 +7342 8812 +7343 7906 +7343 9195 +7343 9128 +7343 8329 +7343 7769 +7343 9489 +7344 9991 +7344 8174 +7345 9057 +7345 7396 +7345 7530 +7345 9339 +7345 7451 +7345 9692 +7345 8253 +7345 9535 +7346 7664 +7346 8042 +7346 9358 +7346 9137 +7346 8946 +7346 7946 +7346 8158 +7347 9735 +7347 8253 +7347 8145 +7347 8027 +7347 7522 +7347 8297 +7347 9593 +7348 8070 +7348 7434 +7348 8514 +7348 8262 +7348 7395 +7348 8823 +7348 8318 +7349 8357 +7349 9252 +7349 8432 +7349 7990 +7349 8540 +7350 8361 +7350 7737 +7350 7617 +7350 9766 +7350 8296 +7351 8486 +7351 9363 +7351 9544 +7351 9646 +7352 9377 +7352 9735 +7352 9833 +7352 7661 +7352 7408 +7352 8571 +7352 9141 +7353 9472 +7353 7434 +7353 9143 +7353 7355 +7353 8897 +7353 8335 +7354 7683 +7354 8177 +7354 7761 +7354 8474 +7355 8416 +7355 8123 +7355 8063 +7356 7484 +7356 8401 +7356 7858 +7357 9346 +7357 7405 +7357 9534 +7358 8339 +7358 9883 +7358 7732 +7358 9658 +7358 9031 +7358 8945 +7358 8187 +7358 9084 +7359 7963 +7359 9544 +7359 9687 +7359 9057 +7359 9705 +7359 8312 +7360 8583 +7360 9767 +7360 9559 +7360 8137 +7360 9882 +7361 8782 +7361 9366 +7362 9526 +7362 9668 +7362 9061 +7362 7392 +7362 9199 +7362 8049 +7363 9008 +7363 8511 +7364 8513 +7364 7557 +7364 9766 +7364 8156 +7364 7875 +7364 7642 +7365 7745 +7365 9802 +7365 9776 +7365 8465 +7365 9650 +7365 9628 +7366 9480 +7366 7629 +7366 8050 +7366 9299 +7367 8236 +7367 9945 +7367 8932 +7368 8881 +7368 9140 +7368 8741 +7369 8416 +7369 9119 +7369 7591 +7369 8183 +7369 7870 +7370 9623 +7370 9245 +7370 9419 +7370 8664 +7371 9451 +7371 8209 +7371 8860 +7371 9528 +7371 8121 +7371 7483 +7371 8767 +7371 8896 +7371 9560 +7371 7386 +7371 8031 +7371 7906 +7371 9835 +7372 8257 +7372 9758 +7372 8486 +7372 8752 +7372 8500 +7372 8222 +7372 9793 +7372 9585 +7372 8572 +7373 8685 +7373 9497 +7373 7710 +7373 9635 +7373 8878 +7373 8377 +7373 7630 +7373 7390 +7373 9701 +7374 8068 +7374 8003 +7374 7970 +7374 8745 +7375 9684 +7375 8990 +7375 9663 +7376 7894 +7376 8228 +7376 7455 +7376 8537 +7376 8318 +7377 8332 +7377 8620 +7377 7892 +7377 8149 +7378 8929 +7378 7620 +7378 9053 +7378 8146 +7378 8405 +7379 9956 +7379 7504 +7379 8986 +7379 8574 +7380 9794 +7380 9572 +7380 7429 +7380 9394 +7380 9636 +7380 9836 +7380 9876 +7381 9986 +7381 7734 +7381 7992 +7381 7708 +7381 8163 +7382 9252 +7382 9063 +7382 7792 +7382 8605 +7382 9822 +7383 8588 +7383 8084 +7383 7966 +7383 8243 +7383 8790 +7383 9325 +7383 7421 +7384 9231 +7384 8003 +7384 8792 +7384 7609 +7384 8733 +7384 8989 +7384 8414 +7385 8715 +7385 8235 +7386 9605 +7386 8589 +7386 9116 +7386 9501 +7386 8863 +7386 8481 +7386 8923 +7386 7890 +7387 9288 +7387 8226 +7387 8113 +7387 8507 +7387 7496 +7387 8030 +7387 8185 +7388 7728 +7388 9482 +7388 9488 +7388 7792 +7388 9208 +7389 9793 +7389 7499 +7389 8790 +7389 8941 +7389 9899 +7389 9688 +7389 8984 +7390 8192 +7390 8462 +7390 9251 +7390 9259 +7390 8753 +7390 8370 +7390 8558 +7391 9875 +7391 9135 +7391 9289 +7391 8526 +7391 7503 +7391 9951 +7391 8681 +7391 7539 +7392 9858 +7392 9846 +7392 7536 +7392 8571 +7392 8991 +7393 9605 +7393 7962 +7393 7457 +7393 9842 +7393 9980 +7394 9670 +7394 8969 +7394 9683 +7394 8473 +7394 9286 +7395 8592 +7395 7798 +7395 8599 +7395 7900 +7395 9366 +7396 9185 +7396 8405 +7396 8084 +7396 9269 +7396 8374 +7396 8572 +7396 9054 +7396 7870 +7397 8995 +7397 8907 +7397 9458 +7398 8933 +7398 8585 +7398 9294 +7398 8334 +7398 7568 +7398 8574 +7398 7581 +7399 8149 +7399 7476 +7399 9654 +7399 7610 +7399 8000 +7399 8277 +7399 9146 +7399 9951 +7399 9830 +7399 7929 +7400 8624 +7400 9228 +7400 7573 +7400 8409 +7401 9793 +7401 8868 +7401 8942 +7401 7760 +7401 8823 +7401 8079 +7401 9980 +7401 9168 +7402 7681 +7402 9175 +7402 9104 +7402 7858 +7402 8956 +7403 7841 +7403 9283 +7404 7937 +7404 8146 +7404 7957 +7404 8260 +7404 8411 +7404 8957 +7404 7829 +7405 8000 +7405 8611 +7405 9095 +7405 9328 +7405 9869 +7405 8241 +7406 8317 +7406 9784 +7406 9594 +7406 8478 +7407 8644 +7407 9287 +7407 8027 +7407 9104 +7407 7825 +7407 8754 +7407 8074 +7408 9403 +7408 8019 +7408 9063 +7408 8938 +7409 8450 +7409 8295 +7409 8585 +7410 9856 +7410 8849 +7410 9000 +7410 9895 +7410 8025 +7410 7432 +7411 8679 +7411 8477 +7411 9600 +7411 7861 +7411 7932 +7412 8256 +7412 8609 +7412 8233 +7412 7792 +7412 7416 +7413 9602 +7413 7830 +7413 9239 +7413 8349 +7413 7850 +7413 9279 +7413 8032 +7413 7632 +7414 9665 +7414 7662 +7414 9533 +7414 7572 +7415 8598 +7415 7751 +7415 8618 +7415 9653 +7416 8909 +7416 9457 +7416 9011 +7416 7989 +7416 9145 +7417 9121 +7417 9633 +7417 9035 +7417 7725 +7417 7825 +7417 8821 +7418 8001 +7418 8064 +7418 8849 +7418 9309 +7418 8510 +7419 8628 +7419 9772 +7419 9855 +7420 8577 +7420 7685 +7420 8333 +7420 7716 +7420 8129 +7420 8522 +7420 9807 +7420 9578 +7421 8652 +7421 8786 +7421 8116 +7421 9886 +7421 8308 +7422 9472 +7422 8726 +7422 8156 +7422 7668 +7422 7933 +7423 8032 +7423 9293 +7423 9583 +7423 7510 +7423 7645 +7424 9631 +7425 9828 +7425 9191 +7425 8970 +7425 7885 +7425 9396 +7425 9514 +7426 7817 +7426 7733 +7427 8450 +7427 8962 +7427 8724 +7427 9371 +7427 9760 +7427 9641 +7427 8385 +7427 8926 +7427 9720 +7428 9089 +7428 9259 +7428 8145 +7428 8658 +7428 9622 +7428 8857 +7428 9987 +7428 8474 +7428 8261 +7429 9864 +7429 7978 +7429 9438 +7429 9284 +7429 7870 +7430 9193 +7430 9098 +7430 7906 +7430 7534 +7430 8655 +7430 8823 +7430 9945 +7430 9243 +7430 8351 +7431 8423 +7431 8559 +7431 8239 +7432 8715 +7432 8081 +7432 9767 +7432 8259 +7432 9540 +7433 8850 +7433 9779 +7433 8628 +7433 9916 +7433 9163 +7433 8284 +7433 9342 +7433 8830 +7434 7709 +7434 9141 +7434 7668 +7435 8177 +7435 7702 +7435 8824 +7435 9434 +7435 8571 +7435 9375 +7436 7942 +7436 7532 +7436 9001 +7436 7598 +7436 9019 +7436 9532 +7436 8812 +7437 7566 +7437 7890 +7437 8444 +7437 8312 +7437 8283 +7437 8124 +7438 9346 +7438 8459 +7438 9970 +7438 9016 +7439 9154 +7439 8932 +7439 9016 +7439 9379 +7439 9741 +7439 7543 +7439 7802 +7439 7949 +7439 7711 +7440 8757 +7441 9839 +7441 7988 +7441 7749 +7441 7527 +7441 9071 +7442 8101 +7442 7817 +7442 9778 +7442 8116 +7442 8380 +7443 7940 +7443 8182 +7443 9551 +7444 7664 +7444 8935 +7444 8278 +7445 9164 +7445 7955 +7445 9390 +7445 8762 +7445 8797 +7446 9910 +7446 8632 +7446 8767 +7446 8772 +7446 7759 +7446 8921 +7446 9434 +7447 9581 +7447 8552 +7447 9234 +7447 7767 +7448 9888 +7448 8196 +7448 7942 +7448 8649 +7448 8778 +7448 8654 +7448 9521 +7448 8087 +7448 9728 +7449 9473 +7449 8588 +7449 8085 +7449 9134 +7449 8246 +7449 9408 +7449 9556 +7449 7768 +7450 8516 +7450 9680 +7450 7952 +7451 8096 +7451 7973 +7451 9616 +7451 8116 +7451 9593 +7451 7562 +7452 8192 +7452 9275 +7452 9404 +7452 8394 +7452 7885 +7452 7765 +7452 8667 +7452 7644 +7453 8299 +7453 7666 +7453 8398 +7453 9139 +7453 7546 +7453 7614 +7453 9567 +7454 8266 +7454 9932 +7454 7757 +7454 8935 +7454 8173 +7455 9736 +7455 8311 +7455 8378 +7455 7548 +7456 7970 +7456 9262 +7456 8917 +7457 9070 +7457 7966 +7458 9610 +7458 8203 +7458 9927 +7458 9456 +7458 9124 +7458 7879 +7459 8104 +7459 9628 +7460 8650 +7460 7617 +7460 8360 +7460 7855 +7460 8628 +7461 9804 +7461 9634 +7461 8696 +7461 9514 +7461 8977 +7462 9561 +7462 7778 +7462 8816 +7462 8913 +7462 8246 +7462 8441 +7463 8746 +7463 9134 +7463 8510 +7463 9290 +7463 9208 +7463 8281 +7463 7770 +7463 8028 +7463 9336 +7463 9213 +7464 9345 +7464 9035 +7464 8054 +7465 7726 +7465 8310 +7465 9398 +7466 8591 +7466 9631 +7466 7775 +7466 7996 +7466 9551 +7466 9200 +7466 8057 +7467 8672 +7467 8398 +7467 9934 +7467 7854 +7468 8577 +7468 9353 +7468 7966 +7468 9631 +7468 9018 +7468 9323 +7469 7777 +7469 7693 +7469 9903 +7469 9654 +7470 8493 +7470 9016 +7470 9044 +7470 9198 +7471 9088 +7471 8097 +7471 9741 +7471 9550 +7471 9328 +7472 8449 +7472 7881 +7472 8033 +7472 9971 +7472 9593 +7473 9921 +7473 9353 +7473 8202 +7473 9049 +7473 8714 +7473 9153 +7473 8140 +7473 7629 +7473 9688 +7473 9177 +7473 7520 +7474 7944 +7474 9491 +7474 7873 +7474 8780 +7474 9303 +7474 9954 +7474 8037 +7475 8001 +7475 8940 +7475 7760 +7475 8145 +7475 9692 +7476 9600 +7476 8865 +7476 7587 +7476 7592 +7476 8399 +7476 9553 +7476 7614 +7477 8496 +7477 8341 +7478 9931 +7478 9811 +7478 9896 +7478 9486 +7478 8818 +7478 8019 +7478 8430 +7478 9224 +7478 8634 +7479 7490 +7479 9956 +7479 8487 +7479 7682 +7479 7481 +7480 8547 +7480 9957 +7480 8550 +7480 8279 +7480 8717 +7480 9556 +7480 8249 +7480 9244 +7481 8337 +7481 8987 +7481 7708 +7481 8794 +7481 9245 +7481 8790 +7481 9581 +7481 7918 +7481 8945 +7482 9007 +7482 9552 +7482 9965 +7482 8297 +7482 9885 +7483 9442 +7483 7793 +7483 9449 +7483 9561 +7483 7564 +7483 9215 +7484 7940 +7484 7579 +7484 7965 +7485 9347 +7485 8098 +7485 7552 +7485 9752 +7485 8282 +7486 8422 +7486 9567 +7487 9874 +7487 9820 +7488 9155 +7488 8648 +7488 9043 +7488 7775 +7488 9756 +7488 8766 +7489 8962 +7489 8082 +7489 9585 +7489 8753 +7489 8261 +7489 9938 +7489 9969 +7490 9350 +7490 9601 +7490 9768 +7490 9969 +7491 9733 +7491 9164 +7491 8554 +7491 8172 +7491 9406 +7492 9867 +7492 7720 +7492 8764 +7492 9690 +7492 8847 +7492 8042 +7492 8942 +7493 9478 +7493 9418 +7493 7565 +7493 8155 +7494 7841 +7494 7712 +7494 9802 +7494 7607 +7494 8473 +7495 8416 +7495 8802 +7495 8323 +7495 9655 +7495 8058 +7496 7939 +7496 9514 +7496 8886 +7496 7740 +7496 9406 +7496 8641 +7496 8266 +7496 9467 +7497 8640 +7497 7591 +7497 8430 +7497 8594 +7497 9588 +7497 9844 +7498 8781 +7498 7511 +7498 9341 +7499 9921 +7499 7733 +7499 8722 +7499 7934 +7499 8126 +7500 9447 +7500 8711 +7500 8253 +7500 8148 +7500 7702 +7500 7802 +7500 8820 +7501 8727 +7501 8265 +7501 8042 +7501 9206 +7501 9341 +7502 8454 +7502 8534 +7502 8669 +7502 8417 +7502 9849 +7503 9607 +7503 8604 +7503 8522 +7503 7777 +7503 8813 +7503 8948 +7504 9324 +7504 9009 +7504 7675 +7504 7995 +7505 8083 +7506 9477 +7506 7531 +7506 9901 +7506 8821 +7506 9976 +7506 8799 +7507 8464 +7507 9597 +7508 8835 +7508 7945 +7508 9487 +7508 7732 +7508 8252 +7508 9028 +7508 8157 +7508 7912 +7508 8819 +7508 9588 +7508 9974 +7509 9073 +7509 9515 +7510 9765 +7510 9648 +7510 7601 +7510 9408 +7510 9673 +7510 7774 +7510 8930 +7510 7916 +7510 9715 +7510 8310 +7511 8547 +7511 7850 +7511 8689 +7512 8018 +7512 9012 +7512 7734 +7513 7683 +7513 8044 +7513 8398 +7513 9842 +7513 8921 +7514 7715 +7514 7674 +7515 9038 +7515 9807 +7515 7925 +7516 8809 +7516 9999 +7516 9421 +7516 8142 +7516 8317 +7516 9711 +7516 9434 +7516 9213 +7517 8062 +7517 9796 +7517 8197 +7517 9959 +7517 9993 +7517 8305 +7518 7584 +7518 9702 +7518 9644 +7518 9398 +7519 7783 +7519 8045 +7519 7667 +7519 7732 +7520 8006 +7520 7612 +7520 9929 +7520 9230 +7520 8623 +7520 7859 +7520 9023 +7521 7555 +7521 8361 +7521 8300 +7521 8332 +7521 8413 +7521 9341 +7522 9665 +7522 8118 +7522 9842 +7522 8690 +7523 9516 +7523 9005 +7523 9750 +7524 8590 +7524 9755 +7524 7858 +7524 8139 +7524 8142 +7524 9953 +7524 8806 +7525 8849 +7525 7720 +7525 9563 +7525 9532 +7525 8232 +7525 9203 +7525 7544 +7525 9468 +7526 8257 +7526 9863 +7526 9942 +7526 8117 +7526 8343 +7526 8603 +7526 8061 +7526 7781 +7527 9859 +7527 9231 +7527 8722 +7527 8603 +7527 7707 +7527 7986 +7527 9916 +7527 9791 +7527 8786 +7527 9558 +7527 9561 +7528 9216 +7528 8802 +7528 8132 +7528 7557 +7528 7995 +7529 8103 +7529 9820 +7530 8454 +7530 8227 +7530 9899 +7530 7765 +7530 7926 +7531 7788 +7531 7565 +7531 9237 +7531 8023 +7531 8825 +7532 7554 +7532 8707 +7532 8016 +7532 7664 +7533 7694 +7533 9935 +7534 8113 +7535 7948 +7535 7581 +7535 8885 +7536 8323 +7536 9992 +7536 8595 +7536 7774 +7537 7966 +7537 9106 +7537 9761 +7537 7710 +7537 7656 +7537 9715 +7537 8821 +7537 7806 +7538 8288 +7538 9293 +7538 9979 +7538 9599 +7539 9223 +7539 8521 +7539 8592 +7539 9649 +7539 9897 +7539 9886 +7540 7742 +7541 8199 +7541 9080 +7542 7778 +7542 8486 +7542 8721 +7542 8712 +7542 9081 +7542 7999 +7542 7621 +7543 9388 +7543 8590 +7543 9378 +7543 8251 +7543 8643 +7543 8903 +7543 8440 +7544 9252 +7544 9132 +7544 8526 +7545 8831 +7546 8582 +7546 9868 +7546 8724 +7546 9788 +7546 9690 +7546 9181 +7546 9336 +7547 9988 +7547 8218 +7547 8866 +7547 8245 +7547 9399 +7547 8770 +7547 8682 +7547 8182 +7547 8440 +7548 9479 +7548 8362 +7548 8007 +7548 8086 +7548 8733 +7549 8803 +7549 8702 +7549 8517 +7550 7719 +7550 8598 +7550 8031 +7552 8212 +7552 9437 +7552 8286 +7552 8822 +7553 8293 +7553 9706 +7553 7628 +7553 7725 +7553 8281 +7553 9051 +7554 9743 +7554 7981 +7554 9304 +7555 9955 +7555 8621 +7555 9677 +7555 8829 +7556 7979 +7556 8964 +7556 9487 +7556 9923 +7556 7620 +7556 7635 +7556 9828 +7556 8939 +7557 9962 +7557 7917 +7557 8386 +7557 7643 +7557 9629 +7558 8195 +7558 8602 +7558 9511 +7558 9955 +7559 7662 +7559 8243 +7559 8543 +7560 8362 +7560 8282 +7560 8542 +7561 8805 +7561 8146 +7561 9813 +7561 9072 +7561 8305 +7561 9443 +7562 8483 +7562 8525 +7562 8668 +7562 8055 +7563 8352 +7563 9345 +7563 8582 +7563 8604 +7563 9451 +7563 9421 +7563 9814 +7563 9871 +7563 9374 +7564 7780 +7564 7692 +7564 9932 +7564 8657 +7564 9691 +7565 9830 +7565 9703 +7565 9755 +7565 9564 +7566 9347 +7566 7972 +7566 8390 +7566 7980 +7566 9839 +7566 9395 +7567 8041 +7567 9243 +7568 7712 +7568 8998 +7568 8007 +7568 9142 +7569 8474 +7569 8113 +7569 7748 +7569 9816 +7569 8284 +7569 8106 +7570 9346 +7570 7835 +7570 8987 +7570 8362 +7570 8370 +7570 7646 +7570 9343 +7571 8513 +7571 9643 +7571 9667 +7571 9080 +7572 8321 +7572 7822 +7572 9617 +7572 9404 +7572 7634 +7572 9695 +7573 9155 +7573 8473 +7574 7589 +7574 9847 +7574 8557 +7574 7764 +7574 8534 +7575 8610 +7575 7844 +7575 8829 +7575 8043 +7576 7830 +7576 8218 +7576 9676 +7576 9807 +7576 7766 +7576 9961 +7577 8270 +7577 9874 +7577 9171 +7577 9657 +7578 9376 +7578 9900 +7578 8979 +7578 9495 +7578 8505 +7578 9083 +7579 8903 +7579 7644 +7580 9002 +7580 8615 +7580 8176 +7580 8681 +7580 8600 +7580 8106 +7580 9022 +7580 7973 +7581 9035 +7581 7799 +7582 9754 +7582 9388 +7582 7858 +7582 9584 +7583 9131 +7583 8710 +7583 9264 +7583 9908 +7583 9716 +7584 7892 +7584 8220 +7585 9738 +7585 9995 +7585 8853 +7585 8863 +7585 9389 +7585 8495 +7585 8500 +7585 8756 +7585 9961 +7585 9968 +7586 9859 +7586 9487 +7586 9496 +7586 8740 +7586 9255 +7586 8746 +7586 8619 +7586 9389 +7586 9658 +7586 8564 +7587 7941 +7587 7827 +7587 9401 +7587 7773 +7587 8935 +7588 9051 +7588 8011 +7588 8462 +7588 9108 +7588 8756 +7589 8107 +7589 9619 +7589 9515 +7589 9150 +7589 7892 +7589 8292 +7590 8430 +7590 8793 +7591 8722 +7591 8869 +7591 8752 +7591 9288 +7592 8067 +7592 9165 +7592 9660 +7593 9197 +7593 9183 +7594 8838 +7594 8262 +7594 8685 +7594 9251 +7594 8190 +7595 9185 +7595 8425 +7595 9642 +7595 8449 +7595 7667 +7595 9692 +7595 9406 +7596 9246 +7597 9927 +7597 8236 +7598 9432 +7598 7966 +7598 8506 +7598 9019 +7598 8315 +7599 9894 +7599 8236 +7600 9350 +7600 9630 +7600 7962 +7600 8540 +7600 9151 +7601 7681 +7601 8450 +7601 8897 +7601 8425 +7601 8232 +7601 9589 +7602 8674 +7602 8073 +7602 7690 +7602 8640 +7602 8384 +7603 8726 +7603 8287 +7603 9546 +7603 9804 +7603 9952 +7603 9827 +7603 8563 +7604 9219 +7604 8806 +7604 9575 +7604 9450 +7604 7875 +7604 9848 +7604 8987 +7605 9218 +7605 8355 +7605 9918 +7605 9538 +7605 7991 +7605 8662 +7605 8948 +7606 8331 +7606 9877 +7606 8945 +7606 8138 +7606 7759 +7606 8675 +7607 8836 +7607 9673 +7607 8657 +7607 8803 +7608 7735 +7608 7748 +7608 8824 +7609 8545 +7609 7979 +7609 9071 +7609 9009 +7610 8219 +7610 8111 +7610 8268 +7610 9946 +7610 7777 +7610 7678 +7611 7712 +7611 8869 +7611 8594 +7611 7923 +7612 8642 +7612 8932 +7612 7981 +7612 9424 +7612 9465 +7613 9632 +7613 8295 +7613 9107 +7613 9176 +7614 9002 +7614 9647 +7614 8179 +7614 8599 +7614 8030 +7615 8832 +7615 8436 +7615 8871 +7615 9420 +7615 9774 +7615 9168 +7615 8314 +7615 7774 +7616 8241 +7616 9382 +7616 8893 +7617 9223 +7617 9417 +7617 9548 +7617 7760 +7617 9819 +7618 8469 +7618 9764 +7618 9380 +7619 9281 +7619 7981 +7619 8277 +7620 8041 +7620 8872 +7620 8182 +7620 7833 +7621 8852 +7621 8855 +7621 8100 +7621 7973 +7621 9774 +7621 8751 +7621 9668 +7621 8779 +7621 9913 +7621 9592 +7622 8111 +7622 9174 +7623 7917 +7623 8741 +7623 8526 +7623 8815 +7623 8080 +7624 7878 +7624 9455 +7625 9560 +7625 8897 +7625 8931 +7625 7793 +7625 8732 +7626 8514 +7626 8119 +7626 8889 +7626 9340 +7627 9588 +7627 9828 +7628 8944 +7629 9161 +7629 8074 +7629 8530 +7630 8019 +7630 8979 +7630 9558 +7630 9419 +7630 9212 +7631 8482 +7631 7846 +7631 8049 +7631 9807 +7631 8146 +7631 8285 +7632 7708 +7632 9548 +7632 9648 +7632 8913 +7632 9577 +7633 8608 +7633 8451 +7633 9480 +7633 8280 +7634 9798 +7634 8147 +7635 8962 +7635 9635 +7635 9526 +7635 8317 +7636 8674 +7636 9893 +7636 9852 +7636 9929 +7636 8919 +7636 9040 +7636 8531 +7636 8571 +7637 8468 +7637 8473 +7637 8873 +7637 9668 +7638 9664 +7638 8269 +7638 9263 +7638 7892 +7638 8229 +7639 9634 +7639 7993 +7639 8129 +7640 8993 +7640 8358 +7640 7982 +7640 9292 +7640 8397 +7640 8143 +7640 8034 +7640 8936 +7641 7686 +7641 9523 +7641 7989 +7641 9674 +7641 8532 +7641 9877 +7642 8160 +7642 8870 +7642 9705 +7643 7689 +7643 9552 +7643 8794 +7643 7781 +7643 9713 +7644 8915 +7645 8417 +7645 9070 +7645 7667 +7645 7957 +7646 7680 +7646 9664 +7646 7949 +7646 8227 +7646 7855 +7646 7968 +7647 9953 +7647 8962 +7647 7877 +7647 7768 +7647 8532 +7648 9922 +7648 9880 +7649 9154 +7649 9546 +7649 8899 +7649 8215 +7650 8485 +7650 9022 +7650 8517 +7650 8135 +7650 9801 +7650 9742 +7650 8052 +7650 8446 +7651 7841 +7651 8185 +7652 8972 +7652 9641 +7652 9623 +7652 9528 +7652 7996 +7652 8414 +7653 9701 +7653 7789 +7653 8845 +7653 8152 +7654 9568 +7654 9375 +7655 8807 +7655 9101 +7655 9939 +7655 8791 +7655 9406 +7656 8558 +7656 9617 +7656 9972 +7657 9447 +7657 8398 +7657 9936 +7657 9719 +7657 9244 +7658 8548 +7658 7720 +7659 9486 +7659 9009 +7659 7993 +7659 8216 +7659 9086 +7660 8177 +7660 9645 +7660 8623 +7660 8401 +7660 9044 +7660 8017 +7661 8581 +7661 9005 +7661 8730 +7661 8612 +7661 9200 +7661 8440 +7662 9874 +7662 8989 +7662 8223 +7662 7733 +7662 8034 +7662 8055 +7662 9727 +7663 8687 +7664 8931 +7664 7667 +7664 9107 +7664 9720 +7665 9358 +7665 7967 +7665 7729 +7665 9018 +7665 9915 +7665 8771 +7665 9549 +7665 9555 +7666 8037 +7666 7809 +7666 9586 +7667 9303 +7668 9314 +7668 8879 +7669 8006 +7669 8297 +7669 8461 +7669 8977 +7669 9266 +7670 9920 +7670 8697 +7671 8709 +7671 7955 +7671 9725 +7672 8744 +7672 8397 +7673 8571 +7673 9317 +7673 8078 +7673 9654 +7673 8086 +7673 7711 +7674 9021 +7674 8037 +7674 9190 +7675 9965 +7675 8163 +7676 8848 +7676 9543 +7676 7979 +7676 9517 +7676 8184 +7677 9895 +7677 8073 +7677 8911 +7677 9282 +7677 8542 +7677 7957 +7678 8323 +7678 9763 +7679 8996 +7680 8222 +7680 7703 +7681 9025 +7681 9225 +7681 8528 +7681 9972 +7682 8067 +7682 9228 +7682 9456 +7682 8850 +7683 9147 +7683 8425 +7683 9779 +7683 9109 +7684 9472 +7684 8465 +7684 8377 +7684 9692 +7684 9981 +7685 8295 +7685 7897 +7685 8399 +7686 8483 +7686 9414 +7686 7856 +7686 9296 +7686 8582 +7686 8982 +7686 8485 +7687 7872 +7687 9018 +7687 7775 +7688 9543 +7688 8049 +7688 9594 +7688 9822 +7688 8127 +7689 8231 +7689 9195 +7689 8867 +7689 9957 +7690 8162 +7690 9316 +7690 9378 +7690 7888 +7690 7768 +7691 9479 +7691 9355 +7691 7696 +7691 9176 +7691 9885 +7691 9658 +7691 9052 +7691 8563 +7692 9860 +7692 7837 +7692 8866 +7692 9662 +7692 9803 +7692 8911 +7692 9693 +7692 8055 +7693 9702 +7693 9356 +7693 8526 +7693 8980 +7694 9347 +7694 9575 +7694 7947 +7694 8491 +7695 8491 +7695 8268 +7695 7824 +7695 7832 +7695 9241 +7695 8123 +7695 7916 +7695 8709 +7696 8507 +7696 8012 +7696 7773 +7697 8992 +7697 9160 +7697 9932 +7697 9384 +7697 9047 +7698 8899 +7698 8936 +7698 8088 +7698 9091 +7699 8619 +7699 8070 +7699 9014 +7699 7807 +7699 8394 +7699 9022 +7700 9259 +7700 8461 +7700 9388 +7700 8506 +7701 8006 +7701 7945 +7701 9547 +7701 7952 +7701 8019 +7701 8587 +7703 9472 +7703 8251 +7703 9627 +7703 9805 +7703 8656 +7704 8123 +7704 8612 +7704 8933 +7704 7758 +7704 7967 +7705 8993 +7705 8134 +7705 9865 +7705 8023 +7705 9491 +7705 8152 +7706 9247 +7706 7845 +7706 9001 +7706 7993 +7706 8788 +7706 7898 +7707 8299 +7707 8699 +7707 7743 +7708 9181 +7709 8580 +7709 9021 +7710 7999 +7710 9347 +7710 9131 +7710 7947 +7710 9583 +7710 9688 +7711 8888 +7711 7775 +7712 9369 +7712 8225 +7712 9542 +7712 8239 +7712 9904 +7712 9270 +7712 8379 +7712 9673 +7712 8315 +7713 7804 +7713 8902 +7713 8325 +7713 8597 +7713 9244 +7713 8991 +7714 8992 +7714 7862 +7715 8893 +7715 7882 +7715 8682 +7715 8528 +7715 8261 +7716 9824 +7716 8374 +7716 8868 +7717 7771 +7717 9914 +7717 9343 +7718 7813 +7718 8336 +7718 9049 +7718 9721 +7720 8422 +7720 8367 +7720 9221 +7721 8496 +7721 8246 +7721 9389 +7721 7928 +7722 8487 +7722 9412 +7722 8678 +7722 7786 +7722 9326 +7722 8503 +7722 8978 +7723 9766 +7723 9580 +7723 8931 +7723 8246 +7724 8290 +7724 9956 +7724 8328 +7724 7948 +7724 8620 +7724 8668 +7726 7905 +7726 9579 +7726 7831 +7726 7824 +7726 7858 +7726 7774 +7727 8338 +7727 8486 +7728 8321 +7728 9762 +7728 8739 +7728 7944 +7728 8362 +7729 9061 +7729 9001 +7729 9066 +7729 9882 +7729 8254 +7730 8903 +7730 7982 +7730 9077 +7730 7807 +7731 8902 +7731 8852 +7731 8632 +7732 9373 +7732 9203 +7733 8102 +7733 9767 +7733 8136 +7733 8921 +7734 8674 +7734 9090 +7735 7874 +7735 8041 +7735 9067 +7735 9908 +7735 9828 +7735 9050 +7736 9753 +7736 9370 +7736 8477 +7736 8102 +7736 9136 +7736 8386 +7736 9541 +7736 8173 +7736 8042 +7737 9334 +7737 8840 +7737 7890 +7737 8758 +7738 9605 +7738 9350 +7738 9609 +7738 8799 +7738 9801 +7738 9167 +7738 8025 +7738 8788 +7739 8065 +7739 8102 +7739 9900 +7739 7794 +7739 9554 +7740 9186 +7740 9668 +7740 9980 +7740 9129 +7741 8931 +7741 8325 +7741 9197 +7741 9385 +7742 8674 +7742 8199 +7742 8408 +7742 8664 +7742 7801 +7742 8473 +7743 9031 +7743 9802 +7743 8303 +7744 9749 +7744 8111 +7744 9876 +7744 8629 +7744 7994 +7745 8996 +7745 8022 +7745 9225 +7745 8985 +7745 9144 +7746 8940 +7746 8667 +7747 8519 +7748 8419 +7748 8331 +7748 9804 +7748 7998 +7749 9896 +7749 8074 +7749 9270 +7749 8028 +7750 7841 +7750 9409 +7750 9538 +7750 9309 +7750 9698 +7750 8035 +7751 8517 +7751 8810 +7751 9563 +7751 9674 +7752 9449 +7752 9135 +7752 8211 +7752 7927 +7753 9324 +7753 8660 +7754 9612 +7754 9693 +7754 9716 +7754 8439 +7754 9279 +7755 7815 +7755 9837 +7755 8910 +7755 9028 +7756 9478 +7756 9684 +7756 8911 +7756 9545 +7756 8638 +7757 9927 +7757 9713 +7758 8327 +7758 7825 +7758 9678 +7758 8273 +7758 8282 +7758 7779 +7758 9838 +7759 9011 +7759 7866 +7759 8523 +7759 9441 +7760 9029 +7760 8938 +7760 9326 +7760 8660 +7761 9158 +7761 7853 +7761 9336 +7761 8122 +7762 9746 +7762 9926 +7762 9808 +7762 9939 +7762 9721 +7762 9051 +7763 9184 +7763 9980 +7763 9580 +7763 8184 +7763 7900 +7763 9790 +7764 8457 +7764 9359 +7764 9892 +7764 9782 +7764 8277 +7764 8829 +7765 8979 +7765 8369 +7765 8501 +7765 9948 +7765 7923 +7765 8315 +7766 9479 +7766 9487 +7766 9689 +7766 9340 +7767 9003 +7767 9134 +7767 9595 +7767 9468 +7768 9601 +7768 9486 +7768 8480 +7768 8633 +7768 8252 +7768 9154 +7768 7882 +7768 9294 +7768 8408 +7768 7899 +7769 9909 +7769 7865 +7769 9034 +7769 8791 +7769 7798 +7769 9592 +7769 9044 +7770 9603 +7770 7817 +7770 8491 +7771 9211 +7771 8779 +7771 8526 +7771 8125 +7772 7912 +7773 9241 +7773 9081 +7774 7982 +7774 9297 +7774 9682 +7774 8562 +7774 7799 +7775 9100 +7775 8685 +7775 7996 +7775 8533 +7775 9046 +7775 9305 +7776 8553 +7776 9658 +7777 8892 +7778 8844 +7778 7958 +7778 8486 +7778 9683 +7778 8232 +7778 8573 +7779 9731 +7779 8665 +7779 8684 +7779 9108 +7780 9165 +7780 8174 +7780 8463 +7780 9769 +7781 8578 +7781 9798 +7781 8014 +7781 8791 +7781 8660 +7782 8291 +7782 8773 +7782 8778 +7782 9487 +7782 9491 +7783 8576 +7783 9606 +7783 8200 +7783 9363 +7783 8099 +7783 8652 +7783 9592 +7783 8827 +7784 9730 +7784 8072 +7784 8979 +7784 8003 +7784 8161 +7784 8167 +7784 9363 +7785 9097 +7785 9219 +7785 9620 +7785 9120 +7785 9275 +7785 9180 +7786 9354 +7786 8103 +7786 9153 +7786 9415 +7786 9168 +7786 9953 +7787 9901 +7787 8110 +7787 8368 +7787 8667 +7788 8930 +7788 8261 +7788 9324 +7788 8975 +7788 8136 +7788 8499 +7788 9465 +7788 9053 +7789 9272 +7789 9150 +7790 9221 +7790 7842 +7790 8508 +7790 8916 +7790 8801 +7790 9976 +7791 9738 +7791 9404 +7792 8462 +7792 9517 +7792 8024 +7792 8218 +7792 9429 +7792 8792 +7793 8072 +7793 8738 +7793 9816 +7793 9053 +7794 9764 +7794 8470 +7795 8584 +7795 8233 +7795 8557 +7796 9952 +7796 9231 +7796 9996 +7796 7995 +7797 8356 +7797 8774 +7797 8007 +7797 8469 +7798 9478 +7798 8714 +7798 9882 +7798 8771 +7798 9571 +7798 7800 +7799 8705 +7799 8450 +7799 8066 +7799 9880 +7799 9041 +7799 9719 +7800 9098 +7800 8466 +7800 7837 +7800 8970 +7800 9976 +7801 8331 +7801 9613 +7801 8593 +7801 9646 +7801 7896 +7801 8018 +7801 9585 +7802 9633 +7802 8559 +7802 9333 +7803 9836 +7803 9548 +7803 9261 +7803 7857 +7803 7804 +7804 9755 +7804 8220 +7804 7851 +7804 9139 +7804 7915 +7805 9617 +7805 9567 +7806 9577 +7806 8877 +7806 9296 +7806 9874 +7806 8475 +7807 8593 +7807 9123 +7807 8507 +7807 8932 +7808 9398 +7808 9240 +7808 8190 +7809 8602 +7809 8126 +7810 9410 +7810 8786 +7810 9078 +7810 9922 +7810 9156 +7811 9088 +7811 8581 +7811 9777 +7811 9043 +7812 7814 +7812 7904 +7812 9538 +7812 8032 +7812 9064 +7813 8508 +7813 7833 +7813 8997 +7813 8878 +7813 9407 +7813 8133 +7813 9671 +7813 8869 +7814 7904 +7814 9539 +7814 8617 +7814 9392 +7814 8950 +7814 8922 +7814 8061 +7815 8071 +7815 9868 +7815 9487 +7815 8858 +7815 7848 +7815 8390 +7816 7975 +7816 9490 +7816 8301 +7816 9970 +7817 8561 +7817 7899 +7817 9456 +7818 9025 +7818 9092 +7818 8870 +7818 9449 +7818 8114 +7818 9395 +7819 9313 +7819 9990 +7819 9450 +7819 8858 +7819 7869 +7820 9544 +7820 8866 +7820 9412 +7820 9036 +7820 9640 +7820 8363 +7820 8728 +7820 8381 +7821 8412 +7821 8034 +7821 9578 +7822 9605 +7822 9882 +7822 9541 +7822 8519 +7822 9160 +7822 9955 +7822 9457 +7823 7904 +7823 9478 +7823 7981 +7823 9777 +7823 8438 +7823 9275 +7824 8968 +7824 8219 +7824 8891 +7824 8527 +7824 8338 +7825 8498 +7825 8138 +7825 9191 +7825 9969 +7825 9587 +7825 8785 +7826 9951 +7826 9067 +7826 9127 +7826 9472 +7826 8630 +7826 8282 +7827 9733 +7827 8100 +7827 9351 +7827 8912 +7827 9814 +7827 8154 +7828 9750 +7828 8337 +7828 9510 +7828 8120 +7828 8642 +7828 9715 +7829 8460 +7829 8762 +7829 8907 +7829 9424 +7829 9174 +7829 9183 +7830 9872 +7830 8210 +7830 9319 +7830 8793 +7830 8181 +7830 8317 +7831 9116 +7831 8872 +7831 8777 +7831 8778 +7831 8539 +7832 8590 +7832 8688 +7832 8841 +7832 9939 +7832 8042 +7833 9670 +7833 8174 +7833 8141 +7834 8932 +7834 8454 +7834 8871 +7834 8621 +7834 8014 +7834 8752 +7834 9434 +7835 8868 +7835 7841 +7835 7895 +7835 8602 +7835 9438 +7835 9311 +7836 9152 +7836 8143 +7836 9498 +7837 8653 +7837 9369 +7838 9611 +7838 9935 +7838 8912 +7838 8769 +7839 9513 +7840 8508 +7840 9111 +7840 9593 +7840 9530 +7841 9219 +7841 8617 +7841 9909 +7842 8961 +7842 7942 +7842 9380 +7842 9692 +7844 8623 +7844 9243 +7844 8765 +7844 9558 +7845 9863 +7845 7850 +7845 9573 +7845 9576 +7845 8177 +7846 9862 +7846 8726 +7846 8375 +7846 9032 +7847 9397 +7847 8149 +7848 9176 +7848 9733 +7848 9779 +7848 9507 +7849 9417 +7849 8399 +7849 8498 +7849 8661 +7849 9503 +7849 9693 +7850 9408 +7850 9651 +7850 7951 +7850 9086 +7851 8715 +7851 9258 +7851 8794 +7851 9189 +7851 8297 +7851 8050 +7852 9478 +7852 9460 +7852 8478 +7852 9535 +7853 9999 +7853 9529 +7853 9149 +7853 9173 +7853 8433 +7853 8826 +7854 8466 +7854 9063 +7854 8159 +7855 7898 +7855 7941 +7856 8717 +7856 8501 +7856 9533 +7856 9938 +7856 8534 +7856 8941 +7857 9249 +7857 8454 +7857 9383 +7857 9783 +7858 8494 +7858 9001 +7858 8369 +7858 9788 +7858 9796 +7858 8039 +7859 8457 +7859 9242 +7859 9139 +7859 7908 +7859 9106 +7859 8830 +7860 8770 +7860 7933 +7861 8188 +7861 9166 +7861 9844 +7861 9783 +7862 8950 +7863 8712 +7863 7956 +7863 8474 +7863 8498 +7863 8883 +7863 8119 +7863 9813 +7864 9355 +7864 8004 +7864 9116 +7864 8434 +7864 9650 +7864 9547 +7864 8412 +7864 9843 +7865 8720 +7865 9107 +7865 8257 +7865 9794 +7865 9804 +7865 9431 +7865 8286 +7865 8807 +7865 8425 +7865 8382 +7865 8062 +7866 8542 +7866 9348 +7866 9803 +7866 9780 +7866 9049 +7867 9442 +7867 8403 +7867 8687 +7868 8858 +7868 7963 +7868 9936 +7868 8824 +7869 8248 +7869 8518 +7869 9436 +7869 8934 +7869 8936 +7869 8043 +7869 9460 +7870 9344 +7870 9613 +7870 8726 +7870 9803 +7871 9088 +7871 9664 +7871 8803 +7871 8534 +7871 9827 +7872 9259 +7872 8178 +7873 8394 +7873 8368 +7873 8274 +7874 9230 +7874 9505 +7874 9814 +7875 9372 +7875 9244 +7875 9964 +7875 9966 +7875 9981 +7875 8959 +7876 9681 +7876 7890 +7877 9375 +7877 8744 +7877 8797 +7877 8840 +7877 9091 +7877 8244 +7878 9382 +7878 8041 +7878 9763 +7879 8463 +7880 9387 +7880 8878 +7880 8564 +7880 8399 +7881 7936 +7881 8994 +7881 8826 +7882 9122 +7882 8999 +7882 9287 +7882 8877 +7882 9144 +7882 8894 +7882 9024 +7882 9157 +7882 8902 +7882 9932 +7882 8691 +7882 8308 +7882 8701 +7883 9675 +7883 8344 +7883 9464 +7884 9137 +7884 9549 +7884 9171 +7885 7938 +7885 7944 +7885 8622 +7885 9680 +7885 8721 +7885 8816 +7885 9073 +7885 8313 +7886 8502 +7886 8206 +7886 9327 +7887 8587 +7887 8195 +7887 9394 +7887 9662 +7887 8033 +7887 9185 +7887 8191 +7888 9371 +7888 8239 +7888 8782 +7888 9305 +7888 8959 +7889 9468 +7889 8178 +7890 8332 +7890 7959 +7891 8385 +7891 8897 +7891 8450 +7891 8679 +7892 8478 +7892 8234 +7892 9145 +7892 9561 +7892 9318 +7892 9326 +7892 9725 +7893 9347 +7893 8010 +7893 9943 +7893 9817 +7893 8567 +7894 9952 +7894 8688 +7894 9509 +7894 8296 +7894 9657 +7894 8944 +7894 8033 +7895 7914 +7895 8699 +7895 9116 +7895 9123 +7895 8984 +7895 9119 +7896 8969 +7896 9073 +7896 9011 +7897 9794 +7897 9828 +7897 8966 +7897 9706 +7897 9425 +7897 8278 +7897 9913 +7898 8353 +7898 9474 +7898 9391 +7898 8431 +7898 8983 +7898 9233 +7899 8330 +7899 9456 +7899 8713 +7899 9110 +7899 9845 +7899 9781 +7899 8186 +7899 9434 +7899 9598 +7900 8224 +7900 8624 +7900 9059 +7900 9669 +7900 8711 +7901 8683 +7901 8296 +7901 9231 +7902 9123 +7902 8129 +7902 9339 +7902 8515 +7902 9140 +7903 9089 +7903 9738 +7903 9840 +7903 8816 +7904 8518 +7904 8553 +7904 8847 +7904 9042 +7904 8217 +7904 8246 +7905 8181 +7906 8263 +7906 8424 +7906 9177 +7907 9154 +7907 9378 +7907 7974 +7907 8713 +7907 9634 +7907 8783 +7907 9978 +7907 8036 +7908 9294 +7908 8431 +7908 8150 +7908 7963 +7909 9879 +7909 8862 +7909 8417 +7909 8806 +7909 8181 +7910 8484 +7910 8141 +7910 8565 +7910 9914 +7910 9053 +7911 8198 +7911 8309 +7912 9734 +7912 8097 +7912 8393 +7912 8974 +7912 9128 +7913 7969 +7913 9499 +7913 8420 +7913 8274 +7913 9437 +7913 9970 +7913 8368 +7913 9011 +7914 8583 +7914 8946 +7914 8852 +7914 9669 +7915 9440 +7916 8578 +7916 9230 +7916 8175 +7916 9590 +7916 8122 +7917 9899 +7917 9677 +7917 9807 +7918 9571 +7918 9945 +7918 8019 +7919 9447 +7920 9861 +7920 9734 +7920 9357 +7920 8328 +7920 9623 +7920 9949 +7921 9440 +7921 8846 +7921 9427 +7921 8415 +7922 8841 +7923 9316 +7923 9808 +7923 8987 +7924 9179 +7924 8167 +7924 9868 +7924 8043 +7924 9900 +7925 9794 +7925 8262 +7925 8295 +7926 8142 +7926 9019 +7927 9798 +7927 9665 +7927 9535 +7928 9890 +7928 9187 +7928 9850 +7929 8140 +7929 8173 +7929 9175 +7929 8537 +7930 8496 +7930 9564 +7931 9607 +7931 8213 +7931 9751 +7931 8877 +7931 9018 +7931 9821 +7931 9963 +7931 9202 +7932 8803 +7932 9604 +7932 9861 +7932 8297 +7932 8751 +7932 9605 +7933 9962 +7933 9995 +7933 9389 +7933 8152 +7934 9067 +7934 8045 +7934 7985 +7935 8257 +7935 9874 +7936 9472 +7936 8625 +7936 9672 +7936 9034 +7936 8667 +7937 9025 +7937 9117 +7937 9400 +7937 9049 +7937 8477 +7938 9699 +7938 8966 +7938 9289 +7938 9726 +7938 8758 +7938 9276 +7938 9023 +7939 7952 +7939 7954 +7939 9659 +7939 8786 +7939 9818 +7940 9861 +7940 8871 +7940 9647 +7940 9274 +7940 8387 +7940 9170 +7941 9657 +7941 9434 +7941 8222 +7942 8012 +7942 9759 +7943 9216 +7943 9615 +7943 8356 +7943 9611 +7943 8772 +7943 9336 +7943 8047 +7943 9592 +7943 9338 +7944 8450 +7944 9780 +7944 8952 +7944 9051 +7944 8636 +7945 9984 +7945 7946 +7945 9250 +7945 9380 +7945 8489 +7945 8884 +7945 9564 +7945 8696 +7946 8579 +7946 8357 +7946 7998 +7946 8768 +7946 8516 +7946 8691 +7947 9384 +7947 9197 +7947 9902 +7947 9303 +7947 8313 +7948 8577 +7948 8970 +7948 9492 +7948 8985 +7948 8091 +7948 8878 +7948 9026 +7948 8227 +7948 9556 +7948 8311 +7949 9244 +7949 8604 +7949 8116 +7949 8259 +7950 9139 +7951 8071 +7951 9360 +7951 9396 +7951 8663 +7951 9954 +7951 9471 +7952 8938 +7952 9147 +7953 8579 +7953 8718 +7953 8878 +7953 9378 +7953 9134 +7953 9138 +7953 9144 +7953 8772 +7953 8261 +7953 8393 +7953 9811 +7953 8405 +7953 9695 +7953 9209 +7954 9732 +7955 8252 +7955 8786 +7956 8842 +7956 9326 +7956 8062 +7957 9991 +7957 9367 +7957 8864 +7957 9379 +7957 9050 +7958 9642 +7958 8689 +7958 8061 +7959 8450 +7959 8363 +7960 8749 +7960 9137 +7960 8903 +7960 8140 +7960 8288 +7961 9622 +7961 9006 +7961 9651 +7961 8158 +7961 8696 +7961 9756 +7962 9909 +7962 9277 +7962 9087 +7963 9911 +7963 9657 +7963 8027 +7963 9697 +7963 8034 +7963 9715 +7964 9364 +7964 9764 +7964 9020 +7964 8795 +7964 8286 +7964 9577 +7965 9368 +7965 8460 +7965 9532 +7965 9718 +7966 9768 +7966 9778 +7966 9042 +7966 8277 +7966 8677 +7966 9186 +7966 8570 +7967 8128 +7967 9345 +7967 8449 +7967 8675 +7967 8348 +7968 9760 +7968 8646 +7968 9409 +7968 9908 +7968 8415 +7969 9355 +7969 8310 +7970 9553 +7970 8844 +7970 8529 +7970 8955 +7971 9874 +7971 8761 +7971 8264 +7971 8905 +7971 9826 +7971 9962 +7972 9621 +7972 8214 +7972 8344 +7972 9117 +7973 9056 +7973 8176 +7973 9426 +7974 8353 +7974 8135 +7974 9738 +7974 9260 +7974 9885 +7974 8819 +7974 8622 +7974 9789 +7974 8668 +7974 9565 +7975 9452 +7975 8946 +7975 9658 +7975 9701 +7976 9492 +7976 9511 +7976 9173 +7976 9814 +7977 9120 +7977 8745 +7977 9637 +7977 9329 +7977 8842 +7977 8508 +7977 9724 +7978 9985 +7978 8011 +7978 8347 +7978 8568 +7978 8764 +7978 9375 +7979 8391 +7980 8679 +7980 9669 +7980 9008 +7980 8316 +7980 8671 +7981 9956 +7981 9929 +7981 9540 +7982 8867 +7982 8902 +7982 9249 +7982 9581 +7983 9792 +7983 8487 +7983 8043 +7983 9170 +7983 8594 +7984 9174 +7984 9224 +7984 8403 +7984 9319 +7984 9978 +7984 9087 +7985 8680 +7985 9173 +7985 9887 +7986 9790 +7986 9324 +7986 9214 +7987 8176 +7987 8700 +7988 8241 +7988 8268 +7988 9013 +7988 9983 +7989 8078 +7989 9497 +7989 9909 +7989 9023 +7989 9165 +7989 8923 +7989 8828 +7990 8110 +7990 9551 +7991 9395 +7991 8500 +7991 9562 +7991 9181 +7992 9750 +7993 9989 +7993 8648 +7993 9838 +7994 9156 +7994 8380 +7994 8606 +7995 8313 +7995 9296 +7995 8147 +7996 9147 +7996 9061 +7996 9133 +7996 8630 +7996 9175 +7996 8202 +7997 8984 +7997 9821 +7998 8487 +7998 8088 +7998 9275 +7999 8333 +8000 8640 +8000 9687 +8000 9993 +8000 9134 +8000 9443 +8000 8373 +8000 9688 +8001 9185 +8001 8779 +8001 8722 +8001 8286 +8001 9487 +8001 9690 +8001 8542 +8002 9008 +8002 8049 +8002 8285 +8002 9509 +8003 8717 +8003 8014 +8004 8224 +8004 8617 +8004 8700 +8005 8222 +8005 8485 +8005 9666 +8005 9551 +8006 8761 +8006 8924 +8007 9411 +8007 8595 +8007 9942 +8007 9381 +8008 9481 +8008 9662 +8008 8769 +8008 8568 +8009 8482 +8009 9458 +8009 8504 +8010 9910 +8010 9229 +8010 8879 +8010 9688 +8010 9014 +8010 8873 +8011 8965 +8011 9752 +8011 9379 +8011 8367 +8011 8142 +8011 9587 +8011 9213 +8012 8811 +8012 9033 +8012 9464 +8012 8265 +8012 8231 +8013 8796 +8014 9386 +8014 9073 +8014 9080 +8014 9503 +8015 8465 +8015 9711 +8015 9885 +8016 8429 +8016 8561 +8016 9978 +8016 9435 +8017 8841 +8017 8982 +8017 9138 +8017 9330 +8017 8440 +8018 9515 +8018 9104 +8018 9076 +8019 8304 +8019 9086 +8020 9382 +8020 9740 +8020 9010 +8020 9114 +8021 8024 +8021 8825 +8022 9995 +8022 8464 +8022 9021 +8022 8255 +8022 9161 +8022 9047 +8022 9304 +8022 8671 +8022 8703 +8023 9991 +8023 8850 +8023 9899 +8023 8260 +8023 9544 +8023 9082 +8023 9572 +8023 9833 +8023 9078 +8024 8747 +8024 9668 +8024 8562 +8024 8100 +8025 8870 +8025 8508 +8025 9739 +8025 8045 +8025 8669 +8026 8768 +8026 9070 +8026 9231 +8027 9295 +8028 8746 +8028 8345 +8028 8042 +8029 9857 +8029 9762 +8029 8112 +8029 8373 +8029 8610 +8029 9570 +8029 8175 +8029 8561 +8029 8829 +8030 9825 +8030 8612 +8030 8848 +8031 9062 +8031 9711 +8031 9905 +8031 9467 +8032 8737 +8032 8444 +8032 9625 +8033 8576 +8033 8577 +8033 9610 +8033 8108 +8034 9734 +8034 9213 +8034 8824 +8034 9432 +8034 8382 +8035 9198 +8035 9240 +8036 8512 +8036 8513 +8036 9415 +8036 9261 +8036 8571 +8036 9375 +8037 9168 +8037 9003 +8037 8218 +8037 8446 +8038 9536 +8038 8163 +8038 9074 +8038 8088 +8038 8126 +8039 8726 +8039 8542 +8039 8168 +8040 9008 +8040 9371 +8040 9584 +8040 8602 +8041 8249 +8041 8547 +8041 9597 +8042 8307 +8042 9161 +8042 9722 +8043 9617 +8043 8864 +8043 8238 +8043 9307 +8043 9595 +8044 9478 +8044 9788 +8045 8829 +8046 9957 +8046 9524 +8046 8901 +8046 9821 +8046 9210 +8047 8712 +8048 9885 +8048 9264 +8048 8373 +8048 9530 +8048 8266 +8049 9500 +8050 9994 +8050 8208 +8050 9001 +8050 8879 +8050 8897 +8050 8660 +8050 9972 +8050 8951 +8051 8228 +8051 9200 +8052 9769 +8052 9176 +8054 8866 +8054 9702 +8054 9122 +8055 8684 +8055 8848 +8055 8102 +8055 8799 +8055 9580 +8055 8955 +8055 8317 +8056 9066 +8056 9266 +8056 9879 +8056 8376 +8057 9262 +8057 9588 +8057 9463 +8057 8511 +8058 8680 +8058 9811 +8058 9395 +8058 8967 +8058 8766 +8059 8612 +8059 9926 +8059 8519 +8059 8269 +8059 8401 +8059 8413 +8060 9929 +8060 9946 +8060 8667 +8060 8937 +8061 9505 +8061 8488 +8061 9456 +8062 9500 +8062 8625 +8062 8251 +8062 9149 +8062 9790 +8062 8910 +8063 8289 +8063 9859 +8063 8188 +8063 8238 +8063 9304 +8063 9753 +8064 8491 +8064 9807 +8064 8593 +8064 9068 +8065 8933 +8065 8287 +8065 8524 +8065 8498 +8065 9419 +8065 8927 +8066 9276 +8067 8950 +8068 9478 +8068 8079 +8068 8248 +8068 9651 +8068 8405 +8068 8351 +8069 9218 +8069 9499 +8069 9901 +8069 8263 +8070 8350 +8070 8517 +8070 8758 +8070 8661 +8070 8943 +8070 8818 +8071 8231 +8071 8978 +8071 8110 +8071 9138 +8071 8247 +8071 9677 +8072 8294 +8072 8572 +8073 8743 +8073 9802 +8073 9481 +8073 9533 +8074 9513 +8074 8234 +8074 8674 +8075 8708 +8075 8914 +8075 8982 +8075 8444 +8076 8833 +8076 9732 +8076 8838 +8076 8257 +8076 8907 +8077 9350 +8077 8738 +8077 8521 +8077 9531 +8078 8726 +8078 8465 +8078 8471 +8078 8221 +8078 8372 +8078 8766 +8078 9152 +8078 9665 +8078 8394 +8078 9292 +8078 9556 +8079 8256 +8079 8177 +8079 8676 +8079 8439 +8080 9059 +8081 9237 +8081 8486 +8081 8244 +8081 9572 +8082 9029 +8082 8811 +8082 9069 +8082 8432 +8083 9519 +8083 8724 +8083 8915 +8083 9812 +8084 9098 +8084 9235 +8084 8473 +8084 8242 +8084 9273 +8084 8647 +8084 9163 +8084 9555 +8085 9874 +8085 8608 +8085 9072 +8085 8361 +8085 9009 +8085 9157 +8085 9943 +8086 8699 +8086 9126 +8086 8622 +8086 8656 +8086 8437 +8087 9429 +8087 8932 +8087 8756 +8087 9653 +8087 8568 +8088 9880 +8088 9541 +8088 9805 +8088 8403 +8088 9072 +8088 8309 +8089 9762 +8089 9812 +8089 8606 +8090 8672 +8090 9218 +8090 9099 +8090 9212 +8090 8944 +8090 8627 +8090 9560 +8090 9084 +8091 8451 +8091 9522 +8092 9957 +8092 8909 +8092 9230 +8092 8119 +8093 8740 +8093 8656 +8093 8121 +8093 9882 +8094 8518 +8094 8525 +8094 9336 +8094 9211 +8095 9792 +8095 9626 +8095 9504 +8095 8102 +8095 8270 +8095 8184 +8096 9119 +8096 8490 +8096 9018 +8096 9285 +8096 9808 +8097 9102 +8098 8973 +8098 8985 +8098 8488 +8098 9169 +8098 8142 +8099 9711 +8099 8144 +8099 8120 +8099 9108 +8099 8977 +8100 8357 +8100 9254 +8100 8581 +8100 8971 +8100 8528 +8100 9407 +8101 9102 +8101 8220 +8101 9532 +8101 8943 +8102 9957 +8102 8110 +8102 8367 +8103 8866 +8103 8279 +8103 8153 +8103 9691 +8104 8929 +8104 8325 +8104 9683 +8104 8371 +8104 9614 +8105 8483 +8105 9164 +8105 8821 +8105 9818 +8106 8706 +8106 9884 +8106 9778 +8106 8393 +8106 8274 +8107 8389 +8107 9193 +8107 8953 +8107 9629 +8107 9849 +8107 9402 +8107 8956 +8108 9703 +8108 9910 +8110 9347 +8111 8706 +8111 9768 +8111 8267 +8111 9081 +8112 9825 +8112 8903 +8112 8366 +8113 9188 +8114 8713 +8114 8689 +8114 8628 +8114 8247 +8115 9632 +8115 9025 +8115 9451 +8115 8174 +8115 9938 +8115 9563 +8116 8120 +8116 8770 +8116 8654 +8116 8410 +8116 8167 +8116 9329 +8117 9125 +8117 9541 +8117 8136 +8117 9335 +8117 9723 +8118 9862 +8118 8148 +8118 9206 +8118 9527 +8118 9306 +8119 9233 +8119 8851 +8119 9926 +8119 8174 +8120 9125 +8121 9106 +8121 8570 +8122 9753 +8122 8153 +8122 9084 +8122 9727 +8123 8652 +8123 8657 +8123 8300 +8123 8189 +8124 8884 +8125 9925 +8125 8786 +8126 8595 +8126 8847 +8127 9662 +8128 9906 +8128 9281 +8129 8711 +8129 9196 +8130 8497 +8131 8429 +8132 8579 +8132 8463 +8132 8759 +8132 8905 +8132 9450 +8132 9713 +8132 9333 +8132 9213 +8133 8355 +8133 9155 +8133 9023 +8134 9736 +8135 8465 +8135 8473 +8135 8349 +8136 9219 +8136 8657 +8137 9103 +8137 8630 +8137 8222 +8138 8646 +8138 8718 +8138 8698 +8139 9063 +8139 8436 +8139 8717 +8140 8744 +8140 8215 +8140 8154 +8141 9099 +8141 9837 +8141 9462 +8142 9653 +8142 9271 +8142 9423 +8143 9956 +8143 9017 +8144 8370 +8144 9043 +8144 9876 +8144 8310 +8144 8734 +8145 9609 +8145 8339 +8145 9751 +8145 9580 +8145 9806 +8145 8275 +8145 8979 +8145 8569 +8146 8847 +8146 9639 +8146 8619 +8146 9789 +8146 8427 +8146 9324 +8146 8956 +8147 9267 +8147 9196 +8147 9649 +8147 8758 +8148 9984 +8148 9127 +8148 9201 +8148 8286 +8148 9603 +8149 8238 +8149 8806 +8149 8938 +8150 8632 +8150 9924 +8150 8950 +8150 8521 +8150 9115 +8150 8893 +8151 9605 +8151 8429 +8151 8371 +8152 8205 +8152 9487 +8152 9258 +8152 8772 +8152 8911 +8152 9302 +8152 9195 +8152 8312 +8153 8163 +8153 8404 +8154 9360 +8154 8523 +8154 9433 +8155 9451 +8155 8656 +8155 9779 +8155 9205 +8156 8638 +8157 9744 +8157 8866 +8157 9557 +8157 9303 +8158 8200 +8158 9221 +8159 8692 +8159 8857 +8159 8469 +8160 8463 +8160 9797 +8160 9292 +8161 8337 +8161 8700 +8162 9249 +8162 8886 +8162 9029 +8162 8262 +8163 8878 +8163 9459 +8164 9633 +8164 9121 +8164 8495 +8164 9538 +8164 8913 +8164 8564 +8165 9956 +8165 8358 +8165 8647 +8165 8420 +8166 9772 +8166 8905 +8166 8282 +8166 9441 +8166 8810 +8166 8944 +8166 8822 +8166 9722 +8167 8873 +8167 9067 +8168 8842 +8168 8971 +8168 9681 +8168 8293 +8168 9656 +8168 9017 +8168 9227 +8168 9917 +8169 9422 +8169 8821 +8169 9178 +8170 9410 +8170 9453 +8171 8576 +8171 9907 +8172 9230 +8172 8212 +8172 9172 +8172 9207 +8172 8825 +8173 9483 +8173 9231 +8173 8874 +8173 9660 +8173 9159 +8173 8795 +8174 8962 +8174 9286 +8175 8297 +8175 8401 +8175 8538 +8176 8809 +8176 9195 +8176 8812 +8176 9488 +8176 9855 +8177 8326 +8177 8350 +8177 9111 +8177 9504 +8177 8519 +8177 9838 +8177 9725 +8178 8837 +8178 8774 +8178 8655 +8178 8893 +8179 8297 +8179 8401 +8179 8823 +8180 8334 +8181 9354 +8181 9101 +8181 9309 +8181 8415 +8182 8837 +8182 8363 +8182 9463 +8183 9996 +8183 8282 +8184 9638 +8184 8369 +8185 8912 +8185 9715 +8186 9540 +8186 9361 +8186 9978 +8187 8645 +8187 8592 +8187 8606 +8188 9890 +8189 8833 +8189 8531 +8189 9368 +8190 8841 +8190 9870 +8190 9550 +8190 8249 +8191 9515 +8191 9673 +8191 8428 +8191 9969 +8192 9761 +8192 9332 +8192 8776 +8192 9955 +8192 8447 +8193 9346 +8193 9412 +8193 9046 +8193 8216 +8194 9094 +8194 8614 +8194 8813 +8194 9263 +8195 8215 +8195 8475 +8195 9563 +8195 8547 +8195 8816 +8195 8511 +8195 8573 +8196 8749 +8196 9967 +8197 9157 +8197 9023 +8197 9136 +8198 8896 +8198 9127 +8198 9517 +8198 9273 +8199 8619 +8199 9288 +8199 9995 +8201 8308 +8201 8510 +8201 8383 +8201 8697 +8201 9313 +8201 9406 +8202 9745 +8202 9784 +8202 8414 +8203 9360 +8203 9565 +8203 9534 +8203 9535 +8204 9987 +8204 9514 +8204 9915 +8204 9407 +8204 8246 +8204 9933 +8204 8411 +8204 8803 +8204 8438 +8204 8699 +8205 8587 +8205 9002 +8205 9152 +8205 8937 +8206 9966 +8206 9713 +8206 9304 +8206 8249 +8206 8570 +8207 8931 +8207 9585 +8207 8638 +8207 9631 +8208 9638 +8208 8398 +8208 8474 +8208 9306 +8209 9923 +8209 9254 +8209 9869 +8209 8346 +8209 9087 +8210 9824 +8210 9812 +8210 9466 +8211 9635 +8211 9164 +8211 8283 +8211 8546 +8211 8312 +8211 8445 +8212 8935 +8212 8802 +8212 9582 +8212 9683 +8212 9529 +8212 9117 +8212 8862 +8213 8924 +8213 9073 +8214 9003 +8214 9388 +8214 8468 +8215 8610 +8215 9644 +8215 9931 +8215 9873 +8215 8308 +8215 8995 +8216 8320 +8216 8411 +8217 8677 +8217 8237 +8217 9688 +8217 9782 +8218 9472 +8218 9678 +8219 9484 +8219 8876 +8219 9562 +8219 8685 +8219 8446 +8221 9802 +8221 9144 +8222 8434 +8224 9594 +8224 8666 +8225 8527 +8226 8416 +8227 8746 +8227 9398 +8227 9151 +8227 9186 +8227 8821 +8228 9520 +8228 8937 +8228 9194 +8228 8403 +8228 9140 +8228 9948 +8229 9643 +8230 8282 +8230 9339 +8231 8386 +8232 9057 +8233 8813 +8234 9152 +8235 9485 +8235 8433 +8236 9105 +8237 9765 +8237 9134 +8237 8249 +8237 8902 +8237 8801 +8237 9963 +8238 9983 +8238 9823 +8238 9182 +8239 9067 +8239 8547 +8239 9302 +8239 9756 +8239 8254 +8240 9876 +8240 8989 +8240 8499 +8240 9403 +8240 8395 +8240 9855 +8241 8770 +8241 8998 +8241 8945 +8241 8818 +8241 9276 +8242 9104 +8242 9305 +8243 9961 +8243 9703 +8243 8574 +8244 8996 +8244 9905 +8244 8734 +8245 9490 +8245 9816 +8246 8851 +8247 9118 +8247 8695 +8248 8320 +8248 9927 +8248 8848 +8248 9258 +8248 9131 +8248 9276 +8248 8263 +8248 8553 +8249 9904 +8249 9965 +8249 8567 +8250 8834 +8250 9357 +8250 8788 +8251 9849 +8251 8523 +8252 8539 +8252 9084 +8253 9132 +8253 9357 +8253 9582 +8254 9221 +8254 8490 +8254 8627 +8254 8983 +8254 8830 +8255 8983 +8255 8364 +8255 9165 +8255 8398 +8256 8908 +8256 9300 +8256 9163 +8257 9759 +8257 9305 +8257 9441 +8258 9805 +8258 9423 +8259 9097 +8259 8851 +8259 8794 +8259 8419 +8259 9323 +8260 9088 +8260 9707 +8260 9212 +8260 9527 +8261 9015 +8262 8740 +8262 9389 +8262 9213 +8263 9412 +8264 9525 +8264 8733 +8265 9472 +8265 9136 +8265 9366 +8265 8700 +8266 8935 +8266 8444 +8267 8383 +8268 9091 +8268 8754 +8268 9171 +8268 8555 +8269 9260 +8269 8694 +8270 8872 +8270 9580 +8270 8684 +8270 8696 +8271 8449 +8271 8775 +8271 9511 +8271 9282 +8271 8368 +8272 8390 +8272 9322 +8273 8323 +8273 8352 +8273 8358 +8273 8638 +8273 9638 +8274 9359 +8274 8338 +8274 9520 +8274 9407 +8274 8817 +8274 8699 +8275 8694 +8275 8882 +8275 9886 +8275 9303 +8276 8715 +8276 9631 +8276 8459 +8277 8707 +8277 9576 +8277 9105 +8277 9558 +8277 9917 +8278 8291 +8278 9815 +8278 9325 +8278 8439 +8279 9782 +8279 9846 +8280 8937 +8280 8595 +8281 8582 +8281 9123 +8281 9548 +8281 8926 +8281 9316 +8282 8354 +8282 9095 +8282 9830 +8283 9189 +8283 9265 +8283 9535 +8283 8796 +8284 9519 +8284 9748 +8285 8400 +8285 9955 +8286 8727 +8286 8844 +8286 9454 +8286 9427 +8286 9700 +8286 9628 +8286 9577 +8287 8896 +8287 9316 +8287 9895 +8288 9758 +8288 9652 +8288 9531 +8288 9666 +8288 8521 +8288 9806 +8288 8921 +8288 9063 +8289 8712 +8289 9527 +8289 9044 +8289 8502 +8289 9820 +8290 8834 +8290 8761 +8290 9144 +8291 9648 +8291 9351 +8291 9781 +8291 9225 +8291 9754 +8293 9507 +8293 8983 +8294 9480 +8294 9867 +8294 8355 +8294 8508 +8295 8611 +8295 9803 +8295 9416 +8295 8817 +8295 8566 +8296 8890 +8297 8333 +8297 8683 +8297 9082 +8298 9700 +8298 9222 +8298 9583 +8299 8653 +8299 8847 +8299 9828 +8299 9064 +8299 8812 +8300 9827 +8300 9697 +8301 8328 +8301 8344 +8301 9914 +8301 8397 +8302 8604 +8302 8495 +8302 9855 +8303 9025 +8303 9160 +8303 8715 +8303 9858 +8303 9973 +8303 8891 +8303 8764 +8304 9128 +8304 8901 +8304 9564 +8304 9066 +8306 8712 +8306 8332 +8306 8853 +8306 9435 +8306 9202 +8307 8513 +8307 8776 +8307 9467 +8307 8447 +8308 9440 +8308 9893 +8309 8360 +8309 8776 +8310 8982 +8310 9641 +8310 9410 +8310 8914 +8311 9107 +8312 8459 +8312 8620 +8312 8510 +8312 9322 +8312 9464 +8313 8349 +8313 9901 +8313 9017 +8313 9297 +8313 9425 +8314 9511 +8314 9283 +8315 8438 +8315 8739 +8315 9750 +8315 8947 +8315 8796 +8316 8357 +8316 9225 +8316 9390 +8316 9012 +8316 9151 +8317 8955 +8318 8928 +8318 9026 +8318 9356 +8318 8578 +8318 9686 +8318 8346 +8319 8381 +8319 8702 +8320 9420 +8321 9527 +8321 9031 +8321 9712 +8321 8573 +8322 8488 +8322 9641 +8322 9746 +8322 9678 +8322 8792 +8322 8506 +8323 8477 +8323 8499 +8323 8428 +8324 9220 +8324 8587 +8324 8462 +8324 8641 +8324 9742 +8324 9193 +8325 8852 +8325 8803 +8326 8970 +8326 8726 +8326 9401 +8327 9926 +8327 8464 +8327 8446 +8328 8395 +8328 8426 +8329 8461 +8329 8354 +8329 9855 +8330 8692 +8331 9332 +8332 9384 +8332 8513 +8332 8957 +8333 8464 +8333 9148 +8333 9821 +8333 8554 +8334 9389 +8334 8506 +8334 8908 +8335 8781 +8335 8697 +8336 9710 +8336 9943 +8336 8987 +8336 9757 +8337 8449 +8337 9103 +8337 9886 +8337 9402 +8338 9639 +8338 8668 +8338 8552 +8339 9511 +8339 8858 +8340 8576 +8340 8468 +8340 9946 +8340 8795 +8340 8928 +8341 8651 +8342 9790 +8343 8763 +8343 9287 +8343 9265 +8343 9943 +8344 8538 +8345 8433 +8345 9513 +8345 9418 +8345 8782 +8345 9184 +8346 8654 +8346 9016 +8346 9989 +8347 8374 +8347 9385 +8347 8492 +8347 9500 +8348 8399 +8348 9744 +8348 9914 +8349 9000 +8349 9863 +8349 8815 +8349 9847 +8350 9369 +8350 9119 +8351 9480 +8351 8365 +8351 8421 +8351 8445 +8352 9784 +8352 9037 +8352 9049 +8352 8804 +8353 9520 +8354 9663 +8355 8465 +8355 8357 +8355 9200 +8356 8988 +8356 8643 +8357 9198 +8357 9679 +8357 9214 +8358 9805 +8359 9544 +8359 9327 +8360 8728 +8361 9615 +8361 8883 +8361 8375 +8361 8650 +8361 9698 +8361 8572 +8361 9514 +8362 8487 +8362 8385 +8362 8527 +8362 9337 +8363 8892 +8364 8459 +8364 8553 +8364 9419 +8364 9590 +8365 9825 +8365 8538 +8366 8421 +8367 8987 +8367 9888 +8367 8896 +8367 9798 +8367 8661 +8368 9499 +8368 9396 +8368 8822 +8368 8568 +8368 9849 +8369 9963 +8369 9737 +8370 9858 +8370 9508 +8370 9900 +8371 9920 +8371 8828 +8372 9152 +8372 9040 +8372 9231 +8372 9396 +8373 9388 +8373 8400 +8373 9779 +8373 8974 +8373 8979 +8374 9031 +8375 9534 +8375 8687 +8375 8851 +8375 9112 +8376 9473 +8376 8834 +8376 9374 +8376 9025 +8376 9555 +8377 8393 +8378 9507 +8379 8866 +8379 9131 +8380 9313 +8380 8835 +8380 9510 +8380 9985 +8380 9130 +8380 9932 +8380 9629 +8380 9949 +8381 9115 +8381 9197 +8381 8795 +8382 9494 +8382 9268 +8382 9430 +8383 9826 +8383 8434 +8384 8985 +8384 9258 +8384 9298 +8384 8923 +8384 8941 +8385 8923 +8385 8688 +8385 8446 +8386 9616 +8386 9142 +8386 9536 +8386 9168 +8386 9304 +8386 8955 +8386 8830 +8387 9864 +8387 9371 +8387 9660 +8388 8707 +8388 9230 +8388 8853 +8388 9799 +8389 8577 +8389 8839 +8389 9073 +8389 9727 +8390 8399 +8391 8509 +8392 8834 +8392 9681 +8392 9572 +8393 8757 +8393 8415 +8393 8550 +8393 8689 +8394 8466 +8395 8482 +8395 9531 +8396 8482 +8396 9506 +8396 9901 +8396 8768 +8396 9180 +8396 8425 +8396 9843 +8397 9257 +8397 9774 +8397 9308 +8397 9463 +8398 8979 +8398 9447 +8398 8688 +8399 9856 +8399 8516 +8400 8563 +8400 9570 +8400 9995 +8401 9224 +8401 9507 +8401 8751 +8401 8826 +8402 8498 +8402 9243 +8403 9728 +8403 9569 +8403 8673 +8403 9971 +8404 9410 +8404 8457 +8404 8941 +8404 8601 +8405 8858 +8405 9628 +8405 8611 +8405 9467 +8406 9885 +8406 9285 +8406 9700 +8406 9836 +8407 9537 +8407 8851 +8407 9908 +8407 9597 +8407 9695 +8408 8834 +8408 9239 +8408 8797 +8409 8866 +8409 9578 +8409 9884 +8409 9701 +8410 9206 +8410 8945 +8410 9081 +8410 9822 +8411 8737 +8411 8870 +8411 9792 +8411 9026 +8411 9935 +8412 9485 +8413 9161 +8413 8971 +8413 9001 +8413 8505 +8414 9075 +8414 9870 +8414 9338 +8414 9013 +8415 8583 +8416 9422 +8416 8941 +8417 9873 +8417 9909 +8417 9784 +8417 9805 +8418 8897 +8419 9986 +8419 9863 +8419 9752 +8419 9754 +8420 8869 +8420 8693 +8422 8811 +8422 9112 +8423 8862 +8424 8960 +8424 9199 +8424 9711 +8424 9108 +8424 9733 +8425 9501 +8425 8658 +8425 8691 +8426 8878 +8427 9609 +8427 9866 +8427 8866 +8427 9546 +8427 9854 +8428 9267 +8428 9386 +8428 9843 +8428 9332 +8428 9719 +8430 8795 +8430 9941 +8430 9978 +8431 8453 +8431 9231 +8431 9646 +8431 9579 +8432 9982 +8433 8457 +8433 8852 +8433 9908 +8434 9795 +8434 8615 +8434 9695 +8434 9340 +8435 9921 +8436 9411 +8437 8768 +8437 9874 +8437 8757 +8438 9216 +8438 9945 +8438 8541 +8438 8958 +8438 9727 +8439 8527 +8440 9917 +8441 9895 +8441 8523 +8441 8913 +8443 9063 +8443 8761 +8443 9245 +8443 8702 +8445 9611 +8445 9103 +8445 8472 +8446 9252 +8446 8969 +8446 9482 +8446 9752 +8447 9239 +8447 8517 +8447 9322 +8447 8892 +8447 8638 +8448 8648 +8448 8457 +8448 9004 +8449 9996 +8450 9263 +8451 8517 +8451 9383 +8451 8912 +8451 8824 +8451 8794 +8452 9420 +8452 9503 +8453 9220 +8455 9869 +8455 9168 +8455 9778 +8455 9808 +8455 9726 +8456 9230 +8457 9060 +8457 9328 +8457 9233 +8458 9457 +8458 9497 +8458 8892 +8459 8753 +8460 9168 +8460 9471 +8461 8856 +8462 9609 +8462 9249 +8463 8484 +8464 9768 +8464 9522 +8464 8597 +8464 8739 +8466 9036 +8466 9556 +8466 8665 +8466 8505 +8467 9410 +8467 8888 +8467 8472 +8468 8833 +8468 8518 +8468 9963 +8468 8892 +8468 9859 +8469 8733 +8469 9532 +8470 9322 +8472 8868 +8472 9019 +8473 9073 +8474 9736 +8474 9049 +8474 9653 +8474 9654 +8474 9273 +8474 9944 +8474 9714 +8476 9485 +8476 8978 +8476 9110 +8476 9771 +8476 8552 +8477 8679 +8477 9258 +8477 9742 +8478 8582 +8478 9690 +8479 9251 +8479 9291 +8479 8678 +8480 9054 +8480 8488 +8480 9455 +8480 8946 +8480 9269 +8481 9448 +8481 9098 +8481 8888 +8482 8688 +8482 8767 +8483 8953 +8483 8954 +8484 9737 +8484 8865 +8484 8899 +8484 8903 +8484 9316 +8485 9419 +8485 8638 +8486 8910 +8486 8681 +8487 9508 +8487 9032 +8487 9065 +8487 9595 +8488 9110 +8488 9121 +8488 8517 +8488 8648 +8489 8986 +8489 9488 +8489 9778 +8489 9019 +8489 9404 +8490 9670 +8490 9819 +8490 8572 +8491 9413 +8491 9168 +8491 9316 +8491 8676 +8492 9506 +8492 8950 +8492 9593 +8493 8863 +8493 8746 +8493 8562 +8493 9203 +8494 9288 +8495 9477 +8495 8696 +8496 9811 +8496 9077 +8496 9726 +8497 8693 +8497 9131 +8497 9420 +8497 9018 +8497 9171 +8498 9986 +8498 9596 +8498 8817 +8498 9244 +8499 8722 +8499 9603 +8499 9880 +8499 9136 +8499 9784 +8500 9826 +8500 8934 +8500 8759 +8500 9710 +8500 9629 +8501 8908 +8501 8509 +8502 8844 +8502 8684 +8502 9321 +8503 8516 +8503 9995 +8503 8651 +8503 9087 +8504 9657 +8504 9775 +8504 9750 +8505 9735 +8505 8535 +8506 9729 +8506 8630 +8507 9543 +8507 9522 +8507 9626 +8507 8510 +8508 8974 +8508 8736 +8508 8624 +8508 9524 +8508 8890 +8508 9301 +8508 9966 +8508 9458 +8508 9467 +8509 9831 +8510 8634 +8510 8782 +8510 8550 +8510 9960 +8511 9355 +8511 8758 +8512 9346 +8512 8612 +8512 8922 +8513 8608 +8513 8828 +8514 9936 +8514 8787 +8514 9560 +8514 9276 +8515 9030 +8515 8647 +8515 9224 +8515 9692 +8515 9943 +8516 9058 +8516 9137 +8516 9393 +8516 9041 +8517 9880 +8517 8733 +8517 8745 +8517 9403 +8517 9549 +8517 9960 +8518 9063 +8518 9194 +8519 9420 +8519 9490 +8519 9626 +8519 9469 +8520 9224 +8520 9739 +8521 8974 +8521 9712 +8523 8687 +8523 8984 +8523 9133 +8523 8632 +8523 9276 +8523 9698 +8523 9325 +8523 9471 +8524 8566 +8524 9546 +8525 9440 +8525 8683 +8525 8649 +8525 9565 +8525 9839 +8526 8757 +8527 9033 +8527 9725 +8528 9388 +8528 9398 +8528 9425 +8528 8546 +8528 8567 +8529 9250 +8529 9784 +8529 8824 +8529 8762 +8530 9105 +8530 9238 +8530 9635 +8530 9062 +8531 9417 +8531 9296 +8531 8567 +8531 9759 +8532 9349 +8532 9130 +8532 9900 +8532 9967 +8532 9873 +8532 9118 +8533 8850 +8533 9142 +8533 9973 +8533 8769 +8533 9556 +8534 8742 +8535 9888 +8537 9299 +8538 9005 +8539 9673 +8539 9939 +8539 9661 +8540 8823 +8540 8574 +8541 8711 +8541 9898 +8541 9925 +8541 8657 +8541 8923 +8542 8731 +8543 9052 +8543 9080 +8544 9072 +8544 9883 +8545 8791 +8546 8623 +8547 8740 +8547 9570 +8547 9454 +8548 9309 +8549 9325 +8549 8863 +8550 8986 +8550 9656 +8550 8614 +8551 9746 +8551 9737 +8552 9285 +8552 8752 +8553 8762 +8553 8666 +8553 9060 +8554 9481 +8554 9867 +8554 9894 +8554 9384 +8555 8735 +8555 9285 +8555 9183 +8556 9186 +8557 9992 +8557 8747 +8557 8752 +8557 9671 +8557 8777 +8557 9982 +8557 9727 +8558 9499 +8558 9115 +8558 9645 +8559 8850 +8559 8655 +8559 8915 +8560 9832 +8560 9711 +8561 8962 +8561 9848 +8561 9642 +8562 9392 +8562 9018 +8562 8586 +8563 9057 +8563 8738 +8563 8769 +8563 9914 +8564 8578 +8564 9955 +8564 9132 +8564 9807 +8564 9032 +8564 8990 +8564 9343 +8565 9605 +8565 8649 +8565 9683 +8565 9688 +8565 9946 +8566 9337 +8567 8593 +8567 8604 +8567 8626 +8567 9271 +8567 9324 +8568 9824 +8568 9721 +8568 9447 +8568 9134 +8568 8573 +8568 9854 +8569 9259 +8570 9541 +8570 8901 +8570 9670 +8570 9552 +8570 9555 +8570 9844 +8571 9728 +8571 9882 +8571 8650 +8571 9193 +8572 9197 +8573 8729 +8573 8675 +8573 9842 +8573 9205 +8574 9441 +8574 8708 +8574 9163 +8574 8934 +8574 9220 +8575 8700 +8575 8791 +8576 9554 +8576 9948 +8577 8769 +8577 8710 +8577 9140 +8577 9141 +8578 9543 +8578 9974 +8579 9537 +8579 9868 +8580 8718 +8580 9470 +8582 9691 +8583 9602 +8583 8594 +8583 8682 +8584 9926 +8584 9548 +8584 8845 +8585 9459 +8585 9136 +8585 9416 +8586 9486 +8586 9362 +8586 8777 +8586 9982 +8587 8846 +8587 8603 +8587 8718 +8587 9845 +8587 9732 +8588 9734 +8588 9708 +8588 8848 +8588 9971 +8588 9655 +8588 9339 +8589 9958 +8589 9804 +8590 9324 +8590 9685 +8591 8980 +8592 8899 +8592 8609 +8592 9653 +8593 9294 +8593 9537 +8593 9666 +8594 9872 +8595 9184 +8595 9058 +8595 9865 +8595 8910 +8596 9153 +8596 9910 +8596 9978 +8597 8685 +8598 8963 +8598 8851 +8598 8951 +8599 9677 +8599 9658 +8600 9507 +8600 9849 +8600 8991 +8601 8910 +8601 9621 +8602 9749 +8602 8696 +8603 8995 +8603 9830 +8603 9711 +8604 8991 +8604 9355 +8604 9543 +8604 9802 +8604 9822 +8604 9851 +8605 9608 +8605 9997 +8606 9348 +8606 9070 +8606 9557 +8607 9930 +8607 9457 +8608 9128 +8608 9834 +8608 9845 +8609 9673 +8609 8626 +8610 9038 +8610 8622 +8610 8882 +8610 9390 +8611 9382 +8611 9000 +8611 8945 +8612 9061 +8612 8884 +8612 9563 +8613 8737 +8613 8875 +8613 9328 +8613 9955 +8614 8993 +8614 9305 +8614 9444 +8614 9975 +8615 8870 +8615 8791 +8615 8795 +8615 9599 +8616 8888 +8616 9563 +8616 8860 +8616 9534 +8617 9622 +8617 9908 +8617 9782 +8617 9286 +8617 9169 +8617 8690 +8618 9600 +8618 8803 +8618 9808 +8619 9157 +8619 9236 +8620 9387 +8620 9846 +8621 9535 +8622 9401 +8623 9262 +8623 9018 +8623 9805 +8623 9038 +8624 9189 +8624 9575 +8624 9398 +8624 8730 +8625 9782 +8625 9599 +8626 9700 +8626 9234 +8628 9180 +8628 9406 +8629 9327 +8629 8756 +8629 9743 +8629 9045 +8630 9007 +8631 9312 +8631 9586 +8632 9775 +8633 8987 +8633 9097 +8633 9830 +8634 9580 +8634 8716 +8634 9994 +8634 9648 +8634 8958 +8635 8775 +8635 9842 +8637 9915 +8637 9696 +8637 9081 +8639 9096 +8639 9551 +8639 8790 +8640 8845 +8640 9006 +8641 9755 +8641 9528 +8642 9865 +8642 9526 +8642 9690 +8643 9154 +8643 9067 +8644 9864 +8646 8721 +8646 8651 +8646 9399 +8646 9957 +8647 9121 +8647 9042 +8647 9082 +8648 9480 +8648 9105 +8648 9665 +8648 9957 +8648 8957 +8650 9494 +8650 9927 +8650 9208 +8650 8767 +8651 8991 +8652 8719 +8652 9239 +8652 8862 +8652 9666 +8653 8847 +8653 8734 +8653 9427 +8653 9429 +8653 9596 +8654 9106 +8654 8724 +8654 8899 +8654 9057 +8654 9443 +8654 9465 +8655 9246 +8655 9641 +8655 9903 +8655 9335 +8656 9207 +8657 8922 +8658 9546 +8658 9325 +8659 9345 +8659 9970 +8659 9557 +8659 9593 +8659 9180 +8660 9651 +8660 9166 +8660 9167 +8660 9333 +8661 8673 +8662 9601 +8662 9263 +8662 9191 +8662 8823 +8663 9027 +8663 9495 +8663 8733 +8665 9905 +8665 9837 +8666 8961 +8666 9269 +8666 8901 +8666 8940 +8666 9107 +8667 9729 +8667 9923 +8668 9620 +8669 8905 +8669 9327 +8669 8944 +8669 9480 +8669 9582 +8670 8837 +8670 9142 +8671 9793 +8671 9211 +8672 9525 +8673 9671 +8673 8974 +8673 9310 +8674 9625 +8674 9379 +8675 9217 +8675 9231 +8677 9644 +8677 9910 +8677 8950 +8679 8705 +8680 8980 +8680 9719 +8680 9022 +8681 8928 +8681 9837 +8682 9147 +8682 9553 +8682 8985 +8683 9903 +8683 9248 +8683 9775 +8683 9294 +8683 9745 +8684 8741 +8684 9415 +8685 9878 +8685 9765 +8685 9435 +8685 9193 +8686 9339 +8686 9459 +8686 9563 +8686 9052 +8688 9411 +8689 9368 +8689 9688 +8690 8805 +8690 8782 +8690 9299 +8692 9490 +8692 9793 +8692 9058 +8692 9715 +8693 9434 +8693 8843 +8694 9798 +8694 9293 +8694 9906 +8695 8791 +8696 9394 +8697 9602 +8697 9611 +8697 8988 +8697 9147 +8697 8947 +8697 8958 +8698 9411 +8698 9935 +8698 8824 +8699 9604 +8699 9645 +8699 9616 +8699 9078 +8700 9416 +8700 9826 +8700 9431 +8700 9442 +8700 9188 +8701 8969 +8701 8819 +8702 9490 +8702 9376 +8702 9580 +8703 9035 +8703 9229 +8704 9931 +8704 9357 +8705 8730 +8705 9151 +8705 9418 +8705 8928 +8705 9834 +8705 9211 +8706 9202 +8707 9669 +8707 9464 +8708 8876 +8708 9832 +8708 8829 +8709 8862 +8709 9754 +8709 9151 +8710 9971 +8710 9861 +8711 9038 +8711 9452 +8712 9515 +8713 9828 +8713 9651 +8713 9548 +8714 8717 +8714 9509 +8714 9539 +8714 9168 +8714 8921 +8714 9969 +8715 9734 +8715 9369 +8715 9664 +8715 9175 +8716 9765 +8717 9239 +8717 9628 +8717 9643 +8717 9679 +8718 9621 +8719 9016 +8720 9782 +8720 9337 +8721 9057 +8722 9174 +8723 9090 +8723 9055 +8723 9335 +8723 9979 +8724 9102 +8725 9844 +8727 9705 +8728 8899 +8729 8842 +8730 9541 +8731 9611 +8732 9008 +8732 9781 +8733 9997 +8733 8781 +8734 9497 +8734 9288 +8735 9260 +8735 8760 +8735 9278 +8735 9598 +8736 8867 +8736 9169 +8737 9347 +8738 8804 +8738 9328 +8739 9190 +8739 9959 +8740 9653 +8741 8970 +8741 8909 +8741 9533 +8742 8777 +8742 8786 +8742 9870 +8743 9495 +8743 9474 +8743 9190 +8743 9731 +8743 9532 +8743 8829 +8744 9715 +8744 9587 +8744 9871 +8745 9099 +8745 8778 +8745 9162 +8746 9107 +8746 9902 +8746 9976 +8747 9997 +8747 9262 +8748 9542 +8748 9215 +8749 9758 +8749 9823 +8750 9715 +8752 9990 +8752 9352 +8752 9667 +8752 9189 +8752 9532 +8754 8977 +8754 9687 +8755 8852 +8755 8879 +8755 8887 +8755 8812 +8756 9656 +8756 9469 +8756 9445 +8757 9759 +8757 9772 +8757 9049 +8757 9565 +8758 8837 +8758 8862 +8759 8882 +8759 9305 +8759 8926 +8760 9356 +8760 9822 +8761 9072 +8761 9621 +8761 8827 +8761 9685 +8762 9989 +8762 8848 +8762 8992 +8762 9518 +8762 9341 +8763 8895 +8763 9318 +8763 9581 +8764 9860 +8764 8879 +8764 8926 +8765 9958 +8765 9107 +8765 9791 +8766 9994 +8766 9378 +8766 8886 +8766 8887 +8766 9955 +8767 9998 +8767 8897 +8767 9169 +8769 9330 +8770 9478 +8770 9850 +8771 9585 +8771 9630 +8772 8817 +8772 9653 +8772 9803 +8773 9350 +8773 9106 +8774 9796 +8775 9655 +8776 9457 +8777 9006 +8777 8944 +8777 9141 +8777 9467 +8777 9558 +8778 9200 +8779 9611 +8779 9784 +8779 9530 +8781 8881 +8781 8956 +8781 9211 +8783 9608 +8783 9740 +8783 9071 +8784 8864 +8784 8802 +8785 9634 +8785 9751 +8786 9858 +8786 9557 +8786 9582 +8787 9092 +8787 9080 +8790 9647 +8790 9978 +8791 9128 +8792 9004 +8792 8913 +8792 8979 +8792 9691 +8793 9152 +8794 9636 +8794 9791 +8794 9948 +8795 9240 +8796 9580 +8796 9944 +8796 9514 +8797 9459 +8797 9631 +8798 9891 +8798 9011 +8798 8955 +8799 9636 +8799 9511 +8799 9208 +8799 9743 +8801 9445 +8802 8967 +8802 9895 +8803 9349 +8803 9367 +8803 9837 +8803 9757 +8805 9503 +8805 9129 +8805 9292 +8805 9327 +8806 8994 +8806 9164 +8806 8941 +8808 9580 +8809 9226 +8809 9456 +8809 9563 +8809 9000 +8810 9451 +8810 8911 +8810 9941 +8810 9663 +8811 9290 +8812 9845 +8812 9081 +8813 9354 +8813 9235 +8813 9370 +8813 9279 +8813 9254 +8813 9897 +8814 9921 +8814 8875 +8814 9909 +8815 9913 +8815 9457 +8815 8831 +8815 9407 +8816 9258 +8817 9443 +8817 8854 +8818 9347 +8818 9353 +8818 9709 +8819 9487 +8819 9561 +8822 9127 +8822 8864 +8822 9663 +8823 9296 +8823 9714 +8824 9955 +8825 9686 +8825 9265 +8825 9304 +8825 9697 +8825 9448 +8826 9175 +8827 9955 +8827 8902 +8827 9425 +8827 9361 +8827 9980 +8828 9479 +8829 9984 +8829 9034 +8830 9769 +8830 9812 +8831 9026 +8831 9730 +8833 9249 +8833 9251 +8833 9566 +8833 9695 +8834 8855 +8834 8972 +8834 9411 +8834 9955 +8834 8949 +8835 8964 +8835 8970 +8838 9086 +8839 9033 +8839 9964 +8839 9365 +8839 8888 +8840 9237 +8840 9434 +8840 9931 +8841 9304 +8841 8965 +8841 9584 +8842 9229 +8842 8860 +8842 9260 +8843 8894 +8843 9388 +8845 8976 +8845 9083 +8846 9201 +8846 9738 +8847 9817 +8847 9708 +8847 9085 +8848 9953 +8848 8853 +8849 9510 +8849 9517 +8849 9114 +8850 9183 +8851 9287 +8852 9547 +8852 9068 +8852 8974 +8852 9818 +8854 9528 +8855 8874 +8855 9548 +8855 9133 +8855 8946 +8856 9284 +8856 9577 +8856 8911 +8856 9145 +8856 9535 +8857 9449 +8857 9776 +8857 9784 +8858 9280 +8858 9297 +8858 9434 +8858 8893 +8859 9026 +8859 9926 +8859 9640 +8859 9322 +8859 9334 +8860 9830 +8860 9039 +8861 9603 +8861 9926 +8863 9486 +8864 9140 +8865 9404 +8865 9681 +8865 9052 +8866 9367 +8866 9885 +8867 9291 +8867 9176 +8868 9363 +8868 9342 +8869 9567 +8870 9229 +8870 8901 +8870 9678 +8870 9820 +8870 9839 +8871 9223 +8871 9875 +8871 9263 +8871 8908 +8873 8994 +8873 9136 +8873 9694 +8874 9272 +8874 9947 +8875 8912 +8876 9721 +8877 9953 +8877 9040 +8880 9963 +8880 8973 +8880 8910 +8880 9880 +8880 9944 +8881 9787 +8881 9411 +8882 9666 +8882 9274 +8883 9579 +8884 9213 +8885 8896 +8885 9313 +8885 9827 +8885 9032 +8885 9358 +8885 9397 +8887 9186 +8888 9416 +8889 9511 +8889 9672 +8890 9667 +8890 9957 +8890 9875 +8891 9741 +8891 9687 +8891 9631 +8892 9026 +8892 9563 +8893 9227 +8893 9624 +8893 9025 +8893 9047 +8894 9410 +8895 9482 +8895 9427 +8896 9103 +8896 8917 +8897 9874 +8897 9948 +8898 9985 +8898 8982 +8898 9101 +8898 9123 +8898 9507 +8898 9211 +8899 9522 +8899 9715 +8899 8952 +8900 9953 +8900 9192 +8900 8981 +8900 9009 +8901 9842 +8902 9384 +8902 8922 +8902 9592 +8903 9943 +8903 9404 +8904 8948 +8904 9373 +8905 9774 +8905 9136 +8905 9034 +8905 9763 +8905 9845 +8906 9234 +8908 9249 +8908 9270 +8909 9788 +8909 9718 +8909 9295 +8909 9327 +8909 9081 +8910 9824 +8911 9603 +8911 9635 +8911 9629 +8912 9160 +8912 9782 +8912 9110 +8913 9137 +8913 9776 +8914 9059 +8915 8955 +8916 9111 +8917 9442 +8917 9223 +8918 9922 +8918 8963 +8920 9578 +8920 8970 +8921 9545 +8921 9035 +8922 8963 +8922 9929 +8922 9634 +8923 8966 +8923 9102 +8923 9364 +8923 9920 +8923 9724 +8924 9317 +8924 9642 +8925 8952 +8926 9473 +8926 9826 +8928 9378 +8928 9196 +8928 9294 +8929 9488 +8931 9254 +8931 9885 +8932 9613 +8933 9903 +8933 9554 +8934 9134 +8934 9423 +8934 9706 +8935 9186 +8935 9502 +8935 9307 +8936 9707 +8937 9134 +8937 9972 +8937 9208 +8937 9977 +8938 9756 +8938 9761 +8938 9273 +8939 9892 +8939 9094 +8939 9923 +8939 9706 +8941 9600 +8941 9262 +8942 9672 +8943 9636 +8943 9017 +8943 9213 +8944 9957 +8945 9764 +8945 9408 +8946 9876 +8946 9251 +8947 9028 +8947 9030 +8947 9353 +8948 9233 +8948 9634 +8948 9909 +8949 9946 +8949 8958 +8949 9887 +8950 9623 +8950 9343 +8951 8961 +8951 9014 +8951 9023 +8951 9554 +8951 9722 +8952 9991 +8952 9885 +8952 9462 +8953 9901 +8954 9747 +8954 9631 +8954 9677 +8954 8959 +8955 9864 +8955 9817 +8955 9965 +8956 9942 +8956 9047 +8956 9828 +8956 9070 +8956 9215 +8957 9765 +8957 9157 +8957 9698 +8958 9242 +8958 9757 +8958 9766 +8958 9916 +8958 9297 +8959 9573 +8959 9039 +8959 9913 +8960 9884 +8960 9319 +8961 9153 +8961 9773 +8961 8983 +8962 9860 +8962 9232 +8963 9033 +8963 9502 +8963 9567 +8964 9122 +8965 9759 +8965 9276 +8965 9338 +8966 9755 +8966 9343 +8967 9488 +8967 9251 +8967 9930 +8967 9431 +8967 9561 +8968 9294 +8969 9902 +8969 9385 +8970 9109 +8970 9367 +8970 9683 +8970 9066 +8971 9475 +8971 9361 +8971 9268 +8971 9785 +8972 9669 +8972 9966 +8972 9680 +8972 9733 +8973 9297 +8973 9682 +8973 9586 +8974 9735 +8974 9683 +8975 9419 +8975 9127 +8975 9556 +8976 9487 +8976 9193 +8977 9872 +8977 9003 +8977 9262 +8977 9069 +8978 8995 +8978 9283 +8979 9356 +8979 9252 +8979 9145 +8979 9536 +8981 9990 +8981 9845 +8982 9571 +8982 9491 +8983 9010 +8984 9276 +8984 9887 +8986 9986 +8986 9939 +8987 9477 +8987 9480 +8987 9447 +8987 9855 +8988 9198 +8988 9554 +8988 9645 +8989 9381 +8989 9109 +8989 9722 +8989 9425 +8990 9360 +8990 9945 +8990 9468 +8991 9775 +8992 9191 +8992 9521 +8994 9185 +8995 9106 +8995 9528 +8995 9799 +8995 9420 +8995 9171 +8995 9458 +8996 9029 +8996 9045 +8997 9897 +9000 9938 +9000 9496 +9000 9435 +9001 9320 +9001 9114 +9002 9623 +9002 9452 +9002 9593 +9002 9983 +9003 9164 +9003 9296 +9004 9578 +9004 9069 +9006 9774 +9006 9245 +9007 9123 +9007 9577 +9007 9841 +9008 9031 +9008 9870 +9009 9775 +9009 9207 +9009 9675 +9010 9280 +9010 9575 +9010 9849 +9010 9321 +9010 9151 +9012 9352 +9012 9869 +9012 9141 +9013 9750 +9013 9524 +9013 9695 +9014 9477 +9014 9144 +9015 9801 +9017 9131 +9018 9694 +9020 9749 +9020 9502 +9021 9173 +9022 9260 +9022 9131 +9022 9107 +9023 9672 +9023 9758 +9024 9222 +9024 9333 +9024 9205 +9025 9505 +9025 9683 +9027 9297 +9027 9078 +9027 9740 +9028 9497 +9029 9856 +9029 9917 +9030 9874 +9031 9395 +9032 9987 +9032 9885 +9032 9928 +9032 9469 +9033 9149 +9033 9175 +9033 9197 +9034 9706 +9034 9077 +9035 9135 +9035 9545 +9035 9040 +9036 9771 +9036 9783 +9036 9797 +9037 9687 +9038 9921 +9038 9095 +9038 9592 +9039 9659 +9039 9148 +9039 9534 +9040 9929 +9040 9421 +9040 9303 +9040 9491 +9041 9175 +9041 9626 +9041 9119 +9041 9891 +9041 9536 +9041 9303 +9041 9432 +9043 9283 +9043 9285 +9043 9598 +9044 9996 +9044 9915 +9044 9942 +9044 9175 +9045 9423 +9045 9149 +9045 9343 +9046 9128 +9046 9174 +9047 9619 +9048 9070 +9048 9213 +9050 9487 +9051 9925 +9051 9254 +9052 9668 +9053 9865 +9053 9195 +9054 9121 +9054 9390 +9054 9953 +9055 9186 +9055 9727 +9056 9772 +9058 9605 +9058 9390 +9058 9273 +9060 9534 +9062 9804 +9062 9324 +9062 9288 +9062 9354 +9063 9948 +9064 9857 +9064 9990 +9064 9463 +9064 9693 +9065 9602 +9065 9294 +9065 9465 +9066 9689 +9066 9422 +9066 9179 +9067 9346 +9067 9746 +9068 9657 +9068 9568 +9068 9839 +9069 9978 +9070 9562 +9070 9821 +9071 9225 +9071 9559 +9071 9589 +9071 9815 +9071 9336 +9071 9700 +9072 9397 +9073 9519 +9073 9147 +9073 9798 +9073 9106 +9074 9671 +9074 9307 +9074 9469 +9075 9514 +9075 9683 +9076 9566 +9077 9371 +9077 9668 +9077 9507 +9077 9403 +9078 9558 +9078 9189 +9079 9440 +9079 9222 +9079 9972 +9079 9627 +9079 9854 +9080 9408 +9080 9292 +9081 9943 +9081 9881 +9082 9897 +9082 9663 +9082 9323 +9082 9464 +9082 9341 +9083 9802 +9085 9889 +9085 9785 +9086 9644 +9086 9935 +9087 9112 +9088 9576 +9088 9845 +9089 9943 +9090 9639 +9091 9170 +9093 9504 +9094 9319 +9097 9684 +9097 9557 +9097 9560 +9099 9935 +9099 9140 +9099 9814 +9100 9151 +9101 9546 +9102 9969 +9103 9477 +9103 9875 +9103 9934 +9104 9881 +9104 9525 +9104 9555 +9104 9724 +9104 9214 +9105 9267 +9105 9466 +9106 9458 +9107 9782 +9107 9706 +9108 9242 +9109 9568 +9109 9501 +9110 9318 +9111 9744 +9111 9809 +9112 9981 +9113 9467 +9114 9990 +9114 9876 +9115 9382 +9115 9385 +9115 9995 +9115 9310 +9115 9587 +9116 9911 +9116 9576 +9116 9208 +9117 9942 +9119 9547 +9119 9850 +9120 9197 +9121 9270 +9121 9996 +9121 9866 +9121 9995 +9121 9145 +9122 9230 +9124 9291 +9124 9906 +9124 9897 +9124 9211 +9124 9534 +9126 9130 +9126 9263 +9127 9929 +9127 9845 +9128 9376 +9128 9492 +9129 9570 +9130 9238 +9130 9349 +9131 9484 +9131 9139 +9131 9664 +9132 9317 +9132 9950 +9133 9319 +9135 9315 +9135 9662 +9135 9760 +9136 9382 +9137 9369 +9138 9730 +9139 9861 +9139 9513 +9140 9997 +9140 9614 +9140 9943 +9140 9619 +9141 9537 +9141 9834 +9144 9619 +9146 9849 +9146 9518 +9146 9584 +9146 9582 +9147 9387 +9147 9446 +9147 9202 +9148 9713 +9149 9265 +9151 9443 +9152 9536 +9152 9478 +9153 9900 +9154 9731 +9154 9220 +9155 9892 +9155 9475 +9155 9693 +9155 9257 +9155 9359 +9155 9914 +9156 9672 +9157 9603 +9157 9882 +9157 9247 +9158 9545 +9158 9708 +9158 9722 +9158 9532 +9159 9621 +9161 9461 +9163 9820 +9164 9195 +9165 9653 +9165 9237 +9166 9960 +9167 9997 +9167 9622 +9168 9955 +9169 9899 +9169 9183 +9170 9873 +9170 9380 +9170 9300 +9170 9559 +9170 9329 +9170 9591 +9171 9499 +9171 9640 +9172 9429 +9173 9772 +9174 9859 +9174 9352 +9174 9666 +9174 9442 +9179 9608 +9180 9451 +9180 9272 +9181 9972 +9182 9568 +9182 9213 +9184 9573 +9184 9552 +9184 9338 +9184 9630 +9186 9658 +9187 9601 +9188 9431 +9188 9564 +9189 9427 +9191 9734 +9191 9621 +9193 9230 +9195 9365 +9195 9804 +9198 9223 +9198 9633 +9198 9560 +9199 9308 +9201 9512 +9201 9516 +9201 9293 +9201 9941 +9202 9346 +9204 9457 +9204 9943 +9205 9916 +9205 9372 +9206 9986 +9206 9894 +9206 9311 +9207 9981 +9207 9719 +9207 9822 +9209 9532 +9209 9946 +9210 9377 +9210 9625 +9210 9658 +9210 9749 +9211 9588 +9212 9464 +9213 9481 +9215 9268 +9215 9582 +9216 9823 +9217 9804 +9217 9932 +9218 9505 +9218 9442 +9220 9571 +9221 9242 +9223 9991 +9223 9249 +9224 9814 +9225 9600 +9225 9432 +9226 9441 +9227 9739 +9227 9587 +9227 9563 +9228 9368 +9228 9535 +9229 9480 +9231 9250 +9231 9529 +9232 9632 +9232 9998 +9232 9583 +9232 9651 +9233 9506 +9233 9913 +9233 9589 +9233 9590 +9234 9990 +9234 9304 +9236 9395 +9236 9309 +9238 9453 +9239 9968 +9240 9649 +9240 9743 +9241 9588 +9241 9775 +9242 9352 +9242 9848 +9244 9298 +9244 9767 +9245 9893 +9246 9966 +9247 9551 +9248 9706 +9248 9727 +9249 9926 +9249 9514 +9249 9841 +9250 9665 +9250 9407 +9252 9312 +9252 9907 +9252 9362 +9252 9529 +9253 9857 +9253 9748 +9253 9988 +9255 9773 +9255 9822 +9257 9927 +9257 9740 +9257 9536 +9258 9926 +9258 9750 +9259 9740 +9259 9872 +9260 9358 +9261 9961 +9262 9626 +9262 9760 +9262 9401 +9263 9770 +9264 9608 +9264 9783 +9264 9595 +9265 9837 +9266 9721 +9267 9332 +9268 9347 +9268 9601 +9268 9766 +9268 9803 +9268 9744 +9269 9985 +9269 9888 +9269 9556 +9269 9957 +9270 9994 +9270 9385 +9270 9432 +9271 9666 +9271 9561 +9271 9902 +9271 9787 +9271 9678 +9272 9946 +9273 9756 +9274 9706 +9275 9480 +9276 9732 +9276 9413 +9276 9663 +9277 9368 +9277 9653 +9278 9473 +9278 9305 +9279 9619 +9279 9585 +9279 9386 +9279 9645 +9279 9945 +9280 9645 +9280 9959 +9280 9450 +9281 9364 +9282 9818 +9283 9790 +9284 9352 +9284 9754 +9284 9851 +9285 9805 +9286 9985 +9286 9375 +9286 9471 +9287 9489 +9288 9309 +9289 9487 +9289 9957 +9289 9332 +9289 9559 +9289 9402 +9290 9905 +9292 9534 +9293 9737 +9293 9869 +9293 9425 +9293 9319 +9293 9968 +9294 9651 +9294 9437 +9296 9314 +9297 9489 +9298 9537 +9298 9785 +9299 9794 +9299 9842 +9299 9884 +9300 9770 +9300 9435 +9302 9769 +9303 9405 +9303 9841 +9303 9977 +9304 9671 +9305 9469 +9306 9589 +9306 9630 +9307 9983 +9307 9397 +9308 9866 +9308 9973 +9309 9825 +9311 9441 +9311 9703 +9312 9314 +9312 9449 +9312 9832 +9312 9406 +9315 9912 +9317 9605 +9319 9394 +9320 9644 +9321 9775 +9323 9334 +9324 9649 +9325 9928 +9327 9492 +9328 9726 +9329 9576 +9330 9382 +9331 9537 +9331 9926 +9331 9800 +9332 9531 +9333 9873 +9333 9860 +9334 9396 +9334 9944 +9335 9415 +9335 9398 +9336 9939 +9338 9977 +9339 9363 +9339 9591 +9340 9802 +9340 9612 +9341 9604 +9342 9964 +9343 9605 +9343 9762 +9343 9506 +9343 9811 +9345 9454 +9346 9644 +9348 9601 +9348 9713 +9349 9568 +9349 9428 +9349 9500 +9349 9471 +9354 9483 +9355 9511 +9357 9926 +9358 9853 +9360 9993 +9360 9782 +9360 9887 +9362 9636 +9362 9830 +9362 9977 +9362 9773 +9362 9517 +9363 9530 +9364 9528 +9365 9899 +9367 9924 +9368 9571 +9368 9844 +9368 9598 +9369 9592 +9370 9587 +9372 9842 +9374 9737 +9374 9918 +9375 9471 +9376 9700 +9376 9461 +9376 9598 +9377 9574 +9377 9660 +9382 9601 +9382 9986 +9382 9962 +9383 9680 +9384 9522 +9384 9574 +9387 9579 +9388 9730 +9388 9427 +9388 9562 +9390 9621 +9390 9941 +9390 9560 +9390 9769 +9391 9483 +9391 9852 +9392 9537 +9392 9461 +9394 9543 +9396 9474 +9396 9406 +9398 9830 +9399 9576 +9399 9546 +9401 9480 +9401 9875 +9403 9493 +9403 9789 +9403 9407 +9403 9956 +9404 9652 +9405 9512 +9405 9556 +9407 9958 +9407 9556 +9409 9506 +9409 9912 +9410 9963 +9411 9866 +9411 9616 +9411 9633 +9411 9454 +9412 9512 +9412 9706 +9413 9476 +9413 9846 +9415 9883 +9415 9515 +9415 9517 +9415 9847 +9417 9984 +9417 9836 +9418 9595 +9418 9630 +9419 9850 +9420 9573 +9420 9616 +9420 9537 +9420 9467 +9421 9680 +9421 9653 +9423 9436 +9423 9567 +9425 9826 +9425 9623 +9425 9528 +9426 9975 +9426 9791 +9428 9642 +9428 9785 +9429 9889 +9429 9563 +9429 9470 +9432 9771 +9434 9501 +9435 9832 +9436 9706 +9437 9769 +9441 9978 +9443 9679 +9444 9682 +9445 9719 +9446 9536 +9446 9570 +9446 9749 +9447 9617 +9447 9836 +9447 9469 +9449 9644 +9450 9459 +9451 9845 +9453 9913 +9454 9491 +9454 9783 +9455 9994 +9456 9546 +9456 9686 +9458 9486 +9458 9542 +9458 9805 +9458 9982 +9459 9802 +9460 9811 +9460 9813 +9461 9992 +9462 9896 +9466 9990 +9466 9943 +9466 9817 +9467 9641 +9468 9908 +9468 9561 +9469 9876 +9469 9885 +9469 9907 +9470 9601 +9471 9528 +9473 9872 +9473 9847 +9474 9993 +9475 9862 +9475 9569 +9477 9641 +9479 9550 +9479 9672 +9481 9666 +9481 9528 +9482 9831 +9482 9866 +9484 9937 +9484 9871 +9485 9896 +9486 9653 +9488 9779 +9488 9850 +9489 9799 +9490 9510 +9493 9667 +9493 9702 +9493 9812 +9494 9771 +9494 9563 +9496 9614 +9496 9907 +9497 9675 +9497 9568 +9502 9611 +9504 9801 +9505 9896 +9505 9962 +9506 9831 +9506 9676 +9507 9772 +9507 9785 +9508 9541 +9508 9578 +9509 9572 +9509 9908 +9509 9786 +9511 9637 +9511 9937 +9514 9943 +9516 9803 +9517 9793 +9518 9565 +9519 9991 +9519 9570 +9519 9551 +9519 9535 +9520 9785 +9521 9825 +9521 9708 +9523 9669 +9524 9541 +9525 9858 +9526 9605 +9527 9898 +9527 9833 +9528 9658 +9531 9783 +9532 9558 +9533 9946 +9535 9952 +9536 9845 +9537 9610 +9538 9603 +9538 9790 +9539 9619 +9539 9975 +9543 9994 +9545 9904 +9545 9932 +9546 9994 +9546 9848 +9548 9730 +9549 9977 +9550 9816 +9551 9681 +9551 9700 +9553 9850 +9554 9635 +9555 9856 +9561 9750 +9561 9638 +9561 9783 +9562 9922 +9562 9930 +9563 9861 +9563 9987 +9563 9703 +9564 9753 +9566 9746 +9568 9777 +9568 9688 +9569 9664 +9573 9731 +9574 9667 +9574 9873 +9575 9730 +9575 9646 +9577 9610 +9578 9653 +9581 9850 +9583 9844 +9583 9758 +9585 9936 +9588 9783 +9589 9747 +9589 9652 +9590 9814 +9595 9853 +9596 9954 +9599 9768 +9602 9633 +9602 9650 +9603 9779 +9603 9951 +9606 9788 +9607 9858 +9610 9623 +9611 9850 +9612 9730 +9615 9905 +9616 9844 +9617 9874 +9618 9662 +9619 9720 +9620 9989 +9622 9727 +9623 9987 +9623 9829 +9623 9949 +9624 9643 +9626 9948 +9627 9831 +9627 9649 +9629 9789 +9630 9666 +9634 9864 +9637 9743 +9638 9732 +9638 9897 +9638 9901 +9639 9701 +9641 9703 +9642 9836 +9643 9877 +9645 9795 +9645 9832 +9648 9998 +9650 9844 +9650 9723 +9652 9679 +9655 9924 +9655 9967 +9657 9665 +9657 9780 +9659 9676 +9661 9808 +9661 9992 +9661 9913 +9662 9862 +9665 9784 +9669 9999 +9670 9704 +9673 9775 +9673 9681 +9677 9685 +9679 9993 +9680 9771 +9680 9815 +9681 9981 +9684 9720 +9685 9767 +9686 9709 +9687 9837 +9688 9820 +9688 9958 +9688 9983 +9689 9934 +9691 9803 +9696 9840 +9696 9980 +9699 9995 +9699 9812 +9700 9789 +9701 9873 +9705 9965 +9705 9777 +9706 9985 +9709 9894 +9712 9906 +9715 9870 +9717 9954 +9719 9985 +9719 9899 +9722 9821 +9726 9794 +9726 9804 +9728 9901 +9730 9861 +9731 9982 +9733 9863 +9737 9920 +9740 9786 +9741 9869 +9742 9801 +9742 9744 +9743 9754 +9743 9855 +9747 9766 +9747 9938 +9748 9914 +9749 9914 +9750 9823 +9751 9892 +9755 9974 +9758 9930 +9761 9842 +9762 9778 +9762 9847 +9763 9813 +9763 9914 +9764 9766 +9766 9877 +9769 9856 +9772 9903 +9776 9997 +9777 9790 +9777 9924 +9781 9788 +9791 9991 +9792 9984 +9792 9863 +9794 9875 +9796 9861 +9796 9993 +9796 9980 +9799 9937 +9801 9865 +9801 9823 +9802 9978 +9803 9944 +9803 9960 +9811 9935 +9812 9911 +9817 9882 +9824 9837 +9826 9904 +9828 9871 +9828 9923 +9836 9843 +9836 9944 +9838 9944 +9845 9876 +9847 9867 +9847 9935 +9848 9926 +9854 9899 +9855 9939 +9856 9888 +9858 9984 +9861 9893 +9863 9932 +9863 9875 +9869 9914 +9875 9885 +9878 9920 +9879 9974 +9880 9905 +9888 9980 +9895 9921 +9897 9929 +9897 9930 +9900 9982 +9906 9971 +9910 9968 +9915 9973 +9918 9973 +9927 9934 +9932 9953 +9949 9973 +9953 9990 +9957 9966 +9973 9981 +9981 9998 diff --git a/snap-python/source/test/data/p2p-Gnutella08.html b/snap-python/source/test/data/p2p-Gnutella08.html new file mode 100644 index 0000000000000000000000000000000000000000..332e83a2e34f234c2cf0f3f656c119935922ca43 --- /dev/null +++ b/snap-python/source/test/data/p2p-Gnutella08.html @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + +
Dataset statistics
Nodes 6301
Edges 20777
Nodes in largest WCC 6299 (1.000)
Edges in largest WCC 20776 (1.000)
Nodes in largest SCC 2068 (0.328)
Edges in largest SCC 9313 (0.448)
Average clustering coefficient 0.0109
Number of triangles 2383
Fraction of closed triangles 0.006983
Diameter (longest shortest path) 9
90-percentile effective diameter 5.5
+
+ + + + + + + + + + +
FileDescription
data/p2p-Gnutella08.txt.gzepinions
diff --git a/snap-python/source/test/data/p2p-Gnutella08.txt b/snap-python/source/test/data/p2p-Gnutella08.txt new file mode 100644 index 0000000000000000000000000000000000000000..dd27fa2e15513b80321b4d8773fa7afaca279238 --- /dev/null +++ b/snap-python/source/test/data/p2p-Gnutella08.txt @@ -0,0 +1,20781 @@ +# Directed graph: data/p2p-Gnutella08.txt +# epinions +# Nodes: 6301 Edges: 20777 +# FromNodeId ToNodeId +0 1 +0 2 +0 3 +0 4 +0 5 +0 6 +0 7 +0 8 +0 9 +0 10 +3 703 +3 826 +3 1097 +3 1287 +3 1591 +3 1895 +3 1896 +3 1897 +3 1898 +3 1899 +4 144 +4 258 +4 491 +4 1021 +4 1418 +4 1669 +4 1900 +4 1901 +4 1902 +4 1903 +5 121 +5 127 +5 128 +5 179 +5 247 +5 249 +5 264 +5 353 +5 424 +5 426 +7 145 +7 176 +7 177 +7 353 +7 753 +7 754 +7 762 +7 2064 +7 3002 +8 520 +8 665 +8 852 +8 1394 +8 1786 +8 1842 +8 1904 +8 1905 +8 1906 +8 1907 +9 124 +9 147 +9 177 +9 246 +9 247 +9 248 +9 249 +9 250 +9 251 +9 252 +703 898 +703 1581 +703 1620 +703 2634 +703 2635 +703 2636 +703 2637 +703 2638 +703 2639 +703 2640 +1287 38 +1287 331 +1287 626 +1287 1945 +1287 2690 +1287 3137 +1287 3138 +1287 3139 +1287 3140 +1287 3141 +1895 1860 +1896 1118 +1896 1227 +1896 1334 +1896 1556 +1896 1980 +1896 2333 +1896 3672 +1896 3677 +1896 3678 +1896 3679 +144 8 +144 121 +144 122 +144 125 +144 146 +144 246 +144 249 +144 264 +144 367 +1669 1573 +1669 3023 +1669 3216 +1669 3413 +1669 3414 +1669 3415 +1669 3416 +1669 3417 +1669 3418 +127 9 +127 144 +127 175 +127 177 +127 247 +127 427 +127 698 +127 762 +127 1246 +127 2076 +179 4 +179 9 +179 17 +179 31 +179 123 +179 125 +179 250 +179 559 +179 2018 +247 776 +247 900 +247 1067 +247 1068 +247 1069 +247 1070 +247 1071 +247 1072 +247 1073 +247 1074 +249 123 +249 250 +249 251 +249 351 +249 753 +249 755 +249 762 +249 983 +264 249 +264 697 +264 1787 +264 2193 +264 2194 +264 2224 +264 2225 +264 2226 +264 2227 +264 2228 +353 122 +353 123 +353 127 +353 249 +353 251 +353 367 +353 368 +353 666 +353 754 +353 856 +424 940 +424 960 +424 2409 +424 2410 +424 2411 +424 2412 +424 2413 +424 2414 +424 2415 +145 149 +145 246 +145 265 +145 367 +145 390 +145 667 +145 717 +145 1317 +145 2098 +176 5 +176 248 +176 369 +176 697 +176 700 +176 946 +176 947 +176 2001 +176 2122 +177 143 +177 145 +177 149 +177 266 +177 367 +177 368 +177 559 +177 856 +177 1245 +753 9 +753 121 +753 122 +753 127 +753 128 +753 129 +753 145 +753 177 +753 367 +762 3 +762 175 +762 176 +762 251 +762 264 +762 266 +762 559 +762 754 +762 2001 +762 2018 +665 4 +665 5 +665 9 +665 126 +665 148 +665 252 +665 352 +665 353 +665 666 +665 667 +852 250 +852 938 +852 1097 +852 1556 +852 1990 +852 2748 +852 2749 +852 2750 +852 2751 +852 2752 +1394 9 +1394 126 +1394 129 +1394 177 +1394 248 +1394 266 +1394 353 +1394 754 +1394 1317 +1394 2018 +1786 122 +1786 125 +1786 142 +1786 146 +1786 248 +1786 249 +1786 264 +1786 367 +1786 1245 +1842 628 +1842 1342 +1842 1383 +1842 2494 +1842 3577 +1842 3578 +1842 3579 +1842 3580 +1842 3581 +1842 3582 +1904 7 +1904 129 +1904 144 +1904 149 +1904 174 +1904 247 +1904 248 +1904 252 +1904 353 +1907 4 +1907 7 +1907 129 +1907 145 +1907 149 +1907 174 +1907 266 +1907 666 +124 122 +124 123 +124 145 +124 147 +124 176 +124 248 +124 390 +124 762 +124 2063 +124 2064 +147 8 +147 128 +147 176 +147 177 +147 264 +147 367 +147 424 +147 427 +147 1246 +248 326 +248 914 +248 915 +248 916 +248 917 +248 918 +248 919 +248 920 +248 921 +248 922 +250 51 +250 64 +250 114 +250 1349 +250 1389 +250 1644 +250 1726 +250 2018 +250 4180 +250 4181 +251 513 +251 586 +251 873 +251 1064 +251 1412 +251 2206 +251 2207 +251 2208 +251 2209 +251 2210 +252 62 +252 808 +252 1475 +252 2211 +252 2212 +252 2213 +252 2214 +252 2215 +252 2216 +898 1620 +898 2785 +1620 112 +1620 342 +1620 1658 +1620 2262 +1620 2612 +1620 2634 +1620 2706 +1620 3027 +1620 3382 +1620 3383 +2634 106 +2634 510 +2634 558 +2634 1817 +2634 2595 +2634 2635 +2634 3409 +2634 3897 +2634 4229 +2635 955 +2635 1265 +2635 1427 +2635 1584 +2635 1602 +2635 1699 +2635 2269 +2635 3310 +2635 4238 +2635 4239 +2638 179 +2638 1061 +2638 1317 +2638 2720 +2638 2721 +2638 3821 +2638 4230 +2638 4231 +2638 4232 +2638 4233 +2639 71 +2639 296 +2639 527 +2639 804 +2639 1017 +2639 2051 +2639 3215 +2639 3362 +2639 4234 +2639 4235 +38 725 +38 1376 +38 1915 +38 2002 +38 2007 +38 2167 +38 2168 +38 2169 +38 2170 +331 100 +331 332 +331 333 +331 334 +331 335 +331 336 +331 337 +331 338 +331 339 +1945 151 +1945 178 +1945 814 +1945 1144 +1945 1228 +1945 1653 +1945 2288 +1945 3722 +1945 3723 +1945 3724 +2690 581 +2690 1493 +2690 1636 +2690 1936 +2690 2234 +2690 2823 +2690 4258 +2690 4259 +2690 4260 +2690 4261 +3137 102 +3137 264 +3137 753 +3137 755 +3137 1212 +3137 3146 +3137 3849 +3137 4455 +3137 4546 +3137 4547 +3138 127 +3138 143 +3138 252 +3138 369 +3138 390 +3138 754 +3138 1387 +3138 1912 +3138 2050 +3138 4487 +3140 477 +3140 2593 +3140 2746 +3140 3364 +3140 3687 +3140 4159 +3140 4437 +3140 5629 +3140 5931 +3140 6071 +1118 560 +1118 813 +1118 2011 +1118 2625 +1118 2996 +1118 2997 +1118 2998 +1118 2999 +1118 3000 +1118 3001 +1556 123 +1556 700 +1556 792 +1556 859 +1556 1491 +1556 2184 +1556 3373 +1556 3374 +1556 3375 +1556 3376 +2333 126 +2333 529 +2333 1334 +2333 1706 +2333 1891 +2333 2344 +2333 3096 +2333 3672 +2333 3822 +2333 4030 +122 578 +122 658 +122 1428 +122 1451 +122 2057 +122 2058 +122 2059 +122 2060 +122 2061 +122 2062 +125 132 +125 222 +125 503 +125 1535 +125 2070 +125 2071 +125 2072 +125 2073 +125 2074 +125 2075 +146 7 +146 285 +146 3337 +146 5048 +146 5171 +146 5338 +146 5940 +146 5941 +146 5942 +367 4 +367 5 +367 7 +367 264 +367 266 +367 559 +367 666 +367 1317 +1573 224 +1573 490 +1573 491 +1573 496 +1573 1123 +1573 1140 +1573 2221 +1573 2222 +1573 2705 +1573 2953 +1573 2973 +1573 3376 +1573 3408 +3023 144 +3023 148 +3023 149 +3023 420 +3023 551 +3023 559 +3023 1184 +3023 1994 +3023 4425 +3023 4459 +3415 17 +3415 125 +3415 148 +3415 266 +3415 559 +3415 697 +3415 753 +3415 1317 +3415 1920 +3417 122 +3417 129 +3417 143 +3417 177 +3417 246 +3417 251 +3417 367 +3417 390 +3417 666 +175 1575 +175 3066 +175 3344 +175 3715 +175 3849 +175 4539 +175 5209 +175 5325 +175 5483 +175 5584 +427 4 +427 124 +427 251 +427 265 +427 353 +427 369 +427 695 +427 700 +427 946 +427 947 +17 1050 +17 2254 +17 2761 +17 3147 +17 3169 +17 3619 +17 3893 +17 4408 +17 4953 +31 124 +31 637 +31 870 +31 1219 +31 1954 +31 2237 +31 2524 +31 2630 +31 3637 +31 3874 +123 3 +123 7 +123 143 +123 145 +123 146 +123 147 +123 252 +123 367 +123 390 +123 423 +559 119 +559 756 +559 759 +559 818 +559 819 +559 820 +559 821 +559 822 +559 823 +559 824 +1067 969 +1067 1570 +1067 2976 +1067 2977 +1068 1688 +1068 2493 +1068 2972 +1068 2973 +1068 2974 +1070 2975 +351 121 +351 176 +351 352 +351 353 +351 354 +351 355 +351 356 +351 357 +351 358 +351 359 +697 870 +697 1441 +697 1589 +697 2034 +697 2214 +697 2597 +697 2598 +697 2599 +697 2600 +697 2601 +1787 549 +1787 802 +1787 1115 +1787 1574 +1787 1788 +1787 3563 +1787 3700 +1787 3701 +1787 3702 +2193 5 +2193 124 +2193 144 +2193 147 +2193 176 +2193 248 +2193 427 +2193 629 +2193 3914 +2193 3915 +2224 122 +2224 127 +2224 175 +2224 249 +2224 266 +2224 367 +2224 390 +2224 423 +2224 697 +2225 604 +2225 1054 +2225 1129 +2225 2278 +2225 2476 +2225 2600 +2225 2733 +2225 3235 +2225 3931 +2225 3932 +2226 260 +2226 282 +2226 822 +2226 889 +2226 1143 +2226 1975 +2226 2042 +2226 2414 +2226 2867 +2226 3933 +2228 222 +2228 1173 +2228 1374 +2228 2358 +2228 2552 +2228 3354 +2228 3934 +2228 3935 +2228 3936 +2228 3937 +856 5 +856 7 +856 145 +856 149 +856 174 +856 179 +856 180 +856 1317 +856 2018 +2411 246 +2411 351 +2411 503 +2411 944 +2411 2077 +2411 2593 +2411 3229 +2411 4089 +2411 4090 +2411 4091 +149 5 +149 10 +149 128 +149 148 +149 238 +149 250 +149 252 +149 265 +149 353 +149 1317 +390 108 +390 261 +390 391 +390 392 +390 393 +390 394 +390 395 +390 396 +390 397 +390 398 +667 152 +667 459 +667 468 +667 1350 +667 1956 +667 2578 +667 2579 +667 2580 +667 2581 +717 124 +717 175 +717 265 +717 369 +717 390 +717 426 +717 427 +717 554 +717 695 +717 754 +1317 1036 +1317 1534 +1317 2362 +1317 3109 +1317 3163 +1317 3164 +1317 3165 +1317 3166 +1317 3167 +1317 3168 +369 9 +369 145 +369 174 +369 246 +369 264 +369 266 +369 422 +369 559 +369 666 +700 584 +700 1056 +700 1517 +700 2614 +700 2615 +700 2616 +700 2617 +700 2618 +700 2619 +700 2620 +2001 253 +2001 261 +2001 924 +2001 1606 +2001 1867 +2001 2071 +2001 2281 +2001 3336 +2001 3771 +2001 3772 +143 122 +143 124 +143 128 +143 146 +143 246 +143 249 +143 367 +143 426 +143 427 +143 2098 +1245 5 +1245 126 +1245 146 +1245 147 +1245 149 +1245 175 +1245 180 +1245 368 +1245 422 +1245 2018 +129 133 +129 219 +129 778 +129 864 +129 2078 +129 2079 +129 2080 +129 2081 +129 2082 +129 2083 +126 127 +126 369 +126 696 +126 698 +126 754 +126 755 +126 946 +126 947 +126 2001 +126 2077 +148 121 +148 122 +148 123 +148 124 +148 176 +148 246 +148 248 +148 367 +148 422 +148 1245 +352 4 +352 146 +352 176 +352 249 +352 266 +352 367 +352 368 +352 422 +352 2001 +938 253 +938 534 +938 547 +938 939 +938 940 +938 941 +938 942 +938 943 +938 944 +938 945 +2748 165 +2748 1066 +2748 1140 +2748 3096 +2748 3801 +2748 3946 +2748 4153 +2748 4300 +2748 4301 +2748 4302 +2750 7 +2750 8 +2750 125 +2750 128 +2750 174 +2750 238 +2750 368 +2750 424 +2750 717 +2750 856 +2751 4 +2751 147 +2751 180 +2751 249 +2751 367 +2751 368 +2751 369 +2751 390 +2751 422 +2751 856 +628 9 +628 144 +628 145 +628 147 +628 149 +628 175 +628 176 +628 369 +628 629 +628 630 +1383 327 +1383 782 +1383 815 +1383 2359 +1383 2451 +1383 2964 +1383 3211 +1383 3227 +1383 3228 +1383 3229 +2494 1433 +2494 1978 +2494 2032 +2494 3530 +2494 4129 +3577 3 +3577 9 +3577 123 +3577 124 +3577 149 +3577 247 +3577 249 +3577 352 +3577 369 +3577 427 +3579 7 +3579 149 +3579 252 +3579 715 +3579 1481 +3579 2001 +3579 4172 +3579 4586 +3579 4679 +3579 4794 +3581 3750 +174 3 +174 5 +174 7 +174 122 +174 126 +174 142 +174 145 +174 249 +174 427 +174 667 +326 922 +326 1004 +326 2277 +326 2278 +326 2279 +326 2280 +326 2281 +326 2282 +326 2283 +326 2284 +914 2042 +918 451 +918 1047 +918 1213 +918 1376 +918 1708 +918 2624 +918 2818 +918 2819 +918 2820 +919 121 +919 122 +919 123 +919 126 +919 145 +919 149 +919 180 +919 250 +919 559 +922 2809 +922 2810 +922 2811 +922 2812 +922 2813 +922 2814 +922 2815 +922 2816 +922 2817 +64 91 +64 102 +64 106 +64 1946 +64 1947 +64 1948 +64 1949 +64 1950 +64 1951 +64 1952 +1389 143 +1389 732 +1389 1390 +1389 1391 +1389 1392 +1389 1393 +1389 1394 +1389 1395 +1389 1396 +1389 1397 +1644 424 +1644 823 +1644 1414 +1644 2040 +1644 2125 +1644 2399 +1644 2880 +1644 3162 +1644 3394 +1644 3395 +4180 143 +4180 476 +4180 693 +4180 911 +4180 1272 +4180 1273 +4180 2808 +4180 5126 +4180 5127 +4180 5128 +586 8 +586 126 +586 128 +586 149 +586 175 +586 247 +586 248 +586 666 +586 717 +586 754 +873 1227 +873 1336 +873 2392 +873 2433 +873 2581 +873 2756 +873 2757 +873 2758 +873 2759 +873 2760 +1412 9 +1412 127 +1412 145 +1412 149 +1412 174 +1412 179 +1412 264 +1412 422 +1412 427 +1412 1317 +62 1064 +62 1194 +62 1196 +62 1198 +62 1959 +62 1960 +62 1961 +62 1962 +62 1963 +112 1064 +112 1160 +112 2044 +112 2045 +112 2046 +112 2047 +112 2048 +112 2049 +112 2050 +1658 92 +1658 860 +1658 963 +1658 1767 +1658 2015 +1658 2880 +1658 2953 +1658 3409 +1658 3410 +1658 3411 +2262 2354 +2262 2385 +2262 2687 +2262 2881 +2262 3951 +2612 726 +2612 1571 +2612 1789 +2612 2274 +2612 2630 +2612 3423 +2612 3570 +2612 3951 +2612 4210 +2612 4211 +3027 29 +3027 38 +3027 576 +3027 1208 +3027 2018 +3027 2291 +3027 2396 +3027 4468 +3027 4469 +3027 4470 +3382 1547 +3382 2331 +3382 2348 +3382 3194 +3382 3617 +3382 4665 +3382 4719 +3382 4720 +3382 4721 +3383 835 +3383 1003 +3383 1288 +3383 2788 +3383 2867 +3383 4625 +3383 4722 +3383 4723 +3383 4724 +558 7 +558 17 +558 122 +558 144 +558 146 +558 250 +558 353 +558 698 +558 5570 +558 5571 +3409 288 +3409 325 +3409 707 +3409 1120 +3409 1211 +3409 1904 +3409 3439 +3409 3849 +3409 4369 +3409 4754 +3897 1223 +3897 3695 +3897 3981 +3897 4059 +3897 4371 +955 690 +955 711 +955 781 +955 908 +955 1337 +955 1541 +955 1901 +955 2214 +955 2422 +955 2428 +955 2805 +955 2837 +955 2838 +955 2839 +955 2840 +955 2841 +955 2842 +955 2843 +1265 2377 +1427 2377 +1584 1036 +1602 121 +1602 122 +1602 123 +1602 143 +1602 246 +1602 247 +1602 249 +1602 264 +1602 352 +1602 1245 +1699 813 +1699 1064 +1699 2207 +1699 3241 +1699 3463 +1699 3464 +1699 3465 +1699 3466 +1699 3467 +2269 738 +2269 2500 +2269 3798 +2269 3855 +2269 3952 +2269 3953 +2269 3954 +2269 3955 +2269 3956 +2269 3957 +3310 296 +3310 1444 +3310 1529 +3310 2453 +3310 3211 +3310 4664 +3310 4665 +3310 4666 +3310 4667 +3310 4668 +4239 2184 +2721 959 +2721 1526 +2721 2341 +2721 2397 +2721 2524 +2721 3215 +2721 3441 +2721 3695 +2721 4290 +4230 781 +4230 1106 +4230 3119 +4230 3344 +4230 3683 +4230 4156 +4230 5000 +4230 5151 +4230 5152 +4230 5153 +4232 962 +4232 2338 +4232 2361 +4232 2885 +4232 5053 +527 1020 +527 1171 +527 1342 +527 2671 +527 2837 +527 2935 +527 3786 +527 3840 +527 4248 +527 4455 +527 4876 +527 4979 +527 4980 +804 778 +804 805 +804 806 +804 807 +804 808 +804 809 +804 810 +804 811 +804 812 +804 813 +804 814 +804 815 +804 816 +804 817 +4234 146 +4234 177 +4234 238 +4234 264 +4234 352 +4234 424 +4234 427 +4234 2098 +4235 1516 +4235 1698 +4235 1786 +4235 1804 +4235 2218 +4235 2400 +4235 3129 +4235 3362 +4235 3473 +4235 5154 +2007 199 +2007 203 +2007 527 +2007 3581 +2007 3680 +2007 3785 +2007 3786 +2007 3787 +2007 3788 +2007 3789 +100 2017 +334 268 +334 376 +334 843 +334 1587 +334 1888 +334 2053 +334 2285 +334 2286 +334 2287 +335 81 +335 141 +335 494 +335 1052 +335 2023 +335 2319 +335 3590 +335 4152 +335 4153 +335 4154 +339 4 +339 5 +339 7 +339 148 +339 264 +339 364 +339 559 +339 1317 +339 1755 +339 2278 +151 152 +151 153 +151 154 +151 155 +151 156 +151 157 +151 158 +151 159 +151 160 +151 161 +178 255 +178 256 +178 554 +178 871 +178 1947 +178 2125 +178 2126 +178 2127 +178 2128 +178 2129 +1144 17 +1144 31 +1144 126 +1144 143 +1144 144 +1144 145 +1144 149 +1144 266 +1144 422 +1144 754 +1228 23 +1228 123 +1228 126 +1228 173 +1228 1896 +1228 3323 +1228 4906 +1228 4907 +1653 69 +1653 485 +1653 1246 +1653 1563 +1653 3403 +2288 3453 +2288 3791 +2288 3971 +2288 3972 +2288 3973 +2288 3974 +2288 3975 +2288 3976 +2288 3977 +2288 3978 +581 2538 +1493 1227 +1636 197 +1636 1553 +1636 1672 +1636 2629 +1636 3033 +1636 3389 +1636 3390 +1636 3391 +1636 3392 +1636 3393 +2823 1089 +2823 1915 +2823 2021 +2823 2884 +2823 3119 +2823 4165 +2823 4321 +2823 4322 +2823 4323 +2823 4324 +4260 3 +4260 9 +4260 123 +4260 124 +4260 149 +4260 238 +4260 249 +4260 352 +4260 367 +4260 369 +102 1928 +102 1968 +102 2026 +102 2027 +102 2028 +1212 665 +1212 777 +1212 840 +1212 1385 +1212 1402 +1212 1724 +1212 2790 +1212 3079 +1212 3080 +3849 8 +3849 123 +3849 129 +3849 174 +3849 248 +3849 352 +3849 369 +3849 424 +3849 1317 +3849 2338 +1387 860 +1387 1454 +1387 1457 +1387 1509 +1387 3220 +1387 3221 +1387 3280 +2050 136 +2050 458 +2050 1414 +2050 1661 +2050 1747 +2050 2630 +2050 3822 +2050 3823 +2050 3824 +2050 3825 +4487 842 +4487 1103 +4487 1141 +4487 1481 +4487 2201 +4487 2453 +4487 3207 +4487 3327 +4487 3714 +4487 4111 +2593 866 +2593 932 +2593 1303 +2593 1377 +2593 1492 +2593 4190 +2593 4191 +2593 4192 +2593 4193 +3364 135 +3364 840 +3364 968 +3364 1740 +3364 1741 +3364 3132 +3364 3334 +3364 4705 +3364 4706 +4159 230 +4159 1425 +4159 2058 +4159 2869 +4159 3759 +4159 3786 +4159 4068 +4159 4270 +4159 5361 +4159 5788 +5629 92 +5629 133 +5629 177 +5629 731 +5629 2443 +5629 2779 +5629 4111 +5629 4646 +5629 5775 +5931 731 +5931 1129 +5931 5228 +5931 5686 +5931 5999 +6071 364 +6071 3298 +6071 5014 +6071 5081 +6071 5179 +6071 5980 +6071 6249 +6071 6250 +6071 6251 +6071 6252 +560 561 +560 562 +560 563 +560 564 +560 565 +560 566 +560 567 +560 568 +560 569 +560 570 +2997 738 +2997 1635 +2997 1650 +2997 2312 +2997 2337 +2997 2414 +2997 2554 +2997 2858 +2997 3772 +2997 4444 +3001 200 +859 671 +859 860 +859 861 +859 862 +859 863 +859 864 +859 865 +859 866 +859 867 +859 868 +2184 3923 +2184 3924 +2184 3925 +2184 3926 +2184 3927 +3373 4 +3373 9 +3373 251 +3373 698 +3373 2599 +3373 4250 +3373 4710 +3373 4711 +3373 4712 +3373 4713 +3374 1090 +3374 1528 +3374 1816 +3374 2474 +3374 2524 +3374 3067 +3374 3108 +3374 3233 +3374 3755 +3374 4210 +1706 8 +1706 121 +1706 123 +1706 128 +1706 179 +1706 238 +1706 247 +1706 248 +1706 264 +1706 353 +1891 199 +1891 538 +1891 725 +1891 852 +1891 1397 +1891 2914 +1891 3166 +1891 3670 +1891 3671 +1891 3672 +3096 654 +3096 1289 +3096 1860 +3096 4459 +3096 4512 +3096 4517 +3096 4518 +3096 4519 +3096 4520 +3822 78 +3822 886 +3822 1423 +3822 2642 +3822 2982 +3822 3779 +3822 4623 +3822 4746 +3822 4939 +2060 3551 +132 5 +132 9 +132 147 +132 250 +132 353 +132 629 +132 753 +132 856 +132 1317 +132 2077 +1535 261 +1535 694 +1535 1608 +1535 1631 +1535 1940 +1535 2179 +1535 2724 +1535 3334 +1535 3335 +1535 3336 +2070 45 +2070 658 +2070 1425 +2070 2167 +2070 2595 +2070 2966 +2070 3834 +2070 3835 +2070 3836 +2070 3837 +2075 219 +2075 668 +2075 1575 +2075 1647 +2075 1786 +2075 1913 +2075 2229 +2075 2418 +2075 3586 +2075 3838 +285 134 +285 311 +285 712 +285 873 +285 955 +285 1197 +285 1227 +285 2218 +285 2219 +285 2243 +3337 32 +3337 1018 +3337 1061 +3337 1675 +3337 2723 +3337 3617 +3337 4286 +3337 4679 +3337 4680 +3337 4681 +5048 5566 +5171 795 +5171 1180 +5171 1338 +5171 2348 +5171 3453 +5171 3801 +5171 5642 +5171 5675 +5171 5676 +5171 5677 +5338 4 +5338 122 +5338 143 +5338 180 +5338 252 +5338 266 +5338 368 +5338 369 +5338 427 +5338 754 +5940 376 +5941 110 +5941 858 +5941 1169 +5941 1509 +5941 2111 +5941 3249 +5941 5978 +5941 6073 +5941 6074 +5941 6075 +490 356 +490 520 +490 852 +490 2069 +490 2167 +490 2214 +490 2403 +490 2464 +490 2465 +490 2466 +496 164 +496 418 +496 633 +496 762 +496 1471 +496 2358 +496 2376 +496 2472 +496 2473 +496 2474 +2221 152 +2221 219 +2221 976 +2221 1044 +2221 1235 +2221 2248 +2221 2673 +2221 3589 +2221 3929 +3408 462 +3408 582 +3408 940 +3408 1530 +3408 2795 +3408 3717 +3408 4237 +3408 4519 +3408 4752 +3408 4753 +551 586 +551 765 +551 955 +551 982 +551 1288 +551 1311 +551 2336 +551 2516 +551 2517 +551 2518 +1184 2259 +1994 664 +1994 788 +1994 1022 +1994 1195 +1994 1371 +1994 1688 +1994 1762 +1994 1954 +1994 2001 +1994 2226 +1994 2255 +1994 2366 +1994 2377 +1994 2384 +1994 2490 +1994 2597 +1994 3429 +1994 3778 +1994 3779 +1994 3780 +1994 3781 +1994 3782 +1994 3783 +1994 3784 +4459 2139 +4459 2425 +4459 2431 +4459 2570 +4459 4507 +4459 5017 +4459 5116 +4459 5150 +4459 5302 +4459 5303 +1920 255 +1920 1005 +1920 1048 +1920 1548 +1920 1772 +1920 1956 +1920 2709 +1920 3685 +1920 3686 +1920 3687 +3066 816 +3066 926 +3066 1568 +3066 1671 +3066 4640 +3066 4714 +3066 5001 +3066 5403 +3066 5404 +3066 5405 +3344 455 +3344 1317 +3344 3894 +3344 4688 +3344 4689 +3715 116 +3715 429 +3715 2287 +3715 4002 +3715 4476 +3715 4839 +3715 4894 +3715 4895 +3715 4896 +3715 4897 +3715 4898 +4539 1651 +4539 2166 +4539 3352 +4539 3781 +4539 4553 +4539 5068 +4539 5085 +4539 5572 +4539 5868 +4539 5884 +695 106 +695 290 +695 1690 +695 1956 +695 2385 +695 2593 +695 2594 +695 2595 +695 2596 +2761 222 +2761 1780 +2761 2008 +2761 2048 +2761 2086 +2761 3484 +2761 3981 +2761 4093 +2761 4298 +2761 4299 +3147 240 +3147 534 +3147 4270 +3147 4653 +3893 126 +3893 145 +3893 147 +3893 252 +3893 667 +3893 732 +3893 754 +3893 1909 +3893 3349 +637 796 +637 869 +637 870 +637 871 +637 872 +637 873 +637 874 +637 875 +637 876 +637 877 +2237 1402 +2237 1454 +2237 1458 +2237 1728 +2237 1866 +2237 2658 +2237 2719 +2237 2789 +2237 3220 +2237 3357 +2524 38 +2524 103 +2524 289 +2524 1252 +2524 2551 +2524 2764 +2524 3114 +2524 3926 +2524 5653 +2524 5840 +423 4 +423 127 +423 390 +423 427 +423 2403 +423 2404 +423 2405 +423 2406 +423 2407 +423 2408 +756 127 +756 262 +756 531 +756 757 +756 758 +756 759 +756 760 +756 761 +756 762 +756 763 +759 77 +759 464 +759 568 +759 1454 +759 2707 +759 2708 +759 2709 +759 2710 +759 2711 +759 2712 +820 3 +820 5 +820 7 +820 125 +820 126 +820 128 +820 145 +820 369 +820 424 +820 1317 +821 32 +821 928 +821 1223 +821 1224 +821 1231 +821 1873 +821 2734 +821 2735 +821 2736 +821 2737 +823 563 +823 894 +823 1264 +823 1322 +823 1323 +823 1324 +823 1325 +823 1326 +823 1327 +823 1328 +2974 50 +2974 892 +2974 1077 +2974 1203 +2974 2089 +2974 2562 +2974 2861 +2974 3749 +2974 4436 +2974 4437 +355 49 +355 117 +355 968 +355 2308 +355 2309 +355 2310 +355 2311 +355 2312 +355 2313 +355 2314 +356 572 +356 980 +356 1212 +356 2321 +356 2322 +356 2323 +356 2324 +356 2325 +356 2326 +356 2327 +359 520 +359 633 +359 1334 +359 1451 +359 2332 +359 2333 +359 2334 +359 2335 +359 2336 +359 2337 +1441 567 +1441 1957 +1441 2493 +1441 3093 +1441 3187 +1441 3298 +1441 3299 +1441 3300 +1441 3301 +1589 156 +1589 1056 +1589 1203 +1589 1327 +1589 2304 +1589 3364 +1589 3365 +1589 3366 +1589 3367 +1589 3368 +2597 21 +2597 352 +2597 476 +2597 505 +2597 621 +2597 1347 +2597 2964 +2597 3607 +2597 3687 +2597 3871 +2599 665 +2599 1175 +2599 1866 +2599 1867 +2599 2563 +2599 3033 +2599 3980 +2599 4199 +2599 4200 +3700 803 +3700 1050 +3700 1317 +3700 1396 +3700 1437 +3700 1481 +3700 2054 +3700 2114 +3700 4017 +3700 4899 +629 323 +629 336 +629 1067 +629 1426 +629 1427 +629 1428 +629 1429 +629 1430 +629 1431 +629 1432 +1129 5 +1129 7 +1129 145 +1129 248 +1129 353 +1129 426 +1129 629 +1129 753 +1129 2077 +1129 3002 +2278 152 +2278 1313 +2278 1901 +2278 1997 +2278 2200 +2278 2602 +2278 2975 +2278 3968 +2278 3969 +2278 3970 +2733 3 +2733 8 +2733 177 +2733 238 +2733 249 +2733 368 +2733 369 +2733 427 +2733 667 +2733 717 +3235 255 +3235 542 +3235 884 +3235 1313 +3235 1538 +3235 2726 +3235 2758 +3235 4620 +3235 4621 +3235 4622 +3931 566 +3931 3212 +3931 3352 +3931 5051 +889 2547 +889 2951 +1143 172 +1143 1556 +1143 1766 +1143 1852 +1143 1890 +1143 2384 +1143 2544 +1143 2666 +1143 3032 +1143 3033 +3933 45 +3933 219 +3933 425 +3933 1056 +3933 2344 +3933 2781 +3933 3995 +3933 4361 +3933 4720 +3933 5008 +1173 412 +1173 1001 +1173 1060 +1173 1441 +1173 2683 +1173 2746 +1173 3781 +1173 3865 +1173 5009 +2358 215 +2358 1522 +2358 2443 +2358 4056 +2358 4281 +2358 4844 +2358 6168 +2358 6232 +3934 15 +3934 855 +3934 1212 +3934 2563 +3934 4629 +3934 4950 +3934 5088 +3934 5414 +3934 5889 +3934 5890 +3937 4 +3937 125 +3937 143 +3937 144 +3937 146 +3937 147 +3937 175 +3937 179 +3937 180 +3937 558 +180 3 +180 1489 +180 1490 +180 1524 +180 1766 +180 2130 +180 2131 +180 2132 +180 2133 +180 2134 +238 9 +238 143 +238 146 +238 174 +238 667 +238 2181 +238 2182 +238 2183 +238 2184 +238 2185 +108 324 +108 365 +108 1486 +108 2037 +108 2038 +108 2039 +108 2040 +108 2041 +108 2042 +108 2043 +391 122 +391 124 +391 146 +391 248 +391 353 +391 422 +391 427 +391 717 +391 718 +391 2338 +392 814 +392 944 +392 1846 +392 2381 +392 2382 +392 2383 +392 2384 +392 2385 +392 2386 +392 2387 +398 176 +398 977 +398 1947 +398 2374 +398 2375 +398 2376 +398 2377 +398 2378 +398 2379 +398 2380 +2578 490 +2578 1775 +2578 2096 +2578 3405 +2578 3616 +2578 3967 +2578 4129 +2578 4222 +2578 4223 +2578 4224 +2581 129 +2581 171 +2581 889 +2581 2553 +2581 3109 +2581 4009 +2581 4201 +2581 4202 +2581 4203 +2581 4204 +554 1547 +554 2148 +554 2472 +554 3141 +554 3283 +554 3312 +554 4477 +554 4515 +554 4516 +1534 303 +1534 424 +1534 771 +1534 804 +1534 1457 +1534 2288 +1534 3170 +1534 3282 +1534 4172 +1534 4301 +1534 4359 +1534 4793 +1534 4818 +1534 4891 +1534 5414 +1534 5895 +1534 5916 +1534 6061 +1534 6062 +2362 327 +2362 684 +2362 1954 +2362 2360 +2362 2666 +2362 4045 +2362 4046 +2362 4047 +2362 4048 +2362 4049 +3163 1021 +3163 2048 +3163 2476 +3163 2787 +3163 3617 +3163 4291 +3163 4566 +3163 4567 +3163 4568 +422 1911 +422 2394 +422 2395 +422 2396 +422 2397 +422 2398 +422 2399 +422 2400 +422 2401 +422 2402 +584 585 +584 586 +584 587 +2614 548 +2614 1165 +2614 1217 +2614 1342 +2614 1985 +2614 2018 +2614 2022 +2614 2343 +2614 2384 +2614 2465 +2614 3232 +2614 3385 +2614 3488 +2614 3903 +2614 4159 +2614 4212 +2614 4213 +2614 4214 +2614 4215 +2614 4216 +2614 4217 +2614 4218 +2615 453 +2615 1273 +2615 1656 +2615 2787 +2615 3053 +2615 3509 +2615 4143 +2615 4219 +2615 4220 +2615 4221 +2617 215 +2617 1313 +2617 1803 +2617 2443 +2617 2643 +2617 2654 +2617 3558 +2617 4037 +253 219 +253 254 +253 255 +253 256 +253 257 +253 258 +253 259 +253 260 +253 261 +253 262 +924 5 +924 7 +924 122 +924 123 +924 149 +924 176 +924 179 +924 249 +924 264 +924 717 +1867 665 +1867 810 +1867 1607 +1867 1849 +1867 2105 +1867 2787 +1867 3615 +1867 3616 +1867 3617 +1867 3618 +2281 344 +2281 930 +2281 1744 +2281 2275 +2281 2292 +2281 2498 +2281 3296 +2281 3569 +2281 3962 +2281 3963 +3771 184 +3771 215 +3771 286 +3771 1979 +3771 2748 +3771 4301 +3771 4840 +3771 4926 +3771 4927 +3771 4928 +3772 2414 +133 110 +133 253 +133 1193 +133 1531 +133 1896 +133 2084 +133 2085 +133 2086 +133 2087 +133 2088 +864 198 +864 290 +864 837 +864 894 +864 1333 +864 2517 +864 2744 +864 2745 +864 2746 +864 2747 +2079 295 +2079 864 +2079 1029 +2079 1850 +2079 2114 +2079 3228 +2079 3851 +2079 3852 +2079 3853 +2079 3854 +2080 71 +2080 1027 +2080 2424 +2080 2602 +2080 2653 +2080 3055 +2080 3448 +2080 3839 +2080 3840 +2080 3841 +547 117 +547 335 +547 824 +547 1790 +547 2078 +547 2151 +547 2240 +547 2418 +547 2514 +547 2515 +941 6087 +945 336 +945 660 +945 801 +945 940 +945 1095 +945 2846 +945 3777 +945 4409 +945 4410 +945 4411 +165 102 +165 108 +165 531 +165 703 +165 1165 +165 1390 +165 1561 +165 1865 +165 2123 +165 2124 +3801 235 +3801 342 +3801 1120 +3801 1591 +3801 1592 +3801 2476 +3801 2612 +3801 3096 +3801 4131 +3946 124 +3946 249 +3946 251 +3946 264 +3946 367 +3946 422 +3946 667 +3946 718 +3946 856 +4300 11 +4300 133 +4300 1492 +4300 2119 +4300 2479 +4300 3699 +4300 5202 +4300 5203 +4300 5204 +4301 165 +4301 1800 +4301 1868 +4301 2324 +4301 3462 +327 8 +327 96 +327 627 +327 681 +327 822 +327 2179 +327 2273 +327 2274 +327 2275 +327 2276 +2451 81 +2451 892 +2451 2345 +2451 3205 +2451 3442 +2451 3719 +2451 3735 +2451 4121 +2451 4122 +2451 4123 +3228 294 +3228 1511 +3228 2024 +3228 2677 +3228 2935 +3228 2936 +3228 3908 +3228 4614 +3228 4615 +3228 4616 +1433 121 +1433 124 +1433 129 +1433 143 +1433 146 +1433 147 +1433 183 +1433 266 +1433 559 +1433 718 +2032 3 +2032 121 +2032 125 +2032 179 +2032 249 +2032 251 +2032 264 +2032 423 +2032 427 +2032 717 +715 638 +715 834 +715 1068 +715 1195 +715 2472 +715 2645 +715 2646 +715 2647 +715 2648 +715 2649 +1004 106 +1004 693 +1004 1591 +1004 1760 +1004 2212 +1004 2552 +1004 2903 +1004 2904 +1004 2905 +1004 2906 +2279 401 +2279 1273 +2279 1337 +2279 1587 +2279 1797 +2279 3397 +2279 3964 +2279 3965 +2279 3966 +2279 3967 +2284 4105 +2819 5 +2819 144 +2819 148 +2819 149 +2819 252 +2819 266 +2819 422 +2819 559 +2819 856 +2819 2098 +91 243 +91 1923 +91 2194 +1946 440 +1946 984 +1946 2486 +1946 2600 +1946 3058 +1946 3070 +1946 3310 +1946 3725 +1947 208 +1947 1934 +1947 2456 +1947 3419 +1947 3727 +1947 3728 +1947 3729 +1947 3730 +1947 3731 +1947 3732 +1948 121 +1948 126 +1948 128 +1948 144 +1948 145 +1948 148 +1948 265 +1948 368 +1948 559 +1948 1626 +1950 1528 +1950 2089 +1950 2462 +1950 2652 +1950 2931 +1951 3113 +732 309 +732 928 +732 1071 +732 1233 +732 1246 +732 1435 +732 2228 +732 2650 +732 2651 +732 2652 +1390 313 +1390 387 +1390 1942 +1390 2322 +1390 2904 +1390 3230 +1390 3231 +1390 3232 +1390 3233 +1390 3234 +1393 4 +1393 5 +1393 145 +1393 147 +1393 149 +1393 183 +1393 252 +1393 390 +1393 423 +1393 667 +1396 266 +1396 437 +1396 459 +1396 1178 +1396 1409 +1396 1504 +1396 1800 +1396 1842 +1396 2871 +1396 3281 +1397 279 +1397 665 +1397 822 +1397 1143 +1397 1890 +1397 2160 +1397 2384 +1397 3194 +1397 3288 +1397 3289 +1414 9 +1414 17 +1414 31 +1414 126 +1414 180 +1414 266 +1414 424 +1414 666 +1414 697 +1414 2018 +2399 59 +2399 730 +2399 1904 +2399 2395 +2399 2398 +2399 2551 +2399 3328 +2399 3921 +2399 4085 +2399 4086 +3394 1724 +3394 2066 +3394 2275 +3394 3660 +3394 4603 +3394 4727 +3394 4728 +3394 4729 +3394 4730 +693 1628 +693 2602 +693 2603 +693 2604 +693 2605 +693 2606 +693 2607 +693 2608 +693 2609 +693 2610 +1273 330 +1273 2868 +1273 3120 +1273 3121 +1273 3122 +1273 3123 +1273 3124 +1273 3125 +1273 3126 +1273 3127 +2808 102 +2808 552 +2808 667 +2808 677 +2808 1056 +2808 1956 +2808 2719 +2808 4189 +2808 4316 +2808 4317 +1336 260 +2392 21 +2392 503 +2392 804 +2392 808 +2392 1339 +2392 1547 +2392 2839 +2392 3346 +2392 4080 +2392 4081 +2757 1829 +2757 3882 +2757 4405 +2757 4406 +1198 338 +1198 1158 +1198 1382 +1198 1383 +1198 3059 +1198 3060 +1198 3061 +1198 3062 +1198 3063 +1198 3064 +2046 7 +2046 9 +2046 122 +2046 127 +2046 145 +2046 248 +2046 249 +2046 251 +2046 353 +2046 369 +2047 5 +2047 145 +2047 149 +2047 175 +2047 177 +2047 180 +2047 266 +2047 353 +2047 424 +2047 1246 +2048 659 +2048 1801 +2048 1817 +2048 2305 +2048 2327 +2048 2764 +2048 2852 +2048 3149 +2048 3812 +2048 3813 +2049 740 +2049 1299 +2049 2684 +2049 2768 +2049 2903 +2049 3004 +2049 3039 +2049 3814 +2049 3815 +2049 3816 +92 2015 +92 2016 +963 1054 +963 1124 +963 1831 +963 2287 +963 2291 +963 2686 +963 2851 +963 2852 +963 2853 +963 2854 +1767 1084 +1767 1768 +1767 1769 +1767 1770 +1767 1771 +1767 1772 +1767 1773 +1767 1774 +1767 1775 +1767 1776 +3411 440 +3411 793 +3411 892 +3411 1120 +3411 1439 +3411 1507 +3411 2769 +3411 4750 +3411 4751 +2881 4 +2881 144 +2881 148 +2881 175 +2881 180 +2881 266 +2881 424 +2881 666 +2881 886 +2881 2018 +726 152 +726 406 +726 540 +726 3459 +726 3654 +726 3726 +726 4072 +726 5137 +726 5138 +726 5139 +4211 4 +4211 10 +4211 122 +4211 251 +4211 265 +4211 369 +4211 426 +4211 427 +4211 698 +4211 946 +29 962 +29 1656 +29 2201 +576 1827 +576 2481 +576 2953 +576 3171 +576 4846 +576 5235 +576 5236 +576 5237 +576 5238 +576 5239 +2396 20 +2396 1162 +2396 1670 +2396 2173 +2396 3059 +2396 4004 +2396 4082 +2396 4083 +2396 4084 +4469 548 +4469 1160 +4469 2126 +4469 2499 +4469 2690 +4469 3574 +4469 3917 +4469 5308 +4469 5309 +4469 5310 +4470 4 +4470 7 +4470 126 +4470 143 +4470 147 +4470 266 +4470 422 +4470 558 +4470 754 +4470 856 +1547 1023 +1547 1339 +1547 1636 +1547 2499 +1547 3169 +1547 3342 +1547 3343 +1547 3344 +1547 3345 +1547 3346 +2331 5437 +2348 1087 +3194 4587 +4665 110 +4665 566 +4665 928 +4665 2254 +4665 2666 +4665 2744 +4665 2859 +4665 3097 +4665 5159 +4665 5412 +4720 131 +4720 133 +4720 400 +4720 883 +4720 4031 +4720 4373 +4720 4400 +4720 4871 +4720 4951 +4720 5438 +4721 51 +4721 472 +4721 1411 +4721 1926 +4721 3552 +4721 4160 +4721 5159 +4721 5439 +4721 5440 +4721 5441 +4723 529 +4723 649 +4723 2358 +4723 3220 +4723 4670 +4723 4676 +4723 4844 +4723 5241 +4723 5428 +4723 5442 +4724 63 +4724 514 +4724 1694 +4724 4296 +4724 5155 +4724 5443 +4724 5444 +4724 5445 +4724 5446 +288 92 +288 209 +288 1917 +288 1946 +288 1957 +288 2015 +288 2244 +288 2245 +288 2246 +325 82 +325 1507 +325 1669 +325 2159 +325 2187 +325 2268 +325 2269 +325 2270 +325 2271 +325 2272 +707 115 +707 1047 +707 1107 +707 1503 +707 1656 +707 1803 +707 2641 +707 2642 +707 2643 +707 2644 +1211 1800 +4369 3694 +4369 5186 +4369 5252 +4369 5253 +4369 5254 +4369 5255 +4369 5256 +4369 5257 +4369 5258 +4369 5259 +4754 115 +4754 124 +4754 483 +4754 521 +4754 1413 +4754 1654 +4754 1768 +4754 4113 +4754 4914 +4754 5467 +1223 651 +1223 751 +1223 1800 +1223 1827 +1223 3156 +1223 3905 +1223 3981 +1223 5192 +1223 5311 +1223 5312 +3981 127 +3981 878 +3981 1007 +3981 1540 +3981 2592 +3981 3557 +3981 4793 +3981 5496 +3981 6241 +3981 6242 +4059 3789 +908 648 +908 697 +908 942 +908 1512 +908 1842 +908 2786 +908 2787 +908 2788 +908 2789 +908 2790 +1337 38 +1337 143 +1337 266 +1337 693 +1337 911 +1337 1221 +1337 1724 +1337 1725 +1337 1726 +1337 1727 +1541 3 +1541 122 +1541 325 +1541 548 +1541 679 +1541 1245 +1541 2039 +1541 3096 +1541 3323 +1541 3347 +2428 451 +2428 532 +2428 1766 +2428 2068 +2428 2069 +2428 2193 +2428 4028 +2428 4095 +2428 4096 +2428 4097 +2377 227 +2377 432 +2377 500 +2377 561 +2377 2392 +2377 2646 +2377 2798 +2377 3172 +2377 4063 +2377 4064 +3463 257 +3463 478 +3463 786 +3463 1129 +3463 2261 +3463 2330 +3463 3417 +3463 4767 +3463 4768 +3465 7 +3465 8 +3465 126 +3465 149 +3465 427 +3465 1246 +3465 1388 +3465 2538 +3465 4551 +3465 4769 +3466 50 +3466 51 +3466 732 +3466 1313 +3466 1325 +3466 1980 +3466 2309 +3466 2984 +3466 3141 +3466 3405 +2500 297 +2500 660 +2500 1573 +2500 2221 +2500 3057 +2500 3705 +2500 4148 +2500 4149 +2500 4150 +2500 4151 +3798 1313 +3798 2375 +3798 2378 +3798 2612 +3798 3211 +3798 3479 +3798 3563 +3798 4209 +3798 4534 +3798 4931 +3952 4706 +3956 1030 +3956 2254 +3956 3822 +3956 5016 +3956 5017 +1444 5490 +1444 5491 +1529 541 +1529 892 +1529 1385 +1529 2347 +1529 2854 +1529 2886 +1529 3330 +1529 3331 +1529 3332 +1529 3333 +2453 125 +2453 126 +2453 128 +2453 145 +2453 179 +2453 180 +2453 250 +2453 856 +2453 2001 +4664 3635 +4664 5434 +4664 5435 +4664 5436 +4666 15 +4666 1158 +4666 1278 +4666 1383 +4666 2558 +4666 3062 +4666 4296 +4666 4297 +4666 4988 +4666 5413 +4667 458 +4667 1482 +4667 1524 +4667 1599 +4667 2887 +4667 3046 +4667 3675 +4667 5101 +4667 5373 +3441 803 +3441 1750 +3441 2299 +3441 2646 +3441 3024 +3441 3439 +3441 3440 +3441 3654 +3441 4838 +3441 4839 +3441 4840 +3441 4841 +3441 4842 +3441 4843 +5151 219 +5151 459 +5151 612 +5151 1102 +5151 2403 +5151 3017 +5151 5510 +5151 5658 +5151 5659 +5152 380 +5152 666 +5152 1540 +5152 1751 +5152 2577 +5152 3174 +5152 3658 +5152 4578 +5152 5199 +5152 5581 +962 867 +962 1228 +962 1777 +962 1778 +962 1779 +962 1780 +962 1781 +962 1782 +962 1783 +962 1784 +2338 256 +2338 840 +2338 1031 +2338 1457 +2338 1509 +2338 2785 +2338 3006 +2338 3743 +2338 5056 +2338 5645 +2361 325 +2361 2662 +2361 2911 +2361 3384 +2361 4088 +2885 129 +2885 176 +2885 177 +2885 180 +2885 266 +2885 368 +2885 390 +2885 427 +2885 667 +2885 856 +5053 116 +5053 906 +5053 1250 +5053 1541 +5053 1859 +5053 3114 +5053 3319 +5053 3726 +5053 4189 +805 57 +805 106 +805 528 +805 637 +805 686 +805 769 +805 770 +805 1644 +805 2738 +805 2739 +811 643 +811 712 +811 965 +811 1151 +811 2176 +811 2729 +811 2730 +811 2731 +811 2732 +811 2733 +816 1048 +816 1129 +816 2237 +816 2548 +816 4695 +816 4844 +816 4878 +816 5224 +816 5628 +816 5629 +1698 2026 +1698 2551 +1698 2850 +1698 2980 +1698 3220 +1698 3450 +1698 3451 +1698 3452 +1698 3453 +1698 3454 +3129 334 +3129 2360 +3129 3634 +3129 3962 +3129 4548 +5154 49 +5154 803 +5154 1219 +5154 1255 +5154 2285 +5154 3017 +5154 3133 +5154 5023 +5154 5463 +5154 5670 +203 5973 +203 5974 +2017 96 +2017 1914 +2017 2750 +2017 2794 +2017 3713 +2017 3807 +2017 3808 +2017 3809 +2017 3810 +2017 3811 +1888 345 +1888 846 +1888 1251 +1888 1826 +1888 1889 +1888 1890 +1888 1891 +1888 1892 +1888 1893 +1888 1894 +2053 252 +2053 368 +2053 369 +2053 390 +2053 423 +2053 1208 +2053 2621 +2053 3675 +2053 3826 +2053 3827 +2285 309 +2285 1019 +2285 1176 +2285 2848 +2285 3164 +2285 3457 +2285 3977 +2285 3979 +2285 3980 +2285 3981 +2286 123 +2286 124 +2286 179 +2286 238 +2286 367 +2286 423 +2286 427 +2286 853 +2286 2059 +2286 3764 +81 1067 +81 1916 +81 1984 +81 1985 +81 1986 +81 1987 +81 1988 +81 1989 +81 1990 +81 1991 +141 7 +141 142 +141 143 +141 144 +141 145 +141 146 +141 147 +141 148 +141 149 +141 150 +494 658 +494 892 +494 924 +494 1372 +494 1787 +494 2475 +494 2476 +494 2477 +494 2478 +494 2479 +2023 38 +2023 281 +2023 369 +2023 2152 +2023 2728 +2023 3487 +2023 3489 +2023 3595 +2023 3797 +2023 3798 +3590 4845 +4152 468 +4152 1655 +4152 2011 +4152 2645 +4152 3016 +4152 4197 +4152 4275 +4152 4438 +4152 4472 +4152 5092 +4154 586 +4154 1085 +4154 1859 +4154 2387 +4154 2894 +4154 4202 +4154 4628 +4154 5093 +4154 5094 +4154 5095 +155 5 +155 121 +155 126 +155 128 +155 129 +155 175 +155 238 +155 353 +155 1317 +158 411 +158 813 +158 1688 +158 2104 +158 2105 +158 2106 +158 2107 +158 2108 +160 13 +160 2053 +160 2056 +160 2109 +160 2110 +160 2111 +160 2112 +160 2113 +160 2114 +160 2115 +173 124 +173 128 +173 144 +173 174 +173 175 +173 176 +173 177 +173 178 +173 179 +173 180 +3323 122 +3323 127 +3323 145 +3323 148 +3323 176 +3323 177 +3323 249 +3323 424 +3323 427 +3323 1246 +485 8 +485 121 +485 123 +485 148 +485 179 +485 249 +485 251 +485 353 +485 369 +485 1317 +3403 7 +3403 123 +3403 125 +3403 144 +3403 149 +3403 248 +3403 251 +3403 367 +3403 424 +3403 1317 +3791 174 +3791 823 +3791 2032 +3791 2971 +3791 3185 +3791 4419 +3791 4526 +3791 4894 +3791 4928 +3791 4929 +3975 57 +3976 149 +3976 266 +3976 368 +3976 423 +3976 424 +3976 559 +3976 718 +3976 856 +3976 1245 +197 198 +197 199 +197 200 +197 201 +197 202 +197 203 +197 204 +197 205 +197 206 +197 207 +1672 1673 +2629 127 +2629 128 +2629 129 +2629 176 +2629 229 +2629 353 +2629 1317 +2629 2115 +2629 3102 +2629 4228 +3033 1476 +3033 1894 +3033 2361 +3033 2532 +3033 3173 +3033 3806 +3033 3833 +3033 3918 +3033 4464 +3033 4465 +3390 661 +3390 976 +3390 1023 +3390 1313 +3390 1530 +3390 1802 +3390 2981 +3390 3727 +3390 4725 +3390 4726 +3393 646 +3393 1251 +3393 1487 +3393 1618 +3393 3223 +3393 3463 +3393 4731 +3393 4732 +1089 96 +1089 727 +1089 944 +1089 1313 +1089 2523 +1089 2872 +1089 3109 +4324 92 +4324 315 +4324 2200 +4324 3095 +4324 3136 +4324 3843 +4324 4721 +4324 5214 +4324 5215 +4324 5216 +1968 476 +1968 955 +1968 1054 +1968 1773 +1968 2625 +1968 3733 +1968 3734 +1968 3735 +1968 3736 +777 352 +777 778 +777 779 +777 780 +777 781 +777 782 +777 783 +777 784 +777 785 +777 786 +1385 69 +1385 191 +1385 616 +1385 3213 +1385 3248 +1385 3249 +1385 3250 +1385 3251 +1385 3252 +1385 3253 +1402 55 +1402 96 +1402 1444 +1402 2186 +1402 2662 +1402 3137 +1402 3258 +1402 3259 +1402 3260 +1402 3261 +1724 493 +1724 837 +1724 1677 +1724 1726 +1724 2038 +1724 3275 +1724 3487 +1724 3488 +1724 3489 +1724 3490 +2790 8 +2790 121 +2790 128 +2790 144 +2790 147 +2790 266 +2790 352 +2790 424 +2790 559 +2790 1317 +3080 38 +3080 706 +3080 1904 +3080 3334 +3080 3409 +3080 3679 +3080 3698 +3080 3849 +3080 4501 +3080 4502 +1454 3 +1454 629 +1454 691 +1454 937 +1454 1989 +1454 2089 +1454 3232 +1454 3307 +1454 3308 +1454 3309 +3220 152 +3220 503 +3220 507 +3220 548 +3220 2345 +3220 2575 +3220 4600 +3220 4601 +3220 4602 +136 57 +136 470 +136 852 +136 2480 +136 2984 +136 3219 +136 4463 +136 4944 +136 4945 +458 459 +458 460 +458 461 +458 462 +458 463 +458 464 +458 465 +458 466 +458 467 +458 468 +3823 1085 +3823 1089 +3823 1794 +3823 1888 +3823 2625 +3823 3829 +3823 4940 +3823 4941 +3823 4942 +3823 4943 +3824 3149 +1141 162 +1141 490 +1141 1122 +1141 1949 +1141 2353 +1141 3023 +1141 3024 +1141 3025 +1141 3026 +1141 3027 +2201 1511 +2201 1815 +2201 1944 +2201 2090 +2201 2416 +2201 2943 +2201 2981 +2201 3205 +2201 3319 +2201 3928 +3207 54 +3207 219 +3207 318 +3207 554 +3207 883 +3207 1935 +3207 3209 +3207 3995 +3207 4591 +3327 124 +3327 151 +3327 368 +3327 424 +3327 1317 +3327 1903 +3327 2086 +3327 3243 +3327 3994 +3327 4368 +3714 1056 +4111 5 +4111 31 +4111 149 +4111 177 +4111 179 +4111 250 +4111 352 +4111 558 +4111 697 +4111 1317 +866 162 +866 416 +866 635 +866 1351 +866 1408 +866 1860 +866 2326 +866 2763 +866 2764 +866 2765 +1377 247 +1377 963 +1377 1135 +1377 2006 +1377 2237 +1377 3082 +1377 3105 +1377 3224 +1377 3225 +1377 3226 +4191 370 +4191 432 +4191 495 +4191 503 +4191 2537 +4191 3004 +4191 3808 +4191 4293 +4191 4617 +4191 5121 +4193 365 +4193 787 +4193 995 +4193 1447 +4193 2601 +4193 2746 +4193 3499 +4193 3840 +4193 3896 +4193 4332 +135 34 +135 132 +135 786 +135 1150 +135 1274 +135 2099 +135 2100 +135 2101 +135 2102 +135 2103 +968 739 +968 828 +968 889 +968 969 +968 970 +968 971 +968 972 +968 973 +968 974 +1740 38 +1740 106 +1740 605 +1740 1133 +1740 1209 +1740 1631 +1740 3273 +1740 3497 +1740 3498 +1740 3499 +4705 5 +4705 144 +4705 148 +4705 249 +4705 252 +4705 264 +4705 266 +4705 367 +4705 666 +4705 1245 +3759 1217 +4068 113 +4068 363 +4068 828 +4068 2414 +4068 4885 +4068 4904 +4068 4953 +4068 5060 +4068 5061 +4068 5062 +5361 2035 +5361 4945 +5361 5115 +5361 5352 +5361 5789 +5361 5790 +5361 5791 +5361 5792 +5361 5793 +5361 5794 +5788 1173 +5788 1487 +5788 1544 +5788 3531 +5788 4885 +5788 5546 +5788 5655 +5788 5980 +5788 5981 +5788 5982 +731 649 +731 982 +731 1156 +731 1258 +731 2053 +731 2176 +731 2655 +731 2656 +731 2657 +731 2658 +2779 7 +2779 124 +2779 125 +2779 144 +2779 148 +2779 149 +2779 248 +2779 249 +2779 251 +2779 367 +5775 376 +5775 710 +5775 779 +5775 1122 +5775 1272 +5775 1375 +5775 2015 +5775 2422 +5775 2634 +5775 3335 +5775 4316 +5775 5850 +5775 5879 +5775 6008 +5775 6009 +5775 6010 +5775 6011 +5228 136 +5014 124 +5014 129 +5014 146 +5014 247 +5014 249 +5014 353 +5014 368 +5014 369 +5014 390 +5014 1245 +5980 563 +5980 762 +5980 789 +5980 835 +5980 977 +5980 1122 +5980 1903 +5980 1913 +5980 3956 +5980 6096 +6249 1402 +6249 4068 +6249 4281 +6249 4311 +6249 4540 +6249 4854 +6249 6151 +6249 6268 +6249 6269 +6249 6270 +6251 554 +6251 1524 +6251 1956 +6251 2023 +6251 2777 +6251 3038 +6251 4629 +6251 6102 +6251 6262 +6251 6263 +6252 2015 +6252 3509 +6252 3991 +6252 4691 +6252 5528 +6252 6098 +6252 6264 +6252 6265 +6252 6266 +6252 6267 +563 1575 +563 2582 +563 2583 +563 2584 +1650 526 +1650 876 +1650 1135 +1650 1565 +1650 1651 +1650 1652 +1650 1653 +1650 1654 +1650 1655 +1650 1656 +2312 148 +2312 174 +2312 251 +2312 264 +2312 367 +2312 368 +2312 390 +2312 422 +2312 718 +2312 1317 +2337 450 +2337 452 +2337 532 +2337 1239 +2337 1741 +2337 2381 +2337 2923 +2337 3102 +2337 3728 +2554 534 +2554 1400 +2554 2843 +2554 3684 +2554 3781 +2554 4166 +2554 4167 +2554 4168 +2554 4169 +4444 769 +4444 770 +4444 1528 +4444 1744 +4444 3852 +4444 4062 +4444 4551 +4444 5182 +4444 5285 +4444 5286 +863 202 +863 513 +863 649 +863 1481 +863 1775 +863 2125 +863 2740 +863 2741 +863 2742 +863 2743 +867 53 +867 470 +867 1734 +867 1738 +867 2527 +867 2766 +867 2767 +867 2768 +867 2769 +867 2770 +868 732 +868 1145 +868 1146 +868 1147 +868 1148 +868 1149 +868 1150 +868 1151 +868 1152 +868 1153 +3926 2349 +3926 2362 +3926 2596 +3926 2925 +3926 3098 +3926 3358 +3926 4413 +3926 4534 +3926 5002 +3926 5003 +1090 1374 +1090 1516 +1090 1568 +1090 1861 +1090 2078 +1090 2222 +1090 2430 +1090 3110 +1090 3111 +1816 628 +1816 820 +1816 1258 +1816 2873 +1816 2975 +1816 3262 +1816 3446 +1816 3551 +1816 3552 +1816 3553 +2474 330 +2474 534 +2474 970 +2474 1511 +2474 1764 +2474 1845 +2474 2300 +2474 5449 +2474 5450 +3067 318 +3067 908 +3067 1267 +3067 1412 +3067 2162 +3067 3487 +3067 3767 +3067 4489 +3067 4490 +3067 4491 +3233 8 +3233 122 +3233 144 +3233 148 +3233 174 +3233 179 +3233 424 +3233 427 +3233 1317 +3233 2338 +3670 406 +3670 933 +3670 1787 +3670 2344 +3670 2595 +3670 3699 +3670 3922 +3670 4540 +3670 4870 +3670 4882 +654 798 +654 1023 +654 1365 +654 2475 +654 2516 +654 2559 +654 2568 +654 2569 +654 2570 +654 2571 +1289 1043 +1289 1916 +1289 2944 +1289 2966 +1289 3142 +1289 3143 +1289 3144 +1289 3145 +1289 3146 +78 725 +78 898 +78 1157 +78 1894 +78 2203 +78 2204 +78 2205 +886 329 +886 887 +886 888 +886 889 +886 890 +886 891 +886 892 +886 893 +886 894 +886 895 +2642 813 +2642 4315 +4746 798 +4746 2443 +4746 2635 +4746 2639 +4746 3071 +4746 3854 +4746 4811 +4746 5369 +4746 5462 +4746 5463 +3551 3 +3551 122 +3551 125 +3551 126 +3551 144 +3551 145 +3551 174 +3551 248 +3551 264 +3551 367 +694 174 +694 175 +694 265 +694 351 +694 695 +694 696 +694 697 +694 698 +694 699 +694 700 +668 669 +668 670 +668 671 +668 672 +668 673 +668 674 +668 675 +668 676 +668 677 +668 678 +1647 5 +1647 147 +1647 149 +1647 175 +1647 252 +1647 667 +1647 856 +1647 1245 +1647 2018 +3838 606 +3838 814 +3838 1701 +3838 2285 +3838 3371 +3838 4132 +3838 4954 +3838 4955 +3838 4956 +3838 4957 +311 127 +311 143 +311 251 +311 252 +311 264 +311 369 +311 753 +311 1245 +311 3677 +2243 9 +2243 123 +2243 125 +2243 126 +2243 129 +2243 144 +2243 176 +2243 352 +2243 367 +2243 427 +32 957 +32 1028 +32 1199 +32 1459 +32 1699 +32 1700 +32 1701 +32 1702 +32 1703 +1675 214 +1675 281 +1675 322 +1675 402 +1675 554 +1675 776 +1675 829 +1675 858 +1675 898 +1675 1026 +1675 1087 +1675 1139 +1675 1575 +1675 1647 +1675 1671 +1675 1706 +1675 1787 +1675 1812 +1675 1952 +1675 2069 +1675 2278 +1675 2548 +1675 2585 +1675 2643 +1675 2964 +1675 3006 +1675 3170 +1675 3419 +1675 3420 +1675 3421 +1675 3422 +1675 3423 +1675 3424 +1675 3425 +1675 3426 +1675 3427 +1675 3428 +1675 3429 +1675 3430 +1675 3431 +1675 3432 +1675 3433 +1675 3434 +1675 3435 +1675 3436 +1675 3437 +1675 3438 +2723 661 +2723 814 +2723 1025 +2723 2038 +2723 2943 +2723 3613 +2723 4082 +2723 4284 +2723 4285 +2723 4286 +4680 1900 +4680 2477 +4680 3590 +4680 4080 +4680 4625 +1338 178 +1338 725 +1338 892 +1338 1530 +1338 2057 +1338 2570 +1338 2671 +1338 2786 +1338 3178 +1338 3179 +5675 2302 +5675 5474 +5675 5729 +5675 5933 +5675 5934 +5677 2625 +5677 3046 +5677 3292 +5677 4295 +5677 4806 +5677 5237 +5677 5315 +5677 5468 +5677 5935 +110 1332 +110 1361 +110 2029 +110 2030 +110 2031 +110 2032 +110 2033 +110 2034 +110 2035 +110 2036 +858 38 +858 263 +858 307 +858 412 +858 1704 +858 1705 +858 1706 +858 1707 +858 1708 +858 1709 +5978 124 +5978 238 +5978 266 +5978 353 +5978 367 +5978 422 +5978 423 +5978 427 +5978 559 +5978 717 +2069 347 +2069 1840 +2069 2051 +2069 2658 +2069 3357 +2069 3463 +2069 3637 +2069 3988 +2069 3989 +2069 3990 +2464 182 +2464 652 +2464 892 +2464 1988 +2464 2448 +2464 2982 +2464 4116 +2464 4117 +2464 4118 +2464 4119 +2465 3 +2465 31 +2465 124 +2465 146 +2465 175 +2465 180 +2465 247 +2465 266 +2465 367 +2465 2001 +418 763 +418 1541 +418 1944 +418 2467 +418 2468 +418 2469 +418 2470 +418 2471 +2376 94 +2376 522 +2376 802 +2376 1332 +2376 1738 +2376 2658 +2376 2906 +2376 3357 +2376 4065 +1235 123 +1235 143 +1235 176 +1235 264 +1235 352 +1235 353 +1235 390 +1235 423 +1235 718 +1235 2338 +2248 117 +2248 485 +2248 820 +2248 2353 +2248 3671 +2248 4067 +2248 5114 +2248 5115 +2248 5116 +2248 5117 +3929 76 +3929 513 +3929 550 +3929 604 +3929 712 +3929 1940 +3929 1955 +3929 1969 +3929 3022 +3929 3509 +582 412 +582 715 +582 1068 +582 1541 +582 1854 +582 2354 +582 2414 +582 2535 +582 2536 +582 2537 +4752 2 +4752 5 +4752 8 +4752 174 +4752 699 +4752 753 +4752 762 +4752 946 +4752 2063 +4752 4257 +982 3028 +982 3029 +982 3030 +982 3031 +2336 158 +2336 1227 +2336 1892 +2336 2099 +2336 2528 +2336 2538 +2336 2799 +2336 2805 +2336 3136 +2336 4041 +1022 1023 +1022 1024 +1022 1025 +1022 1026 +1022 1027 +1022 1028 +1022 1029 +1022 1030 +1022 1031 +1022 1032 +2384 187 +2384 503 +2384 1797 +2384 2350 +2384 2420 +2384 2563 +2384 4069 +2384 4070 +2384 4071 +2490 3 +2490 147 +2490 176 +2490 251 +2490 264 +2490 367 +2490 427 +2490 559 +2490 718 +2490 2018 +3429 1447 +3429 2292 +3429 2413 +3429 2918 +3429 4020 +3781 327 +3781 1059 +3781 1086 +3781 1123 +3781 2519 +3781 3850 +3781 4031 +3781 4923 +3781 4924 +3781 4925 +2425 108 +2425 354 +2425 1968 +2425 2155 +2425 2964 +2425 3046 +2425 4098 +2425 4099 +2425 4100 +2425 4101 +1005 174 +1005 227 +1005 1490 +1005 1624 +1005 2287 +1005 2330 +1005 2908 +1005 2909 +1005 2910 +1005 2911 +1048 844 +1048 973 +1048 1049 +1048 1050 +1048 1051 +1048 1052 +1048 1053 +1048 1054 +1048 1055 +1048 1056 +1548 169 +1548 880 +1548 1084 +1548 1947 +1548 2269 +1548 2822 +1548 3360 +1548 3361 +1548 3362 +1548 3363 +1772 255 +1772 815 +1772 1168 +1772 2265 +1772 2552 +1772 2736 +1772 2756 +1772 2943 +1772 2993 +1772 3530 +2709 23 +2709 518 +2709 2138 +2709 2360 +2709 2794 +2709 3992 +2709 4172 +2709 4287 +2709 4288 +2709 4289 +926 241 +926 347 +926 356 +926 478 +926 572 +926 2300 +926 2337 +926 2821 +926 2822 +926 2823 +5404 1143 +5404 2583 +5404 2658 +5404 2885 +5404 2961 +5404 5749 +5404 5763 +5404 5764 +5404 5805 +455 2038 +455 2188 +455 2241 +455 2441 +455 2442 +4689 924 +4689 1199 +4689 1288 +4689 1424 +4689 1866 +4689 1867 +4689 1868 +4689 2558 +4689 5423 +4689 5424 +116 510 +116 1089 +116 2013 +116 2030 +116 2051 +116 2052 +116 2053 +116 2054 +116 2055 +116 2056 +4002 3 +4002 121 +4002 123 +4002 124 +4002 128 +4002 247 +4002 367 +4002 717 +4002 1246 +4002 2098 +4839 356 +4839 572 +4839 1137 +4839 1287 +4839 1671 +4839 2324 +4839 2475 +4839 2648 +4839 2822 +4839 4754 +4896 263 +4896 733 +4896 878 +4896 1031 +4896 2449 +4896 2779 +4896 3553 +4896 5080 +4896 5568 +4896 5569 +1651 129 +1651 262 +1651 855 +1651 1318 +1651 1974 +1651 2974 +1651 3399 +1651 3400 +1651 3401 +1651 3402 +4553 3 +4553 124 +4553 146 +4553 251 +4553 266 +4553 422 +4553 667 +4553 856 +4553 2001 +4553 2018 +5572 56 +5572 206 +5572 787 +5572 788 +5572 4293 +5572 4676 +5572 5063 +5572 5879 +5572 5880 +5572 5881 +5884 6040 +2596 1491 +2596 1689 +2596 2083 +2596 3681 +2596 3953 +2596 4194 +2596 4195 +2596 4196 +2596 4197 +2596 4198 +1780 1666 +1780 2049 +1780 3533 +1780 3534 +1780 3535 +2086 381 +2086 1070 +2086 1587 +2086 1688 +2086 2720 +2086 2783 +2086 3842 +2086 3843 +2086 3844 +2086 3845 +3484 121 +3484 127 +3484 128 +3484 129 +3484 146 +3484 176 +3484 238 +3484 266 +3484 423 +3484 427 +4093 656 +4093 1156 +4093 1546 +4093 2207 +4093 2254 +4093 4039 +4093 4502 +4093 5049 +4093 5074 +4093 5075 +4298 911 +4298 1726 +4298 2789 +4298 3149 +4298 4371 +4298 4487 +4298 4770 +4298 5200 +4298 5201 +869 586 +869 833 +869 1195 +869 1367 +869 1762 +869 2354 +869 2380 +869 2753 +869 2754 +869 2755 +874 149 +874 177 +874 307 +874 652 +874 1003 +874 1022 +874 1655 +874 2495 +874 2761 +874 2762 +876 541 +1458 4 +1458 5 +1458 125 +1458 144 +1458 148 +1458 149 +1458 353 +1458 422 +1458 666 +1458 856 +1866 4 +1866 123 +1866 127 +1866 368 +1866 390 +1866 1245 +1866 2572 +1866 3675 +1866 3676 +2719 92 +2719 182 +2719 835 +2719 1209 +2719 1255 +2719 1442 +2719 3117 +2719 4278 +2719 4279 +2719 4280 +289 290 +289 291 +289 292 +289 293 +289 294 +289 295 +289 296 +289 297 +289 298 +289 299 +2551 962 +5653 538 +5653 614 +5653 675 +5653 2481 +5653 4655 +5653 5291 +5653 5601 +5653 5927 +5653 5928 +5653 5929 +2407 96 +2407 122 +2407 123 +2407 143 +2407 249 +2407 368 +2407 856 +2407 2001 +2407 2196 +2407 2563 +531 80 +531 343 +531 346 +531 571 +531 572 +531 573 +531 574 +531 575 +531 576 +760 38 +760 528 +760 536 +760 1688 +760 2026 +760 2152 +760 2517 +760 2687 +760 2688 +760 2689 +2710 163 +2710 464 +2710 919 +2710 2911 +2710 2948 +2710 3196 +2710 4272 +2710 4273 +2712 8 +2712 17 +2712 31 +2712 126 +2712 144 +2712 145 +2712 149 +2712 174 +2712 559 +2712 717 +928 2652 +2735 92 +2735 487 +2735 892 +2735 1718 +2735 2952 +2735 3163 +2735 3169 +2735 3471 +2735 4291 +2735 4292 +1323 137 +1323 557 +1323 1039 +1323 1728 +1323 2646 +1323 3079 +1323 3199 +1323 3200 +1323 3201 +1325 731 +1326 335 +1326 2722 +1326 3192 +1326 3193 +1326 3194 +1328 1249 +1328 2377 +1328 2413 +1328 2448 +1328 3169 +1328 3170 +1328 3171 +1328 3172 +1328 3173 +1328 3174 +892 2200 +892 2959 +892 2960 +892 2961 +1077 1022 +2562 529 +2562 541 +2562 1787 +2562 1892 +2562 3280 +2562 3489 +2562 3779 +2562 4182 +2562 4183 +2562 4184 +2861 7 +2861 143 +2861 147 +2861 174 +2861 175 +2861 368 +2861 559 +2861 666 +2861 754 +2861 2018 +49 101 +49 338 +49 2366 +49 2893 +49 3065 +49 3593 +49 3840 +49 3998 +49 3999 +2309 1333 +2309 2017 +2309 2138 +2309 2667 +2309 3124 +2309 3841 +2309 4004 +2309 4005 +2309 4006 +2309 4007 +2313 3 +2313 121 +2313 129 +2313 143 +2313 179 +2313 264 +2313 353 +2313 367 +2313 390 +2313 717 +2314 750 +2314 2067 +2314 2950 +2314 3097 +2314 4172 +2314 4373 +2314 5162 +2314 5163 +2314 5164 +2314 5165 +572 584 +572 818 +572 979 +572 1353 +572 2119 +572 2306 +572 2337 +572 2892 +572 4318 +572 4319 +2322 376 +2322 2303 +2322 2528 +2322 4014 +2322 4015 +2322 4016 +2322 4017 +2322 4018 +2322 4019 +2322 4020 +2324 240 +2324 566 +2324 810 +2324 968 +2324 1245 +2324 3230 +2324 3257 +2324 3475 +2324 3538 +2324 3752 +2325 3144 +2325 3894 +2325 3963 +2325 4021 +2325 4022 +2325 4023 +2325 4024 +2325 4025 +2325 4026 +2326 3343 +2326 4130 +2332 714 +2332 859 +2332 2515 +2332 2646 +2332 2729 +2332 2965 +2332 4031 +2332 4032 +2332 4033 +2304 1327 +2304 1347 +2304 2189 +21 92 +21 1702 +21 1711 +21 1833 +21 1916 +21 1917 +21 1918 +21 1919 +21 1920 +21 1921 +505 5 +505 125 +505 145 +505 148 +505 174 +505 264 +505 368 +505 422 +505 1317 +505 2018 +3607 852 +3607 1457 +3607 2752 +3607 2820 +3607 4866 +4200 429 +4200 432 +4200 1288 +4200 1564 +4200 1573 +4200 1652 +4200 2202 +4200 3813 +2114 979 +2114 1569 +2114 1581 +2114 1637 +2114 1770 +2114 1873 +2114 2409 +2114 2449 +2114 2547 +2114 3779 +1426 92 +1426 368 +1426 425 +1426 799 +1426 1339 +1426 2015 +1426 2588 +1426 3951 +1426 4635 +1426 4970 +1429 336 +1429 1546 +1429 2203 +1429 2319 +1429 2405 +1429 3266 +1429 3295 +1429 3296 +1429 3297 +1430 125 +1430 126 +1430 144 +1430 149 +1430 250 +1430 422 +1430 423 +1430 718 +1430 754 +1430 856 +1431 123 +1431 127 +1431 238 +1431 247 +1431 249 +1431 251 +1431 367 +1431 717 +1431 1245 +1431 3290 +4620 2645 +172 127 +172 128 +172 129 +172 145 +172 174 +172 177 +172 247 +172 353 +172 1246 +172 1317 +1766 2218 +1766 2370 +1766 3680 +1766 3681 +1890 39 +1890 158 +1890 1047 +1890 3341 +1890 3639 +1890 3640 +1890 3641 +1890 3642 +1890 3643 +1890 3644 +1890 3645 +1890 3646 +1890 3647 +1890 3648 +1890 3649 +1890 3650 +1890 3651 +1890 3652 +1890 3653 +1890 3654 +1890 3655 +1890 3656 +1890 3657 +1890 3658 +1890 3659 +1890 3660 +1890 3661 +1890 3662 +1890 3663 +1890 3664 +1890 3665 +1890 3666 +1890 3667 +1890 3668 +2544 8 +2544 282 +2544 837 +2544 1048 +2544 2086 +2544 3032 +2544 4163 +2544 4164 +2544 4165 +2666 8 +2666 1036 +2666 1482 +2666 1485 +2666 2035 +2666 4868 +2666 5154 +2666 5806 +2666 5807 +2666 5808 +3032 125 +3032 128 +3032 148 +3032 248 +3032 353 +3032 424 +3032 559 +3032 1317 +3032 2001 +425 8 +425 121 +425 122 +425 128 +425 147 +425 177 +425 251 +425 422 +425 426 +425 427 +2781 1980 +5008 31 +5008 123 +5008 176 +5008 250 +5008 1317 +5008 1518 +5008 3781 +5008 3934 +5008 4754 +5008 5599 +412 769 +412 2253 +412 2532 +412 3029 +412 3215 +412 3485 +412 4254 +412 5484 +412 5501 +412 5502 +1001 614 +1001 788 +1001 1071 +1001 1100 +1001 1291 +1001 2198 +1001 2931 +1001 2932 +1001 2933 +1001 2934 +1001 2935 +1001 2936 +2683 152 +2683 1695 +2683 2354 +2683 2385 +2683 3109 +2683 3343 +2683 3710 +2683 3879 +2683 3981 +2683 4170 +3865 23 +3865 1235 +3865 2036 +3865 4173 +3865 4904 +3865 4963 +3865 4964 +3865 4965 +3865 4966 +3865 4967 +1522 140 +1522 609 +1522 693 +1522 730 +1522 1249 +1522 1313 +1522 1349 +1522 2032 +1522 3328 +1522 3329 +15 3 +15 123 +15 129 +15 143 +15 251 +15 264 +15 367 +15 426 +15 427 +15 718 +855 249 +855 251 +855 266 +855 322 +855 367 +855 558 +855 667 +855 856 +855 857 +855 858 +4629 151 +4629 281 +4629 491 +4629 2360 +4629 2781 +4629 3576 +4629 3891 +4629 5328 +4629 5391 +5414 855 +5890 285 +2133 86 +2133 433 +2133 1378 +2133 2451 +2133 2637 +2133 3185 +2133 3862 +2133 3880 +2133 3881 +2133 3882 +2134 710 +2134 712 +2134 2847 +2134 3166 +2134 3410 +2134 3756 +2134 3863 +2134 3883 +2134 3884 +2134 3885 +2181 63 +2181 291 +2181 307 +2181 1873 +2181 2546 +2181 2554 +2181 2646 +2181 2697 +2181 3204 +2181 3335 +324 568 +2037 148 +2037 176 +2037 179 +2037 238 +2037 265 +2037 369 +2037 424 +2037 426 +2037 1317 +2037 2098 +2038 266 +2038 390 +2038 422 +2038 423 +2038 559 +2038 736 +2038 754 +2038 856 +2038 886 +2038 2018 +2039 348 +2039 1033 +2039 3465 +2039 4438 +2039 5170 +2039 5171 +2039 5172 +2039 5173 +2039 5174 +2039 5175 +2043 125 +2043 191 +2043 449 +2043 2621 +2043 3010 +2043 3817 +2043 3818 +2043 3819 +2043 3820 +2043 3821 +718 167 +718 243 +718 326 +718 404 +718 942 +718 1885 +718 1886 +718 1887 +2381 193 +2381 924 +2381 1243 +2381 1297 +2381 1515 +2381 1868 +2381 2213 +2381 4066 +2381 4067 +2381 4068 +977 295 +977 2093 +977 2517 +977 2840 +977 2865 +977 2866 +977 2867 +977 2868 +977 2869 +977 2870 +2374 5 +2374 125 +2374 129 +2374 145 +2374 247 +2374 249 +2374 367 +2374 424 +2374 427 +2374 1317 +2375 2035 +2375 2298 +2375 3112 +2375 3695 +2375 4057 +2375 4058 +2375 4059 +2375 4060 +2375 4061 +2375 4062 +2096 7 +2096 147 +2096 248 +2096 250 +2096 289 +2096 353 +2096 390 +2096 753 +2096 754 +2096 762 +3405 732 +3405 1947 +3405 2751 +3405 3232 +3405 3237 +3405 4223 +3405 4735 +3405 4736 +3405 4737 +3405 4738 +3616 321 +3616 699 +3616 3115 +3616 3934 +3616 4858 +3616 4859 +3616 4860 +3616 4861 +3616 4862 +3616 4863 +3967 1123 +3967 1195 +3967 1288 +3967 1833 +3967 2035 +3967 2529 +3967 2755 +3967 4330 +3967 5019 +3967 5020 +4222 156 +4222 582 +4222 726 +4222 892 +4222 894 +4222 904 +4222 1203 +4222 1559 +4222 1670 +4222 2536 +4203 875 +4203 1675 +4203 4118 +4203 4277 +4203 4917 +4203 5129 +4203 5130 +4204 202 +4204 989 +4204 2337 +4204 3367 +4204 3931 +4204 4248 +4204 5047 +4204 5131 +4204 5132 +2148 1048 +2148 2067 +2148 2179 +2148 3134 +2148 3196 +2148 3891 +2148 3892 +2148 3893 +2148 3894 +2148 3895 +3312 29 +3312 513 +3312 532 +3312 1784 +3312 2143 +3312 2695 +3312 2955 +3312 3997 +3312 4669 +3312 4670 +4516 282 +4516 665 +4516 1143 +4516 1988 +4516 2961 +4516 3777 +4516 5333 +4516 5334 +4516 5335 +303 309 +303 341 +303 764 +303 909 +303 1061 +303 1093 +303 1095 +303 2253 +303 2254 +303 2255 +771 507 +771 838 +771 1003 +771 1402 +771 1717 +771 1896 +771 1968 +771 2689 +771 2705 +771 2706 +4359 113 +4359 190 +4359 363 +4359 1056 +4359 1805 +4359 2984 +4359 3275 +4359 4018 +4359 4589 +4359 5004 +4793 105 +4793 127 +4793 423 +4793 442 +4793 918 +4793 1540 +4793 2445 +4793 4664 +4793 5497 +4891 249 +4891 290 +4891 1456 +4891 2149 +4891 2949 +4891 4639 +4891 5106 +4891 5550 +4891 5551 +4891 5552 +5895 122 +5895 123 +5895 128 +5895 129 +5895 249 +5895 251 +5895 266 +5895 368 +5895 427 +5895 718 +6061 6150 +6062 1956 +6062 2761 +6062 3587 +6062 4577 +6062 4818 +6062 5554 +6062 6013 +6062 6151 +6062 6152 +6062 6153 +684 93 +684 1376 +684 1955 +684 2227 +684 2300 +684 2421 +684 2630 +684 2631 +684 2632 +684 2633 +2360 740 +2360 925 +2360 1062 +2360 1245 +2360 3550 +2360 3626 +2360 4053 +2360 4054 +2360 4055 +2360 4056 +4291 5017 +4566 92 +4566 163 +4566 1129 +4566 1808 +4566 3524 +4566 3636 +4566 4431 +4566 4776 +4566 5277 +4566 5353 +4567 149 +4567 261 +4567 649 +4567 1042 +4567 1060 +4567 1867 +4567 1922 +4567 5350 +4567 5351 +4567 5352 +4568 202 +4568 1330 +4568 2791 +4568 5354 +4568 5355 +4568 5356 +4568 5357 +4568 5358 +2398 2792 +2398 3019 +2398 3721 +2398 3813 +2398 4087 +548 469 +548 549 +548 550 +548 551 +548 552 +548 553 +548 554 +548 555 +548 556 +1165 535 +1165 1163 +1165 2089 +1165 2204 +1165 2561 +1165 2795 +1165 3055 +1165 3056 +1165 3057 +1165 3058 +1217 554 +1217 1424 +1217 1670 +1217 1749 +1217 2341 +1217 2672 +1217 2839 +1217 3081 +1217 3082 +1217 3083 +2022 2344 +2343 338 +2343 1196 +2343 1198 +2343 1766 +2343 2320 +2343 2889 +2343 3113 +2343 3301 +2343 3565 +2343 3566 +3232 56 +3232 811 +3232 2489 +3232 2524 +3232 3460 +3232 3994 +3232 4010 +3232 4617 +3232 4618 +3232 4619 +3903 690 +3903 902 +3903 2325 +3903 2942 +3903 3106 +3903 3563 +3903 4847 +3903 4981 +3903 4982 +3903 4983 +4213 477 +4213 579 +4213 856 +4213 1824 +4213 2214 +4213 2366 +4213 2463 +4213 4293 +4213 4894 +4213 5140 +4215 532 +4215 620 +4215 1067 +4215 1089 +4215 1799 +4215 3526 +4215 3682 +4215 4583 +4215 5149 +4216 11 +4216 325 +4216 649 +4216 1300 +4216 1592 +4216 2475 +4216 2928 +4216 4166 +4216 5141 +4216 5142 +4217 5 +4217 265 +4217 823 +4217 1947 +4217 4711 +4217 4712 +4217 4861 +4217 5143 +4217 5144 +4217 5145 +1656 2729 +1656 5140 +4143 685 +4143 1036 +4143 1797 +4143 2334 +4143 3562 +4220 143 +4220 146 +4220 248 +4220 249 +4220 367 +4220 390 +4220 423 +4220 427 +4220 717 +4220 1245 +2654 836 +2654 908 +2654 1412 +2654 2076 +2654 2461 +2654 2660 +2654 3767 +2654 3995 +2654 4243 +2654 4244 +3558 307 +3558 690 +3558 983 +3558 1367 +3558 3266 +3558 3737 +3558 3856 +3558 4686 +3558 4827 +257 69 +257 1137 +257 1233 +257 1300 +257 1301 +257 1302 +257 1303 +257 1304 +257 1305 +257 1306 +3615 155 +3615 2324 +3615 2502 +3615 2504 +3615 3345 +3615 4145 +3615 4864 +3615 4865 +344 881 +930 5 +930 7 +930 147 +930 148 +930 367 +930 368 +930 422 +930 559 +930 1317 +2275 587 +2275 989 +2275 1435 +2275 2412 +2275 2726 +2275 3768 +2275 3958 +2275 3959 +2275 3960 +2275 3961 +2292 298 +2292 667 +2292 1044 +2292 1259 +2292 1762 +2292 2497 +2292 3329 +2292 3982 +2292 3983 +2292 3984 +2498 819 +2498 2502 +2498 3129 +2498 3489 +2498 4107 +2498 4143 +2498 4144 +2498 4145 +2498 4146 +2498 4147 +3296 918 +3296 2027 +3296 2067 +3296 3714 +3296 4204 +3296 4657 +3296 4658 +3296 4659 +3296 4660 +3296 4661 +3962 1122 +3962 1557 +3962 1992 +3962 2380 +3962 2383 +3962 3350 +3962 3981 +3962 4434 +3962 4693 +3962 5018 +3963 23 +3963 96 +3963 350 +3963 1322 +3963 1664 +3963 1798 +3963 3144 +3963 4022 +3963 4890 +1193 5 +1193 250 +1193 265 +1193 4711 +1193 5518 +1193 5519 +1193 5520 +1531 125 +1531 1257 +1531 1532 +1531 1533 +1531 1534 +1531 1535 +1531 1536 +1531 1537 +1531 1538 +1531 1539 +2084 3 +2084 8 +2084 128 +2084 176 +2084 238 +2084 247 +2084 266 +2084 390 +2084 424 +2084 856 +2087 30 +2087 364 +2087 1034 +2087 2681 +2087 3350 +2087 3376 +2087 3847 +2087 3848 +2087 3849 +2087 3850 +2088 131 +2088 267 +2088 532 +2088 1431 +2088 2066 +2088 2819 +2088 2966 +2088 3280 +2088 3516 +2088 3846 +198 412 +198 604 +198 870 +198 1466 +198 1556 +198 2147 +198 2148 +198 2149 +198 2150 +198 2151 +1333 386 +1333 604 +1333 837 +1333 2011 +1333 2093 +1333 2776 +1333 2871 +1333 3175 +1333 3176 +1333 3177 +1029 121 +1029 122 +1029 125 +1029 127 +1029 147 +1029 249 +1029 251 +1029 367 +1029 718 +1029 2098 +1850 21 +1850 191 +1850 585 +1850 2041 +1850 3039 +1850 3595 +1850 3596 +1850 3597 +1850 3598 +1850 3599 +3851 850 +1027 1221 +1027 1316 +1027 1750 +1027 2471 +1027 2612 +1027 2849 +1027 2859 +1027 2952 +1027 2953 +1027 2954 +2424 8 +2424 63 +2424 1691 +2424 1901 +2424 1956 +2424 2231 +2424 2838 +2424 2842 +2653 2403 +2653 2764 +2653 2973 +2653 3576 +2653 4237 +2653 4426 +2653 5289 +2653 5417 +2653 5418 +3448 123 +3448 127 +3448 129 +3448 143 +3448 146 +3448 176 +3448 247 +3448 249 +3448 352 +3448 717 +3839 4063 +801 940 +801 1866 +801 1867 +801 2036 +801 2200 +801 2724 +801 2725 +801 2726 +801 2727 +801 2728 +1561 122 +1561 127 +1561 129 +1561 176 +1561 177 +1561 238 +1561 251 +1561 352 +1561 353 +1561 1245 +11 12 +11 13 +11 14 +11 15 +11 16 +11 17 +11 18 +11 19 +11 20 +11 21 +3699 195 +3699 1903 +3699 2479 +3699 2650 +3699 2768 +3699 3822 +3699 4180 +3699 4888 +3699 4889 +3699 4890 +5202 158 +5202 202 +5202 255 +5202 532 +5202 553 +5202 573 +5202 823 +5202 883 +5202 914 +5202 923 +5202 979 +5202 1047 +5202 1213 +5202 1615 +5202 1708 +5202 1789 +5202 1805 +5202 1808 +5202 1868 +5202 1881 +5202 2015 +5202 2035 +5202 2555 +5202 2664 +5202 2693 +5202 2721 +5202 2905 +5202 3153 +5202 3288 +5202 3351 +5202 3479 +5202 3511 +5202 3740 +5202 3861 +5202 4093 +5202 4333 +5202 4453 +5202 4563 +5202 4623 +5202 4873 +5202 4912 +5202 5029 +5202 5051 +5202 5321 +5202 5629 +5202 5702 +1868 146 +1868 148 +1868 149 +1868 174 +1868 251 +1868 252 +1868 367 +1868 390 +1868 718 +1868 1317 +3462 2115 +3462 2568 +3462 4393 +3462 4395 +3462 4761 +3462 4762 +3462 4763 +3462 4764 +3462 4765 +3462 4766 +2345 510 +2345 881 +2345 3034 +2345 3184 +2345 3547 +2345 4001 +2345 4002 +2345 4042 +2345 4043 +2345 4044 +3719 113 +3719 180 +3719 795 +3719 2186 +3719 2341 +3719 3523 +3719 3740 +3719 4884 +3719 4904 +3719 4905 +4121 732 +4121 960 +4121 1430 +4121 2259 +4121 2655 +4121 3937 +4121 4348 +4121 5083 +4121 5084 +4121 5085 +4122 77 +4122 1030 +4122 1721 +4122 1947 +4122 1982 +4122 2377 +4122 2448 +4122 2523 +4122 3153 +4122 3171 +2024 29 +2024 53 +2024 56 +2024 1034 +2024 1230 +2024 1556 +2024 3489 +2024 3794 +2024 3795 +2024 3796 +2936 534 +2936 2414 +2936 3772 +2936 4412 +2936 4413 +2936 4414 +2646 1544 +2646 1854 +2646 1936 +2646 3105 +2646 3608 +2646 3731 +2646 4236 +2646 4237 +2903 117 +2903 380 +2903 716 +2903 1043 +2903 1706 +2903 1780 +2903 2761 +2903 3146 +2903 4387 +2903 4388 +2904 531 +2904 820 +2904 930 +2904 1608 +2904 1845 +2904 1956 +2904 4156 +2904 4399 +2904 4400 +2904 4401 +2906 301 +2906 692 +2906 2106 +2906 2670 +2906 2916 +2906 3188 +2906 4334 +2906 4402 +2906 4403 +2906 4404 +401 122 +401 124 +401 127 +401 146 +401 247 +401 264 +401 422 +401 423 +401 427 +401 559 +3397 4304 +3966 788 +3966 944 +3966 1163 +3966 1313 +3966 2068 +3966 3524 +3966 4371 +3966 4694 +3966 4801 +3966 5021 +243 1564 +243 2189 +243 2190 +243 2191 +243 2192 +243 2193 +243 2194 +243 2195 +243 2196 +1923 60 +1923 82 +1923 586 +1923 835 +1923 1749 +1923 1969 +1923 2317 +1923 3693 +1923 3694 +1923 3695 +440 261 +440 1607 +440 1868 +440 2312 +440 2399 +440 2492 +440 2784 +440 3617 +440 4781 +440 5476 +984 257 +984 440 +984 859 +984 985 +984 986 +984 987 +984 988 +984 989 +984 990 +984 991 +2486 133 +2486 309 +2486 478 +2486 691 +2486 1019 +2486 1235 +2486 1317 +2486 2196 +2486 4127 +2486 4128 +3058 122 +3058 124 +3058 143 +3058 247 +3058 252 +3058 264 +3058 367 +3058 369 +3058 559 +208 209 +208 210 +208 211 +208 212 +208 213 +208 214 +208 215 +208 216 +208 217 +1934 4 +1934 5 +1934 144 +1934 145 +1934 175 +1934 367 +1934 390 +1934 559 +1934 718 +2456 942 +3728 73 +3728 2923 +3728 3495 +3728 4908 +3728 4909 +3732 1454 +3732 1509 +3732 1568 +3732 1946 +3732 2276 +3732 5688 +3732 5796 +3732 5823 +3732 6138 +1626 340 +1626 637 +1626 860 +1626 2075 +1626 2410 +1626 2570 +1626 3110 +1626 3379 +1626 3380 +1626 3381 +387 825 +387 1733 +387 1961 +387 2001 +387 2353 +387 2354 +387 2355 +387 2356 +1942 2255 +1942 2272 +1942 2853 +1942 2932 +1942 3027 +1942 3718 +1942 3719 +1942 3720 +1942 3721 +3234 4709 +437 1090 +437 1486 +437 2500 +1409 5 +1409 127 +1409 148 +1409 183 +1409 252 +1409 264 +1409 559 +1409 666 +1409 1317 +1504 127 +1504 128 +1504 179 +1504 249 +1504 353 +1504 424 +1504 426 +1504 1354 +1504 3326 +1504 3327 +2871 13 +2871 554 +2871 1756 +2871 3247 +2871 3485 +2871 3489 +2871 3959 +2871 4342 +2871 4343 +3281 3070 +3281 3122 +3281 3326 +3281 4581 +3281 4641 +3281 4648 +3281 4649 +3281 4650 +3281 4651 +3281 4652 +279 8 +279 280 +279 281 +279 282 +279 283 +279 284 +279 285 +279 286 +279 287 +279 288 +3921 312 +3921 837 +3921 894 +3921 897 +3921 942 +3921 1016 +3921 1267 +3921 1524 +3921 3612 +3921 4889 +2066 4 +2066 17 +2066 144 +2066 145 +2066 148 +2066 149 +2066 179 +2066 424 +2066 559 +2066 856 +3660 3 +3660 122 +3660 459 +3660 1252 +3660 1849 +3660 2077 +3660 3178 +3660 4170 +3660 4772 +3660 4881 +4603 5381 +4728 102 +4728 126 +4728 144 +4728 145 +4728 179 +4728 266 +4728 483 +4728 1827 +4728 3290 +4728 4643 +4729 4986 +4730 2519 +4730 2776 +4730 2844 +4730 4273 +4730 4438 +4730 4441 +4730 4664 +4730 4944 +4730 5231 +4730 5453 +2604 4166 +2606 7 +2606 123 +2606 125 +2606 145 +2606 148 +2606 177 +2606 179 +2606 247 +2606 559 +2606 2018 +2607 357 +2607 1092 +2607 1866 +2607 2279 +2607 4150 +2607 4205 +2607 4206 +2607 4207 +2607 4208 +2607 4209 +2868 167 +2868 1232 +2868 1451 +2868 2266 +2868 2723 +2868 2931 +2868 2941 +2868 3375 +2868 3981 +2868 4341 +3120 178 +3120 253 +3120 263 +3120 553 +3120 2325 +3120 2497 +3120 3826 +3120 3942 +3120 4542 +3120 4543 +3126 113 +3127 2157 +3127 2422 +3127 3185 +3127 4573 +3127 4640 +3127 4641 +4189 107 +4189 298 +4189 1396 +4189 1718 +4189 1890 +4189 3543 +4189 4094 +4189 5118 +4189 5119 +4189 5120 +4317 1511 +1339 377 +3346 75 +3346 759 +3346 1583 +3346 2248 +3346 2490 +3346 3966 +3346 4281 +3346 4464 +3346 4683 +3346 4684 +4081 541 +4081 760 +4081 937 +4081 1022 +4081 1929 +4081 1940 +4081 3738 +4081 4402 +4081 5076 +4405 3 +4405 124 +4405 177 +4405 249 +4405 251 +4405 252 +4405 264 +4405 368 +4405 559 +4405 2018 +1158 552 +1158 1017 +1158 1316 +1158 2146 +1158 2844 +1158 3039 +1158 3040 +1158 3041 +1158 3042 +1158 3043 +1382 130 +1382 208 +1382 476 +1382 849 +1382 874 +1382 1022 +1382 1384 +1382 1411 +1382 1671 +1382 1955 +1382 2226 +1382 2414 +1382 2612 +1382 2658 +1382 2819 +1382 3335 +1382 3552 +1382 4132 +1382 4170 +1382 4825 +1382 5241 +1382 5428 +1382 5487 +1382 5494 +1382 5717 +1382 5785 +1382 5786 +1382 5787 +1382 5788 +3059 7 +3059 8 +3059 123 +3059 129 +3059 144 +3059 149 +3059 174 +3059 248 +3059 367 +3059 717 +3060 92 +3060 268 +3060 393 +3060 1720 +3060 2114 +3060 2451 +3060 2500 +3060 3609 +3060 3959 +3060 4295 +3061 4 +3061 126 +3061 144 +3061 689 +3061 4428 +3061 4451 +3061 4486 +3061 4487 +3061 4488 +3063 707 +3063 926 +3063 3016 +3063 3570 +3063 4492 +659 123 +659 143 +659 667 +659 1084 +659 1814 +659 1870 +659 2244 +659 2295 +659 2576 +659 2577 +2852 159 +2852 288 +2852 422 +2852 554 +2852 576 +2852 837 +2852 1199 +2852 1429 +2852 1583 +2852 1591 +2852 1980 +2852 2547 +2852 2918 +2852 3105 +2852 3139 +2852 3921 +2852 4344 +2852 4345 +2852 4346 +2852 4347 +2852 4348 +2852 4349 +2852 4350 +2852 4351 +2852 4352 +2852 4353 +2852 4354 +2852 4355 +3149 1258 +3149 2007 +3149 2039 +3149 2067 +3149 2197 +3149 2218 +3149 2888 +3149 4380 +3149 4549 +3149 4550 +3813 491 +3813 637 +3813 1150 +3813 1338 +3813 1540 +3813 1947 +3813 4789 +3813 4895 +3813 4934 +3813 4935 +740 124 +740 174 +740 1255 +740 1487 +740 1531 +740 1557 +740 1609 +740 2385 +740 2663 +740 4539 +3004 1900 +3004 1983 +3004 3463 +3004 4584 +3039 584 +3039 4599 +3815 178 +3815 1377 +3815 1614 +3815 2200 +3815 2901 +3815 3217 +3815 3225 +3815 3619 +3815 4207 +3815 4733 +1124 360 +1124 1061 +1124 1064 +1124 1125 +1124 1126 +1124 1127 +1124 1128 +1124 1129 +1124 1130 +1124 1131 +1124 1132 +1124 1133 +1831 3568 +1084 49 +1084 184 +1084 505 +1084 725 +1084 1085 +1084 1086 +1084 1087 +1084 1088 +1084 1089 +1084 1090 +1770 2322 +4751 8 +4751 122 +4751 129 +4751 177 +4751 249 +4751 251 +4751 352 +4751 353 +4751 367 +4751 856 +406 1999 +3459 3 +3459 124 +3459 127 +3459 129 +3459 177 +3459 251 +3459 266 +3459 367 +3459 368 +3459 422 +3654 586 +3654 1089 +3654 1280 +3654 1923 +3654 2723 +3654 4009 +3654 4124 +3654 4584 +3654 4877 +3654 4878 +3726 30 +3726 152 +3726 1917 +3726 2186 +3726 2646 +3726 2922 +3726 3259 +3726 3411 +3726 4913 +3726 4914 +4072 4854 +5137 125 +5137 129 +5137 144 +5137 147 +5137 148 +5137 179 +5137 352 +5137 1246 +5137 1317 +5137 2001 +5138 2383 +1827 434 +1827 979 +1827 1697 +1827 1828 +1827 1829 +1827 1830 +1827 1831 +1827 1832 +1827 1833 +3171 113 +3171 870 +3171 997 +3171 3995 +3171 4017 +3171 4120 +3171 4206 +3171 4402 +3171 4569 +3171 4570 +4846 926 +4846 1258 +4846 1382 +4846 1706 +4846 3062 +4846 3064 +4846 4170 +4846 4339 +4846 5881 +5236 125 +5236 143 +5236 145 +5236 146 +5236 147 +5236 367 +5236 368 +5236 422 +5236 559 +5236 754 +5238 208 +5238 347 +5238 724 +5238 3129 +5238 3823 +5238 4764 +5238 5726 +5238 5727 +5238 5728 +5238 5729 +20 121 +20 147 +20 368 +20 427 +20 717 +20 856 +20 975 +20 1908 +20 1909 +20 1910 +1162 452 +1162 453 +1162 460 +1162 563 +1162 803 +1162 847 +1162 1163 +1162 1164 +1162 1165 +1162 1166 +1670 113 +1670 473 +1670 1049 +1670 1321 +1670 1540 +1670 2298 +1670 2896 +1670 3014 +1670 3166 +1670 3572 +2173 2569 +4004 682 +4004 2149 +4004 2442 +4004 5029 +4004 5030 +4004 5031 +4004 5032 +4004 5033 +4004 5034 +4004 5035 +4083 4317 +4587 462 +4587 1359 +4587 1457 +4587 1688 +4587 2875 +4587 3038 +4587 3858 +4587 4880 +4587 5367 +4587 5368 +2859 571 +2859 609 +2859 695 +2859 802 +2859 864 +2859 870 +2859 2638 +2859 3109 +2859 4334 +2859 4356 +131 93 +131 1466 +131 1831 +131 1994 +131 2092 +131 2093 +131 2094 +131 2095 +131 2096 +131 2097 +4400 762 +4400 1647 +4400 2170 +4400 2579 +4400 2599 +4400 4097 +4400 4867 +4400 5260 +4400 5261 +4400 5262 +4951 748 +4951 780 +4951 803 +4951 1280 +4951 2236 +4951 2285 +4951 2568 +4951 2583 +4951 4641 +4951 4799 +472 347 +472 1267 +472 1485 +472 1486 +472 1487 +472 1488 +472 1489 +472 1490 +472 1491 +472 1492 +1411 558 +1411 576 +1411 1412 +1411 1413 +1411 1414 +1411 1415 +1411 1416 +1411 1417 +1411 1418 +1926 982 +1926 1929 +1926 2090 +1926 2317 +1926 2407 +1926 3107 +1926 3696 +1926 3697 +1926 3698 +1926 3699 +3552 2 +3552 123 +3552 147 +3552 177 +3552 250 +3552 251 +3552 351 +3552 946 +3552 983 +3552 2077 +4160 3 +4160 7 +4160 9 +4160 124 +4160 125 +4160 126 +4160 128 +4160 176 +4160 247 +4160 424 +5440 196 +5440 558 +5440 1021 +5440 1088 +5440 1447 +5440 3374 +5440 4885 +5440 5245 +5440 5818 +5440 5819 +4676 524 +4676 3050 +4676 3780 +4676 4109 +5241 198 +5241 1192 +5241 1969 +5241 2776 +5241 2888 +5241 3395 +5241 4251 +5241 4641 +5241 4992 +5241 5725 +63 1364 +63 1950 +63 1977 +63 1978 +63 1979 +63 1980 +63 1981 +63 1982 +63 1983 +1694 246 +1694 942 +1694 3032 +1694 3443 +1694 3444 +1694 3445 +1694 3446 +1694 3447 +5443 898 +5443 1115 +5443 1227 +5443 3217 +5443 4128 +5443 5823 +5443 5824 +5443 5825 +5443 5826 +209 976 +209 1903 +209 1940 +209 2103 +209 2429 +209 2430 +209 2431 +209 2432 +1917 1601 +1917 1711 +1917 1845 +1917 1985 +1917 2181 +1917 2619 +1917 3052 +1917 3056 +1917 3683 +1917 3684 +2244 532 +2244 1219 +2244 1354 +2244 1776 +2244 1842 +2244 2650 +2244 2995 +2244 3943 +2244 3944 +2244 3945 +2245 4092 +1107 998 +3694 1280 +5253 976 +5253 1787 +5253 1809 +5253 2156 +5253 2309 +5253 3185 +5253 4448 +5253 4641 +5253 4793 +5254 450 +5254 2308 +5254 3488 +5254 4426 +5254 4654 +5254 4998 +5254 5474 +5254 5594 +5254 5731 +5254 5732 +5255 147 +5255 248 +5255 422 +5255 427 +5255 2001 +5255 2018 +5255 2968 +5255 3804 +5255 5636 +5255 5730 +5257 76 +5257 726 +5257 3877 +5257 3903 +5257 5734 +5259 4540 +483 1812 +521 27 +521 117 +521 325 +521 577 +521 578 +521 579 +521 580 +521 581 +521 582 +521 583 +1413 1171 +1413 2575 +1413 2582 +1413 2640 +1413 2672 +1413 2828 +1413 2960 +1413 3035 +1413 3269 +1413 3270 +1654 997 +1654 1023 +1654 2552 +1654 2825 +1654 2876 +1654 3282 +1654 3404 +1654 3405 +1654 3406 +1654 3407 +4113 123 +4113 127 +4113 176 +4113 179 +4113 248 +4113 249 +4113 352 +4113 422 +4113 427 +4113 667 +4914 125 +4914 498 +4914 1211 +4914 2798 +4914 3249 +4914 3819 +4914 4006 +4914 4474 +4914 5566 +4914 5567 +751 31 +751 124 +751 146 +751 266 +751 367 +751 427 +751 559 +751 667 +751 856 +751 2001 +3156 477 +3156 710 +3156 2347 +3156 2540 +3156 3489 +3156 4344 +3156 4563 +3156 4564 +3156 4565 +5312 5278 +878 59 +878 202 +878 510 +878 879 +878 880 +878 881 +878 882 +878 883 +878 884 +878 885 +1540 111 +1540 676 +1540 1023 +1540 1050 +1540 1167 +1540 1541 +1540 1542 +1540 1543 +1540 1544 +1540 1545 +3557 23 +3557 113 +3557 1123 +3557 1227 +3557 1501 +3557 2214 +3557 2276 +3557 4371 +3557 4816 +3557 4817 +6241 424 +6241 1800 +6241 3712 +6241 5128 +6241 5182 +6241 6119 +6241 6120 +6241 6255 +6241 6256 +6241 6257 +679 270 +679 680 +679 681 +679 682 +679 683 +679 684 +679 685 +679 686 +679 687 +679 688 +532 1329 +532 1330 +2068 119 +2068 1240 +2068 1415 +2068 1709 +2068 2664 +2068 3741 +2068 3879 +4095 38 +4095 257 +4095 573 +4095 2274 +4095 3299 +4095 3409 +4095 4164 +4095 4230 +4095 4695 +4095 5077 +4096 1772 +500 59 +500 1475 +500 1476 +2798 177 +2798 261 +2798 266 +2798 1134 +2798 1529 +2798 3304 +2798 3590 +2798 4307 +2798 4308 +2798 4309 +478 479 +478 480 +478 481 +478 482 +478 483 +478 484 +478 485 +478 486 +478 487 +478 488 +786 15 +786 331 +786 1300 +786 1326 +786 2091 +786 2714 +786 2715 +786 2716 +786 2717 +786 2718 +2261 122 +2261 124 +2261 128 +2261 129 +2261 176 +2261 249 +2261 264 +2261 367 +2261 368 +2261 369 +4768 989 +4768 5477 +1388 122 +1388 123 +1388 147 +1388 176 +1388 177 +1388 246 +1388 264 +1388 422 +1388 1245 +4551 63 +4551 260 +4551 562 +4551 870 +4551 2236 +4551 3397 +4551 4407 +4551 4970 +4551 5348 +4551 5349 +4769 983 +4769 2670 +4769 2986 +4769 3038 +4769 3337 +4769 4203 +4769 5085 +4769 5140 +4769 5471 +4769 5472 +3705 276 +3705 552 +3705 995 +3705 1947 +3705 1972 +3705 2430 +3705 3594 +3705 4891 +3705 4892 +4149 5105 +4151 5091 +3479 572 +3479 1085 +3479 1456 +3479 3015 +3479 3392 +3479 3634 +3479 3781 +3479 4405 +3479 4780 +1030 791 +1030 2651 +1030 2693 +1030 2944 +1030 2945 +1030 2946 +1030 2947 +1030 2948 +1030 2949 +1030 2950 +5016 133 +5016 241 +5016 582 +5016 965 +5016 1316 +5016 1541 +5016 1882 +5016 2090 +5016 5178 +5016 5601 +541 200 +541 710 +541 2534 +2347 38 +2347 540 +2347 554 +2347 584 +2347 1424 +2347 1940 +2347 2086 +2347 2653 +2347 4034 +2886 121 +2886 125 +2886 129 +2886 146 +2886 176 +2886 238 +2886 248 +2886 264 +2886 352 +2886 427 +3333 211 +3333 331 +3333 651 +3333 2125 +3333 2129 +3333 2377 +3333 3951 +3333 4249 +3333 4676 +3333 4677 +3635 1144 +3635 2170 +3635 2332 +3635 3860 +3635 4136 +3635 4872 +3635 4873 +3635 4874 +3635 4875 +3635 4876 +5436 1956 +1278 412 +1278 1299 +1278 1947 +1278 1974 +1278 2035 +1278 2228 +1278 2547 +1278 3709 +1278 3841 +1278 5199 +4297 4 +4297 9 +4297 125 +4297 143 +4297 145 +4297 148 +4297 264 +4297 368 +4297 1317 +4988 5 +4988 9 +4988 126 +4988 148 +4988 174 +4988 264 +4988 390 +4988 558 +4988 559 +5413 1310 +5413 1883 +5413 3621 +5413 4694 +5413 4723 +5413 4727 +5413 5542 +5413 5820 +5413 5821 +5413 5822 +2887 177 +2887 411 +2887 586 +2887 706 +2887 1588 +2887 3363 +2887 4369 +2887 4370 +2887 4371 +3046 715 +3046 1762 +3046 1865 +3046 2358 +3046 2563 +3046 2700 +3046 3109 +3046 4012 +3046 4658 +3046 5634 +5373 204 +5373 1049 +5373 1685 +5373 2088 +5373 4013 +5373 4317 +5373 4659 +5373 4909 +5373 5633 +5373 5799 +1750 158 +1750 231 +1750 1216 +1750 1217 +1750 1424 +1750 1717 +1750 2385 +1750 3510 +1750 3511 +1750 3512 +2299 424 +2299 2127 +2299 2330 +2299 2898 +2299 2907 +2299 2911 +2299 3991 +2299 3992 +2299 3993 +2299 3994 +3024 352 +3024 1139 +3024 1721 +3024 2790 +3024 3995 +3024 4460 +3024 4461 +3024 4462 +3024 4463 +4842 249 +5510 122 +5510 175 +5510 247 +5510 249 +5510 250 +5510 251 +5510 367 +5510 390 +5510 422 +5510 667 +380 218 +380 1030 +380 1230 +380 1231 +380 1232 +380 1233 +380 1234 +380 1235 +380 1236 +1751 103 +1751 123 +1751 3513 +1751 3514 +1751 3515 +2577 330 +2577 388 +2577 553 +2577 962 +2577 1306 +2577 2010 +2577 3179 +2577 4177 +2577 4178 +2577 4179 +3174 262 +3174 344 +3174 2613 +3174 2994 +3174 4571 +3658 520 +3658 1036 +3658 1587 +3658 1797 +3658 2334 +3658 3094 +3658 3473 +3658 4879 +3658 4880 +1782 503 +1782 1103 +1782 1224 +1782 1301 +1782 1585 +1782 2272 +1782 2766 +1782 3105 +1782 3531 +1782 3532 +1784 3 +1784 4 +1784 122 +1784 143 +1784 422 +1784 423 +1784 427 +1784 666 +1784 667 +5645 57 +5645 271 +5645 2249 +5645 3675 +5645 4077 +5645 5923 +5645 5924 +5645 5925 +5645 5926 +2662 4250 +906 303 +906 518 +906 907 +906 908 +906 909 +906 910 +906 911 +906 912 +906 913 +1250 193 +1250 308 +1250 878 +1250 935 +1250 1415 +1250 1524 +1250 2157 +1250 2179 +1250 3112 +1250 3113 +1859 23 +1859 56 +1859 125 +1859 1137 +1859 3093 +1859 3605 +1859 3606 +1859 3607 +1859 3608 +528 17 +528 241 +528 529 +528 530 +528 531 +528 532 +528 533 +528 534 +528 535 +528 536 +686 1162 +686 1309 +686 1573 +686 1958 +686 2587 +686 2588 +686 2589 +686 2590 +686 2591 +686 2592 +769 1024 +769 1335 +769 2547 +769 2579 +769 2670 +769 2700 +769 2701 +769 2702 +769 2703 +769 2704 +965 583 +965 1208 +965 1390 +965 1728 +965 2871 +965 2872 +965 2873 +965 2874 +965 2875 +965 2876 +2176 3 +2176 175 +2176 266 +2176 368 +2176 390 +2176 423 +2176 427 +2176 697 +2176 1245 +2732 227 +2732 717 +2732 1735 +2732 1749 +2732 1862 +2732 2497 +2732 3009 +2732 4293 +2732 4294 +2732 4295 +2548 17 +2548 146 +2548 175 +2548 266 +2548 423 +2548 558 +2548 559 +2548 667 +2548 697 +2548 1245 +4695 131 +4695 190 +4695 697 +4695 942 +4695 1730 +4695 1922 +4695 2423 +4695 5189 +4695 5428 +4695 5429 +5224 391 +5224 717 +5224 1542 +5224 1787 +5224 1881 +5224 2892 +5224 4490 +5224 4741 +5224 5720 +3451 833 +3451 1599 +3451 1845 +3451 1881 +3451 1889 +3451 3218 +3451 3446 +3451 4541 +3451 4759 +3451 4760 +3452 9 +3452 17 +3452 143 +3452 144 +3452 147 +3452 149 +3452 179 +3452 424 +3452 559 +3452 2018 +3634 1052 +3634 1067 +3634 2479 +3634 2528 +3634 3524 +3634 3677 +3634 4371 +3634 4641 +3634 4870 +3634 4871 +1255 148 +1255 150 +1255 179 +1255 352 +1255 390 +1255 906 +1255 1317 +1255 3115 +1255 3116 +1255 3117 +5670 268 +5670 522 +5670 2538 +5670 2735 +5670 4969 +5670 5149 +5670 5887 +5670 5930 +5670 5931 +5670 5932 +2794 513 +2794 1042 +2794 1509 +2794 2001 +2794 2292 +2794 2615 +2794 3215 +2794 3907 +2794 4306 +3810 1471 +3810 1591 +3810 2037 +3810 2038 +3810 2625 +3810 3822 +3810 4213 +3810 4932 +3810 4933 +345 126 +345 149 +345 177 +345 179 +345 248 +345 266 +345 424 +345 754 +345 2001 +846 152 +846 602 +846 847 +846 848 +846 849 +846 850 +846 851 +846 852 +846 853 +846 854 +1251 262 +1251 416 +1251 1057 +1251 1252 +1251 1253 +1251 1254 +1251 1255 +1251 1256 +1251 1257 +1251 1258 +1889 58 +1889 351 +1889 829 +1889 832 +1889 835 +1889 1306 +1889 1327 +1889 3636 +1889 3637 +1889 3638 +1893 1023 +1893 3136 +2621 4 +2621 146 +2621 368 +2621 390 +2621 422 +2621 423 +2621 856 +2621 1245 +2621 1317 +2621 2001 +1019 551 +1019 898 +1019 945 +1019 1533 +1019 2018 +1019 2926 +1019 2927 +1019 2928 +1019 2929 +1019 2930 +1176 124 +1176 147 +1176 251 +1176 266 +1176 367 +1176 368 +1176 422 +1176 2001 +1176 2018 +3979 8 +3979 9 +3979 125 +3979 128 +3979 175 +3979 250 +3979 353 +3979 424 +3979 754 +1984 255 +1984 361 +1984 2113 +1984 2721 +1984 3554 +1986 1103 +1987 227 +1987 2292 +1987 2528 +1987 2914 +1987 3709 +1987 5541 +1987 5584 +1987 5795 +1987 5796 +1987 5797 +1988 3768 +1989 848 +1989 1792 +1989 1845 +1989 2354 +1989 5177 +2728 121 +2728 129 +2728 174 +2728 183 +2728 238 +2728 353 +2728 424 +2728 427 +2728 717 +2728 2338 +3797 788 +3797 1954 +3797 2127 +3797 3017 +3797 3600 +3797 5089 +3797 5891 +3797 5892 +3797 5893 +3797 5894 +3016 995 +3016 1034 +3016 2148 +3016 3070 +3016 3740 +3016 4532 +3016 5179 +3016 5324 +3016 5325 +3016 5326 +4197 5 +4197 31 +4197 126 +4197 143 +4197 180 +4197 250 +4197 368 +4197 697 +4197 856 +4197 1245 +4275 4 +4275 122 +4275 143 +4275 146 +4275 266 +4275 367 +4275 666 +4275 667 +4275 754 +4275 856 +4438 631 +4438 769 +4438 812 +4438 1317 +4438 1374 +4438 2906 +4438 3617 +4438 3635 +4438 4873 +4438 5275 +4472 5 +4472 123 +4472 125 +4472 144 +4472 177 +4472 247 +4472 248 +4472 249 +4472 717 +4472 1317 +4628 68 +4628 831 +4628 1787 +4628 2355 +4628 2862 +4628 3304 +4628 3470 +4628 4889 +4628 5384 +4628 5385 +5093 2031 +411 96 +411 835 +411 1256 +411 1814 +411 2266 +411 2839 +411 3306 +411 5013 +411 5014 +411 5015 +13 2074 +2056 10 +2056 127 +2056 145 +2056 175 +2056 176 +2056 247 +2056 353 +2056 369 +2056 629 +2056 993 +2112 463 +2112 803 +2112 1492 +2112 2091 +2112 2111 +2112 2115 +2112 2287 +2112 2818 +2112 2941 +2112 3868 +2115 123 +2115 199 +2115 751 +2115 1506 +2115 2474 +2115 2805 +2115 3365 +2115 3595 +2115 3886 +2115 3887 +4419 8 +4419 31 +4419 126 +4419 144 +4419 148 +4419 175 +4419 179 +4419 247 +4419 558 +4419 697 +201 714 +201 2152 +201 2153 +201 2154 +201 2155 +201 2156 +201 2157 +201 2158 +201 2159 +201 2160 +1673 389 +1673 503 +1673 1513 +1673 1940 +1673 2216 +1673 2359 +1673 2634 +1673 2636 +1673 3448 +1673 3449 +229 840 +229 1123 +229 1194 +229 1726 +229 2217 +229 2218 +229 2219 +229 2220 +229 2221 +229 2222 +3102 815 +3102 1066 +3102 2067 +3102 2234 +3102 3916 +3102 4017 +3102 4257 +3102 4478 +3102 4535 +3102 4536 +4228 20 +4228 179 +4228 238 +4228 346 +4228 347 +4228 2337 +4228 3229 +4228 3480 +4228 4132 +4228 5150 +1476 686 +1476 1390 +1476 3017 +1476 3077 +1476 3317 +1476 3318 +1476 3319 +1476 3320 +1476 3321 +1476 3322 +2532 665 +2532 774 +2532 924 +2532 1709 +2532 1859 +2532 2767 +2532 3136 +2532 3682 +2532 3698 +2532 4160 +3833 414 +3833 1168 +3833 1415 +3833 2257 +3833 4037 +3833 4948 +3833 4949 +3833 4950 +3833 4951 +3833 4952 +4465 143 +4465 175 +4465 176 +4465 252 +4465 367 +4465 368 +4465 422 +4465 2001 +4465 2018 +4725 255 +4725 381 +4725 2226 +4725 3181 +4725 5456 +4726 804 +4726 1507 +4726 2292 +4726 2697 +4726 3496 +4726 3516 +4726 3949 +4726 4042 +4726 5261 +646 9 +646 126 +646 145 +646 147 +646 179 +646 252 +646 265 +646 368 +646 426 +1487 3 +1487 127 +1487 177 +1487 183 +1487 247 +1487 249 +1487 367 +1487 427 +1487 718 +1487 2338 +3223 1327 +3223 2265 +3223 3720 +3223 4609 +3223 4610 +4731 2554 +4731 3120 +4731 4770 +4731 5155 +4732 132 +4732 433 +4732 459 +4732 2060 +4732 2097 +4732 2332 +4732 2408 +4732 3312 +4732 3635 +4732 4667 +727 152 +2523 257 +2523 469 +2523 586 +2523 693 +2523 1356 +2523 1454 +2523 2500 +2523 3995 +2523 4158 +2523 4159 +3095 369 +3095 493 +3095 553 +3095 1599 +3095 1796 +3095 2211 +3095 3220 +3095 4521 +3095 4522 +3095 4523 +3095 4524 +3095 4525 +3095 4526 +3095 4527 +3095 4528 +3095 4529 +3095 4530 +3095 4531 +3843 17 +3843 143 +3843 148 +3843 175 +3843 250 +3843 266 +3843 423 +3843 697 +3843 754 +3843 1245 +5214 1193 +5214 1926 +5214 2236 +5214 2337 +5214 2847 +5214 4018 +5214 5081 +5214 5235 +5214 5714 +3733 118 +3733 241 +3733 1086 +3733 2119 +3733 2364 +3733 2502 +3733 3260 +3733 4910 +3733 4911 +3733 4912 +3734 5 +3734 125 +3734 145 +3734 179 +3734 390 +3734 422 +3734 424 +3734 558 +3734 667 +3734 856 +191 77 +191 2190 +191 2365 +191 2366 +191 2367 +191 2368 +191 2369 +191 2370 +191 2371 +191 2372 +3213 3 +3213 5 +3213 7 +3213 8 +3213 124 +3213 174 +3213 249 +3213 251 +3213 369 +3213 427 +3250 1903 +55 56 +55 57 +55 58 +55 59 +55 60 +55 61 +55 62 +55 63 +55 64 +55 65 +3258 124 +3258 127 +3258 128 +3258 143 +3258 147 +3258 247 +3258 251 +3258 266 +3258 369 +3258 1245 +3259 1090 +3259 2049 +3259 2050 +3259 2566 +3259 3014 +3259 3815 +3259 4282 +3259 4633 +3259 4634 +3259 4635 +3260 1212 +3260 1830 +3260 1845 +3260 1936 +3260 2108 +3260 2470 +3260 2563 +3260 2729 +3260 3601 +3490 4781 +706 3501 +706 4623 +706 4624 +4502 125 +4502 174 +4502 424 +4502 503 +4502 1142 +4502 1516 +4502 2537 +4502 4170 +4502 5331 +4502 5332 +937 5 +937 7 +937 143 +937 145 +937 146 +937 249 +937 251 +937 367 +937 666 +937 1317 +3309 9 +3309 97 +3309 413 +3309 581 +3309 1023 +3309 1026 +3309 1533 +3309 3460 +3309 3786 +3309 3822 +507 3 +507 127 +507 143 +507 249 +507 251 +507 252 +507 427 +507 2491 +507 2492 +2575 484 +2575 548 +2575 568 +2575 690 +2575 756 +2575 872 +2575 1025 +2575 2897 +2575 4173 +2575 4174 +4463 81 +4463 637 +4463 697 +4463 2875 +4463 3813 +4463 5100 +4463 5306 +4463 5307 +4944 390 +4944 427 +4944 777 +4944 1842 +4944 2269 +4944 2862 +4944 3658 +4944 4578 +4944 5581 +4944 5582 +466 2447 +466 2448 +466 2449 +466 2450 +466 2451 +1794 271 +1794 458 +1794 818 +1794 1250 +1794 1538 +1794 1766 +1794 1795 +1794 1796 +1794 1797 +1794 1798 +4940 988 +4940 1273 +4940 1480 +4940 2148 +4940 2201 +4940 2787 +4940 3169 +4940 3636 +4940 5579 +4940 5580 +162 163 +162 164 +162 165 +162 166 +162 167 +162 168 +162 169 +162 170 +162 171 +162 172 +3025 3221 +3025 3271 +3025 3335 +3025 4473 +3025 4474 +3026 3 +3026 123 +3026 128 +3026 129 +3026 143 +3026 146 +3026 177 +3026 251 +3026 367 +3026 1245 +1815 459 +1815 801 +1815 808 +1815 892 +1815 1794 +1815 1816 +1815 1817 +1815 1818 +1815 1819 +1815 1820 +416 640 +416 1002 +416 1477 +416 2013 +416 2327 +416 2434 +416 2435 +416 2436 +416 2437 +416 2438 +635 367 +635 404 +635 474 +635 668 +635 746 +635 747 +635 748 +635 749 +635 750 +635 751 +1135 4 +1135 147 +1135 176 +1135 246 +1135 249 +1135 251 +1135 252 +1135 264 +1135 266 +1135 718 +3224 2516 +3225 108 +3225 756 +3225 763 +3225 2911 +3225 3438 +3225 3679 +3225 3748 +3225 4611 +3225 4612 +3225 4613 +370 371 +370 372 +370 373 +370 374 +370 375 +370 376 +370 377 +370 378 +370 379 +370 380 +4293 54 +4293 2253 +4293 4062 +4293 4636 +4293 5193 +4293 5194 +4293 5195 +4293 5196 +4293 5197 +4293 5198 +4617 3716 +4617 3949 +4617 4783 +4617 5175 +4617 5211 +4617 5386 +4617 5387 +4617 5388 +4617 5389 +4617 5390 +787 276 +787 788 +787 789 +787 790 +787 791 +787 792 +787 793 +787 794 +787 795 +787 796 +3499 788 +4332 435 +4332 1219 +4332 2006 +4332 2042 +4332 2197 +4332 2776 +4332 3329 +4332 5217 +4332 5218 +4332 5219 +2102 1766 +2102 1956 +2102 2218 +2102 2841 +2102 3786 +2102 3869 +2102 3870 +2102 3871 +2102 3872 +2102 3873 +739 1380 +739 1609 +739 2664 +739 2665 +739 2666 +972 469 +972 2229 +972 2862 +972 2863 +972 2864 +605 8 +605 121 +605 127 +605 147 +605 176 +605 238 +605 352 +605 353 +605 422 +605 424 +1133 3158 +1209 325 +1209 583 +1209 1210 +1209 1211 +1209 1212 +1209 1213 +1209 1214 +1209 1215 +1209 1216 +1209 1217 +3273 623 +3273 962 +3273 1177 +3273 2337 +3273 2427 +3273 3981 +3273 4645 +3273 4646 +3273 4647 +113 17 +113 143 +113 144 +113 145 +113 179 +113 368 +113 424 +113 754 +113 1317 +113 2018 +5060 363 +5352 149 +5352 266 +5352 1317 +5352 1414 +5352 2197 +5352 2837 +5352 3614 +5352 4427 +5352 4844 +5352 5767 +5792 3 +5792 123 +5792 126 +5792 127 +5792 129 +5792 144 +5792 179 +5792 351 +5792 353 +5792 1317 +5793 436 +5793 551 +5793 1458 +5793 1509 +5793 2804 +5793 3233 +5793 5837 +5793 5983 +5793 5984 +5793 5985 +5794 771 +5794 1637 +5794 1940 +5794 5429 +5794 5986 +5794 5987 +5794 5988 +5794 5989 +5794 5990 +5794 5991 +1544 3337 +1544 3338 +1544 3339 +1544 3340 +3531 38 +3531 412 +3531 2266 +3531 2583 +3531 3441 +3531 3619 +3531 3671 +3531 3674 +3531 3868 +3531 4033 +5655 1608 +5981 111 +5981 830 +5981 1811 +5981 2163 +5981 2193 +5981 3861 +5981 3953 +5981 4332 +5981 6094 +5981 6095 +5982 243 +5982 2260 +5982 3093 +5982 3231 +5982 4592 +5982 5569 +5982 5645 +5982 6097 +5982 6098 +5982 6099 +1258 145 +1258 149 +1258 177 +1258 247 +1258 699 +1258 856 +1258 1317 +1258 2063 +1258 3002 +1258 3118 +2657 1245 +2657 2687 +2657 2866 +2657 3488 +2657 3680 +2657 3886 +2657 4074 +2657 4240 +2657 4241 +2657 4242 +6096 5254 +6269 76 +6269 760 +6269 1611 +6269 1862 +6269 2416 +6269 3767 +6269 6282 +6269 6283 +2777 1103 +2777 3292 +2777 5452 +2777 6039 +2777 6279 +3038 308 +3038 1001 +3038 1239 +3038 1766 +3038 2490 +3038 3516 +3038 3564 +3038 3781 +3038 4471 +3038 4472 +6102 570 +6102 1537 +6102 1838 +6102 1882 +6102 4227 +6102 5508 +6102 6096 +6102 6280 +6102 6281 +6262 898 +6262 3501 +6262 3629 +6262 3846 +6262 3968 +6262 4141 +6262 4397 +6262 5369 +6262 5779 +3991 289 +3991 1846 +3991 2330 +3991 3479 +3991 3632 +3991 4242 +3991 4503 +3991 4587 +3991 5036 +3991 5037 +5528 2716 +5528 4483 +5528 4660 +5528 4771 +5528 4929 +5528 4970 +5528 5863 +5528 5864 +5528 5865 +6264 31 +6264 165 +6264 174 +6264 250 +6264 353 +6264 697 +6264 1379 +6264 3056 +6264 5615 +6264 5617 +6266 169 +6266 892 +6266 2378 +6266 2789 +6266 5633 +6266 5923 +6266 6039 +6266 6237 +6266 6274 +6266 6275 +526 56 +526 527 +450 38 +450 203 +450 451 +450 452 +450 453 +450 454 +450 455 +450 456 +450 457 +1400 326 +1400 657 +1400 922 +1400 3262 +1400 3263 +1400 3264 +1400 3265 +1400 3266 +1400 3267 +1400 3268 +4167 1026 +4167 1898 +4167 2784 +4167 2826 +4167 2886 +4167 3001 +4167 3220 +4167 3858 +4167 4102 +4167 5104 +4062 1787 +4062 2901 +4062 3058 +4062 3334 +4062 3672 +4062 4871 +4062 4880 +4062 5058 +4062 5059 +5285 3440 +5285 5296 +5285 5748 +5285 5750 +5285 5751 +5285 5752 +5285 5753 +5285 5754 +5285 5755 +5285 5756 +2743 14 +2743 1022 +2743 1278 +2743 1352 +2743 2726 +2743 2974 +2743 3312 +2743 4151 +2743 4296 +2743 4297 +1734 157 +1734 351 +1734 554 +1734 814 +1734 1137 +1734 1808 +1734 2870 +1734 3566 +1734 5176 +2767 8 +2767 9 +2767 127 +2767 128 +2767 238 +2767 248 +2767 352 +2767 427 +2767 1317 +2767 4303 +2770 5 +2770 8 +2770 123 +2770 145 +2770 148 +2770 238 +2770 353 +2770 424 +2770 427 +2770 2338 +1146 2430 +1146 3180 +3098 308 +3098 480 +3098 1376 +3098 2199 +3098 2362 +3098 2995 +3098 3273 +3098 4355 +3098 4533 +3098 4534 +3358 132 +3358 1801 +3358 1900 +3358 2224 +3358 3039 +3358 3606 +3358 4533 +3358 4697 +3358 4698 +3358 4699 +5003 2916 +5003 2964 +5003 2981 +5003 3629 +5003 4247 +5003 5220 +5003 5507 +5003 5591 +5003 5592 +5003 5593 +2873 3 +2873 124 +2873 143 +2873 176 +2873 248 +2873 264 +2873 352 +2873 367 +2873 369 +2873 856 +3553 5 +3553 121 +3553 125 +3553 126 +3553 148 +3553 179 +3553 265 +3553 352 +3553 422 +3553 666 +2300 136 +2300 388 +2300 1456 +2300 1457 +2300 1677 +2300 1936 +2300 3995 +2300 3996 +2300 3997 +1267 251 +1267 459 +1267 1268 +1267 1269 +1267 1270 +1267 1271 +1267 1272 +1267 1273 +1267 1274 +3767 863 +3767 864 +3767 1239 +3767 1339 +3767 1711 +3767 2254 +3767 3299 +3767 4846 +3767 4920 +3767 4921 +4489 3813 +4489 5392 +4490 810 +4490 981 +4490 1199 +4490 1297 +4490 1342 +4490 1607 +4490 1608 +4490 1867 +4490 3617 +4490 5320 +3922 21 +3922 3144 +3922 3963 +3922 4022 +1365 1087 +1365 1361 +1365 1477 +1365 2082 +1365 3209 +1365 3210 +1365 3211 +1365 3212 +1365 3213 +2559 43 +2559 788 +2559 2069 +2559 4170 +2559 4171 +2569 79 +2569 164 +2569 243 +2569 296 +2569 455 +2569 1289 +2569 2641 +2569 2740 +2569 3735 +2569 4172 +1043 3146 +1043 4264 +2944 1240 +2944 1425 +2944 1731 +2944 4537 +2944 4538 +3142 124 +3142 129 +3142 177 +3142 248 +3142 249 +3142 266 +3142 667 +3142 717 +3142 856 +3142 1245 +2205 938 +2205 1608 +2205 1849 +2205 3109 +2205 4080 +2205 5310 +2205 5724 +2205 6000 +2205 6001 +887 1671 +887 1688 +887 1786 +887 1805 +887 2361 +887 2662 +887 2775 +887 2776 +887 2777 +887 2778 +4811 3003 +699 529 +699 693 +699 1027 +699 1653 +699 1702 +699 2289 +699 2546 +699 2611 +699 2612 +699 2613 +606 87 +606 820 +606 1040 +606 1097 +606 1439 +606 1644 +606 1730 +606 2555 +606 2556 +606 2557 +1701 612 +1701 1659 +1701 1805 +1701 1939 +1701 2188 +1701 3459 +1701 3460 +1701 3461 +1701 3462 +3371 265 +3371 385 +3371 4707 +3371 4708 +1028 251 +1028 813 +1028 815 +1028 982 +1028 1798 +1028 2733 +1028 2940 +1028 2941 +1028 2942 +1028 2943 +1199 3 +1199 121 +1199 123 +1199 125 +1199 127 +1199 128 +1199 238 +1199 264 +1199 390 +1199 426 +1459 554 +1459 910 +1459 1179 +1459 1275 +1459 1491 +1459 1511 +1459 2494 +1459 3310 +1459 3311 +1459 3312 +1700 23 +1700 436 +1700 451 +1700 2165 +1700 2324 +1700 3455 +1700 3456 +1700 3457 +1700 3458 +1703 78 +1703 889 +1703 1358 +1703 2423 +1703 2906 +1703 3468 +1703 3469 +1703 3470 +1703 3471 +1026 129 +1026 177 +1026 251 +1026 1246 +1026 2199 +1026 2366 +1026 2791 +1026 2937 +1026 2938 +1026 2939 +1139 83 +1139 229 +1139 645 +1139 2359 +1139 3009 +1139 3010 +1139 3011 +1139 3012 +1139 3013 +1139 3014 +3428 1235 +3428 1539 +3428 1776 +3428 1947 +3428 3136 +3428 4373 +3428 4675 +3428 4755 +3428 4756 +3428 4757 +3430 4758 +3431 2077 +3431 2411 +3431 4824 +3433 105 +3433 231 +3433 424 +3433 833 +3433 921 +3433 2911 +3433 3170 +3433 3497 +3433 4461 +3433 4472 +1025 99 +1025 584 +1025 689 +1025 902 +1025 2916 +1025 3191 +1025 3462 +1025 5106 +1025 5107 +1025 5108 +3613 944 +3613 2269 +3613 2621 +3613 3412 +3613 3904 +3613 4553 +3613 4856 +3613 4857 +4285 92 +4285 158 +4285 1645 +4285 1815 +4285 1929 +4285 3551 +4285 4007 +4285 4081 +4285 5183 +4285 5184 +4285 5185 +4285 5186 +4285 5187 +4285 5188 +4285 5189 +4285 5190 +4285 5191 +3178 1948 +3178 2119 +3178 3325 +3178 3457 +3178 4419 +3178 4572 +3178 4573 +3178 4574 +3178 4575 +3178 4576 +3179 282 +3179 303 +3179 728 +3179 822 +3179 1143 +3179 1505 +3179 2528 +3179 2885 +3179 3769 +3179 4075 +5729 586 +5729 898 +5729 2198 +5729 2227 +5729 2789 +5729 3275 +5729 4280 +5729 5756 +5729 5952 +5729 5953 +4295 96 +4295 346 +4295 509 +4295 1632 +4295 1942 +4295 2175 +4295 3292 +4295 4032 +4295 4286 +4295 4533 +4806 5451 +5315 63 +5315 2927 +5315 3346 +5315 4771 +5315 5161 +5315 5578 +5315 5769 +5315 5770 +5315 5771 +5315 5772 +1361 62 +1361 706 +1361 710 +1361 1814 +1361 2209 +1361 3237 +1361 3238 +1361 3239 +1361 3240 +1361 3241 +263 4 +263 126 +263 146 +263 147 +263 264 +263 265 +263 266 +263 267 +263 268 +263 269 +307 711 +307 883 +307 1018 +307 2260 +307 2261 +307 2262 +307 2263 +307 2264 +307 2265 +307 2266 +1704 9 +1704 121 +1704 126 +1704 149 +1704 176 +1704 352 +1704 423 +1704 424 +1704 427 +1704 667 +1707 1956 +1707 2246 +1707 2465 +1707 3477 +1707 3478 +1707 3479 +1707 3480 +1707 3481 +1707 3482 +1707 3483 +1709 248 +1709 587 +1709 1306 +1709 1476 +1709 1509 +1709 1591 +1709 2291 +1709 2429 +1709 3007 +1709 3459 +3988 712 +3988 2209 +3988 2391 +3988 2523 +3988 3119 +3988 3362 +3988 4838 +3988 5024 +3988 5025 +3989 2705 +3989 3908 +3989 4103 +3989 4677 +3989 5028 +652 175 +652 389 +652 424 +652 732 +652 1326 +652 2199 +652 2572 +652 2573 +652 2574 +652 2575 +4117 5086 +2471 57 +2471 272 +2471 274 +2471 834 +2471 1583 +2471 2102 +2471 2141 +2471 2635 +2471 4120 +76 77 +76 78 +76 79 +76 80 +76 81 +76 82 +76 83 +76 84 +76 85 +76 86 +1969 1541 +1969 1548 +1969 2878 +1969 3179 +1969 3519 +1969 3549 +1969 3754 +1969 3755 +1969 3756 +1969 3757 +1854 575 +1854 1290 +1854 1291 +1854 1731 +1854 2049 +1854 2394 +1854 3599 +1854 3602 +1854 3603 +1854 3604 +2536 2254 +4257 9 +4257 123 +4257 126 +4257 145 +4257 148 +4257 149 +4257 248 +4257 369 +4257 1245 +4257 1317 +4041 924 +4041 1199 +4041 1213 +4041 1608 +4041 1867 +4041 1868 +4041 1915 +4041 3336 +4041 4412 +4041 5052 +2350 4 +2350 5 +2350 17 +2350 121 +2350 122 +2350 126 +2350 180 +2350 247 +2350 250 +2350 424 +2420 503 +2420 614 +2420 1763 +2420 2298 +2420 3014 +2420 3071 +2420 3439 +2420 3860 +2420 4093 +2420 4094 +4070 633 +4070 989 +4070 1726 +4070 2207 +4070 2615 +4070 2641 +4070 5059 +4070 5063 +4070 5064 +4070 5065 +1059 3 +1059 8 +1059 121 +1059 125 +1059 128 +1059 174 +1059 179 +1059 247 +1059 424 +1059 717 +1086 152 +1086 219 +1086 424 +1086 1457 +1086 1824 +1086 2124 +1086 2984 +1086 2985 +1086 2986 +3850 125 +3850 129 +3850 146 +3850 249 +3850 251 +4923 5428 +4098 762 +4098 2593 +4098 3956 +4098 4118 +4098 4871 +1055 257 +1055 1347 +1055 2207 +1055 2411 +1055 2802 +1055 2968 +1055 2969 +1055 2970 +1055 2971 +169 818 +169 872 +169 1264 +169 1539 +169 2116 +169 2117 +169 2118 +169 2119 +169 2120 +169 2121 +2822 3 +2822 4 +2822 7 +2822 144 +2822 183 +2822 264 +2822 265 +2822 266 +2822 423 +2822 667 +3360 418 +3363 990 +3363 2444 +3363 2689 +3363 3293 +3363 4221 +3363 4700 +3363 4701 +3363 4702 +3363 4703 +3363 4704 +1168 1909 +1168 1912 +1168 2574 +1168 2791 +1168 2797 +1168 3045 +1168 3046 +1168 3047 +1168 3048 +1168 3049 +241 2010 +241 2186 +241 2187 +241 2188 +2821 73 +2821 176 +2821 353 +2821 354 +2821 367 +2821 667 +2821 823 +2821 1091 +2821 1267 +2821 4320 +2961 345 +2961 415 +2961 937 +2961 1001 +2961 2377 +2961 3242 +2961 3906 +2961 4192 +2961 4433 +2961 4434 +5763 2583 +5763 3359 +5763 3797 +5763 3992 +5763 5118 +5763 5719 +5763 5971 +5763 5972 +2241 3 +2241 163 +2241 1056 +2241 1362 +2241 1539 +2241 2097 +2241 2579 +2241 3946 +2241 3947 +2241 3948 +1424 200 +1424 621 +1424 2261 +1424 2858 +1424 3282 +1424 3283 +1424 3284 +1424 3285 +1424 3286 +1424 3287 +5423 285 +5423 582 +5423 707 +5423 1044 +5423 3202 +5423 4368 +5423 4828 +5423 5100 +5423 5442 +5423 5685 +2052 7 +2052 143 +2052 145 +2052 367 +2052 390 +2052 558 +2052 856 +2052 1040 +2052 1245 +2055 31 +2055 489 +2055 2065 +2055 3290 +2055 3828 +2055 3829 +2055 3830 +2055 3831 +2055 3832 +2055 3833 +1137 83 +1137 2086 +1137 2657 +1137 2966 +1137 3003 +1137 3004 +1137 3005 +1137 3006 +1137 3007 +1137 3008 +5568 894 +5568 1420 +5568 1575 +5568 4368 +5568 4804 +1318 756 +1318 1272 +1318 1273 +1318 1541 +1318 1955 +1318 2758 +1318 3159 +1318 3160 +1318 3161 +1318 3162 +1974 694 +1974 1590 +1974 2368 +1974 3050 +1974 3530 +1974 3744 +1974 3745 +1974 3746 +1974 3747 +1974 3748 +5063 574 +5063 2006 +5063 2375 +5063 2704 +5063 3900 +5063 4114 +5063 5083 +5063 5301 +5063 5475 +5063 5619 +5881 6039 +4194 180 +4194 870 +4194 2432 +4194 3328 +4194 4589 +4196 127 +4196 248 +4196 423 +4196 559 +4196 667 +4196 717 +4196 856 +4196 1041 +4196 4638 +4196 5122 +4198 345 +4198 1318 +4198 1424 +4198 1814 +4198 3033 +4198 3205 +4198 4035 +4198 4960 +4198 5123 +1666 325 +1666 633 +1666 1339 +1666 2275 +1666 3228 +1666 3385 +1666 4109 +1666 4499 +1666 4803 +3535 32 +381 30 +381 279 +381 382 +381 383 +381 384 +381 385 +381 386 +381 387 +381 388 +381 389 +3844 14 +3844 50 +3844 102 +3844 199 +3844 814 +3844 1749 +3844 2344 +3844 2486 +3844 2563 +3844 4958 +656 514 +656 568 +656 657 +656 658 +656 659 +656 660 +656 661 +656 662 +656 663 +656 664 +1546 1547 +1546 1548 +1546 1549 +1546 1550 +1546 1551 +1546 1552 +1546 1553 +1546 1554 +1546 1555 +1546 1556 +5074 311 +5074 1362 +5074 1539 +5074 2087 +5074 2204 +5074 2354 +5074 2579 +5074 3205 +5074 5546 +5075 462 +5075 1454 +5075 1587 +5075 1846 +5075 1903 +5075 2511 +5075 3570 +5075 3586 +5075 5626 +5075 5627 +5200 605 +5200 1714 +5200 2017 +5200 3142 +5200 3402 +5200 4176 +5200 5710 +5200 5711 +5200 5712 +5200 5713 +5201 127 +5201 129 +5201 146 +5201 176 +5201 238 +5201 264 +5201 352 +5201 717 +5201 1245 +5201 2338 +1367 3218 +3676 102 +3676 327 +3676 551 +3676 707 +3676 825 +3676 979 +3676 1010 +3676 1115 +3676 3423 +3676 4295 +1442 575 +3117 308 +3117 860 +3117 1376 +3117 1457 +3117 1767 +3117 2305 +3117 2419 +3117 2712 +3117 2898 +3117 4545 +4279 5 +4279 121 +4279 125 +4279 129 +4279 148 +4279 174 +4279 176 +4279 369 +4279 424 +4279 717 +4280 464 +4280 759 +4280 828 +4280 2709 +4280 2948 +4280 3081 +4280 3859 +4280 4133 +4280 4584 +4280 5181 +298 7 +298 8 +298 121 +298 144 +298 252 +298 266 +298 352 +298 424 +298 666 +299 175 +299 378 +299 443 +299 774 +299 1573 +299 1704 +299 2035 +299 2250 +299 2251 +299 2252 +5291 5660 +5291 5661 +5291 5662 +5291 5663 +5291 5664 +5291 5665 +5291 5666 +5291 5667 +5291 5668 +5291 5669 +5928 4 +5928 127 +5928 143 +5928 146 +5928 175 +5928 264 +5928 390 +5928 427 +5928 558 +80 2014 +343 122 +343 127 +343 176 +343 249 +343 251 +343 558 +343 666 +343 667 +343 754 +343 1245 +346 238 +346 343 +346 1018 +346 2301 +346 2302 +346 2303 +346 2304 +346 2305 +346 2306 +346 2307 +571 721 +571 765 +571 804 +571 1913 +571 2358 +571 2474 +571 2521 +571 2522 +571 2523 +571 2524 +573 228 +573 2520 +574 31 +574 125 +574 175 +574 179 +574 180 +574 250 +574 266 +574 390 +574 424 +536 1132 +2948 355 +2948 607 +2948 823 +2948 1466 +2948 3855 +2948 4424 +2948 4425 +2948 4426 +2948 4427 +2948 4428 +2952 1374 +2952 1507 +2952 2035 +2952 2916 +2952 2953 +2952 3017 +2952 3134 +2952 3629 +2952 4422 +2952 4423 +3471 714 +3471 2425 +3471 2517 +3471 3386 +3471 4854 +4292 103 +4292 1061 +4292 1425 +4292 1827 +4292 1923 +4292 2480 +4292 3021 +4292 3055 +4292 4075 +4292 5192 +137 1728 +557 124 +557 127 +557 147 +557 248 +557 251 +557 252 +557 390 +557 423 +557 558 +557 559 +1039 1176 +1039 1651 +1039 1956 +1039 2271 +1039 2787 +1039 2955 +1039 2956 +1039 2957 +1039 2958 +3200 924 +3200 1517 +3200 2773 +3200 2916 +3200 2943 +3200 3516 +3200 4289 +3200 4478 +3200 4585 +3200 4586 +3192 2 +3192 8 +3192 248 +3192 390 +3192 554 +3192 697 +3192 946 +3192 1317 +3192 2001 +3192 2077 +3193 1983 +4183 463 +4183 1235 +4183 2500 +4183 2823 +4183 4321 +4183 5109 +4183 5110 +4183 5111 +4183 5112 +4183 5113 +101 143 +101 147 +101 249 +101 251 +101 264 +101 369 +101 422 +101 559 +101 718 +101 2018 +3998 255 +3998 1332 +3998 1730 +3998 1936 +3998 3213 +3998 3625 +3998 4704 +3998 5039 +3998 5040 +3998 5041 +4005 1228 +4005 1537 +4005 1587 +4005 2291 +4005 2547 +4005 2563 +4005 3846 +4005 5048 +4005 5049 +4005 5050 +750 385 +750 817 +750 1417 +750 2127 +750 2294 +750 2397 +750 2674 +750 2675 +750 2676 +750 2677 +2950 4435 +5163 1002 +5163 3595 +5163 3822 +5163 4607 +5163 4628 +5163 4734 +5163 4880 +5163 5036 +5163 5272 +5163 5671 +5165 5407 +979 35 +979 119 +979 612 +979 762 +979 866 +979 1023 +979 1318 +979 1319 +979 1320 +979 1321 +2892 763 +2892 2052 +2892 2628 +2892 2773 +2892 4219 +2892 4372 +2892 4373 +2892 4374 +2892 4375 +2892 4376 +4319 720 +4319 866 +4319 1425 +4319 1719 +4319 2546 +4319 4251 +4319 5210 +4319 5211 +4319 5212 +4319 5213 +4016 9 +4016 124 +4016 125 +4016 144 +4016 145 +4016 148 +4016 247 +4016 352 +4016 353 +4016 424 +3257 235 +3257 364 +3257 422 +3257 962 +3257 1565 +3257 2699 +3257 2965 +3257 3605 +3257 4380 +3475 18 +3475 498 +3475 1476 +3475 1554 +3475 2383 +3475 3219 +3475 3717 +3475 4778 +3475 4779 +4021 156 +4021 476 +4021 802 +4021 921 +4021 1336 +4021 2347 +4021 2806 +4021 3053 +4021 3343 +4021 3866 +4026 1330 +4026 5124 +4026 5125 +4032 144 +4032 147 +4032 149 +4032 177 +4032 266 +4032 353 +4032 424 +4032 558 +4032 856 +4032 2338 +4033 21 +4033 385 +4033 1084 +4033 1137 +4033 1167 +4033 1342 +4033 2690 +4033 3829 +4033 4876 +4033 4915 +1711 2707 +1564 3 +1564 127 +1564 144 +1564 146 +1564 149 +1564 176 +1564 177 +1564 238 +1564 247 +1564 367 +1569 65 +1569 373 +1569 1153 +1569 1570 +1569 1571 +1569 1572 +1569 1573 +1569 1574 +1569 1575 +1569 1576 +1637 363 +1637 779 +1637 998 +1637 1503 +1637 1538 +1637 1976 +1637 2299 +1637 3386 +1637 3387 +1637 3388 +4635 443 +4635 664 +4635 828 +4635 942 +4635 2772 +4635 4066 +4635 4333 +4635 4439 +4635 5396 +3266 651 +3266 1935 +3266 2032 +3266 2724 +3266 2948 +3266 3066 +3266 4638 +3266 4639 +3295 925 +3295 1387 +3295 1451 +3295 1587 +3295 2322 +3295 2430 +3295 2790 +3295 3586 +3295 4288 +3295 4663 +3297 921 +39 614 +39 1378 +39 1922 +39 1923 +39 1924 +39 1925 +39 1926 +39 1927 +39 1928 +39 1929 +3341 18 +3341 551 +3341 952 +3341 1388 +3341 3421 +3341 3852 +3341 4043 +3341 4685 +3341 4686 +3341 4687 +4164 8 +4164 121 +4164 127 +4164 146 +4164 177 +4164 353 +4164 369 +4164 422 +4164 427 +4164 717 +1485 8 +1485 9 +1485 121 +1485 125 +1485 128 +1485 129 +1485 144 +1485 352 +1485 427 +1485 1246 +5807 648 +5807 1845 +5807 2264 +5807 3205 +5807 4170 +5807 5403 +5807 5992 +5807 5997 +5807 5998 +5807 5999 +1518 1519 +2253 113 +2253 222 +2253 382 +2253 411 +2253 1157 +2253 2169 +2253 2552 +2253 3949 +2253 3950 +3710 3335 +3710 3708 +3710 4959 +4967 1303 +4967 1989 +4967 2769 +4967 3245 +4967 4330 +4967 4337 +4967 5074 +4967 5507 +4967 5587 +433 20 +433 1370 +433 1565 +433 1824 +433 2433 +3881 528 +3881 756 +3881 874 +3881 3023 +3881 3205 +3881 3271 +3881 3488 +3881 4841 +3881 4975 +3881 4976 +2847 244 +2847 498 +2847 510 +2847 527 +2847 747 +2847 1817 +2847 2535 +2847 3912 +2847 4335 +2847 4336 +3863 804 +3863 2399 +3863 3489 +3863 3543 +3863 3813 +3863 4333 +3863 4395 +3863 5229 +3863 5264 +3863 5337 +3883 8 +3883 123 +3883 146 +3883 247 +3883 248 +3883 249 +3883 266 +3883 369 +3883 427 +3883 667 +3885 2051 +3885 2164 +3885 2708 +3885 3362 +3885 3587 +2546 2 +2546 3 +2546 8 +2546 147 +2546 247 +2546 351 +2546 1317 +2546 2064 +2546 4161 +2546 4162 +736 443 +736 737 +736 738 +736 739 +736 740 +736 741 +736 742 +736 743 +736 744 +736 745 +348 751 +348 930 +348 1322 +348 1364 +348 1366 +348 2004 +348 2292 +348 2293 +348 2294 +348 2295 +1033 281 +1033 554 +1033 659 +1033 1034 +1033 1035 +1033 1036 +1033 1037 +1033 1038 +1033 1039 +1033 1040 +5175 804 +5175 1770 +5175 2004 +5175 2214 +5175 3109 +5175 3596 +5175 3846 +5175 4912 +5175 5633 +5175 5638 +449 4 +449 126 +449 129 +449 145 +449 147 +449 238 +449 266 +449 368 +449 1246 +3010 31 +3010 709 +3010 845 +3010 1544 +3010 3056 +3010 4425 +3010 4449 +3010 4450 +3010 4451 +3010 4452 +3817 909 +3818 953 +3818 1021 +3818 1392 +3818 1798 +3818 2035 +3818 2285 +3818 4103 +3818 4936 +3818 4937 +3818 4938 +3819 432 +3819 514 +3819 730 +3819 1441 +3819 1538 +3819 2785 +3819 3249 +3819 3916 +3819 4484 +3819 4520 +3820 3 +3820 8 +3820 122 +3820 127 +3820 129 +3820 143 +3820 146 +3820 147 +3820 369 +3820 1245 +167 8 +167 17 +167 121 +167 129 +167 175 +167 238 +167 266 +167 353 +167 424 +167 2018 +1885 5 +1885 143 +1885 144 +1885 147 +1885 174 +1885 252 +1885 264 +1885 390 +1885 423 +1885 558 +193 2062 +193 2222 +193 2388 +193 2389 +193 2390 +193 2391 +1243 138 +1243 982 +1243 988 +1243 1787 +1243 2465 +1243 2663 +1243 3106 +1243 3107 +1243 3108 +1297 289 +1297 435 +1297 753 +1297 901 +1297 1199 +1297 1504 +1297 1763 +1297 1764 +1297 1765 +1297 1766 +2093 427 +2093 484 +2093 958 +2093 1426 +2093 1529 +2093 1688 +2093 2244 +2093 3046 +2093 3769 +2093 3863 +2866 364 +2866 619 +2866 706 +2866 1620 +2866 1787 +2866 2089 +2866 3017 +2866 3156 +2866 3930 +2866 4368 +2870 23 +2870 1431 +2870 1754 +2870 2344 +2870 2778 +2870 4360 +2870 4361 +2870 4362 +2870 4363 +2870 4364 +4057 459 +4057 1034 +4057 1054 +4057 1374 +4057 2833 +4057 5066 +4057 5067 +4057 5068 +4057 5069 +4058 550 +4058 628 +4058 1750 +4058 2649 +4058 5056 +4058 5057 +4060 1571 +4060 1918 +4060 2543 +4060 2571 +4060 2745 +4060 2935 +4060 3153 +4060 4172 +4060 4492 +4060 4919 +4735 606 +4735 2249 +4735 3993 +4735 5473 +4735 5474 +4735 5475 +4738 77 +4738 586 +4738 672 +4738 1980 +4738 2147 +4738 3138 +4738 5016 +4738 5303 +4738 5451 +4738 5452 +321 32 +321 322 +321 323 +321 324 +321 325 +321 326 +321 327 +321 328 +321 329 +321 330 +3115 262 +3115 1100 +3115 1415 +3115 1845 +3115 1889 +3115 2113 +3115 3699 +3115 4539 +3115 4540 +3115 4541 +2529 11 +2529 1904 +2529 2061 +2529 3080 +2529 3487 +2529 3849 +2529 4263 +2529 4980 +2529 5159 +2529 5600 +4330 31 +4330 126 +4330 146 +4330 148 +4330 174 +4330 250 +4330 559 +4330 856 +4330 1245 +4330 3779 +904 492 +904 749 +904 1790 +904 2737 +904 2791 +904 2792 +904 2793 +904 2794 +904 2795 +904 2796 +1559 144 +1559 145 +1559 147 +1559 251 +1559 252 +1559 264 +1559 266 +1559 368 +1559 667 +4277 227 +4277 1698 +4277 1787 +4277 2115 +4277 3058 +4277 4026 +4277 4275 +4277 5179 +4277 5180 +5129 848 +5129 1150 +5129 1956 +5129 2094 +5129 3283 +5129 3781 +5129 4256 +5129 4874 +5129 5293 +5129 5644 +989 8 +989 49 +989 53 +989 108 +989 751 +989 756 +989 986 +989 990 +989 991 +989 1047 +989 1383 +989 1424 +989 2054 +989 2375 +989 2399 +989 2525 +989 2606 +989 2890 +989 2891 +989 2892 +989 2893 +989 2894 +989 2895 +989 2896 +989 2897 +5131 823 +5131 1787 +5131 2288 +5131 2566 +5131 3109 +5131 3797 +5131 4248 +5131 4895 +5131 5645 +5131 5646 +2143 494 +2143 1068 +2143 1402 +2143 1545 +2143 2165 +2143 2166 +2143 2215 +2143 2646 +2143 3889 +2143 3890 +2695 3 +2695 124 +2695 127 +2695 264 +2695 353 +2695 718 +2695 1245 +2695 1670 +2695 1878 +2695 1989 +3997 28 +3997 714 +3997 1861 +3997 2425 +3997 3343 +3997 3386 +3997 3471 +3997 3702 +3997 4189 +3997 4854 +4669 141 +4669 289 +4669 2227 +4669 2353 +4669 2625 +4669 3162 +4669 3562 +4669 5414 +4669 5415 +4669 5416 +341 370 +341 862 +341 1591 +341 1805 +341 1891 +341 2177 +341 2288 +341 2289 +341 2290 +341 2291 +764 765 +764 766 +764 767 +764 768 +764 769 +764 770 +764 771 +764 772 +764 773 +764 774 +909 124 +909 127 +909 175 +909 180 +909 251 +909 367 +909 368 +909 390 +909 718 +1717 257 +1717 541 +1717 852 +1717 1441 +1717 1702 +1717 2356 +1717 2553 +1717 3484 +1717 3485 +1717 3486 +1805 871 +1805 1806 +1805 1807 +1805 1808 +1805 1809 +1805 1810 +1805 1811 +1805 1812 +1805 1813 +1805 1814 +105 363 +105 820 +105 1041 +105 1240 +105 2019 +105 2020 +105 2021 +105 2022 +105 2023 +105 2024 +5497 41 +5497 143 +5497 266 +5497 491 +5497 911 +5497 2202 +5497 3599 +5497 4652 +5497 5845 +5497 5846 +2949 163 +2949 264 +2949 667 +2949 708 +2949 1903 +2949 1926 +2949 2035 +2949 3365 +2949 4402 +2949 4421 +4639 472 +4639 576 +4639 2060 +4639 4158 +4639 5406 +5106 1027 +5106 1940 +5106 2005 +5106 2429 +5106 2497 +5106 3238 +5106 4934 +5106 5244 +5106 5639 +5106 5640 +5552 353 +5552 785 +5552 849 +5552 918 +5552 1103 +5552 3618 +5552 4812 +5552 5040 +5552 5405 +5552 5873 +3587 94 +3587 352 +3587 2628 +3587 3109 +3587 3469 +3587 4141 +3587 4170 +3587 4455 +3587 4784 +3587 4844 +4577 8 +4577 282 +4577 822 +4577 1143 +4577 1780 +4577 2016 +4577 3081 +4577 5128 +4577 5365 +6152 371 +6152 762 +6152 1330 +6152 1797 +6152 2531 +6152 3305 +6152 3503 +6152 3900 +6152 4981 +6152 6171 +3550 748 +3550 813 +3550 1587 +3550 1766 +3550 2198 +3550 2744 +3550 2859 +3550 3080 +3550 4280 +3550 4815 +3626 102 +3626 1262 +3626 1647 +3626 3615 +3626 4412 +3524 330 +3524 945 +3524 1047 +3524 1797 +3524 2397 +3524 2705 +3524 3017 +3524 3235 +3524 3583 +3524 4802 +4431 296 +4431 1434 +4431 2427 +4431 2643 +4431 5276 +5277 25 +5277 228 +5277 1227 +5277 3096 +5277 5758 +1922 873 +1922 1359 +1922 1526 +1922 2941 +1922 3612 +1922 3688 +1922 3689 +1922 3690 +1922 3691 +1922 3692 +5356 685 +5356 2002 +5356 2036 +5356 3407 +5356 3455 +5357 1516 +5357 5474 +5357 5816 +469 41 +469 102 +469 470 +469 471 +469 472 +469 473 +469 474 +469 475 +469 476 +469 477 +553 2 +553 4 +553 175 +553 251 +553 554 +553 695 +553 696 +553 697 +553 946 +553 2077 +1163 632 +1163 1882 +1163 2593 +1163 3617 +1163 4494 +1163 4495 +1163 4496 +1163 4497 +1163 4498 +1163 4499 +3056 290 +3056 520 +3056 1493 +3056 2150 +3056 2334 +3056 3833 +3056 4481 +3056 4482 +3056 4483 +1749 863 +1749 1094 +1749 1555 +1749 2722 +1749 2743 +1749 2996 +1749 3506 +1749 3507 +1749 3508 +1749 3509 +3081 9 +3081 549 +3081 1480 +3081 2089 +3081 2385 +3081 2719 +3081 3039 +3081 4278 +3081 4503 +3081 4504 +3566 828 +3566 1289 +3566 1491 +3566 2826 +3566 3928 +3566 4104 +3566 4655 +3566 4751 +3566 4825 +3566 4826 +2489 2661 +4010 110 +4010 2795 +4010 3003 +4010 3404 +4010 4533 +4010 4904 +4010 5045 +4010 5046 +4010 5047 +4619 381 +4619 778 +4619 1592 +4619 1900 +4619 2166 +4619 2234 +4619 2646 +4619 2875 +4619 3327 +4619 4812 +902 1272 +902 2409 +902 2626 +902 2663 +902 2779 +902 2780 +902 2781 +902 2782 +902 2783 +902 2784 +2942 21 +2942 132 +2942 924 +2942 1335 +2942 1417 +2942 1842 +2942 1890 +2942 4415 +2942 4416 +2942 4417 +3106 2543 +4847 350 +4847 1040 +4847 1054 +4847 1512 +4847 2752 +4847 3417 +4847 4080 +4847 4251 +4847 4551 +4847 5526 +579 231 +579 893 +579 1476 +579 1629 +579 1682 +579 2529 +579 2530 +579 2531 +579 2532 +579 2533 +2463 5 +2463 933 +2463 2592 +2463 2797 +2463 2798 +2463 3105 +2463 3927 +2463 4084 +2463 4114 +2463 4115 +620 396 +620 409 +620 469 +620 534 +620 1583 +620 2272 +620 2385 +620 2552 +620 2553 +620 2554 +1799 554 +1799 655 +1799 661 +1799 853 +1799 1026 +1799 1800 +1799 1801 +1799 1802 +1799 1803 +1799 1804 +3526 3 +3526 8 +3526 121 +3526 122 +3526 123 +3526 129 +3526 367 +3526 422 +3526 424 +3526 667 +4583 1068 +4583 1227 +4583 2036 +4583 3087 +4583 4194 +4583 4793 +4583 5281 +4583 5285 +4583 5382 +4583 5383 +5149 802 +5149 2125 +5149 2499 +5149 5656 +5149 5657 +836 837 +836 838 +836 839 +836 840 +836 841 +836 842 +836 843 +836 844 +836 845 +2461 559 +2461 1005 +2461 1081 +2461 1425 +2461 1549 +2461 2791 +2461 2796 +2461 4044 +2461 4112 +2461 4113 +2660 1840 +4244 904 +4244 918 +4244 986 +4244 1157 +4244 1547 +4244 3006 +4244 4628 +4244 4966 +4244 5157 +4244 5158 +3737 660 +3856 4 +3856 7 +3856 144 +3856 149 +3856 238 +3856 247 +3856 353 +3856 717 +3856 1317 +3856 2018 +4686 315 +4686 337 +4686 353 +4686 629 +4686 1491 +4686 3571 +4686 4915 +4686 5300 +4686 5421 +4686 5422 +1301 866 +1301 1305 +1301 1345 +1301 1346 +1301 1347 +1301 1348 +1301 1349 +1301 1350 +1301 1351 +1305 67 +1305 124 +1305 176 +1305 339 +1305 427 +1305 1669 +1305 1749 +1305 3150 +1305 3151 +1305 3152 +2504 894 +2504 1248 +2504 2653 +2504 3555 +2504 3775 +2504 4131 +2504 4132 +2504 4133 +2504 4134 +2504 4135 +4864 141 +4864 279 +4864 1143 +4864 1443 +4864 2961 +4864 3452 +4864 5533 +4864 5534 +4864 5535 +4864 5536 +881 260 +881 667 +881 837 +881 1511 +881 2579 +881 2593 +881 2594 +881 2595 +881 2771 +881 2772 +1259 5 +1259 126 +1259 148 +1259 149 +1259 174 +1259 176 +1259 249 +1259 251 +1259 265 +1259 352 +3982 108 +3982 503 +3982 534 +3982 1511 +3982 1805 +3982 2090 +3982 3461 +3982 4658 +3982 5022 +4107 652 +4107 816 +4107 1097 +4107 3714 +4107 3904 +4107 4012 +4107 4122 +4107 5078 +4107 5079 +4107 5080 +4144 322 +4144 462 +4144 1447 +4144 1481 +4144 1615 +4144 4214 +4144 4307 +4144 4955 +4144 5097 +4144 5098 +4146 621 +4146 2347 +4146 2537 +4146 3372 +4146 3485 +4146 3498 +4146 3608 +4146 4397 +4146 5103 +4658 1973 +1557 367 +1557 562 +1557 931 +1557 943 +1557 1122 +1557 1177 +1557 1558 +1557 1559 +1557 1560 +1557 1561 +1992 126 +1992 128 +1992 144 +1992 145 +1992 147 +1992 424 +1992 2018 +1992 2614 +1992 3466 +1992 3764 +3350 648 +3350 1454 +3350 1812 +3350 2177 +3350 2825 +3350 3363 +3350 4657 +3350 4690 +3350 4691 +3350 4692 +4434 352 +4434 777 +4434 926 +4434 2086 +4434 3932 +4434 3983 +4434 4757 +4434 4980 +4434 5273 +4434 5274 +4693 416 +4693 705 +4693 1651 +4693 1968 +4693 2399 +4693 2848 +4693 3733 +4693 4640 +4693 5426 +4693 5427 +350 329 +350 378 +350 432 +350 558 +350 1734 +350 2264 +350 2328 +350 2329 +350 2330 +350 2331 +4890 223 +4890 1029 +4890 1524 +4890 1695 +4890 1956 +4890 2911 +4890 3489 +4890 3590 +4890 3695 +4890 5553 +1533 85 +1533 279 +1533 529 +1533 1255 +1533 1401 +1533 1822 +1533 1920 +1533 2332 +1533 2884 +1533 2891 +1536 1050 +1537 5 +1537 9 +1537 128 +1537 145 +1537 148 +1537 176 +1537 179 +1537 248 +1537 352 +1537 424 +30 3 +30 5 +30 8 +30 121 +30 124 +30 126 +30 145 +30 174 +30 249 +30 424 +2681 222 +2681 325 +2681 1022 +2681 1064 +2681 1109 +2681 2885 +2681 3217 +2681 3252 +2681 3572 +2681 3848 +3848 3212 +267 414 +267 813 +267 1050 +267 1749 +267 2229 +267 2230 +267 2231 +267 2232 +267 2233 +267 2234 +3846 491 +3846 4241 +3846 4625 +3846 4893 +3846 5155 +3846 5229 +3846 5267 +3846 5937 +3846 5938 +3846 5939 +1466 132 +1466 214 +1466 451 +1466 1162 +1466 2013 +1466 2524 +1466 3313 +1466 3314 +1466 3315 +1466 3316 +386 389 +386 609 +386 1077 +386 1451 +386 2035 +386 2360 +386 2361 +386 2362 +386 2363 +386 2364 +3176 3 +3176 8 +3176 127 +3176 129 +3176 146 +3176 176 +3176 246 +3176 426 +3176 1245 +3176 2098 +3599 693 +3599 2916 +3599 3682 +3599 4852 +3599 4853 +1691 3669 +2231 132 +2231 686 +2231 970 +2231 1598 +2231 2802 +2231 3938 +2231 3939 +2231 3940 +2231 3941 +2231 3942 +5417 892 +5417 1107 +5417 1330 +5417 1617 +5417 1757 +5417 2112 +5417 3926 +5417 5415 +5417 5812 +5417 5813 +5418 7 +5418 124 +5418 144 +5418 146 +5418 148 +5418 266 +5418 698 +5418 754 +5418 1297 +5418 2803 +14 809 +195 4 +195 124 +195 143 +195 176 +195 368 +195 422 +195 558 +195 736 +195 1245 +923 451 +923 494 +923 685 +923 922 +923 924 +923 925 +923 926 +923 927 +923 928 +1881 263 +1881 1085 +1881 1456 +1881 2397 +1881 3392 +1881 3479 +1881 3632 +1881 3633 +1881 3634 +1881 3635 +2693 82 +2693 1536 +2693 1734 +2693 2039 +2693 2433 +2693 2820 +2693 4262 +2693 4263 +2693 4264 +2693 4265 +5029 146 +5029 177 +5029 353 +5029 1047 +5029 1135 +5029 2130 +5029 2338 +5029 3503 +5029 4453 +5029 5617 +5321 255 +5321 1115 +5321 1845 +5321 1928 +5321 3933 +5321 4074 +5321 4129 +5321 5510 +5321 5775 +5321 5776 +4761 159 +4761 813 +4761 2494 +4761 3306 +4761 4759 +4762 3497 +4766 21 +4766 892 +4766 940 +4766 1116 +4766 1658 +4766 1872 +4766 4754 +4766 5348 +4766 5469 +4766 5470 +3034 127 +3034 289 +3034 1223 +3034 3035 +3034 3795 +3034 4292 +3034 4388 +3034 4466 +3034 4467 +3547 711 +4043 744 +4043 749 +4043 946 +4043 2040 +4043 2286 +4043 2912 +4043 4432 +4043 4675 +4043 5054 +4043 5055 +5083 211 +5083 581 +5083 599 +5083 605 +5083 1486 +5083 1855 +5083 2500 +5083 3251 +5083 3402 +5083 3982 +1721 211 +1721 706 +1721 1104 +1721 2127 +1721 2373 +1721 2430 +1721 2720 +1721 3006 +1721 3476 +1982 2086 +1230 586 +1230 862 +1230 1061 +1230 1900 +1230 1923 +1230 2723 +1230 3670 +1230 4540 +3796 110 +3796 563 +3796 884 +3796 1313 +3796 2170 +3796 2216 +3796 3269 +3796 4930 +4236 1505 +4236 1645 +4236 5105 +4236 5155 +4236 5156 +716 124 +716 128 +716 174 +716 176 +716 177 +716 179 +716 353 +716 390 +716 717 +716 718 +4388 213 +4388 265 +4388 369 +4388 427 +4388 554 +4388 695 +4388 754 +4388 2914 +4388 3028 +4388 5247 +4399 5 +4399 125 +4399 127 +4399 179 +4399 248 +4399 250 +4399 559 +4399 667 +4399 717 +4399 2018 +2670 4 +2670 121 +2670 145 +2670 148 +2670 174 +2670 252 +2670 265 +2670 422 +2670 559 +2670 666 +4334 57 +4334 3756 +4334 4036 +4334 4242 +4334 4397 +4334 4684 +4334 4814 +4334 5116 +4334 5220 +4334 5221 +4402 190 +4402 3895 +4402 5220 +4402 5345 +4403 202 +4403 280 +4403 1021 +4403 2251 +4403 2296 +4403 4117 +4403 4382 +4403 5263 +4403 5264 +4304 5157 +4694 1047 +4694 2449 +4694 3293 +4694 3929 +4694 4164 +4694 5430 +4694 5431 +4694 5432 +4694 5433 +5021 5604 +2195 244 +2195 1087 +2195 2697 +2195 2981 +2195 3205 +2195 3319 +2195 3916 +2195 3917 +2195 3918 +60 1937 +60 1938 +60 1939 +60 1940 +60 1941 +60 1942 +60 1943 +60 1944 +60 1945 +3693 3 +3693 123 +3693 126 +3693 144 +3693 149 +3693 179 +3693 251 +3693 367 +3693 424 +3693 717 +2492 64 +2492 813 +2492 852 +2492 1608 +2492 1868 +2492 3196 +2492 3421 +2492 3617 +2492 4040 +4781 679 +4781 963 +4781 1359 +4781 5478 +4781 5479 +4781 5480 +4781 5481 +4781 5482 +4781 5483 +4781 5484 +986 145 +986 146 +986 251 +986 264 +986 367 +986 559 +986 666 +986 667 +986 1245 +988 138 +988 163 +988 870 +988 1610 +988 2474 +988 2630 +988 2767 +988 2887 +988 2888 +988 2889 +990 127 +990 148 +990 183 +990 249 +990 252 +990 264 +990 265 +990 266 +990 368 +990 666 +211 494 +211 621 +211 1358 +211 1412 +211 2161 +211 2162 +211 2163 +211 2164 +211 2165 +211 2166 +73 717 +73 1022 +73 1969 +73 1970 +73 1971 +73 1972 +73 1973 +73 1974 +73 1975 +73 1976 +3495 3 +3495 145 +3495 174 +3495 176 +3495 177 +3495 249 +3495 251 +3495 353 +3495 1317 +3495 3995 +4908 424 +4908 5314 +4908 5563 +4908 5564 +4908 5565 +6138 129 +6138 143 +6138 146 +6138 177 +6138 249 +6138 367 +6138 369 +6138 423 +6138 424 +6138 2338 +340 341 +340 342 +340 343 +340 344 +340 345 +340 346 +340 347 +340 348 +340 349 +340 350 +3380 248 +3380 487 +3380 910 +3380 1801 +3380 2002 +3380 3350 +3380 4716 +3380 4717 +3380 4718 +825 826 +825 827 +825 828 +825 829 +825 830 +825 831 +825 832 +825 833 +825 834 +825 835 +1733 73 +1733 407 +1733 830 +1733 2350 +1733 3491 +1733 3492 +1733 3493 +1733 3494 +1733 3495 +1733 3496 +2356 38 +2356 215 +2356 962 +2356 1522 +2356 2007 +2356 4035 +2356 4036 +2356 4037 +2356 4038 +1354 163 +1354 1642 +1354 1741 +1354 2134 +1354 2329 +1354 2683 +1354 2880 +1354 3202 +1354 3203 +3326 418 +3326 1021 +3326 1030 +3326 1240 +3326 3478 +3326 3499 +3326 4430 +3326 4583 +3326 4673 +3326 4674 +3247 321 +3247 452 +3247 453 +3247 531 +3247 736 +3247 1947 +3247 2035 +3247 2689 +3247 3095 +3247 4625 +4343 169 +4343 1050 +4343 1317 +4343 1437 +4343 3223 +4343 3362 +4343 4731 +4343 5200 +4343 5231 +4650 605 +4650 835 +4650 1430 +4650 2970 +4650 3369 +4650 5407 +4650 5408 +4650 5409 +4650 5410 +280 318 +280 552 +280 790 +280 967 +280 1202 +280 1259 +280 1412 +280 1620 +280 1933 +280 2235 +283 552 +283 632 +283 779 +283 838 +283 1321 +283 1371 +283 1571 +283 1891 +283 1892 +283 2236 +284 32 +284 503 +284 1699 +284 1789 +284 2237 +284 2238 +284 2239 +284 2240 +284 2241 +284 2242 +3612 4855 +4881 5672 +4643 538 +4643 1575 +4643 1731 +4643 2214 +4643 2784 +4643 3566 +4643 4336 +4643 5342 +4643 5343 +4986 200 +4986 1038 +4986 1044 +4986 2036 +4986 2425 +4986 3566 +4986 3794 +4986 4262 +4986 5588 +4986 5589 +4441 76 +4441 1087 +4441 1726 +4441 2583 +4441 2762 +4441 3487 +4441 3511 +4441 3823 +4441 5287 +4205 1501 +4206 123 +4206 369 +4206 504 +4206 1442 +4206 1487 +4206 2060 +4206 3304 +4206 5146 +4206 5147 +4206 5148 +4207 97 +4207 706 +4207 1685 +4207 1903 +4207 4231 +4208 252 +4208 1068 +4208 2564 +4208 3620 +4208 4071 +4208 5022 +4208 5133 +4208 5134 +4208 5135 +4208 5136 +1232 263 +1232 1854 +1232 1881 +1232 2493 +1232 3089 +1232 3090 +1232 3091 +1232 3092 +1232 3093 +1232 3094 +5120 626 +377 127 +377 129 +377 176 +377 369 +377 423 +377 718 +377 856 +377 2018 +377 2338 +75 190 +75 219 +75 262 +75 1142 +75 1337 +75 1964 +75 1965 +75 1966 +75 1967 +75 1968 +4684 970 +4684 1731 +4684 3837 +4684 4176 +4684 4735 +4684 5343 +4684 5419 +4684 5420 +1929 126 +1929 128 +1929 145 +1929 149 +1929 174 +1929 177 +1929 179 +1929 266 +1929 2001 +1929 2018 +3738 587 +3738 1216 +3738 1424 +3738 1792 +3738 2010 +3738 3084 +3738 4788 +3738 4915 +3738 4916 +2146 4 +2146 5 +2146 9 +2146 10 +2146 147 +2146 266 +2146 368 +2146 423 +2146 1245 +3040 4 +3040 5 +3040 122 +3040 123 +3040 128 +3040 144 +3040 175 +3040 176 +3040 424 +3041 134 +3041 365 +3041 1061 +3041 3207 +3041 3819 +3041 3867 +3041 4136 +3041 4193 +3041 4484 +3041 4485 +3042 3 +3042 124 +3042 175 +3042 249 +3042 250 +3042 266 +3042 367 +3042 558 +3042 697 +3042 754 +3043 9 +3043 126 +3043 145 +3043 147 +3043 148 +3043 252 +3043 266 +3043 352 +3043 559 +3043 856 +130 131 +130 132 +130 133 +130 134 +130 135 +130 136 +130 137 +130 138 +130 139 +130 140 +4825 838 +4825 839 +4825 1716 +4825 2211 +4825 2226 +4825 4388 +4825 4915 +4825 5513 +4825 5514 +4825 5515 +5487 5858 +5785 121 +5785 123 +5785 144 +5785 149 +5785 176 +5785 180 +5785 352 +5785 754 +5785 1317 +689 609 +689 690 +689 691 +689 692 +689 693 +4428 179 +4428 247 +4428 251 +4428 266 +4428 368 +4428 422 +4428 423 +4428 424 +4428 667 +4428 717 +4492 573 +4492 1138 +4492 1177 +4492 1212 +4492 1940 +4492 3343 +4492 3860 +4492 4254 +4492 5321 +4492 5322 +1814 442 +1814 1328 +1814 1817 +1814 2193 +1814 3204 +1814 3546 +1814 3547 +1814 3548 +1814 3549 +1814 3550 +1870 71 +1870 642 +1870 706 +1870 1705 +1870 1714 +1870 1871 +1870 1872 +1870 1873 +1870 1874 +1870 1875 +2295 76 +2295 612 +2295 1512 +2295 2348 +2295 2403 +2295 2868 +2295 3082 +2295 3127 +2295 3794 +2576 111 +2576 3699 +2576 4004 +2576 4175 +2576 4176 +4344 684 +4344 1943 +4344 3861 +4344 4766 +4344 4973 +4344 5226 +4344 5227 +4344 5228 +4344 5229 +4344 5230 +4353 4 +4353 5 +4353 123 +4353 125 +4353 126 +4353 144 +4353 177 +4353 180 +4353 754 +4353 1317 +4355 202 +4355 472 +4355 867 +4355 1213 +4355 1929 +4355 4081 +4355 5185 +4355 5186 +4355 5240 +4355 5241 +2888 527 +2888 652 +2888 1738 +2888 2304 +2888 3017 +2888 4327 +2888 4393 +2888 4394 +2888 4395 +2888 4396 +4935 1136 +4935 2151 +4935 2785 +4935 3849 +4935 3856 +4935 4103 +4935 5388 +4935 5448 +4935 5585 +4935 5586 +2663 107 +2663 325 +2663 1412 +2663 1504 +2663 2862 +2663 3204 +2663 3292 +2663 4247 +2663 4248 +2663 4249 +2901 3 +2901 8 +2901 123 +2901 128 +2901 146 +2901 177 +2901 179 +2901 248 +2901 390 +2901 1245 +4733 178 +4733 983 +4733 1679 +4733 2569 +4733 3590 +4733 3730 +4733 4526 +4733 4876 +4733 5447 +4733 5448 +360 65 +360 361 +360 362 +360 363 +360 364 +360 365 +1126 3147 +1126 3148 +1130 2938 +3568 43 +3568 221 +3568 918 +3568 1311 +3568 1934 +3568 2862 +3568 3614 +3568 4802 +3568 4836 +3568 4837 +1999 209 +1999 924 +1999 1199 +1999 1297 +1999 1606 +1999 1608 +1999 1867 +1999 1868 +1999 3336 +1999 3769 +4124 1208 +4124 2474 +4124 2636 +4124 3404 +4124 3733 +4124 3806 +4124 4687 +4124 5087 +4124 5088 +4124 5089 +2922 178 +2922 252 +2922 264 +2922 367 +2922 390 +2922 422 +2922 423 +2922 559 +2922 754 +2922 2001 +434 4 +434 5 +434 7 +434 127 +434 145 +434 148 +434 266 +434 559 +434 1317 +434 2018 +1832 604 +1832 1154 +1832 1408 +1832 1754 +1832 1888 +1832 1967 +1832 1984 +1832 1985 +1832 3583 +1832 3584 +997 522 +997 1332 +997 1829 +997 2061 +997 2383 +997 2507 +997 2902 +4569 581 +4569 1026 +4569 2965 +4569 4455 +4569 4516 +4569 4821 +4569 4844 +4569 5359 +4569 5360 +4569 5361 +724 152 +724 215 +724 725 +724 1313 +724 1424 +724 1434 +724 2443 +724 2653 +724 2654 +5726 4 +5726 9 +5726 17 +5726 126 +5726 149 +5726 175 +5726 422 +5726 559 +5726 754 +5727 1531 +5727 2241 +5727 2804 +5727 3334 +5727 5844 +5727 5947 +5727 5948 +5727 5949 +5727 5950 +5727 5951 +975 906 +975 940 +975 976 +975 977 +975 978 +975 979 +975 980 +975 981 +975 982 +975 983 +1910 271 +1910 549 +1910 659 +1910 711 +1910 1180 +1910 1583 +1910 2288 +1910 2634 +1910 2833 +1910 3682 +473 1193 +473 1509 +473 3205 +473 3309 +473 4207 +473 4282 +473 4828 +473 4829 +473 4830 +3014 274 +3014 937 +3014 1016 +3014 1305 +3014 1503 +3014 1608 +3014 1800 +3014 1947 +3014 3706 +3014 4458 +682 309 +682 690 +682 712 +682 851 +682 1337 +682 1347 +682 2411 +682 2585 +682 2586 +5030 281 +5030 1168 +5030 1447 +5030 1451 +5030 1590 +5030 2353 +5030 2885 +5030 3069 +5030 4687 +5030 4877 +5034 3029 +5035 2857 +5035 3681 +5035 3727 +5035 3772 +5035 4663 +5035 5606 +5035 5607 +5035 5608 +5035 5609 +5035 5610 +1359 626 +1359 913 +1359 1741 +1359 1958 +1359 1980 +1359 2194 +1359 2617 +1359 3206 +1359 3207 +1359 3208 +2875 141 +2875 396 +2875 848 +2875 2313 +2875 3327 +2875 3894 +2875 4051 +2875 4357 +2875 4358 +2875 4359 +3858 2081 +3858 2519 +3858 2762 +3858 3247 +3858 4439 +3858 4441 +3858 4828 +3858 4877 +4880 1598 +4880 4333 +4880 4395 +4880 5295 +4880 5545 +4880 5546 +4880 5547 +4880 5548 +4880 5549 +4356 2927 +4356 3376 +4356 3916 +4356 4940 +4356 5323 +2092 133 +2092 266 +2092 666 +2092 1531 +2092 1866 +2092 3124 +2092 3855 +2092 3856 +2092 3857 +2092 3858 +2094 629 +2094 685 +2094 2317 +2094 2494 +2094 2540 +2094 2776 +2094 3594 +2094 3859 +2094 3860 +2094 3861 +2095 3862 +4867 493 +4867 600 +4867 725 +4867 1034 +4867 2347 +4867 3968 +4867 5283 +4867 5543 +4867 5544 +4799 1456 +4799 1618 +4799 2234 +4799 2896 +4799 4876 +4799 4883 +4799 5463 +4799 5498 +1415 17 +1415 455 +1415 747 +1415 2119 +1415 2311 +1415 2897 +1415 2975 +1415 3271 +1415 3272 +1415 3273 +1417 8 +1417 121 +1417 122 +1417 123 +1417 127 +1417 147 +1417 177 +1417 246 +1417 251 +1417 353 +196 246 +196 424 +196 659 +196 809 +196 2120 +196 2142 +196 2143 +196 2144 +196 2145 +196 2146 +5245 123 +5245 127 +5245 146 +5245 147 +5245 175 +5245 247 +5245 250 +5245 369 +5245 423 +5819 123 +5819 143 +5819 177 +5819 179 +5819 247 +5819 264 +5819 367 +5819 369 +5819 422 +5819 1246 +4109 795 +4109 843 +4109 979 +4109 1172 +4109 2085 +4109 2561 +4109 3925 +4109 4075 +4109 4183 +4109 5082 +1192 338 +1192 834 +1192 900 +1192 1193 +1192 1194 +1192 1195 +1192 1196 +1192 1197 +1192 1198 +1981 451 +1981 1724 +1981 2255 +1981 2524 +1981 3758 +1981 3759 +1981 3760 +1981 3761 +1981 3762 +1981 3763 +5824 1592 +5824 1993 +5824 2267 +5824 2650 +5824 2672 +5824 2720 +5824 4128 +5824 5771 +5824 5958 +5824 5974 +1601 125 +1601 126 +1601 129 +1601 148 +1601 149 +1601 179 +1601 247 +1601 248 +1601 717 +1601 754 +3943 2539 +3943 2744 +3943 2747 +3943 2859 +3943 2898 +3943 3779 +3943 4613 +3943 5010 +3943 5011 +3943 5012 +3945 122 +3945 123 +3945 124 +3945 126 +3945 149 +3945 177 +3945 247 +3945 698 +998 181 +998 668 +998 1536 +998 1735 +998 2023 +998 2451 +998 2898 +998 2899 +998 2900 +998 2901 +2156 1016 +2156 2309 +2156 2354 +2156 3300 +2156 3431 +2156 5343 +2156 5468 +2156 5958 +2156 5959 +2156 5960 +4654 1137 +4654 1239 +4654 1509 +4654 1616 +4654 1803 +4654 3141 +4654 3699 +4654 3807 +4654 4655 +4654 5852 +4654 5954 +4654 5955 +3877 478 +27 901 +27 960 +27 1511 +27 1624 +27 1836 +27 1911 +27 1912 +27 1913 +27 1914 +27 1915 +577 164 +577 584 +577 642 +577 977 +577 1610 +577 2506 +577 2525 +577 2526 +577 2527 +577 2528 +580 3 +580 910 +580 1275 +580 1427 +580 1782 +580 1792 +580 2539 +580 2540 +580 2541 +580 2542 +2828 113 +2828 256 +2828 518 +2828 2196 +2828 2322 +2828 2992 +2828 3963 +2828 4124 +2828 4325 +3269 5 +3269 17 +3269 126 +3269 143 +3269 149 +3269 250 +3269 266 +3269 423 +3269 424 +3269 559 +3270 522 +3270 4150 +3270 4365 +3270 4642 +3270 4643 +3406 1367 +3406 3292 +3406 3991 +3406 4739 +3406 4740 +3407 1246 +3407 1503 +3407 1650 +3407 1845 +3407 2343 +3407 3303 +3407 4206 +3407 4264 +3407 4741 +3407 4742 +882 2774 +885 2773 +111 1419 +111 1561 +111 1670 +111 1787 +111 1846 +111 2065 +111 2066 +111 2067 +111 2068 +111 2069 +1167 274 +1167 1168 +1167 1169 +1167 1170 +1167 1171 +1545 1837 +6255 757 +270 190 +270 271 +270 272 +270 273 +270 274 +270 275 +270 276 +270 277 +270 278 +680 144 +680 145 +680 251 +680 630 +680 1841 +680 1842 +680 1843 +680 1844 +680 1845 +680 1846 +5077 837 +5077 2842 +5077 3743 +5077 4270 +5077 5634 +1134 164 +3304 125 +3304 174 +3304 180 +3304 252 +3304 264 +3304 266 +3304 368 +3304 390 +3304 422 +3304 559 +4308 1299 +4308 1533 +4308 1609 +4308 1872 +4308 1926 +4308 1955 +4308 3455 +4308 4078 +4308 4485 +4308 5205 +479 2452 +479 2453 +479 2454 +479 2455 +479 2456 +479 2457 +479 2458 +479 2459 +479 2460 +479 2461 +480 382 +480 507 +480 722 +480 726 +480 1048 +480 2319 +480 2358 +480 2462 +480 2463 +481 4 +481 124 +481 265 +481 353 +481 368 +481 369 +481 695 +481 700 +481 946 +481 947 +484 337 +484 532 +484 786 +484 1352 +484 1764 +484 2493 +484 2494 +484 2495 +484 2496 +484 2497 +2091 681 +2091 979 +2091 1212 +2091 2326 +2091 2385 +2091 2395 +2091 3460 +2091 3864 +2091 3865 +2091 3866 +2715 285 +2715 693 +2715 1310 +2715 1592 +2715 1792 +2715 2476 +2715 2595 +2715 2891 +2715 3335 +2715 4061 +2716 196 +2716 524 +2716 1765 +2716 2452 +2716 3058 +2716 3138 +2716 4274 +2716 4275 +2716 4276 +2716 4277 +2718 748 +2718 2127 +2718 2293 +2718 2614 +2718 3558 +2718 3913 +2718 4052 +2718 4281 +2718 4282 +2718 4283 +4407 169 +4407 1342 +4407 2001 +4407 2046 +4407 3362 +4407 5265 +4407 5266 +4407 5267 +4407 5268 +2986 3 +2986 121 +2986 128 +2986 143 +2986 147 +2986 176 +2986 177 +2986 264 +2986 422 +2986 718 +5472 866 +5472 1288 +5472 1433 +5472 3061 +5472 3796 +5472 4166 +5472 4382 +5472 4866 +5472 5211 +5472 5839 +276 272 +276 274 +276 600 +276 1583 +276 1800 +276 2247 +276 2248 +276 2249 +1972 170 +1972 252 +1972 1615 +1972 2279 +1972 3563 +1972 3749 +1972 3750 +1972 3751 +1972 3752 +1972 3753 +3594 363 +3594 1138 +3594 2498 +3594 2747 +3594 4846 +3594 4847 +3594 4848 +3594 4849 +3594 4850 +3594 4851 +4892 212 +4892 458 +4892 2272 +4892 3054 +4892 3931 +4892 4074 +4892 4563 +4892 5554 +4892 5555 +2946 1787 +2946 1939 +2946 2190 +2946 4005 +2946 4007 +2946 4354 +2946 4429 +2946 4430 +2946 4431 +2946 4432 +1882 486 +1882 1531 +1882 1862 +1882 1930 +1882 2337 +1882 3624 +1882 3625 +1882 3626 +1882 3627 +1882 3628 +4874 123 +4874 249 +4874 250 +4874 251 +4874 264 +4874 422 +4874 427 +4874 1245 +4874 2001 +4875 107 +4875 1229 +4875 2093 +4875 2350 +4875 2408 +4875 2890 +4875 3395 +4875 3542 +4875 4158 +4875 5333 +1310 9 +1310 122 +1310 123 +1310 124 +1310 128 +1310 179 +1310 367 +1310 369 +1310 427 +1310 1317 +1883 534 +1883 621 +1883 944 +1883 1060 +1883 1261 +1883 2252 +1883 2789 +1883 3188 +1883 3673 +1883 3674 +3621 4159 +5542 495 +5542 1194 +5542 1261 +5542 1587 +5542 2089 +5542 2384 +5542 2541 +5542 4782 +5542 4813 +5542 4945 +5820 1831 +5820 2472 +5820 2627 +5820 4060 +5820 5501 +5820 5657 +5820 6002 +5820 6003 +5820 6004 +5820 6005 +5821 491 +5821 858 +5821 983 +5821 1313 +5821 1458 +5821 3388 +5821 5534 +5821 5837 +5821 6006 +5821 6007 +4012 1010 +4012 1300 +4012 1571 +4012 2230 +4012 2377 +4012 2887 +4012 3185 +4012 3781 +4012 4655 +4012 4847 +1685 222 +1685 521 +1685 779 +1685 1652 +1685 1686 +1685 1687 +1685 1688 +1685 1689 +1685 1690 +1685 1691 +1216 1591 +1216 1749 +2898 932 +2898 1305 +2898 2353 +2898 2694 +2898 2770 +2898 3138 +2898 4058 +2898 4381 +2898 4382 +2898 4383 +2907 112 +2907 117 +2907 841 +2907 2154 +2907 3526 +2907 4082 +2907 4389 +2907 4390 +2907 4391 +2907 4392 +218 219 +218 220 +218 221 +218 222 +218 223 +218 224 +218 225 +218 226 +218 227 +1234 228 +1234 342 +1234 1023 +1234 2093 +1234 2612 +1234 2678 +1234 2871 +1234 3095 +1234 3096 +1234 3097 +3514 921 +3514 1160 +3514 1429 +3514 1898 +3514 2479 +3514 2555 +3514 3574 +3514 4600 +3514 4791 +3514 4792 +3515 3 +3515 4 +3515 127 +3515 147 +3515 176 +3515 264 +3515 427 +3515 666 +3515 667 +4179 3 +4179 123 +4179 127 +4179 144 +4179 145 +4179 238 +4179 251 +4179 352 +4179 369 +4179 2338 +1585 281 +1585 562 +1585 1586 +1585 1587 +1585 1588 +1585 1589 +1585 1590 +1585 1591 +1585 1592 +1585 1593 +5924 276 +5924 619 +5924 1568 +5924 1983 +5924 2276 +5924 3173 +5924 3891 +5924 4052 +5924 5911 +5924 6071 +5925 125 +5925 229 +5925 3257 +5925 3852 +5925 4882 +5925 4894 +5925 5086 +5925 5128 +5925 5229 +5925 6070 +907 64 +907 1292 +907 1397 +907 2099 +907 2778 +907 2804 +907 2805 +907 2806 +907 2807 +907 2808 +910 518 +910 869 +910 2322 +910 2797 +910 2798 +910 2799 +910 2800 +910 2801 +910 2802 +910 2803 +3605 731 +533 1482 +533 1512 +533 1607 +533 2498 +533 2499 +533 2500 +533 2501 +533 2502 +533 2503 +533 2504 +1958 58 +1958 172 +1958 582 +1958 583 +1958 1250 +1958 1541 +1958 2394 +1958 2758 +1958 3159 +1958 3726 +2589 4185 +2590 57 +2590 1376 +2590 2248 +2590 4186 +2591 1162 +2591 2463 +2591 3677 +2591 4082 +2591 4083 +2591 4133 +2591 4187 +2591 4188 +2591 4189 +2702 351 +2702 2419 +2702 2566 +2702 3007 +2702 3797 +2702 3953 +2702 4266 +2702 4267 +2702 4268 +2702 4269 +2704 837 +1735 103 +1735 298 +1735 982 +1735 1332 +1735 1736 +1735 1737 +1735 1738 +1735 1739 +1735 1740 +1735 1741 +1862 748 +1862 1377 +1862 3799 +1862 3800 +1862 3801 +1862 3802 +1862 3803 +1862 3804 +1862 3805 +1862 3806 +3009 17 +3009 144 +3009 175 +3009 1245 +3009 1317 +3009 1667 +3009 2018 +3009 2627 +3009 4457 +5429 651 +5429 1534 +5429 1720 +5429 2690 +5429 4306 +5429 4439 +5429 4961 +5429 5040 +5429 5827 +5429 5828 +4741 1658 +4741 1974 +4741 2358 +4741 3127 +4741 3224 +4741 3860 +4741 4303 +4741 4306 +4741 5459 +4741 5460 +5720 5890 +4541 495 +4541 1213 +4541 1214 +4541 1577 +4541 2661 +4541 3721 +4541 4038 +4541 4158 +4541 4735 +4541 5344 +5887 1240 +5887 2690 +5887 3946 +5887 6042 +5887 6043 +5887 6044 +5887 6045 +5887 6046 +5887 6047 +5887 6048 +5932 552 +4306 4 +4306 143 +4306 175 +4306 249 +4306 251 +4306 264 +4306 369 +4306 422 +4306 856 +4932 1943 +4932 2276 +4932 2723 +4932 3786 +4932 4623 +4932 5572 +4932 5573 +4932 5574 +4932 5575 +4932 5576 +848 448 +1057 164 +1057 1058 +1057 1059 +1057 1060 +1057 1061 +1057 1062 +1057 1063 +1057 1064 +1057 1065 +1057 1066 +1253 13 +1253 750 +1253 2359 +1253 3119 +1254 813 +1254 1890 +1254 2207 +1254 2997 +1254 3007 +1256 3114 +2926 664 +2927 868 +2927 963 +2927 1749 +2927 2298 +2927 3717 +2927 4265 +2927 5777 +2927 5778 +2927 5779 +2927 5780 +2930 2158 +1792 1001 +1792 1203 +1792 2377 +1792 3000 +1792 3104 +1792 3536 +1792 3537 +1792 3538 +1792 3539 +1792 3540 +5177 1438 +5177 3109 +5177 4930 +5177 5681 +5177 5682 +5177 5683 +5177 5684 +5177 5685 +5177 5686 +5177 5687 +5089 3981 +5892 6049 +5893 8 +5893 124 +5893 238 +5893 248 +5893 249 +5893 251 +5893 352 +5893 422 +5893 423 +5893 667 +4532 4 +4532 127 +4532 143 +4532 248 +4532 266 +4532 390 +4532 422 +4532 423 +4532 667 +5326 701 +5326 703 +5326 1430 +5326 2149 +5326 3017 +5326 3027 +5326 4297 +5326 5268 +5326 5339 +5326 5352 +631 15 +631 632 +631 633 +631 634 +631 635 +68 152 +68 219 +68 346 +68 965 +68 1953 +68 1954 +68 1955 +68 1956 +68 1957 +68 1958 +2862 455 +2862 633 +2862 1931 +2862 2407 +2862 3594 +2862 4280 +2862 4337 +2862 4338 +2862 4339 +2862 4340 +3470 583 +3470 1947 +3470 2360 +3470 2528 +3470 2636 +3470 4155 +3470 4775 +3470 4776 +3470 4777 +5385 309 +5385 1120 +5385 1511 +5385 2007 +5385 2090 +5385 5074 +5385 5636 +5385 5729 +5385 5801 +5385 5802 +1506 1090 +1506 1507 +1506 1508 +1506 1509 +1506 1510 +1506 1511 +1506 1512 +1506 1513 +1506 1514 +1506 1515 +3886 451 +3886 478 +3886 677 +3886 1020 +3886 1230 +3886 2215 +3886 3275 +3886 4126 +3886 4977 +3886 4978 +3887 690 +3887 744 +3887 1300 +3887 1730 +3887 3053 +3887 4373 +3887 4984 +3887 4985 +3887 4986 +3887 4987 +2153 1219 +2153 2847 +2153 3804 +2153 3856 +2153 3908 +2153 3909 +2153 3910 +2153 3911 +2153 3912 +2153 3913 +2158 262 +2158 1021 +2158 1115 +2158 2002 +2158 3433 +2158 3467 +2158 3896 +2158 3897 +2158 3898 +2158 3899 +389 693 +389 882 +389 951 +389 1383 +389 1538 +389 1792 +389 2271 +389 2357 +389 2358 +389 2359 +2217 5 +2217 9 +2217 149 +2217 177 +2217 238 +2217 247 +2217 249 +2217 369 +2217 424 +2217 1317 +4478 1052 +4478 1146 +4478 1961 +4478 3418 +4478 4009 +4478 4364 +4478 5313 +4478 5314 +4478 5315 +4478 5316 +4536 56 +4536 158 +4536 1199 +4536 1341 +4536 2304 +4536 4096 +4536 5081 +4536 5340 +4536 5341 +3480 341 +3480 343 +3480 347 +3480 2306 +3480 2307 +3480 2337 +3480 3343 +3480 4170 +3480 4628 +3480 4663 +3077 3 +3077 127 +3077 147 +3077 264 +3077 352 +3077 368 +3077 390 +3077 423 +3077 427 +3077 1245 +3317 4678 +3321 1913 +3321 1926 +3321 2433 +3321 4014 +3321 4675 +4948 5583 +4949 31 +4949 127 +4949 143 +4949 368 +4949 422 +4949 427 +4949 558 +4949 856 +4949 2001 +3496 566 +3496 645 +3496 674 +3496 884 +3496 1926 +3496 2302 +3496 2857 +3496 3768 +3496 4655 +1356 48 +1356 270 +1356 281 +1356 472 +1356 1357 +1356 1358 +1356 1359 +1356 1360 +1356 1361 +4158 584 +4158 770 +4158 2229 +4158 3982 +4158 4739 +4158 4783 +4158 5099 +4158 5100 +4158 5101 +4158 5102 +2364 1999 +2364 4050 +2364 4051 +2364 4052 +61 907 +61 1922 +61 1992 +61 1993 +61 1994 +61 1995 +61 1996 +61 1997 +61 1998 +61 1999 +65 86 +65 1954 +65 2002 +65 2003 +65 2004 +65 2005 +65 2006 +65 2007 +65 2008 +65 2009 +4282 125 +4282 824 +4282 1088 +4282 2220 +4282 3138 +4282 3468 +4282 4339 +4282 4414 +4282 4502 +4282 5182 +4633 199 +4633 474 +4633 476 +4633 637 +4633 2269 +4633 3105 +4633 3227 +4633 4646 +4633 5397 +4633 5398 +5332 121 +5332 129 +5332 352 +5332 424 +5332 5731 +413 2393 +2897 262 +2897 396 +2897 1397 +2897 4307 +2897 4366 +2897 4377 +2897 4378 +2897 4379 +2897 4380 +4174 8 +4174 122 +4174 143 +4174 146 +4174 174 +4174 196 +4174 352 +4174 353 +4174 369 +4174 424 +5306 129 +5306 1509 +5306 1912 +5306 3566 +5306 5156 +5306 5369 +5306 5747 +5306 5767 +5306 5768 +5580 2881 +1818 18 +1818 270 +1818 725 +1818 1157 +1818 1575 +1818 3174 +1818 3413 +1818 3554 +1818 3555 +1818 3556 +1819 996 +1819 1492 +1819 2486 +1819 2869 +1819 3327 +1819 3563 +1819 3564 +1819 3565 +1819 3566 +1819 3567 +1820 894 +1820 1022 +1820 1139 +1820 2358 +1820 3557 +1820 3558 +1820 3559 +1820 3560 +1820 3561 +1820 3562 +1002 20 +1002 95 +1002 341 +1002 478 +1002 798 +1002 892 +1002 1408 +1002 1439 +1002 1440 +1002 1441 +1477 3 +1477 4 +1477 17 +1477 122 +1477 176 +1477 264 +1477 422 +1477 666 +1477 856 +747 2051 +747 2427 +747 2648 +747 2667 +747 2668 +747 2669 +747 2670 +747 2671 +747 2672 +747 2673 +371 4 +371 7 +371 9 +371 148 +371 251 +371 264 +371 265 +371 367 +371 422 +371 1245 +372 231 +372 295 +372 1928 +372 2177 +372 2315 +372 2316 +372 2317 +372 2318 +372 2319 +372 2320 +378 121 +378 122 +378 123 +378 127 +378 143 +378 251 +378 390 +378 667 +378 717 +378 1245 +379 2373 +4636 5 +4636 9 +4636 148 +4636 179 +4636 390 +4636 422 +4636 558 +4636 697 +4636 754 +4636 856 +5195 521 +5195 1070 +5195 3782 +5195 3962 +5195 3977 +5195 4031 +5195 5434 +5195 5604 +5195 5700 +5195 5701 +5196 107 +5196 326 +5196 1928 +5196 2313 +5196 3598 +5196 4082 +5196 4423 +5196 5695 +5196 5696 +5196 5697 +5197 48 +5197 968 +5197 1814 +5197 2055 +5197 2164 +5197 3112 +5197 5441 +5197 5475 +5197 5698 +5197 5699 +3716 977 +3716 3119 +3716 3301 +3716 3376 +3716 3890 +3716 4655 +3716 4900 +3716 4901 +3716 4902 +3716 4903 +4783 51 +4783 651 +4783 1563 +4783 2186 +4783 2377 +4783 2452 +4783 2579 +4783 3418 +4783 3917 +4783 4293 +5211 115 +5211 279 +5211 1597 +5211 2547 +5211 2594 +5211 3021 +5211 3912 +5211 4894 +5211 5121 +5211 5703 +5386 5 +5386 125 +5386 129 +5386 174 +5386 238 +5386 248 +5386 250 +5386 252 +5386 1084 +5389 2634 +435 127 +1380 41 +1380 385 +1380 1437 +1380 1899 +1380 2054 +1380 2272 +1380 3076 +1380 3156 +1380 3235 +1380 3236 +2864 352 +2804 470 +2804 604 +2804 1325 +2804 1451 +2804 2422 +2804 2733 +2804 2768 +2804 3276 +2804 3772 +2804 4311 +5987 529 +5987 981 +5987 2776 +5987 3140 +5987 4225 +5987 6100 +5987 6101 +5987 6102 +5987 6103 +5987 6104 +5988 5 +5988 9 +5988 126 +5988 175 +5988 180 +5988 252 +5988 266 +5988 368 +5988 3677 +5990 547 +5990 996 +5990 1451 +5990 1888 +5990 3039 +5990 5628 +5990 5913 +5990 6109 +5990 6110 +5990 6111 +3338 133 +3338 1808 +3338 2971 +3338 3808 +3338 4281 +3338 4356 +3338 4412 +3338 4682 +830 4 +830 31 +830 148 +830 179 +830 180 +830 368 +830 666 +830 736 +830 886 +830 2018 +1811 117 +1811 522 +1811 711 +1811 1636 +1811 1650 +1811 2792 +1811 3542 +1811 3543 +1811 3544 +1811 3545 +6094 1006 +6094 1323 +6094 1333 +6094 2026 +6094 4254 +6094 4297 +6094 6095 +6094 6174 +6094 6175 +6094 6176 +6095 380 +6095 2295 +6095 3021 +6095 3675 +6095 3804 +6095 4363 +6095 5449 +6095 5603 +6095 6177 +6095 6178 +2260 38 +2260 1688 +2260 2191 +2260 2941 +2260 3804 +2260 4501 +2260 4894 +2260 5909 +2260 6108 +2260 6181 +4592 5380 +6099 106 +6099 1637 +6099 1915 +6099 2015 +6099 4893 +6099 5714 +6099 5901 +6099 6166 +6099 6179 +6099 6180 +4242 407 +4242 651 +4242 1194 +4242 1369 +4242 1575 +4242 3250 +4242 3491 +4242 4072 +4242 4603 +4242 5161 +6282 3992 +6282 6291 +5452 8 +5452 122 +5452 126 +5452 145 +5452 149 +5452 174 +5452 179 +5452 424 +5452 427 +5452 1317 +6039 202 +6039 503 +6039 810 +6039 814 +6039 1915 +6039 2149 +6039 2719 +6039 2755 +6039 2978 +6039 3275 +6039 3293 +6039 3325 +6039 3488 +6039 5049 +6039 5395 +6039 5554 +6039 5816 +6039 5888 +6039 5952 +6039 5966 +6039 6022 +6039 6157 +6039 6158 +6039 6159 +6039 6160 +6039 6161 +6039 6162 +6039 6163 +6039 6164 +6039 6165 +6039 6166 +6279 115 +6279 1845 +6279 5529 +6279 5970 +6279 6011 +6279 6284 +6279 6285 +6279 6286 +6279 6287 +6279 6288 +3564 854 +3564 1123 +3564 1573 +3564 3409 +3564 4158 +3564 4339 +3564 4718 +3564 4823 +4227 123 +4227 127 +4227 176 +4227 238 +4227 367 +4227 422 +4227 427 +4227 667 +4227 717 +4227 2338 +5508 547 +5508 1301 +5508 2376 +5508 3813 +5508 4067 +5508 4382 +5508 5856 +5508 5857 +5037 2765 +5037 5611 +4771 804 +4771 1090 +4771 1426 +4771 3951 +4771 4422 +1379 602 +1379 1274 +1379 1380 +1379 1381 +1379 1382 +1379 1383 +1379 1384 +1379 1385 +1379 1386 +1379 1387 +5615 1082 +5615 1923 +5615 2005 +5615 2207 +5615 2726 +5615 3125 +5615 3376 +5615 4854 +5615 5900 +5615 5901 +2826 249 +2826 1400 +2826 2287 +2826 2541 +2826 2558 +2826 2923 +2826 4336 +2826 5277 +2826 5516 +2826 5517 +4102 50 +4102 2557 +5104 23 +5104 689 +5104 910 +5104 967 +5104 1424 +5104 2552 +5104 2787 +5104 3487 +5104 4400 +5104 5277 +5058 85 +5058 153 +5058 919 +5058 1956 +5058 2112 +5058 2410 +5058 2414 +5058 4735 +5058 5196 +5058 5452 +5296 1001 +5296 1948 +5296 4735 +5296 4788 +5296 5073 +5296 5398 +5296 5504 +5296 5763 +5296 5764 +5296 5765 +5750 487 +5750 491 +5750 811 +5750 862 +5750 1509 +5750 1757 +5750 2127 +5750 4287 +5750 5962 +5750 5963 +5751 5168 +5753 244 +5753 835 +5753 1321 +5753 1890 +5753 3446 +5753 4639 +5753 4881 +5753 5368 +5753 5966 +5753 5967 +5754 870 +5754 1048 +5754 2537 +5754 3563 +5754 3993 +5754 4622 +5754 5729 +5754 5920 +5754 5964 +5754 5965 +5755 3509 +1352 124 +1352 126 +1352 145 +1352 174 +1352 179 +1352 423 +1352 667 +1352 1353 +1352 1354 +1352 1355 +4303 31 +4303 121 +4303 124 +4303 148 +4303 177 +4303 180 +4303 352 +4303 427 +4303 736 +4303 2001 +2199 322 +2199 412 +2199 527 +2199 2940 +2199 3593 +2199 3697 +2199 3919 +2199 3920 +2199 3921 +2199 3922 +4533 103 +4533 112 +4533 1382 +4533 1541 +4533 1741 +4533 2201 +4533 2312 +4533 2758 +4533 5338 +4533 5339 +5220 1168 +5220 1480 +5220 2823 +5220 4137 +5220 4740 +5220 4929 +5220 5715 +5220 5716 +5220 5717 +5220 5718 +4921 219 +4921 1798 +4921 2129 +4921 2235 +4921 4468 +981 8 +981 448 +981 731 +981 822 +981 1143 +981 1974 +981 2883 +981 2884 +981 2885 +981 2886 +3210 691 +3210 2055 +3210 2691 +3210 2935 +3210 3221 +3210 4594 +3210 4595 +3210 4596 +3210 4597 +3210 4598 +43 1604 +43 1679 +43 1903 +43 1930 +43 1931 +43 1932 +43 1933 +43 1934 +43 1935 +43 1936 +4264 1157 +5724 3 +5724 7 +5724 122 +5724 123 +5724 124 +5724 125 +5724 145 +5724 177 +5724 352 +5724 427 +2778 3497 +3003 219 +3003 1087 +3003 1761 +3003 1930 +3003 2645 +3003 2787 +3003 2871 +3003 3207 +3003 4082 +3003 4445 +2611 1956 +87 88 +87 89 +87 90 +87 91 +87 92 +87 93 +87 94 +87 95 +87 96 +87 97 +1040 1023 +1040 1055 +1040 2254 +1040 2962 +1040 2963 +1040 2964 +1040 2965 +1040 2966 +1040 2967 +1659 143 +1659 522 +1659 1791 +1659 2285 +1659 2349 +1659 2862 +1659 3121 +1659 3175 +1659 3300 +1659 3412 +1939 840 +385 23 +385 314 +385 1741 +385 2162 +385 2339 +385 2340 +385 2341 +385 2342 +385 2343 +385 2344 +1275 1276 +1275 1277 +1275 1278 +1275 1279 +1275 1280 +1275 1281 +1275 1282 +1275 1283 +1275 1284 +1275 1285 +3311 493 +3311 498 +3311 560 +3311 767 +3311 2293 +3468 740 +3468 997 +3468 1565 +3468 3968 +3468 4206 +3468 4239 +3468 4355 +3468 4770 +3468 4771 +3468 4772 +3469 123 +3469 266 +3469 570 +3469 1630 +3469 2236 +3469 2752 +3469 2948 +3469 3247 +3469 4773 +3469 4774 +2938 486 +2938 494 +2938 534 +2938 924 +2938 1297 +2938 1559 +2938 1940 +2938 2650 +2938 4124 +2939 802 +2939 1866 +2939 2275 +2939 2412 +2939 2948 +2939 3636 +2939 4170 +2939 4418 +2939 4419 +2939 4420 +83 7 +83 8 +83 9 +83 148 +83 351 +83 426 +83 762 +83 946 +83 2000 +83 2001 +645 330 +645 2223 +645 2430 +645 2563 +645 2564 +3011 94 +3011 352 +3011 466 +3011 1022 +3011 2628 +3011 3587 +3011 4453 +3011 4454 +3011 4455 +3011 4456 +4755 5 +4755 7 +4755 121 +4755 125 +4755 127 +4755 148 +4755 174 +4755 177 +4755 251 +4755 427 +4758 365 +4758 1321 +4758 1808 +4758 2304 +4758 3092 +4758 4031 +4758 4063 +4758 5451 +4758 5468 +3191 101 +3191 1171 +3191 1235 +3191 2335 +3191 2575 +3191 3134 +3191 3140 +3191 3339 +3191 4580 +3191 4581 +3412 112 +3412 1636 +3412 2430 +3412 3760 +3412 4002 +3412 4402 +3412 4746 +3412 4747 +3412 4748 +3412 4749 +3904 312 +3904 1656 +3904 2175 +3904 3489 +3904 4091 +3904 4718 +3904 4998 +3904 4999 +3904 5000 +3904 5001 +4856 508 +4856 5393 +4856 5531 +4856 5532 +4857 114 +4857 387 +4857 473 +4857 531 +4857 588 +4857 1821 +4857 3511 +4857 4215 +4857 5530 +5183 363 +5183 1706 +5183 1711 +5183 2055 +5183 2481 +5183 4436 +5183 4559 +5183 5094 +5183 5494 +5183 5688 +5187 302 +5187 1184 +5187 1946 +5187 3023 +5187 3414 +5187 3988 +5187 5065 +5187 5184 +5187 5689 +5187 5690 +5190 1056 +5191 2693 +5191 4129 +5191 4809 +5191 5051 +5191 5508 +5191 5691 +5191 5692 +5191 5693 +5191 5694 +4572 5376 +4574 392 +4574 617 +4574 1616 +4574 1937 +4574 1987 +4574 3446 +4574 4960 +4574 5362 +4574 5363 +4574 5364 +728 45 +728 89 +728 298 +728 729 +728 730 +728 731 +728 732 +728 733 +728 734 +728 735 +5952 714 +5952 1627 +5952 2047 +5952 2475 +5952 3232 +5952 4012 +5952 5287 +5952 5508 +5952 5815 +5952 6080 +509 14 +509 193 +509 363 +509 503 +509 828 +509 840 +509 2447 +509 2488 +509 2489 +509 2490 +1632 1481 +5578 1511 +5578 1762 +5578 2090 +5578 5580 +5578 5883 +3478 1539 +2391 478 +2391 986 +2391 1370 +2391 3457 +2391 3487 +2391 4075 +2391 4076 +2391 4077 +2391 4078 +2391 4079 +5024 114 +4103 9 +4103 17 +4103 175 +4103 252 +4103 390 +4103 422 +4103 559 +4103 856 +4103 1245 +4103 1770 +5028 156 +5028 1037 +5028 1129 +5028 1203 +5028 2752 +5028 3064 +5028 3797 +5028 5353 +5028 5605 +3519 648 +3519 895 +3519 1227 +3519 4872 +3519 4883 +3549 190 +3549 227 +3549 260 +3549 412 +3549 637 +3549 979 +3549 1689 +3549 1702 +3549 2984 +3549 3136 +3757 123 +3757 127 +3757 147 +3757 249 +3757 251 +3757 368 +3757 423 +3757 718 +3757 1245 +1290 176 +1290 177 +1290 179 +1290 248 +1290 249 +1290 352 +1290 422 +1290 427 +1290 717 +1290 1317 +5052 198 +5052 356 +5052 558 +5052 2234 +5052 2285 +5052 2354 +5052 3035 +5052 3133 +5052 4892 +5052 5618 +5065 21 +5065 503 +5065 997 +5065 3296 +5065 3931 +5065 4324 +5065 4801 +5065 4826 +5065 5621 +5065 5622 +2116 510 +2116 1018 +2116 1633 +2116 2069 +2116 2130 +2116 3724 +2116 3875 +2116 3876 +2116 3877 +2116 3878 +2444 478 +2444 2288 +2444 2420 +2444 2657 +2444 2690 +2444 3698 +2444 3700 +2444 4102 +2444 4103 +2444 4104 +2797 5 +2797 17 +2797 125 +2797 126 +2797 143 +2797 149 +2797 175 +2797 754 +2797 856 +3045 42 +3045 125 +3045 219 +3045 550 +3045 614 +3045 2004 +3045 2499 +3045 3104 +3045 4475 +3045 4476 +1091 95 +1091 309 +1091 434 +1091 909 +1091 1092 +1091 1093 +1091 1094 +1091 1095 +1091 1096 +1091 1097 +415 156 +415 427 +415 676 +415 799 +415 803 +415 1018 +415 1019 +415 1020 +415 1021 +4433 8 +4433 1345 +4433 1890 +4433 3362 +4433 3677 +3359 997 +5971 6091 +1362 1026 +1362 1061 +1362 1348 +1362 1363 +1362 1364 +1362 1365 +1362 1366 +1362 1367 +1362 1368 +1362 1369 +3948 124 +3948 127 +3948 143 +3948 247 +3948 251 +3948 264 +3948 367 +3948 390 +3948 718 +3948 1245 +3284 452 +3284 453 +3284 1688 +3284 2354 +3284 2653 +3284 3408 +3284 4288 +3284 4654 +3284 4655 +3284 4656 +3285 17 +3285 1768 +3285 1827 +3285 1972 +3285 2244 +3285 3047 +3285 5638 +3285 6036 +3285 6037 +3285 6038 +3202 267 +3202 1466 +3202 2869 +3202 3488 +3202 3708 +3202 3796 +3202 3818 +3202 4165 +3202 4322 +3202 4590 +489 224 +489 490 +489 491 +489 492 +489 493 +489 494 +489 495 +489 496 +489 497 +489 498 +2065 585 +3831 33 +3831 1729 +3831 2357 +3831 3258 +3831 3259 +3831 4072 +3831 4363 +3831 4655 +3831 4946 +3831 4947 +3160 2734 +3160 3138 +3160 4510 +3160 4556 +3160 4557 +3160 4558 +3160 4559 +3160 4560 +3160 4561 +3160 4562 +1590 710 +1590 894 +1590 1179 +1590 1688 +1590 1886 +1590 2643 +1590 3104 +1590 3369 +1590 3370 +3744 3149 +3747 496 +3747 621 +3747 678 +3747 2875 +3747 2973 +3747 3993 +3747 4641 +3747 4877 +3747 4917 +3900 158 +3900 1243 +3900 1331 +3900 2024 +3900 3416 +3900 4752 +3900 4916 +3900 4988 +3900 4989 +3900 4990 +4114 124 +4114 127 +4114 251 +4114 264 +4114 390 +4114 427 +4114 559 +4114 667 +4114 1245 +4114 2018 +5619 261 +5619 391 +5619 898 +5619 1212 +5619 1866 +5619 1867 +5619 2149 +5619 2973 +5619 3982 +5619 4237 +1041 69 +1041 529 +1041 621 +1041 789 +1041 1042 +1041 1043 +1041 1044 +1041 1045 +1041 1046 +1041 1047 +4638 159 +4638 828 +4638 1604 +4638 2886 +4638 5357 +4638 5399 +4638 5400 +4638 5401 +4638 5402 +4803 495 +4803 2497 +4803 3088 +4803 3422 +4803 4036 +4803 4187 +4803 4882 +4803 5043 +4803 5507 +4803 5508 +382 996 +382 1969 +382 2345 +382 2346 +382 2347 +382 2348 +382 2349 +382 2350 +382 2351 +382 2352 +1549 130 +1549 1009 +1549 1629 +1549 2230 +1549 2587 +1549 2673 +1549 3341 +1550 126 +1550 145 +1550 149 +1550 183 +1550 246 +1550 390 +1550 423 +1550 667 +1550 718 +1550 856 +5626 584 +5626 1203 +5626 1509 +5626 3253 +5626 4037 +5626 4632 +5626 5837 +5626 5909 +5626 5910 +5626 5911 +1714 824 +1714 1034 +1714 1037 +1714 1715 +1714 1716 +1714 1717 +1714 1718 +1714 1719 +1714 1720 +1714 1721 +4176 2205 +4176 2222 +4176 3318 +4176 3418 +4176 3563 +4176 4006 +4176 5494 +4176 5814 +4176 5815 +1010 1191 +1010 1517 +1010 2411 +1010 2538 +1010 2920 +1010 2921 +1010 2922 +1010 2923 +1010 2924 +1010 2925 +3859 133 +3859 391 +3859 855 +3859 2676 +3859 3618 +3859 4285 +3859 4297 +3859 4960 +3859 4961 +3859 4962 +2252 3 +2252 7 +2252 8 +2252 123 +2252 128 +2252 148 +2252 176 +2252 179 +2252 424 +2252 717 +2014 21 +2014 2304 +2014 3038 +2014 3052 +2014 3377 +2014 3574 +2014 3790 +2014 3791 +2014 3792 +2014 3793 +228 176 +228 182 +228 229 +228 230 +228 231 +228 232 +228 233 +228 234 +228 235 +607 608 +607 609 +607 610 +607 611 +607 612 +607 613 +607 614 +607 615 +607 616 +4424 110 +4424 498 +4424 1804 +4424 2708 +4424 4885 +4424 5279 +4424 5280 +4424 5281 +4424 5282 +4424 5283 +4423 8 +4423 77 +4423 282 +4423 1143 +4423 1571 +4423 1765 +4423 2961 +4423 3138 +4423 4801 +4423 5282 +2958 458 +2958 669 +2958 852 +2958 1115 +2958 1786 +2958 1798 +2958 2255 +2958 2571 +2958 4136 +2773 557 +2773 583 +2773 810 +2773 832 +2773 1728 +2773 1866 +2773 2974 +2773 4304 +2773 4305 +4585 158 +4585 229 +4585 1591 +4585 2893 +4585 3316 +4585 3906 +4585 4098 +4585 4784 +4585 4839 +4585 5366 +5110 38 +5110 2018 +5110 2148 +5110 2666 +5110 3895 +5110 3935 +5110 4838 +5110 4855 +5110 5642 +5110 5643 +5113 893 +5113 1407 +5113 1590 +5113 1772 +5113 1862 +5113 2269 +5113 3716 +5113 4432 +5113 5291 +5113 5641 +5040 1010 +5040 2304 +5040 2392 +5040 2443 +5040 2853 +5040 3081 +5040 4507 +5040 5437 +5040 5612 +5040 5613 +2676 63 +4734 43 +5272 203 +5272 852 +5272 1614 +5272 1797 +5272 2652 +5272 2706 +5272 5735 +5272 5736 +5272 5737 +1319 121 +1319 147 +1319 248 +1319 252 +1319 264 +1319 390 +1319 423 +1319 559 +1319 667 +1319 1245 +720 4 +720 5 +720 8 +720 126 +720 145 +720 149 +720 353 +720 424 +720 2001 +720 2018 +5213 253 +5213 2330 +5213 2552 +5213 3883 +5213 5501 +5213 5705 +5213 5706 +5213 5707 +2699 3 +2699 122 +2699 127 +2699 143 +2699 146 +2699 177 +2699 238 +2699 249 +2699 352 +2699 856 +4778 712 +4778 1034 +4778 1345 +4778 1743 +4778 1807 +4778 2391 +4778 3110 +4778 4003 +4778 5485 +4778 5486 +3866 1549 +3866 2305 +3866 2310 +3866 2493 +3866 2806 +3866 3355 +3866 3960 +3866 4302 +3866 4968 +3866 4969 +1572 1127 +1572 1273 +1572 1550 +1572 1961 +1572 2400 +1572 2465 +1572 3356 +1572 3357 +1572 3358 +1572 3359 +1924 524 +1924 2451 +1924 2908 +1924 3051 +1924 3219 +1924 3867 +952 749 +952 796 +952 953 +952 954 +952 955 +952 956 +952 957 +952 958 +952 959 +952 960 +1519 561 +1519 725 +1519 756 +1519 982 +1519 1061 +1519 1120 +1519 1422 +1519 3348 +1519 3349 +1519 3350 +4337 165 +4337 1787 +4337 2539 +4337 4895 +4337 5222 +5587 5300 +1370 825 +1370 1371 +1370 1372 +1370 1373 +1370 1374 +1370 1375 +1370 1376 +1370 1377 +1370 1378 +244 338 +244 612 +244 1264 +244 1284 +244 2197 +244 2198 +244 2199 +244 2200 +244 2201 +244 2202 +3912 889 +3912 1367 +3912 3266 +3912 3856 +3912 4735 +3912 4894 +3912 4991 +3912 4992 +3912 4993 +3912 4994 +4336 4491 +2164 57 +2164 453 +2164 851 +2164 1049 +2164 2423 +2164 2648 +2164 2669 +2164 2906 +2164 3468 +2164 3906 +737 898 +737 1539 +737 2516 +737 2659 +737 2660 +737 2661 +737 2662 +737 2663 +741 31 +741 538 +741 1575 +741 2272 +741 2538 +741 2719 +741 2720 +741 2721 +741 2722 +741 2723 +742 1476 +742 1975 +742 2412 +742 2453 +742 2678 +742 2679 +742 2680 +742 2681 +742 2682 +742 2683 +1366 1152 +1366 2093 +1366 2215 +1366 2561 +1366 2789 +1366 3214 +1366 3215 +1366 3216 +1366 3217 +2293 118 +2293 717 +2293 771 +2293 1364 +2293 1365 +2293 1366 +2293 1946 +2293 2581 +2293 3985 +2293 3986 +709 200 +709 205 +709 541 +709 552 +709 710 +709 711 +709 712 +709 713 +709 714 +709 715 +845 127 +845 144 +845 145 +845 176 +845 177 +845 247 +845 265 +845 630 +845 698 +845 762 +4449 162 +4449 199 +4449 290 +4449 757 +4449 2151 +4449 5292 +4449 5293 +4449 5294 +4449 5295 +4449 5296 +4452 228 +4452 554 +4452 789 +4452 1957 +4452 2153 +4452 2612 +4452 3083 +4452 3539 +4452 3919 +4452 5297 +4937 1412 +4937 2162 +4937 2500 +4937 4012 +4937 4589 +4937 4811 +4937 4825 +4937 4889 +4937 5349 +4937 5578 +2388 261 +2388 937 +2388 1229 +2388 2225 +2388 2595 +2388 2948 +2388 3205 +2388 4072 +2388 4073 +2388 4074 +138 23 +138 446 +138 842 +138 1096 +138 1598 +138 1752 +138 2089 +138 2090 +138 2091 +1765 839 +1765 2420 +1765 2477 +1765 3086 +1765 3185 +1765 3193 +1765 3197 +1765 3301 +1765 3527 +958 180 +958 558 +958 584 +958 1249 +958 1540 +958 3491 +958 4123 +958 4892 +958 4973 +958 4974 +3930 1228 +3930 1777 +3930 1928 +3930 2933 +3930 3331 +3930 4461 +3930 5004 +3930 5005 +3930 5006 +3930 5007 +4360 381 +4360 1239 +4360 2568 +4360 3212 +4360 3566 +4360 4828 +4360 5232 +4360 5233 +4360 5234 +4362 437 +4362 906 +4362 2779 +4362 3687 +4362 3886 +4362 4286 +4362 5242 +4362 5243 +4362 5244 +4362 5245 +5066 164 +5066 523 +5066 815 +5066 2155 +5066 2237 +5066 2548 +5066 3407 +5066 4319 +5066 5159 +5066 5620 +5067 804 +5067 940 +5067 1710 +5067 2844 +5067 3407 +5067 4364 +5067 5434 +5067 5631 +5067 5632 +5067 5633 +5069 5623 +4263 11 +4263 20 +4263 1389 +4263 2628 +4263 2668 +4263 3080 +4263 3177 +4263 3945 +4263 4876 +4263 4980 +5600 4943 +2796 3 +2796 5 +2796 7 +2796 8 +2796 125 +2796 126 +2796 149 +2796 247 +2796 249 +2796 424 +4256 2613 +5644 643 +5644 877 +5644 1316 +5644 1335 +5644 1928 +5644 3027 +5644 4101 +5644 5916 +5644 5917 +2890 56 +2890 442 +2890 1279 +2890 2220 +2890 3156 +2890 3794 +2890 4368 +2890 4397 +2890 4398 +3890 3 +3890 123 +3890 129 +3890 251 +3890 264 +3890 367 +3890 426 +3890 427 +3890 718 +3890 2717 +28 846 +28 1516 +28 1517 +2290 10 +2290 121 +2290 128 +2290 145 +2290 266 +2290 352 +2290 422 +2290 559 +2290 666 +2290 1317 +766 17 +766 262 +766 1332 +766 1689 +766 1956 +766 2330 +766 2569 +766 2697 +766 2698 +766 2699 +767 1618 +767 1863 +767 2550 +767 2690 +767 2691 +767 2692 +767 2693 +767 2694 +767 2695 +767 2696 +773 2907 +1806 124 +1806 251 +1806 368 +1806 369 +1806 422 +1806 718 +1806 754 +1806 856 +1806 2018 +1806 3216 +1813 146 +1813 176 +1813 246 +1813 252 +1813 264 +1813 368 +1813 369 +1813 390 +1813 667 +1813 718 +2020 5 +2020 126 +2020 144 +2020 145 +2020 149 +2020 176 +2020 247 +2020 249 +2020 251 +2020 352 +4421 124 +4421 381 +4421 477 +4421 1655 +4421 2055 +4421 2169 +4421 2254 +4421 4129 +4421 5266 +4421 5272 +5406 38 +5406 740 +5406 1956 +5406 2060 +5406 2391 +5406 4170 +5406 5096 +5406 5510 +5406 5803 +5406 5804 +4784 122 +4784 123 +4784 124 +4784 127 +4784 129 +4784 248 +4784 845 +4784 2381 +4784 3305 +4784 5492 +3305 115 +3305 911 +3305 2189 +3305 2955 +3305 3189 +3305 3486 +3305 3524 +3305 3537 +3305 4469 +3305 4662 +3503 176 +3503 937 +3503 1275 +3503 1387 +3503 2829 +3503 3596 +3503 4097 +3503 4445 +3503 4606 +3503 4788 +6171 311 +6171 809 +6171 1022 +6171 1694 +6171 3403 +6171 3677 +6171 4014 +6171 4518 +6171 5988 +6171 6236 +4815 463 +4815 1676 +4815 2274 +4815 2860 +4815 2900 +4815 3149 +4815 3295 +4815 4352 +4815 5509 +1434 78 +1434 309 +1434 762 +1434 891 +1434 1019 +1434 1317 +1434 1435 +1434 1436 +1434 1437 +1434 1438 +5276 235 +5276 342 +5276 1591 +5276 3205 +5276 3428 +5276 4041 +5276 4740 +5276 5321 +5276 5747 +5276 5748 +25 1022 +3690 252 +3690 360 +3690 1224 +3690 1288 +3690 3868 +3690 4200 +3690 4884 +3690 4885 +3690 4886 +3690 4887 +475 1670 +475 1915 +475 2480 +475 2481 +475 2482 +475 2483 +475 2484 +475 2485 +475 2486 +475 2487 +4482 3 +4482 8 +4482 127 +4482 143 +4482 176 +4482 177 +4482 248 +4482 352 +4482 353 +4482 367 +1094 121 +1094 124 +1094 127 +1094 128 +1094 144 +1094 145 +1094 174 +1094 179 +1094 247 +1094 1246 +3507 738 +3507 1251 +3507 1458 +3507 1509 +3507 2077 +3507 2825 +3507 3249 +3507 4679 +3507 4789 +3507 4790 +4826 230 +4826 1192 +4826 2217 +4826 2360 +4826 3903 +4826 4112 +4826 4215 +4826 5300 +4826 5523 +4826 5524 +5045 1015 +5045 2869 +5045 3084 +5045 5056 +5045 5080 +5045 5096 +5045 5425 +5045 5614 +5045 5615 +5045 5616 +2626 4227 +4416 122 +4416 527 +4416 571 +4416 894 +4416 1027 +4416 2563 +4416 2615 +4416 4373 +4416 4719 +4416 5269 +4417 95 +4417 1197 +4417 1619 +4417 2079 +4417 2114 +4417 3253 +4417 3598 +4417 4303 +4417 4950 +4417 5175 +2530 63 +2530 933 +2530 1220 +2530 1618 +2530 2579 +2530 2626 +2530 3758 +2530 4155 +2530 4156 +2530 4157 +409 3 +409 146 +409 147 +409 175 +409 247 +409 248 +409 266 +409 368 +409 422 +409 2018 +655 1032 +655 1246 +655 1378 +655 1411 +655 1836 +655 1999 +655 2200 +655 2565 +655 2566 +655 2567 +3087 38 +3087 2571 +3087 2948 +3087 4134 +3087 4420 +3087 4510 +3087 4511 +3087 4512 +3087 4513 +3087 4514 +5281 7 +5281 174 +5281 390 +5281 699 +5281 753 +5281 754 +5281 762 +5281 2064 +5281 2077 +5281 3118 +5656 442 +5657 667 +5657 1923 +5657 2005 +5657 3083 +5657 3200 +5657 4234 +5657 4324 +5657 5016 +5657 5922 +1081 512 +1081 922 +1081 940 +1081 1720 +1081 2978 +1081 2979 +1081 2980 +1081 2981 +1081 2982 +1081 2983 +4112 7 +4112 8 +4112 145 +4112 148 +4112 174 +4112 266 +4112 424 +4112 856 +4112 2338 +5158 4402 +3571 199 +3571 293 +3571 364 +3571 659 +3571 1259 +3571 1266 +3571 2020 +3571 4831 +3571 4832 +3571 4833 +5421 2146 +1346 1730 +1346 1766 +1346 2503 +1346 2708 +1346 3177 +1346 3187 +1346 3188 +1346 3189 +1346 3190 +1346 3191 +67 472 +67 534 +67 762 +67 1123 +67 2222 +67 2789 +67 3052 +67 3332 +67 3769 +67 3956 +3152 769 +3152 1078 +3152 1409 +3152 2374 +3152 4116 +3152 4316 +3152 4442 +3152 4553 +3152 4554 +3152 4555 +3555 1039 +3555 1792 +3555 2314 +3555 4148 +3555 4350 +3555 4362 +3555 4675 +3555 4818 +3555 4819 +3555 4820 +1443 1444 +5535 2499 +5535 2670 +5535 2958 +5535 3067 +5535 3629 +5535 3674 +5535 4276 +5535 4840 +5535 5811 +5535 5835 +5078 531 +5078 605 +5078 810 +5078 813 +5078 924 +5078 1867 +5078 1868 +5078 2677 +5078 3336 +5078 5630 +1973 155 +1973 520 +1973 2020 +1973 2222 +1973 2889 +1973 3220 +1973 3595 +1973 3742 +1973 3743 +4692 532 +4692 2916 +4692 4371 +4692 4402 +4692 5425 +5273 680 +5273 1267 +5273 2268 +5273 2465 +5273 5757 +705 226 +705 352 +705 1594 +705 1600 +705 1641 +705 2625 +705 2626 +705 2627 +705 2628 +705 2629 +2329 103 +2329 1631 +2329 2114 +2329 3283 +2329 3329 +2329 3466 +2329 4027 +2329 4028 +2329 4029 +1401 510 +1401 677 +1401 736 +1401 2546 +1401 3169 +1401 3254 +1401 3255 +1401 3256 +1401 3257 +5267 3 +5267 9 +5267 122 +5267 125 +5267 126 +5267 145 +5267 149 +5267 174 +5267 247 +5267 1317 +5937 817 +5937 1652 +5937 3083 +5937 4075 +5937 5614 +5939 325 +5939 1007 +5939 1952 +5939 2477 +5939 3124 +5939 3416 +5939 3543 +5939 4877 +5939 5896 +5939 6072 +3315 1362 +3315 2087 +3315 2425 +3315 2999 +3315 3156 +3315 3849 +3315 4375 +3315 4559 +3315 4671 +3315 4672 +4852 554 +4852 763 +4852 1400 +4852 1881 +4852 4447 +4852 4645 +4852 5110 +4852 5527 +4852 5528 +4852 5529 +2803 633 +2803 942 +2803 2095 +2803 2307 +2803 2327 +2803 2870 +2803 2927 +2803 3204 +2803 3808 +2803 4310 +1872 356 +1872 458 +1872 1209 +1872 2383 +1872 3539 +1872 3619 +1872 3620 +1872 3621 +1872 3622 +1872 3623 +4467 2345 +4467 3097 +4467 3260 +4467 3314 +4467 5037 +4432 92 +4432 892 +4432 1217 +4432 1404 +4432 1989 +4432 4004 +4432 4031 +4432 4058 +4432 5277 +4432 5278 +599 437 +599 564 +599 581 +599 600 +599 601 +599 602 +599 603 +599 604 +599 605 +599 606 +1855 161 +1855 473 +1855 552 +1855 1670 +1855 1731 +1855 2563 +1855 3364 +1855 3572 +1855 3600 +1855 3601 +5156 3370 +4036 813 +4036 842 +4036 924 +4036 2904 +4036 2928 +4036 3058 +4036 3109 +4036 4248 +4036 4978 +5221 96 +5221 292 +5221 334 +5221 400 +5221 1122 +5221 1177 +5221 1377 +5221 2322 +5221 3306 +5221 5719 +2296 3987 +4382 4 +4382 124 +4382 146 +4382 247 +4382 249 +4382 367 +4382 427 +4382 559 +4382 718 +4382 754 +5263 124 +5263 143 +5263 147 +5263 247 +5263 390 +5263 422 +5263 423 +5263 427 +5263 2001 +5432 379 +5432 418 +5432 513 +5432 882 +5432 2354 +5432 2684 +5432 4779 +5432 5344 +5432 5734 +5432 5817 +1941 749 +1941 1362 +1941 2785 +1941 3136 +1941 3599 +1941 3708 +1941 3709 +1941 3710 +1941 3711 +1941 3712 +1943 13 +1943 279 +1943 646 +1943 1887 +1943 2545 +1943 3256 +1943 3515 +1943 3715 +1943 3716 +1943 3717 +5478 122 +5478 123 +5478 145 +5478 148 +5478 238 +5478 353 +5478 424 +5478 697 +5478 736 +5478 2001 +5479 2697 +5479 4065 +5479 5882 +1610 60 +1610 234 +1610 269 +1610 721 +1610 1539 +1610 1611 +1610 1612 +1610 1613 +1610 1614 +1610 1615 +1971 769 +1971 774 +1971 1127 +1971 1341 +1971 2847 +1971 3737 +1971 3738 +1971 3739 +1971 3740 +1971 3741 +5565 705 +5565 1029 +5565 1084 +5565 3765 +5565 3818 +5565 5874 +5565 5875 +5565 5876 +5565 5877 +5565 5878 +349 473 +349 855 +349 946 +349 1716 +349 2296 +349 2297 +349 2298 +349 2299 +349 2300 +407 412 +407 1217 +407 1749 +407 2392 +4038 2236 +4674 5283 +3369 104 +3369 391 +3369 860 +3369 1855 +3369 3014 +3369 4093 +3369 4120 +3369 4298 +3369 4714 +3369 4715 +5410 275 +5410 605 +5410 1123 +5410 1430 +5410 1818 +5410 2721 +5410 3919 +5410 5809 +5410 5810 +5410 5811 +967 15 +967 440 +967 669 +967 2855 +967 2856 +967 2857 +967 2858 +967 2859 +967 2860 +967 2861 +1202 3105 +5343 946 +5343 2414 +5343 2563 +5343 2780 +5343 3930 +5343 4245 +5343 4675 +5343 5300 +5343 5781 +5343 5782 +5589 203 +5589 697 +5589 750 +5589 913 +5589 2716 +5589 4156 +5589 4189 +5589 5407 +5589 5449 +504 3 +504 123 +504 125 +504 146 +504 264 +504 352 +504 353 +504 427 +504 1245 +504 1246 +5147 123 +5147 1321 +5147 3052 +5147 4213 +5147 4929 +5147 4998 +5147 5301 +5147 5653 +5147 5654 +5147 5655 +5135 184 +5135 613 +5135 2973 +5135 4111 +5135 5647 +5135 5648 +5135 5649 +5135 5650 +5135 5651 +5135 5652 +3092 1424 +3092 1524 +3092 2257 +3092 3053 +3092 3096 +3092 3105 +3092 3269 +3092 3716 +3092 4130 +3092 4532 +4788 1909 +4788 1942 +4788 2068 +4788 4183 +4788 4216 +4788 4653 +4788 5115 +4788 5304 +4788 5493 +4788 5494 +3867 1297 +3867 1866 +3867 1867 +3867 2356 +3867 2376 +3867 3329 +3867 3615 +3867 4828 +3867 4971 +3867 4972 +5515 8 +5515 123 +5515 124 +5515 127 +5515 179 +5515 247 +5515 367 +5515 390 +5515 423 +5515 1246 +5858 612 +1138 152 +1138 2013 +1138 2221 +1138 2770 +1138 2785 +1138 2848 +1138 3015 +1138 3016 +1138 3017 +1871 3491 +4175 5209 +4973 140 +4973 350 +4973 1066 +4973 3417 +4973 4324 +4973 4501 +4973 4752 +4973 5310 +4973 5463 +4973 5521 +5226 748 +5226 1316 +5226 1326 +5226 1487 +5226 2414 +5226 2639 +5226 2901 +5226 3192 +5226 3849 +5226 4765 +5227 480 +5227 1039 +5227 1654 +5227 3348 +5227 5138 +5227 5427 +5227 5721 +5227 5722 +5227 5723 +5227 5724 +1136 553 +1136 856 +1136 1137 +1136 1138 +1136 1139 +1136 1140 +1136 1141 +1136 1142 +1136 1143 +1136 1144 +5585 106 +5585 1949 +5585 2593 +5585 2594 +5585 2595 +5585 2892 +5585 3343 +5585 4613 +5585 5887 +5585 5888 +3148 3301 +4837 5525 +1154 538 +1154 738 +1154 744 +1154 921 +1154 1155 +1154 1156 +1154 1157 +1154 1158 +1154 1159 +1154 1160 +5359 4 +5359 125 +5359 175 +5359 352 +5359 368 +5359 558 +5359 717 +5359 856 +5359 1317 +5359 2338 +5950 9 +5950 147 +5950 149 +5950 238 +5950 252 +5950 266 +5950 426 +5950 666 +5950 717 +5950 2018 +5951 870 +5951 2348 +5951 3165 +5951 3550 +5951 3733 +5951 4093 +5951 5129 +5951 5644 +5951 6078 +5951 6079 +978 215 +978 314 +978 315 +978 1140 +978 2877 +978 2878 +978 2879 +978 2880 +978 2881 +978 2882 +4458 47 +4458 491 +4458 541 +4458 2869 +4458 3779 +4458 5118 +4458 5298 +4458 5299 +4458 5300 +4458 5301 +5608 65 +5608 311 +5608 612 +5608 2308 +5608 2566 +5608 3539 +5608 5004 +5608 5897 +5608 5898 +5608 5899 +3206 2909 +3206 3403 +3206 3489 +3206 4588 +3206 4589 +3208 559 +3208 1037 +3208 1122 +3208 1175 +3208 2018 +3208 2524 +3208 4005 +3208 4508 +3208 4592 +3208 4593 +4051 122 +4051 175 +4051 250 +4051 252 +4051 266 +4051 367 +4051 423 +4051 558 +4051 754 +4051 2001 +4358 124 +4358 250 +4358 264 +4358 266 +4358 368 +4358 423 +4358 427 +4358 559 +4358 2018 +5545 63 +5545 629 +5545 1034 +5545 1384 +5545 2078 +5545 2249 +5545 2386 +5545 2698 +5545 2780 +5545 3110 +5545 3517 +5545 4503 +5545 4838 +5545 6292 +5545 6293 +5545 6294 +5545 6295 +5548 4453 +5548 5012 +5548 5634 +5548 5871 +5548 5872 +5543 123 +5543 146 +5543 249 +5543 264 +5543 352 +5543 369 +5543 422 +5543 423 +5543 427 +5543 2338 +5498 144 +5498 145 +5498 147 +5498 148 +5498 149 +5498 175 +5498 367 +5498 390 +5498 718 +2145 262 +2145 1407 +2145 1637 +2145 1926 +2145 3900 +2145 3901 +2145 3902 +2145 3903 +2145 3904 +2145 3905 +1172 296 +1172 1173 +1172 1174 +1172 1175 +1172 1176 +1172 1177 +1172 1178 +1172 1179 +1172 1180 +5082 348 +5082 731 +5082 1233 +5082 1323 +5082 1506 +5082 3213 +5082 3356 +5082 3468 +5082 4893 +5082 5373 +2267 855 +2267 1323 +2267 1439 +2267 1808 +2267 3568 +2267 4275 +2267 4738 +2267 4806 +2267 6121 +2267 6122 +5012 266 +5012 440 +5012 826 +5012 852 +5012 2394 +5012 2552 +5012 3334 +5012 3456 +5012 4281 +181 182 +181 183 +181 184 +181 185 +181 186 +181 187 +181 188 +181 189 +181 190 +181 191 +2900 177 +2900 303 +2900 1487 +2900 2751 +2900 3142 +2900 3179 +2900 3544 +2900 4384 +2900 4385 +2900 4386 +5960 3304 +1616 288 +1616 1595 +1616 1617 +1616 1618 +1616 1619 +1616 1620 +1616 1621 +1616 1622 +1616 1623 +1616 1624 +1836 112 +1836 298 +1836 579 +1836 627 +1836 894 +1836 2485 +1836 2730 +1836 3569 +1836 3570 +2506 983 +2506 2223 +2506 2646 +2506 2733 +2506 3569 +2506 3772 +2506 3894 +2506 4061 +2506 4141 +2506 4142 +2992 928 +2992 1054 +2992 2906 +2992 2995 +2992 3681 +2992 4438 +2992 4439 +2992 4440 +2992 4441 +2992 4442 +4739 260 +4739 762 +4739 1333 +4739 3475 +4739 3504 +4739 3807 +4739 3851 +4739 5454 +4739 5455 +4740 908 +4740 942 +4740 991 +4740 1412 +4740 2162 +4740 2708 +4740 3767 +4740 4113 +4740 5457 +4740 5458 +2774 2440 +1419 740 +1419 1085 +1419 1131 +1419 1271 +1419 1420 +1419 1421 +1419 1422 +1419 1423 +1419 1424 +1419 1425 +1843 567 +1843 892 +1843 1021 +1843 2033 +1843 2853 +1843 3307 +1843 3573 +1843 3574 +1843 3575 +1843 3576 +1844 50 +1844 586 +1844 1064 +1844 1528 +1844 2221 +1844 3585 +1844 3586 +1844 3587 +1844 3588 +1844 3589 +4078 387 +4078 584 +4078 674 +4078 1670 +4078 2091 +4078 3091 +4078 4328 +4078 4467 +4078 5070 +4078 5071 +2452 77 +2452 1027 +2452 1321 +2452 1925 +2452 2373 +2452 3156 +2452 3849 +2452 4106 +2452 4107 +2452 4108 +2454 586 +2459 215 +2459 856 +2459 960 +2459 1103 +2459 1152 +2459 1402 +2459 1709 +2459 3165 +2459 3866 +2459 4109 +2460 892 +2460 1019 +2460 1342 +2460 1476 +2460 2530 +2460 2531 +2460 2532 +2460 3874 +2460 4110 +2460 4111 +722 2713 +4274 164 +4274 230 +4274 424 +4274 2017 +4274 2148 +4274 2787 +4274 3523 +4274 3988 +4274 4813 +4274 5178 +4276 5 +4276 7 +4276 125 +4276 126 +4276 147 +4276 149 +4276 175 +4276 266 +4276 667 +4276 754 +3913 204 +3913 607 +3913 804 +3913 1072 +3913 1605 +3913 1728 +3913 1780 +3913 3339 +3913 4995 +1930 190 +1930 814 +1930 923 +1930 1655 +1930 2900 +1930 3703 +1930 3704 +1930 3705 +1930 3706 +1930 3707 +3627 3022 +3627 3699 +3627 4867 +3627 4868 +3627 4869 +3628 352 +1229 1916 +1229 2140 +1229 2949 +1229 2984 +1229 3084 +1229 3085 +1229 3086 +1229 3087 +1229 3088 +3542 470 +3542 2304 +3542 4625 +3542 4788 +3542 4793 +3542 4811 +3542 4812 +3542 4813 +3542 4814 +3673 123 +3673 127 +3673 177 +3673 246 +3673 264 +3673 353 +3673 422 +3673 717 +3673 856 +3673 1245 +4782 1947 +4782 2524 +4782 2787 +4782 3140 +4782 3283 +4782 3288 +4782 3766 +4782 5487 +4782 5488 +4782 5489 +4813 300 +4813 1434 +4813 1487 +4813 1730 +4813 2541 +4813 2787 +4813 2881 +4813 5510 +2627 9 +2627 144 +2627 146 +2627 148 +2627 149 +2627 175 +2627 264 +2627 390 +2627 1245 +6004 583 +6004 1058 +6004 5292 +6004 5940 +6004 6112 +6004 6113 +6004 6114 +6004 6115 +6004 6116 +6006 230 +6006 1458 +6006 2649 +6006 3389 +6006 3794 +6006 6117 +6006 6118 +6006 6119 +6006 6120 +1687 721 +1687 1115 +1687 2359 +1687 3070 +1687 3100 +1687 3230 +1687 3439 +1687 3440 +1687 3441 +1687 3442 +2694 3363 +4381 89 +4381 691 +4381 3189 +4381 3314 +4381 3849 +4381 4344 +4381 4788 +4381 4934 +4381 5246 +4389 208 +4389 1173 +4389 1362 +4389 4164 +4389 5248 +4389 5249 +4390 339 +4390 527 +4390 1339 +4390 2066 +4390 2839 +4390 2973 +4390 3524 +4390 3661 +4390 4723 +4390 5250 +4391 1894 +225 199 +225 221 +225 893 +225 1343 +225 1749 +225 1861 +225 2177 +225 2178 +225 2179 +225 2180 +226 168 +226 314 +226 1114 +226 1564 +226 2171 +226 2172 +226 2173 +226 2174 +226 2175 +226 2176 +2678 2314 +2678 2481 +2678 2788 +2678 2828 +2678 3279 +2678 4251 +2678 4252 +2678 4253 +2678 4254 +2678 4255 +4792 769 +4792 874 +4792 1227 +4792 1894 +4792 2538 +4792 2670 +4792 4199 +4792 4338 +4792 4578 +4792 5327 +1586 4 +1586 8 +1586 147 +1586 148 +1586 174 +1586 352 +1586 368 +1586 424 +1586 856 +1586 2098 +6070 1087 +6070 1512 +6070 2857 +6070 3593 +6070 3841 +6070 3948 +6070 4159 +6070 4844 +6070 5373 +6070 5436 +1292 3149 +2807 143 +2807 249 +2807 264 +2807 390 +2807 423 +2807 559 +2807 1842 +2807 4312 +2807 4313 +2807 4314 +2501 5 +2501 123 +2501 125 +2501 126 +2501 129 +2501 144 +2501 148 +2501 149 +2501 248 +2501 1317 +2503 132 +2503 181 +2503 397 +2503 707 +2503 1786 +2503 2750 +2503 2751 +2503 3801 +2503 3995 +2503 4136 +4187 31 +4187 144 +4187 145 +4187 146 +4187 149 +4187 180 +4187 266 +4187 423 +4187 856 +4187 1317 +4269 4797 +1737 710 +1737 740 +1737 2246 +1737 2758 +1737 3093 +1737 3236 +1737 3243 +1737 3528 +1737 3529 +1739 3 +1739 123 +1739 125 +1739 179 +1739 251 +1739 352 +1739 353 +1739 369 +1739 427 +1739 1317 +3802 478 +3805 2059 +3805 2238 +3805 4508 +3805 5001 +3805 5848 +3805 5849 +3805 5850 +3805 5851 +3805 5852 +3805 5853 +5827 3077 +5827 3964 +5827 4614 +5827 5323 +5827 6059 +5827 6060 +5828 122 +5828 246 +5828 264 +5459 385 +5459 870 +5459 1048 +5459 1980 +5459 4793 +5459 5831 +5459 5832 +5459 5833 +5459 5834 +1577 550 +1577 1578 +6045 5338 +6046 73 +6046 177 +6046 1974 +6046 3022 +6046 3088 +6046 4465 +6046 4511 +6046 4580 +6046 5962 +6046 6139 +6047 5754 +448 108 +448 128 +448 148 +448 878 +448 1317 +448 1376 +448 1556 +448 1912 +448 2439 +448 2440 +1063 2493 +1063 2987 +1063 2988 +1063 2989 +1063 2990 +1063 2991 +1063 2992 +1063 2993 +1063 2994 +1063 2995 +3536 751 +3536 1802 +3536 3795 +3536 3918 +3536 4804 +3536 4805 +3536 4806 +3536 4807 +3537 123 +3537 126 +3537 145 +3537 149 +3537 177 +3537 352 +3537 353 +3537 424 +3537 558 +3537 754 +3539 47 +3539 503 +3539 1342 +3539 3460 +3539 4199 +3539 4281 +3539 4727 +3539 4808 +3539 4809 +3539 4810 +1438 173 +1438 202 +1438 222 +1438 685 +1438 1421 +1438 1534 +1438 3291 +1438 3292 +1438 3293 +1438 3294 +5682 364 +5682 852 +5682 1700 +5682 1910 +5682 1945 +5682 2085 +5682 3299 +5682 4891 +5682 5116 +5682 5837 +6049 157 +6049 500 +6049 664 +6049 1017 +6049 1715 +6049 2991 +6049 3293 +6049 6140 +6049 6141 +6049 6142 +701 118 +701 499 +701 506 +701 702 +701 703 +701 704 +701 705 +701 706 +701 707 +701 708 +5339 124 +5339 147 +5339 175 +5339 247 +5339 250 +5339 367 +5339 368 +5339 369 +5339 559 +5339 754 +634 308 +634 503 +634 717 +634 2941 +634 2968 +634 3112 +634 5880 +634 6131 +634 6132 +634 6133 +4338 56 +4338 363 +4338 432 +4338 554 +4338 1859 +4338 3608 +4338 4143 +4338 4151 +4338 4929 +4338 5225 +4340 1255 +4340 1300 +4340 1591 +4340 1792 +4340 2112 +4340 2164 +4340 3893 +4340 5141 +4340 5223 +4340 5224 +5802 4273 +3910 122 +3910 124 +3910 127 +3910 143 +3910 247 +3910 264 +3910 352 +3910 353 +3910 390 +3910 1245 +1341 63 +1341 435 +1341 740 +1341 1754 +1341 2125 +1341 2217 +1341 2524 +1341 2740 +1341 3204 +1341 3205 +1360 968 +1360 1561 +1360 2356 +1360 2918 +1360 3223 +5102 23 +5102 1022 +5102 1044 +5102 1867 +5102 3414 +5102 3488 +5102 4039 +5102 5475 +5102 5637 +5102 5638 +1995 3767 +1996 909 +1996 1297 +1996 1535 +1996 1571 +1996 2201 +1996 2265 +1996 2942 +1996 3193 +1996 3765 +1996 3766 +1998 3770 +2003 442 +2003 494 +2003 918 +2003 1326 +2003 3230 +2003 3773 +2003 3774 +2003 3775 +2003 3776 +2003 3777 +4378 255 +4378 363 +4378 741 +4378 869 +4378 1456 +4378 1762 +4378 2485 +4378 3109 +4378 4854 +4378 5251 +996 77 +996 997 +996 998 +3560 126 +3560 224 +3560 756 +3560 820 +3560 821 +3560 1362 +3560 3105 +3560 4450 +3560 4821 +3560 4822 +1440 292 +1440 1177 +1440 1557 +1440 1718 +1440 2656 +1440 3302 +1440 3303 +1440 3304 +1440 3305 +1440 3306 +2315 458 +2315 869 +2315 881 +2315 1447 +2315 2886 +2315 3547 +2315 4000 +2315 4001 +2315 4002 +2315 4003 +2318 1021 +2318 2538 +2318 3763 +2318 3789 +2318 4008 +2318 4009 +2318 4010 +2318 4011 +2318 4012 +2318 4013 +5701 603 +5701 1552 +5701 1720 +5701 2081 +5701 2177 +5701 2933 +5701 3224 +5701 3543 +5701 3743 +5701 5406 +5695 1384 +5695 2219 +5695 5254 +5695 5975 +4900 5 +4900 8 +4900 121 +4900 129 +4900 149 +4900 174 +4900 179 +4900 249 +4900 251 +4900 352 +4902 996 +4902 2868 +4902 3188 +4902 3580 +4902 3804 +4902 4563 +4902 4903 +4902 5556 +4902 5557 +4902 5558 +4903 2679 +4903 3195 +4903 3822 +4903 4732 +4903 5056 +4903 5559 +4903 5560 +4903 5561 +4903 5562 +5703 789 +3236 17 +3236 145 +3236 175 +3236 179 +3236 180 +3236 424 +3236 717 +3236 736 +3236 754 +3236 2001 +3276 5 +3276 8 +3276 31 +3276 149 +3276 176 +3276 352 +3276 353 +3276 558 +3276 754 +6110 1084 +6110 2117 +6110 2276 +6110 3252 +6110 3257 +6110 3531 +6110 5557 +6110 5600 +6110 6195 +6110 6196 +6111 554 +6111 839 +6111 967 +6111 1267 +6111 3227 +6111 3327 +6111 3481 +6111 4914 +6111 5601 +3544 3 +3544 121 +3544 124 +3544 143 +3544 174 +3544 177 +3544 264 +3544 426 +3544 427 +3544 717 +6174 5 +6174 7 +6174 8 +6174 121 +6174 149 +6174 247 +6174 353 +6174 424 +6174 754 +6174 1317 +6175 4 +6175 125 +6175 148 +6175 559 +6175 697 +6175 754 +6175 856 +6175 1317 +6175 5710 +5603 1094 +5603 1495 +5603 1597 +5603 1608 +5603 1788 +5603 2689 +5603 3053 +5603 4295 +5603 4702 +5603 5895 +5909 282 +5909 342 +5909 1805 +5909 2612 +5909 3963 +5909 4170 +5909 4333 +5909 4365 +5909 5729 +6108 76 +6108 131 +6108 1023 +6108 1863 +6108 2080 +6108 2127 +6108 3677 +6108 3962 +6108 4260 +6108 6182 +6181 8 +6181 122 +6181 177 +6181 247 +6181 249 +6181 251 +6181 266 +6181 353 +6181 422 +6181 718 +5380 1001 +5901 664 +5901 2663 +5901 3415 +5901 3906 +5901 5407 +5901 5415 +5901 5781 +5901 6054 +5901 6055 +6180 129 +6180 1351 +6180 2068 +6180 2360 +6180 3886 +6180 4009 +6180 5729 +6180 6243 +6180 6244 +6180 6245 +1369 256 +1369 308 +1369 860 +1369 1457 +1369 1767 +1369 1817 +1369 3219 +1369 3220 +1369 3221 +1369 3222 +6163 491 +6163 744 +6163 851 +6163 2202 +6163 2583 +6163 3089 +6163 3601 +6163 5826 +6163 6041 +6163 6233 +6165 255 +6165 376 +6165 777 +6165 1229 +6165 3190 +6165 3683 +6165 4757 +6165 4885 +6165 5593 +6165 5801 +5529 345 +5529 2377 +5529 3285 +5529 3334 +5529 4160 +5529 4735 +5529 4986 +5529 5168 +5529 5866 +5529 5867 +5970 86 +5970 477 +5970 586 +5970 1240 +5970 1770 +5970 4756 +5970 4844 +5970 5627 +5970 6090 +6288 77 +6288 5097 +6288 5211 +6288 6287 +6288 6296 +1082 3 +1082 7 +1082 8 +1082 124 +1082 126 +1082 144 +1082 238 +1082 248 +1082 352 +1082 427 +5073 363 +5073 462 +5073 518 +5073 1047 +5073 2127 +5073 2612 +5073 3083 +5073 4408 +5073 5624 +5073 5625 +5504 505 +5504 3293 +5504 3778 +5504 4293 +5504 4458 +5504 5121 +5504 5703 +5504 5792 +5504 5854 +5504 5855 +5962 249 +5962 266 +5962 367 +5962 422 +5962 559 +5962 695 +5962 736 +5962 754 +5962 3677 +5168 229 +5168 1039 +5168 1192 +5168 1458 +5168 2127 +5168 2974 +5168 4563 +5168 5678 +5168 5679 +5168 5680 +5965 179 +5965 1335 +5965 2361 +5965 2487 +5965 3388 +5965 5514 +5965 5626 +5965 5989 +5965 6088 +5965 6089 +3919 7 +3919 219 +3919 256 +3919 424 +3919 1602 +3919 2119 +3919 2364 +3919 3120 +3919 4756 +3919 4996 +3920 49 +3920 1056 +3920 1512 +3920 1739 +3920 2789 +3920 3322 +3920 4412 +3920 4597 +3920 4716 +3920 4997 +4137 264 +4137 385 +4137 1227 +4137 1281 +4137 1310 +4137 3266 +4137 4077 +4137 4345 +4137 4362 +4137 4739 +5716 206 +5716 941 +5716 2037 +5716 2823 +5716 4639 +5716 4694 +5716 4809 +5716 5944 +5716 5945 +5716 5946 +2883 337 +2883 409 +2883 1289 +2883 1473 +2883 2321 +2883 2744 +2883 3565 +2883 4365 +2883 4366 +2883 4367 +4596 133 +4596 3949 +4596 4426 +4596 5308 +4596 5370 +4596 5371 +4596 5372 +4596 5373 +4596 5374 +4596 5375 +4598 4 +4598 146 +4598 180 +4598 250 +4598 368 +4598 390 +4598 697 +4598 1245 +4598 1317 +1932 364 +1932 685 +1932 921 +1932 1313 +1932 1829 +1932 2644 +1932 3018 +1932 3713 +1932 3714 +4445 4 +4445 127 +4445 143 +4445 247 +4445 249 +4445 250 +4445 369 +4445 559 +4445 667 +4445 2001 +89 211 +89 914 +89 1476 +89 1776 +89 1906 +89 1976 +89 2010 +89 2011 +89 2012 +89 2013 +2962 823 +2962 1457 +2962 2397 +2962 2637 +2962 2873 +2962 2898 +2962 3127 +2962 3992 +2962 4443 +314 121 +314 147 +314 177 +314 248 +314 249 +314 252 +314 264 +314 266 +314 423 +314 1245 +1276 901 +1276 2075 +1276 2585 +1276 2874 +1276 3128 +1276 3153 +1276 3154 +1276 3155 +1276 3156 +1276 3157 +1279 1227 +1279 1787 +1279 1993 +1279 2626 +1279 3017 +1279 3128 +1279 3129 +1279 3130 +1279 3131 +1279 3132 +1281 483 +1281 833 +1281 1431 +1281 1509 +1281 2034 +1281 2236 +1281 3133 +1281 3134 +1281 3135 +1281 3136 +1284 148 +1284 174 +1284 266 +1284 368 +1284 369 +1284 423 +1284 427 +1284 559 +1284 1245 +1284 1317 +4420 224 +4420 281 +4420 386 +4420 1401 +4420 3358 +4420 3448 +4420 3590 +4420 5270 +4420 5271 +2223 107 +2223 883 +2223 1021 +2223 1048 +2223 1175 +2223 1269 +2223 1936 +2223 2414 +2223 3868 +2223 3930 +4456 9 +4456 126 +4456 143 +4456 144 +4456 145 +4456 148 +4456 179 +4456 423 +4456 697 +4748 1337 +4748 1981 +4748 2383 +4748 3775 +4748 3810 +4748 4598 +4748 5102 +4748 5464 +4748 5465 +4748 5466 +4999 123 +4999 149 +4999 179 +4999 427 +508 260 +508 452 +508 487 +508 509 +508 510 +508 511 +508 512 +508 513 +508 514 +508 515 +5531 1945 +5531 1955 +5531 2062 +5531 2399 +5531 2617 +5531 2850 +5531 2874 +5531 5405 +5531 5902 +5531 5903 +5532 8 +5532 17 +5532 126 +5532 129 +5532 147 +5532 250 +5532 422 +5532 424 +5532 3937 +588 589 +588 590 +588 591 +588 592 +588 593 +588 594 +588 595 +588 596 +588 597 +588 598 +1821 112 +1821 690 +1821 703 +1821 1636 +1821 1703 +1821 1822 +1821 1823 +1821 1824 +1821 1825 +1821 1826 +302 1233 +302 2519 +5691 3481 +617 618 +617 619 +617 620 +617 621 +617 622 +617 623 +617 624 +617 625 +617 626 +617 627 +734 623 +734 893 +734 1412 +734 1734 +734 2015 +734 2582 +734 2631 +734 2684 +734 2685 +734 2686 +1627 364 +1627 442 +1627 2278 +1627 3384 +1627 3385 +4076 175 +4076 251 +4076 252 +4076 266 +4076 292 +4076 390 +4076 422 +4076 558 +4076 856 +4076 3933 +5618 637 +5618 969 +5618 1039 +5618 1311 +5618 1541 +5618 2444 +5618 2646 +5618 4798 +5618 5904 +5618 5905 +1633 83 +1633 831 +1633 1634 +1633 1635 +1633 1636 +1633 1637 +1633 1638 +1633 1639 +1633 1640 +6036 474 +6036 810 +6036 1332 +6036 1458 +6036 1842 +6036 3213 +6036 3411 +6036 3658 +6036 3913 +6036 6137 +6038 50 +6038 190 +6038 1376 +6038 1557 +6038 1689 +6038 2254 +6038 2354 +6038 2414 +6038 2657 +6038 2750 +33 34 +33 35 +33 36 +33 37 +33 38 +33 39 +33 40 +33 41 +33 42 +33 43 +1729 23 +1729 1058 +1729 1594 +1729 1647 +1729 1679 +1729 1730 +1729 1731 +1729 1732 +1729 1733 +1729 1734 +4510 157 +4510 158 +4510 442 +4510 1317 +4510 4177 +4510 4958 +4510 5328 +4510 5329 +4510 5330 +4557 41 +4557 804 +4557 2247 +4557 2536 +4557 3996 +4557 4459 +4557 5162 +4557 5300 +4557 5346 +4557 5347 +1331 390 +1331 548 +1331 892 +1331 1332 +1331 1333 +1331 1334 +1331 1335 +1331 1336 +1331 1337 +1331 1338 +1046 3 +1046 17 +1046 31 +1046 146 +1046 147 +1046 175 +1046 250 +1046 368 +1046 1245 +3088 121 +3088 122 +3088 123 +3088 125 +3088 127 +3088 144 +3088 174 +3088 352 +3088 369 +3088 1317 +5043 2557 +2351 1248 +2351 1335 +2351 1779 +2351 2669 +2351 2792 +2351 3172 +2351 3580 +2351 3935 +2351 4035 +2352 63 +2352 738 +2352 1556 +2352 1949 +2352 2279 +2352 2699 +2352 3204 +2352 3863 +2352 4039 +2352 4040 +1009 77 +1009 784 +1009 1010 +1009 1011 +1009 1012 +1009 1013 +1009 1014 +1009 1015 +1009 1016 +1009 1017 +1191 116 +1191 1076 +1191 1079 +1191 1331 +1191 1339 +1191 1340 +1191 1341 +1191 1342 +1191 1343 +1191 1344 +2921 296 +2921 828 +2921 944 +2921 1456 +2921 2354 +2921 3139 +2921 3779 +2921 4248 +2921 4407 +2921 4408 +3790 256 +3790 413 +3790 459 +3790 1305 +3790 1940 +3790 2113 +3790 2841 +3790 3288 +3790 4160 +3790 4581 +232 2223 +608 2026 +610 881 +610 1217 +610 1392 +610 1990 +610 2273 +610 2558 +610 2559 +610 2560 +610 2561 +610 2562 +611 532 +611 586 +611 740 +611 808 +611 1500 +611 2265 +611 2480 +611 2543 +611 2544 +611 2545 +613 1631 +613 2337 +613 2453 +613 2546 +613 2547 +613 2548 +613 2549 +613 2550 +613 2551 +5279 1402 +5279 2035 +5279 3080 +5279 4882 +5279 5749 +5366 942 +5366 1456 +5366 2230 +5366 2366 +5366 2612 +5366 2841 +5366 2982 +5366 3707 +5366 5798 +5643 5918 +5613 1454 +5613 2191 +5613 3328 +5613 3574 +5613 4885 +5613 5576 +5613 5704 +5613 5784 +5613 5887 +5613 5896 +5735 1120 +5735 1375 +5735 2027 +5735 3109 +5735 3335 +5735 3930 +5735 4986 +5735 5956 +5735 5957 +5707 823 +1743 849 +1743 2016 +1743 2648 +1743 2735 +1743 2781 +1743 2836 +1743 3188 +1743 3500 +1743 3501 +1743 3502 +4003 3 +4003 8 +4003 127 +4003 143 +4003 177 +4003 248 +4003 352 +4003 353 +4003 367 +4003 424 +5486 1056 +5486 1160 +5486 1199 +5486 2709 +5486 3489 +5486 3977 +5486 4332 +5486 5836 +5486 5837 +5486 5838 +3355 584 +3355 1837 +3355 2629 +3355 3035 +3355 3319 +3355 3335 +3355 4693 +3355 4694 +3355 4695 +3355 4696 +3356 127 +3356 128 +3356 246 +3356 248 +3356 352 +3356 353 +3356 422 +3356 427 +3356 667 +3356 856 +956 2836 +3348 124 +3348 128 +3348 146 +3348 147 +3348 176 +3348 238 +3348 249 +3348 264 +3348 368 +3348 718 +5222 3301 +2659 945 +2659 1489 +2659 2086 +2659 2411 +2659 2982 +2659 3684 +2659 4245 +2659 4246 +2679 10 +2679 148 +2679 265 +2679 369 +2679 427 +2679 698 +2679 754 +2679 947 +2679 2064 +2679 4257 +2680 1466 +2680 1685 +2680 2881 +2680 3023 +2680 3207 +2680 3247 +2680 4095 +2680 4237 +2680 4256 +2682 4173 +3985 563 +3985 1846 +3985 2489 +3985 2517 +3985 3819 +3985 3863 +3985 3988 +3985 4241 +3985 4565 +3985 5023 +3986 531 +3986 749 +3986 1279 +3986 2207 +3986 2383 +3986 2864 +3986 4087 +3986 4734 +3986 5026 +3986 5027 +5292 1240 +5292 3029 +5292 4641 +5292 5159 +5292 5766 +5294 64 +5294 2633 +5294 3205 +5294 3218 +5294 4205 +5294 4939 +5294 5759 +5294 5760 +5294 5761 +5294 5762 +4073 134 +4073 1224 +4073 1250 +4073 1739 +4073 1862 +4073 2050 +4073 3460 +4073 4262 +4073 5072 +4073 5073 +1752 83 +1752 690 +1752 1022 +1752 2198 +1752 2311 +1752 3272 +1752 3516 +1752 3517 +1752 3518 +1752 3519 +3086 327 +3086 1087 +3086 1689 +3086 2195 +3086 3823 +3086 4505 +3086 4506 +3086 4507 +3086 4508 +3086 4509 +3197 585 +3197 1036 +3197 1730 +3197 1797 +3197 2556 +3197 2997 +3197 3619 +3197 3808 +3197 4582 +3197 4583 +5007 1880 +5007 2841 +5007 3460 +5007 4111 +5007 4619 +5007 5594 +5007 5595 +5007 5596 +5007 5597 +5007 5598 +1710 1711 +5623 212 +5623 531 +5623 1094 +5623 1665 +5623 2298 +5623 2468 +5623 5378 +5623 5906 +5623 5907 +5623 5908 +2698 470 +2698 802 +2698 928 +2698 958 +2698 1067 +2698 1590 +2698 3995 +2698 4137 +2698 4270 +2698 4271 +2550 2163 +5096 145 +5096 359 +5096 427 +5096 605 +5096 881 +5096 1861 +5096 3402 +5096 3550 +5096 5635 +5096 5636 +5804 1538 +5804 3345 +5804 3702 +5804 4939 +5804 5988 +5804 5992 +5804 5993 +5804 5994 +5804 5995 +5804 5996 +5492 163 +5492 1968 +5492 2648 +5492 4844 +5492 5475 +5492 5767 +5492 5841 +5492 5842 +5492 5843 +5492 5844 +4662 828 +4662 1195 +4662 2698 +4662 2773 +4662 2891 +4662 3595 +4662 4770 +4662 4848 +4662 5392 +4662 5411 +2829 43 +2829 122 +2829 123 +2829 251 +2829 423 +2829 1228 +2829 1245 +2829 1679 +2829 1721 +2829 4334 +4606 862 +4606 1458 +4606 1900 +4606 3220 +4606 3221 +4606 4287 +4606 4586 +4606 5377 +4606 5378 +4606 5379 +1676 3 +1676 5 +1676 7 +1676 8 +1676 122 +1676 123 +1676 149 +1676 174 +1676 251 +1676 717 +2860 122 +2860 127 +2860 143 +2860 177 +2860 179 +2860 367 +2860 369 +2860 390 +2860 422 +2860 718 +5509 1405 +5509 2218 +5509 3288 +5509 4501 +5509 4854 +5509 5859 +5509 5860 +5509 5861 +5509 5862 +2485 33 +2485 100 +2485 568 +2485 2422 +2485 2588 +2485 2654 +2485 3335 +2485 4124 +2485 4125 +2485 4126 +4790 547 +4790 909 +4790 1007 +4790 1812 +4790 2928 +4790 3033 +4790 4558 +4790 5050 +4790 5495 +4790 5496 +5523 241 +1015 503 +1015 535 +1015 673 +1015 840 +1015 979 +1015 2916 +1015 2917 +1015 2918 +1015 2919 +5425 415 +5425 1158 +5425 1383 +5425 2059 +5425 2677 +5425 2869 +5425 3213 +5425 3516 +5425 4377 +5425 5616 +5614 4415 +5616 133 +5616 813 +5616 1533 +5616 2215 +5616 2391 +5616 2625 +5616 2847 +5616 3836 +5616 4484 +4157 5096 +4513 904 +4513 1524 +4513 2164 +4513 2710 +4513 3241 +4513 3303 +4513 3478 +4513 5191 +4513 5336 +4513 5337 +1266 906 +4833 1056 +4833 1539 +4833 1974 +4833 2020 +4833 2114 +4833 2755 +4833 3277 +4833 4810 +4833 5521 +4833 5522 +3190 123 +3190 124 +3190 367 +3190 368 +3190 667 +3190 857 +3190 1208 +3190 4577 +3190 4578 +3190 4579 +4442 522 +4442 837 +4442 1034 +4442 2670 +4442 3110 +4442 3141 +4442 3448 +4442 3737 +4442 5291 +5811 222 +5811 342 +5811 2324 +5811 2445 +5811 2475 +5811 2612 +5811 4131 +5811 4597 +5811 4885 +5630 290 +5630 380 +5630 3299 +5630 5914 +5630 5915 +3742 979 +3742 1730 +3742 2204 +3742 2215 +3742 2556 +3742 3020 +3742 3523 +3742 4285 +3742 4408 +3742 4411 +5757 4570 +1594 1595 +1600 127 +1600 248 +1600 264 +1600 367 +1600 390 +1600 422 +1600 423 +1600 559 +1600 666 +1600 667 +1641 604 +1641 1077 +1641 1097 +1641 1642 +1641 1643 +1641 1644 +1641 1645 +1641 1646 +1641 1647 +3254 1067 +3255 127 +3255 146 +3255 250 +3255 367 +3255 369 +3255 423 +3255 697 +3255 754 +3255 856 +3256 762 +3256 1361 +3256 2222 +3256 2753 +3256 3358 +3256 3467 +3256 4139 +3256 4636 +3256 4637 +4447 416 +4447 1287 +4447 2621 +4447 2886 +4447 4260 +4447 4462 +4447 4921 +4447 5288 +4447 5289 +4447 5290 +1404 228 +1404 2429 +1404 2477 +1404 2755 +1404 3274 +1404 3275 +1404 3276 +1404 3277 +1404 3278 +1404 3279 +5882 261 +5882 337 +5882 442 +5882 1530 +5882 1952 +5882 3732 +5882 3989 +5882 5086 +5882 5261 +5882 5546 +1612 1724 +1612 2222 +1612 3377 +1612 3378 +3765 921 +3765 4586 +3765 4796 +3765 4918 +3765 4919 +104 2025 +5809 4 +5809 7 +5809 8 +5809 126 +5809 129 +5809 144 +5809 175 +5809 179 +5809 1317 +4245 437 +4245 481 +4245 505 +4245 870 +4245 1137 +4245 1741 +4245 1780 +4245 2114 +4245 2535 +4245 4166 +5654 3 +5654 123 +5654 124 +5654 127 +5654 247 +5654 369 +5654 390 +5654 666 +5654 667 +5654 856 +5650 5921 +5651 290 +5651 2379 +5651 2898 +5651 3367 +5651 3489 +5651 5288 +5651 5887 +5651 5919 +5651 5920 +5304 113 +5304 2313 +5304 2932 +5304 3017 +5304 3134 +5304 4702 +5304 5281 +5304 5299 +5304 5510 +5304 5657 +1155 823 +1155 824 +1155 955 +1155 2394 +1155 2966 +1155 3034 +1155 3035 +1155 3036 +1155 3037 +1155 3038 +6078 14 +6078 36 +6078 1100 +6078 1291 +6078 1824 +6078 1859 +6078 2275 +6078 3035 +6078 4813 +6078 6169 +6079 458 +6079 944 +6079 983 +6079 3981 +6079 5016 +6079 5115 +6079 5790 +6079 5802 +6079 6170 +2879 5 +2879 31 +2879 125 +2879 126 +2879 148 +2879 175 +2879 179 +2879 238 +2879 353 +2879 558 +5897 758 +5897 918 +5897 919 +5897 1865 +5897 5562 +5897 5576 +5897 6050 +5897 6051 +5897 6052 +5897 6053 +5899 17 +5899 96 +5899 3376 +5899 4024 +5899 4987 +5899 5230 +5899 5341 +5899 6056 +5899 6057 +5899 6058 +4508 125 +4508 129 +4508 145 +4508 174 +4508 180 +4508 353 +4508 559 +4508 697 +4508 717 +4508 1317 +4593 227 +4593 727 +4593 802 +4593 945 +4593 1347 +4593 1956 +4593 2884 +4593 3485 +4593 4324 +4593 5369 +6293 117 +6293 274 +6293 788 +6293 1100 +6293 2249 +6293 2635 +6293 3344 +6293 5155 +6293 5685 +6293 6300 +1174 1178 +1174 1233 +1174 1439 +1174 1491 +1174 1946 +1174 3050 +1174 3051 +1174 3052 +1174 3053 +5457 438 +5457 908 +5457 991 +5457 3767 +5457 4486 +5457 4487 +5457 5554 +5457 5829 +5457 5830 +5458 2719 +2440 1881 +2440 4957 +2440 5304 +2440 5305 +3573 184 +3573 412 +3573 725 +3573 2119 +3573 2461 +3573 3602 +3573 4382 +3573 4445 +3573 4834 +3573 4835 +3575 1842 +3588 4813 +4106 452 +4106 453 +4106 1587 +4106 3404 +4106 5081 +1605 102 +1605 430 +1605 472 +1605 1024 +1605 1297 +1605 1381 +1605 1606 +1605 1607 +1605 1608 +1605 1609 +4995 800 +4995 1590 +4995 1600 +4995 1872 +4995 2860 +4995 2930 +4995 3674 +4995 5291 +4995 5590 +3703 459 +3703 1171 +3703 1822 +3703 3193 +3703 3204 +3703 3767 +3703 3778 +3703 4813 +3703 4893 +300 218 +300 301 +300 302 +300 303 +300 304 +300 305 +300 306 +300 307 +300 308 +300 309 +6114 424 +6114 858 +6114 1629 +6114 5962 +6114 6189 +6114 6190 +6114 6191 +6114 6192 +6114 6193 +6114 6194 +3100 303 +3100 1017 +3100 1221 +3100 1941 +3100 2932 +3100 3123 +3100 3722 +3100 3788 +3100 4171 +3100 4544 +5250 5733 +1343 351 +1343 1168 +1343 1504 +1343 1764 +1343 1765 +1343 2585 +1343 3195 +1343 3196 +1343 3197 +1343 3198 +2178 17 +2178 31 +2178 123 +2178 126 +2178 145 +2178 149 +2178 176 +2178 697 +2178 1317 +2171 3907 +2172 96 +2172 604 +2172 828 +2172 1291 +2172 1575 +2172 1961 +2172 2533 +2172 2555 +2172 3020 +2172 3713 +2174 1144 +4252 115 +4252 760 +4252 1672 +4252 1838 +4252 1955 +4252 2690 +4252 4301 +4252 4961 +4252 4976 +4253 5169 +4255 1146 +4255 1635 +4255 2694 +4255 2936 +4255 3181 +4255 3813 +4255 4578 +4255 5166 +4255 5167 +4255 5168 +4312 280 +4312 492 +4312 704 +4312 1084 +4312 1862 +4312 2847 +4312 3717 +4312 5206 +4312 5207 +4312 5208 +3528 305 +3528 707 +3528 2285 +3528 2869 +3528 4726 +3528 4797 +3528 4798 +3528 4799 +3528 4800 +3528 4801 +3529 127 +3529 146 +3529 180 +3529 249 +3529 266 +3529 559 +3529 754 +3529 1245 +3529 2001 +6059 683 +6060 174 +6060 179 +6060 251 +6060 351 +6060 983 +5831 8 +5831 36 +5831 57 +5831 75 +5831 102 +5831 252 +5831 311 +5831 383 +5831 582 +5831 583 +5831 611 +5831 634 +5831 654 +5831 1157 +5831 1173 +5831 1477 +5831 1872 +5831 1890 +5831 1931 +5831 2248 +5831 2746 +5831 2767 +5831 2931 +5831 2941 +5831 3115 +5831 3161 +5831 3343 +5831 3981 +5831 4115 +5831 4159 +5831 4303 +5831 5184 +5831 5528 +5831 5872 +5831 5931 +5831 5932 +5831 6012 +5831 6013 +5831 6014 +5831 6015 +5831 6016 +5831 6017 +5831 6018 +5831 6019 +5831 6020 +5831 6021 +5831 6022 +5831 6023 +5834 124 +5834 177 +5834 248 +5834 249 +5834 1245 +6139 187 +6139 257 +6139 301 +6139 558 +6139 1017 +6139 1052 +6139 1797 +6139 3837 +6139 5765 +6139 6197 +6139 6198 +6139 6199 +6139 6200 +6139 6201 +6139 6202 +6139 6203 +6139 6204 +6139 6205 +6139 6206 +6139 6207 +6139 6208 +6139 6209 +6139 6210 +6139 6211 +6139 6212 +6139 6213 +6139 6214 +6139 6215 +6139 6216 +6139 6217 +6139 6218 +6139 6219 +6139 6220 +6139 6221 +6139 6222 +6139 6223 +6139 6224 +6139 6225 +6139 6226 +6139 6227 +6139 6228 +2988 1396 +2988 1598 +2988 1821 +2988 2069 +2988 2276 +2988 3188 +2988 3433 +2988 3563 +2988 3974 +2988 4422 +2989 2232 +2989 2448 +2991 1335 +2991 2394 +2991 2663 +2991 2787 +2991 3244 +2991 3815 +2991 4423 +2991 4446 +2991 4447 +2991 4448 +4805 55 +4805 325 +4805 490 +4805 963 +4805 1287 +4805 1370 +4805 1423 +4805 3577 +4805 5506 +4810 5 +4810 143 +4810 145 +4810 368 +4810 667 +4810 740 +4810 1548 +4810 2718 +4810 3002 +4810 3048 +6141 213 +6141 1762 +6141 2179 +6141 2234 +6141 2272 +6141 2449 +6141 2797 +6141 3557 +6141 4815 +6141 6229 +499 71 +499 466 +499 500 +499 501 +499 502 +499 503 +499 504 +499 505 +499 506 +499 507 +704 612 +704 702 +704 851 +704 1531 +704 1539 +704 2621 +704 2622 +704 2623 +704 2624 +6132 3 +6132 125 +6132 176 +6132 249 +6132 251 +6132 353 +6132 559 +6132 754 +6132 1317 +6132 3371 +3776 77 +3776 262 +3776 492 +3776 1975 +3776 3343 +3776 3681 +3776 4266 +3776 4587 +3776 4664 +3776 4922 +5251 5368 +5251 5738 +5251 5739 +5251 5740 +5251 5741 +5251 5742 +5251 5743 +5251 5744 +5251 5745 +5251 5746 +4822 1054 +4822 1561 +4822 1619 +4822 2310 +4822 2652 +4822 2713 +4822 2981 +4822 4598 +4822 5511 +4822 5512 +4000 294 +4000 2964 +4000 4658 +4000 4961 +4000 5038 +4008 1199 +4008 1297 +4008 1867 +4008 2664 +4008 3071 +4008 3801 +4008 4723 +4008 5042 +4008 5043 +4008 5044 +6196 124 +6196 1396 +6196 1845 +6196 1971 +6196 2235 +6196 5110 +6196 5204 +6196 5263 +6196 6247 +6196 6248 +1495 1496 +6243 3243 +6244 3270 +6244 3808 +6245 187 +6245 367 +6245 469 +6245 474 +6245 3227 +6245 4196 +6245 4503 +6245 4985 +6245 5788 +6245 5988 +3222 296 +3222 413 +3222 1903 +3222 1939 +3222 4603 +3222 4604 +3222 4605 +3222 4606 +3222 4607 +3222 4608 +5866 2232 +5866 3481 +6296 798 +6296 849 +6296 1325 +6296 2058 +6296 5076 +6296 5236 +6296 6297 +6296 6298 +6296 6299 +5625 686 +5625 1863 +5625 1940 +5625 2794 +5625 3193 +5625 3205 +5625 4891 +5625 5912 +5625 5913 +5854 1087 +5854 3084 +5854 4068 +5854 5556 +5854 5626 +5854 5976 +5854 5977 +5854 5979 +5854 6031 +5854 6032 +5855 171 +5855 788 +5855 3378 +5855 3385 +5855 5523 +5855 5735 +5855 5850 +5855 6033 +5855 6034 +5855 6035 +5680 531 +5680 678 +5680 3124 +5680 3232 +5680 3571 +5680 4006 +5680 4193 +5680 4307 +5680 5589 +5680 5936 +6088 220 +6088 2181 +6088 2773 +6088 3858 +6088 3989 +6088 5815 +6088 6027 +6088 6099 +6088 6171 +6089 6237 +5944 969 +5944 2090 +5944 3488 +5944 3903 +5944 5536 +5944 5607 +5944 6001 +5944 6005 +5944 6076 +5944 6077 +1473 9 +1473 121 +1473 127 +1473 128 +1473 144 +1473 149 +1473 238 +1473 247 +1473 426 +1473 1317 +5372 2594 +4443 173 +4443 489 +4443 1896 +4443 1974 +4443 2646 +4443 3114 +4443 3806 +4443 4036 +4443 4275 +4443 5284 +3135 283 +3135 476 +3135 1511 +3135 1714 +3135 2860 +3135 3343 +3135 3463 +3135 4419 +3135 4551 +3135 4552 +5270 2398 +5270 3350 +5270 3385 +5270 4375 +5270 5482 +5464 2005 +5464 2532 +5464 2862 +5464 3564 +5464 3860 +5464 4633 +5464 5155 +5464 5425 +5464 5823 +5464 5835 +4798 821 +4798 1456 +4798 1842 +4798 1955 +4798 2866 +4798 2889 +4798 3233 +4798 3805 +4798 5499 +4798 5500 +5905 130 +5905 570 +5905 1261 +5905 1511 +5905 1921 +5905 3722 +5905 4485 +5905 4875 +5905 4979 +5905 5723 +1638 2017 +36 3 +36 123 +36 126 +36 145 +36 174 +36 179 +36 247 +36 249 +36 264 +36 424 +1732 9 +1732 128 +1732 148 +1732 149 +1732 175 +1732 179 +1732 238 +1732 352 +1732 353 +1732 559 +5347 20 +5347 54 +5347 146 +5347 534 +5347 749 +5347 1901 +5347 2616 +5347 3292 +5347 4051 +5347 5224 +5347 5348 +5347 5462 +5347 5542 +5347 5616 +5347 5632 +5347 5783 +5347 5784 +1011 3044 +1013 302 +1013 406 +1013 435 +1013 2119 +1013 2909 +1013 2912 +1013 2913 +1013 2914 +1013 2915 +1344 1219 +1344 1288 +1344 1309 +1344 2650 +1344 2744 +1344 2966 +1344 3018 +1344 3184 +1344 3185 +1344 3186 +2549 5 +2549 126 +2549 148 +2549 149 +2549 179 +2549 180 +2549 266 +2549 754 +2549 1245 +2549 2018 +5956 503 +5956 2154 +5956 2373 +5956 2378 +5956 2385 +5956 4944 +5956 5429 +5956 6081 +5956 6082 +5956 6083 +5957 86 +5957 1246 +5957 2008 +5957 4353 +5957 4368 +5957 5504 +5957 5715 +5957 6084 +5957 6085 +5957 6086 +3500 2127 +3500 2420 +3500 4185 +3500 4626 +3500 4782 +3500 4783 +3500 4784 +3500 4785 +3500 4786 +3500 4787 +4246 496 +4246 1224 +4246 2058 +4246 2068 +4246 2744 +4246 3117 +4246 3133 +4246 3277 +4246 5159 +4246 5160 +5026 1050 +5026 1447 +5026 1590 +5026 1689 +5026 1912 +5026 2194 +5026 2337 +5026 4133 +5026 5602 +5026 5603 +5759 704 +5759 837 +5759 1137 +5759 1928 +5759 4095 +5759 5230 +5759 5931 +5759 5968 +5759 5969 +5761 1388 +5761 2176 +5761 2385 +5761 3018 +5761 3516 +5761 4776 +5761 5050 +5761 5567 +5761 5826 +5761 5970 +4505 3456 +4506 5316 +1880 219 +1880 363 +1880 846 +1880 925 +1880 1001 +1880 2563 +1880 3105 +1880 3629 +1880 3630 +1880 3631 +5597 419 +5597 1025 +5597 1728 +5597 4779 +5597 5886 +1665 126 +1665 251 +1665 264 +1665 265 +1665 266 +1665 368 +1665 666 +1665 667 +1665 1666 +1665 1667 +5378 296 +5378 352 +5378 1358 +5378 3221 +5378 3446 +5378 3519 +5378 5432 +5378 5612 +5378 5800 +5907 796 +5907 1380 +5907 1892 +5907 4131 +5907 4268 +5907 5442 +5907 6063 +5907 6064 +5907 6065 +5994 38 +5994 132 +5994 747 +5994 1130 +5994 2556 +5994 3460 +5994 5879 +5994 6105 +5994 6106 +5994 6107 +5995 122 +5379 2579 +5495 183 +5495 610 +5495 1848 +5495 2044 +5495 3471 +5495 3516 +5495 4940 +5495 5118 +5495 5211 +5495 5847 +5915 1255 +5915 1677 +5915 2161 +5915 2612 +5915 2622 +5915 3194 +5915 3954 +5915 4754 +5915 6066 +5915 6067 +4139 268 +4139 487 +4139 1339 +4139 2220 +4139 2898 +4139 4307 +4139 4328 +4139 4382 +4139 4841 +4139 4993 +5290 3476 +3274 4644 +3378 2875 +4918 5577 +5921 1064 +5921 2450 +5921 2552 +5921 3698 +5921 4109 +5921 4507 +5921 4793 +5921 5788 +5921 6068 +5921 6069 +3037 1212 +3037 2051 +3037 2782 +3037 2796 +3037 3740 +3037 4434 +3037 4477 +3037 4478 +3037 4479 +3037 4480 +6169 83 +6169 969 +6169 1679 +6169 3190 +6169 3304 +6169 4654 +6169 4762 +6169 6065 +6169 6234 +6169 6235 +6170 717 +6170 803 +6170 1401 +6170 2621 +6170 3076 +6170 3477 +6170 3485 +6170 6238 +6170 6239 +6170 6240 +6050 307 +6050 1173 +6050 2220 +6050 6143 +6050 6144 +6050 6145 +6050 6146 +6050 6147 +6050 6148 +6050 6149 +6057 3218 +438 156 +438 456 +438 1383 +438 1522 +438 2094 +438 2220 +438 2443 +438 2444 +438 2445 +438 2446 +5829 3480 +5830 529 +5830 942 +5830 2622 +5830 2797 +5830 2798 +5830 4469 +5830 5593 +5830 6023 +5830 6024 +5830 6025 +430 826 +430 1415 +430 2235 +430 2373 +430 2416 +430 2417 +430 2418 +430 2419 +430 2420 +430 2421 +5590 706 +5590 800 +5590 1600 +5590 1766 +5590 5885 +305 587 +305 710 +305 838 +305 1498 +305 1776 +305 1850 +305 2256 +305 2257 +305 2258 +305 2259 +6191 2237 +6193 1287 +6193 2403 +6193 2868 +6193 3448 +6193 3728 +6193 5101 +6193 5615 +6193 5975 +6193 6246 +6194 4934 +6194 5049 +6194 5850 +6194 6289 +5167 1886 +5167 1940 +5167 1980 +5167 2569 +5167 3069 +5167 3125 +5167 4125 +5167 5672 +5167 5673 +5167 5674 +5206 43 +5206 169 +5206 219 +5206 246 +5206 2652 +5206 3058 +5206 3601 +5206 3925 +5206 3944 +5206 5704 +5207 544 +5207 816 +5207 1504 +5207 1764 +5207 1765 +5207 2069 +5207 4846 +5207 5499 +5207 5708 +5207 5709 +4800 1240 +4800 1559 +4800 1766 +4800 3205 +4800 3672 +4800 3678 +4800 4942 +4800 5503 +4800 5504 +4800 5505 +6012 2023 +6012 2024 +6012 3988 +6012 4058 +6012 5469 +6012 5498 +6012 6123 +6012 6124 +6012 6125 +6012 6126 +6015 235 +6015 1402 +6015 1846 +6015 1860 +6015 2086 +6015 2325 +6015 3486 +6015 3820 +6015 4754 +6015 6127 +6016 1042 +6016 1203 +6016 1255 +6016 1430 +6016 2492 +6016 3630 +6016 6041 +6016 6128 +6016 6129 +6016 6130 +6018 443 +6023 78 +6023 350 +6023 1168 +6023 4303 +6023 4423 +6023 5350 +6023 6134 +6023 6135 +6023 6136 +3244 120 +3244 257 +3244 456 +3244 872 +3244 1492 +3244 1651 +3244 1758 +3244 4626 +3244 4627 +3244 4628 +4446 4733 +6229 983 +6229 1602 +6229 1719 +6229 2693 +6229 3798 +6229 4169 +6229 4235 +6229 6186 +6229 6253 +6229 6254 +2622 889 +2622 892 +2622 1824 +2622 2193 +2622 2194 +2622 3076 +2622 3244 +2622 3999 +2622 4225 +2622 4226 +5740 2018 +5742 381 +5742 448 +5742 1311 +5742 1850 +5742 2663 +5742 3460 +5742 3801 +5742 4365 +5742 5677 +5742 5961 +5042 2968 +5044 122 +5044 123 +5044 125 +5044 144 +5044 174 +5044 352 +5044 369 +5044 424 +5044 427 +5044 2338 +5976 337 +5976 1541 +5976 1952 +5976 2417 +5976 3385 +5976 3732 +5976 4668 +5976 5086 +5976 5688 +5976 6092 +5977 243 +5977 424 +5977 1893 +5977 2448 +5977 3171 +5977 3344 +5977 3756 +5977 4213 +5977 6007 +5977 6093 +6031 4966 +5936 31 +5936 485 +5936 1127 +5936 2424 +5936 3214 +5936 3771 +5936 4016 +5936 4128 +5936 4526 +5936 5378 +6077 9 +6077 125 +6077 148 +6077 174 +6077 179 +6077 352 +6077 353 +6077 424 +6077 736 +6077 753 +4552 3813 +5499 3635 +5499 4128 +5499 4462 +5499 4670 +5499 5828 +5500 2059 +5783 351 +5783 996 +5783 3249 +5783 5779 +5783 5823 +5783 5976 +5783 5977 +5783 5978 +5783 5979 +6081 129 +6081 219 +6081 864 +6081 1812 +6081 2079 +6081 4107 +6081 4319 +6081 6046 +5160 201 +5160 400 +5160 459 +5160 1484 +5160 2023 +5160 2492 +5160 3594 +5160 3715 +5160 3849 +5160 4487 +5602 1085 +5602 1333 +3631 788 +5886 285 +5886 1592 +5886 1761 +5886 2563 +5886 2646 +5886 5487 +5886 5617 +5886 5941 +5886 6023 +5886 6041 +6063 255 +6063 275 +6063 456 +6063 527 +6063 1375 +6063 2126 +6063 5216 +6063 5288 +6063 5406 +6063 5556 +6105 6179 +1848 167 +1848 276 +1848 368 +1848 2127 +1848 2571 +1848 2787 +1848 2996 +1848 3593 +1848 3594 +5847 518 +5847 1240 +5847 1691 +5847 5511 +5847 6026 +5847 6027 +5847 6028 +5847 6029 +5847 6030 +6066 86 +6066 1246 +6066 2008 +6066 3138 +6066 3515 +6066 6071 +6066 6086 +6066 6154 +6066 6155 +6066 6156 +6067 17 +6067 123 +6067 175 +6067 249 +6067 390 +6067 423 +6067 695 +6067 697 +6067 856 +6069 158 +6069 490 +6069 650 +6069 1522 +6069 3205 +6069 5133 +6069 5469 +6069 6167 +6069 6168 +4479 183 +4479 604 +4479 913 +4479 2039 +4479 2291 +4479 3318 +4479 4378 +4479 5317 +4479 5318 +4479 5319 +6234 5552 +6239 2397 +6239 2854 +6239 5369 +6239 5475 +6239 5960 +6239 6118 +6239 6258 +6239 6259 +6239 6260 +6239 6261 +544 522 +544 2505 +544 2506 +544 2507 +544 2508 +544 2509 +544 2510 +544 2511 +544 2512 +544 2513 +5708 5943 +5505 295 +6123 523 +6123 524 +6123 1038 +6123 2046 +6123 2821 +6123 3331 +6123 4301 +6123 4383 +6123 5765 +6123 5844 +6124 311 +6124 510 +6124 962 +6124 2136 +6124 2151 +6124 4885 +6124 4915 +6124 4978 +6124 6176 +6124 6183 +6125 1377 +6125 3125 +6125 3264 +6125 3981 +6125 5535 +6125 6184 +6125 6185 +6125 6186 +6125 6187 +6125 6188 +6134 3960 +120 3 +120 121 +120 122 +120 123 +120 124 +120 125 +120 126 +120 127 +120 128 +120 129 +1758 1135 +1758 2805 +1758 3126 +1758 3520 +1758 3521 +1758 3522 +1758 3523 +1758 3524 +1758 3525 +1758 3526 +6186 57 +6186 440 +6186 1221 +6186 1618 +6186 2823 +6186 4076 +6186 5261 +6186 5824 +6186 5988 +6186 6091 +5961 1460 +5961 2881 +5961 2933 +5961 6108 +6092 4 +6092 8 +6092 126 +6092 129 +6092 144 +6092 179 +6092 1317 +6092 3022 +6092 5911 +6093 253 +6093 2292 +6093 2445 +6093 3963 +6093 4872 +6093 5269 +6093 6166 +6093 6172 +6093 6173 +1484 1581 +1484 2071 +1484 2516 +1484 2532 +1484 3079 +1484 3200 +1484 3323 +1484 3324 +1484 3325 +6155 2394 +6155 2487 +6155 3768 +6155 4080 +6155 4503 +6155 4883 +6155 5086 +6155 6230 +6155 6231 +5318 346 +5318 1861 +5318 1922 +5318 2353 +5318 2360 +5318 2456 +5318 3190 +5318 3418 +5318 5773 +5318 5774 +6258 1531 +6258 1882 +6258 2500 +6258 2693 +6258 5253 +6258 5514 +6258 5529 +6258 6271 +6258 6272 +6258 6273 +2505 23 +2505 133 +2505 916 +2505 3594 +2505 4137 +2510 49 +2510 101 +2510 1339 +2510 1628 +2510 2114 +2510 2231 +2510 3077 +2510 4138 +2510 4139 +2510 4140 +2136 3888 +6187 4170 +3521 629 +3521 711 +3521 1049 +3521 2594 +3521 2650 +3521 2779 +3521 4096 +3521 4794 +3521 4795 +3521 4796 +3522 179 +3522 1089 +3522 1604 +3522 4096 +3522 4360 +3522 4362 +3522 4487 +3522 4516 +3522 4793 +1460 1461 +4140 248 +4140 344 +4140 387 +4140 894 +4140 1942 +4140 2383 +4140 2394 +4140 3921 +4140 4210 +4140 5090 +5090 122 +5090 123 +5090 129 +5090 143 +5090 147 +5090 177 +5090 367 +5090 368 +5090 390 +5090 1245 +22 23 +22 24 +22 25 +22 26 +22 27 +22 28 +22 29 +22 30 +22 31 +22 32 +44 45 +44 46 +44 47 +44 48 +44 49 +44 50 +44 51 +44 52 +44 53 +44 54 +6273 1437 +6273 2413 +6273 2984 +6273 3733 +6273 3981 +6273 5911 +6273 6276 +6273 6277 +6273 6278 +66 16 +66 67 +66 68 +66 69 +66 70 +66 71 +66 72 +66 73 +66 74 +66 75 +98 99 +98 100 +98 101 +98 102 +98 103 +98 104 +98 105 +98 106 +98 107 +98 108 +109 110 +109 111 +109 112 +109 113 +109 114 +109 115 +109 116 +109 117 +109 118 +109 119 +6276 810 +6276 3488 +6276 3632 +6276 4926 +6276 5395 +6276 5545 +6276 5627 +6276 5710 +6276 6159 +6276 6172 +6277 1798 +6277 5040 +6277 5791 +6277 5911 +6277 6290 +192 38 +192 193 +192 194 +192 195 +192 196 +194 86 +194 139 +194 1020 +194 2135 +194 2136 +194 2137 +194 2138 +194 2139 +194 2140 +194 2141 +236 24 +236 237 +236 238 +236 239 +236 240 +236 241 +236 242 +236 243 +236 244 +236 245 +310 311 +310 312 +310 313 +310 314 +310 315 +310 316 +310 317 +310 318 +310 319 +310 320 +316 2267 +366 3 +366 124 +366 147 +366 177 +366 251 +366 264 +366 266 +366 367 +366 368 +366 369 +399 400 +399 401 +399 402 +399 403 +399 404 +399 405 +399 406 +399 407 +399 408 +399 409 +410 411 +410 412 +410 413 +410 414 +410 415 +410 416 +410 417 +410 418 +410 419 +410 420 +421 8 +421 122 +421 123 +421 125 +421 264 +421 352 +421 390 +421 422 +421 423 +421 424 +428 429 +428 430 +428 431 +428 432 +428 433 +428 434 +428 435 +428 436 +428 437 +428 438 +431 487 +431 2214 +431 2311 +431 2422 +431 2423 +431 2424 +431 2425 +431 2426 +431 2427 +431 2428 +439 440 +439 441 +439 442 +439 443 +439 444 +439 445 +439 446 +439 447 +439 448 +439 449 +516 350 +516 517 +516 518 +516 519 +516 520 +516 521 +516 522 +516 523 +516 524 +516 525 +537 538 +537 539 +537 540 +537 541 +537 542 +537 543 +537 544 +537 545 +537 546 +537 547 +636 475 +636 507 +636 637 +636 638 +636 639 +636 640 +636 641 +636 642 +636 643 +644 645 +647 216 +647 585 +647 648 +647 649 +647 650 +647 651 +647 652 +647 653 +647 654 +647 655 +719 479 +719 720 +719 721 +719 722 +719 723 +719 724 +719 725 +719 726 +719 727 +752 5 +752 180 +752 247 +752 250 +752 351 +752 426 +752 554 +752 753 +752 754 +752 755 +775 776 +797 289 +797 420 +797 460 +797 463 +797 798 +797 799 +797 800 +797 801 +797 802 +797 803 +896 563 +896 897 +896 898 +896 899 +896 900 +896 901 +896 902 +896 903 +896 904 +896 905 +929 335 +929 930 +929 931 +929 932 +929 933 +929 934 +929 935 +929 936 +929 937 +948 31 +948 862 +948 949 +948 950 +948 951 +949 1028 +949 1661 +949 2697 +949 2829 +949 2830 +949 2831 +949 2832 +949 2833 +949 2834 +949 2835 +950 870 +950 1570 +950 1631 +950 1747 +950 2793 +950 2824 +950 2825 +950 2826 +950 2827 +950 2828 +2831 133 +2831 397 +2831 398 +2831 982 +2831 3221 +2831 3981 +2831 4326 +2831 4327 +2831 4328 +2831 4329 +2835 815 +2835 1197 +2835 1234 +2835 2821 +2835 3351 +2835 4191 +2835 4330 +2835 4331 +2835 4332 +2835 4333 +961 8 +961 262 +961 280 +961 560 +961 962 +961 963 +961 964 +961 965 +961 966 +961 967 +964 364 +964 697 +964 2213 +964 2844 +964 2845 +964 2846 +964 2847 +964 2848 +964 2849 +964 2850 +992 3 +992 174 +992 251 +992 265 +992 351 +992 369 +992 390 +992 697 +992 947 +992 993 +994 995 +999 716 +999 1000 +999 1001 +999 1002 +999 1003 +999 1004 +999 1005 +999 1006 +999 1007 +999 1008 +1075 116 +1075 1076 +1075 1077 +1075 1078 +1075 1079 +1075 1080 +1075 1081 +1075 1082 +1075 1083 +1080 2868 +1098 1051 +1098 1099 +1098 1100 +1098 1101 +1098 1102 +1098 1103 +1098 1104 +1098 1105 +1098 1106 +1108 467 +1108 1109 +1108 1110 +1108 1111 +1108 1112 +1108 1113 +1108 1114 +1108 1115 +1108 1116 +1111 435 +1111 1618 +1111 1645 +1111 1982 +1111 2163 +1111 3018 +1111 3019 +1111 3020 +1111 3021 +1111 3022 +1113 4 +1113 124 +1113 249 +1113 266 +1113 367 +1113 368 +1113 369 +1113 423 +1113 1245 +1117 29 +1117 124 +1117 126 +1117 496 +1117 1118 +1117 1119 +1117 1120 +1117 1121 +1117 1122 +1117 1123 +1161 3 +1161 5 +1161 8 +1161 121 +1161 122 +1161 124 +1161 144 +1161 145 +1161 177 +1161 248 +1181 1182 +1181 1183 +1181 1184 +1181 1185 +1181 1186 +1181 1187 +1181 1188 +1181 1189 +1181 1190 +1181 1191 +1189 3054 +1200 229 +1200 341 +1200 1201 +1200 1202 +1200 1203 +1200 1204 +1200 1205 +1200 1206 +1200 1207 +1200 1208 +1204 1097 +1204 1322 +1204 2887 +1204 3098 +1204 3099 +1204 3100 +1204 3101 +1204 3102 +1204 3103 +1204 3104 +1205 141 +1205 1849 +1205 1850 +1205 2996 +1205 3065 +1205 3066 +1205 3067 +1205 3068 +1205 3069 +1205 3070 +1207 1749 +1207 2739 +1207 3071 +1207 3072 +1207 3073 +1207 3074 +1207 3075 +1207 3076 +1207 3077 +1207 3078 +3074 289 +3074 979 +3074 1228 +3074 4288 +3074 4493 +3078 75 +3078 108 +3078 272 +3078 274 +3078 477 +3078 814 +3078 1542 +3078 2248 +3078 4019 +3078 4500 +4500 120 +4500 1666 +4500 1884 +4500 4002 +4500 4799 +4500 4841 +4500 5187 +4500 5283 +4500 5315 +4500 5327 +1884 122 +1884 123 +1884 124 +1884 125 +1884 127 +1884 128 +1884 129 +1884 144 +1884 264 +1884 427 +1218 58 +1218 165 +1218 292 +1218 514 +1218 941 +1218 1000 +1218 1219 +1218 1220 +1218 1221 +1222 49 +1222 78 +1222 468 +1222 1223 +1222 1224 +1222 1225 +1222 1226 +1222 1227 +1222 1228 +1222 1229 +1237 842 +1237 852 +1237 1238 +1237 1239 +1237 1240 +1237 1241 +1237 1242 +1237 1243 +1237 1244 +1241 1492 +1247 158 +1247 582 +1247 583 +1247 955 +1247 1032 +1247 1068 +1247 1070 +1247 1248 +1247 1249 +1247 1250 +1260 301 +1260 1084 +1260 1086 +1260 1261 +1260 1262 +1260 1263 +1260 1264 +1260 1265 +1260 1266 +1286 391 +1286 1056 +1286 1100 +1286 1287 +1286 1288 +1286 1289 +1286 1290 +1286 1291 +1286 1292 +1286 1293 +1294 148 +1294 369 +1294 438 +1294 690 +1294 1069 +1294 1295 +1294 1296 +1294 1297 +1294 1298 +1294 1299 +1307 240 +1307 1308 +1307 1309 +1307 1310 +1307 1311 +1307 1312 +1307 1313 +1307 1314 +1307 1315 +1307 1316 +1308 2661 +1308 2922 +1308 3181 +1308 3182 +1308 3183 +1398 554 +1398 736 +1398 1022 +1398 1399 +1398 1400 +1398 1401 +1398 1402 +1399 387 +1399 416 +1399 765 +1399 806 +1399 3242 +1399 3243 +1399 3244 +1399 3245 +1399 3246 +1399 3247 +3246 268 +3246 576 +3246 840 +3246 1797 +3246 3956 +3246 4608 +3246 4629 +3246 4630 +3246 4631 +3246 4632 +4631 251 +4631 664 +4631 803 +4631 2218 +4631 2285 +4631 2309 +4631 4137 +4631 5393 +4631 5394 +4631 5395 +1403 132 +1403 188 +1403 926 +1403 1404 +1403 1405 +1403 1406 +1403 1407 +1403 1408 +1403 1409 +1403 1410 +1445 326 +1445 502 +1445 578 +1445 1446 +1445 1447 +1445 1448 +1445 1449 +1445 1450 +1445 1451 +1445 1452 +1453 221 +1453 476 +1453 1195 +1453 1295 +1453 1454 +1453 1455 +1453 1456 +1453 1457 +1453 1458 +1453 1459 +1462 1463 +1462 1464 +1462 1465 +1462 1466 +1462 1467 +1462 1468 +1462 1469 +1462 1470 +1462 1471 +1462 1472 +1474 158 +1478 110 +1478 798 +1478 1095 +1478 1215 +1478 1479 +1478 1480 +1478 1481 +1478 1482 +1478 1483 +1478 1484 +1494 5 +1494 7 +1494 125 +1494 144 +1494 149 +1494 174 +1494 179 +1494 424 +1494 559 +1494 667 +1497 125 +1497 828 +1497 1498 +1497 1499 +1497 1500 +1497 1501 +1497 1502 +1497 1503 +1497 1504 +1497 1505 +1520 609 +1520 614 +1520 883 +1520 958 +1520 1521 +1520 1522 +1520 1523 +1520 1524 +1520 1525 +1520 1526 +1527 3 +1527 454 +1527 462 +1527 691 +1527 970 +1527 1025 +1527 1492 +1527 1528 +1527 1529 +1527 1530 +1562 391 +1562 405 +1562 824 +1562 1105 +1562 1563 +1562 1564 +1562 1565 +1562 1566 +1562 1567 +1562 1568 +1566 297 +1566 338 +1566 1192 +1566 1425 +1566 2450 +1566 3351 +1566 3352 +1566 3353 +1566 3354 +1566 3355 +1579 391 +1579 602 +1579 1240 +1579 1246 +1579 1385 +1579 1580 +1579 1581 +1579 1582 +1579 1583 +1582 355 +1582 1791 +1582 1797 +1582 2285 +1582 2309 +1582 2799 +1582 3282 +1582 3371 +1582 3372 +1596 298 +1596 465 +1596 1597 +1596 1598 +1596 1599 +1596 1600 +1596 1601 +1596 1602 +1596 1603 +1596 1604 +1603 5 +1603 8 +1603 9 +1603 147 +1603 149 +1603 179 +1603 252 +1603 426 +1603 856 +1603 2098 +1625 29 +1625 303 +1625 364 +1625 1061 +1625 1626 +1625 1627 +1625 1628 +1625 1629 +1625 1630 +1625 1631 +1648 1649 +1649 297 +1649 324 +1649 1044 +1649 1157 +1649 2793 +1649 3396 +1649 3397 +1649 3398 +3396 163 +3396 266 +3396 894 +3396 2196 +3396 2221 +3396 2443 +3396 4402 +3396 4689 +3396 4733 +3396 4734 +3398 341 +3398 1859 +3398 1955 +3398 2891 +3398 2905 +3398 3788 +3398 3822 +3398 4743 +3398 4744 +3398 4745 +4745 56 +4745 738 +4745 823 +4745 898 +4745 1568 +4745 2024 +4745 3681 +4745 4337 +4745 4769 +4745 5461 +1657 89 +1657 547 +1657 1340 +1657 1658 +1657 1659 +1657 1660 +1657 1661 +1657 1662 +1657 1663 +1657 1664 +1663 266 +1663 1152 +1663 2257 +1663 2429 +1663 3140 +1663 3571 +1668 71 +1668 1353 +1668 1669 +1668 1670 +1668 1671 +1674 513 +1674 1587 +1674 1675 +1674 1676 +1674 1677 +1674 1678 +1674 1679 +1674 1680 +1674 1681 +1674 1682 +1680 2131 +1683 1684 +1692 191 +1692 280 +1692 1084 +1692 1256 +1692 1693 +1692 1694 +1692 1695 +1692 1696 +1692 1697 +1692 1698 +1712 1713 +1713 469 +1713 514 +1713 1219 +1713 1252 +1713 1776 +1713 2163 +1713 3472 +1713 3473 +1713 3474 +1713 3475 +1722 1723 +1723 4 +1723 7 +1723 149 +1723 175 +1723 179 +1723 252 +1723 266 +1723 352 +1723 424 +1742 577 +1742 813 +1742 938 +1742 1408 +1742 1600 +1742 1743 +1742 1744 +1742 1745 +1742 1746 +1742 1747 +1746 255 +1746 406 +1746 538 +1746 889 +1746 2084 +1746 2314 +1746 2547 +1746 3503 +1746 3504 +1746 3505 +3505 3 +3505 143 +3505 145 +3505 177 +3505 251 +3505 353 +3505 753 +3505 754 +3505 3002 +3505 3132 +1748 255 +1748 916 +1748 1028 +1748 1044 +1748 1564 +1748 1749 +1748 1750 +1748 1751 +1748 1752 +1753 182 +1753 1754 +1753 1755 +1753 1756 +1753 1757 +1753 1758 +1753 1759 +1753 1760 +1753 1761 +1753 1762 +1785 174 +1785 1574 +1785 1786 +1785 1787 +1785 1788 +1785 1789 +1785 1790 +1785 1791 +1785 1792 +1785 1793 +1793 1248 +1793 1901 +1793 2336 +1793 2543 +1793 2713 +1793 2818 +1793 2838 +1793 3541 +1834 224 +1834 275 +1834 1287 +1834 1835 +1834 1836 +1834 1837 +1834 1838 +1834 1839 +1834 1840 +1839 53 +1839 222 +1839 818 +1839 2359 +1839 2377 +1839 2683 +1839 2767 +1839 3590 +1839 3591 +1839 3592 +1847 141 +1847 977 +1847 1848 +1847 1849 +1847 1850 +1847 1851 +1847 1852 +1847 1853 +1847 1854 +1847 1855 +1856 289 +1856 1211 +1856 1857 +1856 1858 +1856 1859 +1856 1860 +1856 1861 +1856 1862 +1856 1863 +1857 757 +1857 758 +1857 884 +1857 2176 +1857 3609 +1857 3610 +1857 3611 +1857 3612 +1857 3613 +1857 3614 +1864 58 +1864 924 +1864 1297 +1864 1606 +1864 1608 +1864 1865 +1864 1866 +1864 1867 +1864 1868 +1864 1869 +1876 1288 +1877 477 +1877 534 +1877 1733 +1877 1878 +1877 1879 +1877 1880 +1877 1881 +1877 1882 +1877 1883 +1877 1884 +5537 477 +5537 1194 +5537 1365 +5537 2345 +5537 2955 +5537 5538 +5537 5539 +5537 5540 +5537 5541 +5537 5542 +5538 162 +5538 223 +5538 477 +5538 2345 +5538 3081 +5538 3989 +5538 5058 +5538 5868 +5538 5869 +5538 5870 +5539 125 diff --git a/snap-python/source/test/data/test-509.txt b/snap-python/source/test/data/test-509.txt new file mode 100644 index 0000000000000000000000000000000000000000..dd2fbdf896be6a7a06a94d71e9528ea154277f2b --- /dev/null +++ b/snap-python/source/test/data/test-509.txt @@ -0,0 +1,2 @@ +a b 3 +b c 5 diff --git a/snap-python/source/test/delnode.py b/snap-python/source/test/delnode.py new file mode 100644 index 0000000000000000000000000000000000000000..d763913b3c4cc8895b2c2f335657375d95275f14 --- /dev/null +++ b/snap-python/source/test/delnode.py @@ -0,0 +1,56 @@ +import snap + +print("version", snap.Version) +g = snap.TNEANet.New() +print("nodes", g.GetNodes(), "edges", g.GetEdges()) + +g.AddNode(1) +print("nodes", g.GetNodes(), "edges", g.GetEdges()) + +g.AddNode(2) +print("nodes", g.GetNodes(), "edges", g.GetEdges()) + +g.AddEdge(1,2) +print("nodes", g.GetNodes(), "edges", g.GetEdges()) + +g.AddIntAttrDatN(1,1,'node_attr') +g.AddIntAttrDatE(0,2,'edge_attr') + +g.DelNode(1) +print("nodes", g.GetNodes(), "edges", g.GetEdges()) + +print("-------------------") + +g = snap.TNEANet.New() +g.AddNode(0) +g.AddNode(2) +g.AddNode(1) +g.AddNode(3) +g.AddNode(4) +g.AddNode(5) + +e = g.AddEdge(1,2) +print(e) +e = g.AddEdge(2,3) +print(e) +e = g.AddEdge(3,4) +print(e) +e = g.AddEdge(4,5) +print(e) +e = g.AddEdge(2,5) +print(e) + +#g.AddIntAttrDatN(1, 1, 'weight') +g.AddIntAttrDatE(0, 2, 'edge_weight') +g.AddIntAttrDatE(1, 5, 'edge_weight') +g.AddIntAttrDatE(2, 9, 'edge_weight') +g.AddIntAttrDatE(3, 12, 'edge_weight') +g.AddIntAttrDatE(4, 232, 'edge_weight') +#print(g.GetNodes()) +g.DelNode(1) +g.DelNode(3) +#print(g.GetNodes()) + +for edge in g.Edges(): + print(edge.GetSrcNId(), edge.GetDstNId(), g.GetIntAttrDatE(edge.GetId(), 'edge_weight')) + diff --git a/snap-python/source/test/demo-random.py b/snap-python/source/test/demo-random.py new file mode 100644 index 0000000000000000000000000000000000000000..0166496ddadc3242ff31aa5f6df7726900b884d0 --- /dev/null +++ b/snap-python/source/test/demo-random.py @@ -0,0 +1,19 @@ +import snap + +G = snap.GenFull(snap.PNEANet, 100) + +# get a new random generator, provide the seed value +Rnd = snap.TRnd(42) + +# randomize the generator, every execution will produce a different sequence. +# Comment out the line to get the same sequence on every execution. +Rnd.Randomize() + +for i in range(0,10): + # provide the random generator as a parameter to the function + NId = G.GetRndNId(Rnd) + print(NId) + + # result is not well formed, the following statement fails + #print(NI.GetId()) + diff --git a/snap-python/source/test/except.py b/snap-python/source/test/except.py new file mode 100644 index 0000000000000000000000000000000000000000..6132f03af2b01070e2cc35e74a36429c50a6e638 --- /dev/null +++ b/snap-python/source/test/except.py @@ -0,0 +1,28 @@ +import snap +import sys + +print("Version", snap.Version) + +try: + G = snap.TUNGraph.New() + print(snap.GetMxDegNId(G)) +except RuntimeError: + e = sys.exc_info() + print("1-except1", e) + print("1-except2", e[0]) + print("1-except3", e[1]) + +print("after GetMxDegNId") + +try: + G = snap.TUNGraph.New() + G.AddNode(1) + G.AddNode(1) +except RuntimeError: + e = sys.exc_info() + print("2-except1", e) + print("2-except2", e[0]) + print("2-except3", e[1]) + +print("after AddNode") + diff --git a/snap-python/source/test/genrnd.py b/snap-python/source/test/genrnd.py new file mode 100644 index 0000000000000000000000000000000000000000..b50ac5179d7355f50dcfecf013e592209b4b8619 --- /dev/null +++ b/snap-python/source/test/genrnd.py @@ -0,0 +1,36 @@ +import random +import sys + +sys.path.append("../swig") + +import snap as Snap + +def GenRndGnm(): + Graph = Snap.GenRndGnm_PNGraph(1000,10000) + print("Graph", str(type(Graph)), Graph.GetNodes(), Graph.GetEdges()) + + # save the graph + FName = "test2.graph" + print("Save", FName) + + FOut = Snap.TFOut(Snap.TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + print("Read", FName) + FIn = Snap.TFIn(Snap.TStr(FName)) + #Graph2 = Snap.TNGraph(FIn) + #Graph2 = Snap.TNGraph.Load(FIn) + Graph2 = Snap.PNGraph.New() + print("Graph2", str(type(Graph2))) + print(str(dir(Graph2))) + Graph2.Load(FIn) + #Graph2 = Snap.Load_PNGraph(FIn) + #print("Read end", FName) + #print("Graph2", str(type(Graph2)), Graph2.GetNodes(), Graph2.GetEdges()) + +if __name__ == '__main__': + print("----- GenRndGnm -----") + GenRndGnm() + diff --git a/snap-python/source/test/getidv.py b/snap-python/source/test/getidv.py new file mode 100644 index 0000000000000000000000000000000000000000..3d97e6265ab997e82569f41777a5fb956140bc5f --- /dev/null +++ b/snap-python/source/test/getidv.py @@ -0,0 +1,14 @@ +import snap + +Graph = snap.GenFull(snap.PNEANet, 10) + +NIdV = snap.TIntV() +Graph.GetNIdV(NIdV) +for i in NIdV: + print("node", i) + +EIdV = snap.TIntV() +Graph.GetEIdV(EIdV) +for i in EIdV: + print("edge", i) + diff --git a/snap-python/source/test/gnuplot.py b/snap-python/source/test/gnuplot.py new file mode 100644 index 0000000000000000000000000000000000000000..b263ce245c33d1f04666072118162b21833710e4 --- /dev/null +++ b/snap-python/source/test/gnuplot.py @@ -0,0 +1,7 @@ +import snap + +G = snap.LoadEdgeList(snap.PNGraph, "wiki-Vote.txt", 0, 1) + +snap.PlotInDegDistr(G, "wiki-in-degree", "wiki-Vote in Degree") + + diff --git a/snap-python/source/test/graphviz.py b/snap-python/source/test/graphviz.py new file mode 100644 index 0000000000000000000000000000000000000000..2c6c7431275974b4f4ffd39d7156f9400b330e24 --- /dev/null +++ b/snap-python/source/test/graphviz.py @@ -0,0 +1,21 @@ +import snap + +G = snap.TNGraph.New() +G.AddNode(1) +G.AddNode(2) +G.AddNode(3) +G.AddNode(4) +G.AddEdge(1,2) +G.AddEdge(2,3) +G.AddEdge(1,3) +G.AddEdge(2,4) +G.AddEdge(3,4) + +S = snap.TIntStrH() +S.AddDat(1,"David") +S.AddDat(2,"Emma") +S.AddDat(3,"Jim") +S.AddDat(4,"Sam") + +snap.DrawGViz(G, snap.gvlDot, "gviz.png", "Graph", S) + diff --git a/snap-python/source/test/hash.py b/snap-python/source/test/hash.py new file mode 100644 index 0000000000000000000000000000000000000000..66221012c32287d7828d1caa799d6d87876373c3 --- /dev/null +++ b/snap-python/source/test/hash.py @@ -0,0 +1,126 @@ +import random +import os +import sys +import time + +sys.path.append("../swig") +import snap as Snap + +numnodes = 100 +valrange = numnodes / 5 + +Edges = Snap.TIntV() + +for i in range(0,numnodes): + Edges.Add(int(random.random() * valrange)) + +d = {} +for i in range(0,numnodes,2): + #print("Edges", i/2, Edges.GetVal(i).Val, Edges.GetVal(i+1).Val) + d[(Edges.GetVal(i).Val,Edges.GetVal(i+1).Val)] = 1 + +Hash = Snap.TIntH() +#Snap.Edge2Hash(Edges,Hash) + +Hash.AddDat(3,5) +Hash.AddDat(4,6) +Hash.AddDat(1,8) +Hash.AddDat(6,2) + +print("type", type(Edges), type(Hash)) + +#for i in range(0,valrange): +# Vec2 = Hash.GetDat(i) +# print(i, Vec2.Val) + +print("len", Hash.Len()) +Iter = Hash.BegI() +Key = Iter.GetKey().Val +Value = Iter.GetDat().Val +print("iter", Key, Value) + +print("Iter < Hash.EndI", Iter < Hash.EndI()) +#while Iter < Hash.EndI(): +while not Iter.IsEnd(): + Key = Iter.GetKey().Val + Value = Iter.GetDat().Val + print(Key, Value) + + Iter.Next() + +sys.exit(0) + +AdjLists = Snap.TIntIntVH() +print("type", type(Edges), type(AdjLists)) +Snap.GetAdjLists(Edges, AdjLists) + +size = 0 +for i in range(0,valrange): + Vec2 = AdjLists.GetDat(i) + size += Vec2.Len() + + for j in range(0,Vec2.Len()): + print(i, Vec2.GetVal(j).Val) + +print("done", Edges.Len(), AdjLists.Len(), size, len(d)) + +sys.exit(0) + +#print("dir(Snap.TIntV)", dir(Snap.TIntV)) +Vec1 = Snap.TIntV(numnodes) +#print("dir(Vec1)", dir(Vec1)) +print("Len Vec1", Vec1.Len()) + +#print("dir(Snap.TIntIntVV)", dir(Snap.TIntIntVV)) +Vec2 = Snap.TIntIntVV(numtask) +#print("dir(Vec2)", dir(Vec2)) +print("Len Vec2", Vec2.Len()) + +print("Vec1", type(Vec1)) + +Snap.GetDegrees(Vec1, 10.0, 1.5) + +for i in range(0,Vec1.Len()): + print("Vec1", i, Vec1.GetVal(i).Val) + +Snap.AssignRndTask(Vec1, Vec2) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print("Vec3", i, Vec3.Len()) + + for j in range(0,Vec3.Len()): + print("Vec4", i, j, Vec3.GetVal(j).Val) + +sys.exit(0) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print("Vec3", i, Vec3.Len()) + + h = httplib.HTTPConnection("rokl1.stanford.edu",8100) + #h.request("POST","/msg/GenStubs-0/GenTasks-2","12345",{"User-agent": "007"}) + h.connect() + url = "/msg/GenStubs-0/GenTasks-%d" % (i) + h.putrequest("POST",url) + h.putheader("User-Agent", "007") + #h.putheader("Content-Length", "9") + h.putheader("Content-Length", str(Vec3.GetMemSize())) + h.endheaders() + + fileno = h.sock.fileno() + print("fileno", fileno) + + n = Vec3.Send(fileno) + #n = os.write(fileno,"123abcdef") + print(n) + + #h.send("abc123") + + res = h.getresponse() + print(res.status, res.reason) + data = res.read() + print(len(data)) + print(data) + + diff --git a/snap-python/source/test/hkey.py b/snap-python/source/test/hkey.py new file mode 100644 index 0000000000000000000000000000000000000000..670ebd6911b839c42c729c4d476b116385153cab --- /dev/null +++ b/snap-python/source/test/hkey.py @@ -0,0 +1,27 @@ +import snap as Snap + +h = Snap.TIntIntVH() +print(h.Len()) + +for i in range(0,10): + k = h.AddKey(Snap.TInt(i)) + v = h.GetDat(Snap.TInt(i)) + + for j in range(0,i+3): + v.Add(j) + + print(i,k) + +print(h.Len()) + +print("-----------") + +for i in range(0,10): + j = h.GetKeyId(Snap.TInt(i)) + print(j) + + v = h.GetDat(Snap.TInt(i)) + #print(type(j), type(v)) + print(v.Len()) + print() + diff --git a/snap-python/source/test/intro.py b/snap-python/source/test/intro.py new file mode 100644 index 0000000000000000000000000000000000000000..d60df1f094ad317b806d6e405825d36b3b70e14d --- /dev/null +++ b/snap-python/source/test/intro.py @@ -0,0 +1,86 @@ +import snap + +def intro(): + + # create a graph PNGraph + G1 = snap.TNGraph.New() + G1.AddNode(1) + G1.AddNode(5) + G1.AddNode(32) + G1.AddEdge(1,5) + G1.AddEdge(5,1) + G1.AddEdge(5,32) + print("G1: Nodes %d, Edges %d" % (G1.GetNodes(), G1.GetEdges())) + + # create a directed random graph on 100 nodes and 1k edges + G2 = snap.GenRndGnm(snap.PNGraph, 100, 1000) + print("G2: Nodes %d, Edges %d" % (G2.GetNodes(), G2.GetEdges())) + + # traverse the nodes + for NI in G2.Nodes(): + print("node id %d with out-degree %d and in-degree %d" % ( + NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) + # traverse the edges + for EI in G2.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + + # traverse the edges by nodes + for NI in G2.Nodes(): + for Id in NI.GetOutEdges(): + print("edge (%d %d)" % (NI.GetId(), Id)) + + # generate a network using Forest Fire model + G3 = snap.GenForestFire(1000, 0.35, 0.35) + print("G3: Nodes %d, Edges %d" % (G3.GetNodes(), G3.GetEdges())) + + # save and load binary + FOut = snap.TFOut("test.graph") + G3.Save(FOut) + FOut.Flush() + FIn = snap.TFIn("test.graph") + G4 = snap.TNGraph.Load(FIn) + print("G4: Nodes %d, Edges %d" % (G4.GetNodes(), G4.GetEdges())) + + # save and load from a text file + snap.SaveEdgeList(G4, "test.txt", "Save as tab-separated list of edges") + G5 = snap.LoadEdgeList(snap.PNGraph, "test.txt", 0, 1) + print("G5: Nodes %d, Edges %d" % (G5.GetNodes(), G5.GetEdges())) + + # generate a network using Forest Fire model + G6 = snap.GenForestFire(1000, 0.35, 0.35) + print("G6: Nodes %d, Edges %d" % (G6.GetNodes(), G6.GetEdges())) + # convert to undirected graph + G7 = snap.ConvertGraph(snap.PUNGraph,G6) + print("G7: Nodes %d, Edges %d" % (G7.GetNodes(), G7.GetEdges())) + # get largest weakly connected component of G + WccG = snap.GetMxWcc(G6) + # get a subgraph induced on nodes {0,1,2,3,4,5} + SubG = snap.GetSubGraph(G6, snap.TIntV.GetV(0,1,2,3,4)) + # get 3-core of G + Core3 = snap.GetKCore(G6, 3) + # delete nodes of out degree 10 and in degree 5 + snap.DelDegKNodes(G6, 10, 5) + print("G6a: Nodes %d, Edges %d" % (G6.GetNodes(), G6.GetEdges())) + + # generate a Preferential Attachment graph on 1000 nodes and node out degree of 3 + G8 = snap.GenPrefAttach(1000, 3) + print("G8: Nodes %d, Edges %d" % (G8.GetNodes(), G8.GetEdges())) + # vector of pairs of integers (size, count) + CntV = snap.TIntPrV() + # get distribution of connected components (component size, count) + snap.GetWccSzCnt(G8, CntV) + # get degree distribution pairs (degree, count) + snap.GetOutDegCnt(G8, CntV) + # vector of floats + EigV = snap.TFltV() + # get first eigenvector of graph adjacency matrix + snap.GetEigVec(G8, EigV) + # get diameter of G8 + snap.GetBfsFullDiam(G8, 100) + # count the number of triads in G8, get the clustering coefficient of G8 + snap.GetTriads(G8) + snap.GetClustCf(G8) + +if __name__ == '__main__': + intro() + diff --git a/snap-python/source/test/make-graph.py b/snap-python/source/test/make-graph.py new file mode 100644 index 0000000000000000000000000000000000000000..9d5914750955064c71c9d8151df82240f1d1ab36 --- /dev/null +++ b/snap-python/source/test/make-graph.py @@ -0,0 +1,28 @@ +import sys + +import snap + +if __name__ == '__main__': + + if len(sys.argv) < 2: + print("Usage: " + sys.argv[0] + " ") + sys.exit(1) + + fname = sys.argv[1] + + context = snap.TTableContext() + + schema = snap.Schema() + schema.Add(snap.TStrTAttrPr("SrcNode", snap.atStr)) + schema.Add(snap.TStrTAttrPr("DstNode", snap.atStr)) + schema.Add(snap.TStrTAttrPr("EdgeType", snap.atStr)) + + T1 = snap.TTable.LoadSS(schema, fname, context, "\t", snap.TBool(False)) + print("T1 #rows", T1.GetNumRows()) + + G1 = snap.ToGraph(snap.PNGraph, T1, "SrcNode", "DstNode", snap.aaFirst) + print("G1 #nodes", G1.GetNodes()) + print("G1 #edges", G1.GetEdges()) + + G1.PrintInfo("Graph Statistics", "graph-stats.txt", False) + diff --git a/snap-python/source/test/make-tab.py b/snap-python/source/test/make-tab.py new file mode 100644 index 0000000000000000000000000000000000000000..50211bdbc7e22005023af590cfe36619539957a1 --- /dev/null +++ b/snap-python/source/test/make-tab.py @@ -0,0 +1,18 @@ +# +# convert input to TSV format, remove final '.' +# + +import sys + +if __name__ == '__main__': + + for nline in sys.stdin: + line = nline.splitlines()[0] + + line = line.replace("> <", ">\t<") + line = line.replace("> \"", ">\t\"") + + if line[-2:] == " .": + line = line[:-2] + + print(line) diff --git a/snap-python/source/test/net.py b/snap-python/source/test/net.py new file mode 100644 index 0000000000000000000000000000000000000000..321c287748b971288570f967b9538a9c28891fcd --- /dev/null +++ b/snap-python/source/test/net.py @@ -0,0 +1,334 @@ +import random +import sys +from snap import * + +def PrintGStats(s, Graph): + ''' + Print graph statistics + ''' + + print("graph %s, nodes %d, edges %d, empty %s" % ( + s, Graph.GetNodes(), Graph.GetEdges(), + "yes" if Graph.Empty() else "no")) + +def DefaultConstructor(): + ''' + Test the default constructor + ''' + + Graph = TNEANet() + PrintGStats("DefaultConstructor:Graph", Graph) + +def ManipulateNodesEdges(): + ''' + Test node, edge creation + ''' + + NNodes = 10000 + NEdges = 100000 + FName = "test.graph" + + Graph = TNEANet.New() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1", Graph) + + # get all the nodes + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + # get all the edges for all the nodes + ECount1 = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + ECount1 += NI.GetOutDeg() + NI.Next() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0 + EI = Graph.BegEI() + while EI < Graph.EndEI(): + ECount2 += 1 + EI.Next() + + print("graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d"\ + % (NCount, ECount1, ECount2)) + PrintInfo(Graph,TStr("test"),TStr(""),0) + + # assignment + Graph1 = Graph + PrintGStats("ManipulateNodesEdges:Graph3", Graph1) + + # save the graph + print("graph type = ", type(Graph)) + FOut = TFOut(TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + FIn = TFIn(TStr(FName)) + Graph2 = TNEANet(FIn) + PrintGStats("ManipulateNodesEdges:Graph4" , Graph2) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5" , Graph) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6" , Graph1) + +def ManipulateNodeEdgeAttributes(): + ''' + Test node attribute functionality + ''' + + NNodes = 1000 + NEdges = 1000 + + Graph = TNEANet() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + print("Added nodes") + + # create attributes and fill all nodes + attr1 = TStr("str") + attr2 = TStr("int") + attr3 = TStr("float") + attr4 = TStr("default") + + # Test verticaliterator for node 3, 50, 700, 900 + # Check if we can set defaults to 0 fordata. + Graph.AddIntAttrN(attr2, 0) + Graph.AddIntAttrDatN(3, 3*2, attr2) + Graph.AddIntAttrDatN(50, 50*2, attr2) + Graph.AddIntAttrDatN(700, 700*2, attr2) + Graph.AddIntAttrDatN(900, 900*2, attr2) + + print("Added attributes") + + NodeId = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + if NI.GetDat() != 0: + print("Attribute: %s, Node: %i, Val: %d" % (attr2(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test vertical flt iterator for node 3, 50, 700, 900 + Graph.AddFltAttrDatN(5, 3.41, attr3) + Graph.AddFltAttrDatN(50, 2.718, attr3) + Graph.AddFltAttrDatN(300, 150.0, attr3) + + Graph.AddFltAttrDatN(653, 653, attr3) + NodeId = 0 + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + NI = Graph.BegNAFltI(attr3) + NodeId = 0 + while NI < Graph.EndNAFltI(attr3): + if NI.GetDat() != TFlt.Mn: + print("Attribute: %s, Node: %i, Val: %f" % (attr3(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test vertical str iterator for node 3, 50, 700, 900 + Graph.AddStrAttrDatN(10, TStr("abc"), attr1) + Graph.AddStrAttrDatN(20, TStr("def"), attr1) + Graph.AddStrAttrDatN(400, TStr("ghi"), attr1) + # this does not show since ""=null + Graph.AddStrAttrDatN(455, TStr(""), attr1) + NodeId = 0 + + NI = Graph.BegNAStrI(attr1) + NodeId = 0 + while NI < Graph.EndNAStrI(attr1): + if NI.GetDat() != TStr.GetNullStr(): + print("Attribute: %s, Node: %i, Val: %s" % (attr1(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test vertical iterator over many types (must skip default/deleted attr) + NId = 55 + Graph.AddStrAttrDatN(NId, TStr("aaa"), attr1) + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.AddFltAttrDatN(NId, 3.41, attr3) + Graph.AddStrAttrDatN(80, TStr("dont appear"), attr4) # should not show up + NIdAttrName = TStrV() + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node: %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.DelAttrDatN(NId, attr2) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node (no int) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.DelAttrN(attr1) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node (no str) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + NIdAttrValue = TStrV() + Graph.AttrValueNI(NId, NIdAttrValue) + AttrLen = NIdAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node (no str) : %i, Attr_Val: %s" % (NId, NIdAttrName.GetI(i)())) + + for i in range(NNodes): + Graph.AddIntAttrDatN(i, 70, attr2) + + total = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + total += NI.GetDat() + NI.Next() + + print("Average: %i (should be 70)" % (total/NNodes)) + + # Test verticaliterator for edge + Graph.AddIntAttrDatE(3, 3*2, attr2) + Graph.AddIntAttrDatE(55, 55*2, attr2) + Graph.AddIntAttrDatE(705, 705*2, attr2) + Graph.AddIntAttrDatE(905, 905*2, attr2) + EdgeId = 0 + EI = Graph.BegEAIntI(attr2) + while EI < Graph.EndEAIntI(attr2): + if EI.GetDat() != TInt.Mn: + print("E Attribute: %s, Edge: %i, Val: %i"\ + % (attr2(), EdgeId, EI.GetDat())) + EdgeId += 1 + EI.Next() + + # Test vertical flt iterator for edge + Graph.AddFltAttrE(attr3, 0.00) + Graph.AddFltAttrDatE(5, 4.41, attr3) + Graph.AddFltAttrDatE(50, 3.718, attr3) + Graph.AddFltAttrDatE(300, 151.0, attr3) + Graph.AddFltAttrDatE(653, 654, attr3) + EdgeId = 0 + EI = Graph.BegEAFltI(attr3) + while EI < Graph.EndEAFltI(attr3): + # Check if defaults are set to 0. + if EI.GetDat() != 0: + print("E Attribute: %s, Edge: %i, Val: %f" % \ + (attr3(), EdgeId, EI.GetDat())) + EdgeId += 1 + EI.Next() + + # Test vertical str iterator for edge + Graph.AddStrAttrDatE(10, TStr("abc"), attr1) + Graph.AddStrAttrDatE(20, TStr("def"), attr1) + Graph.AddStrAttrDatE(400, TStr("ghi"), attr1) + # this does not show since ""=null + Graph.AddStrAttrDatE(455, TStr(""), attr1) + EdgeId = 0 + EI = Graph.BegEAStrI(attr1) + while EI < Graph.EndEAStrI(attr1): + if EI.GetDat() != TStr.GetNullStr(): + print("E Attribute: %s, Edge: %i, Val: %s" %\ + (attr1(), EdgeId, EI.GetDat())) + EdgeId += 1 + EI.Next() + + # Test vertical iterator over many types (must skip default/deleted attr) + EId = 55 + Graph.AddStrAttrDatE(EId, TStr("aaa"), attr1) + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.AddFltAttrDatE(EId, 3.41, attr3) + Graph.AddStrAttrDatE(80, TStr("dont appear"), attr4) # should not show up + EIdAttrName = TStrV() +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge: %i, Attr: %s" % (EId, EIdAttrName.GetI(i))) + + Graph.DelAttrDatE(EId, attr2) +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge (no int) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i))) + + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.DelAttrE(attr1) +# Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge (no str) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + EIdAttrValue = TStrV() + Graph.AttrValueEI(TInt(EId), EIdAttrValue) + AttrLen = EIdAttrValue.Len() + for i in range(AttrLen): + print("Vertical Edge (no str) : %i, Attr_Val: %s" % (EId, EIdAttrValue.GetI(i)())) + + for i in range(NEdges): + Graph.AddIntAttrDatE(i, 70, attr2) + + total = 0 + EI = Graph.BegNAIntI(attr2) + while EI < Graph.EndNAIntI(attr2): + total += EI.GetDat() + EI.Next() + + print("Average: %i (should be 70)" % (total/NEdges)) + + Graph.Clr() + +if __name__ == '__main__': + print("----- DefaultConstructor -----") + DefaultConstructor() + print("----- ManipulateNodesEdges -----") + ManipulateNodesEdges() + print("----- ManipulateNodesEdgesAttributes -----") + ManipulateNodeEdgeAttributes() + diff --git a/snap-python/source/test/ops.py b/snap-python/source/test/ops.py new file mode 100644 index 0000000000000000000000000000000000000000..331dd740a791ab1c215d2d0a551a30a147c8f25f --- /dev/null +++ b/snap-python/source/test/ops.py @@ -0,0 +1,98 @@ +import snap + +#G6 = snap.GenForestFire(100000, 0.25, 0.25) +G6 = snap.GenRndGnm(snap.PNGraph, 10000, 5000) +print("type(G6) %s" % (type(G6))) +print("G6 nodes %d, edges %d" % (G6.GetNodes(), G6.GetEdges())) + +l = [] +for EI in G6.Edges(): + src = EI.GetSrcNId() + dst = EI.GetDstNId() + if EI.GetSrcNId() > EI.GetDstNId(): + dst = EI.GetSrcNId() + src = EI.GetDstNId() + + l.append((src,dst)) + +l.sort() +#for item in l: +# print("G6\t%d\t%d" % (item[0], item[1])) + + +G7 = snap.ConvertGraph(snap.PUNGraph, G6) +print("type(G7) %s" % (type(G7))) +print("G7 nodes %d, edges %d" % (G7.GetNodes(), G7.GetEdges())) + +l = [] +for EI in G7.Edges(): + src = EI.GetSrcNId() + dst = EI.GetDstNId() + if EI.GetSrcNId() > EI.GetDstNId(): + dst = EI.GetSrcNId() + src = EI.GetDstNId() + + l.append((src,dst)) + +l.sort() +#for item in l: +# print("G7\t%d\t%d" % (item[0], item[1])) + +WccG6 = snap.GetMxWcc(G6) +print("type(WccG6) %s" % (type(WccG6))) +print("WccG6 nodes %d, edges %d" % (WccG6.GetNodes(), WccG6.GetEdges())) + +WccG7 = snap.GetMxWcc(G7) +print("type(WccG7) %s" % (type(WccG7))) +print("WccG7 nodes %d, edges %d" % (WccG7.GetNodes(), WccG7.GetEdges())) + +SccG6 = snap.GetMxScc(G6) +print("type(SccG6) %s" % (type(SccG6))) +print("SccG6 nodes %d, edges %d" % (SccG6.GetNodes(), SccG6.GetEdges())) + +SccG7 = snap.GetMxScc(G7) +print("type(SccG7) %s" % (type(SccG7))) +print("SccG7 nodes %d, edges %d" % (SccG7.GetNodes(), SccG7.GetEdges())) + +SubG6 = snap.GetSubGraph(G6, snap.TIntV.GetV(0,1,2,3,4)) +print("type(SubG6) %s" % (type(SubG6))) +print("SubG6 nodes %d, edges %d" % (SubG6.GetNodes(), SubG6.GetEdges())) +for EI in SubG6.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + +Core3G6 = snap.GetKCore(G6, 3) +print("type(Core3G6) %s" % (type(Core3G6))) +print("CoreG6 nodes %d, edges %d" % (Core3G6.GetNodes(), Core3G6.GetEdges())) + +G8 = snap.GenRndGnm(snap.PNGraph, 1000, 100000) +print("type(G8) %s" % (type(G8))) +print("G8 nodes %d, edges %d" % (G8.GetNodes(), G8.GetEdges())) + +WccG8 = snap.GetMxWcc(G8) +print("type(WccG8) %s" % (type(WccG8))) +print("WccG8 nodes %d, edges %d" % (WccG8.GetNodes(), WccG8.GetEdges())) + +WccG7 = snap.GetMxWcc(G7) +print("type(WccG7) %s" % (type(WccG7))) +print("WccG7 nodes %d, edges %d" % (WccG7.GetNodes(), WccG7.GetEdges())) + +SccG8 = snap.GetMxScc(G8) +print("type(SccG8) %s" % (type(SccG8))) +print("SccG8 nodes %d, edges %d" % (SccG8.GetNodes(), SccG8.GetEdges())) + +SccG7 = snap.GetMxScc(G7) +print("type(SccG7) %s" % (type(SccG7))) +print("SccG7 nodes %d, edges %d" % (SccG7.GetNodes(), SccG7.GetEdges())) + +SubG8 = snap.GetSubGraph(G8, snap.TIntV.GetV(0,1,2,3,4)) +print("type(SubG8) %s" % (type(SubG8))) +print("SubG8 nodes %d, edges %d" % (SubG8.GetNodes(), SubG8.GetEdges())) +for EI in SubG8.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + +Core3G8 = snap.GetKCore(G8, 3) +print("type(Core3G8) %s" % (type(Core3G8))) +print("CoreG8 nodes %d, edges %d" % (Core3G8.GetNodes(), Core3G8.GetEdges())) + + + diff --git a/snap-python/source/test/ops1.py b/snap-python/source/test/ops1.py new file mode 100644 index 0000000000000000000000000000000000000000..3c9b3b01f7a7f2fb94a470981585646032518a37 --- /dev/null +++ b/snap-python/source/test/ops1.py @@ -0,0 +1,31 @@ +import snap + +#G6 = snap.GenForestFire(100000, 0.25, 0.25) +G6 = snap.GenRndGnm(snap.PNGraph, 10000, 5000) +print("type(G6) %s" % (type(G6))) +print("G6 nodes %d, edges %d" % (G6.GetNodes(), G6.GetEdges())) + +G7 = snap.ConvertGraph(snap.PUNGraph, G6) +print("type(G7) %s" % (type(G7))) +print("G7 nodes %d, edges %d" % (G7.GetNodes(), G7.GetEdges())) + +WccG6 = snap.GetMxWcc(G6) +print("type(WccG6) %s" % (type(WccG6))) +print("WccG6 nodes %d, edges %d" % (WccG6.GetNodes(), WccG6.GetEdges())) + +G8 = snap.GenForestFire(1000, 0.35, 0.35) +print("type(G8) %s" % (type(G8))) +print("G8 nodes %d, edges %d" % (G8.GetNodes(), G8.GetEdges())) + +SubG8 = snap.GetSubGraph(G8, snap.TIntV.GetV(0,1,2,3,4)) +print("type(SubG8) %s" % (type(SubG8))) +print("SubG8 nodes %d, edges %d" % (SubG8.GetNodes(), SubG8.GetEdges())) + +Core3G8 = snap.GetKCore(G8, 3) +print("type(Core3G8) %s" % (type(Core3G8))) +print("CoreG8 nodes %d, edges %d" % (Core3G8.GetNodes(), Core3G8.GetEdges())) + +snap.DelDegKNodes(G8, 3, 2) +print("type(G8) %s" % (type(G8))) +print("G8 nodes %d, edges %d" % (G8.GetNodes(), G8.GetEdges())) + diff --git a/snap-python/source/test/pagerank.py b/snap-python/source/test/pagerank.py new file mode 100644 index 0000000000000000000000000000000000000000..14029aa7d826dc62469c31cae6cb0d98c27c8116 --- /dev/null +++ b/snap-python/source/test/pagerank.py @@ -0,0 +1,20 @@ +import snap + +Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) +PRankH = snap.TIntFltH() +snap.GetPageRank(Graph, PRankH) +for item in PRankH: + print(item, PRankH[item]) + +Graph = snap.GenRndGnm(snap.PUNGraph, 5000000, 50000000) +PRankH = snap.TIntFltH() +snap.GetPageRank(Graph, PRankH) +for item in PRankH: + print(item, PRankH[item]) + +Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) +PRankH = snap.TIntFltH() +snap.GetPageRank(Graph, PRankH) +for item in PRankH: + print(item, PRankH[item]) + diff --git a/snap-python/source/test/plotdeg.py b/snap-python/source/test/plotdeg.py new file mode 100644 index 0000000000000000000000000000000000000000..aa8e026da6bb86764da5d95f4fab53a5efdfac4b --- /dev/null +++ b/snap-python/source/test/plotdeg.py @@ -0,0 +1,11 @@ +import snap + +G1 = snap.GenRndGnm(snap.PNGraph, 100, 1000) +snap.PlotInDegDistr(G1, 'test_directed', 'test for directed gragh', 0, 0) + +G2 = snap.GenRndGnm(snap.PUNGraph, 100, 1000) +snap.PlotInDegDistr(G2, 'test_undirected', 'test for undirected gragh', 0, 0) + +G3 = snap.GenRndGnm(snap.PNEANet, 100, 1000) +snap.PlotInDegDistr(G3, 'test_neanet', 'test for neanet', 0, 0) + diff --git a/snap-python/source/test/printsnap.py b/snap-python/source/test/printsnap.py new file mode 100644 index 0000000000000000000000000000000000000000..b7fd983b34ccb6f04d667dd413982f92545e26ae --- /dev/null +++ b/snap-python/source/test/printsnap.py @@ -0,0 +1,6 @@ +import snap + +s = dir(snap) +for item in s: + print(item) + diff --git a/snap-python/source/test/printstat.py b/snap-python/source/test/printstat.py new file mode 100644 index 0000000000000000000000000000000000000000..96cbac06d1fba5bfc548d8c2ab02731c5a473c47 --- /dev/null +++ b/snap-python/source/test/printstat.py @@ -0,0 +1,24 @@ +# printstat.py +# python printstat.py data/p2p-Gnutella08.txt p2p + +import os +import sys + +sys.path.insert(0,"../swig") + +import snap + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print("Usage: " + sys.argv[0] + " ") + sys.exit(1) + + gname = sys.argv[1] + header = sys.argv[2] + + tlabel = snap.TStr(os.path.splitext(gname)[0]) + theader = snap.TStr(header) + + g = snap.LoadEdgeList(snap.PNGraph, gname, 0, 1) + snap.PrintGraphStatTable(g,tlabel,theader) diff --git a/snap-python/source/test/props.py b/snap-python/source/test/props.py new file mode 100644 index 0000000000000000000000000000000000000000..841621c2272d5c3fe81a78ab14d0a4eca4a02690 --- /dev/null +++ b/snap-python/source/test/props.py @@ -0,0 +1,31 @@ +import snap + +G9 = snap.GenRndGnm(snap.PNGraph, 10000, 1000) + +CntV = snap.TIntPrV() +snap.GetWccSzCnt(G9, CntV) +for p in CntV: + print("size %d: count %d" % (p.GetVal1(), p.GetVal2())) + +snap.GetOutDegCnt(G9, CntV) +for p in CntV: + print("degree %d: count %d" % (p.GetVal1(), p.GetVal2())) + +G10 = snap.GenPrefAttach(100, 3) + +EigV = snap.TFltV() +snap.GetEigVec(G10, EigV) +nr = 0 +for f in EigV: + nr += 1 + print("%d: %.6f" % (nr, f)) + +diam = snap.GetBfsFullDiam(G10, 10) +print("diam", diam) + +triads = snap.GetTriads(G10) +print("triads", triads) + +cf = snap.GetClustCf(G10) +print("cf", cf) + diff --git a/snap-python/source/test/quick_test.py b/snap-python/source/test/quick_test.py new file mode 100644 index 0000000000000000000000000000000000000000..3fe9231b60ced39df127e0343e4411296bdb1c43 --- /dev/null +++ b/snap-python/source/test/quick_test.py @@ -0,0 +1,15 @@ +status = False +try: + import snap + version = snap.Version + i = snap.TInt(5) + if i == 5: + status = True +except: + pass + +if status: + print("SUCCESS, your version of Snap.py is %s" % (version)) +else: + print("*** ERROR, no working Snap.py was found on your computer") + diff --git a/snap-python/source/test/readgraph.py b/snap-python/source/test/readgraph.py new file mode 100644 index 0000000000000000000000000000000000000000..d2d888973642a4c10a2ed94e79398be6accf765e --- /dev/null +++ b/snap-python/source/test/readgraph.py @@ -0,0 +1,97 @@ +import os +import sys +import time + +import snap + +def SaveConnList(G, name): + fout = open(name, "w") + for NI in G.Nodes(): + l = [] + l.append(NI.GetId()) + for Id in NI.GetOutEdges(): + l.append(Id) + + l1 = list(map(lambda x: str(x), l)) + fout.write(" ".join(l1) + "\n") + fout.close() + +def printtime(tprev, note): + t = time.time() + lt = time.localtime(t) + # get the time and add milliseconds + s = time.strftime("%H:%M:%S", lt) + ("%.3f" % (t - int(t)))[1:] + delta = "%9.3f" % (t - tprev) + print(s, delta, note) + + return t + +if __name__ == '__main__': + + if len(sys.argv) < 3: + print("Usage: " + sys.argv[0] + " ") + sys.exit(1) + + nodes = int(sys.argv[1]) + degree = int(sys.argv[2]) + + name = "test-%d-%d" % (nodes, degree) + txtname = name + ".txt" + adjname = name + "-adj" + ".txt" + binname = name + ".bin" + + print("nodes", nodes) + print("degree", degree) + + t = time.time() + t = printtime(t, "generating the graph") + + G1 = snap.GenPrefAttach(nodes, degree) + print("G1 nodes", G1.GetNodes()) + print("G1 edges", G1.GetEdges()) + + t = printtime(t, "saving the graph to edge list") + G1.SaveEdgeList(txtname, "Save as tab-separated list of edges") + + t = printtime(t, "reading the graph from edge list") + G2 = snap.LoadEdgeList(snap.TUNGraph, txtname, 0, 1) + print("G2 nodes", G2.GetNodes()) + print("G2 edges", G2.GetEdges()) + + t = printtime(t, "saving the graph to adjacency list") + SaveConnList(G1, adjname) + + t = printtime(t, "reading the graph from adjacency list") + G3 = snap.LoadConnList(snap.TUNGraph, adjname) + print("G3 nodes", G3.GetNodes()) + print("G3 edges", G3.GetEdges()) + + t = printtime(t, "saving the graph to binary") + FOut = snap.TFOut(binname) + G1.Save(FOut) + FOut.Flush() + + t = printtime(t, "reading the graph from binary") + FIn = snap.TFIn(binname) + G4 = snap.TUNGraph.Load(FIn) + print("G4 nodes", G4.GetNodes()) + print("G4 edges", G4.GetEdges()) + + t = printtime(t, "reading the graph as table") + context = snap.TTableContext() + + schema = snap.Schema() + schema.Add(snap.TStrTAttrPr("SrcID", snap.atInt)) + schema.Add(snap.TStrTAttrPr("DstID", snap.atInt)) + + T1 = snap.TTable.LoadSS(schema, txtname, context, "\t", snap.TBool(False)) + print("T1 rows", T1.GetNumRows()) + + t = printtime(t, "converting table to graph") + G5 = snap.ToGraph(snap.PUNGraph, T1, "SrcID", "DstID", snap.aaFirst) + print("G5 nodes", G5.GetNodes()) + print("G5 edges", G5.GetEdges()) + + printtime(t, "done") + t = printtime(t, "reading the graph as table") + diff --git a/snap-python/source/test/readvec.py b/snap-python/source/test/readvec.py new file mode 100644 index 0000000000000000000000000000000000000000..e6059bb6bbdd514faea17567c4230802a717abeb --- /dev/null +++ b/snap-python/source/test/readvec.py @@ -0,0 +1,24 @@ +import os +import sys +import time + +sys.path.append("/home/rok/git/rok/snapworld") +import snap as Snap + +if __name__ == '__main__': + + if len(sys.argv) < 2: + print("Usage: " + sys.argv[0] + " ") + sys.exit(1) + + fname = sys.argv[1] + + FIn = Snap.TFIn(Snap.TStr(fname)) + Vec = Snap.TIntV(FIn) + print("len", Vec.Len()) + + Vec.Sort() + + for i in range(0,Vec.Len()): + print("Vec", i, Vec.GetVal(i).Val) + diff --git a/snap-python/source/test/rnd.py b/snap-python/source/test/rnd.py new file mode 100644 index 0000000000000000000000000000000000000000..207265b4f6b91021bd630cddf57772570feab4cc --- /dev/null +++ b/snap-python/source/test/rnd.py @@ -0,0 +1,16 @@ +import snap + +Graph = snap.GenFull(snap.PNEANet, 100) + +for i in xrange(0,10): + print("node id ", Graph.GetRndNId()) + +#for i in xrange(0,10): +# print("node ni", Graph.GetRndNI().GetId()) + +for i in xrange(0,10): + print("edge id ", Graph.GetRndEId()) + +#for i in xrange(0,10): +# print("edge ni", Graph.GetRndEI().GetId()) + diff --git a/snap-python/source/test/snap-test-pylayer.py b/snap-python/source/test/snap-test-pylayer.py new file mode 100644 index 0000000000000000000000000000000000000000..4ee4bf0e06608a63fd2c0c259bda2b12a59ce9e6 --- /dev/null +++ b/snap-python/source/test/snap-test-pylayer.py @@ -0,0 +1,3693 @@ +# coding: utf-8 +import hashlib +import math +import os +import re +import time +import unittest + +import snap + +PATH_TO_GNUTELLA = "data/p2p-Gnutella08.txt" + +class SnapPythonTest(unittest.TestCase): + + def __init__(self, *args, **kwargs): + self.gnutella = snap.LoadEdgeList(snap.TNGraph, PATH_TO_GNUTELLA) + super(SnapPythonTest, self).__init__(*args, **kwargs) + + def setUp(self): + # Defaults for creating graphs + self.num_nodes = 10 + + # Full Graphs + self.DirGraphFull = snap.GenFull(snap.TNGraph, self.num_nodes) + self.UnDirGraphFull = snap.GenFull(snap.TUNGraph, self.num_nodes) + self.NetFull = snap.GenFull(snap.TNEANet, self.num_nodes) + + # Star Graphs + self.DirGraphStar = snap.GenStar(snap.TNGraph, self.num_nodes) + self.UnDirGraphStar = snap.GenStar(snap.TUNGraph, self.num_nodes) + self.NetStar = snap.GenStar(snap.TNEANet, self.num_nodes) + + # Graph With Self Edges + self.DirGraphSelfEdge = snap.GenRndGnm(snap.TNGraph, 10, 20) + self.DirGraphSelfEdge.AddEdge(0, 0) + self.UnDirGraphSelfEdge = snap.GenRndGnm(snap.TUNGraph, 10, 20) + self.UnDirGraphSelfEdge.AddEdge(0, 0) + self.NetSelfEdge = snap.GenRndGnm(snap.TNEANet, 10, 20) + self.NetSelfEdge.AddEdge(0, 0) + + # Graph With Multiple Zero-Degree Nodes + self.DirGraphZeroDegree = snap.GenRndGnm(snap.TNGraph, 10, 1) + self.UnDirGraphZeroDegree = snap.GenRndGnm(snap.TUNGraph, 10, 1) + self.NetZeroDegree = snap.GenRndGnm(snap.TNEANet, 10, 1) + + # Trees + self.DirTree = snap.GenTree(snap.TNGraph, 3, 3) + self.UnDirTree = snap.GenTree(snap.TUNGraph, 3, 3) + self.NetTree = snap.GenTree(snap.TNEANet, 3, 3) + + # Random + self.DirRand = snap.GenRndGnm(snap.TNGraph, 10, 20) + self.UnDirRand = snap.GenRndGnm(snap.TUNGraph, 10, 20) + self.NetRand = snap.GenRndGnm(snap.TNEANet, 10, 20) + + # Grid + self.DirGrid = snap.GenGrid(snap.TNGraph, 3, 3, False) + self.UnDirGrid = snap.GenGrid(snap.TUNGraph, 3, 3) + self.NetGrid = snap.GenGrid(snap.TNEANet, 3, 3, False) + + # Petersen graph + Graph = snap.TUNGraph.New() + for i in range(10): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i+1) % 5) + for i in range(5): + Graph.AddEdge(i + 5,(i+2) % 5 + 5) + for i in range(5): + Graph.AddEdge(i,i + 5) + self.UPetersen = Graph + #snap.DrawGViz(Graph, snap.gvlDot, "upetersen.png", "petersen 1") + + # directed Petersen graph + Graph = snap.TNGraph.New() + for i in range(10): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i+1) % 5) + for i in range(5): + Graph.AddEdge(i + 5,(i+2) % 5 + 5) + for i in range(5): + Graph.AddEdge(i,i + 5) + self.DPetersen = Graph + #snap.DrawGViz(Graph, snap.gvlDot, "dpetersen.png", "petersen 2") + + # directed Petersen network + self.NPetersen = self.DPetersen.ConvertGraph(snap.TNEANet) + #snap.DrawGViz(self.NPetersen, snap.gvlDot, "npetersen.png", "petersen 3") + + self.PetersenGraphs = [ self.UPetersen, self.DPetersen, self.NPetersen ] + + #### Helper Functions for Tests #### + + def checkPlotHash(self, gen_file, exp_hash): + self.assertTrue(os.path.isfile(gen_file)) + f = open(gen_file,'r') + lines = f.readlines() + f.close() + # remove comments, since these include time + newlines = [] + for line in lines: + if len(line) > 0 and line[0] == "#": + continue + newlines.append(line) + # remove carriage return, which is included on Windows + newcontent = str("".join(newlines).replace("\r","")).encode("utf-8") + act_hash = hashlib.md5(newcontent).hexdigest() + self.assertEqual(exp_hash, act_hash) + + def getFileHash(self, fname): + f = open(fname, 'r') + content = f.read() + f.close() + newcontent = str(content.replace("\r","")).encode("utf-8") + test_hash = hashlib.md5(newcontent).hexdigest() + return test_hash + + def checkPrintInfoOutput(self, filename, params): + count = 0 + with open(filename) as f: + for line in f: + if count == 0: + firstLine = line.split(':') + self.assertEqual(params[count], firstLine[0]) + else: + result = re.findall('[0-9]+', line) + self.assertEqual(params[count], result[0]) + count += 1 + + def checkGraphs(self, G1, G2): + nodes1 = [item.GetId() for item in G1.Nodes()] + nodes1.sort() + nodes2 = [item.GetId() for item in G2.Nodes()] + nodes2.sort() + for node1,node2 in zip(nodes1, nodes2): + self.assertEqual(node1, node2) + edges1 = [(item.GetSrcNId(), item.GetDstNId()) for item in G1.Edges()] + edges1.sort() + edges2 = [(item.GetSrcNId(), item.GetDstNId()) for item in G2.Edges()] + edges2.sort() + for edge1,edge2 in zip(edges1, edges2): + self.assertEqual(edge1, edge2) + + #### Tests #### + + def test_GenFull(self): + # Directed Graph + Graph_swig = snap.GenFull(snap.PNGraph, 5) + Graph = snap.GenFull(snap.TNGraph, 5) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Undirected Graph + Graph_swig = snap.GenFull(snap.PUNGraph, 5) + Graph = snap.GenFull(snap.TUNGraph, 5) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Network + Graph_swig = snap.GenFull(snap.PNEANet, 5) + Graph = snap.GenFull(snap.TNEANet, 5) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + def test_GenCircle(self): + # Directed Graph + Graph_swig = snap.GenCircle(snap.PNGraph, 10, 2) + Graph = snap.GenCircle(snap.TNGraph, 10, 2) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Undirected Graph + Graph_swig = snap.GenCircle(snap.PUNGraph, 10, 2) + Graph = snap.GenCircle(snap.TUNGraph, 10, 2) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Network + Graph_swig = snap.GenCircle(snap.PNEANet, 10, 2) + Graph = snap.GenCircle(snap.TNEANet, 10, 2) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + def test_GenGrid(self): + # Directed Graph + Graph_swig = snap.GenGrid(snap.PNGraph, 2, 2) + Graph = snap.GenGrid(snap.TNGraph, 2, 2) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Undirected Graph + Graph_swig = snap.GenGrid(snap.PUNGraph, 2, 2) + Graph = snap.GenGrid(snap.TUNGraph, 2, 2) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Network + Graph_swig = snap.GenGrid(snap.PNEANet, 2, 2) + Graph = snap.GenGrid(snap.TNEANet, 2, 2) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + def test_GenStar(self): + # Directed Graph + Graph_swig = snap.GenStar(snap.PNGraph, 5) + Graph = snap.GenStar(snap.TNGraph, 5) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Undirected Graph + Graph_swig = snap.GenStar(snap.PUNGraph, 5) + Graph = snap.GenStar(snap.TUNGraph, 5) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Network + Graph_swig = snap.GenStar(snap.PNEANet, 5) + Graph = snap.GenStar(snap.TNEANet, 5) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + def test_GenTree(self): + # Directed Graph + Graph_swig = snap.GenTree(snap.PNGraph, 3, 3) + Graph = snap.GenTree(snap.TNGraph, 3, 3) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Undirected Graph + Graph_swig = snap.GenTree(snap.PUNGraph, 3, 3) + Graph = snap.GenTree(snap.TUNGraph, 3, 3) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Network + Graph_swig = snap.GenTree(snap.PNEANet, 3, 3) + Graph = snap.GenTree(snap.TNEANet, 3, 3) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + def test_GenRndGnm(self): + # Directed Graph + Graph_swig = snap.GenRndGnm(snap.PNGraph, 100, 1000) + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Undirected Graph + Graph_swig = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Network + Graph_swig = snap.GenRndGnm(snap.PNEANet, 100, 1000) + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + def test_GenBaraHierar(self): + # Directed Graph + Graph_swig = snap.GenBaraHierar(snap.PNGraph, 3, True) + Graph = snap.GenBaraHierar(snap.TNGraph, 3, True) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Undirected Graph + Graph_swig = snap.GenBaraHierar(snap.PUNGraph, 3, True) + Graph = snap.GenBaraHierar(snap.TUNGraph, 3, True) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + # Network + Graph_swig = snap.GenBaraHierar(snap.PNEANet, 3, True) + Graph = snap.GenBaraHierar(snap.TNEANet, 3, True) + self.assertEqual(Graph_swig.GetNodes(), Graph.GetNodes()) + self.assertEqual(Graph_swig.GetEdges(), Graph.GetEdges()) + + def test_CntInDegNodes(self): + # Directed graph + num_nodes = self.DirGraphFull.CntInDegNodes(self.num_nodes-1) + num_nodes_swig = snap.CntInDegNodes(self.DirGraphFull, self.num_nodes-1) + self.assertEqual(num_nodes, num_nodes_swig) + + # Undirected Graph + num_nodes = self.UnDirGraphFull.CntInDegNodes(self.num_nodes-1) + num_nodes_swig = snap.CntInDegNodes(self.UnDirGraphFull, self.num_nodes-1) + self.assertEqual(num_nodes, num_nodes_swig) + + # Network + num_nodes = self.NetFull.CntInDegNodes(self.num_nodes-1) + num_nodes_swig = snap.CntInDegNodes(self.NetFull, self.num_nodes-1) + self.assertEqual(num_nodes, num_nodes_swig) + + def test_CntOutDegNodes(self): + # Directed Graph + num_nodes = self.DirGraphFull.CntOutDegNodes(self.num_nodes-1) + num_nodes_swig = snap.CntOutDegNodes(self.DirGraphFull, self.num_nodes-1) + self.assertEqual(num_nodes, num_nodes_swig) + + # Undirected Graph + num_nodes = self.UnDirGraphFull.CntOutDegNodes(self.num_nodes-1) + num_nodes_swig = snap.CntOutDegNodes(self.UnDirGraphFull, self.num_nodes-1) + self.assertEqual(num_nodes, num_nodes_swig) + + # Network + num_nodes = self.NetFull.CntOutDegNodes(self.num_nodes-1) + num_nodes_swig = snap.CntOutDegNodes(self.NetFull, self.num_nodes-1) + self.assertEqual(num_nodes, num_nodes_swig) + + def test_CntDegNodes(self): + # Directed Graph - it will have twice the edges as the undirected graph + num_nodes = self.DirGraphFull.CntDegNodes(2*(self.num_nodes-1)) + num_nodes_swig = snap.CntDegNodes(self.DirGraphFull, 2*(self.num_nodes-1)) + self.assertEqual(num_nodes, num_nodes_swig) + + # Undirected Graph + num_nodes = self.UnDirGraphFull.CntDegNodes(self.num_nodes-1) + num_nodes_swig = snap.CntDegNodes(self.UnDirGraphFull, self.num_nodes-1) + self.assertEqual(num_nodes, num_nodes_swig) + + # Network + num_nodes = self.NetFull.CntDegNodes(2*(self.num_nodes-1)) + num_nodes_swig = snap.CntDegNodes(self.NetFull, 2*(self.num_nodes-1)) + self.assertEqual(num_nodes, num_nodes_swig) + + def test_CntNonZNodes(self): + # Directed Graph + num_nodes = self.DirGraphFull.CntNonZNodes() + num_nodes_swig = snap.CntNonZNodes(self.DirGraphFull) + self.assertEqual(num_nodes, num_nodes_swig) + + # Undirected Graph + num_nodes = self.UnDirGraphFull.CntNonZNodes() + num_nodes_swig = snap.CntNonZNodes(self.UnDirGraphFull) + self.assertEqual(num_nodes, num_nodes_swig) + + # Network + num_nodes = self.NetFull.CntNonZNodes() + num_nodes_swig = snap.CntNonZNodes(self.NetFull) + self.assertEqual(num_nodes, num_nodes_swig) + + def test_GetMxDegNId(self): + # Directed Graph + max_id = self.DirGraphStar.GetMxDegNId() + max_id_swig = snap.GetMxDegNId(self.DirGraphStar) + self.assertEqual(max_id, max_id_swig) + + # Undirected Graph + max_id = self.UnDirGraphStar.GetMxDegNId() + max_id_swig = snap.GetMxDegNId(self.UnDirGraphStar) + self.assertEqual(max_id, max_id_swig) + + # Network + max_id = self.NetStar.GetMxDegNId() + max_id_swig = snap.GetMxDegNId(self.NetStar) + self.assertEqual(max_id, max_id_swig) + + def test_GetMxInDegNId(self): + # Directed Graph + # node with id 0 is the only node with in-degree 0 + max_id = self.DirGrid.GetMxInDegNId() + max_id_swig = snap.GetMxInDegNId(self.DirGrid) + self.assertEqual(max_id, max_id_swig) + + # Undirected Graph + max_id = self.UnDirGrid.GetMxInDegNId() + max_id_swig = snap.GetMxInDegNId(self.UnDirGrid) + self.assertEqual(max_id, max_id_swig) + + # Network + # node with id 0 is the only node with in-degree 0 + max_id = self.NetGrid.GetMxInDegNId() + max_id_swig = snap.GetMxInDegNId(self.NetGrid) + self.assertEqual(max_id, max_id_swig) + + def test_GetMxOutDegNId(self): + # Directed Graph + max_id = self.DirGraphStar.GetMxOutDegNId() + max_id_swig = snap.GetMxOutDegNId(self.DirGraphStar) + self.assertEqual(max_id, max_id_swig) + + # Undirected Graph + max_id = self.UnDirGraphStar.GetMxOutDegNId() + max_id_swig = snap.GetMxOutDegNId(self.UnDirGraphStar) + self.assertEqual(max_id, max_id_swig) + + # Network + max_id = self.NetStar.GetMxOutDegNId() + max_id_swig = snap.GetMxOutDegNId(self.NetStar) + self.assertEqual(max_id, max_id_swig) + + def test_GetInDegCnt(self): + # Directed Graph + DegToCntV = self.DirGraphFull.GetInDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetInDegCnt(self.DirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Undirected Graph + DegToCntV = self.UnDirGraphFull.GetInDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetInDegCnt(self.UnDirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Network + DegToCntV = self.NetFull.GetInDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetInDegCnt(self.NetFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + def test_GetOutDegCnt(self): + # Directed Graph + DegToCntV = self.DirGraphFull.GetOutDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetOutDegCnt(self.DirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Undirected Graph + DegToCntV = self.UnDirGraphFull.GetOutDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetOutDegCnt(self.UnDirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Network + DegToCntV = self.NetFull.GetOutDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetOutDegCnt(self.NetFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + def test_GetDegCnt(self): + # Directed Graph + DegToCntV = self.DirGraphFull.GetDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetDegCnt(self.DirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Undirected Graph + DegToCntV = self.UnDirGraphFull.GetDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetDegCnt(self.UnDirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Network + DegToCntV = self.NetFull.GetDegCnt() + DegToCntV_swig = snap.TIntPrV() + snap.GetDegCnt(self.NetFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + def test_GetNodeInDegV(self): + # Directed Graph + DegToCntV = self.DirGraphFull.GetNodeInDegV() + DegToCntV_swig = snap.TIntPrV() + snap.GetNodeInDegV(self.DirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Undirected Graph + DegToCntV = self.UnDirGraphFull.GetNodeInDegV() + DegToCntV_swig = snap.TIntPrV() + snap.GetNodeInDegV(self.UnDirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Network + DegToCntV = self.NetFull.GetNodeInDegV() + DegToCntV_swig = snap.TIntPrV() + snap.GetNodeInDegV(self.NetFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + def test_GetNodeOutDegV(self): + # Directed Graph + DegToCntV = self.DirGraphFull.GetNodeOutDegV() + DegToCntV_swig = snap.TIntPrV() + snap.GetNodeOutDegV(self.DirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Undirected Graph + DegToCntV = self.UnDirGraphFull.GetNodeOutDegV() + DegToCntV_swig = snap.TIntPrV() + snap.GetNodeOutDegV(self.UnDirGraphFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + # Network + DegToCntV = self.NetFull.GetNodeOutDegV() + DegToCntV_swig = snap.TIntPrV() + snap.GetNodeOutDegV(self.NetFull, DegToCntV_swig) + self.assertEqual(DegToCntV, DegToCntV_swig) + + def test_GetDegSeqV(self): + # Directed Graph + V = self.DirGraphFull.GetDegSeqV(Dir = False) + V_swig = snap.TIntV() + snap.GetDegSeqV(self.DirGraphFull, V_swig) + self.assertEqual(V, V_swig) + + # Undirected Graph + V = self.UnDirGraphFull.GetDegSeqV(Dir = False) + V_swig = snap.TIntV() + snap.GetDegSeqV(self.UnDirGraphFull, V_swig) + self.assertEqual(V, V_swig) + + # Network + V = self.NetFull.GetDegSeqV(Dir = False) + V_swig = snap.TIntV() + snap.GetDegSeqV(self.NetFull, V_swig) + self.assertEqual(V, V_swig) + + def test_GetDegSeqV2(self): + # Directed Graph + V, V2 = self.DirGraphFull.GetDegSeqV(Dir = True) + V_swig = snap.TIntV() + V2_swig = snap.TIntV() + snap.GetDegSeqV(self.DirGraphFull, V_swig, V2_swig) + self.assertEqual(V, V_swig) + self.assertEqual(V2, V2_swig) + + # Undirected Graph + V, V2 = self.UnDirGraphFull.GetDegSeqV(Dir = True) + V_swig = snap.TIntV() + V2_swig = snap.TIntV() + snap.GetDegSeqV(self.UnDirGraphFull, V_swig, V2_swig) + self.assertEqual(V, V_swig) + self.assertEqual(V2, V2_swig) + + # Network + V, V2 = self.NetFull.GetDegSeqV(Dir = True) + V_swig = snap.TIntV() + V2_swig = snap.TIntV() + snap.GetDegSeqV(self.NetFull, V_swig, V2_swig) + self.assertEqual(V, V_swig) + self.assertEqual(V2, V2_swig) + + def test_CntUniqUndirEdges(self): + # Directed Graph + num_edges = self.DirGraphFull.CntUniqUndirEdges() + num_edges_swig = snap.CntUniqUndirEdges(self.DirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Unidrected Graph + num_edges = self.UnDirGraphFull.CntUniqUndirEdges() + num_edges_swig = snap.CntUniqUndirEdges(self.UnDirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Network + num_edges = self.NetFull.CntUniqUndirEdges() + num_edges_swig = snap.CntUniqUndirEdges(self.NetFull) + self.assertEqual(num_edges, num_edges_swig) + + def test_CntUniqDirEdges(self): + # Directed Graph + num_edges = self.DirGraphFull.CntUniqDirEdges() + num_edges_swig = snap.CntUniqDirEdges(self.DirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Unidrected Graph + num_edges = self.UnDirGraphFull.CntUniqDirEdges() + num_edges_swig = snap.CntUniqDirEdges(self.UnDirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Network + num_edges = self.NetFull.CntUniqDirEdges() + num_edges_swig = snap.CntUniqDirEdges(self.NetFull) + self.assertEqual(num_edges, num_edges_swig) + + def test_CntUniqBiDirEdges(self): + # Directed Graph + num_edges = self.DirGraphFull.CntUniqBiDirEdges() + num_edges_swig = snap.CntUniqBiDirEdges(self.DirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Unidrected Graph + num_edges = self.UnDirGraphFull.CntUniqBiDirEdges() + num_edges_swig = snap.CntUniqBiDirEdges(self.UnDirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Network + num_edges = self.NetFull.CntUniqBiDirEdges() + num_edges_swig = snap.CntUniqBiDirEdges(self.NetFull) + self.assertEqual(num_edges, num_edges_swig) + + def test_CntSelfEdges(self): + # Directed Graph + num_edges = self.DirGraphFull.CntSelfEdges() + num_edges_swig = snap.CntSelfEdges(self.DirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Undirected Graph + num_edges = self.UnDirGraphFull.CntSelfEdges() + num_edges_swig = snap.CntSelfEdges(self.UnDirGraphFull) + self.assertEqual(num_edges, num_edges_swig) + + # Network + num_edges = self.NetFull.CntSelfEdges() + num_edges_swig = snap.CntSelfEdges(self.NetFull) + self.assertEqual(num_edges, num_edges_swig) + + def test_GetUnDir(self): + # Directed Graph + New_Graph = self.DirGraphStar.GetUnDir() + New_Graph_swig = snap.GetUnDir(self.DirGraphStar) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Undirected Graph + New_Graph = self.UnDirGraphStar.GetUnDir() + New_Graph_swig = snap.GetUnDir(self.UnDirGraphStar) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Network + New_Graph = self.NetStar.GetUnDir() + New_Graph_swig = snap.GetUnDir(self.NetStar) + self.checkGraphs(New_Graph, New_Graph_swig) + + def test_MakeUnDir(self): + # Directed Graph + New_Graph = self.DirGraphStar.ConvertGraph(snap.TNGraph) + New_Graph.MakeUnDir() + New_Graph_swig = snap.ConvertGraph(snap.PNGraph, self.DirGraphStar) + snap.MakeUnDir(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Undirected Graph + New_Graph = self.UnDirGraphStar.ConvertGraph(snap.TUNGraph) + New_Graph.MakeUnDir() + New_Graph_swig = snap.ConvertGraph(snap.PUNGraph, self.UnDirGraphStar) + snap.MakeUnDir(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Network + New_Graph = self.NetStar.ConvertGraph(snap.TNEANet) + New_Graph.MakeUnDir() + New_Graph_swig = snap.ConvertGraph(snap.PNEANet, self.NetStar) + snap.MakeUnDir(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + def test_AddSelfEdges(self): + # Directed Graph + New_Graph = self.DirGraphFull.ConvertGraph(snap.TNGraph) + New_Graph.AddSelfEdges() + New_Graph_swig = snap.ConvertGraph(snap.PNGraph, self.DirGraphFull) + snap.AddSelfEdges(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Undirected Graph + New_Graph = self.UnDirGraphFull.ConvertGraph(snap.TUNGraph) + New_Graph.AddSelfEdges() + New_Graph_swig = snap.ConvertGraph(snap.PUNGraph, self.UnDirGraphFull) + snap.AddSelfEdges(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Network + New_Graph = self.NetFull.ConvertGraph(snap.TNEANet) + New_Graph.AddSelfEdges() + New_Graph_swig = snap.ConvertGraph(snap.PNEANet, self.NetFull) + snap.AddSelfEdges(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + def test_DelSelfEdges(self): + # Directed Graph + New_Graph = self.DirGraphSelfEdge.ConvertGraph(snap.TNGraph) + New_Graph.DelSelfEdges() + New_Graph_swig = snap.ConvertGraph(snap.PNGraph, self.DirGraphSelfEdge) + snap.DelSelfEdges(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Undirected Graph + New_Graph = self.UnDirGraphSelfEdge.ConvertGraph(snap.TUNGraph) + New_Graph.DelSelfEdges() + New_Graph_swig = snap.ConvertGraph(snap.PUNGraph, self.UnDirGraphSelfEdge) + snap.DelSelfEdges(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Network + New_Graph = self.NetSelfEdge.ConvertGraph(snap.TNEANet) + New_Graph.DelSelfEdges() + New_Graph_swig = snap.ConvertGraph(snap.PNEANet, self.NetSelfEdge) + snap.DelSelfEdges(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + def test_DelNodes(self): + # Directed Graph + New_Graph = self.DirGraphFull.ConvertGraph(snap.TNGraph) + DelNodes = [0] + New_Graph.DelNodes(DelNodes) + New_Graph_swig = snap.ConvertGraph(snap.PNGraph, self.DirGraphFull) + DelNodes_swig = snap.TIntV() + DelNodes_swig.Add(0) + snap.DelNodes(New_Graph_swig, DelNodes_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Undirected Graph + New_Graph = self.UnDirGraphFull.ConvertGraph(snap.TUNGraph) + DelNodes = [0] + New_Graph.DelNodes(DelNodes) + New_Graph_swig = snap.ConvertGraph(snap.PUNGraph, self.UnDirGraphFull) + DelNodes_swig = snap.TIntV() + DelNodes_swig.Add(0) + snap.DelNodes(New_Graph_swig, DelNodes_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Network + New_Graph = self.NetFull.ConvertGraph(snap.TNEANet) + DelNodes = [0] + New_Graph.DelNodes(DelNodes) + New_Graph_swig = snap.ConvertGraph(snap.PNEANet, self.NetFull) + DelNodes_swig = snap.TIntV() + DelNodes_swig.Add(0) + snap.DelNodes(New_Graph_swig, DelNodes_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + def test_DelZeroDegNodes(self): + # Directed Graph + New_Graph = self.DirGraphZeroDegree.ConvertGraph(snap.TNGraph) + New_Graph.DelZeroDegNodes() + New_Graph_swig = snap.ConvertGraph(snap.PNGraph, self.DirGraphZeroDegree) + snap.DelZeroDegNodes(New_Graph_swig) + self.checkGraphs(New_Graph, New_Graph_swig) + + # Undirected Graph + New_Graph = self.UnDirGraphZeroDegree.ConvertGraph(snap.TUNGraph) + New_Graph.DelZeroDegNodes() + New_Graph_swig = snap.ConvertGraph(snap.PUNGraph, self.UnDirGraphZeroDegree) + New_Graph_swig.DelZeroDegNodes() + self.checkGraphs(New_Graph, New_Graph_swig) + + # Network + New_Graph = self.NetZeroDegree.ConvertGraph(snap.TNEANet) + New_Graph.DelZeroDegNodes() + New_Graph_swig = snap.ConvertGraph(snap.PNEANet, self.NetZeroDegree) + New_Graph_swig.DelZeroDegNodes() + self.checkGraphs(New_Graph, New_Graph_swig) + + def test_DelDegKNodes(self): + # Directed Graph + New_Graph = self.DirGraphZeroDegree.ConvertGraph(snap.TNGraph) + New_Graph.DelDegKNodes(0,0) + New_Graph_swig = snap.ConvertGraph(snap.PNGraph, self.DirGraphZeroDegree) + snap.DelDegKNodes(New_Graph_swig,0,0) + self.checkGraphs(New_Graph, New_Graph_swig) + + New_Graph = self.UnDirGraphZeroDegree.ConvertGraph(snap.TUNGraph) + New_Graph.DelDegKNodes(0,0) + + New_Graph_swig = snap.ConvertGraph(snap.PUNGraph, self.UnDirGraphZeroDegree) + snap.DelDegKNodes(New_Graph_swig,0,0) + self.checkGraphs(New_Graph, New_Graph_swig) + + New_Graph = self.NetZeroDegree.ConvertGraph(snap.TNEANet) + New_Graph.DelDegKNodes(0,0) + New_Graph_swig = snap.ConvertGraph(snap.PNEANet, self.NetZeroDegree) + snap.DelDegKNodes(New_Graph_swig,0,0) + self.checkGraphs(New_Graph, New_Graph_swig) + + def test_IsTree(self): + # Directed Graph + results = self.DirTree.IsTree() + results_swig = snap.IsTree(self.DirTree) + self.assertEqual(results, results_swig) + + # Network + results = self.NetTree.IsTree() + results_swig = snap.IsTree(self.NetTree) + self.assertEqual(results, results_swig) + + def test_GetTreeRootNId(self): + # Directed Graph + root_id = self.DirTree.GetTreeRootNId() + root_id_swig = snap.GetTreeRootNId(self.DirTree) + self.assertEqual(root_id, root_id_swig) + + # Network + root_id = self.NetTree.GetTreeRootNId() + root_id_swig = snap.GetTreeRootNId(self.NetTree) + self.assertEqual(root_id, root_id_swig) + + def test_GetBfsTree(self): + start_node = 0 + follow_out = True + follow_in = False + + # Directed Graph + BfsTree = self.DirGraphFull.GetBfsTree(start_node, follow_out, follow_in) + BfsTree_swig = snap.GetBfsTree(self.DirGraphFull, start_node, follow_out, follow_in) + self.checkGraphs(BfsTree, BfsTree_swig) + + # Undirected Graph + BfsTree = self.UnDirGraphFull.GetBfsTree(start_node, follow_out, follow_in) + BfsTree_swig = snap.GetBfsTree(self.UnDirGraphFull, start_node, follow_out, follow_in) + self.checkGraphs(BfsTree, BfsTree_swig) + + # Network + BfsTree = self.NetFull.GetBfsTree(start_node, follow_out, follow_in) + BfsTree_swig = snap.GetBfsTree(self.NetFull, start_node, follow_out, follow_in) + self.checkGraphs(BfsTree, BfsTree_swig) + + def test_GetSubTreeSz(self): + # Directed Graph + results = self.DirTree.GetSubTreeSz(0, True, True) + results_swig = snap.GetSubTreeSz(self.DirTree, 0, True, True) + self.assertEqual(results, results_swig) + + # Undirected Graph + results = self.UnDirTree.GetSubTreeSz(0, True, True) + results_swig = snap.GetSubTreeSz(self.UnDirTree, 0, True, True) + self.assertEqual(results, results_swig) + + # Network + results = self.NetTree.GetSubTreeSz(0, True, True) + results_swig = snap.GetSubTreeSz(self.NetTree, 0, True, True) + self.assertEqual(results, results_swig) + + def test_GetNodesAtHop(self): + # Directed Graph + num_nodes, NodeVec = self.DirGraphStar.GetNodesAtHop(0, 1, True) + NodeVec_swig = snap.TIntV() + num_nodes_swig = snap.GetNodesAtHop(self.DirGraphStar, 0, 1, NodeVec_swig, True) + self.assertEqual(num_nodes, num_nodes_swig) + self.assertEqual(NodeVec, NodeVec_swig) + + # Undirected Graph + num_nodes, NodeVec = self.UnDirGraphStar.GetNodesAtHop(0, 1, True) + NodeVec_swig = snap.TIntV() + num_nodes_swig = snap.GetNodesAtHop(self.UnDirGraphStar, 0, 1, NodeVec_swig, False) + self.assertEqual(num_nodes, num_nodes_swig) + self.assertEqual(NodeVec, NodeVec_swig) + + # Network + num_nodes, NodeVec = self.NetStar.GetNodesAtHop(0, 1, True) + NodeVec_swig = snap.TIntV() + num_nodes_swig = snap.GetNodesAtHop(self.NetStar, 0, 1, NodeVec_swig, True) + self.assertEqual(num_nodes, num_nodes_swig) + self.assertEqual(NodeVec, NodeVec_swig) + + def test_GetNodesAtHops(self): + # Directed Graph + num_hops, HopVec = self.DirGraphStar.GetNodesAtHops(0, True) + HopVec_swig = snap.TIntPrV() + num_hops_swig = snap.GetNodesAtHops(self.DirGraphStar, 0, HopVec_swig, True) + self.assertEqual(num_hops, num_hops_swig) + self.assertEqual(HopVec, HopVec_swig) + + # Undirected Graph + num_hops, HopVec = self.UnDirGraphStar.GetNodesAtHops(0, False) + HopVec_swig = snap.TIntPrV() + num_hops_swig = snap.GetNodesAtHops(self.UnDirGraphStar, 0, HopVec_swig, False) + self.assertEqual(num_hops, num_hops_swig) + self.assertEqual(HopVec, HopVec_swig) + + # Network + num_hops, HopVec = self.NetStar.GetNodesAtHops(0, False) + HopVec_swig = snap.TIntPrV() + num_hops_swig = snap.GetNodesAtHops(self.NetStar, 0, HopVec_swig, True) + self.assertEqual(num_hops, num_hops_swig) + self.assertEqual(HopVec, HopVec_swig) + + def test_GetDegreeCentr(self): + # Undirected Graph + degree_center = self.UnDirGraphStar.GetDegreeCentr(0) + degree_center_swig = snap.GetDegreeCentr(self.UnDirGraphStar, 0) + self.assertEqual(degree_center, degree_center_swig) + + def test_GetFarnessCentr(self): + # Undirected Graph + farness_center = self.UnDirGraphStar.GetFarnessCentr(0) + farness_center_swig = snap.GetFarnessCentr(self.UnDirGraphStar, 0) + self.assertEqual(farness_center, farness_center_swig) + + # Directed Graph + farness_center = self.DirGraphStar.GetFarnessCentr(0) + farness_center_swig = snap.GetFarnessCentr(self.DirGraphStar, 0) + self.assertEqual(farness_center, farness_center_swig) + + # Network + farness_center = self.NetStar.GetFarnessCentr(0) + farness_center_swig = snap.GetFarnessCentr(self.NetStar, 0) + self.assertEqual(farness_center, farness_center_swig) + + def test_GetClosenessCentr(self): + # Undirected Graph + closeness_center = self.UnDirGraphStar.GetClosenessCentr(0) + closeness_center_swig = snap.GetClosenessCentr(self.UnDirGraphStar, 0) + self.assertEqual(closeness_center, closeness_center_swig) + + # Directed Graph + closeness_center = self.DirGraphStar.GetClosenessCentr(0) + closeness_center_swig = snap.GetClosenessCentr(self.DirGraphStar, 0) + self.assertEqual(closeness_center, closeness_center_swig) + + # Network + closeness_center = self.NetStar.GetClosenessCentr(0) + closeness_center_swig = snap.GetClosenessCentr(self.NetStar, 0) + self.assertEqual(closeness_center, closeness_center_swig) + + def test_GetEigenVectorCentr(self): + # Undirected Graph + EigenVec = self.UnDirGraphStar.GetEigenVectorCentr() + EigenVec_swig = snap.TIntFltH() + snap.GetEigenVectorCentr(self.UnDirGraphStar, EigenVec_swig) + self.assertEqual(EigenVec, EigenVec_swig) + + def test_GetNodeEcc(self): + # Directed Graph + node_ecc = self.DirGraphStar.GetNodeEcc(0, True) + node_ecc_swig = snap.GetNodeEcc(self.DirGraphStar, 0, True) + self.assertEqual(node_ecc, node_ecc_swig) + + # Undirected Graph + node_ecc = self.UnDirGraphStar.GetNodeEcc(0, True) + node_ecc_swig = snap.GetNodeEcc(self.UnDirGraphStar, 0, False) + self.assertEqual(node_ecc, node_ecc_swig) + + # Network + node_ecc = self.NetStar.GetNodeEcc(0, True) + node_ecc_swig = snap.GetNodeEcc(self.NetStar, 0, True) + self.assertEqual(node_ecc, node_ecc_swig) + + def test_GetPageRank(self): + # Directed Graph + PRankH = self.DPetersen.GetPageRank() + PRankH_swig = snap.TIntFltH() + snap.GetPageRank(self.DPetersen, PRankH_swig) + self.assertEqual(len(PRankH), len(PRankH_swig)) + for item in PRankH_swig: + self.assertAlmostEqual(PRankH[item], PRankH_swig[item]) + + # Undirected Graph + PRankH = self.UPetersen.GetPageRank() + PRankH_swig = snap.TIntFltH() + snap.GetPageRank(self.UPetersen, PRankH_swig) + self.assertEqual(len(PRankH), len(PRankH_swig)) + for item in PRankH_swig: + self.assertAlmostEqual(PRankH[item], PRankH_swig[item]) + + # Network + PRankH = self.NPetersen.GetPageRank() + PRankH_swig = snap.TIntFltH() + snap.GetPageRank(self.NPetersen, PRankH_swig) + self.assertEqual(len(PRankH), len(PRankH_swig)) + for item in PRankH_swig: + self.assertAlmostEqual(PRankH[item], PRankH_swig[item]) + + def test_GetHits(self): + # Directed Graph + NIdHubH, NIdAuthH = self.DirGraphFull.GetHits() + NIdHubH_swig = snap.TIntFltH() + NIdAuthH_swig = snap.TIntFltH() + snap.GetHits(self.DirGraphFull, NIdHubH_swig, NIdAuthH_swig) + self.assertEqual(NIdHubH, NIdHubH_swig) + self.assertEqual(NIdAuthH, NIdAuthH_swig) + + # Undirected Graph + NIdHubH, NIdAuthH = self.UnDirGraphFull.GetHits() + NIdHubH_swig = snap.TIntFltH() + NIdAuthH_swig = snap.TIntFltH() + snap.GetHits(self.UnDirGraphFull, NIdHubH_swig, NIdAuthH_swig) + self.assertEqual(NIdHubH, NIdHubH_swig) + self.assertEqual(NIdAuthH, NIdAuthH_swig) + + # Network + NIdHubH, NIdAuthH = self.NetFull.GetHits() + NIdHubH_swig = snap.TIntFltH() + NIdAuthH_swig = snap.TIntFltH() + snap.GetHits(self.NetFull, NIdHubH_swig, NIdAuthH_swig) + self.assertEqual(NIdHubH, NIdHubH_swig) + self.assertEqual(NIdAuthH, NIdAuthH_swig) + + def test_CommunityGirvanNewman(self): + Graph = snap.GenPrefAttach(100, 10) + act_val, Vec = Graph.CommunityGirvanNewman() + Vec_swig = snap.TCnComV() + act_val_swig = snap.CommunityGirvanNewman(Graph, Vec_swig) + self.assertEqual(act_val, act_val_swig) + self.assertEqual(Vec, Vec_swig) + + def test_CommunityCNM(self): + gnutellaUndir = self.gnutella.ConvertGraph(snap.TUNGraph) + modularity, Vcc = gnutellaUndir.CommunityCNM() + Vcc_swig = snap.TCnComV() + modularity_swig = snap.CommunityCNM(gnutellaUndir, Vcc_swig) + self.assertEqual(modularity, modularity_swig) + self.assertEqual(Vcc, Vcc_swig) + + def test_GetModularity(self): + V = [0,1,2,3,4] + V_swig = snap.TIntV() + for i in range(5): + V_swig.Add(i) + + # Directed Graph + val = self.DirGraphFull.GetModularity(V) + val_swig = snap.GetModularity(self.DirGraphFull, V_swig) + self.assertEqual(val, val_swig) + + # Undirected Graph + val = self.UnDirGraphFull.GetModularity(V) + val_swig = snap.GetModularity(self.UnDirGraphFull, V_swig) + self.assertEqual(val, val_swig) + + # Network + val = self.NetFull.GetModularity(V) + val_swig = snap.GetModularity(self.NetFull, V_swig) + self.assertEqual(val, val_swig) + + def test_GetEdgesInOut(self): + V = [0] + V_swig = snap.TIntV() + V_swig.Add(0) + + # Directed Graph + result = self.DirGraphFull.GetEdgesInOut(V) + result_swig = snap.GetEdgesInOut(self.DirGraphFull, V_swig) + self.assertEqual(result, result_swig) + + # Undirected Graph + result = self.UnDirGraphFull.GetEdgesInOut(V) + result_swig = snap.GetEdgesInOut(self.UnDirGraphFull, V_swig) + self.assertEqual(result, result_swig) + + # Network + result = self.NetFull.GetEdgesInOut(V) + result_swig = snap.GetEdgesInOut(self.NetFull, V_swig) + self.assertEqual(result, result_swig) + + def test_GetBiConSzCnt(self): + # Undirected Graph + szCntV = self.UnDirGraphFull.GetBiConSzCnt() + szCntV_swig = snap.TIntPrV() + snap.GetBiConSzCnt(self.UnDirGraphFull, szCntV_swig) + self.assertEqual(szCntV, szCntV_swig) + + def test_GetBiCon(self): + # Undirected Graph + CnComs = self.UnDirGraphFull.GetBiCon() + CnComs_swig = snap.TCnComV() + snap.GetBiCon(self.UnDirGraphFull, CnComs_swig) + self.assertEqual(CnComs, CnComs_swig) + + def test_GetEdgeBridges(self): + # Undirected Graph + edges = self.UnDirGraphStar.GetEdgeBridges() + edges_swig = snap.TIntPrV() + snap.GetEdgeBridges(self.UnDirGraphStar, edges_swig) + self.assertEqual(edges, edges_swig) + + def test_Get1CnCom(self): + # Undirected Graph + components = self.UnDirGraphStar.Get1CnCom() + components_swig = snap.TCnComV() + snap.Get1CnCom(self.UnDirGraphStar, components_swig) + self.assertEqual(components, components_swig) + + def test_GetMxBiCon(self): + # Directed Graph + Graph = self.DirGraphFull.GetMxBiCon() + Graph_swig = snap.GetMxBiCon(self.DirGraphFull) + self.checkGraphs(Graph, Graph_swig) + + # Undirected Graph + Graph = self.UnDirGraphFull.GetMxBiCon() + Graph_swig = snap.GetMxBiCon(self.UnDirGraphFull) + self.checkGraphs(Graph, Graph_swig) + + # Network + Graph = self.NetFull.GetMxBiCon() + Graph_swig = snap.GetMxBiCon(self.NetFull) + self.checkGraphs(Graph, Graph_swig) + + def test_GetNodeWcc(self): + # Directed Graph + component = self.DirGraphStar.GetNodeWcc(1) + component_swig = snap.TIntV() + snap.GetNodeWcc(self.DirGraphStar, 1, component_swig) + self.assertEqual(component, component_swig) + + # Undirected Graph + component = self.UnDirGraphStar.GetNodeWcc(1) + component_swig = snap.TIntV() + snap.GetNodeWcc(self.UnDirGraphStar, 1, component_swig) + self.assertEqual(component, component_swig) + + # Network + component = self.NetStar.GetNodeWcc(1) + component_swig = snap.TIntV() + snap.GetNodeWcc(self.NetStar, 1, component_swig) + self.assertEqual(component, component_swig) + + def test_isConnected(self): + # Directed Graph + result = self.DirGraphStar.IsConnected() + result_swig = snap.IsConnected(self.DirGraphStar) + self.assertEqual(result, result_swig) + + # Undirected Graph + result = self.UnDirGraphStar.IsConnected() + result_swig = snap.IsConnected(self.UnDirGraphStar) + self.assertEqual(result, result_swig) + + # Network + result = self.NetStar.IsConnected() + result_swig = snap.IsConnected(self.NetStar) + self.assertEqual(result, result_swig) + + def test_isWeaklyConn(self): + # Directed Graph + result = self.DirGraphStar.IsWeaklyConn() + result_swig = snap.IsWeaklyConn(self.DirGraphStar) + self.assertEqual(result, result_swig) + + # Undirected Graph + result = self.UnDirGraphStar.IsWeaklyConn() + result_swig = snap.IsWeaklyConn(self.UnDirGraphStar) + self.assertEqual(result, result_swig) + + # Network + result = self.NetStar.IsWeaklyConn() + result_swig = snap.IsWeaklyConn(self.NetStar) + self.assertEqual(result, result_swig) + + def test_GetWccSzCnt(self): + # Directed Graph + counts = self.DirGraphStar.GetWccSzCnt() + counts_swig = snap.TIntPrV() + snap.GetWccSzCnt(self.DirGraphStar, counts_swig) + self.assertEqual(counts, counts_swig) + + # Undirected Graph + counts = self.UnDirGraphStar.GetWccSzCnt() + counts_swig = snap.TIntPrV() + snap.GetWccSzCnt(self.UnDirGraphStar, counts_swig) + self.assertEqual(counts, counts_swig) + + # Network + counts = self.NetStar.GetWccSzCnt() + counts_swig = snap.TIntPrV() + snap.GetWccSzCnt(self.NetStar, counts_swig) + self.assertEqual(counts, counts_swig) + + def test_GetWccs(self): + # Directed Graph + components = self.DirGraphStar.GetWccs() + components_swig = snap.TCnComV() + snap.GetWccs(self.DirGraphStar, components_swig) + self.assertEqual(components, components_swig) + + # Undirected Graph + components = self.UnDirGraphStar.GetWccs() + components_swig = snap.TCnComV() + snap.GetWccs(self.UnDirGraphStar, components_swig) + self.assertEqual(components, components_swig) + + # Network + components = self.UnDirGraphStar.GetWccs() + components_swig = snap.TCnComV() + snap.GetWccs(self.NetStar, components_swig) + self.assertEqual(components, components_swig) + + def test_GetSccSzCnt(self): + # Directed Graph + counts = self.DirGraphFull.GetSccSzCnt() + counts_swig = snap.TIntPrV() + snap.GetSccSzCnt(self.DirGraphFull, counts_swig) + self.assertEqual(counts, counts_swig) + + # Undirected Graph + counts = self.UnDirGraphFull.GetSccSzCnt() + counts_swig = snap.TIntPrV() + snap.GetSccSzCnt(self.UnDirGraphFull, counts_swig) + self.assertEqual(counts, counts_swig) + + # Network + counts = self.NetFull.GetSccSzCnt() + counts_swig = snap.TIntPrV() + snap.GetSccSzCnt(self.NetFull, counts_swig) + self.assertEqual(counts, counts_swig) + + def test_GetSccs(self): + # Directed Graph + components = self.DirGraphFull.GetSccs() + components_swig = snap.TCnComV() + snap.GetSccs(self.DirGraphFull, components_swig) + self.assertEqual(components, components_swig) + + # Undirected Graph + components = self.UnDirGraphFull.GetSccs() + components_swig = snap.TCnComV() + snap.GetSccs(self.UnDirGraphFull, components_swig) + self.assertEqual(components, components_swig) + + # Network + components = self.NetFull.GetSccs() + components_swig = snap.TCnComV() + snap.GetSccs(self.NetFull, components_swig) + self.assertEqual(components, components_swig) + + def test_GetMxWccSz(self): + # Directed Graph + size = self.DirGraphStar.GetMxWccSz() + size_swig = snap.GetMxWccSz(self.DirGraphStar) + self.assertEqual(size, size_swig) + + # Undirected Graph + size = self.UnDirGraphStar.GetMxWccSz() + size_swig = snap.GetMxWccSz(self.UnDirGraphStar) + self.assertEqual(size, size_swig) + + # Network + size = self.NetStar.GetMxWccSz() + size_swig = snap.GetMxWccSz(self.NetStar) + self.assertEqual(size, size_swig) + + def test_GetMxSccSz(self): + # Directed Graph + size = self.DirGraphStar.GetMxSccSz() + size_swig = snap.GetMxSccSz(self.DirGraphStar) + self.assertEqual(size, size_swig) + + # Undirected Graph + size = self.UnDirGraphStar.GetMxSccSz() + size_swig = snap.GetMxSccSz(self.UnDirGraphStar) + self.assertEqual(size, size_swig) + + # Network + size = self.NetStar.GetMxSccSz() + size_swig = snap.GetMxSccSz(self.NetStar) + self.assertEqual(size, size_swig) + + def test_GetMxWcc(self): + # Directed Graph + Graph = self.DirGraphStar.GetMxWcc() + Graph_swig = snap.GetMxWcc(self.DirGraphStar) + self.checkGraphs(Graph, Graph_swig) + + # Undirected Graph + Graph = self.UnDirGraphStar.GetMxWcc() + Graph_swig = snap.GetMxWcc(self.UnDirGraphStar) + self.checkGraphs(Graph, Graph_swig) + + # Network + Graph = self.NetStar.GetMxWcc() + Graph_swig = snap.GetMxWcc(self.NetStar) + self.checkGraphs(Graph, Graph_swig) + + def test_GetMxScc(self): + # Directed Graph + Graph = self.DirGraphFull.GetMxScc() + Graph_swig = snap.GetMxScc(self.DirGraphFull) + self.checkGraphs(Graph, Graph_swig) + + # Undirected Graph + Graph = self.UnDirGraphFull.GetMxScc() + Graph_swig = snap.GetMxScc(self.UnDirGraphFull) + self.checkGraphs(Graph, Graph_swig) + + # Network + Graph = self.NetFull.GetMxScc() + Graph_swig = snap.GetMxScc(self.NetFull) + self.checkGraphs(Graph, Graph_swig) + + def test_GetMxBiCon(self): + # Directed Graph + Graph = self.DirGraphFull.GetMxBiCon() + Graph_swig = snap.GetMxBiCon(self.DirGraphFull) + self.checkGraphs(Graph, Graph_swig) + + # Undirected Graph + Graph = self.UnDirGraphFull.GetMxBiCon() + Graph_swig = snap.GetMxBiCon(self.UnDirGraphFull) + self.checkGraphs(Graph, Graph_swig) + + # Network + Graph = self.NetFull.GetMxBiCon() + Graph_swig = snap.GetMxBiCon(self.NetFull) + self.checkGraphs(Graph, Graph_swig) + + def test_PrintInfo(self): + self.DirGraphFull.PrintInfo("description", "test.txt") + self.checkPrintInfoOutput("test.txt", ["description", '10', '90', '0', '0', '0', '10']) + os.remove('test.txt') + + self.UnDirGraphFull.PrintInfo("description", "test.txt") + self.checkPrintInfoOutput("test.txt", ["description", '10', '45', '0', '0', '0', '10']) + os.remove('test.txt') + + self.NetFull.PrintInfo("description", "test.txt") + self.checkPrintInfoOutput("test.txt", ["description", '10', '90', '0', '0', '0', '10']) + os.remove('test.txt') + + def test_GetKCoreNodes(self): + # Directed Graph + result, CoreN = self.DirGraphStar.GetKCoreNodes() + CoreN_swig = snap.TIntPrV() + result_swig = snap.GetKCoreNodes(self.DirGraphStar, CoreN_swig) + self.assertEqual(result, result_swig) + self.assertEqual(CoreN, CoreN_swig) + + # Undirected Graph + result, CoreN = self.UnDirGraphStar.GetKCoreNodes() + CoreN_swig = snap.TIntPrV() + result_swig = snap.GetKCoreNodes(self.UnDirGraphStar, CoreN_swig) + self.assertEqual(result, result_swig) + self.assertEqual(CoreN, CoreN_swig) + + # Network + result, CoreN = self.NetStar.GetKCoreNodes() + CoreN_swig = snap.TIntPrV() + result_swig = snap.GetKCoreNodes(self.NetStar, CoreN_swig) + self.assertEqual(result, result_swig) + self.assertEqual(CoreN, CoreN_swig) + + def test_GetKCoreEdges(self): + # Directed Graph + result, CoreN = self.DirGraphStar.GetKCoreEdges() + CoreN_swig = snap.TIntPrV() + result_swig = snap.GetKCoreEdges(self.DirGraphStar, CoreN_swig) + self.assertEqual(result, result_swig) + self.assertEqual(CoreN, CoreN_swig) + + # Undirected Graph + result, CoreN = self.UnDirGraphStar.GetKCoreEdges() + CoreN_swig = snap.TIntPrV() + result_swig = snap.GetKCoreEdges(self.UnDirGraphStar, CoreN_swig) + self.assertEqual(result, result_swig) + self.assertEqual(CoreN, CoreN_swig) + + # Network + result, CoreN = self.NetStar.GetKCoreEdges() + CoreN_swig = snap.TIntPrV() + result_swig = snap.GetKCoreEdges(self.NetStar, CoreN_swig) + self.assertEqual(result, result_swig) + self.assertEqual(CoreN, CoreN_swig) + + def test_GenRewire(self): + Rewired = self.UnDirRand.GenRewire() + Rewired_swig = snap.GenRewire(self.UnDirRand) + for node in Rewired.Nodes(): + for nodeR in Rewired_swig.Nodes(): + if node.GetId() == nodeR.GetId(): + self.assertEqual(node.GetOutDeg()+node.GetInDeg(), nodeR.GetOutDeg()+nodeR.GetInDeg()) + + def test_SaveEdgeList(self): + # Directed Graph + fname = "mygraph.txt" + self.DirGraphFull.SaveEdgeList(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveEdgeList(self.DirGraphFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + # Undirected Graph + fname = "mygraph.txt" + self.UnDirGraphFull.SaveEdgeList(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveEdgeList(self.UnDirGraphFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + # Directed Graph + fname = "mygraph.txt" + self.NetFull.SaveEdgeList(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveEdgeList(self.NetFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + def test_SaveMatlabSparseMtx(self): + # Directed Graph + fname = "mygraph.txt" + self.DirGraphFull.SaveMatlabSparseMtx(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveMatlabSparseMtx(self.DirGraphFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + # Undirected Graph + fname = "mygraph.txt" + self.UnDirGraphFull.SaveMatlabSparseMtx(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveMatlabSparseMtx(self.UnDirGraphFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + # Directed Graph + fname = "mygraph.txt" + self.NetFull.SaveMatlabSparseMtx(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveMatlabSparseMtx(self.NetFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + def test_GetSngVals(self): + SngVals = 4 + SngValV = self.DirGraphFull.GetSngVals(SngVals) + SngValV_swig = snap.TFltV() + snap.GetSngVals(self.DirGraphFull, SngVals, SngValV_swig) + self.assertEqual(SngValV, SngValV_swig) + + def test_GetEigVals(self): + Graph = snap.GenStar(snap.TUNGraph, 50) + NumEigVals = 2 + EigValV = Graph.GetEigVals(NumEigVals) + EigValV_swig = snap.TFltV() + snap.GetEigVals(Graph, NumEigVals, EigValV_swig) + self.assertEqual(EigValV, EigValV_swig) + + def test_GetInvParticipRate(self): + Graph = snap.TUNGraph.New() + Graph.AddNode(1) + Graph.AddNode(2) + Graph.AddNode(3) + Graph.AddNode(4) + Graph.AddNode(5) + Graph.AddNode(6) + Graph.AddEdge(1, 2) + Graph.AddEdge(2, 3) + Graph.AddEdge(3, 5) + Graph.AddEdge(4, 6) + Graph.AddEdge(4, 1) + + EigValIprV = Graph.GetInvParticipRat(10, 1000) + EigValIprV_swig = snap.TFltPrV() + snap.GetInvParticipRat(Graph, 10, 1000, EigValIprV_swig) + self.assertEqual(EigValIprV, EigValIprV_swig) + + def test_GetKCore(self): + # Directed Graph + k = self.num_nodes - 1 + KCore = self.DirGraphFull.GetKCore(k) + KCore_swig = snap.GetKCore(self.DirGraphFull, k) + self.checkGraphs(KCore, KCore_swig) + + # Undirected Graph + k = self.num_nodes - 1 + KCore = self.UnDirGraphFull.GetKCore(k) + KCore_swig = snap.GetKCore(self.UnDirGraphFull, k) + self.checkGraphs(KCore, KCore_swig) + + # Network + k = self.num_nodes - 1 + KCore = self.NetFull.GetKCore(k) + KCore_swig = snap.GetKCore(self.NetFull, k) + self.checkGraphs(KCore, KCore_swig) + + def test_PlotEigValRank(self): + Graph = snap.GenStar(snap.TUNGraph, 20) + NumEigVals = 2 + fname = 'test' + desc = 'test' + plt = 'eigVal.' + fname + '.plt' + png = 'eigVal.' + fname + '.png' + tab = 'eigVal.' + fname + '.tab' + + Graph.PlotEigValRank(NumEigVals, fname, desc) + self.checkPlotHash(plt, 'c6ed3d548e47a32ab81b9d93fd5210fa') + os.remove(plt) + #self.checkPlotHash(png, '88e8150cca4d8b102e69e48f4f75bbc8') + os.remove(png) + self.checkPlotHash(tab, '74c9e40a9c5254c36f3808524f42b3d8') + os.remove(tab) + + def test_PlotEigValDistr(self): + Graph = snap.GenStar(snap.TUNGraph, 20) + NumEigVals = 2 + fname = 'test' + desc = 'test' + plt = 'eigDistr.' + fname + '.plt' + png = 'eigDistr.' + fname + '.png' + tab = 'eigDistr.' + fname + '.tab' + + Graph.PlotEigValDistr(NumEigVals, fname, desc) + self.checkPlotHash(plt, 'b22f6198cf212c27756b1edb4bed3508') + os.remove(plt) + #self.checkPlotHash(png, 'a620e5ca09dd447b4229850227678056') + os.remove(png) + self.checkPlotHash(tab, 'e6af369e84c82eea2fc1ae422d64f171') + os.remove(tab) + + def test_PlotInvParticipRat(self): + Graph = self.UnDirGraphStar + NumEigVals = 3 + TimeLimit = 5 + fname = 'test' + desc = 'test' + plt = 'eigIPR.' + fname + '.plt' + png = 'eigIPR.' + fname + '.png' + tab = 'eigIPR.' + fname + '.tab' + + Graph.PlotInvParticipRat(NumEigVals, TimeLimit, fname, desc) + self.checkPlotHash(plt, '87de319e252341f359c6cf92aa9b7090') + os.remove(plt) + #self.checkPlotHash(png, 'b518c4e4a1b0af4de529961986198127') + os.remove(png) + self.checkPlotHash(tab, '303939e032d64c7f1e3d201a3bb3629e') + os.remove(tab) + + def test_PlotSngValRank(self): + Graph = self.DirGraphFull + SngVals = 3 + fname = 'test' + desc = 'test' + plt = 'sngVal.' + fname + '.plt' + png = 'sngVal.' + fname + '.png' + tab = 'sngVal.' + fname + '.tab' + + Graph.PlotSngValRank(SngVals, fname, desc) + self.checkPlotHash(plt, '3d94b5107efd76abb478b18995447c2c') + os.remove(plt) + #self.checkPlotHash(png, 'c4d688e2e38f3a7df07067ee1c92ab64') + os.remove(png) + self.checkPlotHash(tab, 'bc0edcc3dd69677930bb37316e3bdddf') + os.remove(tab) + + def test_PlotSngValDistr(self): + Graph = self.DirGraphFull + SngVals = 3 + fname = 'test' + desc = 'test' + plt = 'sngDistr.' + fname + '.plt' + png = 'sngDistr.' + fname + '.png' + tab = 'sngDistr.' + fname + '.tab' + + Graph.PlotSngValDistr(SngVals, fname, desc) + self.checkPlotHash(plt, '3c3dde0ffb43838943dcc5983baa5aa3') + os.remove(plt) + #self.checkPlotHash(png, '61a7195efc4864225c38f389e89c641e') + os.remove(png) + self.checkPlotHash(tab, '8683dabf0f9d787609dc1be1867f31a5') + os.remove(tab) + + def test_PlotInDegDistr(self): + fname = 'test' + desc = 'test' + plt = 'inDeg.' + fname + '.plt' + png = 'inDeg.' + fname + '.png' + tab = 'inDeg.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + Graph.PlotInDegDistr(fname, desc) + + self.checkPlotHash(plt, '7f08086973d30d356eaa2e695e1a6fff') + os.remove(plt) + #self.checkPlotHash(png, '3a7a729d393a0ba37d455c67dacd8510') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotInDegDistr(fname, desc) + + self.checkPlotHash(plt, '9469cef95ca7701898d9da53fd83d3cf') + os.remove(plt) + #self.checkPlotHash(png, '3a7a729d393a0ba37d455c67dacd8510') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotInDegDistr(fname, desc) + + self.checkPlotHash(plt, '7f08086973d30d356eaa2e695e1a6fff') + os.remove(plt) + #self.checkPlotHash(png, '3a7a729d393a0ba37d455c67dacd8510') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + def test_PlotOutDegDistr(self): + fname = 'test' + desc = 'test' + plt = 'outDeg.' + fname + '.plt' + png = 'outDeg.' + fname + '.png' + tab = 'outDeg.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotOutDegDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'c0e03b616e4dc61331efb11d6ed6d3f6') + os.remove(plt) + #self.checkPlotHash(png, '03a7e7d530235143bf3a0ad09df30d5d') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotOutDegDistr(fname, desc) + + self.checkPlotHash(plt, '893e4d32769a7235bade506f4558559a') + os.remove(plt) + #self.checkPlotHash(png, '03a7e7d530235143bf3a0ad09df30d5d') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotOutDegDistr(fname, desc) + + self.checkPlotHash(plt, 'c0e03b616e4dc61331efb11d6ed6d3f6') + os.remove(plt) + #self.checkPlotHash(png, '03a7e7d530235143bf3a0ad09df30d5d') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + def test_PlotWccDistr(self): + fname = 'test' + desc = 'test' + plt = 'wcc.' + fname + '.plt' + png = 'wcc.' + fname + '.png' + tab = 'wcc.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + Graph.PlotWccDistr(fname, desc) + + self.checkPlotHash(plt, '376654f801519f5a89519c020cd0cecf') + os.remove(plt) + #self.checkPlotHash(png, '3092ffd346709cbb0fb1210e39314c4c') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotWccDistr(fname, desc) + + self.checkPlotHash(plt, '25f0e2f9efd05b483bd3498de485b525') + os.remove(plt) + #self.checkPlotHash(png, '3092ffd346709cbb0fb1210e39314c4c') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotWccDistr(fname, desc) + + self.checkPlotHash(plt, '376654f801519f5a89519c020cd0cecf') + os.remove(plt) + #self.checkPlotHash(png, '3092ffd346709cbb0fb1210e39314c4c') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + def test_PlotSccDistr(self): + fname = 'test' + desc = 'test' + plt = 'scc.' + fname + '.plt' + png = 'scc.' + fname + '.png' + tab = 'scc.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + Graph.PlotSccDistr(fname, desc) + + self.checkPlotHash(plt, 'f92d2c3b97156ff049ce64aaeada099c') + os.remove(plt) + #self.checkPlotHash(png, '91fb4493d7a2e9fef7fc998607a94649') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotSccDistr(fname, desc) + + self.checkPlotHash(plt, '09bc574ab814ec9bd0fc5865529f513b') + os.remove(plt) + #self.checkPlotHash(png, '91fb4493d7a2e9fef7fc998607a94649') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotSccDistr(fname, desc) + + self.checkPlotHash(plt, 'f92d2c3b97156ff049ce64aaeada099c') + os.remove(plt) + #self.checkPlotHash(png, '91fb4493d7a2e9fef7fc998607a94649') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + def test_PlotClustCf(self): + fname = 'test' + desc = 'test' + plt = 'ccf.' + fname + '.plt' + png = 'ccf.' + fname + '.png' + tab = 'ccf.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + Graph.PlotClustCf(fname, desc) + + self.checkPlotHash(plt, 'd3e9c7ce6e1c5792a663bd0ee1abeb04') + os.remove(plt) + #self.checkPlotHash(png, '634a0518b0ee9db6c712ade205e089a2') + os.remove(png) + self.checkPlotHash(tab, '5e08cd594354ee12d733c98ffbb888c4') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotClustCf(fname, desc) + + self.checkPlotHash(plt, 'f2d1d9456515a92700e922d213a82084') + os.remove(plt) + #self.checkPlotHash(png, '634a0518b0ee9db6c712ade205e089a2') + os.remove(png) + self.checkPlotHash(tab, '0350d2154b877f0ae9415ea4d7e07f07') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotClustCf(fname, desc) + + self.checkPlotHash(plt, 'd3e9c7ce6e1c5792a663bd0ee1abeb04') + os.remove(plt) + #self.checkPlotHash(png, '634a0518b0ee9db6c712ade205e089a2') + os.remove(png) + self.checkPlotHash(tab, '5e08cd594354ee12d733c98ffbb888c4') + os.remove(tab) + + def test_PlotHops(self): + fname = 'test' + desc = 'test' + plt = 'hop.' + fname + '.plt' + png = 'hop.' + fname + '.png' + tab = 'hop.' + fname + '.tab' + NApprox = 1024 + + # Directed Graph + Graph = self.DirGraphFull + isDir = True + Graph.PlotHops(fname, desc, isDir, NApprox) + + self.assertTrue(os.path.isfile(plt)) + os.remove(plt) + #self.checkPlotHash(png, '7558cfcb4b34e02fdda090fe2ebdeb03') + os.remove(png) + self.assertTrue(os.path.isfile(tab)) + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + isDir = False + Graph.PlotHops(fname, desc, isDir, NApprox) + + self.assertTrue(os.path.isfile(plt)) + os.remove(plt) + #self.checkPlotHash(png, '7558cfcb4b34e02fdda090fe2ebdeb03') + os.remove(png) + self.assertTrue(os.path.isfile(tab)) + os.remove(tab) + + # Network + Graph = self.NetFull + isDir = True + Graph.PlotHops(fname, desc, isDir, NApprox) + + self.assertTrue(os.path.isfile(plt)) + os.remove(plt) + #self.checkPlotHash(png, '7558cfcb4b34e02fdda090fe2ebdeb03') + os.remove(png) + self.assertTrue(os.path.isfile(tab)) + os.remove(tab) + + def test_PlotShortPathDistr(self): + fname = 'test' + desc = 'test' + plt = 'diam.' + fname + '.plt' + png = 'diam.' + fname + '.png' + tab = 'diam.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + Graph.PlotShortPathDistr(fname, desc) + + self.checkPlotHash(plt, 'dbd3b8f4b0c82637c204173997625600') + os.remove(plt) + #self.checkPlotHash(png, 'ceaaab603196866102afa52042d33b15') + os.remove(png) + self.checkPlotHash(tab, '9b31a3d74e08ba09fb560dd2cfbf8e59') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotShortPathDistr(fname, desc) + + self.checkPlotHash(plt, 'b0e6ad4b3419c43ec4f4bac9ab9d74c7') + os.remove(plt) + #self.checkPlotHash(png, 'ceaaab603196866102afa52042d33b15') + os.remove(png) + self.checkPlotHash(tab, '9b31a3d74e08ba09fb560dd2cfbf8e59') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotShortPathDistr(fname, desc) + + self.checkPlotHash(plt, 'dbd3b8f4b0c82637c204173997625600') + os.remove(plt) + #self.checkPlotHash(png, 'ceaaab603196866102afa52042d33b15') + os.remove(png) + self.checkPlotHash(tab, '9b31a3d74e08ba09fb560dd2cfbf8e59') + os.remove(tab) + + def test_PlotKCoreNodes(self): + fname = 'test' + desc = 'test' + plt = 'coreNodes.' + fname + '.plt' + png = 'coreNodes.' + fname + '.png' + tab = 'coreNodes.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + Graph.PlotKCoreNodes(fname, desc) + + self.checkPlotHash(plt, '8b47f5a7082e940e5b1a49f7a19bac1a') + os.remove(plt) + #self.checkPlotHash(png, 'c4ffb2358ff82930b8832cbe1d5d3ecd') + os.remove(png) + self.checkPlotHash(tab, '1b1750d5304a4f2fbb19ab8919be8e27') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotKCoreNodes(fname, desc) + + self.checkPlotHash(plt, 'fd660ab9df8f84231ca61e6ad74b5a9f') + os.remove(plt) + #self.checkPlotHash(png, 'c4ffb2358ff82930b8832cbe1d5d3ecd') + os.remove(png) + self.checkPlotHash(tab, '6a1db7740949f594b7cc3917ec65f4d9') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotKCoreNodes(fname, desc) + + self.checkPlotHash(plt, '8b47f5a7082e940e5b1a49f7a19bac1a') + os.remove(plt) + #self.checkPlotHash(png, 'c4ffb2358ff82930b8832cbe1d5d3ecd') + os.remove(png) + self.checkPlotHash(tab, '1b1750d5304a4f2fbb19ab8919be8e27') + os.remove(tab) + + def test_PlotKCoreEdges(self): + fname = 'test' + desc = 'test' + plt = 'coreEdges.' + fname + '.plt' + png = 'coreEdges.' + fname + '.png' + tab = 'coreEdges.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + Graph.PlotKCoreEdges(fname, desc) + + self.checkPlotHash(plt, 'b2bcd1cbfadfa7280727163c0fc85854') + os.remove(plt) + #self.checkPlotHash(png, '6fab2c397c5b4ab0b740d4a5adf4171a') + os.remove(png) + self.checkPlotHash(tab, '7c22771f72c0bbe0c5ac5fa7c97928eb') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + Graph.PlotKCoreEdges(fname, desc) + + self.checkPlotHash(plt, 'ce0a125f61e5e00e58c639afa434b012') + os.remove(plt) + #self.checkPlotHash(png, '6fab2c397c5b4ab0b740d4a5adf4171a') + os.remove(png) + self.checkPlotHash(tab, '13f4612f2cec666a421b39d18ae7afb6') + os.remove(tab) + + # Network + Graph = self.NetFull + Graph.PlotKCoreEdges(fname, desc) + + self.checkPlotHash(plt, 'b2bcd1cbfadfa7280727163c0fc85854') + os.remove(plt) + #self.checkPlotHash(png, '6fab2c397c5b4ab0b740d4a5adf4171a') + os.remove(png) + self.checkPlotHash(tab, '7c22771f72c0bbe0c5ac5fa7c97928eb') + os.remove(tab) + + def test_GetESubGraph(self): + EIdV = [] + for edge in self.NetStar.Edges(): + EIdV.append(edge.GetId()) + ESubGraph = self.NetStar.GetESubGraph(EIdV) + EIdV_swig = snap.TIntV() + for edge in self.NetStar.Edges(): + EIdV_swig.Add(edge.GetId()) + ESubGraph_swig = snap.GetESubGraph(self.NetStar, EIdV_swig) + self.checkGraphs(ESubGraph, ESubGraph_swig) + + def test_ConvertGraph(self): + # Directed to Undirected + UnDirStar = self.DirGraphStar.ConvertGraph(snap.TUNGraph) + UnDirStar_swig = snap.ConvertGraph(snap.PUNGraph, self.DirGraphStar) + self.checkGraphs(UnDirStar, UnDirStar_swig) + + # Directed to Network + NetStar = self.DirGraphStar.ConvertGraph(snap.TNEANet) + NetStar_swig = snap.ConvertGraph(snap.PNEANet, self.DirGraphStar) + self.checkGraphs(NetStar, NetStar_swig) + + # Undirected to Directed + DirStar = self.UnDirGraphStar.ConvertGraph(snap.TNGraph) + DirStar_swig = snap.ConvertGraph(snap.PNGraph, self.UnDirGraphStar) + self.checkGraphs(DirStar, DirStar_swig) + + # Undirected to Network + NetStar = self.UnDirGraphStar.ConvertGraph(snap.TNEANet) + NetStar_swig = snap.ConvertGraph(snap.PNEANet, self.UnDirGraphStar) + self.checkGraphs(NetStar, NetStar_swig) + + # Network to Undirected + UnDirStar = self.NetStar.ConvertGraph(snap.TUNGraph) + UnDirStar_swig = snap.ConvertGraph(snap.PUNGraph, self.NetStar) + self.checkGraphs(UnDirStar, UnDirStar_swig) + + # Network to Directed + DirStar = self.NetStar.ConvertGraph(snap.TNGraph) + DirStar_swig = snap.ConvertGraph(snap.PNGraph, self.NetStar) + self.checkGraphs(DirStar, DirStar_swig) + + def test_ConvertSubGraph(self): + ListNodes = [] + for x in range(self.num_nodes): + ListNodes.append(x) + ListNodes_swig = snap.TIntV() + for x in range(self.num_nodes): + ListNodes_swig.Add(x) + + # Directed to Undirected + UnDirStar = self.DirGraphStar.ConvertSubGraph(snap.TUNGraph, ListNodes) + UnDirStar_swig = snap.ConvertSubGraph(snap.PUNGraph, self.DirGraphStar, ListNodes_swig) + self.checkGraphs(UnDirStar, UnDirStar_swig) + + # Directed to Network + NetStar = self.DirGraphStar.ConvertSubGraph(snap.TNEANet, ListNodes) + NetStar_swig = snap.ConvertSubGraph(snap.PNEANet, self.DirGraphStar, ListNodes_swig) + self.checkGraphs(NetStar, NetStar_swig) + + # Undirected to Directed + DirStar = self.UnDirGraphStar.ConvertSubGraph(snap.TNGraph, ListNodes) + DirStar_swig = snap.ConvertSubGraph(snap.PNGraph, self.UnDirGraphStar, ListNodes_swig) + self.checkGraphs(DirStar, DirStar_swig) + + # Undirected to Network + NetStar = self.UnDirGraphStar.ConvertSubGraph(snap.TNEANet, ListNodes) + NetStar_swig = snap.ConvertSubGraph(snap.PNEANet, self.UnDirGraphStar, ListNodes_swig) + self.checkGraphs(NetStar, NetStar_swig) + + # Network to Undirected + UnDirStar = self.NetStar.ConvertSubGraph(snap.TUNGraph, ListNodes) + UnDirStar_swig = snap.ConvertSubGraph(snap.PUNGraph, self.NetStar, ListNodes_swig) + self.checkGraphs(UnDirStar, UnDirStar_swig) + + # Network to Directed + DirStar = self.NetStar.ConvertSubGraph(snap.TNGraph, ListNodes) + DirStar_swig = snap.ConvertSubGraph(snap.PNGraph, self.NetStar, ListNodes_swig) + self.checkGraphs(DirStar, DirStar_swig) + + def test_GetRndSubGraph(self): + exp_nodes = 10 + + # Directed Graph + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + subGraph = Graph.GetRndSubGraph(exp_nodes) + self.assertEqual(exp_nodes, subGraph.GetNodes()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(Graph.IsNode(edge.GetSrcNId())) + self.assertTrue(Graph.IsNode(edge.GetDstNId())) + + # Undirected Graph + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 1000) + subGraph = Graph.GetRndSubGraph(exp_nodes) + self.assertEqual(exp_nodes, subGraph.GetNodes()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(Graph.IsNode(edge.GetSrcNId())) + self.assertTrue(Graph.IsNode(edge.GetDstNId())) + + # Directed Graph + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + subGraph = Graph.GetRndSubGraph(exp_nodes) + self.assertEqual(exp_nodes, subGraph.GetNodes()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(Graph.IsNode(edge.GetSrcNId())) + self.assertTrue(Graph.IsNode(edge.GetDstNId())) + + def test_GetRndESubGraph(self): + exp_edges = 10 + + # Directed Graph + Graph = snap.GenRndGnm(snap.TNGraph, 100, 1000) + subGraph = Graph.GetRndESubGraph(exp_edges) + self.assertEqual(exp_edges, subGraph.GetEdges()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + self.assertTrue(node.GetInDeg() + node.GetOutDeg() > 0) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Network + Graph = snap.GenRndGnm(snap.TNEANet, 100, 1000) + subGraph = Graph.GetRndESubGraph(exp_edges) + self.assertEqual(exp_edges, subGraph.GetEdges()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + self.assertTrue(node.GetInDeg() + node.GetOutDeg() > 0) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + def test_GetTriadEdges(self): + # Directed Graph + act_triad_edges = self.DirGraphFull.GetTriadEdges() + act_triad_edges_swig = snap.GetTriadEdges(self.DirGraphFull) + self.assertEqual(act_triad_edges, act_triad_edges_swig) + + # Unirected Graph + act_triad_edges = self.UnDirGraphFull.GetTriadEdges() + act_triad_edges_swig = snap.GetTriadEdges(self.UnDirGraphFull) + self.assertEqual(act_triad_edges, act_triad_edges_swig) + + # Network + act_triad_edges = self.NetFull.GetTriadEdges() + act_triad_edges_swig = snap.GetTriadEdges(self.NetFull) + self.assertEqual(act_triad_edges, act_triad_edges_swig) + + def test_GetTriadParticip(self): + f = math.factorial + exp_num_tri = f(self.num_nodes-1)/f(2)/f(self.num_nodes-3) + + # Directed Graph + TriadCntV = self.DirGraphFull.GetTriadParticip() + TriadCntV_swig = snap.TIntPrV() + snap.GetTriadParticip(self.DirGraphFull, TriadCntV_swig) + self.assertEqual(TriadCntV, TriadCntV_swig) + + # Undirected Graph + TriadCntV = self.UnDirGraphFull.GetTriadParticip() + TriadCntV_swig = snap.TIntPrV() + snap.GetTriadParticip(self.UnDirGraphFull, TriadCntV_swig) + + # Network + TriadCntV = self.NetFull.GetTriadParticip() + TriadCntV_swig = snap.TIntPrV() + snap.GetTriadParticip(self.NetFull, TriadCntV_swig) + + def test_CntEdgesToSet(self): + # Directed Graph + G = snap.GenFull(snap.TNGraph, 10) + val = G.CntEdgesToSet(0, set()) + TS_swig = snap.TIntSet() + val_swig = snap.CntEdgesToSet(G, 0, TS_swig) + self.assertEqual(val, val_swig) + + # Undirected Graph + G = snap.GenFull(snap.TUNGraph, 10) + val = G.CntEdgesToSet(0, set()) + TS_swig = snap.TIntSet() + val_swig = snap.CntEdgesToSet(G, 0, TS_swig) + self.assertEqual(val, val_swig) + + # Network + G = snap.GenFull(snap.TNEANet, 10) + val = G.CntEdgesToSet(0, set()) + TS_swig = snap.TIntSet() + val_swig = snap.CntEdgesToSet(G, 0, TS_swig) + self.assertEqual(val, val_swig) + + def test_GetAnfNode(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + SrcNId = 0 + DistNbrsV = Graph.GetAnfNode(SrcNId, 3, False, 8192) + SrcNId_swig = 0 + DistNbrsV_swig = snap.TIntFltKdV() + snap.GetAnf(Graph, SrcNId_swig, DistNbrsV_swig, 3, False, 8192) + self.assertEqual(DistNbrsV, DistNbrsV_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + SrcNId = 0 + DistNbrsV = Graph.GetAnfNode(SrcNId, 3, False, 8192) + SrcNId_swig = 0 + DistNbrsV_swig = snap.TIntFltKdV() + snap.GetAnf(Graph, SrcNId_swig, DistNbrsV_swig, 3, False, 8192) + self.assertEqual(DistNbrsV, DistNbrsV_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + SrcNId = 0 + DistNbrsV = Graph.GetAnfNode(SrcNId, 3, False, 8192) + SrcNId_swig = 0 + DistNbrsV_swig = snap.TIntFltKdV() + snap.GetAnf(Graph, SrcNId_swig, DistNbrsV_swig, 3, False, 8192) + self.assertEqual(DistNbrsV, DistNbrsV_swig) + + def test_GetAnfGraph(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + DistNbrsV = Graph.GetAnfGraph(3, False, 8192) + DistNbrsV_swig = snap.TIntFltKdV() + snap.GetAnf(Graph, DistNbrsV_swig, 3, False, 8192) + self.assertEqual(DistNbrsV, DistNbrsV_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + DistNbrsV = Graph.GetAnfGraph(3, False, 8192) + DistNbrsV_swig = snap.TIntFltKdV() + snap.GetAnf(Graph, DistNbrsV_swig, 3, False, 8192) + self.assertEqual(DistNbrsV, DistNbrsV_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + DistNbrsV = Graph.GetAnfGraph(3, False, 8192) + DistNbrsV_swig = snap.TIntFltKdV() + snap.GetAnf(Graph, DistNbrsV_swig, 3, False, 8192) + self.assertEqual(DistNbrsV, DistNbrsV_swig) + + def test_GetAnfEffDiam(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetAnfEffDiam(True, 0.9, 1024) + result_swig = snap.GetAnfEffDiam(Graph, True, 0.9, 1024) + self.assertAlmostEqual(result, result_swig, places=2) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetAnfEffDiam(True, 0.9, 1024) + result_swig = snap.GetAnfEffDiam(Graph, True, 0.9, 1024) + self.assertAlmostEqual(result, result_swig, places=2) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetAnfEffDiam(True, 0.9, 1024) + result_swig = snap.GetAnfEffDiam(Graph, True, 0.9, 1024) + self.assertAlmostEqual(result, result_swig, places=2) + + def test_GetAnfEffDiam2(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetAnfEffDiam() + result_swig = snap.GetAnfEffDiam(Graph) + self.assertAlmostEqual(result, result_swig, places=2) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetAnfEffDiam() + result_swig = snap.GetAnfEffDiam(Graph) + self.assertAlmostEqual(result, result_swig, places=2) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetAnfEffDiam() + result_swig = snap.GetAnfEffDiam(Graph) + self.assertAlmostEqual(result, result_swig, places=2) + + def test_GetShortPath(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetShortPath(0, 1) + result_swig = snap.GetShortPath(Graph, 0, 1) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetShortPath(0, 1) + result_swig = snap.GetShortPath(Graph, 0, 1) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetShortPath(0, 1) + result_swig = snap.GetShortPath(Graph, 0, 1) + self.assertEqual(result, result_swig) + + def test_GetShortPath2(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result, H = Graph.GetShortPathAll(0) + H_swig = snap.TIntH() + result_swig = snap.GetShortPath(Graph, 0, H_swig) + self.assertEqual(result, result_swig) + self.assertEqual(H, H_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result, H = Graph.GetShortPathAll(0) + H_swig = snap.TIntH() + result_swig = snap.GetShortPath(Graph, 0, H_swig) + self.assertEqual(result, result_swig) + self.assertEqual(H, H_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result, H = Graph.GetShortPathAll(0) + H_swig = snap.TIntH() + result_swig = snap.GetShortPath(Graph, 0, H_swig) + self.assertEqual(result, result_swig) + self.assertEqual(H, H_swig) + + def test_GetBfsFullDiam(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetBfsFullDiam(10) + result_swig = snap.GetBfsFullDiam(Graph, 10) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetBfsFullDiam(10) + result_swig = snap.GetBfsFullDiam(Graph, 10) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetBfsFullDiam(10) + result_swig = snap.GetBfsFullDiam(Graph, 10) + self.assertEqual(result, result_swig) + + def test_GetBfsEffDiam(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetBfsEffDiam(10) + result_swig = snap.GetBfsEffDiam(Graph, 10) + self.assertAlmostEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetBfsEffDiam(10) + result_swig = snap.GetBfsEffDiam(Graph, 10) + self.assertEqual(result, result_swig) + self.assertAlmostEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetBfsEffDiam(10) + result_swig = snap.GetBfsEffDiam(Graph, 10) + self.assertAlmostEqual(result, result_swig) + + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 100) + Num = 50 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + PyList = [1, 4, 9, 16, 25, 36] + result = Graph.GetBfsEffDiam(Num, PyList, True) + result_swig = snap.GetBfsEffDiam(Graph, Num, List, True) + self.assertAlmostEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 100) + Num = 75 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + PyList = [1, 4, 9, 16, 25, 36] + result = Graph.GetBfsEffDiam(Num, PyList, False) + result_swig = snap.GetBfsEffDiam(Graph, Num, List, False) + self.assertAlmostEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 100) + Num = 33 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + PyList = [1, 4, 9, 16, 25, 36] + result = Graph.GetBfsEffDiam(Num, PyList, True) + result_swig = snap.GetBfsEffDiam(Graph, Num, List, True) + self.assertAlmostEqual(result, result_swig) + + def test_GetBfsEffDiamAll(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 100) + Num = 50 + result = Graph.GetBfsEffDiamAll(Num, True) + result_swig = snap.GetBfsEffDiamAll(Graph, Num, True) + self.assertAlmostEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 100) + Num = 75 + result = Graph.GetBfsEffDiamAll(Num, False) + result_swig = snap.GetBfsEffDiamAll(Graph, Num, False) + self.assertAlmostEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 100) + Num = 33 + result = Graph.GetBfsEffDiamAll(Num, True) + result_swig = snap.GetBfsEffDiamAll(Graph, Num, True) + self.assertAlmostEqual(result, result_swig) + + def test_GetBetweennessCentr(self): + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + Nodes, Edges = Graph.GetBetweennessCentr(1.0) + Nodes_swig = snap.TIntFltH() + Edges_swig = snap.TIntPrFltH() + snap.GetBetweennessCentr(Graph, Nodes_swig, Edges_swig, 1.0) + self.assertEqual(Nodes, Nodes_swig) + self.assertEqual(Edges, Edges_swig) + + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + Nodes, Edges = Graph.GetBetweennessCentr(1.0) + Nodes_swig = snap.TIntFltH() + Edges_swig = snap.TIntPrFltH() + snap.GetBetweennessCentr(Graph, Nodes_swig, Edges_swig, 1.0) + self.assertEqual(Nodes, Nodes_swig) + self.assertEqual(Edges, Edges_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + Nodes, Edges = Graph.GetBetweennessCentr(1.0) + Nodes_swig = snap.TIntFltH() + Edges_swig = snap.TIntPrFltH() + snap.GetBetweennessCentr(Graph, Nodes_swig, Edges_swig, 1.0) + self.assertEqual(Nodes, Nodes_swig) + self.assertEqual(Edges, Edges_swig) + + def test_GetArtPoints(self): + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + V = Graph.GetArtPoints() + V_swig = snap.TIntV() + snap.GetArtPoints(Graph, V_swig) + self.assertEqual(V, V_swig) + + def test_GenConfModel(self): + # Undirected Graph + DegSeqV = [0] + Graph = snap.GenConfModel(DegSeqV) + DegSeqV_swig = snap.TIntV() + DegSeqV_swig.Add(0) + Graph_swig = snap.GenConfModel(DegSeqV_swig) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + + def test_GetCmnNbrs(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetCmnNbrs(0, 1, False) + result_swig = snap.GetCmnNbrs(Graph, 0, 1) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetCmnNbrs(0, 1, False) + result_swig = snap.GetCmnNbrs(Graph, 0, 1) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetCmnNbrs(0, 1, False) + result_swig = snap.GetCmnNbrs(Graph, 0, 1) + self.assertEqual(result, result_swig) + + def test_GetCmnNbrs1(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result, V = Graph.GetCmnNbrs(0, 1, True) + V_swig = snap.TIntV() + result_swig = snap.GetCmnNbrs(Graph, 0, 1, V_swig) + self.assertEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result, V = Graph.GetCmnNbrs(0, 1, True) + V_swig = snap.TIntV() + result_swig = snap.GetCmnNbrs(Graph, 0, 1, V_swig) + self.assertEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result, V = Graph.GetCmnNbrs(0, 1, True) + V_swig = snap.TIntV() + result_swig = snap.GetCmnNbrs(Graph, 0, 1, V_swig) + self.assertEqual(result, result_swig) + self.assertEqual(V, V_swig) + + def test_GetNodeTriads(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetNodeTriads(0) + result_swig = snap.GetNodeTriads(Graph, 0) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetNodeTriads(0) + result_swig = snap.GetNodeTriads(Graph, 0) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetNodeTriads(0) + result_swig = snap.GetNodeTriads(Graph, 0) + self.assertEqual(result, result_swig) + + def test_GetNodeTriadsSet(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 100) + for NI in Graph.Nodes(): + break + NId = NI.GetId() + GroupSet = set() + for NbrIdx in range(4): + GroupSet.add(NI.GetOutNId(NbrIdx)) + result = Graph.GetNodeTriadsSet(NId, GroupSet) + GroupSet_swig = snap.TIntSet() + for NbrIdx in range(4): + GroupSet_swig.AddKey(NI.GetOutNId(NbrIdx)) + result_swig = snap.GetNodeTriads(Graph, NId, GroupSet_swig) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 100) + for NI in Graph.Nodes(): + break + NId = NI.GetId() + GroupSetPy = set() + for NbrIdx in range(4): + GroupSetPy.add(NI.GetOutNId(NbrIdx)) + result = Graph.GetNodeTriadsSet(NId, GroupSetPy) + GroupSet_swig = snap.TIntSet() + for NbrIdx in range(4): + GroupSet_swig.AddKey(NI.GetOutNId(NbrIdx)) + result_swig = snap.GetNodeTriads(Graph, NId, GroupSet_swig) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 100) + for NI in Graph.Nodes(): + break + NId = NI.GetId() + GroupSetPy = set() + for NbrIdx in range(4): + GroupSetPy.add(NI.GetOutNId(NbrIdx)) + expected_result = [6, 6, 380, 4465] + result = Graph.GetNodeTriadsSet(NId, GroupSetPy) + GroupSet_swig = snap.TIntSet() + for NbrIdx in range(4): + GroupSet_swig.AddKey(NI.GetOutNId(NbrIdx)) + result_swig = snap.GetNodeTriads(Graph, NId, GroupSet_swig) + self.assertEqual(result, result_swig) + + def test_GetNodeTriadsAll(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 100) + result = Graph.GetNodeTriadsAll(10) + result_swig = snap.GetNodeTriadsAll(Graph, 10) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 100) + result = Graph.GetNodeTriadsAll(10) + result_swig = snap.GetNodeTriadsAll(Graph, 10) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 100) + result = Graph.GetNodeTriadsAll(10) + result_swig = snap.GetNodeTriadsAll(Graph, 10) + self.assertEqual(result, result_swig) + + def test_GetTriads(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + result = Graph.GetTriads() + result_swig = snap.GetTriads(Graph) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + result = Graph.GetTriads() + result_swig = snap.GetTriads(Graph) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + result = Graph.GetTriads() + result_swig = snap.GetTriads(Graph) + self.assertEqual(result, result_swig) + + def test_GetTriadsAll(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 100) + result = Graph.GetTriadsAll() + result_swig = snap.GetTriadsAll(Graph) + self.assertEqual(result, result_swig) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 100) + result = Graph.GetTriadsAll() + result_swig = snap.GetTriadsAll(Graph) + self.assertEqual(result, result_swig) + + # Network + Graph = snap.GenFull(snap.TNEANet, 100) + result = Graph.GetTriadsAll() + result_swig = snap.GetTriadsAll(Graph) + self.assertEqual(result, result_swig) + + def test_GetClustCf(self): + + # testing GetClustCf(Graph, SampleNodes=-1) + + DirGraph = snap.GenFull(snap.TNGraph, 10) + UnGraph = snap.GenFull(snap.TUNGraph, 10) + MultiGraph = snap.GenFull(snap.TNEANet, 10) + + # no parameters + + # Directed Graph + result = DirGraph.GetClustCf() + result_swig = snap.GetClustCf(DirGraph) + self.assertAlmostEqual(result, result_swig) + + # Undirected Graph + result = UnGraph.GetClustCf() + result_swig = snap.GetClustCf(UnGraph) + self.assertAlmostEqual(result, result_swig) + + # Network + result = MultiGraph.GetClustCf() + result_swig = snap.GetClustCf(MultiGraph) + self.assertAlmostEqual(result, result_swig) + + # parameter = 0 + + result = DirGraph.GetClustCf(False, 0) + result_swig = snap.GetClustCf(DirGraph, 0) + self.assertAlmostEqual(result, result_swig) + + result = UnGraph.GetClustCf(False, 0) + result_swig = snap.GetClustCf(UnGraph, 0) + self.assertAlmostEqual(result, result_swig) + + result = MultiGraph.GetClustCf(False, 0) + result_swig = snap.GetClustCf(MultiGraph, 0) + self.assertAlmostEqual(result, result_swig) + + # parameter > 0 + + result = DirGraph.GetClustCf(False, 3) + result_swig = snap.GetClustCf(DirGraph, 3) + self.assertAlmostEqual(result, result_swig) + + result = UnGraph.GetClustCf(False, 3) + result_swig = snap.GetClustCf(UnGraph, 3) + self.assertAlmostEqual(result, result_swig) + + result = MultiGraph.GetClustCf(False, 3) + result_swig = snap.GetClustCf(MultiGraph, 3) + self.assertAlmostEqual(result, result_swig) + + def test_GetClustCf2(self): + + # testing GetClustCf(Graph, DegToCCfV, SampleNodes=-1) + + DirGraph = snap.GenFull(snap.TNGraph, 10) + UnGraph = snap.GenFull(snap.TUNGraph, 10) + MultiGraph = snap.GenFull(snap.TNEANet, 10) + + # no parameters + + # Directed Graph + result, V = DirGraph.GetClustCf(True) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(DirGraph, V_swig) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # Undirected Graph + result, V = UnGraph.GetClustCf(True) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(UnGraph, V_swig) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # Network + result, V = MultiGraph.GetClustCf(True) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(MultiGraph, V_swig) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # parameter = 0 + + result, V = DirGraph.GetClustCf(True, 0) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(DirGraph, V_swig, 0) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = UnGraph.GetClustCf(True, 0) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(UnGraph, V_swig, 0) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = MultiGraph.GetClustCf(True, 0) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(MultiGraph, V_swig, 0) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # parameter > 0 + + result, V = DirGraph.GetClustCf(True, 3) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(DirGraph, V_swig, 3) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = UnGraph.GetClustCf(True, 3) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(UnGraph, V_swig, 3) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = MultiGraph.GetClustCf(True, 3) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCf(MultiGraph, V_swig, 3) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + def test_GetClustCfAll(self): + + DirGraph = snap.GenFull(snap.TNGraph, 100) + UnGraph = snap.GenFull(snap.TUNGraph, 100) + MultiGraph = snap.GenFull(snap.TNEANet, 100) + + # no parameter + + result, V = DirGraph.GetClustCfAll() + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(DirGraph, V_swig) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = UnGraph.GetClustCfAll() + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(UnGraph, V_swig) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = MultiGraph.GetClustCfAll() + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(MultiGraph, V_swig) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # parameter = 0 + + result, V = DirGraph.GetClustCfAll(0) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(DirGraph, V_swig, 0) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = UnGraph.GetClustCfAll(0) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(UnGraph, V_swig, 0) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = MultiGraph.GetClustCfAll(0) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(MultiGraph, V_swig, 0) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + # parameter > 0 + + result, V = DirGraph.GetClustCfAll(5) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(DirGraph, V_swig, 5) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = UnGraph.GetClustCfAll(5) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(UnGraph, V_swig, 5) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + result, V = MultiGraph.GetClustCfAll(5) + V_swig = snap.TFltPrV() + result_swig = snap.GetClustCfAll(MultiGraph, V_swig, 5) + self.assertAlmostEqual(result, result_swig) + self.assertEqual(V, V_swig) + + def test_GetLen2Paths(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 100) + result_swig = Graph.GetLen2Paths(0, 1, False) + result = snap.GetLen2Paths(Graph, 0, 1) + self.assertEqual(result_swig, result) + + result_swig, NV_swig = Graph.GetLen2Paths(0, 1, True) + NV = snap.TIntV() + result = snap.GetLen2Paths(Graph, 0, 1, NV) + self.assertEqual(result_swig, result) + self.assertEqual(NV_swig.Len(), NV_swig.Len()) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 100) + result_swig = Graph.GetLen2Paths(0, 1, False) + result = snap.GetLen2Paths(Graph, 0, 1) + self.assertEqual(result_swig, result) + + result_swig, NV_swig = Graph.GetLen2Paths(0, 1, True) + NV = snap.TIntV() + result = snap.GetLen2Paths(Graph, 0, 1, NV) + self.assertEqual(result_swig, result) + self.assertEqual(NV_swig.Len(), NV_swig.Len()) + + # Network + Graph = snap.GenFull(snap.TNEANet, 100) + result_swig = Graph.GetLen2Paths(0, 1, False) + result = snap.GetLen2Paths(Graph, 0, 1) + self.assertEqual(result_swig, result) + + result_swig, NV_swig = Graph.GetLen2Paths(0, 1, True) + NV = snap.TIntV() + result = snap.GetLen2Paths(Graph, 0, 1, NV) + self.assertEqual(result_swig, result) + self.assertEqual(NV_swig.Len(), NV_swig.Len()) + + def test_SavePajek(self): + fname = "mygraph.txt" + # Directed Graph + self.DirGraphFull.SavePajek(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.DirGraphFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + # Undirected Graph + self.UnDirGraphFull.SavePajek(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.UnDirGraphFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + # Directed Graph + self.NetFull.SavePajek(fname) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.NetFull, fname) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash, test_hash_swig) + + def test_SavePajek2(self): + fname = "mygraph.txt" + NIdColorH_swig = snap.TIntStrH() + NIdColorH = {} + for i in range(self.num_nodes): + NIdColorH_swig[i] = "red" + NIdColorH[i] = "red" + # Directed Graph + self.DirGraphFull.SavePajek(fname, NIdColorH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.DirGraphFull, fname, NIdColorH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Undirected Graph + self.UnDirGraphFull.SavePajek(fname, NIdColorH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.UnDirGraphFull, fname, NIdColorH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Directed Graph + self.NetFull.SavePajek(fname, NIdColorH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.NetFull, fname, NIdColorH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + def test_SavePajek3(self): + fname = "mygraph.txt" + NIdColorH_swig = snap.TIntStrH() + NIdColorH = {} + for i in range(self.num_nodes): + NIdColorH_swig[i] = "red" + NIdColorH[i] = "red" + NIdLabelH_swig = snap.TIntStrH() + NIdLabelH = {} + for i in range(100): + NIdLabelH_swig[i] = str(i) + NIdLabelH[i] = str(i) + # Directed Graph + self.DirGraphFull.SavePajek(fname, NIdColorH, NIdLabelH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.DirGraphFull, fname, NIdColorH_swig, NIdLabelH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Undirected Graph + self.UnDirGraphFull.SavePajek(fname, NIdColorH, NIdLabelH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.UnDirGraphFull, fname, NIdColorH_swig, NIdLabelH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Directed Graph + self.NetFull.SavePajek(fname, NIdColorH, NIdLabelH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.NetFull, fname, NIdColorH_swig, NIdLabelH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + def test_SavePajek4(self): + fname = "mygraph.txt" + NIdColorH_swig = snap.TIntStrH() + NIdColorH = {} + for i in range(self.num_nodes): + NIdColorH_swig[i] = "red" + NIdColorH[i] = "red" + NIdLabelH_swig = snap.TIntStrH() + NIdLabelH = {} + for i in range(100): + NIdLabelH_swig[i] = str(i) + NIdLabelH[i] = str(i) + EIdColorH_swig = snap.TIntStrH() + EIdColorH = {} + for i in range(1000): + EIdColorH_swig[i] = "black" + EIdColorH[i] = "black" + # Directed Graph + self.DirGraphFull.SavePajek(fname, NIdColorH, NIdLabelH, EIdColorH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.DirGraphFull, fname, NIdColorH_swig, NIdLabelH_swig, EIdColorH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Undirected Graph + self.UnDirGraphFull.SavePajek(fname, NIdColorH, NIdLabelH, EIdColorH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.UnDirGraphFull, fname, NIdColorH_swig, NIdLabelH_swig, EIdColorH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Directed Graph + self.NetFull.SavePajek(fname, NIdColorH, NIdLabelH, EIdColorH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SavePajek(self.NetFull, fname, NIdColorH_swig, NIdLabelH_swig, EIdColorH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + def test_SaveGViz(self): + fname = "mygraph.dot" + NIdColorH = snap.TIntStrH() + NIdColor_dict = {} + for i in range(self.num_nodes): + NIdColorH[i] = "red" + NIdColor_dict[i] = "red" + # Directed Graph + snap.SaveGViz(self.DirGraphFull, fname, "text", True, NIdColorH) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.DirGraphFull.SaveGVizColor(fname, "text", True, NIdColor_dict) + test_hash = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Undirected Graph + snap.SaveGViz(self.UnDirGraphFull, fname, "text", True, NIdColorH) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.UnDirGraphFull.SaveGVizColor(fname, "text", True, NIdColor_dict) + test_hash = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Directed Graph + snap.SaveGViz(self.NetFull, fname, "text", True, NIdColorH) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.NetFull.SaveGVizColor(fname, "text", True, NIdColor_dict) + test_hash = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + def test_SaveGViz2(self): + fname = "mygraph.dot" + NIdLabelH_swig = snap.TIntStrH() + NIdLabelH = {} + for i in range(self.num_nodes): + NIdLabelH_swig[i] = str(i) + NIdLabelH[i] = str(i) + # Directed Graph + self.DirGraphFull.SaveGViz(fname, "text", NIdLabelH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveGViz(self.DirGraphFull, fname, "text", NIdLabelH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Undirected Graph + self.UnDirGraphFull.SaveGViz(fname, "text", NIdLabelH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveGViz(self.UnDirGraphFull, fname, "text", NIdLabelH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + # Directed Graph + self.NetFull.SaveGViz(fname, "text", NIdLabelH) + test_hash = self.getFileHash(fname) + os.remove(fname) + snap.SaveGViz(self.NetFull, fname, "text", NIdLabelH_swig) + test_hash_swig = self.getFileHash(fname) + os.remove(fname) + self.assertEqual(test_hash_swig, test_hash) + + def test_LoadEdgeList(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveEdgeList(self.DirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.TNGraph, fname, 0, 1) + Graph_swig = snap.LoadEdgeList(snap.PNGraph, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + os.remove(fname) + + # Undirected Graph + snap.SaveEdgeList(self.UnDirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.TUNGraph, fname, 0, 1) + Graph_swig = snap.LoadEdgeList(snap.PUNGraph, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + os.remove(fname) + + # Directed Graph + snap.SaveEdgeList(self.NetFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.TNEANet, fname, 0, 1) + Graph_swig = snap.LoadEdgeList(snap.PNEANet, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + os.remove(fname) + + def test_LoadEdgeList2(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveEdgeList(self.DirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.TNGraph, fname, 0, 1, '\t') + Graph_swig = snap.LoadEdgeList(snap.PNGraph, fname, 0, 1, '\t') + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + os.remove(fname) + + # Undirected Graph + snap.SaveEdgeList(self.UnDirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.TUNGraph, fname, 0, 1, '\t') + Graph_swig = snap.LoadEdgeList(snap.PUNGraph, fname, 0, 1, '\t') + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + os.remove(fname) + + # Directed Graph + snap.SaveEdgeList(self.NetFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.TNEANet, fname, 0, 1, '\t') + Graph_swig = snap.LoadEdgeList(snap.PNEANet, fname, 0, 1, '\t') + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + os.remove(fname) + + def test_LoadEdgeListStr(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveEdgeList(self.DirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph, mapping = snap.LoadEdgeListStr(snap.TNGraph, fname, 0, 1, True) + mapping_swig = snap.TStrIntSH() + Graph_swig = snap.LoadEdgeListStr(snap.PNGraph, fname, 0, 1, mapping_swig) + self.assertEqual(mapping.Len(), mapping_swig.Len()) + self.checkGraphs(Graph, Graph_swig) + os.remove(fname) + + # Undirected Graph + snap.SaveEdgeList(self.UnDirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph, mapping = snap.LoadEdgeListStr(snap.TUNGraph, fname, 0, 1, True) + mapping_swig = snap.TStrIntSH() + Graph_swig = snap.LoadEdgeListStr(snap.PUNGraph, fname, 0, 1, mapping_swig) + self.assertEqual(mapping.Len(), mapping_swig.Len()) + self.checkGraphs(Graph, Graph_swig) + os.remove(fname) + + # Directed Graph + snap.SaveEdgeList(self.NetFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph, mapping = snap.LoadEdgeListStr(snap.TNEANet, fname, 0, 1, True) + mapping_swig = snap.TStrIntSH() + Graph_swig = snap.LoadEdgeListStr(snap.PNEANet, fname, 0, 1, mapping_swig) + self.assertEqual(mapping.Len(), mapping_swig.Len()) + self.checkGraphs(Graph, Graph_swig) + os.remove(fname) + + + def test_LoadConnList(self): + fname = "mygraph.txt" + output = open(fname, "w") + output.write('0 1 2\n') + output.write('1 2 0\n') + output.write('2 0 1\n') + output.close() + + # Directed Graph + Graph_swig = snap.LoadConnList(snap.PNGraph, fname) + Graph = snap.LoadConnList(snap.TNGraph, fname) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + + # Undirected Graph + Graph_swig = snap.LoadConnList(snap.PUNGraph, fname) + Graph = snap.LoadConnList(snap.TUNGraph, fname) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + + # Network + Graph_swig = snap.LoadConnList(snap.PNEANet, fname) + Graph = snap.LoadConnList(snap.TNEANet, fname) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + os.remove(fname) + + def test_LoadConnListStr(self): + fname = "mygraph.txt" + output = open(fname, "w") + output.write('0 1 2\n') + output.write('1 2 0\n') + output.write('2 0 1\n') + output.close() + + # Directed Graph + mapping_swig = snap.TStrIntSH() + Graph_swig = snap.LoadConnListStr(snap.PNGraph, fname, mapping_swig) + Graph, mapping = snap.LoadConnListStr(snap.TNGraph, fname) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + self.assertEqual(mapping.Len(), mapping_swig.Len()) + + # Undirected Graph + mapping_swig = snap.TStrIntSH() + Graph_swig = snap.LoadConnListStr(snap.PUNGraph, fname, mapping_swig) + Graph, mapping = snap.LoadConnListStr(snap.TUNGraph, fname) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + self.assertEqual(mapping.Len(), mapping_swig.Len()) + + # Network + mapping_swig = snap.TStrIntSH() + Graph_swig = snap.LoadConnListStr(snap.PNEANet, fname, mapping_swig) + Graph, mapping = snap.LoadConnListStr(snap.TNEANet, fname) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + self.assertEqual(mapping.Len(), mapping_swig.Len()) + os.remove(fname) + + def test_LoadPajek(self): + fname = "example.paj" + output = open(fname, "w") + output.write('*Vertices 9\n') + output.write('1 "1" 0.3034 0.7561\n') + output.write('2 "2" 0.4565 0.6039\n') + output.write('3 "3" 0.4887 0.8188\n') + output.write('*Arcs\n') + output.write('*Edges\n') + output.write(' 1 2 1\n') + output.write(' 1 3 1\n') + output.write(' 2 3 1\n') + output.close() + + # Directed Graph + Graph = snap.LoadPajek(snap.TNGraph, fname) + count = 1 + for node in Graph.Nodes(): + self.assertEqual(count, node.GetId()) + count += 1 + + # Undirected Graph + Graph = snap.LoadPajek(snap.TUNGraph, fname) + count = 1 + for node in Graph.Nodes(): + self.assertEqual(count, node.GetId()) + count += 1 + + # Network + Graph = snap.LoadPajek(snap.TNGraph, fname) + count = 1 + for node in Graph.Nodes(): + self.assertEqual(count, node.GetId()) + count += 1 + + os.remove(fname) + + def test_GetSngVec(self): + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + LeftSV, RightSV = Graph.GetLeadSngVec() + LeftSV_swig = snap.TFltV() + RightSV_swig = snap.TFltV() + snap.GetSngVec(Graph, LeftSV_swig, RightSV_swig) + for i,i_swig in zip(LeftSV, LeftSV_swig): + self.assertAlmostEqual(i, i_swig) + for i,i_swig in zip(RightSV, RightSV_swig): + self.assertAlmostEqual(i, i_swig) + + SngValV, LeftSVV, RightSVV = Graph.GetSngVecs(5) + SngValV_swig = snap.TFltV() + LeftSVV_swig = snap.TFltVFltV() + RightSVV_swig = snap.TFltVFltV() + snap.GetSngVec(Graph, 5, SngValV_swig, LeftSVV_swig, RightSVV_swig) + for i,i_swig in zip(SngValV, SngValV_swig): + self.assertAlmostEqual(i, i_swig) + for i,i_swig in zip(LeftSVV, LeftSVV_swig): + self.assertAlmostEqual(i, i_swig) + for i,i_swig in zip(RightSVV, RightSVV_swig): + self.assertAlmostEqual(i, i_swig) + + def test_GetLeadEigVec(self): + # Undirected Graph + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 500) + EigV = Graph.GetLeadEigVec() + self.assertEqual(EigV.Len(), 100) + + def test_GetEigVecs(self): + # Undirected Graph + Graph = snap.GenRndGnm(snap.TUNGraph, 100, 500) + EigVal, EigVV = Graph.GetEigVecs(10) + self.assertEqual(EigVal.Len(), 10) + for V in EigVV: + self.assertEqual(V.Len(), 100) + + def test_DrawGViz(self): + # Directed Graph + fname = "mygraph.png" + fname_swig = "mygraph_swig.png" + self.DirGraphFull.DrawGViz(snap.gvlDot, fname, "graph 1") + snap.DrawGViz(self.DirGraphFull, snap.gvlDot, fname_swig, "graph 1") + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + f = open(fname_swig, 'rb') + swig_hash = hashlib.md5(f.read()).hexdigest() + f.close() + self.assertEqual(swig_hash, test_hash) + os.remove(fname) + os.remove(fname_swig) + + # Undirected Graph + fname = "mygraph.png" + fname_swig = "mygraph_swig.png" + self.UnDirGraphFull.DrawGViz(snap.gvlDot, fname, "graph 1") + snap.DrawGViz(self.UnDirGraphFull, snap.gvlDot, fname_swig, "graph 1") + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + f = open(fname_swig, 'rb') + swig_hash = hashlib.md5(f.read()).hexdigest() + f.close() + self.assertEqual(swig_hash, test_hash) + os.remove(fname) + os.remove(fname_swig) + + # Network + fname = "mygraph.png" + fname_swig = "mygraph_swig.png" + self.NetFull.DrawGViz(snap.gvlDot, fname, "graph 1") + snap.DrawGViz(self.NetFull, snap.gvlDot, fname_swig, "graph 1") + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + f = open(fname_swig, 'rb') + swig_hash = hashlib.md5(f.read()).hexdigest() + f.close() + self.assertEqual(swig_hash, test_hash) + os.remove(fname) + os.remove(fname_swig) + + def test_DrawGViz2(self): + + # Directed Graph + fname = "mygraph.png" + fname_swig = "mygraph_swig.png" + labels = snap.TIntStrH() + for NI in self.DirGraphFull.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + self.DirGraphFull.DrawGViz(snap.gvlDot, fname, "graph 1", labels) + snap.DrawGViz(self.DirGraphFull, snap.gvlDot, fname_swig, "graph 1", labels) + self.assertTrue(os.stat(fname).st_size > 50000) + self.assertTrue(os.path.isfile(fname)) + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + f = open(fname_swig, 'rb') + swig_hash = hashlib.md5(f.read()).hexdigest() + f.close() + #self.assertEqual(swig_hash, test_hash) + os.remove(fname) + os.remove(fname_swig) + + # Undirected Graph + fname = "mygraph.png" + fname_swig = "mygraph_swig.png" + labels = snap.TIntStrH() + for NI in self.UnDirGraphFull.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + self.UnDirGraphFull.DrawGViz(snap.gvlDot, fname, "graph 1", labels) + snap.DrawGViz(self.UnDirGraphFull, snap.gvlDot, fname_swig, "graph 1", labels) + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + f = open(fname_swig, 'rb') + swig_hash = hashlib.md5(f.read()).hexdigest() + f.close() + self.assertEqual(swig_hash, test_hash) + os.remove(fname) + os.remove(fname_swig) + + # Network + fname = "mygraph.png" + fname_swig = "mygraph_swig.png" + labels = snap.TIntStrH() + for NI in self.NetFull.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + self.NetFull.DrawGViz(snap.gvlDot, fname, "graph 1", labels) + snap.DrawGViz(self.NetFull, snap.gvlDot, fname_swig, "graph 1", labels) + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + f = open(fname_swig, 'rb') + swig_hash = hashlib.md5(f.read()).hexdigest() + f.close() + self.assertEqual(swig_hash, test_hash) + os.remove(fname) + os.remove(fname_swig) + + def test_GetSubGraph(self): + V = [] + for i in range(5): + V.append(i) + V_swig = snap.TIntV() + for i in range(5): + V_swig.Add(i) + + # Directed Graph + Graph = snap.GenFull(snap.TNGraph, 10) + SubGraph = Graph.GetSubGraph(V) + SubGraph_swig = snap.GetSubGraph(Graph, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + SubGraph = Graph.GetSubGraphRenumber(V) + SubGraph_swig = snap.GetSubGraphRenumber(Graph, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + # verify that NIds are in 0..N-1 + for NI in SubGraph.Nodes(): + self.assertEqual(NI.GetId() < SubGraph.GetNodes(), True) + + # Undirected Graph + Graph = snap.GenFull(snap.TUNGraph, 10) + SubGraph = Graph.GetSubGraph(V) + SubGraph_swig = snap.GetSubGraph(Graph, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + SubGraph = Graph.GetSubGraphRenumber(V) + SubGraph_swig = snap.GetSubGraphRenumber(Graph, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + # verify that NIds are in 0..N-1 + for NI in SubGraph.Nodes(): + self.assertEqual(NI.GetId() < SubGraph.GetNodes(), True) + + # Network + Graph = snap.GenFull(snap.TNEANet, 10) + SubGraph = Graph.GetSubGraph(V) + SubGraph_swig = snap.GetSubGraph(Graph, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + def test_GetNodeClustCf(self): + # Directed Graph + H = self.DirGraphFull.GetNodeClustCfAll() + H_swig = snap.TIntFltH() + snap.GetNodeClustCf(self.DirGraphFull, H_swig) + self.assertEqual(H, H_swig) + + # Undirected Graph + H = self.UnDirGraphFull.GetNodeClustCfAll() + H_swig = snap.TIntFltH() + snap.GetNodeClustCf(self.UnDirGraphFull, H_swig) + self.assertEqual(H, H_swig) + + # Network + H = self.NetFull.GetNodeClustCfAll() + H_swig = snap.TIntFltH() + snap.GetNodeClustCf(self.NetFull, H_swig) + self.assertEqual(H, H_swig) + + def test_ConvertESubGraph(self): + V = [] + for i in range(10): + V.append(i+1) + V_swig = snap.TIntV() + for i in range(10): + V_swig.Add(i+1) + + # Directed Graph + SubGraph = self.NetFull.ConvertESubGraph(snap.TNGraph, V) + SubGraph_swig = snap.ConvertESubGraph(snap.PNGraph, self.NetFull, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + # Undirected Graph + SubGraph = self.NetFull.ConvertESubGraph(snap.TUNGraph, V) + SubGraph_swig = snap.ConvertESubGraph(snap.PUNGraph, self.NetFull, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + # Network + SubGraph = self.NetFull.ConvertESubGraph(snap.TNEANet, V) + SubGraph_swig = snap.ConvertESubGraph(snap.PNEANet, self.NetFull, V_swig) + self.checkGraphs(SubGraph, SubGraph_swig) + + def test_GetEgonet(self): + + # Undirected Graph + for i in range(10): + Egonet, edges = self.UPetersen.GetEgonet(i) + Egonet_swig, edges_swig = snap.GetEgonet(self.UPetersen, i) + self.assertEqual(Egonet.GetNodes(), Egonet_swig.GetNodes()) + self.assertEqual(Egonet.GetEdges(), Egonet_swig.GetEdges()) + self.assertEqual(edges, edges_swig) + + # Directed Graph + for i in range(10): + Egonet, ein, eout = self.DPetersen.GetEgonet(i) + Egonet_swig, ein_swig, eout_swig = snap.GetEgonet(self.DPetersen, i) + self.assertEqual(Egonet.GetNodes(), Egonet_swig.GetNodes()) + self.assertEqual(Egonet.GetEdges(), Egonet_swig.GetEdges()) + self.assertEqual(ein, ein_swig) + self.assertEqual(eout, eout_swig) + + def test_GetEgonetHop(self): + + n = 0 + for Graph in self.PetersenGraphs: + for i in range(1,3): + n = (n + 1) % 10 + Egonet = Graph.GetEgonetHop(n, i) + Egonet_swig = snap.GetEgonetHop(Graph, n, i) + self.assertEqual(Egonet.GetNodes(), Egonet_swig.GetNodes()) + self.assertEqual(Egonet.GetEdges(), Egonet_swig.GetEdges()) + + def test_GetInEgonetHop(self): + + n = 2 + for Graph in self.PetersenGraphs: + for i in range(1,3): + n = (n + 1) % 10 + Egonet = Graph.GetInEgonetHop(n, i) + Egonet_swig = snap.GetInEgonetHop(Graph, n, i) + self.assertEqual(Egonet.GetNodes(), Egonet_swig.GetNodes()) + self.assertEqual(Egonet.GetEdges(), Egonet_swig.GetEdges()) + + def test_GetOutEgonetHop(self): + + n = 5 + for Graph in self.PetersenGraphs: + for i in range(1,3): + n = (n + 1) % 10 + Egonet = Graph.GetOutEgonetHop(n, i) + Egonet_swig = snap.GetOutEgonetHop(Graph, n, i) + self.assertEqual(Egonet.GetNodes(), Egonet_swig.GetNodes()) + self.assertEqual(Egonet.GetEdges(), Egonet_swig.GetEdges()) + + def test_GetInEgonetSub(self): + + n = 8 + for Graph in self.PetersenGraphs: + for i in range(1,3): + n = (n + 1) % 10 + Egonet = Graph.GetInEgonetSub(n, i, 2) + Egonet_swig = snap.GetInEgonetSub(Graph, n, i, 2) + self.assertEqual(Egonet.GetNodes(), Egonet_swig.GetNodes()) + self.assertEqual(Egonet.GetEdges(), Egonet_swig.GetEdges()) + + def test_GetGraphUnion(self): + + #Undirected Graph + Graph = snap.TUNGraph.New() + Graph0 = snap.TUNGraph.New() + for i in range(5): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i+1) % 5) + Graph.AddEdge(i,(i+2) % 5) + + for i in range(3,8): + Graph0.AddNode(i) + for i in range(5): + Graph0.AddEdge(i + 3,((i+1) % 5) + 3) + + Graph_swig = Graph.ConvertGraph(snap.TUNGraph) + Graph0_swig = Graph0.ConvertGraph(snap.TUNGraph) + + Graph.GetGraphUnion(Graph0) + snap.GetGraphUnion(Graph_swig, Graph0_swig) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + + # Directed Graph + Graph1 = snap.TNGraph.New() + Graph2 = snap.TNGraph.New() + for i in range(4): + Graph1.AddNode(i) + for i in range(1,5): + Graph2.AddNode(i) + + Graph1.AddEdge(0, 1) + Graph1.AddEdge(1, 2) + Graph2.AddEdge(1, 2) + Graph2.AddEdge(2, 1) + Graph1.AddEdge(2, 3) + Graph2.AddEdge(2, 3) + Graph1.AddEdge(3, 2) + Graph2.AddEdge(3, 4) + Graph2.AddEdge(1, 4) + + Graph1_swig = Graph1.ConvertGraph(snap.TNGraph) + Graph2_swig = Graph2.ConvertGraph(snap.TNGraph) + + Graph1.GetGraphUnion(Graph2) + snap.GetGraphUnion(Graph1_swig, Graph2_swig) + self.assertEqual(Graph1.GetNodes(), Graph1_swig.GetNodes()) + self.assertEqual(Graph1.GetEdges(), Graph1_swig.GetEdges()) + + # Directed Network + Graph3 = snap.TNEANet.New() + Graph4 = snap.TNEANet.New() + EId = 0 + for i in range(4): + Graph3.AddNode(i) + for i in range(1,5): + Graph4.AddNode(i) + + Graph3.AddEdge(0, 1, EId) + EId += 1 + Graph3.AddEdge(1, 2, EId) + EId += 1 + Graph4.AddEdge(1, 2, EId) + EId += 1 + Graph4.AddEdge(2, 1, EId) + EId += 1 + Graph3.AddEdge(2, 3, EId) + Graph4.AddEdge(2, 3, EId) + EId += 1 + Graph3.AddEdge(3, 2, EId) + EId += 1 + Graph4.AddEdge(3, 4, EId) + EId += 1 + Graph4.AddEdge(1, 4, EId) + EId += 1 + + Graph3_swig = Graph3.ConvertGraph(snap.TNEANet) + Graph4_swig = Graph4.ConvertGraph(snap.TNEANet) + + Graph3.GetGraphUnion(Graph4) + snap.GetGraphUnion(Graph3_swig, Graph4_swig) + self.assertEqual(Graph3.GetNodes(), Graph3_swig.GetNodes()) + self.assertEqual(Graph3.GetEdges(), Graph3_swig.GetEdges()) + + def test_GetGraphUnionAttr(self): + Graph = snap.TNEANet.New() + Graph0 = snap.TNEANet.New() + + s = "id" + for i in range(6): + Graph.AddNode(i) + Graph.AddIntAttrDatN(i, i, s) + + for i in range(3,9): + Graph0.AddNode(i) + Graph0.AddIntAttrDatN(i, i, s) + + for i in range(6): + EId = Graph.AddEdge(i, (i + 2) % 6) + Graph.AddIntAttrDatE(EId, (i + 2) % 6, s) + EId = Graph.AddEdge(i, (i + 5) % 6) + Graph.AddIntAttrDatE(EId, (i + 5) % 6, s) + + for i in range(6): + EId = Graph0.AddEdge(i + 3, ((i + 3) % 6) + 3) + Graph0.AddIntAttrDatE(EId, ((i + 3) % 6) + 3, s) + EId = Graph0.AddEdge(i + 3, ((i + 4) % 6) + 3) + Graph0.AddIntAttrDatE(EId, ((i + 4) % 6) + 3, s) + + Graph_swig = Graph.ConvertGraph(snap.TNEANet) + Graph0_swig = Graph0.ConvertGraph(snap.TNEANet) + + Graph.GetGraphUnionAttr(Graph0) + snap.GetGraphUnionAttr(Graph_swig, Graph0_swig) + self.assertEqual(Graph.GetNodes(), Graph_swig.GetNodes()) + self.assertEqual(Graph.GetEdges(), Graph_swig.GetEdges()) + + def test_GetGraphIntersection(self): + #Undirected Graph + Graph = snap.TUNGraph.New() + Graph0 = snap.TUNGraph.New() + + for i in range(5): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i + 1) % 5) + Graph.AddEdge(i,(i + 2) % 5) + + for i in range(2,6): + Graph0.AddNode(i) + for i in range(4): + Graph0.AddEdge(i + 2, ((i + 1) % 4) + 2) + Graph0.AddEdge(i + 2, ((i + 2) % 4) + 2) + + Graph_swig = Graph.ConvertGraph(snap.TUNGraph) + Graph0_swig = Graph0.ConvertGraph(snap.TUNGraph) + + IntersectionGraph = Graph.GetGraphIntersection(Graph0) + IntersectionGraph_swig = snap.GetGraphIntersection(Graph_swig, Graph0_swig) + self.assertEqual(IntersectionGraph.GetNodes(), IntersectionGraph_swig.GetNodes()) + self.assertEqual(IntersectionGraph.GetEdges(), IntersectionGraph_swig.GetEdges()) + + # Directed Graph + Graph1 = snap.TNGraph.New() + Graph2 = snap.TNGraph.New() + + for i in range(8): + Graph1.AddNode(i) + for i in range(8): + Graph1.AddEdge(i, (i + 1) % 8) + Graph1.AddEdge((i + 1) % 8, i) + + for i in range(2,6): + Graph2.AddNode(i) + for i in range(4): + Graph2.AddEdge(i + 2, ((i + 1) % 4) + 2) + Graph2.AddEdge(i + 2, ((i + 2) % 4) + 2) + + Graph1_swig = Graph1.ConvertGraph(snap.TNGraph) + Graph2_swig = Graph2.ConvertGraph(snap.TNGraph) + + IntersectionGraph0 = Graph1.GetGraphIntersection(Graph2) + IntersectionGraph0_swig = snap.GetGraphIntersection(Graph1_swig, Graph2_swig) + self.assertEqual(IntersectionGraph0.GetNodes(), IntersectionGraph0_swig.GetNodes()) + self.assertEqual(IntersectionGraph0.GetEdges(), IntersectionGraph0_swig.GetEdges()) + + # Directed Network + Graph3 = snap.TNEANet.New() + Graph4 = snap.TNEANet.New() + EId3 = 0 + EId4 = 1 + for i in range(4): + Graph3.AddNode(i) + for i in range(3): + Graph3.AddEdge(i, i + 1, EId3) + EId3 += 1 + Graph3.AddEdge(1, 0, EId3) + EId3 += 1 + Graph3.AddEdge(1, 2, EId3) + EId3 += 1 + Graph3.AddEdge(3, 2, EId3) + EId3 += 1 + + for i in range(1,5): + Graph4.AddNode(i) + for i in range(1,4): + Graph4.AddEdge(i + 1, i, EId4 + 3) + Graph4.AddEdge(i, i + 1, EId4) + EId4 += 1 + + Graph3_swig = Graph3.ConvertGraph(snap.TNEANet) + Graph4_swig = Graph4.ConvertGraph(snap.TNEANet) + + IntersectionGraph1 = Graph3.GetGraphIntersection(Graph4) + IntersectionGraph1_swig = snap.GetGraphIntersection(Graph3_swig, Graph4_swig) + self.assertEqual(IntersectionGraph1.GetNodes(), IntersectionGraph1_swig.GetNodes()) + self.assertEqual(IntersectionGraph1.GetEdges(), IntersectionGraph1_swig.GetEdges()) + + def test_GetGraphIntersectionAttr(self): + Graph = snap.TNEANet.New() + Graph0 = snap.TNEANet.New() + + s = "id" + for i in range(7): + Graph.AddNode(i) + Graph.AddIntAttrDatN(i, i, s) + + for i in range(2,9): + Graph0.AddNode(i) + Graph0.AddIntAttrDatN(i, i, s) + + for i in range(7): + EId = Graph.AddEdge(i, (i + 2) % 7) + Graph.AddIntAttrDatE(EId, (i + 2) % 7, s) + EId = Graph.AddEdge(i, (i + 3) % 7) + Graph.AddIntAttrDatE(EId, (i + 3) % 7, s) + + for i in range(7): + EId = Graph0.AddEdge(i + 2, ((i + 3) % 7) + 2) + Graph0.AddIntAttrDatE(EId, ((i + 3) % 7) + 2, s) + + Graph_swig = Graph.ConvertGraph(snap.TNEANet) + Graph0_swig = Graph0.ConvertGraph(snap.TNEANet) + + IntersectionGraph = snap.GetGraphIntersectionAttr(Graph, Graph0) + IntersectionGraph_swig = snap.GetGraphIntersectionAttr(Graph_swig, Graph0_swig) + self.assertEqual(IntersectionGraph.GetNodes(), IntersectionGraph_swig.GetNodes()) + self.assertEqual(IntersectionGraph.GetEdges(), IntersectionGraph_swig.GetEdges()) + +if __name__ == '__main__': + unittest.main() + diff --git a/snap-python/source/test/snap-test.py b/snap-python/source/test/snap-test.py new file mode 100644 index 0000000000000000000000000000000000000000..0a47329dfdb58af1ca6bd2fcaeb632e67bfd7b9a --- /dev/null +++ b/snap-python/source/test/snap-test.py @@ -0,0 +1,3994 @@ +# coding: utf-8 +import hashlib +import math +import os +import re +import time +import unittest + +import snap + +PATH_TO_GNUTELLA = "data/p2p-Gnutella08.txt" + +class SnapPythonTest(unittest.TestCase): + + def __init__(self, *args, **kwargs): + self.gnutella = snap.LoadEdgeList(snap.PNGraph, PATH_TO_GNUTELLA) + super(SnapPythonTest, self).__init__(*args, **kwargs) + + def setUp(self): + # Defaults for creating graphs + self.num_nodes = 10 + + # Full Graphs + self.DirGraphFull = snap.GenFull(snap.PNGraph, self.num_nodes) + self.UnDirGraphFull = snap.GenFull(snap.PUNGraph, self.num_nodes) + self.NetFull = snap.GenFull(snap.PNEANet, self.num_nodes) + + # Star Graphs + self.DirGraphStar = snap.GenStar(snap.PNGraph, self.num_nodes) + self.UnDirGraphStar = snap.GenStar(snap.PUNGraph, self.num_nodes) + self.NetStar = snap.GenStar(snap.PNEANet, self.num_nodes) + + # Graph With Self Edges + self.DirGraphSelfEdge = snap.GenRndGnm(snap.PNGraph, 10, 20) + self.DirGraphSelfEdge.AddEdge(0, 0) + self.UnDirGraphSelfEdge = snap.GenRndGnm(snap.PUNGraph, 10, 20) + self.UnDirGraphSelfEdge.AddEdge(0, 0) + self.NetSelfEdge = snap.GenRndGnm(snap.PNEANet, 10, 20) + self.NetSelfEdge.AddEdge(0, 0) + + # Graph With Multiple Zero-Degree Nodes + self.DirGraphZeroDegree = snap.GenRndGnm(snap.PNGraph, 10, 1) + self.UnDirGraphZeroDegree = snap.GenRndGnm(snap.PUNGraph, 10, 1) + self.NetZeroDegree = snap.GenRndGnm(snap.PNEANet, 10, 1) + + # Trees + self.DirTree = snap.GenTree(snap.PNGraph, 3, 3) + self.UnDirTree = snap.GenTree(snap.PUNGraph, 3, 3) + self.NetTree = snap.GenTree(snap.PNEANet, 3, 3) + + # Random + self.DirRand = snap.GenRndGnm(snap.PNGraph, 10, 20) + self.UnDirRand = snap.GenRndGnm(snap.PUNGraph, 10, 20) + self.NetRand = snap.GenRndGnm(snap.PNEANet, 10, 20) + + # Petersen graph + Graph = snap.TUNGraph.New() + for i in range(10): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i+1) % 5) + for i in range(5): + Graph.AddEdge(i + 5,(i+2) % 5 + 5) + for i in range(5): + Graph.AddEdge(i,i + 5) + self.UPetersen = Graph + #snap.DrawGViz(self.UPetersen, snap.gvlDot, "upetersen.png", "undir") + + # directed Petersen graph + Graph = snap.TNGraph.New() + for i in range(10): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i+1) % 5) + for i in range(5): + Graph.AddEdge(i + 5,(i+2) % 5 + 5) + for i in range(5): + Graph.AddEdge(i,i + 5) + self.DPetersen = Graph + #snap.DrawGViz(self.DPetersen, snap.gvlDot, "dpetersen.png", "dir") + + # directed Petersen network + self.NPetersen = self.DPetersen.ConvertGraph(snap.TNEANet) + #snap.DrawGViz(self.NPetersen, snap.gvlDot, "npetersen.png", "multi") + + #### Helper Functions for Tests #### + + def checkPlotHash(self, gen_file, exp_hash): + self.assertTrue(os.path.isfile(gen_file)) + f = open(gen_file,'r') + lines = f.readlines() + f.close() + # remove comments, since these include time + newlines = [] + for line in lines: + if len(line) > 0 and line[0] == "#": + continue + newlines.append(line) + # remove carriage return, which is included on Windows + newcontent = str("".join(newlines).replace("\r","")).encode("utf-8") + act_hash = hashlib.md5(newcontent).hexdigest() + self.assertEqual(exp_hash, act_hash) + + def getFileHash(self, fname): + f = open(fname, 'r') + content = f.read() + f.close() + newcontent = str(content.replace("\r","")).encode("utf-8") + test_hash = hashlib.md5(newcontent).hexdigest() + return test_hash + + def checkPrintInfoOutput(self, filename, params): + count = 0 + with open(filename) as f: + for line in f: + if count == 0: + firstLine = line.split(':') + self.assertEqual(params[count], firstLine[0]) + else: + result = re.findall('[0-9]+', line) + self.assertEqual(params[count], result[0]) + count += 1 + + #### Tests #### + + # Avery Vector tests + def test_vec_append(self): + # Vector to test against + new_vec = snap.TIntV() + new_vec.Add(1) + + vector = snap.TIntV() + vector.append(1) + self.assertEqual(vector, new_vec) + + def test_vec_extend(self): + # Vector to test against + new_vec = snap.TIntV() + new_vec.Add(1) + new_vec.Add(2) + new_vec.Add(3) + + # Vector to extend by + extend_vec = snap.TIntV() + extend_vec.Add(2) + extend_vec.Add(3) + + # Extend operation + vector = snap.TIntV() + vector.Add(1) + vector.extend(extend_vec) + + self.assertEqual(vector, new_vec) + + def test_vec_clear(self): + # Vector to test against + new_vec = snap.TIntV() + + # Adding to and clearing vector + vector = snap.TIntV() + vector.Add(1) + vector.clear() + + self.assertEqual(vector, new_vec) + + def test_vec_insert(self): + # Vector to test against + new_vec = snap.TIntV() + new_vec.Add(1) + new_vec.Add(2) + new_vec.Add(3) + + # Attempting insert on self.vector + vector = snap.TIntV() + vector.Add(1) + vector.Add(3) + vector.insert(1, 2) + + self.assertEqual(vector, new_vec) + + def test_vec_remove(self): + # Vector to test against + new_vec = snap.TIntV() + new_vec.Add(1) + + # Attempting insert on vector + vector = snap.TIntV() + vector.Add(1) + vector.Add(2) + vector.remove(2) + + self.assertEqual(vector, new_vec) + + def test_vec_index(self): + vector = snap.TIntV() + vector.Add(1) + vector.Add(2) + index = vector.index(2) + + self.assertEqual(index, 1) + + def test_vec_count(self): + vector = snap.TIntV() + vector.Add(1) + vector.Add(1) + vector.Add(1) + num_ones = vector.count(1) + + self.assertEqual(num_ones, 3) + + def test_vec_pop(self): + vector = snap.TIntV() + vector.Add(1) + vector.Add(2) + popped = vector.pop(1) + + self.assertEqual(popped, 2) + + def test_vec_reverse(self): + # Vector to compare + new_vec = snap.TIntV() + new_vec.Add(2) + new_vec.Add(1) + + vector = snap.TIntV() + vector.Add(1) + vector.Add(2) + vector.reverse() + + self.assertEqual(vector, new_vec) + + def test_vec_sort(self): + # Vector to compare + new_vec = snap.TIntV() + new_vec.Add(1) + new_vec.Add(2) + new_vec.Add(3) + + vector = snap.TIntV() + vector.Add(1) + vector.Add(3) + vector.Add(2) + vector.sort(asc=True) + + self.assertEqual(vector, new_vec) + + def test_vec_copy(self): + vector = snap.TIntV() + vector.Add(1) + vector.Add(2) + new_vec = vector.copy() + + self.assertEqual(vector, new_vec) + + def test_vec_max(self): + vector = snap.TIntV() + vector.Add(1) + vector.Add(5) + vector.Add(2) + + maximum = max(vector) + + self.assertEqual(maximum, 5) + + def test_vec_min(self): + vector = snap.TIntV() + vector.Add(2) + vector.Add(1) + vector.Add(5) + + minimum = min(vector) + + self.assertEqual(minimum, 1) + + # Avery Hash Table Tests + def test_hash_clear(self): + new_ht = snap.TIntH() + + ht = snap.TIntH() + ht[1] = 2 + ht.clear() + + self.assertEqual(ht, new_ht) + + def test_hash_copy(self): + ht = snap.TIntH() + ht[1] = 2 + new_ht = ht.copy() + + self.assertEqual(ht, new_ht) + + def test_hash_get(self): + ht = snap.TIntH() + ht[1] = 2 + value = ht.get(1) + + self.assertEqual(value, 2) + + def test_hash_items(self): + ht = snap.TIntH() + ht[1] = 2 + ht[3] = 4 + items = [(1, 2), (3, 4)] + ht_items = ht.items() + + self.assertEqual(items, ht_items) + + def test_hash_keys(self): + ht = snap.TIntH() + ht[1] = 2 + ht[3] = 4 + keys = [1, 3] + ht_keys = ht.keys() + + self.assertEqual(keys, ht_keys) + + def test_hash_pop(self): + ht = snap.TIntH() + ht[1] = 2 + ht[3] = 4 + popped = 2 + ht_popped = ht.pop(1) + + self.assertEqual(popped, ht_popped) + + def test_hash_setdefault(self): + new_ht = snap.TIntH() + new_ht[1] = 2 + new_ht[3] = 4 + + ht = snap.TIntH() + ht[1] = 2 + default_val = ht.setdefault(3, 4) + + self.assertEqual(ht, new_ht) + self.assertEqual(default_val, 4) + + def test_hash_update(self): + new_ht = snap.TIntH() + new_ht[1] = 2 + new_ht[3] = 5 + + ht = snap.TIntH() + ht[3] = 4 + ht.update(new_ht) + + final_ht = snap.TIntH() + final_ht[1] = 2 + final_ht[3] = 5 + + self.assertEqual(ht, final_ht) + + def test_hash_values(self): + expected_values = [2, 4] + + ht = snap.TIntH() + ht[1] = 2 + ht[3] = 4 + values = ht.values() + + self.assertEqual(expected_values, values) + + + def test_CntInDegNodes(self): + # Directed graph + num_nodes = snap.CntInDegNodes(self.DirGraphFull, self.num_nodes-1) + self.assertEqual(self.num_nodes, num_nodes) + + # Undirected Graph + num_nodes = snap.CntInDegNodes(self.UnDirGraphFull, self.num_nodes-1) + self.assertEqual(self.num_nodes, num_nodes) + + # Network + num_nodes = snap.CntInDegNodes(self.NetFull, self.num_nodes-1) + self.assertEqual(self.num_nodes, num_nodes) + + def test_CntOutDegNodes(self): + # Directed Graph + num_nodes = snap.CntOutDegNodes(self.DirGraphFull, self.num_nodes-1) + self.assertEqual(self.num_nodes, num_nodes) + + # Undirected Graph + num_nodes = snap.CntOutDegNodes(self.UnDirGraphFull, self.num_nodes-1) + self.assertEqual(self.num_nodes, num_nodes) + + # Network + num_nodes = snap.CntOutDegNodes(self.NetFull, self.num_nodes-1) + self.assertEqual(self.num_nodes, num_nodes) + + def test_CntDegNodes(self): + # Directed Graph - it will have twice the edges as the undirected graph + num_nodes = snap.CntDegNodes(self.DirGraphFull, 2*(self.num_nodes-1)) + self.assertEqual(self.num_nodes, num_nodes) + + # Undirected Graph + num_nodes = snap.CntDegNodes(self.UnDirGraphFull, self.num_nodes-1) + self.assertEqual(self.num_nodes, num_nodes) + + # Network + num_nodes = snap.CntDegNodes(self.NetFull, 2*(self.num_nodes-1)) + self.assertEqual(self.num_nodes, num_nodes) + + def test_CntNonZNodes(self): + # Directed Graph + num_nodes = snap.CntNonZNodes(self.DirGraphFull) + self.assertEqual(self.num_nodes, num_nodes) + + # Undirected Graph + num_nodes = snap.CntNonZNodes(self.UnDirGraphFull) + self.assertEqual(self.num_nodes, num_nodes) + + # Network + num_nodes = snap.CntNonZNodes(self.NetFull) + self.assertEqual(self.num_nodes, num_nodes) + + def test_GetMxDegNId(self): + # Directed Graph + max_id = snap.GetMxDegNId(self.DirGraphStar) + self.assertEqual(0, max_id) + + # Undirected Graph + max_id = snap.GetMxDegNId(self.UnDirGraphStar) + self.assertEqual(0, max_id) + + # Network + max_id = snap.GetMxDegNId(self.NetStar) + self.assertEqual(0, max_id) + + def test_GetMxInDegNId(self): + # Directed Graph + max_id = snap.GetMxInDegNId(self.DirGraphStar) + # node with id 0 is the only node with in-degree 0 + self.assertNotEqual(0, max_id) + + # Undirected Graph + max_id = snap.GetMxInDegNId(self.UnDirGraphStar) + self.assertEqual(0, max_id) + + # Network + max_id = snap.GetMxInDegNId(self.NetStar) + # node with id 0 is the only node with in-degree 0 + self.assertNotEqual(0, max_id) + + def test_GetMxOutDegNId(self): + # Directed Graph + max_id = snap.GetMxOutDegNId(self.DirGraphStar) + self.assertEqual(0, max_id) + + # Undirected Graph + max_id = snap.GetMxOutDegNId(self.UnDirGraphStar) + self.assertEqual(0, max_id) + + # Network + max_id = snap.GetMxOutDegNId(self.NetStar) + self.assertEqual(0, max_id) + + def test_GetInDegCnt(self): + # Directed Graph + DegToCntV = snap.TIntPrV() + snap.GetInDegCnt(self.DirGraphFull, DegToCntV) + # There should be only one entry (num_nodes -1, num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + # Undirected Graph + DegToCntV = snap.TIntPrV() + snap.GetInDegCnt(self.UnDirGraphFull, DegToCntV) + # There should be only one entry (num_nodes -1, num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + # Network + DegToCntV = snap.TIntPrV() + snap.GetInDegCnt(self.NetFull, DegToCntV) + # There should be only one entry (num_nodes -1, num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + def test_GetOutDegCnt(self): + # Directed Graph + DegToCntV = snap.TIntPrV() + snap.GetOutDegCnt(self.DirGraphFull, DegToCntV) + # There should be only one entry (num_nodes -1, num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + # Undirected Graph + DegToCntV = snap.TIntPrV() + snap.GetOutDegCnt(self.UnDirGraphFull, DegToCntV) + # There should be only one entry (num_nodes -1, num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + # Network + DegToCntV = snap.TIntPrV() + snap.GetOutDegCnt(self.NetFull, DegToCntV) + # There should be only one entry (2*(num_nodes-1), num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + def test_GetDegCnt(self): + # Directed Graph + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(self.DirGraphFull, DegToCntV) + # There should be only one entry (2*(num_nodes-1), num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(2*(self.num_nodes-1), item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + # Undirected Graph + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(self.UnDirGraphFull, DegToCntV) + # There should be only one entry (num_nodes-1, num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal1()) + self.assertEqual(self.num_nodes, item.GetVal2()) + + # Network + DegToCntV = snap.TIntPrV() + snap.GetDegCnt(self.NetFull, DegToCntV) + # There should be only one entry (2*(num_nodes-1), num_nodes) in DegToCntV + for item in DegToCntV: + self.assertEqual(self.num_nodes, item.GetVal2()) + + def test_GetNodeInDegV(self): + # Directed Graph + DegToCntV = snap.TIntPrV() + snap.GetNodeInDegV(self.DirGraphFull, DegToCntV) + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal2()) + + # Undirected Graph + DegToCntV = snap.TIntPrV() + snap.GetNodeInDegV(self.UnDirGraphFull, DegToCntV) + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal2()) + + # Network + DegToCntV = snap.TIntPrV() + snap.GetNodeInDegV(self.NetFull, DegToCntV) + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal2()) + + def test_GetNodeOutDegV(self): + # Directed Graph + DegToCntV = snap.TIntPrV() + snap.GetNodeOutDegV(self.DirGraphFull, DegToCntV) + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal2()) + + # Undirected Graph + DegToCntV = snap.TIntPrV() + snap.GetNodeOutDegV(self.UnDirGraphFull, DegToCntV) + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal2()) + + # Network + DegToCntV = snap.TIntPrV() + snap.GetNodeOutDegV(self.NetFull, DegToCntV) + for item in DegToCntV: + self.assertEqual(self.num_nodes-1, item.GetVal2()) + + def test_CntUniqUndirEdges(self): + # Directed Graph + num_edges = snap.CntUniqUndirEdges(self.DirGraphFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1)/2, num_edges) + + # Unidrected Graph + num_edges = snap.CntUniqUndirEdges(self.UnDirGraphFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1)/2, num_edges) + + # Network + num_edges = snap.CntUniqUndirEdges(self.NetFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1)/2, num_edges) + + def test_CntUniqDirEdges(self): + # Directed Graph + num_edges = snap.CntUniqDirEdges(self.DirGraphFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1), num_edges) + + # Unidrected Graph + num_edges = snap.CntUniqDirEdges(self.UnDirGraphFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1), num_edges) + + # Network + num_edges = snap.CntUniqDirEdges(self.NetFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1), num_edges) + + def test_CntUniqBiDirEdges(self): + # Directed Graph + num_edges = snap.CntUniqBiDirEdges(self.DirGraphFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1)/2, num_edges) + + # Unidrected Graph + num_edges = snap.CntUniqBiDirEdges(self.UnDirGraphFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1)/2, num_edges) + + # Network + num_edges = snap.CntUniqBiDirEdges(self.NetFull) + self.assertEqual(self.num_nodes * (self.num_nodes - 1)/2, num_edges) + + def test_CntSelfEdges(self): + # Directed Graph + num_edges = snap.CntSelfEdges(self.DirGraphFull) + self.assertEqual(0, num_edges) + + # Undirected Graph + num_edges = snap.CntSelfEdges(self.UnDirGraphFull) + self.assertEqual(0, num_edges) + + # Network + num_edges = snap.CntSelfEdges(self.NetFull) + self.assertEqual(0, num_edges) + + def test_GetUnDir(self): + # Directed Graph + New_Graph = snap.GetUnDir(self.DirGraphStar) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(New_Graph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(New_Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(New_Graph.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + + # Undirected Graph + New_Graph = snap.GetUnDir(self.UnDirGraphStar) + for node in self.UnDirGraphStar.Nodes(): + self.assertTrue(New_Graph.IsNode(node.GetId())) + for edge in self.UnDirGraphStar.Edges(): + self.assertTrue(New_Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(New_Graph.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + + # Network + New_Graph = snap.GetUnDir(self.NetStar) + for node in self.NetStar.Nodes(): + self.assertTrue(New_Graph.IsNode(node.GetId())) + for edge in self.NetStar.Edges(): + self.assertTrue(New_Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(New_Graph.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + + def test_MakeUnDir(self): + # Directed Graph + New_Graph = self.DirGraphStar + snap.MakeUnDir(New_Graph) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(New_Graph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(New_Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(New_Graph.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + + # Undirected Graph + New_Graph = self.UnDirGraphStar + snap.MakeUnDir(New_Graph) + for node in self.UnDirGraphStar.Nodes(): + self.assertTrue(New_Graph.IsNode(node.GetId())) + for edge in self.UnDirGraphStar.Edges(): + self.assertTrue(New_Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(New_Graph.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + + # Network + New_Graph = self.NetStar + snap.MakeUnDir(New_Graph) + for node in self.NetStar.Nodes(): + self.assertTrue(New_Graph.IsNode(node.GetId())) + for edge in self.NetStar.Edges(): + self.assertTrue(New_Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(New_Graph.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + + def test_AddSelfEdges(self): + # Directed Graph + Graph_Copy = self.DirGraphFull + snap.AddSelfEdges(Graph_Copy) + for node in Graph_Copy.Nodes(): + self.assertTrue(Graph_Copy.IsEdge(node.GetId(), node.GetId())) + + # Undirected Graph + Graph_Copy = self.UnDirGraphFull + snap.AddSelfEdges(Graph_Copy) + for node in Graph_Copy.Nodes(): + self.assertTrue(Graph_Copy.IsEdge(node.GetId(), node.GetId())) + + # Network + Graph_Copy = self.NetFull + snap.AddSelfEdges(Graph_Copy) + for node in Graph_Copy.Nodes(): + self.assertTrue(Graph_Copy.IsEdge(node.GetId(), node.GetId())) + + def test_DelSelfEdges(self): + # Directed Graph + Graph_Copy = self.DirGraphSelfEdge + snap.DelSelfEdges(Graph_Copy) + for node in Graph_Copy.Nodes(): + self.assertFalse(Graph_Copy.IsEdge(node.GetId(), node.GetId())) + + # Undirected Graph + Graph_Copy = self.UnDirGraphSelfEdge + snap.DelSelfEdges(Graph_Copy) + for node in Graph_Copy.Nodes(): + self.assertFalse(Graph_Copy.IsEdge(node.GetId(), node.GetId())) + + # Network + Graph_Copy = self.NetSelfEdge + snap.DelSelfEdges(Graph_Copy) + for node in Graph_Copy.Nodes(): + self.assertFalse(Graph_Copy.IsEdge(node.GetId(), node.GetId())) + + def test_DelNodes(self): + # Directed Graph + Graph_Copy = self.DirGraphFull + DelNodes = snap.TIntV() + DelNodes.Add(0) + snap.DelNodes(Graph_Copy, DelNodes) + for node in DelNodes: + self.assertFalse(Graph_Copy.IsNode(node)) + + # Undirected Graph + Graph_Copy = self.UnDirGraphFull + DelNodes = snap.TIntV() + DelNodes.Add(0) + snap.DelNodes(Graph_Copy, DelNodes) + for node in DelNodes: + self.assertFalse(Graph_Copy.IsNode(node)) + + # Network + Graph_Copy = self.NetFull + DelNodes = snap.TIntV() + DelNodes.Add(0) + snap.DelNodes(Graph_Copy, DelNodes) + for node in DelNodes: + self.assertFalse(Graph_Copy.IsNode(node)) + + def test_DelZeroDegNodes(self): + # Directed Graph + snap.DelZeroDegNodes(self.DirGraphZeroDegree) + for NI in self.DirGraphZeroDegree.Nodes(): + self.assertNotEqual(0, NI.GetOutDeg() + NI.GetInDeg()) + + # Undirected Graph + snap.DelZeroDegNodes(self.UnDirGraphZeroDegree) + for NI in self.UnDirGraphZeroDegree.Nodes(): + self.assertNotEqual(0, NI.GetOutDeg() + NI.GetInDeg()) + + # Network + snap.DelZeroDegNodes(self.NetZeroDegree) + for NI in self.NetZeroDegree.Nodes(): + self.assertNotEqual(0, NI.GetOutDeg() + NI.GetInDeg()) + + def test_DelDegKNodes(self): + # Directed Graph + snap.DelDegKNodes(self.DirGraphZeroDegree, 0, 0) + for NI in self.DirGraphZeroDegree.Nodes(): + self.assertNotEqual(0, NI.GetOutDeg() + NI.GetInDeg()) + + # Undirected Graph + snap.DelDegKNodes(self.UnDirGraphZeroDegree, 0, 0) + for NI in self.UnDirGraphZeroDegree.Nodes(): + self.assertNotEqual(0, NI.GetOutDeg() + NI.GetInDeg()) + + # Network + snap.DelDegKNodes(self.NetZeroDegree, 0, 0) + for NI in self.NetZeroDegree.Nodes(): + self.assertNotEqual(0, NI.GetOutDeg() + NI.GetInDeg()) + + def test_IsTree(self): + # Directed Graph + expected_results = [True, 0] + results = snap.IsTree(self.DirTree) + self.assertEqual(expected_results, results) + + # Network + expected_results = [True, 0] + results = snap.IsTree(self.NetTree) + self.assertEqual(expected_results, results) + + def test_GetTreeRootNId(self): + # Directed Graph + root_id = snap.GetTreeRootNId(self.DirTree) + self.assertEqual(0, root_id) + + # Network + root_id = snap.GetTreeRootNId(self.NetTree) + self.assertEqual(0, root_id) + + def test_GetBfsTree(self): + start_node = 0 + follow_out = True + follow_in = False + + # Directed Graph + BfsTree = snap.GetBfsTree(self.DirGraphFull, start_node, follow_out, follow_in) + self.assertEqual(self.num_nodes - 1, BfsTree.GetEdges()) + for end_node in range(1, self.num_nodes-1): + self.assertTrue(BfsTree.IsEdge(start_node, end_node)) + + # Undirected Graph + BfsTree = snap.GetBfsTree(self.UnDirGraphFull, start_node, follow_out, follow_in) + self.assertEqual(self.num_nodes - 1, BfsTree.GetEdges()) + for end_node in range(1, self.num_nodes-1): + self.assertTrue(BfsTree.IsEdge(start_node, end_node)) + + # Network + BfsTree = snap.GetBfsTree(self.NetFull, start_node, follow_out, follow_in) + self.assertEqual(self.num_nodes - 1, BfsTree.GetEdges()) + for end_node in range(1, self.num_nodes-1): + self.assertTrue(BfsTree.IsEdge(start_node, end_node)) + + def test_GetSubTreeSz(self): + # Directed Graph + results = snap.GetSubTreeSz(self.DirTree, 0, True, True) + exp_results = [40, 40, 3] + self.assertEqual(exp_results, results) + + # Undirected Graph + results = snap.GetSubTreeSz(self.UnDirTree, 0, True, True) + exp_results = [40, 40, 3] + self.assertEqual(exp_results, results) + + # Network + results = snap.GetSubTreeSz(self.NetTree, 0, True, True) + exp_results = [40, 40, 3] + self.assertEqual(exp_results, results) + + def test_GetNodesAtHop(self): + # Directed Graph + NodeVec = snap.TIntV() + num_nodes = snap.GetNodesAtHop(self.DirGraphStar, 0, 1, NodeVec, True) + self.assertEqual(self.num_nodes-1, num_nodes) + + # Undirected Graph + NodeVec = snap.TIntV() + num_nodes = snap.GetNodesAtHop(self.UnDirGraphStar, 0, 1, NodeVec, False) + self.assertEqual(self.num_nodes-1, num_nodes) + + # Network + NodeVec = snap.TIntV() + num_nodes = snap.GetNodesAtHop(self.NetStar, 0, 1, NodeVec, True) + self.assertEqual(self.num_nodes-1, num_nodes) + + def test_GetNodesAtHops(self): + # Directed Graph + HopVec = snap.TIntPrV() + num_hops = snap.GetNodesAtHops(self.DirGraphStar, 0, HopVec, True) + self.assertEqual(2, num_hops) + for pair in HopVec: + if pair.Val1() == 0: + self.assertEqual(1, pair.Val2()) + else: + self.assertEqual(1, pair.Val1()) + self.assertEqual(self.num_nodes-1, pair.Val2()) + + # Undirected Graph + HopVec = snap.TIntPrV() + num_hops = snap.GetNodesAtHops(self.UnDirGraphStar, 0, HopVec, False) + self.assertEqual(2, num_hops) + for pair in HopVec: + if pair.Val1() == 0: + self.assertEqual(1, pair.Val2()) + else: + self.assertEqual(1, pair.Val1()) + self.assertEqual(self.num_nodes-1, pair.Val2()) + + # Network + HopVec = snap.TIntPrV() + num_hops = snap.GetNodesAtHops(self.NetStar, 0, HopVec, True) + self.assertEqual(2, num_hops) + for pair in HopVec: + if pair.Val1() == 0: + self.assertEqual(1, pair.Val2()) + else: + self.assertEqual(1, pair.Val1()) + self.assertEqual(self.num_nodes-1, pair.Val2()) + + def test_GetDegreeCentr(self): + # Undirected Graph + degree_center = snap.GetDegreeCentr(self.UnDirGraphStar, 0) + self.assertEqual(1, degree_center) + + def test_GetFarnessCentr(self): + # Undirected Graph + farness_center = snap.GetFarnessCentr(self.UnDirGraphStar, 0) + self.assertEqual(1, farness_center) + + # Directed Graph + farness_center = snap.GetFarnessCentr(self.DirGraphStar, 0) + self.assertEqual(1, farness_center) + + # Network + farness_center = snap.GetFarnessCentr(self.NetStar, 0) + self.assertEqual(1, farness_center) + + def test_GetClosenessCentr(self): + # Undirected Graph + closeness_center = snap.GetClosenessCentr(self.UnDirGraphStar, 0) + self.assertEqual(1, closeness_center) + + # Directed Graph + closeness_center = snap.GetClosenessCentr(self.DirGraphStar, 0) + self.assertEqual(1, closeness_center) + + # Network + closeness_center = snap.GetClosenessCentr(self.NetStar, 0) + self.assertEqual(1, closeness_center) + + def test_GetEigenVectorCentr(self): + # Undirected Graph + EigenVec = snap.TIntFltH() + snap.GetEigenVectorCentr(self.UnDirGraphStar, EigenVec) + for item in EigenVec: + self.assertTrue(0 < EigenVec[item]) + + def test_GetNodeEcc(self): + # Directed Graph + node_ecc = snap.GetNodeEcc(self.DirGraphStar, 0, True) + self.assertEqual(1, node_ecc) + + # Undirected Graph + node_ecc = snap.GetNodeEcc(self.UnDirGraphStar, 0, False) + self.assertEqual(1, node_ecc) + + # Network + node_ecc = snap.GetNodeEcc(self.NetStar, 0, True) + self.assertEqual(1, node_ecc) + + def test_GetPageRank(self): + DirRank = { + 0 : 0.0260929959985197, + 1 : 0.0260929959985197, + 2 : 0.0260929959985197, + 3 : 0.0260929959985197, + 4 : 0.0260929959985197, + 5 : 0.17390700400148032, + 6 : 0.17390700400148032, + 7 : 0.17390700400148032, + 8 : 0.17390700400148032, + 9 : 0.17390700400148032, + } + UnDirRank = { + 0 : 0.10000000000000002, + 1 : 0.10000000000000002, + 2 : 0.10000000000000002, + 3 : 0.10000000000000002, + 4 : 0.10000000000000002, + 5 : 0.10000000000000002, + 6 : 0.10000000000000002, + 7 : 0.10000000000000002, + 8 : 0.10000000000000002, + 9 : 0.10000000000000002, + } + + # Directed Graph + PRankH = snap.TIntFltH() + snap.GetPageRank(self.DPetersen, PRankH) + self.assertEqual(len(PRankH), len(DirRank)) + for item in DirRank: + self.assertAlmostEqual(PRankH[item], DirRank[item]) + + # Undirected Graph + PRankH = snap.TIntFltH() + snap.GetPageRank(self.UPetersen, PRankH) + self.assertEqual(len(PRankH), len(UnDirRank)) + for item in UnDirRank: + self.assertAlmostEqual(PRankH[item], UnDirRank[item]) + + # Network + PRankH = snap.TIntFltH() + snap.GetPageRank(self.NPetersen, PRankH) + self.assertEqual(len(PRankH), len(DirRank)) + for item in DirRank: + self.assertAlmostEqual(PRankH[item], DirRank[item]) + + def test_GetHits(self): + # Directed Graph + NIdHubH = snap.TIntFltH() + NIdAuthH = snap.TIntFltH() + snap.GetHits(self.DirGraphFull, NIdHubH, NIdAuthH) + value = NIdHubH.GetDat(0) + for item in NIdHubH: + self.assertEqual(value, NIdHubH[item]) + value = NIdAuthH.GetDat(0) + for item in NIdAuthH: + self.assertEqual(value, NIdAuthH[item]) + + # Undirected Graph + NIdHubH = snap.TIntFltH() + NIdAuthH = snap.TIntFltH() + snap.GetHits(self.UnDirGraphFull, NIdHubH, NIdAuthH) + value = NIdHubH.GetDat(0) + for item in NIdHubH: + self.assertEqual(value, NIdHubH[item]) + value = NIdAuthH.GetDat(0) + for item in NIdAuthH: + self.assertEqual(value, NIdAuthH[item]) + + # Network + NIdHubH = snap.TIntFltH() + NIdAuthH = snap.TIntFltH() + snap.GetHits(self.NetFull, NIdHubH, NIdAuthH) + value = NIdHubH.GetDat(0) + for item in NIdHubH: + self.assertEqual(value, NIdHubH[item]) + value = NIdAuthH.GetDat(0) + for item in NIdAuthH: + self.assertEqual(value, NIdAuthH[item]) + + def test_CommunityGirvanNewman(self): + Rnd = snap.TRnd(42) + Graph = snap.GenPrefAttach(100, 10, Rnd) + exp_val = 0.00963802805072646 + Vec = snap.TCnComV() + act_val = snap.CommunityGirvanNewman(Graph, Vec) + self.assertAlmostEqual(exp_val, act_val) + + def test_CommunityCNM(self): + gnutellaUndir = snap.ConvertGraph(snap.PUNGraph, self.gnutella) + Vcc = snap.TCnComV() + modularity = snap.CommunityCNM(gnutellaUndir, Vcc) + self.assertAlmostEqual(0.4647213330572384, modularity) + + def test_GetModularity(self): + V = snap.TIntV() + for i in range(5): + V.Add(i) + + val = snap.GetModularity(self.DirGraphFull, V) + self.assertAlmostEqual(0.04861111111111111, val) + + val = snap.GetModularity(self.UnDirGraphFull, V) + self.assertAlmostEqual(-0.027777777777777776, val) + + val = snap.GetModularity(self.NetFull, V) + self.assertAlmostEqual(0.04861111111111111, val) + + def test_GetEdgesInOut(self): + V = snap.TIntV() + V.Add(0) + + # Directed Graph + result = snap.GetEdgesInOut(self.DirGraphFull, V) + exp_results = [0, 9] + self.assertEqual(exp_results, result) + + # Undirected Graph + result = snap.GetEdgesInOut(self.UnDirGraphFull, V) + exp_results = [0, 9] + self.assertEqual(exp_results, result) + + # Network + result = snap.GetEdgesInOut(self.NetFull, V) + exp_results = [0, 9] + self.assertEqual(exp_results, result) + + def test_GetBiConSzCnt(self): + # Undirected Graph + szCntV = snap.TIntPrV() + snap.GetBiConSzCnt(self.UnDirGraphFull, szCntV) + for item in szCntV: + self.assertEqual(item.GetVal1(), self.num_nodes) + self.assertEqual(item.GetVal2(), 1) + + def test_GetBiCon(self): + # Undirected Graph + CnComs = snap.TCnComV() + snap.GetBiCon(self.UnDirGraphFull, CnComs) + nodeId = 0 + for CnCom in CnComs: + for node in CnCom: + self.assertEqual(nodeId, node) + nodeId += 1 + + def test_GetEdgeBridges(self): + # Undirected Graph + edges = snap.TIntPrV() + snap.GetEdgeBridges(self.UnDirGraphStar, edges) + count = 0 + for edge in edges: + self.assertEqual(0, edge.GetVal1()) + self.assertNotEqual(0, edge.GetVal2()) + count+=1 + self.assertEqual(9, count) + + def test_Get1CnCom(self): + # Undirected Graph + components = snap.TCnComV() + snap.Get1CnCom(self.UnDirGraphStar, components) + num_comp = 0 + comp_size = 0 + for comp in components: + num_comp += 1 + for node in comp: + comp_size += 1 + self.assertEqual(1, num_comp) + self.assertEqual(self.num_nodes-1, comp_size) + + def test_GetMxBiCon(self): + # Directed Graph + Graph = snap.GetMxBiCon(self.DirGraphFull) + self.assertEqual(self.DirGraphFull.GetNodes(), Graph.GetNodes()) + self.assertEqual(self.DirGraphFull.GetEdges(), Graph.GetEdges()) + self.assertEqual(type(self.DirGraphFull), type(Graph)) + + # Undirected Graph + Graph = snap.GetMxBiCon(self.UnDirGraphFull) + self.assertEqual(self.UnDirGraphFull.GetNodes(), Graph.GetNodes()) + self.assertEqual(self.UnDirGraphFull.GetEdges(), Graph.GetEdges()) + self.assertEqual(type(self.UnDirGraphFull), type(Graph)) + + # Network + Graph = snap.GetMxBiCon(self.NetFull) + self.assertEqual(self.NetFull.GetNodes(), Graph.GetNodes()) + self.assertEqual(self.NetFull.GetEdges(), Graph.GetEdges()) + self.assertEqual(type(Graph), type(self.NetFull)) + + def test_GetNodeWcc(self): + # Directed Graph + component = snap.TIntV() + snap.GetNodeWcc(self.DirGraphStar, 1, component) + sumNodes = 0 + for node in component: + sumNodes += node + self.assertEqual((self.num_nodes - 1) * self.num_nodes / 2, sumNodes) + + # Undirected Graph + component = snap.TIntV() + snap.GetNodeWcc(self.UnDirGraphStar, 1, component) + sumNodes = 0 + for node in component: + sumNodes += node + self.assertEqual((self.num_nodes - 1) * self.num_nodes / 2, sumNodes) + + # Network + component = snap.TIntV() + snap.GetNodeWcc(self.NetStar, 1, component) + sumNodes = 0 + for node in component: + sumNodes += node + self.assertEqual((self.num_nodes - 1) * self.num_nodes / 2, sumNodes) + + def test_isConnected(self): + # Directed Graph + self.assertTrue(snap.IsConnected(self.DirGraphStar)) + + # Undirected Graph + self.assertTrue(snap.IsConnected(self.UnDirGraphStar)) + + # Network + self.assertTrue(snap.IsConnected(self.NetStar)) + + def test_isWeaklyConn(self): + # Directed Graph + self.assertTrue(snap.IsWeaklyConn(self.DirGraphStar)) + + # Undirected Graph + self.assertTrue(snap.IsWeaklyConn(self.UnDirGraphStar)) + + # Network + self.assertTrue(snap.IsWeaklyConn(self.NetStar)) + + def test_GetWccSzCnt(self): + # Directed Graph + counts = snap.TIntPrV() + snap.GetWccSzCnt(self.DirGraphStar, counts) + for pair in counts: + self.assertEqual(self.num_nodes, pair.GetVal1()) + self.assertEqual(1, pair.GetVal2()) + + # Undirected Graph + counts = snap.TIntPrV() + snap.GetWccSzCnt(self.UnDirGraphStar, counts) + for pair in counts: + self.assertEqual(self.num_nodes, pair.GetVal1()) + self.assertEqual(1, pair.GetVal2()) + + # Network + counts = snap.TIntPrV() + snap.GetWccSzCnt(self.NetStar, counts) + for pair in counts: + self.assertEqual(self.num_nodes, pair.GetVal1()) + self.assertEqual(1, pair.GetVal2()) + + def test_GetWccs(self): + # Directed Graph + components = snap.TCnComV() + snap.GetWccs(self.DirGraphStar, components) + num_comp = 0 + comp_size = 0 + for comp in components: + num_comp += 1 + for node in comp: + comp_size += 1 + self.assertEqual(1, num_comp) + self.assertEqual(self.num_nodes, comp_size) + + # Undirected Graph + components = snap.TCnComV() + snap.GetWccs(self.UnDirGraphStar, components) + num_comp = 0 + comp_size = 0 + for comp in components: + num_comp += 1 + for node in comp: + comp_size += 1 + self.assertEqual(1, num_comp) + self.assertEqual(self.num_nodes, comp_size) + + # Network + components = snap.TCnComV() + snap.GetWccs(self.NetStar, components) + num_comp = 0 + comp_size = 0 + for comp in components: + num_comp += 1 + for node in comp: + comp_size += 1 + self.assertEqual(1, num_comp) + self.assertEqual(self.num_nodes, comp_size) + + def test_GetSccSzCnt(self): + # Directed Graph + counts = snap.TIntPrV() + snap.GetSccSzCnt(self.DirGraphFull, counts) + for pair in counts: + self.assertEqual(self.num_nodes, pair.GetVal1()) + self.assertEqual(1, pair.GetVal2()) + + # Undirected Graph + counts = snap.TIntPrV() + snap.GetSccSzCnt(self.UnDirGraphFull, counts) + for pair in counts: + self.assertEqual(self.num_nodes, pair.GetVal1()) + self.assertEqual(1, pair.GetVal2()) + + # Network + counts = snap.TIntPrV() + snap.GetSccSzCnt(self.NetFull, counts) + for pair in counts: + self.assertEqual(self.num_nodes, pair.GetVal1()) + self.assertEqual(1, pair.GetVal2()) + + def test_GetSccs(self): + # Directed Graph + components = snap.TCnComV() + snap.GetSccs(self.DirGraphFull, components) + num_comp = 0 + comp_size = 0 + for comp in components: + num_comp += 1 + for node in comp: + comp_size += 1 + self.assertEqual(1, num_comp) + self.assertEqual(self.num_nodes, comp_size) + + # Undirected Graph + components = snap.TCnComV() + snap.GetSccs(self.UnDirGraphFull, components) + num_comp = 0 + comp_size = 0 + for comp in components: + num_comp += 1 + for node in comp: + comp_size += 1 + self.assertEqual(1, num_comp) + self.assertEqual(self.num_nodes, comp_size) + + # Network + components = snap.TCnComV() + snap.GetSccs(self.NetFull, components) + num_comp = 0 + comp_size = 0 + for comp in components: + num_comp += 1 + for node in comp: + comp_size += 1 + self.assertEqual(1, num_comp) + self.assertEqual(self.num_nodes, comp_size) + + def test_GetMxWccSz(self): + # Directed Graph + sz = snap.GetMxWccSz(self.DirGraphStar) + self.assertEqual(1, sz) + + # Undirected Graph + sz = snap.GetMxWccSz(self.UnDirGraphStar) + self.assertEqual(1, sz) + + # Network + sz = snap.GetMxWccSz(self.NetStar) + self.assertEqual(1, sz) + + def test_GetMxSccSz(self): + # Directed Graph + sz = snap.GetMxSccSz(self.DirGraphStar) + self.assertEqual(1.0/self.num_nodes, sz) + + # Undirected Graph + sz = snap.GetMxSccSz(self.UnDirGraphStar) + self.assertEqual(1, sz) + + # Network + sz = snap.GetMxSccSz(self.NetStar) + self.assertEqual(1.0/self.num_nodes, sz) + + def test_GetMxWcc(self): + # Directed Graph + subgraph = snap.GetMxWcc(self.DirGraphStar) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Undirected Graph + subgraph = snap.GetMxWcc(self.UnDirGraphStar) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Network + subgraph = snap.GetMxWcc(self.NetStar) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + def test_GetMxScc(self): + # Directed Graph + subgraph = snap.GetMxScc(self.DirGraphFull) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Undirected Graph + subgraph = snap.GetMxScc(self.UnDirGraphFull) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Network + subgraph = snap.GetMxScc(self.NetFull) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + def test_GetMxBiCon(self): + # Directed Graph + subgraph = snap.GetMxBiCon(self.DirGraphFull) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Undirected Graph + subgraph = snap.GetMxBiCon(self.UnDirGraphFull) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Network + subgraph = snap.GetMxBiCon(self.NetFull) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(subgraph.IsNode(node.GetId())) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(subgraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + def test_PrintInfo(self): + snap.PrintInfo(self.DirGraphFull, "description", "test.txt") + self.checkPrintInfoOutput("test.txt", ["description", '10', '90', '0', '0', '0', '10']) + os.remove('test.txt') + + snap.PrintInfo(self.UnDirGraphFull, "description", "test.txt") + self.checkPrintInfoOutput("test.txt", ["description", '10', '45', '0', '0', '0', '10']) + os.remove('test.txt') + + snap.PrintInfo(self.NetFull, "description", "test.txt") + self.checkPrintInfoOutput("test.txt", ["description", '10', '90', '0', '0', '0', '10']) + os.remove('test.txt') + + def test_GetKCoreNodes(self): + # Directed Graph + CoreN = snap.TIntPrV() + result = snap.GetKCoreNodes(self.DirGraphStar, CoreN) + self.assertEqual(2, result) + + # Undirected Graph + CoreN = snap.TIntPrV() + result = snap.GetKCoreNodes(self.UnDirGraphStar, CoreN) + self.assertEqual(2, result) + + # Network + CoreN = snap.TIntPrV() + result = snap.GetKCoreNodes(self.NetStar, CoreN) + self.assertEqual(2, result) + + def test_GetKCoreEdges(self): + # Directed Graph + CoreN = snap.TIntPrV() + result = snap.GetKCoreEdges(self.DirGraphStar, CoreN) + self.assertEqual(2, result) + + # Undirected Graph + CoreN = snap.TIntPrV() + result = snap.GetKCoreEdges(self.UnDirGraphStar, CoreN) + self.assertEqual(2, result) + + # Network + CoreN = snap.TIntPrV() + result = snap.GetKCoreEdges(self.NetStar, CoreN) + self.assertEqual(2, result) + + def test_GenDegSeq(self): + DegSeqV = snap.TIntV() + DegSeqV.Add(3) + DegSeqV.Add(2) + DegSeqV.Add(1) + DegSeqV.Add(1) + DegSeqV.Add(1) + Graph = snap.GenDegSeq(DegSeqV) + count = 0 + for n in Graph.Nodes(): + count += 1 + self.assertEqual(5, count) + count = [0, 0, 0, 0, 0] + for node in Graph.Nodes(): + count[node.GetId()] = node.GetInDeg() + self.assertEqual(3, count[0]) + self.assertEqual(2, count[1]) + self.assertEqual(1, count[2]) + self.assertEqual(1, count[3]) + self.assertEqual(1, count[4]) + + def test_GenRewire(self): + Rewired = snap.GenRewire(self.UnDirRand) + for node in self.UnDirRand.Nodes(): + for nodeR in Rewired.Nodes(): + if node.GetId() == nodeR.GetId(): + self.assertEqual(node.GetOutDeg()+node.GetInDeg(), nodeR.GetOutDeg()+nodeR.GetInDeg()) + + def test_GenPrefAttach(self): + Graph = snap.GenPrefAttach(100, 10) + for node in Graph.Nodes(): + self.assertTrue(node.GetOutDeg() >= 10) + self.assertEqual(100, Graph.GetNodes()) + + def test_GenGeoPrefAttach(self): + Graph = snap.GenGeoPrefAttach(100, 10, 0.25) + for node in Graph.Nodes(): + self.assertTrue(node.GetOutDeg() + node.GetInDeg() >= 10) + self.assertEqual(100, Graph.GetNodes()) + + def test_GenForestFire(self): + Graph = snap.GenForestFire(100, 0.5, 0.5) + self.assertEqual(100, Graph.GetNodes()) + + def test_GenRMat(self): + Graph = snap.GenRMat(10, 20, 0.25, 0.25, 0.25) + self.assertEqual(10, Graph.GetNodes()) + self.assertEqual(20, Graph.GetEdges()) + + def test_GenRMatEpinions(self): + Graph = snap.GenRMatEpinions() + expected_nodes = 75888 + expected_edges = 508837 + self.assertEqual(expected_nodes, Graph.GetNodes()) + self.assertEqual(expected_edges, Graph.GetEdges()) + + def test_GenStar(self): + # Directed Graph + Graph = self.DirGraphStar + for node in Graph.Nodes(): + if node.GetId() == 0: + self.assertEqual(self.num_nodes-1, node.GetOutDeg()) + self.assertEqual(0, node.GetInDeg()) + else: + self.assertEqual(0, node.GetOutDeg()) + self.assertEqual(1, node.GetInDeg()) + + # Undirected Graph + Graph = self.UnDirGraphStar + for node in Graph.Nodes(): + if node.GetId() == 0: + self.assertEqual(self.num_nodes-1, node.GetOutDeg()) + self.assertEqual(self.num_nodes-1, node.GetInDeg()) + else: + self.assertEqual(1, node.GetOutDeg()) + self.assertEqual(1, node.GetInDeg()) + + # Network + Graph = self.NetStar + for node in Graph.Nodes(): + if node.GetId() == 0: + self.assertEqual(self.num_nodes-1, node.GetOutDeg()) + self.assertEqual(0, node.GetInDeg()) + else: + self.assertEqual(0, node.GetOutDeg()) + self.assertEqual(1, node.GetInDeg()) + + def test_GenTree(self): + # Directed Graph + Graph = snap.GenTree(snap.PNGraph, 3, 3, True, False) + for node in Graph.Nodes(): + self.assertTrue(node.GetDeg() == 4 or (node.GetDeg() == 3 and node.GetId() == 0) or node.GetDeg() == 1) + + # Undirected Graph + Graph = snap.GenTree(snap.PUNGraph, 3, 3, False, False) + for node in Graph.Nodes(): + self.assertTrue(node.GetDeg() == 4 or (node.GetDeg() == 3 and node.GetId() == 0) or node.GetDeg() == 1) + + # Network + Graph = snap.GenTree(snap.PNEANet, 3, 3, True, False) + for node in Graph.Nodes(): + self.assertTrue(node.GetDeg() == 4 or (node.GetDeg() == 3 and node.GetId() == 0) or node.GetDeg() == 1) + + def test_GenBaraHierar(self): + expected_nodes = 625 + expected_edges = 1976 + + # Directed Graph + Graph = snap.GenBaraHierar(snap.PNGraph, 3, True) + self.assertEqual(expected_nodes, Graph.GetNodes()) + self.assertEqual(expected_edges, Graph.GetEdges()) + + # Directed Graph + Graph = snap.GenBaraHierar(snap.PUNGraph, 3, True) + self.assertEqual(expected_nodes, Graph.GetNodes()) + self.assertEqual(expected_edges, Graph.GetEdges()) + + # Directed Graph + Graph = snap.GenBaraHierar(snap.PNEANet, 3, True) + self.assertEqual(expected_nodes, Graph.GetNodes()) + self.assertEqual(expected_edges, Graph.GetEdges()) + + def test_LoadDyNet(self): + Gout = snap.GenRndGnm(snap.PNGraph, 100, 1000) + fname = "test.xml" + with open(fname, "w") as f: + f.write("\n") + + for EI in Gout.Edges(): + src = EI.GetSrcNId() + dst = EI.GetDstNId() + f.write("\t \n") + + f.write("\n") + + Gin = snap.LoadDyNet(fname) + + self.assertTrue(Gin.GetNodes() == Gout.GetNodes()) + self.assertTrue(Gin.GetEdges() == Gout.GetEdges()) + os.remove(fname) + + def test_LoadConnList(self): + fname = "test.txt" + with open(fname, "w") as f: + for i in range(10): + line = str(i) + for j in range(10): + if j != i: + line += " " + str(j) + f.write(line + "\n") + + # Directed Graph + Graph = snap.LoadConnList(snap.PNGraph, fname) + for i in range(10): + for j in range(10): + if i != j: + self.assertTrue(Graph.IsEdge(i, j)) + else: + self.assertFalse(Graph.IsEdge(i, j)) + + # Undirected Graph + Graph = snap.LoadConnList(snap.PUNGraph, fname) + for i in range(10): + for j in range(10): + if i != j: + self.assertTrue(Graph.IsEdge(i, j)) + else: + self.assertFalse(Graph.IsEdge(i, j)) + + # Network + Graph = snap.LoadConnList(snap.PNEANet, fname) + for i in range(10): + for j in range(10): + if i != j: + self.assertTrue(Graph.IsEdge(i, j)) + else: + self.assertFalse(Graph.IsEdge(i, j)) + + os.remove(fname) + + def test_LoadPajek(self): + fname = "example.paj" + output = open(fname, "w") + output.write('*Vertices 9\n') + output.write('1 "1" 0.3034 0.7561\n') + output.write('2 "2" 0.4565 0.6039\n') + output.write('3 "3" 0.4887 0.8188\n') + output.write('*Arcs\n') + output.write('*Edges\n') + output.write(' 1 2 1\n') + output.write(' 1 3 1\n') + output.write(' 2 3 1\n') + output.close() + + # Directed Graph + Graph = snap.LoadPajek(snap.PNGraph, fname) + count = 1 + for node in Graph.Nodes(): + self.assertEqual(count, node.GetId()) + count += 1 + + # Undirected Graph + Graph = snap.LoadPajek(snap.PUNGraph, fname) + count = 1 + for node in Graph.Nodes(): + self.assertEqual(count, node.GetId()) + count += 1 + + # Network + Graph = snap.LoadPajek(snap.PNGraph, fname) + count = 1 + for node in Graph.Nodes(): + self.assertEqual(count, node.GetId()) + count += 1 + + os.remove(fname) + + def test_SaveEdgeList(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveEdgeList(self.DirGraphFull, fname) + exp_hash = 'd26278f1b4d13aac3c22763f937a30d3' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + snap.SaveEdgeList(self.UnDirGraphFull, fname) + exp_hash = 'c767b54d9d1c607c791d895817b9b758' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + snap.SaveEdgeList(self.NetFull, fname) + exp_hash = 'd26278f1b4d13aac3c22763f937a30d3' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_SaveMatlabSparseMtx(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveMatlabSparseMtx(self.DirGraphFull, fname) + exp_hash = 'a0e90dc5e7e3d9383a4af049d4dafee2' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + snap.SaveMatlabSparseMtx(self.UnDirGraphFull, fname) + test_hash = self.getFileHash(fname) + exp_hash = '28a9ccb0bf7c71de564fac9d071fb704' + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + snap.SaveMatlabSparseMtx(self.NetFull, fname) + exp_hash = 'a0e90dc5e7e3d9383a4af049d4dafee2' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_GetSngVals(self): + SngVals = 4 + SngValV = snap.TFltV() + snap.GetSngVals(self.DirGraphFull, SngVals, SngValV) + count = 0 + for item in SngValV: + if count == 0: + self.assertAlmostEqual(self.num_nodes-1, item) + else: + self.assertAlmostEqual(1, item) + count += 1 + + def test_GetEigVals(self): + Graph = snap.GenStar(snap.PUNGraph, 50) + NumEigVals = 2 + EigValV = snap.TFltV() + snap.GetEigVals(Graph, NumEigVals, EigValV) + count = 0 + for item in EigValV: + if count == 0: + self.assertAlmostEqual(7.0, item) + else: + self.assertAlmostEqual(-7.0, item) + count += 1 + self.assertEqual(2, count) + + def test_GetInvParticipRate(self): + Graph = snap.TUNGraph.New() + Graph.AddNode(1) + Graph.AddNode(2) + Graph.AddNode(3) + Graph.AddNode(4) + Graph.AddNode(5) + Graph.AddNode(6) + Graph.AddEdge(1, 2) + Graph.AddEdge(2, 3) + Graph.AddEdge(3, 5) + Graph.AddEdge(4, 6) + Graph.AddEdge(4, 1) + + expected = [[-1.246980, 0.214286],[0.445042, 0.214286],[1.801938, 0.214286]] + EigValIprV = snap.TFltPrV() + snap.GetInvParticipRat(Graph, 10, 1000, EigValIprV) + count = 0 + for x in EigValIprV: + self.assertAlmostEqual(expected[count][0], x.GetVal1(), 5) + self.assertAlmostEqual(expected[count][1], x.GetVal2(), 5) + count += 1 + + def test_GetKCore(self): + # Directed Graph + k = self.num_nodes - 1 + KCore = snap.GetKCore(self.DirGraphFull, k) + self.assertEqual(self.num_nodes, KCore.GetNodes()) + + # Undirected Graph + k = self.num_nodes - 1 + KCore = snap.GetKCore(self.UnDirGraphFull, k) + self.assertEqual(self.num_nodes, KCore.GetNodes()) + + # Network + k = self.num_nodes - 1 + KCore = snap.GetKCore(self.NetFull, k) + self.assertEqual(self.num_nodes, KCore.GetNodes()) + + def test_PlotEigValRank(self): + Graph = snap.GenStar(snap.PUNGraph, 20) + NumEigVals = 2 + fname = 'test' + desc = 'test' + plt = 'eigVal.' + fname + '.plt' + png = 'eigVal.' + fname + '.png' + tab = 'eigVal.' + fname + '.tab' + snap.PlotEigValRank(Graph, NumEigVals, fname, desc) + + self.checkPlotHash(plt, 'c6ed3d548e47a32ab81b9d93fd5210fa') + os.remove(plt) + #self.checkPlotHash(png, '88e8150cca4d8b102e69e48f4f75bbc8') + os.remove(png) + self.checkPlotHash(tab, '74c9e40a9c5254c36f3808524f42b3d8') + os.remove(tab) + + def test_PlotEigValDistr(self): + Graph = snap.GenStar(snap.PUNGraph, 20) + NumEigVals = 2 + fname = 'test' + desc = 'test' + plt = 'eigDistr.' + fname + '.plt' + png = 'eigDistr.' + fname + '.png' + tab = 'eigDistr.' + fname + '.tab' + snap.PlotEigValDistr(Graph, NumEigVals, fname, desc) + + self.checkPlotHash(plt, 'b22f6198cf212c27756b1edb4bed3508') + os.remove(plt) + #self.checkPlotHash(png, 'a620e5ca09dd447b4229850227678056') + os.remove(png) + self.checkPlotHash(tab, 'e6af369e84c82eea2fc1ae422d64f171') + os.remove(tab) + + def test_PlotInvParticipRat(self): + Graph = self.UnDirGraphStar + NumEigVals = 3 + TimeLimit = 5 + fname = 'test' + desc = 'test' + plt = 'eigIPR.' + fname + '.plt' + png = 'eigIPR.' + fname + '.png' + tab = 'eigIPR.' + fname + '.tab' + snap.PlotInvParticipRat(Graph, NumEigVals, TimeLimit, fname, desc) + + self.checkPlotHash(plt, '87de319e252341f359c6cf92aa9b7090') + os.remove(plt) + #self.checkPlotHash(png, 'b518c4e4a1b0af4de529961986198127') + os.remove(png) + self.checkPlotHash(tab, '303939e032d64c7f1e3d201a3bb3629e') + os.remove(tab) + + def test_PlotSngValRank(self): + Graph = self.DirGraphFull + SngVals = 3 + fname = 'test' + desc = 'test' + plt = 'sngVal.' + fname + '.plt' + png = 'sngVal.' + fname + '.png' + tab = 'sngVal.' + fname + '.tab' + snap.PlotSngValRank(Graph, SngVals, fname, desc) + + self.checkPlotHash(plt, '3d94b5107efd76abb478b18995447c2c') + os.remove(plt) + #self.checkPlotHash(png, 'c4d688e2e38f3a7df07067ee1c92ab64') + os.remove(png) + self.checkPlotHash(tab, 'bc0edcc3dd69677930bb37316e3bdddf') + os.remove(tab) + + def test_PlotSngValDistr(self): + Graph = self.DirGraphFull + SngVals = 3 + fname = 'test' + desc = 'test' + plt = 'sngDistr.' + fname + '.plt' + png = 'sngDistr.' + fname + '.png' + tab = 'sngDistr.' + fname + '.tab' + snap.PlotSngValDistr(Graph, SngVals, fname, desc) + + self.checkPlotHash(plt, '3c3dde0ffb43838943dcc5983baa5aa3') + os.remove(plt) + #self.checkPlotHash(png, '61a7195efc4864225c38f389e89c641e') + os.remove(png) + self.checkPlotHash(tab, '8683dabf0f9d787609dc1be1867f31a5') + os.remove(tab) + + def test_PlotInDegDistr(self): + fname = 'test' + desc = 'test' + plt = 'inDeg.' + fname + '.plt' + png = 'inDeg.' + fname + '.png' + tab = 'inDeg.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotInDegDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '7f08086973d30d356eaa2e695e1a6fff') + os.remove(plt) + #self.checkPlotHash(png, '3a7a729d393a0ba37d455c67dacd8510') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotInDegDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '9469cef95ca7701898d9da53fd83d3cf') + os.remove(plt) + #self.checkPlotHash(png, '3a7a729d393a0ba37d455c67dacd8510') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotInDegDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '7f08086973d30d356eaa2e695e1a6fff') + os.remove(plt) + #self.checkPlotHash(png, '3a7a729d393a0ba37d455c67dacd8510') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + def test_PlotOutDegDistr(self): + fname = 'test' + desc = 'test' + plt = 'outDeg.' + fname + '.plt' + png = 'outDeg.' + fname + '.png' + tab = 'outDeg.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotOutDegDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'c0e03b616e4dc61331efb11d6ed6d3f6') + os.remove(plt) + #self.checkPlotHash(png, '03a7e7d530235143bf3a0ad09df30d5d') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotOutDegDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '893e4d32769a7235bade506f4558559a') + os.remove(plt) + #self.checkPlotHash(png, '03a7e7d530235143bf3a0ad09df30d5d') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotOutDegDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'c0e03b616e4dc61331efb11d6ed6d3f6') + os.remove(plt) + #self.checkPlotHash(png, '03a7e7d530235143bf3a0ad09df30d5d') + os.remove(png) + self.checkPlotHash(tab, 'b3fd1f8e8d03274bc4c6b7d63dda8ac6') + os.remove(tab) + + def test_PlotWccDistr(self): + fname = 'test' + desc = 'test' + plt = 'wcc.' + fname + '.plt' + png = 'wcc.' + fname + '.png' + tab = 'wcc.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotWccDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '376654f801519f5a89519c020cd0cecf') + os.remove(plt) + #self.checkPlotHash(png, '3092ffd346709cbb0fb1210e39314c4c') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotWccDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '25f0e2f9efd05b483bd3498de485b525') + os.remove(plt) + #self.checkPlotHash(png, '3092ffd346709cbb0fb1210e39314c4c') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotWccDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '376654f801519f5a89519c020cd0cecf') + os.remove(plt) + #self.checkPlotHash(png, '3092ffd346709cbb0fb1210e39314c4c') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + def test_PlotSccDistr(self): + fname = 'test' + desc = 'test' + plt = 'scc.' + fname + '.plt' + png = 'scc.' + fname + '.png' + tab = 'scc.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotSccDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'f92d2c3b97156ff049ce64aaeada099c') + os.remove(plt) + #self.checkPlotHash(png, '91fb4493d7a2e9fef7fc998607a94649') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotSccDistr(Graph, fname, desc) + + self.checkPlotHash(plt, '09bc574ab814ec9bd0fc5865529f513b') + os.remove(plt) + #self.checkPlotHash(png, '91fb4493d7a2e9fef7fc998607a94649') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotSccDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'f92d2c3b97156ff049ce64aaeada099c') + os.remove(plt) + #self.checkPlotHash(png, '91fb4493d7a2e9fef7fc998607a94649') + os.remove(png) + self.checkPlotHash(tab, 'ead5104c0c23279add2652356fe836e4') + os.remove(tab) + + def test_PlotClustCf(self): + fname = 'test' + desc = 'test' + plt = 'ccf.' + fname + '.plt' + png = 'ccf.' + fname + '.png' + tab = 'ccf.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotClustCf(Graph, fname, desc) + + self.checkPlotHash(plt, 'd3e9c7ce6e1c5792a663bd0ee1abeb04') + os.remove(plt) + #self.checkPlotHash(png, '634a0518b0ee9db6c712ade205e089a2') + os.remove(png) + self.checkPlotHash(tab, '5e08cd594354ee12d733c98ffbb888c4') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotClustCf(Graph, fname, desc) + + self.checkPlotHash(plt, 'f2d1d9456515a92700e922d213a82084') + os.remove(plt) + #self.checkPlotHash(png, '634a0518b0ee9db6c712ade205e089a2') + os.remove(png) + self.checkPlotHash(tab, '0350d2154b877f0ae9415ea4d7e07f07') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotClustCf(Graph, fname, desc) + + self.checkPlotHash(plt, 'd3e9c7ce6e1c5792a663bd0ee1abeb04') + os.remove(plt) + #self.checkPlotHash(png, '634a0518b0ee9db6c712ade205e089a2') + os.remove(png) + self.checkPlotHash(tab, '5e08cd594354ee12d733c98ffbb888c4') + os.remove(tab) + + def test_PlotHops(self): + fname = 'test' + desc = 'test' + plt = 'hop.' + fname + '.plt' + png = 'hop.' + fname + '.png' + tab = 'hop.' + fname + '.tab' + NApprox = 1024 + + # Directed Graph + Graph = self.DirGraphFull + isDir = True + snap.PlotHops(Graph, fname, desc, isDir, NApprox) + + self.assertTrue(os.path.isfile(plt)) + os.remove(plt) + #self.checkPlotHash(png, '7558cfcb4b34e02fdda090fe2ebdeb03') + os.remove(png) + self.assertTrue(os.path.isfile(tab)) + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + isDir = False + snap.PlotHops(Graph, fname, desc, isDir, NApprox) + + self.assertTrue(os.path.isfile(plt)) + os.remove(plt) + #self.checkPlotHash(png, '7558cfcb4b34e02fdda090fe2ebdeb03') + os.remove(png) + self.assertTrue(os.path.isfile(tab)) + os.remove(tab) + + # Network + Graph = self.NetFull + isDir = True + snap.PlotHops(Graph, fname, desc, isDir, NApprox) + + self.assertTrue(os.path.isfile(plt)) + os.remove(plt) + #self.checkPlotHash(png, '7558cfcb4b34e02fdda090fe2ebdeb03') + os.remove(png) + self.assertTrue(os.path.isfile(tab)) + os.remove(tab) + + def test_PlotShortPathDistr(self): + fname = 'test' + desc = 'test' + plt = 'diam.' + fname + '.plt' + png = 'diam.' + fname + '.png' + tab = 'diam.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotShortPathDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'dbd3b8f4b0c82637c204173997625600') + os.remove(plt) + #self.checkPlotHash(png, 'ceaaab603196866102afa52042d33b15') + os.remove(png) + self.checkPlotHash(tab, '9b31a3d74e08ba09fb560dd2cfbf8e59') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotShortPathDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'b0e6ad4b3419c43ec4f4bac9ab9d74c7') + os.remove(plt) + #self.checkPlotHash(png, 'ceaaab603196866102afa52042d33b15') + os.remove(png) + self.checkPlotHash(tab, '9b31a3d74e08ba09fb560dd2cfbf8e59') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotShortPathDistr(Graph, fname, desc) + + self.checkPlotHash(plt, 'dbd3b8f4b0c82637c204173997625600') + os.remove(plt) + #self.checkPlotHash(png, 'ceaaab603196866102afa52042d33b15') + os.remove(png) + self.checkPlotHash(tab, '9b31a3d74e08ba09fb560dd2cfbf8e59') + os.remove(tab) + + def test_PlotKCoreNodes(self): + fname = 'test' + desc = 'test' + plt = 'coreNodes.' + fname + '.plt' + png = 'coreNodes.' + fname + '.png' + tab = 'coreNodes.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotKCoreNodes(Graph, fname, desc) + + self.checkPlotHash(plt, '8b47f5a7082e940e5b1a49f7a19bac1a') + os.remove(plt) + #self.checkPlotHash(png, 'c4ffb2358ff82930b8832cbe1d5d3ecd') + os.remove(png) + self.checkPlotHash(tab, '1b1750d5304a4f2fbb19ab8919be8e27') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotKCoreNodes(Graph, fname, desc) + + self.checkPlotHash(plt, 'fd660ab9df8f84231ca61e6ad74b5a9f') + os.remove(plt) + #self.checkPlotHash(png, 'c4ffb2358ff82930b8832cbe1d5d3ecd') + os.remove(png) + self.checkPlotHash(tab, '6a1db7740949f594b7cc3917ec65f4d9') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotKCoreNodes(Graph, fname, desc) + + self.checkPlotHash(plt, '8b47f5a7082e940e5b1a49f7a19bac1a') + os.remove(plt) + #self.checkPlotHash(png, 'c4ffb2358ff82930b8832cbe1d5d3ecd') + os.remove(png) + self.checkPlotHash(tab, '1b1750d5304a4f2fbb19ab8919be8e27') + os.remove(tab) + + def test_PlotKCoreEdges(self): + fname = 'test' + desc = 'test' + plt = 'coreEdges.' + fname + '.plt' + png = 'coreEdges.' + fname + '.png' + tab = 'coreEdges.' + fname + '.tab' + + # Directed Graph + Graph = self.DirGraphFull + snap.PlotKCoreEdges(Graph, fname, desc) + + self.checkPlotHash(plt, 'b2bcd1cbfadfa7280727163c0fc85854') + os.remove(plt) + #self.checkPlotHash(png, '6fab2c397c5b4ab0b740d4a5adf4171a') + os.remove(png) + self.checkPlotHash(tab, '7c22771f72c0bbe0c5ac5fa7c97928eb') + os.remove(tab) + + # Undirected Graph + Graph = self.UnDirGraphFull + snap.PlotKCoreEdges(Graph, fname, desc) + + self.checkPlotHash(plt, 'ce0a125f61e5e00e58c639afa434b012') + os.remove(plt) + #self.checkPlotHash(png, '6fab2c397c5b4ab0b740d4a5adf4171a') + os.remove(png) + self.checkPlotHash(tab, '13f4612f2cec666a421b39d18ae7afb6') + os.remove(tab) + + # Network + Graph = self.NetFull + snap.PlotKCoreEdges(Graph, fname, desc) + + self.checkPlotHash(plt, 'b2bcd1cbfadfa7280727163c0fc85854') + os.remove(plt) + #self.checkPlotHash(png, '6fab2c397c5b4ab0b740d4a5adf4171a') + os.remove(png) + self.checkPlotHash(tab, '7c22771f72c0bbe0c5ac5fa7c97928eb') + os.remove(tab) + + def test_GetESubGraph(self): + EIdV = snap.TIntV() + for edge in self.NetStar.Edges(): + EIdV.Add(edge.GetId()) + ESubGraph = snap.GetESubGraph(self.NetStar, EIdV) + for node in self.NetStar.Nodes(): + self.assertTrue(ESubGraph.IsNode(node.GetId())) + for edge in self.NetStar.Edges(): + self.assertTrue(ESubGraph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + def test_ConvertGraph(self): + # Directed to Undirected + UnDirStar = snap.ConvertGraph(snap.PUNGraph, self.DirGraphStar) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(UnDirStar.IsNode(node.GetId())) + self.assertEqual(UnDirStar.GetNodes(), self.DirGraphStar.GetNodes()) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(UnDirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(UnDirStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(UnDirStar.GetEdges(), self.DirGraphStar.GetEdges()) + + # Directed to Network + NetStar = snap.ConvertGraph(snap.PNEANet, self.DirGraphStar) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(NetStar.IsNode(node.GetId())) + self.assertEqual(NetStar.GetNodes(), self.DirGraphStar.GetNodes()) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(NetStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertEqual(NetStar.GetEdges(), self.DirGraphStar.GetEdges()) + + # Undirected to Directed + DirStar = snap.ConvertGraph(snap.PNGraph, self.UnDirGraphStar) + for node in self.UnDirGraphStar.Nodes(): + self.assertTrue(DirStar.IsNode(node.GetId())) + self.assertEqual(DirStar.GetNodes(), self.UnDirGraphStar.GetNodes()) + for edge in self.UnDirGraphStar.Edges(): + self.assertTrue(DirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(DirStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(DirStar.GetEdges(), self.UnDirGraphStar.GetEdges()*2) + + # Undirected to Network + NetStar = snap.ConvertGraph(snap.PNEANet, self.UnDirGraphStar) + for node in self.UnDirGraphStar.Nodes(): + self.assertTrue(NetStar.IsNode(node.GetId())) + self.assertEqual(NetStar.GetNodes(), self.UnDirGraphStar.GetNodes()) + for edge in self.UnDirGraphStar.Edges(): + self.assertTrue(NetStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(NetStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(NetStar.GetEdges(), self.UnDirGraphStar.GetEdges()*2) + + # Network to Undirected + UnDirStar = snap.ConvertGraph(snap.PUNGraph, self.NetStar) + for node in self.NetStar.Nodes(): + self.assertTrue(UnDirStar.IsNode(node.GetId())) + self.assertEqual(UnDirStar.GetNodes(), self.NetStar.GetNodes()) + for edge in self.NetStar.Edges(): + self.assertTrue(UnDirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(UnDirStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(UnDirStar.GetEdges(), self.NetStar.GetEdges()) + + # Network to Directed + DirStar = snap.ConvertGraph(snap.PNGraph, self.NetStar) + for node in self.NetStar.Nodes(): + self.assertTrue(DirStar.IsNode(node.GetId())) + self.assertEqual(DirStar.GetNodes(), self.NetStar.GetNodes()) + for edge in self.NetStar.Edges(): + self.assertTrue(DirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertEqual(DirStar.GetEdges(), self.NetStar.GetEdges()) + + def test_ConvertSubGraph(self): + ListNodes = snap.TIntV() + for x in range(self.num_nodes): + ListNodes.Add(x) + + # Directed to Undirected + UnDirStar = snap.ConvertSubGraph(snap.PUNGraph, self.DirGraphStar, ListNodes) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(UnDirStar.IsNode(node.GetId())) + self.assertEqual(UnDirStar.GetNodes(), self.DirGraphStar.GetNodes()) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(UnDirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(UnDirStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(UnDirStar.GetEdges(), self.DirGraphStar.GetEdges()) + + # Directed to Network + NetStar = snap.ConvertSubGraph(snap.PNEANet, self.DirGraphStar, ListNodes) + for node in self.DirGraphStar.Nodes(): + self.assertTrue(NetStar.IsNode(node.GetId())) + self.assertEqual(NetStar.GetNodes(), self.DirGraphStar.GetNodes()) + for edge in self.DirGraphStar.Edges(): + self.assertTrue(NetStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertEqual(NetStar.GetEdges(), self.DirGraphStar.GetEdges()) + + # Undirected to Directed + DirStar = snap.ConvertSubGraph(snap.PNGraph, self.UnDirGraphStar, ListNodes) + for node in self.UnDirGraphStar.Nodes(): + self.assertTrue(DirStar.IsNode(node.GetId())) + self.assertEqual(DirStar.GetNodes(), self.UnDirGraphStar.GetNodes()) + for edge in self.UnDirGraphStar.Edges(): + self.assertTrue(DirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(DirStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(DirStar.GetEdges(), self.UnDirGraphStar.GetEdges()*2) + + # Undirected to Network + NetStar = snap.ConvertSubGraph(snap.PNEANet, self.UnDirGraphStar, ListNodes) + for node in self.UnDirGraphStar.Nodes(): + self.assertTrue(NetStar.IsNode(node.GetId())) + self.assertEqual(NetStar.GetNodes(), self.UnDirGraphStar.GetNodes()) + for edge in self.UnDirGraphStar.Edges(): + self.assertTrue(NetStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(NetStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(NetStar.GetEdges(), self.UnDirGraphStar.GetEdges()*2) + + # Network to Undirected + UnDirStar = snap.ConvertSubGraph(snap.PUNGraph, self.NetStar, ListNodes) + for node in self.NetStar.Nodes(): + self.assertTrue(UnDirStar.IsNode(node.GetId())) + self.assertEqual(UnDirStar.GetNodes(), self.NetStar.GetNodes()) + for edge in self.NetStar.Edges(): + self.assertTrue(UnDirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(UnDirStar.IsEdge(edge.GetDstNId(), edge.GetSrcNId())) + self.assertEqual(UnDirStar.GetEdges(), self.NetStar.GetEdges()) + + # Network to Directed + DirStar = snap.ConvertSubGraph(snap.PNGraph, self.NetStar, ListNodes) + for node in self.NetStar.Nodes(): + self.assertTrue(DirStar.IsNode(node.GetId())) + self.assertEqual(DirStar.GetNodes(), self.NetStar.GetNodes()) + for edge in self.NetStar.Edges(): + self.assertTrue(DirStar.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertEqual(DirStar.GetEdges(), self.NetStar.GetEdges()) + + def test_GetRndSubGraph(self): + exp_nodes = 10 + + # Directed Graph + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + subGraph = snap.GetRndSubGraph(Graph, exp_nodes) + self.assertEqual(exp_nodes, subGraph.GetNodes()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(Graph.IsNode(edge.GetSrcNId())) + self.assertTrue(Graph.IsNode(edge.GetDstNId())) + + # Undirected Graph + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + subGraph = snap.GetRndSubGraph(Graph, exp_nodes) + self.assertEqual(exp_nodes, subGraph.GetNodes()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(Graph.IsNode(edge.GetSrcNId())) + self.assertTrue(Graph.IsNode(edge.GetDstNId())) + + # Directed Graph + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + subGraph = snap.GetRndSubGraph(Graph, exp_nodes) + self.assertEqual(exp_nodes, subGraph.GetNodes()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + self.assertTrue(Graph.IsNode(edge.GetSrcNId())) + self.assertTrue(Graph.IsNode(edge.GetDstNId())) + + def test_GetRndESubGraph(self): + exp_edges = 10 + + # Directed Graph + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + subGraph = snap.GetRndESubGraph(Graph, exp_edges) + self.assertEqual(exp_edges, subGraph.GetEdges()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + self.assertTrue(node.GetInDeg() + node.GetOutDeg() > 0) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + # Network + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + subGraph = snap.GetRndESubGraph(Graph, exp_edges) + self.assertEqual(exp_edges, subGraph.GetEdges()) + for node in subGraph.Nodes(): + self.assertTrue(Graph.IsNode(node.GetId())) + self.assertTrue(node.GetInDeg() + node.GetOutDeg() > 0) + for edge in subGraph.Edges(): + self.assertTrue(Graph.IsEdge(edge.GetSrcNId(), edge.GetDstNId())) + + def test_GetTriadEdges(self): + # Directed Graph + exp_triad_edges = self.DirGraphFull.GetEdges() + act_triad_edges = snap.GetTriadEdges(self.DirGraphFull) + self.assertEqual(exp_triad_edges, act_triad_edges) + + # Unirected Graph + exp_triad_edges = self.UnDirGraphFull.GetEdges() + act_triad_edges = snap.GetTriadEdges(self.UnDirGraphFull) + self.assertEqual(exp_triad_edges, act_triad_edges) + + # Network + exp_triad_edges = self.NetFull.GetEdges() + act_triad_edges = snap.GetTriadEdges(self.NetFull) + self.assertEqual(exp_triad_edges, act_triad_edges) + + def test_GetTriadParticip(self): + f = math.factorial + exp_num_tri = f(self.num_nodes-1)/f(2)/f(self.num_nodes-3) + + # Directed Graph + TriadCntV = snap.TIntPrV() + snap.GetTriadParticip(self.DirGraphFull, TriadCntV) + for pair in TriadCntV: + self.assertEqual(exp_num_tri, pair.Val1()) + self.assertEqual(self.num_nodes, pair.Val2) + + # Undirected Graph + TriadCntV = snap.TIntPrV() + snap.GetTriadParticip(self.UnDirGraphFull, TriadCntV) + for pair in TriadCntV: + self.assertEqual(exp_num_tri, pair.Val1()) + self.assertEqual(self.num_nodes, pair.Val2) + + # Network + TriadCntV = snap.TIntPrV() + snap.GetTriadParticip(self.NetFull, TriadCntV) + for pair in TriadCntV: + self.assertEqual(exp_num_tri, pair.Val1()) + self.assertEqual(self.num_nodes, pair.Val2) + + def test_CntEdgesToSet(self): + # Directed Graph + G = snap.GenFull(snap.PNGraph, 10) + TS = snap.TIntSet() + val = snap.CntEdgesToSet(G, 0, TS) + self.assertEqual(0, val) + + # Undirected Graph + G = snap.GenFull(snap.PUNGraph, 10) + TS = snap.TIntSet() + val = snap.CntEdgesToSet(G, 0, TS) + self.assertEqual(0, val) + + # Network + G = snap.GenFull(snap.PNEANet, 10) + TS = snap.TIntSet() + val = snap.CntEdgesToSet(G, 0, TS) + self.assertEqual(0, val) + + def test_GetDegSeqV(self): + # Directed Graph + G = snap.GenFull(snap.PNGraph, 10) + V = snap.TIntV() + snap.GetDegSeqV(G, V) + for i in V: + self.assertEqual(18, i) + + # Undirected Graph + G = snap.GenFull(snap.PUNGraph, 10) + V = snap.TIntV() + snap.GetDegSeqV(G, V) + for i in V: + self.assertEqual(9, i) + + # Network + G = snap.GenFull(snap.PNEANet, 10) + V = snap.TIntV() + snap.GetDegSeqV(G, V) + for i in V: + self.assertEqual(18, i) + + def test_GetDegSeqV2(self): + # Directed Graph + G = snap.GenFull(snap.PNGraph, 10) + V = snap.TIntV() + V2 = snap.TIntV() + snap.GetDegSeqV(G, V, V2) + for i in V: + self.assertEqual(9, i) + for i in V2: + self.assertEqual(9, i) + + # Undirected Graph + G = snap.GenFull(snap.PUNGraph, 10) + V = snap.TIntV() + V2 = snap.TIntV() + snap.GetDegSeqV(G, V, V2) + for i in V: + self.assertEqual(9, i) + for i in V2: + self.assertEqual(9, i) + + # Network + G = snap.GenFull(snap.PNEANet, 10) + V = snap.TIntV() + V2 = snap.TIntV() + snap.GetDegSeqV(G, V, V2) + for i in V: + self.assertEqual(9, i) + for i in V2: + self.assertEqual(9, i) + + def test_GetAnf(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + SrcNId = 0 + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, SrcNId, DistNbrsV, 3, False, 8192) + self.assertEqual(3, DistNbrsV.Len()) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + SrcNId = 0 + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, SrcNId, DistNbrsV, 3, False, 8192) + self.assertEqual(3, DistNbrsV.Len()) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + SrcNId = 0 + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, SrcNId, DistNbrsV, 3, False, 8192) + self.assertEqual(3, DistNbrsV.Len()) + + def test_GetAnf2(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, DistNbrsV, 3, False, 8192) + self.assertEqual(3, DistNbrsV.Len()) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, DistNbrsV, 3, False, 8192) + self.assertEqual(3, DistNbrsV.Len()) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + DistNbrsV = snap.TIntFltKdV() + snap.GetAnf(Graph, DistNbrsV, 3, False, 8192) + self.assertEqual(3, DistNbrsV.Len()) + + def test_GetAnfEffDiam(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetAnfEffDiam(Graph, True, 0.9, 1024) + self.assertTrue(result >= 0) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetAnfEffDiam(Graph, True, 0.9, 1024) + self.assertTrue(result >= 0) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetAnfEffDiam(Graph, True, 0.9, 1024) + self.assertTrue(result >= 0) + + def test_GetAnfEffDiam2(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetAnfEffDiam(Graph) + self.assertTrue(result >= 0) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetAnfEffDiam(Graph) + self.assertTrue(result >= 0) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetAnfEffDiam(Graph) + self.assertTrue(result >= 0) + + def test_GetShortPath(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetShortPath(Graph, 0, 1) + self.assertEqual(1, result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetShortPath(Graph, 0, 1) + self.assertEqual(1, result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetShortPath(Graph, 0, 1) + self.assertEqual(1, result) + + def test_GetShortPath2(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + H = snap.TIntH() + result = snap.GetShortPath(Graph, 0, H) + self.assertEqual(1, result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + H = snap.TIntH() + result = snap.GetShortPath(Graph, 0, H) + self.assertEqual(1, result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + H = snap.TIntH() + result = snap.GetShortPath(Graph, 0, H) + self.assertEqual(1, result) + + def test_GetBfsFullDiam(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetBfsFullDiam(Graph, 10) + self.assertEqual(1, result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetBfsFullDiam(Graph, 10) + self.assertEqual(1, result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetBfsFullDiam(Graph, 10) + self.assertEqual(1, result) + + def test_GetBfsEffDiam(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetBfsEffDiam(Graph, 10) + self.assertAlmostEqual(0.88888888888888888888, result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetBfsEffDiam(Graph, 10) + self.assertAlmostEqual(0.88888888888888888888, result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetBfsEffDiam(Graph, 10) + self.assertAlmostEqual(0.88888888888888888888, result) + + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 100) + Num = 50 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + expected_result = [0.88, 0.88, 1] + result = snap.GetBfsEffDiam(Graph, Num, List, True) + self.assertEqual(expected_result, result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 100) + Num = 75 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + expected_result = [0.88, 0.88, 1] + result = snap.GetBfsEffDiam(Graph, Num, List, False) + self.assertEqual(expected_result, result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 100) + Num = 33 + List = snap.TIntV.GetV(1, 4, 9, 16, 25, 36) + expected_result = [0.88, 0.88, 1] + result = snap.GetBfsEffDiam(Graph, Num, List, True) + self.assertEqual(expected_result, result) + + def test_GetBfsEffDiamAll(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 100) + Num = 50 + expected_result = [0.89898989898989901, + 0.89898989898989901, 1, 0.98999999999999999] + result = snap.GetBfsEffDiamAll(Graph, Num, True) + self.assertEqual(expected_result, result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 100) + Num = 75 + expected_result = [0.89898989898989901, + 0.89898989898989901, 1, 0.98999999999999999] + result = snap.GetBfsEffDiamAll(Graph, Num, False) + self.assertEqual(expected_result, result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 100) + Num = 33 + expected_result = [0.89898989898989901, + 0.89898989898989901, 1, 0.98999999999999999] + result = snap.GetBfsEffDiamAll(Graph, Num, True) + self.assertEqual(expected_result, result) + + def test_GetBetweennessCentr(self): + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + Nodes = snap.TIntFltH() + Edges = snap.TIntPrFltH() + snap.GetBetweennessCentr(Graph, Nodes, Edges, 1.0) + for node in Nodes: + self.assertAlmostEqual(0, Nodes[node]) + for edge in Edges: + self.assertAlmostEqual(2, Edges[edge]) + + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + Nodes = snap.TIntFltH() + Edges = snap.TIntPrFltH() + snap.GetBetweennessCentr(Graph, Nodes, Edges, 1.0) + for node in Nodes: + self.assertAlmostEqual(0, Nodes[node]) + for edge in Edges: + self.assertAlmostEqual(2, Edges[edge]) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + Nodes = snap.TIntFltH() + Edges = snap.TIntPrFltH() + snap.GetBetweennessCentr(Graph, Nodes, Edges, 1.0) + for node in Nodes: + self.assertAlmostEqual(0, Nodes[node]) + for edge in Edges: + self.assertAlmostEqual(2, Edges[edge]) + + def test_GetArtPoints(self): + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + V = snap.TIntV() + snap.GetArtPoints(Graph, V) + self.assertEqual(0, V.Len()) + + def test_GenRndPowerLaw(self): + # Undirected Graph + Graph = snap.GenRndPowerLaw (9, 10) + self.assertEqual(Graph.GetNodes(), 9) + + def test_GenConfModel(self): + # Undirected Graph + DegSeqV = snap.TIntV() + DegSeqV.Add(0) + Graph = snap.GenConfModel(DegSeqV) + self.assertEqual(Graph.GetNodes(), 1) + + def test_GenConfModel1(self): + # Undirected Graph + GraphIn = snap.GenFull(snap.PUNGraph, 10) + Graph = snap.GenConfModel(GraphIn) + self.assertEqual(Graph.GetNodes(), 10) + + def test_GenSmallWorld(self): + # Undirected Graph + Graph = snap.GenSmallWorld(10, 3, 0, snap.TRnd()) + self.assertEqual(Graph.GetNodes(), 10) + + def test_GenCopyModel(self): + # Directed Graph + Graph = snap.GenCopyModel(20, 0.4, snap.TRnd()) + self.assertEqual(Graph.GetNodes(), 20) + + def test_GenGrid(self): + # Directed Graph + Graph = snap.GenGrid(snap.PNGraph, 2, 2) + self.assertEqual(Graph.GetNodes(), 4) + self.assertEqual(Graph.GetEdges(), 4) + + # Undirected Graph + Graph = snap.GenGrid(snap.PUNGraph, 2, 2) + self.assertEqual(Graph.GetNodes(), 4) + self.assertEqual(Graph.GetEdges(), 4) + + # Network + Graph = snap.GenGrid(snap.PNEANet, 2, 2) + self.assertEqual(Graph.GetNodes(), 4) + self.assertEqual(Graph.GetEdges(), 4) + + def test_GenFull(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 5) + self.assertEqual(Graph.GetNodes(), 5) + self.assertEqual(Graph.GetEdges(), 20) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 5) + self.assertEqual(Graph.GetNodes(), 5) + self.assertEqual(Graph.GetEdges(), 10) + + # Network + Graph = snap.GenFull(snap.PNEANet, 5) + self.assertEqual(Graph.GetNodes(), 5) + self.assertEqual(Graph.GetEdges(), 20) + + def test_GenRndGnm(self): + # Directed Graph + Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) + self.assertEqual(Graph.GetNodes(), 100) + self.assertEqual(Graph.GetEdges(), 1000) + + # Undirected Graph + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) + self.assertEqual(Graph.GetNodes(), 100) + self.assertEqual(Graph.GetEdges(), 1000) + + # Network + Graph = snap.GenRndGnm(snap.PNEANet, 100, 1000) + self.assertEqual(Graph.GetNodes(), 100) + self.assertEqual(Graph.GetEdges(), 1000) + + def test_GetCmnNbrs(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetCmnNbrs(Graph, 0, 1) + self.assertEqual(result, 8) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetCmnNbrs(Graph, 0, 1) + self.assertEqual(result, 8) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetCmnNbrs(Graph, 0, 1) + self.assertEqual(result, 8) + + def test_GetCmnNbrs1(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + V = snap.TIntV() + result = snap.GetCmnNbrs(Graph, 0, 1, V) + self.assertEqual(result, 8) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + V = snap.TIntV() + result = snap.GetCmnNbrs(Graph, 0, 1, V) + self.assertEqual(result, 8) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + V = snap.TIntV() + result = snap.GetCmnNbrs(Graph, 0, 1, V) + self.assertEqual(result, 8) + + def test_GetNodeTriads(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetNodeTriads(Graph, 0) + self.assertEqual(result, 36) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetNodeTriads(Graph, 0) + self.assertEqual(result, 36) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetNodeTriads(Graph, 0) + self.assertEqual(result, 36) + + def test_GetNodeTriadsSet(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 100) + for NI in Graph.Nodes(): + break + NId = NI.GetId() + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + expected_result = [6, 6, 380, 4465] + result = snap.GetNodeTriads(Graph, NId, GroupSet) + self.assertEqual(result, expected_result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 100) + for NI in Graph.Nodes(): + break + NId = NI.GetId() + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + expected_result = [6, 6, 380, 4465] + result = snap.GetNodeTriads(Graph, NId, GroupSet) + self.assertEqual(result, expected_result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 100) + for NI in Graph.Nodes(): + break + NId = NI.GetId() + GroupSet = snap.TIntSet() + for NbrIdx in range(4): + GroupSet.AddKey(NI.GetOutNId(NbrIdx)) + expected_result = [6, 6, 380, 4465] + result = snap.GetNodeTriads(Graph, NId, GroupSet) + self.assertEqual(result, expected_result) + + def test_GetNodeTriadsAll(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 100) + expected_result = [4851, 4851, 0] + result = snap.GetNodeTriadsAll(Graph, 10) + self.assertEqual(result, expected_result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 100) + expected_result = [4851, 4851, 0] + result = snap.GetNodeTriadsAll(Graph, 10) + self.assertEqual(result, expected_result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 100) + expected_result = [4851, 4851, 0] + result = snap.GetNodeTriadsAll(Graph, 10) + self.assertEqual(result, expected_result) + + def test_GetTriads(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + result = snap.GetTriads(Graph) + self.assertEqual(result, 120) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + result = snap.GetTriads(Graph) + self.assertEqual(result, 120) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + result = snap.GetTriads(Graph) + self.assertEqual(result, 120) + + def test_GetTriadsAll(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 100) + expected_result = [161700, 161700, 0] + result = snap.GetTriadsAll(Graph) + self.assertEqual(result, expected_result) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 100) + expected_result = [161700, 161700, 0] + result = snap.GetTriadsAll(Graph) + self.assertEqual(result, expected_result) + + # Network + Graph = snap.GenFull(snap.PNEANet, 100) + expected_result = [161700, 161700, 0] + result = snap.GetTriadsAll(Graph) + self.assertEqual(result, expected_result) + + def test_GetClustCf(self): + + # testing GetClustCf(Graph, SampleNodes=-1) + + DirGraph = snap.GenFull(snap.PNGraph, 10) + UnGraph = snap.GenFull(snap.PUNGraph, 10) + MultiGraph = snap.GenFull(snap.PNEANet, 10) + + # no parameters + + # Directed Graph + result = snap.GetClustCf(DirGraph) + self.assertAlmostEqual(result, 1.0) + + # Undirected Graph + result = snap.GetClustCf(UnGraph) + self.assertAlmostEqual(result, 1.0) + + # Network + result = snap.GetClustCf(MultiGraph) + self.assertAlmostEqual(result, 1.0) + + # parameter = 0 + + result = snap.GetClustCf(DirGraph, 0) + self.assertAlmostEqual(result, 0.0) + + result = snap.GetClustCf(UnGraph, 0) + self.assertAlmostEqual(result, 0.0) + + result = snap.GetClustCf(MultiGraph, 0) + self.assertAlmostEqual(result, 0.0) + + # parameter > 0 + + result = snap.GetClustCf(DirGraph, 3) + self.assertAlmostEqual(result, 1.0) + + result = snap.GetClustCf(UnGraph, 3) + self.assertAlmostEqual(result, 1.0) + + result = snap.GetClustCf(MultiGraph, 3) + self.assertAlmostEqual(result, 1.0) + + def test_GetClustCf2(self): + + # testing GetClustCf(Graph, DegToCCfV, SampleNodes=-1) + + DirGraph = snap.GenFull(snap.PNGraph, 10) + UnGraph = snap.GenFull(snap.PUNGraph, 10) + MultiGraph = snap.GenFull(snap.PNEANet, 10) + + # no parameters + + # Directed Graph + V = snap.TFltPrV() + result = snap.GetClustCf(DirGraph, V) + self.assertAlmostEqual(result, 1.0) + self.assertEqual(V.Len(), 1) + + # Undirected Graph + V = snap.TFltPrV() + result = snap.GetClustCf(UnGraph, V) + self.assertAlmostEqual(result, 1.0) + self.assertEqual(V.Len(), 1) + + # Network + V = snap.TFltPrV() + result = snap.GetClustCf(MultiGraph, V) + self.assertAlmostEqual(result, 1.0) + self.assertEqual(V.Len(), 1) + + # parameter = 0 + + V = snap.TFltPrV() + result = snap.GetClustCf(DirGraph, V, 0) + self.assertAlmostEqual(result, 0.0) + self.assertEqual(V.Len(), 0) + + V = snap.TFltPrV() + result = snap.GetClustCf(UnGraph, V, 0) + self.assertAlmostEqual(result, 0.0) + self.assertEqual(V.Len(), 0) + + V = snap.TFltPrV() + result = snap.GetClustCf(MultiGraph, V, 0) + self.assertAlmostEqual(result, 0.0) + self.assertEqual(V.Len(), 0) + + # parameter > 0 + + V = snap.TFltPrV() + result = snap.GetClustCf(DirGraph, V, 3) + self.assertAlmostEqual(result, 1.0) + self.assertEqual(V.Len(), 1) + + V = snap.TFltPrV() + result = snap.GetClustCf(UnGraph, V, 3) + self.assertAlmostEqual(result, 1.0) + self.assertEqual(V.Len(), 1) + + V = snap.TFltPrV() + result = snap.GetClustCf(MultiGraph, V, 3) + self.assertAlmostEqual(result, 1.0) + self.assertEqual(V.Len(), 1) + + def test_GetClustCfAll(self): + + DirGraph = snap.GenFull(snap.PNGraph, 100) + UnGraph = snap.GenFull(snap.PUNGraph, 100) + MultiGraph = snap.GenFull(snap.PNEANet, 100) + + # no parameter + + V = snap.TFltPrV() + result = snap.GetClustCfAll(DirGraph, V) + expected_result = [1.0, 161700, 0] + self.assertEqual(result, expected_result) + + V = snap.TFltPrV() + result = snap.GetClustCfAll(UnGraph, V) + expected_result = [1.0, 161700, 0] + self.assertEqual(result, expected_result) + + V = snap.TFltPrV() + result = snap.GetClustCfAll(MultiGraph, V) + expected_result = [1.0, 161700, 0] + self.assertEqual(result, expected_result) + + # parameter = 0 + + V = snap.TFltPrV() + result = snap.GetClustCfAll(DirGraph, V, 0) + expected_result = [0.0, 0, 0] + self.assertEqual(result, expected_result) + + V = snap.TFltPrV() + result = snap.GetClustCfAll(UnGraph, V, 0) + expected_result = [0.0, 0, 0] + self.assertEqual(result, expected_result) + + V = snap.TFltPrV() + result = snap.GetClustCfAll(MultiGraph, V, 0) + expected_result = [0.0, 0, 0] + self.assertEqual(result, expected_result) + + # parameter > 0 + + V = snap.TFltPrV() + result = snap.GetClustCfAll(DirGraph, V, 5) + expected_result = [1.0, 8085, 0] + self.assertEqual(result, expected_result) + + V = snap.TFltPrV() + result = snap.GetClustCfAll(UnGraph, V, 5) + expected_result = [1.0, 8085, 0] + self.assertEqual(result, expected_result) + + V = snap.TFltPrV() + result = snap.GetClustCfAll(MultiGraph, V, 5) + expected_result = [1.0, 8085, 0] + self.assertEqual(result, expected_result) + + def test_GetLen2Paths(self): + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 100) + result = snap.GetLen2Paths(Graph, 0, 1) + self.assertEqual(result, 98) + + NV = snap.TIntV() + result = snap.GetLen2Paths(Graph, 0, 1, NV) + self.assertEqual(NV.Len(), 98) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 100) + result = snap.GetLen2Paths(Graph, 0, 1) + self.assertEqual(result, 98) + + NV = snap.TIntV() + result = snap.GetLen2Paths(Graph, 0, 1, NV) + self.assertEqual(result, 98) + self.assertEqual(NV.Len(), 98) + + # Network + Graph = snap.GenFull(snap.PNEANet, 100) + result = snap.GetLen2Paths(Graph, 0, 1) + self.assertEqual(result, 98) + self.assertEqual(result, 98) + + NV = snap.TIntV() + result = snap.GetLen2Paths(Graph, 0, 1, NV) + self.assertEqual(result, 98) + self.assertEqual(NV.Len(), 98) + + def test_SavePajek(self): + # Directed Graph + fname = "mygraph.txt" + snap.SavePajek(self.DirGraphFull, fname) + exp_hash = '9474d66aacad5a21ce366eb6b98eb157' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + snap.SavePajek(self.UnDirGraphFull, fname) + exp_hash = '7552ace478ac1b2193a91f4d2707d45d' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + snap.SavePajek(self.NetFull, fname) + exp_hash = '9474d66aacad5a21ce366eb6b98eb157' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_SavePajek2(self): + # Directed Graph + fname = "mygraph.txt" + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + snap.SavePajek(self.DirGraphFull, fname, NIdColorH) + exp_hash = '1d0c1618ae32a2e3e600e47d9540e2e4' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + snap.SavePajek(self.UnDirGraphFull, fname, NIdColorH) + exp_hash = '7a63bc4bd44d9c078e50ba2a43fc484f' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + snap.SavePajek(self.NetFull, fname, NIdColorH) + exp_hash = '1d0c1618ae32a2e3e600e47d9540e2e4' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_SavePajek3(self): + # Directed Graph + fname = "mygraph.txt" + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + snap.SavePajek(self.DirGraphFull, fname, NIdColorH, NIdLabelH) + exp_hash = '1d0c1618ae32a2e3e600e47d9540e2e4' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + snap.SavePajek(self.UnDirGraphFull, fname, NIdColorH, NIdLabelH) + exp_hash = '7a63bc4bd44d9c078e50ba2a43fc484f' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + snap.SavePajek(self.NetFull, fname, NIdColorH, NIdLabelH) + exp_hash = '1d0c1618ae32a2e3e600e47d9540e2e4' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_SavePajek4(self): + # Directed Graph + fname = "mygraph.txt" + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + EIdColorH = snap.TIntStrH() + for i in range(1000): + EIdColorH[i] = "black" + snap.SavePajek(self.DirGraphFull, fname, NIdColorH, NIdLabelH, EIdColorH) + exp_hash = '1d0c1618ae32a2e3e600e47d9540e2e4' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + EIdColorH = snap.TIntStrH() + for i in range(1000): + EIdColorH[i] = "black" + snap.SavePajek(self.UnDirGraphFull, fname, NIdColorH, NIdLabelH, EIdColorH) + exp_hash = '7a63bc4bd44d9c078e50ba2a43fc484f' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + NIdLabelH = snap.TIntStrH() + for i in range(100): + NIdLabelH[i] = str(i) + EIdColorH = snap.TIntStrH() + for i in range(1000): + EIdColorH[i] = "black" + snap.SavePajek(self.NetFull, fname, NIdColorH, NIdLabelH, EIdColorH) + exp_hash = '22acc46e0a1a57c4f74fbacac90ebd82' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_SaveGViz(self): + # Directed Graph + fname = "mygraph.dot" + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + snap.SaveGViz(self.DirGraphFull, fname, "text", True, NIdColorH) + exp_hash = '64fe626fa482a0d45416824dc02d73a5' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + snap.SaveGViz(self.UnDirGraphFull, fname, "text", True, NIdColorH) + exp_hash = 'd2185ec44f908e8d10da6c6319c900a5' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + NIdColorH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdColorH[i] = "red" + snap.SaveGViz(self.NetFull, fname, "text", True, NIdColorH) + exp_hash = '64fe626fa482a0d45416824dc02d73a5' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_SaveGViz2(self): + # Directed Graph + fname = "mygraph.dot" + NIdLabelH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdLabelH[i] = str(i) + snap.SaveGViz(self.DirGraphFull, fname, "text", NIdLabelH) + exp_hash = '260c9cfe1b5eac55a053ffcf418703e1' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + NIdLabelH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdLabelH[i] = str(i) + snap.SaveGViz(self.UnDirGraphFull, fname, "text", NIdLabelH) + exp_hash = 'df04d8deed65d2a537a741e3ab3e251b' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Directed Graph + NIdLabelH = snap.TIntStrH() + for i in range(self.num_nodes): + NIdLabelH[i] = str(i) + snap.SaveGViz(self.NetFull, fname, "text", NIdLabelH) + exp_hash = '260c9cfe1b5eac55a053ffcf418703e1' + test_hash = self.getFileHash(fname) + self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_LoadEdgeList(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveEdgeList(self.DirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.PNGraph, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes) + os.remove(fname) + + # Undirected Graph + snap.SaveEdgeList(self.UnDirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.PUNGraph, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes/2) + os.remove(fname) + + # Directed Graph + snap.SaveEdgeList(self.NetFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.PNEANet, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes) + os.remove(fname) + + def test_LoadEdgeList2(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveEdgeList(self.DirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.PNGraph, fname, 0, 1, '\t') + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes) + os.remove(fname) + + # Undirected Graph + snap.SaveEdgeList(self.UnDirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.PUNGraph, fname, 0, 1, '\t') + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes/2) + os.remove(fname) + + # Directed Graph + snap.SaveEdgeList(self.NetFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeList(snap.PNEANet, fname, 0, 1, '\t') + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes) + os.remove(fname) + + def test_LoadEdgeListStr(self): + # Directed Graph + fname = "mygraph.txt" + snap.SaveEdgeList(self.DirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeListStr(snap.PNGraph, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes) + os.remove(fname) + + # Undirected Graph + snap.SaveEdgeList(self.UnDirGraphFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeListStr(snap.PUNGraph, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes/2) + os.remove(fname) + + # Directed Graph + snap.SaveEdgeList(self.NetFull, fname) + self.assertTrue(os.path.isfile(fname)) + Graph = snap.LoadEdgeListStr(snap.PNEANet, fname, 0, 1) + self.assertEqual(Graph.GetNodes(), self.num_nodes) + self.assertEqual(Graph.GetEdges(), (self.num_nodes-1)*self.num_nodes) + os.remove(fname) + + def test_GetSngVec(self): + # Directed Graph + val = 0.316227766017 + Graph = snap.GenFull(snap.PNGraph, 10) + LeftSV = snap.TFltV() + RightSV = snap.TFltV() + snap.GetSngVec(Graph, LeftSV, RightSV) + for i in LeftSV: + self.assertAlmostEqual(i, val) + for i in RightSV: + self.assertAlmostEqual(i, val) + + SngValV = snap.TFltV() + LeftSVV = snap.TFltVFltV() + RightSVV = snap.TFltVFltV() + snap.GetSngVec(Graph, 5, SngValV, LeftSVV, RightSVV) + self.assertAlmostEqual(SngValV[0], 9.0) + for i in range(1,10): + self.assertAlmostEqual(SngValV[1], 1.0) + + def test_LoadConnList(self): + fname = "mygraph.txt" + output = open(fname, "w") + output.write('0 1 2\n') + output.write('1 2 0\n') + output.write('2 0 1\n') + output.close() + + # Directed Graph + Graph = snap.LoadConnList(snap.PNGraph, fname) + self.assertEqual(Graph.GetNodes(), 3) + self.assertEqual(Graph.GetEdges(), 6) + + # Undirected Graph + Graph = snap.LoadConnList(snap.PUNGraph, fname) + self.assertEqual(Graph.GetNodes(), 3) + self.assertEqual(Graph.GetEdges(), 3) + + # Network + Graph = snap.LoadConnList(snap.PNEANet, fname) + self.assertEqual(Graph.GetNodes(), 3) + self.assertEqual(Graph.GetEdges(), 6) + os.remove(fname) + + def test_GetEigVec(self): + # Undirected Graph + Graph = snap.GenRndGnm(snap.PUNGraph, 100, 500) + EigV = snap.TFltV() + snap.GetEigVec(Graph, EigV) + self.assertEqual(EigV.Len(), 100) + + EigVal = snap.TFltV() + EigVV = snap.TFltVFltV() + snap.GetEigVec(Graph, 10, EigVal, EigVV) + self.assertEqual(EigVal.Len(), 10) + for V in EigVV: + self.assertEqual(V.Len(), 100) + + def test_DrawGViz(self): + # Directed Graph + fname = "mygraph.png" + snap.DrawGViz(self.DirGraphFull, snap.gvlDot, fname, "graph 1") + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + exp_hash = '7ac8bcf157f7d916be78a09faaf13f23' + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + # OP RS 2014/05/13, disabled since it is not portable + #self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + fname = "mygraph.png" + snap.DrawGViz(self.UnDirGraphFull, snap.gvlDot, fname, "graph 1") + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + exp_hash = '734899b11f197b88d14d771b18011d85' + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + # OP RS 2014/05/13, disabled since it is not portable + #self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Network + fname = "mygraph.png" + snap.DrawGViz(self.NetFull, snap.gvlDot, fname, "graph 1") + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + exp_hash = '7ac8bcf157f7d916be78a09faaf13f23' + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + # OP RS 2014/05/13, disabled since it is not portable + #self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_DrawGViz2(self): + + # Directed Graph + fname = "mygraph.png" + labels = snap.TIntStrH() + for NI in self.DirGraphFull.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + snap.DrawGViz(self.DirGraphFull, snap.gvlDot, fname, "graph 1", labels) + self.assertTrue(os.stat(fname).st_size > 50000) + self.assertTrue(os.path.isfile(fname)) + exp_hash = 'd0fa3688dd5d9c5599222270be49805e' + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + # OP RS 2014/05/13, disabled since it is not portable + #self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Undirected Graph + fname = "mygraph.png" + labels = snap.TIntStrH() + for NI in self.UnDirGraphFull.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + snap.DrawGViz(self.UnDirGraphFull, snap.gvlDot, fname, "graph 1", labels) + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + exp_hash = '191c86413fd43f23bf1c5ce4a9972863' + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + # OP RS 2014/05/13, disabled since it is not portable + #self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + # Network + fname = "mygraph.png" + labels = snap.TIntStrH() + for NI in self.NetFull.Nodes(): + labels[NI.GetId()] = str(NI.GetId()) + snap.DrawGViz(self.NetFull, snap.gvlDot, fname, "graph 1", labels) + self.assertTrue(os.path.isfile(fname)) + self.assertTrue(os.stat(fname).st_size > 50000) + exp_hash = 'd0fa3688dd5d9c5599222270be49805e' + f = open(fname, 'rb') + test_hash = hashlib.md5(f.read()).hexdigest() + f.close() + # OP RS 2014/05/13, disabled since it is not portable + #self.assertEqual(exp_hash, test_hash) + os.remove(fname) + + def test_GetSubGraph(self): + V = snap.TIntV() + for i in range(5): + V.Add(i) + # Directed Graph + Graph = snap.GenFull(snap.PNGraph, 10) + SubGraph = snap.GetSubGraph(Graph, V) + self.assertEqual(SubGraph.GetNodes(), 5) + self.assertEqual(SubGraph.GetEdges(), 5 * 4) + + SubGraph = snap.GetSubGraphRenumber(Graph, V) + self.assertEqual(SubGraph.GetNodes(), 5) + self.assertEqual(SubGraph.GetEdges(), 5 * 4) + # verify that NIds are in 0..N-1 + for NI in SubGraph.Nodes(): + self.assertEqual(NI.GetId() < SubGraph.GetNodes(), True) + + # Undirected Graph + Graph = snap.GenFull(snap.PUNGraph, 10) + SubGraph = snap.GetSubGraph(Graph, V) + self.assertEqual(SubGraph.GetNodes(), 5) + self.assertEqual(SubGraph.GetEdges(), 5 * 4/2) + + SubGraph = snap.GetSubGraphRenumber(Graph, V) + self.assertEqual(SubGraph.GetNodes(), 5) + self.assertEqual(SubGraph.GetEdges(), 5 * 4/2) + # verify that NIds are in 0..N-1 + for NI in SubGraph.Nodes(): + self.assertEqual(NI.GetId() < SubGraph.GetNodes(), True) + + # Network + Graph = snap.GenFull(snap.PNEANet, 10) + SubGraph = snap.GetSubGraph(Graph, V) + self.assertEqual(SubGraph.GetNodes(), 5) + self.assertEqual(SubGraph.GetEdges(), 5 * 4) + + def test_GetNodeClustCf(self): + # Directed Graph + H = snap.TIntFltH() + snap.GetNodeClustCf(self.DirGraphFull, H) + for i in H: + self.assertEqual(1.0, H[i]) + + # Undirected Graph + H = snap.TIntFltH() + snap.GetNodeClustCf(self.UnDirGraphFull, H) + for i in H: + self.assertEqual(1.0, H[i]) + + # Network + H = snap.TIntFltH() + snap.GetNodeClustCf(self.NetFull, H) + for i in H: + self.assertEqual(1.0, H[i]) + + def test_ConvertESubGraph(self): + V = snap.TIntV() + for i in range(10): + V.Add(i+1) + # Directed Graph + SubGraph = snap.ConvertESubGraph(snap.PNGraph, self.NetFull, V) + self.assertEqual(SubGraph.GetEdges(), V.Len()) + + # Undirected Graph + SubGraph = snap.ConvertESubGraph(snap.PUNGraph, self.NetFull, V) + self.assertEqual(SubGraph.GetEdges(), V.Len()) + + # Network + SubGraph = snap.ConvertESubGraph(snap.PNEANet, self.NetFull, V) + self.assertEqual(SubGraph.GetEdges(), V.Len()) + + def test_GetEgonet(self): + + # Undirected Graph + for i in range(10): + Egonet, edges = snap.GetEgonet(self.UPetersen, i) + self.assertEqual(Egonet.GetNodes(), 4) + self.assertEqual(Egonet.GetEdges(), 3) + self.assertEqual(edges, 6) + + # Directed Graph + for i in range(10): + Egonet, ein, eout = snap.GetEgonet(self.DPetersen, i) + self.assertEqual(Egonet.GetNodes(), 4) + self.assertEqual(Egonet.GetEdges(), 3) + if i < 5: + self.assertEqual(ein, 2) + self.assertEqual(eout, 4) + else: + self.assertEqual(ein, 4) + self.assertEqual(eout, 2) + + def test_GetEgonetHop(self): + + # Undirected Graph + for i in range(1,3): + Egonet = snap.GetEgonetHop(self.UPetersen, 0, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 4) + self.assertEqual(Egonet.GetEdges(), 3) + else: + self.assertEqual(Egonet.GetNodes(), 10) + self.assertEqual(Egonet.GetEdges(), 15) + + # Directed Graph + for i in range(1,3): + Egonet = snap.GetEgonetHop(self.DPetersen, 1, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 4) + self.assertEqual(Egonet.GetEdges(), 3) + else: + self.assertEqual(Egonet.GetNodes(), 10) + self.assertEqual(Egonet.GetEdges(), 15) + + # Directed Network + for i in range(1,3): + Egonet = snap.GetEgonetHop(self.NPetersen, 2, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 4) + self.assertEqual(Egonet.GetEdges(), 3) + else: + self.assertEqual(Egonet.GetNodes(), 10) + self.assertEqual(Egonet.GetEdges(), 15) + + def test_GetInEgonetHop(self): + + # Undirected Graph + for i in range(1,3): + Egonet = snap.GetInEgonetHop(self.UPetersen, 3, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 4) + self.assertEqual(Egonet.GetEdges(), 3) + else: + self.assertEqual(Egonet.GetNodes(), 10) + self.assertEqual(Egonet.GetEdges(), 15) + + # Directed Graph + for i in range(1,3): + Egonet = snap.GetInEgonetHop(self.DPetersen, 4, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 2) + self.assertEqual(Egonet.GetEdges(), 1) + else: + self.assertEqual(Egonet.GetNodes(), 3) + self.assertEqual(Egonet.GetEdges(), 2) + + # Directed Network + for i in range(1,3): + Egonet = snap.GetInEgonetHop(self.NPetersen, 5, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 3) + self.assertEqual(Egonet.GetEdges(), 2) + else: + self.assertEqual(Egonet.GetNodes(), 6) + self.assertEqual(Egonet.GetEdges(), 6) + + def test_GetOutEgonetHop(self): + + # Undirected Graph + for i in range(1,3): + Egonet = snap.GetOutEgonetHop(self.UPetersen, 6, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 4) + self.assertEqual(Egonet.GetEdges(), 3) + else: + self.assertEqual(Egonet.GetNodes(), 10) + self.assertEqual(Egonet.GetEdges(), 15) + + # Directed Graph + for i in range(1,3): + Egonet = snap.GetOutEgonetHop(self.DPetersen, 7, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 2) + self.assertEqual(Egonet.GetEdges(), 1) + else: + self.assertEqual(Egonet.GetNodes(), 3) + self.assertEqual(Egonet.GetEdges(), 2) + + # Directed Network + for i in range(1,3): + Egonet = snap.GetOutEgonetHop(self.NPetersen, 8, i) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 2) + self.assertEqual(Egonet.GetEdges(), 1) + else: + self.assertEqual(Egonet.GetNodes(), 3) + self.assertEqual(Egonet.GetEdges(), 2) + + def test_GetInEgonetSub(self): + + # Undirected Graph + for i in range(1,3): + Egonet = snap.GetInEgonetSub(self.UPetersen, 9, i, 2) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 3) + self.assertEqual(Egonet.GetEdges(), 2) + else: + self.assertEqual(Egonet.GetNodes(), 7) + self.assertEqual(Egonet.GetEdges(), 8) + + # Directed Graph + for i in range(1,3): + Egonet = snap.GetInEgonetSub(self.DPetersen, 0, i, 2) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 2) + self.assertEqual(Egonet.GetEdges(), 1) + else: + self.assertEqual(Egonet.GetNodes(), 3) + self.assertEqual(Egonet.GetEdges(), 2) + + # Directed Network + for i in range(1,3): + Egonet = snap.GetInEgonetSub(self.NPetersen, 1, i, 2) + if i == 1: + self.assertEqual(Egonet.GetNodes(), 2) + self.assertEqual(Egonet.GetEdges(), 1) + else: + self.assertEqual(Egonet.GetNodes(), 3) + self.assertEqual(Egonet.GetEdges(), 2) + + def test_GetGraphUnion(self): + + #Undirected Graph + Graph = snap.TUNGraph.New() + Graph0 = snap.TUNGraph.New() + for i in range(5): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i+1) % 5) + Graph.AddEdge(i,(i+2) % 5) + + for i in range(3,8): + Graph0.AddNode(i) + for i in range(5): + Graph0.AddEdge(i + 3,((i+1) % 5) + 3) + + snap.GetGraphUnion(Graph, Graph0) + self.assertEqual(Graph.GetNodes(), 8) + self.assertEqual(Graph.GetEdges(), 14) + + # Directed Graph + Graph1 = snap.TNGraph.New() + Graph2 = snap.TNGraph.New() + for i in range(4): + Graph1.AddNode(i) + for i in range(1,5): + Graph2.AddNode(i) + + Graph1.AddEdge(0, 1) + Graph1.AddEdge(1, 2) + Graph2.AddEdge(1, 2) + Graph2.AddEdge(2, 1) + Graph1.AddEdge(2, 3) + Graph2.AddEdge(2, 3) + Graph1.AddEdge(3, 2) + Graph2.AddEdge(3, 4) + Graph2.AddEdge(1, 4) + + snap.GetGraphUnion(Graph1, Graph2) + self.assertEqual(Graph1.GetNodes(), 5) + self.assertEqual(Graph1.GetEdges(), 7) + + # Directed Network + Graph3 = snap.TNEANet.New() + Graph4 = snap.TNEANet.New() + EId = 0 + for i in range(4): + Graph3.AddNode(i) + for i in range(1,5): + Graph4.AddNode(i) + + Graph3.AddEdge(0, 1, EId) + EId += 1 + Graph3.AddEdge(1, 2, EId) + EId += 1 + Graph4.AddEdge(1, 2, EId) + EId += 1 + Graph4.AddEdge(2, 1, EId) + EId += 1 + Graph3.AddEdge(2, 3, EId) + Graph4.AddEdge(2, 3, EId) + EId += 1 + Graph3.AddEdge(3, 2, EId) + EId += 1 + Graph4.AddEdge(3, 4, EId) + EId += 1 + Graph4.AddEdge(1, 4, EId) + EId += 1 + + snap.GetGraphUnion(Graph3, Graph4) + self.assertEqual(Graph3.GetNodes(), 5) + self.assertEqual(Graph3.GetEdges(), 7) + + def test_GetGraphUnionAttr(self): + Graph = snap.TNEANet.New() + Graph0 = snap.TNEANet.New() + + s = "id" + for i in range(6): + Graph.AddNode(i) + Graph.AddIntAttrDatN(i, i, s) + + for i in range(3,9): + Graph0.AddNode(i) + Graph0.AddIntAttrDatN(i, i, s) + + for i in range(6): + EId = Graph.AddEdge(i, (i + 2) % 6) + Graph.AddIntAttrDatE(EId, (i + 2) % 6, s) + EId = Graph.AddEdge(i, (i + 5) % 6) + Graph.AddIntAttrDatE(EId, (i + 5) % 6, s) + + for i in range(6): + EId = Graph0.AddEdge(i + 3, ((i + 3) % 6) + 3) + Graph0.AddIntAttrDatE(EId, ((i + 3) % 6) + 3, s) + EId = Graph0.AddEdge(i + 3, ((i + 4) % 6) + 3) + Graph0.AddIntAttrDatE(EId, ((i + 4) % 6) + 3, s) + + snap.GetGraphUnionAttr(Graph, Graph0) + self.assertEqual(Graph.GetNodes(), 9) + self.assertEqual(Graph.GetEdges(), 24) + + def test_GetGraphIntersection(self): + #Undirected Graph + Graph = snap.TUNGraph.New() + Graph0 = snap.TUNGraph.New() + + for i in range(5): + Graph.AddNode(i) + for i in range(5): + Graph.AddEdge(i,(i + 1) % 5) + Graph.AddEdge(i,(i + 2) % 5) + + for i in range(2,6): + Graph0.AddNode(i) + for i in range(4): + Graph0.AddEdge(i + 2, ((i + 1) % 4) + 2) + Graph0.AddEdge(i + 2, ((i + 2) % 4) + 2) + + IntersectionGraph = snap.GetGraphIntersection(Graph, Graph0) + self.assertEqual(IntersectionGraph.GetNodes(), 3) + self.assertEqual(IntersectionGraph.GetEdges(), 3) + + # Directed Graph + Graph1 = snap.TNGraph.New() + Graph2 = snap.TNGraph.New() + + for i in range(8): + Graph1.AddNode(i) + for i in range(8): + Graph1.AddEdge(i, (i + 1) % 8) + Graph1.AddEdge((i + 1) % 8, i) + + for i in range(2,6): + Graph2.AddNode(i) + for i in range(4): + Graph2.AddEdge(i + 2, ((i + 1) % 4) + 2) + Graph2.AddEdge(i + 2, ((i + 2) % 4) + 2) + + IntersectionGraph0 = snap.GetGraphIntersection(Graph1, Graph2) + self.assertEqual(IntersectionGraph0.GetNodes(), 4) + self.assertEqual(IntersectionGraph0.GetEdges(), 3) + + # Directed Network + Graph3 = snap.TNEANet.New() + Graph4 = snap.TNEANet.New() + EId3 = 0 + EId4 = 1 + for i in range(4): + Graph3.AddNode(i) + for i in range(3): + Graph3.AddEdge(i, i + 1, EId3) + EId3 += 1 + Graph3.AddEdge(1, 0, EId3) + EId3 += 1 + Graph3.AddEdge(1, 2, EId3) + EId3 += 1 + Graph3.AddEdge(3, 2, EId3) + EId3 += 1 + + for i in range(1,5): + Graph4.AddNode(i) + for i in range(1,4): + Graph4.AddEdge(i + 1, i, EId4 + 3) + Graph4.AddEdge(i, i + 1, EId4) + EId4 += 1 + + IntersectionGraph1 = snap.GetGraphIntersection(Graph3, Graph4) + self.assertEqual(IntersectionGraph1.GetNodes(), 3) + self.assertEqual(IntersectionGraph1.GetEdges(), 3) + + def test_GetGraphIntersectionAttr(self): + Graph = snap.TNEANet.New() + Graph0 = snap.TNEANet.New() + + s = "id" + for i in range(7): + Graph.AddNode(i) + Graph.AddIntAttrDatN(i, i, s) + + for i in range(2,9): + Graph0.AddNode(i) + Graph0.AddIntAttrDatN(i, i, s) + + for i in range(7): + EId = Graph.AddEdge(i, (i + 2) % 7) + Graph.AddIntAttrDatE(EId, (i + 2) % 7, s) + EId = Graph.AddEdge(i, (i + 3) % 7) + Graph.AddIntAttrDatE(EId, (i + 3) % 7, s) + + for i in range(7): + EId = Graph0.AddEdge(i + 2, ((i + 3) % 7) + 2) + Graph0.AddIntAttrDatE(EId, ((i + 3) % 7) + 2, s) + + IntersectionGraph = snap.GetGraphIntersectionAttr(Graph, Graph0) + self.assertEqual(IntersectionGraph.GetNodes(), 5) + self.assertEqual(IntersectionGraph.GetEdges(), 3) + +if __name__ == '__main__': + unittest.main() diff --git a/snap-python/source/test/table-test-avery.py b/snap-python/source/test/table-test-avery.py new file mode 100644 index 0000000000000000000000000000000000000000..a7cc56416ff3b3af1749a6fd7c008c4f943b91db --- /dev/null +++ b/snap-python/source/test/table-test-avery.py @@ -0,0 +1,93 @@ +# coding: utf-8 +import hashlib +import math +import os +import re +import time +import unittest + +import snap + +PATH_TO_GNUTELLA = "data/p2p-Gnutella08.txt" + +class SnapPythonTest(unittest.TestCase): + + def __init__(self, *args, **kwargs): + self.gnutella = snap.LoadEdgeList(snap.PNGraph, PATH_TO_GNUTELLA) + super(SnapPythonTest, self).__init__(*args, **kwargs) + + def setUp(self): + # Defaults for creating graphs + self.num_nodes = 10 + + # Full Graphs + self.DirGraphFull = snap.GenFull(snap.PNGraph, self.num_nodes) + self.UnDirGraphFull = snap.GenFull(snap.PUNGraph, self.num_nodes) + self.NetFull = snap.GenFull(snap.PNEANet, self.num_nodes) + + # Star Graphs + self.DirGraphStar = snap.GenStar(snap.PNGraph, self.num_nodes) + self.UnDirGraphStar = snap.GenStar(snap.PUNGraph, self.num_nodes) + self.NetStar = snap.GenStar(snap.PNEANet, self.num_nodes) + + # Graph With Self Edges + self.DirGraphSelfEdge = snap.GenRndGnm(snap.PNGraph, 10, 20) + self.DirGraphSelfEdge.AddEdge(0, 0) + self.UnDirGraphSelfEdge = snap.GenRndGnm(snap.PUNGraph, 10, 20) + self.UnDirGraphSelfEdge.AddEdge(0, 0) + self.NetSelfEdge = snap.GenRndGnm(snap.PNEANet, 10, 20) + self.NetSelfEdge.AddEdge(0, 0) + + # Graph With Multiple Zero-Degree Nodes + self.DirGraphZeroDegree = snap.GenRndGnm(snap.PNGraph, 10, 1) + self.UnDirGraphZeroDegree = snap.GenRndGnm(snap.PUNGraph, 10, 1) + self.NetZeroDegree = snap.GenRndGnm(snap.PNEANet, 10, 1) + + # Trees + self.DirTree = snap.GenTree(snap.PNGraph, 3, 3) + self.UnDirTree = snap.GenTree(snap.PUNGraph, 3, 3) + self.NetTree = snap.GenTree(snap.PNEANet, 3, 3) + + # Random + self.DirRand = snap.GenRndGnm(snap.PNGraph, 10, 20) + self.UnDirRand = snap.GenRndGnm(snap.PUNGraph, 10, 20) + self.NetRand = snap.GenRndGnm(snap.PNEANet, 10, 20) + + + + + + # not at all sure how to test getitem, not in other + def test_table_getitem(self): + context = snap.TTableContext() + + schema = snap.Schema() + + schema.Add(snap.TStrTAttrPr("Col1", snap.atInt)) + schema.Add(snap.TStrTAttrPr("Col2", snap.atInt)) + schema.Add(snap.TStrTAttrPr("Col3", snap.atFlt)) + + filename = "data/data-table.txt" + grade_table = snap.TTable.LoadSS(schema, filename, context, "\t", snap.TBool(False)) + int_vec = snap.TIntV() + int_vec.Add(0) + int_vec.Add(1) + int_vec.Add(2) + int_vec.Add(3) + int_vec.Add(4) + # unsure about next line! + col2_vec = grade_table[] + # also passing on len for now since not obvious either. + + def test_table_merge(self): + context = snap.TTableContext() + + schema = snap.Schema() + + schema.Add(snap.TStrTAttrPr("Col1", snap.atInt)) + schema.Add(snap.TStrTAttrPr("Col2", snap.atInt)) + schema.Add(snap.TStrTAttrPr("Col3", snap.atFlt)) + + filename = "data/data-table.txt" + grade_table = snap.TTable.LoadSS(schema, filename, context, "\t", snap.TBool(False)) + int_vec = snap.TIntV() diff --git a/snap-python/source/test/test-131-setiter.py b/snap-python/source/test/test-131-setiter.py new file mode 100644 index 0000000000000000000000000000000000000000..9931f66ebce3fb1fedcca5ed83d36965d0a8db9b --- /dev/null +++ b/snap-python/source/test/test-131-setiter.py @@ -0,0 +1,20 @@ +import snap + +print("testing snap.TIntSet ...") +set = snap.TIntSet() +set.AddKey(0) +set.AddKey(1) +set.AddKey(2) +for Id_A in set: + for Id_B in set: + print((Id_A, Id_B)) + +print("testing snap.TIntH ...") +hash = snap.TIntH() +hash[0] = 0 +hash[1] = 1 +hash[2] = 2 +for Id_A in hash: + for Id_B in hash: + print((Id_A, Id_B)) + diff --git a/snap-python/source/test/test-2015-18a-attr.py b/snap-python/source/test/test-2015-18a-attr.py new file mode 100644 index 0000000000000000000000000000000000000000..bb727752834204f51ffc5b527bc2e1135f4196f6 --- /dev/null +++ b/snap-python/source/test/test-2015-18a-attr.py @@ -0,0 +1,45 @@ +import snap + +Gnea = snap.TNEANet.New() # Create an empty graph +Gnea.AddStrAttrN('name') # Add a node attribute "name" + +# Add some nodes +Gnea.AddNode(0) +Gnea.AddNode(1) +Gnea.AddNode(2) + +# Fill in the attribute "name" +Gnea.AddStrAttrDatN(0, 'zero', 'name') +Gnea.AddStrAttrDatN(1, 'one', 'name') +Gnea.AddStrAttrDatN(2, 'two', 'name') + +# Retrieve attribute "name" +Gnea.GetStrAttrDatN(0, 'name') +Gnea.GetStrAttrDatN(1, 'name') +Gnea.GetStrAttrDatN(2, 'name') + +# Add some edges +Gnea.AddEdge(0, 1, -1) +Gnea.AddEdge(1, 2, -1) +Gnea.AddEdge(2, 0, -1) + +Gnea.AddFltAttrE('posWeight') # Add an edge attribute "weight" +Gnea.AddFltAttrE('negWeight') # Add an edge attribute "weight" + +# Fill in the edge attributes +for x in Gnea.Edges(): + Gnea.AddFltAttrDatE(x.GetId(), float(x.GetId()*3+1), 'posWeight') + Gnea.AddFltAttrDatE(x.GetId(), -1.0*float(x.GetId()*3+1), 'negWeight') + +# Retrieve the attribute "weight" +for x in Gnea.Edges(): + print(Gnea.GetFltAttrDatE(x.GetId(), 'posWeight')) + +for x in Gnea.Edges(): + print(Gnea.GetFltAttrDatE(x.GetId(), 'negWeight')) + +for x in Gnea.Edges(): + if Gnea.GetFltAttrDatE(x.GetId(), 'posWeight') == Gnea.GetFltAttrDatE(x.GetId(), 'negWeight'): + print("*** Error: attributes are equal") + sys.exit(1) + diff --git a/snap-python/source/test/test-2015-298.py b/snap-python/source/test/test-2015-298.py new file mode 100644 index 0000000000000000000000000000000000000000..14f318d7c440a7699e6999b3f834476d795c0266 --- /dev/null +++ b/snap-python/source/test/test-2015-298.py @@ -0,0 +1,25 @@ +# +# testing edge iterator +# + +import snap +import sys + +n = 1000 + +G = snap.GenFull(snap.PNEANet, n) + +for SrcNId in range(1,n): + for DstNId in range(1,n): + if SrcNId == DstNId: + continue + + EI = G.GetEI(SrcNId, DstNId) + if EI.GetSrcNId() != SrcNId: + print("*** Error SrcNID (%d, %d), expected %d, got %d" % ( + SrcNId, DstNId, SrcNId, EI.GetSrcNId())) + + if EI.GetDstNId() != DstNId: + print("*** Error DstNID (%d, %d), expected %d, got %d" % ( + SrcNId, DstNId, DstNId, EI.GetDstNId())) + diff --git a/snap-python/source/test/test-20160801-LoadConnListStr.py b/snap-python/source/test/test-20160801-LoadConnListStr.py new file mode 100644 index 0000000000000000000000000000000000000000..3c81b9d85d4dc1d62bcbaf94c6e76fa5465da75f --- /dev/null +++ b/snap-python/source/test/test-20160801-LoadConnListStr.py @@ -0,0 +1,16 @@ +import snap + +H = snap.TStrIntSH() +Graph = snap.LoadConnListStr(snap.PNGraph, + "data/example-LoadConnListStr.txt", H) +# get node ID of "A" +print(H.GetDat("A")) + +H = snap.TStrIntSH() +UGraph = snap.LoadConnListStr(snap.PUNGraph, + "data/example-LoadConnListStr.txt", H) + +H = snap.TStrIntSH() +Network = snap.LoadConnListStr(snap.PNEANet, + "data/example-LoadConnListStr.txt", H) + diff --git a/snap-python/source/test/test-20180416-table.py b/snap-python/source/test/test-20180416-table.py new file mode 100644 index 0000000000000000000000000000000000000000..ddea01ad8501407775f33092d5c258cd1f1dacdf --- /dev/null +++ b/snap-python/source/test/test-20180416-table.py @@ -0,0 +1,26 @@ +import snap + +#tsv_file = "data-table1.txt" +tsv_file = "data/data-table.txt" + +print("writing table") +context = snap.TTableContext() +schema = snap.Schema() +schema.Add(snap.TStrTAttrPr("srcID", snap.atInt)) +schema.Add(snap.TStrTAttrPr("dstID", snap.atInt)) +schema.Add(snap.TStrTAttrPr("distance", snap.atFlt)) +#schema.Add(snap.TStrTAttrPr("distance", snap.atStr)) + +table = snap.TTable.LoadSS(schema, tsv_file, context, "\t", snap.TBool(False)) +#FOut = snap.TFOut(table_file) +#table.Save(FOut) +#FOut.Flush() + +tmp = table.BegRI() +while tmp < table.EndRI(): + #print(str(tmp)) + #print(tmp.GetFltAttr('distance')) + print(tmp.GetIntAttr('srcID'), tmp.GetIntAttr('dstID'), tmp.GetFltAttr('distance')) + #print(tmp.GetIntAttr('srcID'), tmp.GetIntAttr('dstID'), tmp.GetStrAttr('distance')) + tmp.Next() + diff --git a/snap-python/source/test/test-346-getei.py b/snap-python/source/test/test-346-getei.py new file mode 100644 index 0000000000000000000000000000000000000000..a8c7532dd62fdc943aaecdd1c83ce6001127a581 --- /dev/null +++ b/snap-python/source/test/test-346-getei.py @@ -0,0 +1,50 @@ +import snap + +Graph = snap.GenFull(snap.PNEANet, 10) +print(Graph.GetEI(0,5).GetId()) + +Src = 0 +Dst = 5 +EI = Graph.GetEI(Src,Dst) +Src1 = EI.GetSrcNId() +Dst1 = EI.GetDstNId() +EI1 = Graph.GetEI(Src1,Dst1) + +if Src != Src1 or Dst != Dst1: + print("*** Error1") + +if EI.GetId() != EI1.GetId(): + print("*** Error2") + +Graph = snap.GenFull(snap.PUNGraph, 10) +print(Graph.GetEI(0,5).GetId()) + +Src = 0 +Dst = 5 +EI = Graph.GetEI(Src,Dst) +Src1 = EI.GetSrcNId() +Dst1 = EI.GetDstNId() +EI1 = Graph.GetEI(Src1,Dst1) + +if Src != Src1 or Dst != Dst1: + print("*** Error1") + +if EI.GetId() != EI1.GetId(): + print("*** Error2") + +Graph = snap.GenFull(snap.PNGraph, 10) +print(Graph.GetEI(0,5).GetId()) + +Src = 0 +Dst = 5 +EI = Graph.GetEI(Src,Dst) +Src1 = EI.GetSrcNId() +Dst1 = EI.GetDstNId() +EI1 = Graph.GetEI(Src1,Dst1) + +if Src != Src1 or Dst != Dst1: + print("*** Error1") + +if EI.GetId() != EI1.GetId(): + print("*** Error2") + diff --git a/snap-python/source/test/test-356-getei.py b/snap-python/source/test/test-356-getei.py new file mode 100644 index 0000000000000000000000000000000000000000..01876fa0573f177a3d46f8f8cfdd8a019695d623 --- /dev/null +++ b/snap-python/source/test/test-356-getei.py @@ -0,0 +1,19 @@ +import snap +Graph = snap.GenFull(snap.PNEANet, 10) +Src = 1 +Dst = 2 +EI = Graph.GetEI(Src,Dst) +EId = EI.GetId() +print(EId, Graph.GetEI(Src,Dst).GetId()) +print(Graph.GetEI(Src,Dst).GetSrcNId(), Graph.GetEI(Src,Dst).GetDstNId()) +print(Graph.GetEI(EId).GetSrcNId(), Graph.GetEI(EId).GetDstNId()) + +if EId != Graph.GetEI(Src,Dst).GetId(): + print("*** error1") + +if Graph.GetEI(Src,Dst).GetSrcNId() != Graph.GetEI(EId).GetSrcNId(): + print("*** error2") + +if Graph.GetEI(Src,Dst).GetDstNId() != Graph.GetEI(EId).GetDstNId(): + print("*** error3") + diff --git a/snap-python/source/test/test-374-addstrattrdate.py b/snap-python/source/test/test-374-addstrattrdate.py new file mode 100644 index 0000000000000000000000000000000000000000..2fe530d474769ee154e20f01d88ad07e5fb76142 --- /dev/null +++ b/snap-python/source/test/test-374-addstrattrdate.py @@ -0,0 +1,16 @@ +import snap + +G1 = snap.GenFull(snap.PNEANet, 5) + +G1.AddStrAttrE("sign1") + +for EI in G1.Edges(): + EId = G1.GetEId(EI.GetSrcNId(),EI.GetDstNId()) + G1.AddStrAttrDatE(EId,"+",'sign1') + +G1.AddStrAttrE("sign2") + +# why it works with edge_Id, but does not work with edge +for EI in G1.Edges(): + G1.AddStrAttrDatE(EI,"+",'sign2') + diff --git a/snap-python/source/test/test-384-deledge.py b/snap-python/source/test/test-384-deledge.py new file mode 100644 index 0000000000000000000000000000000000000000..87904621061f6596517d461b03de09ad74eb461b --- /dev/null +++ b/snap-python/source/test/test-384-deledge.py @@ -0,0 +1,13 @@ +import snap + +net = snap.TNEANet.New() +net.AddNode(0) +net.AddNode(1) +net.AddEdge(0,1) + +net.AddStrAttrE('name') +#for edge in net.Edges(): +# net.AddStrAttrDatE(edge.GetId(),'01','name') + +net.DelEdge(0,1) + diff --git a/snap-python/source/test/test-509-load.py b/snap-python/source/test/test-509-load.py new file mode 100644 index 0000000000000000000000000000000000000000..b8d0008897b409f23990a291bb31a4c3685214fa --- /dev/null +++ b/snap-python/source/test/test-509-load.py @@ -0,0 +1,12 @@ +import snap + +print("LoadEdgeListStr 1") +G1 = snap.LoadEdgeListStr(snap.PUNGraph, "data/test-509.txt", 0, 1) +print("nodes %d, edges %d" % (G1.GetNodes(), G1.GetEdges())) + +print("LoadEdgeListStr 2") +#mapping = snap.TStrIntH() +mapping = snap.TStrIntSH() +G2 = snap.LoadEdgeListStr(snap.PUNGraph, "data/test-509.txt", 0, 1, mapping) +print("nodes %d, edges %d" % (G2.GetNodes(), G2.GetEdges())) + diff --git a/snap-python/source/test/test-582-getnodewcc.py b/snap-python/source/test/test-582-getnodewcc.py new file mode 100644 index 0000000000000000000000000000000000000000..8f10dc990157cb27615e4d5d08c669d0c0eb01ee --- /dev/null +++ b/snap-python/source/test/test-582-getnodewcc.py @@ -0,0 +1,9 @@ +import snap + +Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) +CnCom = snap.TIntV() +snap.GetNodeWcc(Graph, 0, CnCom) +print("Nodes in the same connected component as node 0:") +for node in CnCom: + print(node) + diff --git a/snap-python/source/test/test-585-genrndpowerlaw.py b/snap-python/source/test/test-585-genrndpowerlaw.py new file mode 100644 index 0000000000000000000000000000000000000000..c138c8abd5873e69510d34b7ce594912648d1565 --- /dev/null +++ b/snap-python/source/test/test-585-genrndpowerlaw.py @@ -0,0 +1,4 @@ +import snap + +G = snap.GenRndPowerLaw(1000, 13.74, True) + diff --git a/snap-python/source/test/test-613-getbfstree.py b/snap-python/source/test/test-613-getbfstree.py new file mode 100644 index 0000000000000000000000000000000000000000..a0519b8f076f41bee05fec76bba603af40e67375 --- /dev/null +++ b/snap-python/source/test/test-613-getbfstree.py @@ -0,0 +1,21 @@ +import snap + +G = snap.TNGraph.New() +for i in range(4): + xxx = G.AddNode(i) + +xxx = G.AddEdge(0,1); xxx = G.AddEdge(0,2) +xxx = G.AddEdge(1,3); xxx = G.AddEdge(2,3) + + +T = snap.GetBfsTree(G, 0, True, True) + +#T = snap.GetBfsTree(G, 0, True, False) # same result + +#T = snap.GetBfsTree(G, 0, False, True) # node 0 only, no edges + +#T = snap.GetBfsTree(G, 0, False, False) # node 0 only, no edges + +for e in T.Edges(): + print(e.GetSrcNId(), e.GetDstNId()) + diff --git a/snap-python/source/test/test-GetBetweennessCentr.py b/snap-python/source/test/test-GetBetweennessCentr.py new file mode 100644 index 0000000000000000000000000000000000000000..7f6e5a2764ddc88181c95264a074baf6afa327e9 --- /dev/null +++ b/snap-python/source/test/test-GetBetweennessCentr.py @@ -0,0 +1,30 @@ +import snap + +Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) +Nodes = snap.TIntFltH() +Edges = snap.TIntPrFltH() +snap.GetBetweennessCentr(Graph, Nodes, Edges, 1.0) +for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) +for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + +UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) +Nodes = snap.TIntFltH() +Edges = snap.TIntPrFltH() +snap.GetBetweennessCentr(UGraph, Nodes, Edges, 1.0) +for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) +for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + +Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) +Nodes = snap.TIntFltH() +Edges = snap.TIntPrFltH() +snap.GetBetweennessCentr(Network, Nodes, Edges, 1.0) +for node in Nodes: + print("node: %d centrality: %f" % (node, Nodes[node])) +for edge in Edges: + print("edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])) + + diff --git a/snap-python/source/test/test-GetClosenessCentr.py b/snap-python/source/test/test-GetClosenessCentr.py new file mode 100644 index 0000000000000000000000000000000000000000..f5d9e15bd373f66a25a75aabdcc292e27eb8fb77 --- /dev/null +++ b/snap-python/source/test/test-GetClosenessCentr.py @@ -0,0 +1,17 @@ +import snap + +Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) +for NI in Graph.Nodes(): + CloseCentr = snap.GetClosenessCentr(Graph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) + +UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) +for NI in UGraph.Nodes(): + CloseCentr = snap.GetClosenessCentr(UGraph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) + +Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) +for NI in Network.Nodes(): + CloseCentr = snap.GetClosenessCentr(Network, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), CloseCentr)) + diff --git a/snap-python/source/test/test-GetFarnessCentr.py b/snap-python/source/test/test-GetFarnessCentr.py new file mode 100644 index 0000000000000000000000000000000000000000..d61fba2eb9b13cbe1d993ad177cd51f470bf357e --- /dev/null +++ b/snap-python/source/test/test-GetFarnessCentr.py @@ -0,0 +1,17 @@ +import snap + +Graph = snap.GenRndGnm(snap.PNGraph, 100, 1000) +for NI in Graph.Nodes(): + FarCentr = snap.GetFarnessCentr(Graph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + +UGraph = snap.GenRndGnm(snap.PUNGraph, 100, 1000) +for NI in UGraph.Nodes(): + FarCentr = snap.GetFarnessCentr(UGraph, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + +Network = snap.GenRndGnm(snap.PNEANet, 100, 1000) +for NI in Network.Nodes(): + FarCentr = snap.GetFarnessCentr(Network, NI.GetId()) + print("node: %d centrality: %f" % (NI.GetId(), FarCentr)) + diff --git a/snap-python/source/test/test-THashKeyDatI.py b/snap-python/source/test/test-THashKeyDatI.py new file mode 100644 index 0000000000000000000000000000000000000000..60dde71439ffe4a1910361b0fc4c684f5a443a5c --- /dev/null +++ b/snap-python/source/test/test-THashKeyDatI.py @@ -0,0 +1,11 @@ +import snap +#h1 = snap.TIntH() +h1 = snap.TIntStrH() +for i in range(500): + h1[i] = "a" + +it = h1.BegI() +while not it.IsEnd(): + print(it.GetKey(), it.GetDat()) + it.Next() + diff --git a/snap-python/source/test/test-emptystr.py b/snap-python/source/test/test-emptystr.py new file mode 100644 index 0000000000000000000000000000000000000000..adec41f607d11fa7763505000fb04c656e923f0e --- /dev/null +++ b/snap-python/source/test/test-emptystr.py @@ -0,0 +1,16 @@ +import snap +G = snap.LoadEdgeList(snap.PNGraph, 'wiki-Vote.txt', 0, 1) + +print(" 1 ----------") +snap.PrintInfo(G, "a") +print(" 2 ----------") +snap.PrintInfo(G, "a", "file.txt") +print(" 3 ----------") +snap.PrintInfo(G, "a", "file.txt", False) + +print(" 4 ----------") +snap.PrintInfo(G, "a", "") + +#print(" 5 ----------") +#snap.PrintInfo(G, "a", "", False) + diff --git a/snap-python/source/test/test-girvan-newman.py b/snap-python/source/test/test-girvan-newman.py new file mode 100644 index 0000000000000000000000000000000000000000..f98a4008fbc3aef0011f163d66ce02f86fd224c0 --- /dev/null +++ b/snap-python/source/test/test-girvan-newman.py @@ -0,0 +1,29 @@ +import sys +import unittest + +import snap + +class TestCommunityGirvanNeuman(unittest.TestCase): + + def test_CommunityGirvanNewman(self): + + Rnd = snap.TRnd(42) + Graph = snap.GenPrefAttach(100, 10, Rnd) + exp_val = 0.00963802805072646 + + Vec = snap.TCnComV() + act_val = snap.CommunityGirvanNewman(Graph, Vec) + self.assertAlmostEqual(exp_val, act_val) + + Vec = snap.TCnComV() + act_val = snap.CommunityGirvanNewman(Graph, Vec) + self.assertAlmostEqual(exp_val, act_val) + + Vec = snap.TCnComV() + act_val = snap.CommunityGirvanNewman(Graph, Vec) + self.assertAlmostEqual(exp_val, act_val) + +if __name__ == '__main__': + + unittest.main() + diff --git a/snap-python/source/test/test-gnuplot.py b/snap-python/source/test/test-gnuplot.py new file mode 100644 index 0000000000000000000000000000000000000000..a5640b25851407adcd89a93d9125c793e08d61df --- /dev/null +++ b/snap-python/source/test/test-gnuplot.py @@ -0,0 +1,5 @@ +import snap + +G = snap.GenPrefAttach(100000, 3) +snap.PlotInDegDistr(G, "pref-attach", "PrefAttach(100000, 3) in Degree") + diff --git a/snap-python/source/test/test-graphviz.py b/snap-python/source/test/test-graphviz.py new file mode 100644 index 0000000000000000000000000000000000000000..37a62e330013f2804c6fb317c34564acaa7a9fd5 --- /dev/null +++ b/snap-python/source/test/test-graphviz.py @@ -0,0 +1,5 @@ +import snap + +G = snap.GenGrid(snap.PUNGraph, 5, 3) +snap.DrawGViz(G, snap.gvlDot, "grid5x3.png", "Grid 5x3") + diff --git a/snap-python/source/test/test-io.py b/snap-python/source/test/test-io.py new file mode 100644 index 0000000000000000000000000000000000000000..5624250e0491c10c38d09402720c7b75c64b53a6 --- /dev/null +++ b/snap-python/source/test/test-io.py @@ -0,0 +1,89 @@ +import random +import unittest + +import snap + +class TestSequenceFunctions(unittest.TestCase): + + def setUp(self): + self.nodes = 100 + self.edges = 1000 + + # list graph types to test + self.gtypes = [ snap.PUNGraph, snap.PNGraph, snap.PNEANet ] + + def test_graph(self): + for gtype in self.gtypes: + # create the graph + G1 = snap.GenRndGnm(gtype, self.nodes, self.edges) + self.ioproc(G1) + + def ioproc(self, G1): + # save the graph in binary + FOut = snap.TFOut("test.graph") + G1.Save(FOut) + FOut.Flush() + + # load the graph in binary + FIn = snap.TFIn("test.graph") + if type(G1) == snap.PUNGraph: + G2 = snap.TUNGraph.Load(FIn) + elif type(G1) == snap.PNGraph: + G2 = snap.TNGraph.Load(FIn) + elif type(G1) == snap.PNEANet: + G2 = snap.TNEANet.Load(FIn) + + self.compare(G1, G2) + + # save the graph in text + snap.SaveEdgeList(G2, "test.txt", "Save as tab-separated list of edges") + + # load the graph in text + G3 = snap.LoadEdgeList(type(G1), "test.txt", 0, 1) + + self.compare(G1, G3) + + def compare(self, G1, G2): + # test the number of nodes and edges + self.assertEqual(G1.GetNodes(), G2.GetNodes()) + self.assertEqual(G1.GetEdges(), G2.GetEdges()) + + # test the number nodes + g1nodes = [ NI.GetId() for NI in G1.Nodes() ] + g2nodes = [ NI.GetId() for NI in G2.Nodes() ] + self.assertEqual(len(g1nodes), len(g2nodes)) + + g1nodes.sort() + g2nodes.sort() + + for p in zip(g1nodes, g2nodes): + # test node ids + self.assertEqual(p[0], p[1]) + + # test out-neighbors + NI1 = G1.GetNI(p[0]) + g1nbrs = [ e for e in NI1.GetOutEdges() ] + NI2 = G2.GetNI(p[1]) + g2nbrs = [ e for e in NI2.GetOutEdges() ] + + g1nbrs.sort() + g2nbrs.sort() + + for p1 in zip(g1nbrs, g2nbrs): + self.assertEqual(p1[0], p1[1]) + + # test in-neighbors + NI1 = G1.GetNI(p[0]) + g1nbrs = [ e for e in NI1.GetInEdges() ] + NI2 = G2.GetNI(p[1]) + g2nbrs = [ e for e in NI2.GetInEdges() ] + + g1nbrs.sort() + g2nbrs.sort() + + for p1 in zip(g1nbrs, g2nbrs): + self.assertEqual(p1[0], p1[1]) + +if __name__ == '__main__': + unittest.main() + diff --git a/snap-python/source/test/test-node2vec.py b/snap-python/source/test/test-node2vec.py new file mode 100644 index 0000000000000000000000000000000000000000..f90e3374fb1deace0e95560aaecd1fe27b385b03 --- /dev/null +++ b/snap-python/source/test/test-node2vec.py @@ -0,0 +1,9 @@ +import snap + +# get wiki-Vote.txt from http://snap.stanford.edu/data/wiki-Vote.html +G5 = snap.LoadEdgeList(snap.PNGraph,"wiki-Vote.txt",0,1) + +hv = snap.TIntFltVH() + +snap.node2vec(G5, 1.0, 1.0, 128, 80, 10, 10, 1, False, hv) + diff --git a/snap-python/source/test/test-pajek.py b/snap-python/source/test/test-pajek.py new file mode 100644 index 0000000000000000000000000000000000000000..f77d8218876214963586104c83b5517adbfe45b0 --- /dev/null +++ b/snap-python/source/test/test-pajek.py @@ -0,0 +1,66 @@ +import os +import sys + +import snap + +filename = "example.paj" + +output = open(filename, "w") +output.write("""*Vertices 9 + 1 "1" 0.3034 0.7561 + 2 "2" 0.4565 0.6039 + 3 "3" 0.4887 0.8188 +*Arcs + 1 2 1 + 1 3 1 + 2 3 1 +""") +output.close() + +print("Directed graph") +Graph = snap.LoadPajek(snap.PNGraph, filename) + +print("Nodes", Graph.GetNodes()) +if Graph.GetNodes() != 3: + print("*** Error11") +for NI in Graph.Nodes(): + print("Node", NI.GetId()) + +print("Edges", Graph.GetEdges()) +if Graph.GetEdges() != 3: + print("*** Error12") +for EI in Graph.Edges(): + print("Edge", EI.GetSrcNId(), EI.GetDstNId()) + +print("Undirected graph") +UGraph = snap.LoadPajek(snap.PUNGraph, filename) + +print("Nodes", UGraph.GetNodes()) +if UGraph.GetNodes() != 3: + print("*** Error21") +for NI in UGraph.Nodes(): + print("Node", NI.GetId()) + +print("Edges", UGraph.GetEdges()) +if UGraph.GetEdges() != 3: + print("*** Error22") +for EI in UGraph.Edges(): + print("Edge", EI.GetSrcNId(), EI.GetDstNId()) + +print("Directed multigraph") +Network = snap.LoadPajek(snap.PNEANet, filename) + +print("Nodes", Network.GetNodes()) +if Network.GetNodes() != 3: + print("*** Error31") +for NI in Network.Nodes(): + print("Node", NI.GetId()) + +print("Edges", Network.GetEdges()) +if Network.GetEdges() != 3: + print("*** Error32") +for EI in Network.Edges(): + print("Edge", EI.GetSrcNId(), EI.GetDstNId()) + +os.remove(filename) + diff --git a/snap-python/source/test/test-rewire.py b/snap-python/source/test/test-rewire.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb45f3080d6ae19cb7e0ad2689e0dfe9a4fbade --- /dev/null +++ b/snap-python/source/test/test-rewire.py @@ -0,0 +1,12 @@ +import snap + +def rewire(G_in): + G = G_in.ConvertGraph(snap.TUNGraph) + G_rewire = snap.GenRewire(G,1000) + return G_rewire + +G_in = snap.GenFull(snap.TNGraph, 572) +for i in range(500): + G_rewired = rewire(G_in) + print(i, G_rewired.GetNodes(), G_rewired.GetEdges()) + diff --git a/snap-python/source/test/test-snappy.bat b/snap-python/source/test/test-snappy.bat new file mode 100644 index 0000000000000000000000000000000000000000..f4896af798d213c0ebd2fa59c5142678aaff77ff --- /dev/null +++ b/snap-python/source/test/test-snappy.bat @@ -0,0 +1,34 @@ +rem test script for basic Snap.py functionality on Windows +rem +rem input file requirements, files are in "data" +rem p2p-Gnutella08.txt + +python quick_test.py +python cncom.py +python intro.py +python tutorial.py +python tneanet.py +python bfs.py +python attributes.py +python test-tnodei.py +python test-io.py +python test-131-setiter.py +python test-346-getei.py +python test-356-getei.py +python test-374-addstrattrdate.py +python test-384-deledge.py +python test-509-load.py +python test-582-getnodewcc.py +python test-585-genrndpowerlaw.py +python test-613-getbfstree.py +python test-vec-ops.py +python test-2015-18a-attr.py +python test-20160801-LoadConnListStr.py +python test-GetBetweennessCentr.py +python test-GetClosenessCentr.py +python test-GetFarnessCentr.py +python test-pajek.py +python test-girvan-newman.py +python snap-test.py +python snap-test-pylayer.py + diff --git a/snap-python/source/test/test-snappy.sh b/snap-python/source/test/test-snappy.sh new file mode 100644 index 0000000000000000000000000000000000000000..e7595b80a1ba2a4dc3f0d50d989b85ce768acc53 --- /dev/null +++ b/snap-python/source/test/test-snappy.sh @@ -0,0 +1,51 @@ +#!/bin/bash + +# +# test script for basic Snap.py functionality +# +# input file requirements, files are in "data" +# p2p-Gnutella08.txt +# + +# TODO +# bug-328-cnm.py +# bug-585-genrndpowerlaw.py +# bug-20150706-pagerank.py +# bug-2015-18.py +# bug-2015-130.py +# bug-GetClosenessCentr.py +scripts=(quick_test.py \ + cncom.py intro.py tutorial.py tneanet.py bfs.py attributes.py \ + test-tnodei.py test-io.py \ + test-131-setiter.py \ + test-346-getei.py \ + test-356-getei.py \ + test-374-addstrattrdate.py \ + test-384-deledge.py \ + test-509-load.py \ + test-582-getnodewcc.py \ + test-585-genrndpowerlaw.py \ + test-613-getbfstree.py \ + test-vec-ops.py \ + test-2015-18a-attr.py \ + test-20160801-LoadConnListStr.py \ + test-20180416-table.py \ + attrtest.py \ + test-GetBetweennessCentr.py \ + test-GetClosenessCentr.py \ + test-GetFarnessCentr.py \ + test-pajek.py \ + test-girvan-newman.py \ + snap-test.py \ + snap-test-pylayer.py) + +for line in "${scripts[@]}"; do + echo "***" `date` "$line ..." + python $line + RETVAL=$? + if [ $RETVAL -ne 0 ]; then + echo "***" `date` "ERROR: $line" + exit $RETVAL + fi; +done + diff --git a/snap-python/source/test/test-snappy3.sh b/snap-python/source/test/test-snappy3.sh new file mode 100644 index 0000000000000000000000000000000000000000..ba4ba9f9dd66f244ac83fec993d099d00225c4f7 --- /dev/null +++ b/snap-python/source/test/test-snappy3.sh @@ -0,0 +1,48 @@ +#!/bin/bash + + # +# test script for basic Snap.py functionality +# +# input file requirements, files are in "data" +# p2p-Gnutella08.txt +# + + # TODO +# bug-328-cnm.py +# bug-585-genrndpowerlaw.py +# bug-20150706-pagerank.py +# bug-2015-18.py +# bug-2015-130.py +# bug-GetClosenessCentr.py +scripts=(quick_test.py \ + cncom.py intro.py tutorial.py tneanet.py bfs.py attributes.py \ + test-tnodei.py test-io.py \ + test-131-setiter.py \ + test-346-getei.py \ + test-356-getei.py \ + test-374-addstrattrdate.py \ + test-384-deledge.py \ + test-509-load.py \ + test-582-getnodewcc.py \ + test-585-genrndpowerlaw.py \ + test-613-getbfstree.py \ + test-vec-ops.py \ + test-2015-18a-attr.py \ + test-20160801-LoadConnListStr.py \ + test-GetBetweennessCentr.py \ + test-GetClosenessCentr.py \ + test-GetFarnessCentr.py \ + test-pajek.py \ + test-girvan-newman.py \ + snap-test.py \ + snap-test-pylayer.py) + + for line in "${scripts[@]}"; do + echo "***" `date` "$line ..." + python3 $line + RETVAL=$? + if [ $RETVAL -ne 0 ]; then + echo "***" `date` "ERROR: $line" + exit $RETVAL + fi; +done diff --git a/snap-python/source/test/test-table.py b/snap-python/source/test/test-table.py new file mode 100644 index 0000000000000000000000000000000000000000..d5dc8c4f486d5cf4276b4d52fd315f89aef00555 --- /dev/null +++ b/snap-python/source/test/test-table.py @@ -0,0 +1,52 @@ +import snap + +edgefilename = "imdb_actor_edges.tsv" +nodefilename = "imdb_actors_key.tsv" +context = snap.TTableContext() + +edgeschema = snap.Schema() +edgeschema.Add(snap.TStrTAttrPr("srcID", snap.atStr)) +edgeschema.Add(snap.TStrTAttrPr("dstID", snap.atStr)) +edgeschema.Add(snap.TStrTAttrPr("edgeattr1", snap.atStr)) + +nodeschema = snap.Schema() +nodeschema.Add(snap.TStrTAttrPr("nodeID", snap.atStr)) +nodeschema.Add(snap.TStrTAttrPr("name", snap.atStr)) +nodeschema.Add(snap.TStrTAttrPr("movies", snap.atStr)) +nodeschema.Add(snap.TStrTAttrPr("main_genre", snap.atStr)) +nodeschema.Add(snap.TStrTAttrPr("genres", snap.atStr)) + +edge_table = snap.TTable.LoadSS(edgeschema, edgefilename, context, "\t", snap.TBool(False)) +print("edge_rows", edge_table.GetNumValidRows()) + +node_table = snap.TTable.LoadSS(nodeschema, nodefilename, context, "\t", snap.TBool(False)) +print("node_rows", node_table.GetNumValidRows()) + +srcattrv = snap.TStrV() +srcattrv.Add("edgeattr1") + +dstattrv = snap.TStrV() +dstattrv.Add("edgeattr1") + +edgeattrv = snap.TStrV() +edgeattrv.Add("edgeattr1") + +nodeattrv = snap.TStrV() +nodeattrv.Add("name") + +net1 = snap.ToNetwork(snap.PNEANet, edge_table, "srcID", "dstID", srcattrv, dstattrv, edgeattrv, snap.aaFirst) +print("nodes1", net1.GetNodes()) +print("edges1", net1.GetEdges()) + +net2 = snap.ToNetwork(snap.PNEANet, edge_table, "srcID", "dstID", snap.aaFirst) +print("nodes2", net2.GetNodes()) +print("edges2", net2.GetEdges()) + +net3 = snap.ToNetwork(snap.PNEANet, edge_table, "srcID", "dstID", edgeattrv, snap.aaFirst) +print("nodes3", net3.GetNodes()) +print("edges3", net3.GetEdges()) + +net4 = snap.ToNetwork(snap.PNEANet, edge_table, "srcID", "dstID", edgeattrv, node_table, "nodeID", nodeattrv, snap.aaFirst) +print("nodes4", net4.GetNodes()) +print("edges4", net4.GetEdges()) + diff --git a/snap-python/source/test/test-tnodei.py b/snap-python/source/test/test-tnodei.py new file mode 100644 index 0000000000000000000000000000000000000000..199afb541783edfe35df50ecc3c856745588dcad --- /dev/null +++ b/snap-python/source/test/test-tnodei.py @@ -0,0 +1,64 @@ +import random +import unittest + +import snap + +class TestSequenceFunctions(unittest.TestCase): + + def setUp(self): + self.nodes = 100 + self.edges = 1000 + + # list graph types to test + self.gtypes = [ snap.PUNGraph, snap.PNGraph, snap.PNEANet ] + + def test_graph(self): + for gtype in self.gtypes: + # create the graph + G1 = snap.GenRndGnm(gtype, self.nodes, self.edges) + self.graph(G1) + self.nodei(G1) + + def graph(self, G): + # verify the number of nodes and edges + self.assertEqual(self.nodes, G.GetNodes()) + self.assertEqual(self.edges, G.GetEdges()) + + # test node iterator + count = 0 + for NI in G.Nodes(): + count += 1 + self.assertEqual(self.nodes, count) + + # test edge iterator + count = 0 + for EI in G.Edges(): + count += 1 + self.assertEqual(self.edges, count) + + def nodei(self, G): + + for NI in G.Nodes(): + # get out and in neighbors + olist = [e for e in NI.GetOutEdges()] + ilist = [e for e in NI.GetInEdges()] + + # test number of neighbors + self.assertEqual(NI.GetOutDeg(), len(olist)) + self.assertEqual(NI.GetInDeg(), len(ilist)) + + # test neighbor access + for i in range(0, NI.GetOutDeg()): + self.assertEqual(olist[i], NI.GetOutNId(i)) + for i in range(0, NI.GetInDeg()): + self.assertEqual(ilist[i], NI.GetInNId(i)) + + # test neighbor validation + for i in range(0,self.nodes): + self.assertEqual(i in olist, NI.IsOutNId(i)) + self.assertEqual(i in ilist, NI.IsInNId(i)) + self.assertEqual((i in ilist) or (i in olist), NI.IsNbrNId(i)) + +if __name__ == '__main__': + unittest.main() + diff --git a/snap-python/source/test/test-vec-ops.py b/snap-python/source/test/test-vec-ops.py new file mode 100644 index 0000000000000000000000000000000000000000..9bf4ad72af6fe024351d828a49f99b4509b86202 --- /dev/null +++ b/snap-python/source/test/test-vec-ops.py @@ -0,0 +1,69 @@ +import snap + +# first vector +a = snap.TIntV() +a.Add(1) +a.Add(2) +a.Add(3) +a.Add(4) +a.Add(5) +l = [ str(elem) for elem in a] +print("a = ", ", ".join(l)) + +# second vector +b = snap.TIntV() +b.Add(3) +b.Add(4) +b.Add(5) +b.Add(6) +b.Add(7) +l = [ str(elem) for elem in b] +print("b = ", ", ".join(l)) + +# third vector +c = snap.TIntV() +c.Add(6) +c.Add(7) +c.Add(8) +c.Add(9) +l = [ str(elem) for elem in c] +print("c = ", ", ".join(l)) +print() + +# intersection +a.Intrs(b) +l = [ str(elem) for elem in a] +print("a = a^b ", ", ".join(l)) +l = [ str(elem) for elem in b] +print("b = ", ", ".join(l)) +print() + +# union +a.Union(c) +l = [ str(elem) for elem in a] +print("a = avc ", ", ".join(l)) +l = [ str(elem) for elem in c] +print("c = ", ", ".join(l)) +print() + +# intersection +i = snap.TIntV() +a.Intrs(c,i) +l = [ str(elem) for elem in i] +print("i = a^c ", ", ".join(l)) +l = [ str(elem) for elem in a] +print("a = ", ", ".join(l)) +l = [ str(elem) for elem in c] +print("c = ", ", ".join(l)) +print() + +# union +u = snap.TIntV() +b.Union(c,u) +l = [ str(elem) for elem in u] +print("u = bvc ", ", ".join(l)) +l = [ str(elem) for elem in b] +print("b = ", ", ".join(l)) +l = [ str(elem) for elem in c] +print("c = ", ", ".join(l)) + diff --git a/snap-python/source/test/thash.py b/snap-python/source/test/thash.py new file mode 100644 index 0000000000000000000000000000000000000000..6befd09a1b837bb0109ceea38cec8293d62a831b --- /dev/null +++ b/snap-python/source/test/thash.py @@ -0,0 +1,63 @@ +import random +import os +import sys +import time + +import snap + +print("---------- 1 ---------") + +Hash = snap.TIntIntH() + +Hash.AddDat(5,4) +Hash.AddDat(1,2) +Hash.AddDat(4,8) + +Hash[17] = 15 +Hash[11] = 14 +Hash[15] = 18 +#Hash.AddDat(TInt(3),TInt(5)) +#Hash.AddDat(TInt(4),TInt(6)) +#Hash.AddDat(TInt(1),TInt(8)) +#Hash.AddDat(TInt(6),TInt(2)) + +print("len", Hash.Len()) + +Iter = Hash.BegI() +Key = Iter.GetKey() +Value = Iter.GetDat() +print("iter", Key, Value) + +print("Iter < Hash.EndI", Iter < Hash.EndI()) +#while Iter < Hash.EndI(): +while not Iter.IsEnd(): + Key = Iter.GetKey() + Value = Iter.GetDat() + print(Key, Value) + + Iter.Next() + +for item in Hash: + print(item, Hash[item]) + +print("---------- 2 ---------") + +h = snap.TIntStrH() + +h[5] = "five" +h[3] = "thre" +h[9] = "nine" +h[6] = "six" +h[1] = "one" + +print(h.Len()) + +print("h[3] =", h[3]) + +h[3] = "three" + +print("h[3] =", h[3]) + +for item in h: + print(item, h[item]) + diff --git a/snap-python/source/test/titer.py b/snap-python/source/test/titer.py new file mode 100644 index 0000000000000000000000000000000000000000..24d6303461f0673d4fdeb56f0e8921ff3579ba62 --- /dev/null +++ b/snap-python/source/test/titer.py @@ -0,0 +1,233 @@ +import random +import sys +sys.path.append("../swig") +from snap import * + +def PrintGStats(s, Graph, nodes, edges, empty): + ''' + Print graph statistics + ''' + + print("%s graph %s, nodes %d (%d), edges %d (%d), empty %s (%s)" % ( + type(Graph), s, Graph.GetNodes(), nodes, Graph.GetEdges(), edges, + Graph.Empty(), empty)) + + if Graph.GetNodes() != nodes: + print("*** Error: %d %d, incorrect number of nodes" % ( + Graph.GetNodes(), nodes)) + sys.exit(1) + + if Graph.GetEdges() != edges: + print("*** Error: %d %d, incorrect number of edges" % ( + Graph.GetEdges(), edges)) + sys.exit(1) + + if Graph.Empty() != empty: + print("*** Error: %s %s, incorrect empty test" % ( + Graph.Empty(), empty)) + sys.exit(1) + +def GenGraph1(gtype): + ''' + Test node, edge creation + ''' + + NNodes = 12345 + NEdges = 123456 + + if gtype == PNEANet: + # PNEANet + Graph = GenRndGnm(NNodes, NEdges) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + return Graph + + if gtype == PUNGraph: + # PUNGraph + Graph = GenRndGnm_PUNGraph(NNodes, NEdges) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + return Graph + + if gtype == PNGraph: + # PNGraph + #Graph = GenRndGnm_PNGraph(NNodes, NEdges) + Graph = GenRndGnm_PNGraph(NNodes, NEdges) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + return Graph + + return None + +def ManipulateNodesEdges(Graph): + ''' + Test node, edge creation + ''' + + print("4type %s" % (type(Graph))) + print("4nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + Graph.Clr() + print("5nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + NNodes = 12345 + NEdges = 123456 + FName = "test.graph" + + #Graph = TNEANet() + #print("5type %s" % (type(Graph))) + + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1", Graph, NNodes, NEdges, False) + + # get all the nodes + NCount = 0 + for NI in Graph.Nodes(): + NCount += 1 + + # get all the edges for all the nodes + ECount1 = 0 + for NI in Graph.Nodes(): + ECount1 += NI.GetOutDeg() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0 + for EI in Graph.Edges(): + ECount2 += 1 + + print("graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d (%d)"\ + % (NCount, ECount1, ECount2, ECount1*2)) + + # assignment + Graph1 = Graph + PrintGStats("ManipulateNodesEdges:Graph3", Graph1, NNodes, NEdges, False) + + # save the graph + print("graph type = ", type(Graph)) + FOut = TFOut(TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + FIn = TFIn(TStr(FName)) + if type(Graph) == PNEANet: + Graph2 = TNEANet(FIn) + elif type(Graph) == PUNGraph: + Graph2 = TUNGraph(FIn) + elif type(Graph) == PNGraph: + Graph2 = TNGraph(FIn) + PrintGStats("ManipulateNodesEdges:Graph4" , Graph2, NNodes, NEdges, False) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5" , Graph, 0, 0, True) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6" , Graph1, 0, 0, True) + +def NewGraph(): + + print("----- New TUNGraph -----") + Graph = TUNGraph.New() + #Graph = PUNGraph.New() + print("6type %s" % (type(Graph))) + print("connected", IsConnected(Graph)) + #print("connected", IsConnected_PNEANet(Graph)) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 0, 0, True) + + Graph = GenRndGnm(PUNGraph, 23, 234) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + print("connected", IsConnected(Graph)) + print("connected", IsConnected_PUNGraph(Graph)) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 23, 234, False) + for NI in Graph.Nodes(): + print(NI.GetId()) + for EI in Graph.Edges(): + print(EI.GetId()) + +def Main(): + + print("----- PNEANet -----") + Graph = TNEANet.New() + #Graph = PNEANet.New() + print("6type %s" % (type(Graph))) + print("connected", IsConnected(Graph)) + #print("connected", IsConnected_PNEANet(Graph)) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 0, 0, True) + + Graph = GenRndGnm(PNEANet, 23, 234) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + print("connected", IsConnected(Graph)) + print("connected", IsConnected_PNEANet(Graph)) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 23, 234, False) + for NI in Graph.Nodes(): + print(NI.GetId()) + for EI in Graph.Edges(): + print(EI.GetId()) + + print("----- ManipulateNodesEdges -----") + ManipulateNodesEdges(Graph) + + print("----- PUNGraph -----") + Graph = TUNGraph.New() + print("6type %s" % (type(Graph))) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 0, 0, True) + + Graph = GenRndGnm(PUNGraph, 34, 345) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 34, 345, False) + for NI in Graph.Nodes(): + print(NI.GetId()) + for EI in Graph.Edges(): + print(EI.GetId()) + + print("----- ManipulateNodesEdges -----") + ManipulateNodesEdges(Graph) + + print("----- PNGraph -----") + Graph = TNGraph.New() + print("6type %s" % (type(Graph))) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 0, 0, True) + + Graph = GenRndGnm(PNGraph, 45, 456) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + PrintGStats("ManipulateNodesEdges:Graph" , Graph, 45, 456, False) + for NI in Graph.Nodes(): + print(NI.GetId()) + for EI in Graph.Edges(): + print(EI.GetId()) + + print("----- ManipulateNodesEdges -----") + ManipulateNodesEdges(Graph) + +if __name__ == '__main__': + NewGraph() + Main() + diff --git a/snap-python/source/test/tmany.py b/snap-python/source/test/tmany.py new file mode 100644 index 0000000000000000000000000000000000000000..138dbb210552562d957ef9429f22dca88401fabd --- /dev/null +++ b/snap-python/source/test/tmany.py @@ -0,0 +1,183 @@ +import random +import sys +sys.path.append("../swig") +from snap import * + +def PrintGStats(s, Graph): + ''' + Print graph statistics + ''' + + print("graph %s, nodes %d, edges %d, empty %s" % ( + s, Graph.GetNodes(), Graph.GetEdges(), + "yes" if Graph.Empty() else "no")) + +def GenGraph1(gtype): + ''' + Test node, edge creation + ''' + + NNodes = 12345 + NEdges = 123456 + + if gtype == PNEANet: + # PNEANet + Graph = GenRndGnm(NNodes, NEdges) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + return Graph + + if gtype == PUNGraph: + # PUNGraph + Graph = GenRndGnm_PUNGraph(NNodes, NEdges) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + return Graph + + if gtype == PNGraph: + # PNGraph + #Graph = GenRndGnm_PNGraph(NNodes, NEdges) + Graph = GenRndGnm_PNGraph(NNodes, NEdges) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + return Graph + + return None + +def ManipulateNodesEdges(): + ''' + Test node, edge creation + ''' + + NNodes = 12345 + NEdges = 123456 + + FName = "test.graph" + + Graph = TNEANet() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1", Graph) + + # get all the nodes + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + # get all the edges for all the nodes + ECount1 = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + ECount1 += NI.GetOutDeg() + NI.Next() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0 + EI = Graph.BegEI() + while EI < Graph.EndEI(): + ECount2 += 1 + EI.Next() + + print("graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d"\ + % (NCount, ECount1, ECount2)) + + # assignment + Graph1 = Graph + PrintGStats("ManipulateNodesEdges:Graph3", Graph1) + + # save the graph + print("graph type = ", type(Graph)) + FOut = TFOut(TStr(FName)) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + FIn = TFIn(TStr(FName)) + Graph2 = TNEANet(FIn) + PrintGStats("ManipulateNodesEdges:Graph4" , Graph2) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5" , Graph) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6" , Graph1) + +if __name__ == '__main__': + + print("type 1", PNEANet) + p = PNEANet + print("type 2", p) + if p == PNEANet: + print("true snap.PNEANet") + else: + print("false snap.PNEANet") + if p == PNGraph: + print("true snap.PGraph") + else: + print("false snap.PGraph") + + print("type 1", PNGraph) + p = PNGraph + print("type 2", p) + if p == PNEANet: + print("true snap.PNEANet") + else: + print("false snap.PNEANet") + if p == PNGraph: + print("true snap.PGraph") + else: + print("false snap.PGraph") + + print("----- GenGraph -----") + Graph = GenGraph(PNEANet) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + Graph = GenGraph(PUNGraph) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + Graph = GenGraph(PNGraph) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + Graph = GenGraph1(PNEANet) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + Graph = GenGraph1(PUNGraph) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + Graph = GenGraph1(PNGraph) + print("type %s" % (type(Graph))) + print("nodes %d, edges %d" % (Graph.GetNodes(), Graph.GetEdges())) + + #print("----- ManipulateNodesEdges -----") + #ManipulateNodesEdges() + diff --git a/snap-python/source/test/tneanet.py b/snap-python/source/test/tneanet.py new file mode 100644 index 0000000000000000000000000000000000000000..7bd5e36e1d7d509088225a1fe0b5a9537c8c0468 --- /dev/null +++ b/snap-python/source/test/tneanet.py @@ -0,0 +1,869 @@ +import random +import sys + +import snap + +def PrintGStats(s, Graph): + ''' + Print graph statistics + ''' + + print("graph %s, nodes %d, edges %d, empty %s" % ( + s, Graph.GetNodes(), Graph.GetEdges(), + "yes" if Graph.Empty() else "no")) + +def DefaultConstructor(): + ''' + Test the default constructor + ''' + + Graph = snap.TNEANet.New() + PrintGStats("DefaultConstructor:Graph", Graph) + +def ManipulateNodesEdges(): + ''' + Test node, edge creation + ''' + + NNodes = 10000 + NEdges = 100000 + FName = "test.graph" + + Graph = snap.TNEANet.New() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + PrintGStats("ManipulateNodesEdges:Graph1", Graph) + + # get all the nodes + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + # get all the edges for all the nodes + ECount1 = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + ECount1 += NI.GetOutDeg() + NI.Next() + + ECount1 = ECount1 / 2 + + # get all the edges directly + ECount2 = 0 + EI = Graph.BegEI() + while EI < Graph.EndEI(): + ECount2 += 1 + EI.Next() + + print("graph ManipulateNodesEdges:Graph2, nodes %d, edges1 %d, edges2 %d"\ + % (NCount, ECount1, ECount2)) + + # assignment + Graph1 = Graph + PrintGStats("ManipulateNodesEdges:Graph3", Graph1) + + # save the graph + print("graph type = ", type(Graph)) + #FOut = TFOut(TStr(FName)) + FOut = snap.TFOut(FName) + Graph.Save(FOut) + FOut.Flush() + + # load the graph + #FIn = TFIn(TStr(FName)) + FIn = snap.TFIn(FName) + Graph2 = snap.TNEANet(FIn) + PrintGStats("ManipulateNodesEdges:Graph4" , Graph2) + + # remove all the nodes and edges + for i in range(0, NNodes): + n = Graph.GetRndNId() + Graph.DelNode(n) + + PrintGStats("ManipulateNodesEdges:Graph5" , Graph) + + Graph1.Clr() + PrintGStats("ManipulateNodesEdges:Graph6" , Graph1) + +def ManipulateAttributesId(): + ''' + Test node, edge attribute functionality using Ids + ''' + + NNodes = 1000 + NEdges = 1000 + + Graph = snap.TNEANet.New() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + print("Added nodes") + + # create attributes and fill all nodes + #attr1 = TStr("str") + #attr2 = TStr("int") + #attr3 = TStr("float") + #attr4 = TStr("default") + attr1 = "STR" + attr2 = "INT" + attr3 = "FLOAT" + attr4 = "DEFAULT" + + # Test column int iterator for node 3, 50, 700, 900 + # Check if we can set defaults to 0 fordata. + Graph.AddIntAttrN(attr2, 0) + Graph.AddIntAttrDatN(3, 3*2, attr2) + Graph.AddIntAttrDatN(50, 50*2, attr2) + Graph.AddIntAttrDatN(700, 700*2, attr2) + Graph.AddIntAttrDatN(900, 900*2, attr2) + + print("Added attributes") + + NodeId = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + if NI.GetDat() != 0: + print("Attribute1: %s, Node: %i, Val: %d" % (attr2, NodeId, NI.GetDat())) + #print("Attribute: %s, Node: %i, Val: %d" % (attr2(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test column flt iterator for node 3, 50, 700, 900 + Graph.AddFltAttrDatN(5, 3.41, attr3) + Graph.AddFltAttrDatN(50, 2.718, attr3) + Graph.AddFltAttrDatN(300, 150.0, attr3) + + Graph.AddFltAttrDatN(653, 653, attr3) + NodeId = 0 + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + NI = Graph.BegNAFltI(attr3) + NodeId = 0 + while NI < Graph.EndNAFltI(attr3): + if NI.GetDat() != snap.TFlt.Mn: + print("Attribute2: %s, Node: %i, Val: %f" % (attr3, NodeId, NI.GetDat())) + #print("Attribute: %s, Node: %i, Val: %f" % (attr3(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test column str iterator for node 3, 50, 700, 900 + #Graph.AddStrAttrDatN(10, TStr("abc"), attr1) + #Graph.AddStrAttrDatN(20, TStr("def"), attr1) + #Graph.AddStrAttrDatN(400, TStr("ghi"), attr1) + Graph.AddStrAttrDatN(10, "abc", attr1) + Graph.AddStrAttrDatN(20, "def", attr1) + Graph.AddStrAttrDatN(400, "ghi", attr1) + # this does not show since ""=null + #Graph.AddStrAttrDatN(455, TStr(""), attr1) + # TODO Graph.AddStrAttrDatN(455, "", attr1) + NodeId = 0 + + NI = Graph.BegNAStrI(attr1) + NodeId = 0 + while NI < Graph.EndNAStrI(attr1): + if NI.GetDat() != snap.TStr.GetNullStr(): + print("Attribute3: %s, Node: %i, Val: %s" % (attr1, NodeId, NI.GetDat())) + #print("Attribute: %s, Node: %i, Val: %s" % (attr1(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test column iterator over many types (must skip default/deleted attr) + NId = 55 + #Graph.AddStrAttrDatN(NId, TStr("aaa"), attr1) + Graph.AddStrAttrDatN(NId, "aaa", attr1) + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.AddFltAttrDatN(NId, 3.41, attr3) + #Graph.AddStrAttrDatN(80, TStr("dont appear"), attr4) # should not show up + Graph.AddStrAttrDatN(80, "dont appear", attr4) # should not show up + + attr1idx = Graph.GetAttrIndN(attr1) + attr2idx = Graph.GetAttrIndN(attr2) + attr3idx = Graph.GetAttrIndN(attr3) + attr4idx = Graph.GetAttrIndN(attr4) + print("Node attribute indexes: %s %d, %s %d, %s %d, %s %d" % ( + attr1, attr1idx, attr2, attr2idx, attr3, attr3idx, attr4, attr4idx)) + + print("NId attributes: %i, %s %d %.2f" % ( + NId, + Graph.GetStrAttrDatN(NId, attr1), + Graph.GetIntAttrDatN(NId, attr2), + Graph.GetFltAttrDatN(NId, attr3))) + + print("ind attributes: %i, %s %d %.2f" % ( + NId, + Graph.GetStrAttrIndDatN(NId, attr1idx), + Graph.GetIntAttrIndDatN(NId, attr2idx), + Graph.GetFltAttrIndDatN(NId, attr3idx))) + + NIdAttrName = snap.TStrV() + NIdAttrValue = snap.TStrV() + NIdIntAttrValue = snap.TIntV() + NIdFltAttrValue = snap.TFltV() + NIdStrAttrValue = snap.TStrV() + + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node1: %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.IntAttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node11 (int): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.FltAttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node12 (flt): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.StrAttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node13 (str): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.IntAttrValueNI(NId, NIdIntAttrValue) + AttrLen = NIdIntAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node14 (int): %i, Attr_Val: %d" % (NId, NIdIntAttrValue.GetI(i)())) + + Graph.FltAttrValueNI(NId, NIdFltAttrValue) + AttrLen = NIdFltAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node15 (flt): %i, Attr_Val: %.2f" % (NId, NIdFltAttrValue.GetI(i)())) + + Graph.StrAttrValueNI(NId, NIdStrAttrValue) + AttrLen = NIdStrAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node16 (str): %i, Attr_Val: %s" % (NId, NIdStrAttrValue.GetI(i)())) + + print("DeletedN: %i, Attr: %s, %s" % (NId, attr1, Graph.IsAttrDeletedN(NId, attr1))) + print("DeletedN: %i, Attr: %s, %s" % (NId, attr2, Graph.IsAttrDeletedN(NId, attr2))) + print("DeletedN: %i, Attr: %s, %s" % (NId, attr3, Graph.IsAttrDeletedN(NId, attr3))) + print("DeletedN: %i, Attr: %s, %s" % (NId, attr4, Graph.IsAttrDeletedN(NId, attr4))) + print("DeletedN (str): %i, Attr: %s, %s" % (NId, attr1, Graph.IsStrAttrDeletedN(NId, attr1))) + print("DeletedN (int): %i, Attr: %s, %s" % (NId, attr2, Graph.IsIntAttrDeletedN(NId, attr2))) + print("DeletedN (flt): %i, Attr: %s, %s" % (NId, attr3, Graph.IsFltAttrDeletedN(NId, attr3))) + print("DeletedN (str): %i, Attr: %s, %s" % (NId, attr4, Graph.IsStrAttrDeletedN(NId, attr4))) + print("DeletedN (int): %i, Attr: %s, %s" % (NId, attr4, Graph.IsIntAttrDeletedN(NId, attr4))) + print("DeletedN (flt): %i, Attr: %s, %s" % (NId, attr4, Graph.IsFltAttrDeletedN(NId, attr4))) + + Graph.DelAttrDatN(NId, attr2) + print("DeletedN: %i, Attr: %s, %s" % (NId, attr2, Graph.IsAttrDeletedN(NId, attr2))) + print("DeletedN (int): %i, Attr: %s, %s" % (NId, attr2, Graph.IsIntAttrDeletedN(NId, attr2))) + + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node2 (no int): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.DelAttrN(attr1) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node3 (no str): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.AttrValueNI(NId, NIdAttrValue) + AttrLen = NIdAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node4 (no str): %i, Attr_Val: %s" % (NId, NIdAttrValue.GetI(i)())) + + for i in range(NNodes): + Graph.AddIntAttrDatN(i, 70, attr2) + + total = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + total += NI.GetDat() + NI.Next() + + print("Average: %i (should be 70)" % (total/NNodes)) + if total/NNodes != 70: + print("*** Error1") + + # Test column iterator for edge + Graph.AddIntAttrDatE(3, 3*2, attr2) + Graph.AddIntAttrDatE(55, 55*2, attr2) + Graph.AddIntAttrDatE(705, 705*2, attr2) + Graph.AddIntAttrDatE(905, 905*2, attr2) + EdgeId = 0 + EI = Graph.BegEAIntI(attr2) + while EI < Graph.EndEAIntI(attr2): + if EI.GetDat() != snap.TInt.Mn: + print("E Attribute1: %s, Edge: %i, Val: %i" % ( + attr2, EdgeId, EI.GetDat())) + #% (attr2(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test column flt iterator for edge + Graph.AddFltAttrE(attr3, 0.00) + Graph.AddFltAttrDatE(5, 4.41, attr3) + Graph.AddFltAttrDatE(50, 3.718, attr3) + Graph.AddFltAttrDatE(300, 151.0, attr3) + Graph.AddFltAttrDatE(653, 654, attr3) + EdgeId = 0 + EI = Graph.BegEAFltI(attr3) + while EI < Graph.EndEAFltI(attr3): + # Check if defaults are set to 0. + if EI.GetDat() != 0: + print("E Attribute2: %s, Edge: %i, Val: %f" % ( + attr3, EdgeId, EI.GetDat())) + #(attr3(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test column str iterator for edge + #Graph.AddStrAttrDatE(10, TStr("abc"), attr1) + #Graph.AddStrAttrDatE(20, TStr("def"), attr1) + #Graph.AddStrAttrDatE(400, TStr("ghi"), attr1) + Graph.AddStrAttrDatE(10, "abc", attr1) + Graph.AddStrAttrDatE(20, "def", attr1) + Graph.AddStrAttrDatE(400, "ghi", attr1) + # this does not show since ""=null + #Graph.AddStrAttrDatE(455, TStr(""), attr1) + # TODO Graph.AddStrAttrDatE(455, "", attr1) + EdgeId = 0 + EI = Graph.BegEAStrI(attr1) + while EI < Graph.EndEAStrI(attr1): + if EI.GetDat() != snap.TStr.GetNullStr(): + print("E Attribute3: %s, Edge: %i, Val: %s" % ( + attr1, EdgeId, EI.GetDat())) + #(attr1(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test column iterator over many types (must skip default/deleted attr) + EId = 55 + #Graph.AddStrAttrDatE(EId, TStr("aaa"), attr1) + Graph.AddStrAttrDatE(EId, "aaa", attr1) + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.AddFltAttrDatE(EId, 3.41, attr3) + #Graph.AddStrAttrDatE(80, TStr("dont appear"), attr4) # should not show up + Graph.AddStrAttrDatE(80, "dont appear", attr4) # should not show up + + attr1idx = Graph.GetAttrIndE(attr1) + attr2idx = Graph.GetAttrIndE(attr2) + attr3idx = Graph.GetAttrIndE(attr3) + attr4idx = Graph.GetAttrIndE(attr4) + print("Edge attribute indexes: %s %d, %s %d, %s %d, %s %d" % ( + attr1, attr1idx, attr2, attr2idx, attr3, attr3idx, attr4, attr4idx)) + + print("EId attributes: %i, %s %d %.2f" % ( + EId, + Graph.GetStrAttrDatE(EId, attr1), + Graph.GetIntAttrDatE(EId, attr2), + Graph.GetFltAttrDatE(EId, attr3))) + + print("ind attributes: %i, %s %d %.2f" % ( + EId, + Graph.GetStrAttrIndDatE(EId, attr1idx), + Graph.GetIntAttrIndDatE(EId, attr2idx), + Graph.GetFltAttrIndDatE(EId, attr3idx))) + + EIdAttrName = snap.TStrV() + EIdAttrValue = snap.TStrV() + EIdIntAttrValue = snap.TIntV() + EIdFltAttrValue = snap.TFltV() + EIdStrAttrValue = snap.TStrV() + + EdgeId = 0 + EI = Graph.BegEAIntI(attr2) + while EI < Graph.EndEAIntI(attr2): + if EI.GetDat() != snap.TInt.Mn: + print("E Attribute1: %s, Edge: %i, Val: %i" % ( + attr2, EdgeId, EI.GetDat())) + #% (attr2(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + Graph.AttrValueEI(EId, EIdAttrValue) + AttrLen = EIdAttrValue.Len() + for i in range(AttrLen): + print("Vertical Edge4 (no str): %i, Attr_Val: %s" % (EId, EIdAttrValue.GetI(i)())) + + Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge1: %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.IntAttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge11 (int): %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.FltAttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge12 (flt): %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.StrAttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge13 (str): %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.IntAttrValueEI(EId, EIdIntAttrValue) + AttrLen = EIdIntAttrValue.Len() + for i in range(AttrLen): + print("Vertical Edge14 (int): %i, Attr_Val: %d" % (EId, EIdIntAttrValue.GetI(i)())) + + Graph.FltAttrValueEI(EId, EIdFltAttrValue) + AttrLen = EIdFltAttrValue.Len() + for i in range(AttrLen): + print("Vertical Edge15 (flt): %i, Attr_Val: %.2f" % (EId, EIdFltAttrValue.GetI(i)())) + + Graph.StrAttrValueEI(EId, EIdStrAttrValue) + AttrLen = EIdStrAttrValue.Len() + for i in range(AttrLen): + print("Vertical Edge16 (str): %i, Attr_Val: %s" % (EId, EIdStrAttrValue.GetI(i)())) + + print("DeletedE: %i, Attr: %s, %s" % (EId, attr1, Graph.IsAttrDeletedE(EId, attr1))) + print("DeletedE: %i, Attr: %s, %s" % (EId, attr2, Graph.IsAttrDeletedE(EId, attr2))) + print("DeletedE: %i, Attr: %s, %s" % (EId, attr3, Graph.IsAttrDeletedE(EId, attr3))) + print("DeletedE: %i, Attr: %s, %s" % (EId, attr4, Graph.IsAttrDeletedE(EId, attr4))) + print("DeletedE (str): %i, Attr: %s, %s" % (EId, attr1, Graph.IsStrAttrDeletedE(EId, attr1))) + print("DeletedE (int): %i, Attr: %s, %s" % (EId, attr2, Graph.IsIntAttrDeletedE(EId, attr2))) + print("DeletedE (flt): %i, Attr: %s, %s" % (EId, attr3, Graph.IsFltAttrDeletedE(EId, attr3))) + print("DeletedE (str): %i, Attr: %s, %s" % (EId, attr4, Graph.IsStrAttrDeletedE(EId, attr4))) + print("DeletedE (int): %i, Attr: %s, %s" % (EId, attr4, Graph.IsIntAttrDeletedE(EId, attr4))) + print("DeletedE (flt): %i, Attr: %s, %s" % (EId, attr4, Graph.IsFltAttrDeletedE(EId, attr4))) + + Graph.DelAttrDatE(EId, attr2) + print("DeletedE: %i, Attr: %s, %s" % (EId, attr2, Graph.IsAttrDeletedE(EId, attr2))) + print("DeletedE (int): %i, Attr: %s, %s" % (EId, attr2, Graph.IsIntAttrDeletedE(EId, attr2))) + + Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge2 (no int): %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.DelAttrE(attr1) + Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge3 (no str): %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.AttrValueEI(EId, EIdAttrValue) + AttrLen = EIdAttrValue.Len() + for i in range(AttrLen): + print("Vertical Edge4 (no str): %i, Attr_Val: %s" % (EId, EIdAttrValue.GetI(i)())) + + for i in range(NEdges): + Graph.AddIntAttrDatE(i, 70, attr2) + + total = 0 + EI = Graph.BegNAIntI(attr2) + while EI < Graph.EndNAIntI(attr2): + total += EI.GetDat() + EI.Next() + + print("Average: %i (should be 70)" % (total/NEdges)) + if total/NNodes != 70: + print("*** Error2") + + Graph.Clr() + +def ManipulateAttributesIter(): + ''' + Test node, edge attribute functionality using iterators + ''' + + NNodes = 1000 + NEdges = 1000 + + Graph = snap.TNEANet.New() + t = Graph.Empty() + + # create the nodes + for i in range(0, NNodes): + Graph.AddNode(i) + + t = Graph.Empty() + n = Graph.GetNodes() + + # create random edges + NCount = NEdges + while NCount > 0: + x = int(random.random() * NNodes) + y = int(random.random() * NNodes) + # skip the loops in this test + if x != y and not Graph.IsEdge(x,y): + n = Graph.AddEdge(x, y) + NCount -= 1 + + print("Added nodes") + + # create attributes and fill all nodes + #attr1 = TStr("str") + #attr2 = TStr("int") + #attr3 = TStr("float") + #attr4 = TStr("default") + attr1 = "STR" + attr2 = "INT" + attr3 = "FLOAT" + attr4 = "DEFAULT" + + # Test column int iterator for node 3, 50, 700, 900 + # Check if we can set defaults to 0 fordata. + Graph.AddIntAttrN(attr2, 0) + NI3 = Graph.GetNI(3) + NI50 = Graph.GetNI(50) + NI700 = Graph.GetNI(700) + NI900 = Graph.GetNI(900) + Graph.AddIntAttrDatN(NI3, 3*2, attr2) + Graph.AddIntAttrDatN(NI50, 50*2, attr2) + Graph.AddIntAttrDatN(NI700, 700*2, attr2) + Graph.AddIntAttrDatN(NI900, 900*2, attr2) + + print("Added attributes") + + NodeId = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + if NI.GetDat() != 0: + print("Attribute1: %s, Node: %i, Val: %d" % (attr2, NodeId, NI.GetDat())) + #print("Attribute: %s, Node: %i, Val: %d" % (attr2(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test column flt iterator for node 3, 50, 700, 900 + NI5 = Graph.GetNI(5) + NI50 = Graph.GetNI(50) + NI300 = Graph.GetNI(300) + NI653 = Graph.GetNI(653) + Graph.AddFltAttrDatN(NI5, 3.41, attr3) + Graph.AddFltAttrDatN(NI50, 2.718, attr3) + Graph.AddFltAttrDatN(NI300, 150.0, attr3) + Graph.AddFltAttrDatN(NI653, 653, attr3) + + NodeId = 0 + NCount = 0 + NI = Graph.BegNI() + while NI < Graph.EndNI(): + NCount += 1 + NI.Next() + + NI = Graph.BegNAFltI(attr3) + NodeId = 0 + while NI < Graph.EndNAFltI(attr3): + if NI.GetDat() != snap.TFlt.Mn: + print("Attribute2: %s, Node: %i, Val: %f" % (attr3, NodeId, NI.GetDat())) + #print("Attribute: %s, Node: %i, Val: %f" % (attr3(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test column str iterator for node 3, 50, 700, 900 + NI10 = Graph.GetNI(10) + NI20 = Graph.GetNI(20) + NI400 = Graph.GetNI(400) + #Graph.AddStrAttrDatN(10, TStr("abc"), attr1) + #Graph.AddStrAttrDatN(20, TStr("def"), attr1) + #Graph.AddStrAttrDatN(400, TStr("ghi"), attr1) + Graph.AddStrAttrDatN(NI10, "abc", attr1) + Graph.AddStrAttrDatN(NI20, "def", attr1) + Graph.AddStrAttrDatN(NI400, "ghi", attr1) + # this does not show since ""=null + #Graph.AddStrAttrDatN(455, TStr(""), attr1) + # TODO Graph.AddStrAttrDatN(455, "", attr1) + NodeId = 0 + + NI = Graph.BegNAStrI(attr1) + NodeId = 0 + while NI < Graph.EndNAStrI(attr1): + if NI.GetDat() != snap.TStr.GetNullStr(): + print("Attribute3: %s, Node: %i, Val: %s" % (attr1, NodeId, NI.GetDat())) + #print("Attribute: %s, Node: %i, Val: %s" % (attr1(), NodeId, NI.GetDat())) + NodeId += 1 + NI.Next() + + # Test column iterator over many types (must skip default/deleted attr) + NId = 55 + NI55 = Graph.GetNI(55) + NI80 = Graph.GetNI(80) + #Graph.AddStrAttrDatN(NId, TStr("aaa"), attr1) + Graph.AddStrAttrDatN(NI55, "aaa", attr1) + Graph.AddIntAttrDatN(NI55, 3*2, attr2) + Graph.AddFltAttrDatN(NI55, 3.41, attr3) + #Graph.AddStrAttrDatN(80, TStr("dont appear"), attr4) # should not show up + Graph.AddStrAttrDatN(NI80, "dont appear", attr4) # should not show up + + attr1idx = Graph.GetAttrIndN(attr1) + attr2idx = Graph.GetAttrIndN(attr2) + attr3idx = Graph.GetAttrIndN(attr3) + attr4idx = Graph.GetAttrIndN(attr4) + print("Node attribute indexes: %s %d, %s %d, %s %d, %s %d" % ( + attr1, attr1idx, attr2, attr2idx, attr3, attr3idx, attr4, attr4idx)) + + NI = Graph.GetNI(NId) + print("NI attributes: %i, %s %d %.2f" % ( + NI.GetId(), + Graph.GetStrAttrDatN(NI, attr1), + Graph.GetIntAttrDatN(NI, attr2), + Graph.GetFltAttrDatN(NI, attr3))) + + print("ind attributes: %i, %s %d %.2f" % ( + NI.GetId(), + Graph.GetStrAttrIndDatN(NI, attr1idx), + Graph.GetIntAttrIndDatN(NI, attr2idx), + Graph.GetFltAttrIndDatN(NI, attr3idx))) + + NIdAttrName = snap.TStrV() + NIdAttrValue = snap.TStrV() + NIdIntAttrValue = snap.TIntV() + NIdFltAttrValue = snap.TFltV() + NIdStrAttrValue = snap.TStrV() + + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node1: %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + NIdAttrName = snap.TStrV() + Graph.IntAttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node11 (int): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + NIdAttrName = snap.TStrV() + Graph.FltAttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node12 (flt): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + NIdAttrName = snap.TStrV() + Graph.StrAttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node13 (str): %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.IntAttrValueNI(NId, NIdIntAttrValue) + AttrLen = NIdIntAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node14 (int): %i, Attr_Val: %d" % (NId, NIdIntAttrValue.GetI(i)())) + + Graph.FltAttrValueNI(NId, NIdFltAttrValue) + AttrLen = NIdFltAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node15 (flt): %i, Attr_Val: %.2f" % (NId, NIdFltAttrValue.GetI(i)())) + + Graph.StrAttrValueNI(NId, NIdStrAttrValue) + AttrLen = NIdStrAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node16 (str): %i, Attr_Val: %s" % (NId, NIdStrAttrValue.GetI(i)())) + + Graph.DelAttrDatN(NId, attr2) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node2 (no int) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.AddIntAttrDatN(NId, 3*2, attr2) + Graph.DelAttrN(attr1) + Graph.AttrNameNI(NId, NIdAttrName) + AttrLen = NIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Node3 (no str) : %i, Attr: %s" % (NId, NIdAttrName.GetI(i)())) + + Graph.AttrValueNI(NId, NIdAttrValue) + AttrLen = NIdAttrValue.Len() + for i in range(AttrLen): + print("Vertical Node4 (no str) : %i, Attr_Val: %s" % (NId, NIdAttrValue.GetI(i)())) + + for i in range(NNodes): + Graph.AddIntAttrDatN(i, 70, attr2) + + total = 0 + NI = Graph.BegNAIntI(attr2) + while NI < Graph.EndNAIntI(attr2): + total += NI.GetDat() + NI.Next() + + print("Average: %i (should be 70)" % (total/NNodes)) + if total/NNodes != 70: + print("*** Error3") + + # Test column iterator for edge + EI3 = Graph.GetEI(3) + EI55 = Graph.GetEI(55) + EI705 = Graph.GetEI(705) + EI905 = Graph.GetEI(905) + Graph.AddIntAttrDatE(EI3, 3*2, attr2) + Graph.AddIntAttrDatE(EI55, 55*2, attr2) + Graph.AddIntAttrDatE(EI705, 705*2, attr2) + Graph.AddIntAttrDatE(EI905, 905*2, attr2) + EdgeId = 0 + EI = Graph.BegEAIntI(attr2) + while EI < Graph.EndEAIntI(attr2): + if EI.GetDat() != snap.TInt.Mn: + print("E Attribute1: %s, Edge: %i, Val: %i" % ( + attr2, EdgeId, EI.GetDat())) + #% (attr2(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test column flt iterator for edge + Graph.AddFltAttrE(attr3, 0.00) + EI5 = Graph.GetEI(5) + EI50 = Graph.GetEI(50) + EI300 = Graph.GetEI(300) + EI653 = Graph.GetEI(653) + Graph.AddFltAttrDatE(EI5, 4.41, attr3) + Graph.AddFltAttrDatE(EI50, 3.718, attr3) + Graph.AddFltAttrDatE(EI300, 151.0, attr3) + Graph.AddFltAttrDatE(EI653, 654, attr3) + EdgeId = 0 + EI = Graph.BegEAFltI(attr3) + while EI < Graph.EndEAFltI(attr3): + # Check if defaults are set to 0. + if EI.GetDat() != 0: + print("E Attribute2: %s, Edge: %i, Val: %f" % ( + attr3, EdgeId, EI.GetDat())) + #(attr3(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test column str iterator for edge + #Graph.AddStrAttrDatE(10, TStr("abc"), attr1) + #Graph.AddStrAttrDatE(20, TStr("def"), attr1) + #Graph.AddStrAttrDatE(400, TStr("ghi"), attr1) + EI10 = Graph.GetEI(10) + EI20 = Graph.GetEI(20) + EI400 = Graph.GetEI(400) + Graph.AddStrAttrDatE(EI10, "abc", attr1) + Graph.AddStrAttrDatE(EI20, "def", attr1) + Graph.AddStrAttrDatE(EI400, "ghi", attr1) + # this does not show since ""=null + #Graph.AddStrAttrDatE(455, TStr(""), attr1) + # TODO Graph.AddStrAttrDatE(455, "", attr1) + EdgeId = 0 + EI = Graph.BegEAStrI(attr1) + while EI < Graph.EndEAStrI(attr1): + if EI.GetDat() != snap.TStr.GetNullStr(): + print("E Attribute3: %s, Edge: %i, Val: %s" % ( + attr1, EdgeId, EI.GetDat())) + #(attr1(), EdgeId, EI.GetDat()) + EdgeId += 1 + EI.Next() + + # Test column iterator over many types (must skip default/deleted attr) + EId = 55 + EI55 = Graph.GetEI(55) + EI80 = Graph.GetEI(80) + #Graph.AddStrAttrDatE(EId, TStr("aaa"), attr1) + Graph.AddStrAttrDatE(EI55, "aaa", attr1) + Graph.AddIntAttrDatE(EI55, 3*2, attr2) + Graph.AddFltAttrDatE(EI55, 3.41, attr3) + #Graph.AddStrAttrDatE(80, TStr("dont appear"), attr4) # should not show up + Graph.AddStrAttrDatE(EI80, "dont appear", attr4) # should not show up + + attr1idx = Graph.GetAttrIndE(attr1) + attr2idx = Graph.GetAttrIndE(attr2) + attr3idx = Graph.GetAttrIndE(attr3) + attr4idx = Graph.GetAttrIndE(attr4) + print("Edge attribute indexes: %s %d, %s %d, %s %d, %s %d" % ( + attr1, attr1idx, attr2, attr2idx, attr3, attr3idx, attr4, attr4idx)) + + EI = Graph.GetEI(EId) + print("EI attributes: %i, %s %d %.2f" % ( + EI.GetId(), + Graph.GetStrAttrDatE(EI, attr1), + Graph.GetIntAttrDatE(EI, attr2), + Graph.GetFltAttrDatE(EI, attr3))) + + print("ind attributes: %i, %s %d %.2f" % ( + EI.GetId(), + Graph.GetStrAttrIndDatE(EI, attr1idx), + Graph.GetIntAttrIndDatE(EI, attr2idx), + Graph.GetFltAttrIndDatE(EI, attr3idx))) + + EIdAttrName = snap.TStrV() + EIdAttrValue = snap.TStrV() + + Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge1: %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.DelAttrDatE(EId, attr2) + Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge2 (no int) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.AddIntAttrDatE(EId, 3*2, attr2) + Graph.DelAttrE(attr1) + Graph.AttrNameEI(EId, EIdAttrName) + AttrLen = EIdAttrName.Len() + for i in range(AttrLen): + print("Vertical Edge3 (no str) : %i, Attr: %s" % (EId, EIdAttrName.GetI(i)())) + + Graph.AttrValueEI(EId, EIdAttrValue) + AttrLen = EIdAttrValue.Len() + for i in range(AttrLen): + print("Vertical Edge4 (no str) : %i, Attr_Val: %s" % (EId, EIdAttrValue.GetI(i)())) + + for i in range(NEdges): + Graph.AddIntAttrDatE(i, 70, attr2) + + total = 0 + EI = Graph.BegNAIntI(attr2) + while EI < Graph.EndNAIntI(attr2): + total += EI.GetDat() + EI.Next() + + print("Average: %i (should be 70)" % (total/NEdges)) + if total/NNodes != 70: + print("*** Error4") + + Graph.Clr() + +if __name__ == '__main__': + print("----- DefaultConstructor -----") + DefaultConstructor() + print("----- ManipulateNodesEdges -----") + ManipulateNodesEdges() + print("----- ManipulateAttributesId -----") + ManipulateAttributesId() + print("----- ManipulateAttributesIter -----") + ManipulateAttributesIter() + diff --git a/snap-python/source/test/tnodei.py b/snap-python/source/test/tnodei.py new file mode 100644 index 0000000000000000000000000000000000000000..51620ec32ff2e48e102ef28c62b02d418411e485 --- /dev/null +++ b/snap-python/source/test/tnodei.py @@ -0,0 +1,24 @@ +import snap + +G2 = snap.GenRndGnm(snap.PNGraph, 100, 1000) +count = 0 +for NI in G2.Nodes(): + count += 1 + print("%2d: node %d, out-degree %d, in-degree %d" % ( count, NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) + print("GetId() %d" % (NI.GetId())) + print("GetOutDeg() %d" % (NI.GetOutDeg())) + print("GetInDeg() %d" % (NI.GetInDeg())) + print("GetOutNId(0) %d" % (NI.GetOutNId(0))) + print("GetOutNId(1) %d" % (NI.GetOutNId(1))) + print("GetInNId(0) %d" % (NI.GetInNId(0))) + print("GetInNId(1) %d" % (NI.GetInNId(1))) + e1 = NI.GetOutNId(3) + print("IsOutNId(%d): %d" % (e1, NI.IsOutNId(e1))) + print("IsOutNId(101): %d" % (NI.IsOutNId(101))) + e2 = NI.GetInNId(2) + print("IsInNId(%d): %d" % (e2, NI.IsInNId(e2))) + print("IsInNId(101): %d" % (NI.IsInNId(101))) + print("IsNbhNId(%d): %d" % (e1, NI.IsNbrNId(e1))) + print("IsNbhNId(%d): %d" % (e2, NI.IsNbrNId(e2))) + print("IsNbrNId(101): %d" % (NI.IsNbrNId(101))) + diff --git a/snap-python/source/test/tpair.py b/snap-python/source/test/tpair.py new file mode 100644 index 0000000000000000000000000000000000000000..a4bee1b8f4d828c94a2525262aaf6796545dd310 --- /dev/null +++ b/snap-python/source/test/tpair.py @@ -0,0 +1,7 @@ +import snap + +p = snap.TIntStrPr(1, "one"); + +print(p.GetVal1()) +print(p.GetVal2()) + diff --git a/snap-python/source/test/tree.py b/snap-python/source/test/tree.py new file mode 100644 index 0000000000000000000000000000000000000000..2f9ec7c422b0c2011d66c3e97b9005448b59acb0 --- /dev/null +++ b/snap-python/source/test/tree.py @@ -0,0 +1,16 @@ +import snap + +tree = snap.GenTree(snap.PNGraph, 3, 5) +print("nodes %d, edges %d" % (tree.GetNodes(), tree.GetEdges())) + +#result = snap.IsTree_PNGraph(tree) +result = snap.IsTree(tree) +print("IsTree %s" % (str(result))) + +istree = result[0] +root = result[1] +print("Result1 %d %d" % (istree, root)) + +istree, root = snap.IsTree(tree) +print("Result2 %d %d" % (istree, root)) + diff --git a/snap-python/source/test/tutorial.py b/snap-python/source/test/tutorial.py new file mode 100644 index 0000000000000000000000000000000000000000..2e9f5fd0a2591ca44f533f658f1471cf7d18ab12 --- /dev/null +++ b/snap-python/source/test/tutorial.py @@ -0,0 +1,158 @@ +import snap + +print("----- vector ----- ") + +v = snap.TIntV() + +v.Add(1) +v.Add(2) +v.Add(3) +v.Add(4) +v.Add(5) + +print(v.Len()) +print(v[2]) + +v.SetVal(2, 2*v[2]) +print(v[2]) + +for item in v: + print(item) + +for i in range(0, v.Len()): + print(i, v[i]) + +print("----- hash table ----- ") + +h = snap.TIntStrH() + +h[5] = "five" +h[3] = "three" +h[9] = "nine" +h[6] = "six" +h[1] = "one" + +print(h.Len()) + +print("h[3] =", h[3]) + +h[3] = "four" +print("h[3] =", h[3]) + +for key in h: + print(key, h[key]) + +print("----- pair ----- ") + +p = snap.TIntStrPr(1, "one"); + +print(p.GetVal1()) +print(p.GetVal2()) + +print("----- graphs ----- ") + +G1 = snap.TUNGraph.New() +G2 = snap.TNGraph.New() +N1 = snap.TNEANet.New() + +G1.AddNode(1) +G1.AddNode(5) +G1.AddNode(32) + +G1.AddEdge(1,5) +G1.AddEdge(5,1) +G1.AddEdge(5,32) + +# create a directed random graph on 100 nodes and 1k edges +G2 = snap.GenRndGnm(snap.PNGraph, 100, 1000) +print("G2: Nodes %d, Edges %d" % (G2.GetNodes(), G2.GetEdges())) + +# traverse the nodes +for NI in G2.Nodes(): + print("node id %d with out-degree %d and in-degree %d" % ( + NI.GetId(), NI.GetOutDeg(), NI.GetInDeg())) +# traverse the edges +for EI in G2.Edges(): + print("edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId())) + +# traverse the edges by nodes +for NI in G2.Nodes(): + for Id in NI.GetOutEdges(): + print("edge (%d %d)" % (NI.GetId(), Id)) + +# save and load binary +FOut = snap.TFOut("test.graph") +G2.Save(FOut) +FOut.Flush() +FIn = snap.TFIn("test.graph") +G4 = snap.TNGraph.Load(FIn) +print("G4: Nodes %d, Edges %d" % (G4.GetNodes(), G4.GetEdges())) + +# save and load from a text file +snap.SaveEdgeList(G4, "test.txt", "Save as tab-separated list of edges") +G5 = snap.LoadEdgeList(snap.PNGraph, "test.txt", 0, 1) +print("G5: Nodes %d, Edges %d" % (G5.GetNodes(), G5.GetEdges())) + +# create a directed random graph on 10k nodes and 5k edges +G6 = snap.GenRndGnm(snap.PNGraph, 10000, 5000) +print("G6: Nodes %d, Edges %d" % (G6.GetNodes(), G6.GetEdges())) +# convert to undirected graph +G7 = snap.ConvertGraph(snap.PUNGraph, G6) +print("G7: Nodes %d, Edges %d" % (G7.GetNodes(), G7.GetEdges())) +# get largest weakly connected component +WccG = snap.GetMxWcc(G6) + +# generate a network using Forest Fire model +G8 = snap.GenForestFire(1000, 0.35, 0.35) +print("G8: Nodes %d, Edges %d" % (G8.GetNodes(), G8.GetEdges())) + +# get a subgraph induced on nodes {0,1,2,3,4} +SubG = snap.GetSubGraph(G8, snap.TIntV.GetV(0,1,2,3,4)) + +# get 3-core of G8 +Core3 = snap.GetKCore(G8, 3) +print("Core3: Nodes %d, Edges %d" % (Core3.GetNodes(), Core3.GetEdges())) + +# delete nodes of out degree 3 and in degree 2 +snap.DelDegKNodes(G8, 3, 2) + +# create a directed random graph on 10k nodes and 1k edges +G9 = snap.GenRndGnm(snap.PNGraph, 10000, 1000) +print("G9: Nodes %d, Edges %d" % (G9.GetNodes(), G9.GetEdges())) + +# define a vector of pairs of integers (size, count) and +# get a distribution of connected components (component size, count) +CntV = snap.TIntPrV() +snap.GetWccSzCnt(G9, CntV) +for p in CntV: + print("size %d: count %d" % (p.GetVal1(), p.GetVal2())) + +# get degree distribution pairs (out-degree, count): +snap.GetOutDegCnt(G9, CntV) +for p in CntV: + print("degree %d: count %d" % (p.GetVal1(), p.GetVal2())) + +# generate a Preferential Attachment graph on 100 nodes and out-degree of 3 +G10 = snap.GenPrefAttach(100, 3) +print("G10: Nodes %d, Edges %d" % (G10.GetNodes(), G10.GetEdges())) + +# define a vector of floats and get first eigenvector of graph adjacency matrix +EigV = snap.TFltV() +snap.GetEigVec(G10, EigV) +nr = 0 +for f in EigV: + nr += 1 + print("%d: %.6f" % (nr, f)) + +# get an approximation of graph diameter +diam = snap.GetBfsFullDiam(G10, 10) +print("diam", diam) + +# count the number of triads: +triads = snap.GetTriads(G10) +print("triads", triads) + +# get the clustering coefficient +cf = snap.GetClustCf(G10) +print("cf", cf) + diff --git a/snap-python/source/test/tvec.py b/snap-python/source/test/tvec.py new file mode 100644 index 0000000000000000000000000000000000000000..9524ad77b18efe7d4172f3e670b2c281b722c902 --- /dev/null +++ b/snap-python/source/test/tvec.py @@ -0,0 +1,50 @@ +import snap + +#v = TIntV.GetV(TInt(11),TInt(12),TInt(13),TInt(14),TInt(15)) +v = snap.TIntV.GetV(11,12,13,14,15) + +print("length", v.Len()) +print("v[2]", v[2]) + + +try: + print(v[5]) +except: + print("*** PYTHON CATCH") + +print("--------- 1") +for item in v: + print(item) + +print("--------- 2") +for i in range(0, v.Len()): + print(v[i]) + +print("--------- 3") +for i in range(0, v.Len()): + print("__getval__", v.GetVal(i), v[i]) + +print("--------- 4") +v = snap.TIntV() + +v.Add(1) +v.Add(2) +v.Add(3) +v.Add(4) +v.Add(5) + +print(v.Len()) +print(v[2]) + +v.SetVal(3, 2*v[2]) +v[4] = 2*v[2] +print("__setval__", v[3], v[4]) + +print(v[2]) + +for item in v: + print(item) + +for i in range(0, v.Len()): + print(i, v[i]) + diff --git a/snap-python/source/test/vec.py b/snap-python/source/test/vec.py new file mode 100644 index 0000000000000000000000000000000000000000..a6ce30b44c900ba7edbcd0f47bd79b4af4208047 --- /dev/null +++ b/snap-python/source/test/vec.py @@ -0,0 +1,69 @@ +import httplib +import os +import sys +import time + +sys.path.append("../swig") +import snap as Snap + +numnodes = 100 +numtask = 10 + +#print("dir(Snap.TIntV)", dir(Snap.TIntV)) +Vec1 = Snap.TIntV(numnodes) +#print("dir(Vec1)", dir(Vec1)) +print("Len Vec1", Vec1.Len()) + +#print("dir(Snap.TIntIntVV)", dir(Snap.TIntIntVV)) +Vec2 = Snap.TIntIntVV(numtask) +#print("dir(Vec2)", dir(Vec2)) +print("Len Vec2", Vec2.Len()) + +print("Vec1", type(Vec1)) + +Snap.GetDegrees(Vec1, 10.0, 1.5) + +for i in range(0,Vec1.Len()): + print("Vec1", i, Vec1.GetVal(i).Val) + +Snap.AssignRndTask(Vec1, Vec2) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print("Vec3", i, Vec3.Len()) + + for j in range(0,Vec3.Len()): + print("Vec4", i, j, Vec3.GetVal(j).Val) + +#sys.exit(0) + +for i in range(0,Vec2.Len()): + Vec3 = Vec2.GetVal(i) + print("Vec3", i, Vec3.Len()) + + h = httplib.HTTPConnection("rokl1.stanford.edu",8100) + #h.request("POST","/msg/GenStubs-0/GenTasks-2","12345",{"User-agent": "007"}) + h.connect() + url = "/msg/GenStubs-0/GenTasks-%d" % (i) + h.putrequest("POST",url) + h.putheader("User-Agent", "007") + #h.putheader("Content-Length", "9") + h.putheader("Content-Length", str(Vec3.GetMemSize())) + h.endheaders() + + fileno = h.sock.fileno() + print("fileno", fileno) + + n = Vec3.Send(fileno) + #n = os.write(fileno,"123abcdef") + print(n) + + #h.send("abc123") + + res = h.getresponse() + print(res.status, res.reason) + data = res.read() + print(len(data)) + print(data) + + diff --git a/snap-python/source/test/vector_comp.py b/snap-python/source/test/vector_comp.py new file mode 100644 index 0000000000000000000000000000000000000000..f780d31385d40fe5cd84bee25df595dfbcf2700c --- /dev/null +++ b/snap-python/source/test/vector_comp.py @@ -0,0 +1,69 @@ +#!/usr/bin/python +# vector_comp.py +# +# Author: Nick Shelly, Spring 2013 +# Description: +# - Loads SNAP as a Python module. +# - Randomly generates Python types +# - Compares conversion of Python types to SNAP types: +# 1. Python instantiation of SNAP type +# 2. Passing Python objects to SWIG C++ and convertion to SNAP type + +import sys +sys.path.append("../swig") +import snap +import timeit +import cProfile + +# Python conversion of Python list to SNAP vector +def PyListToTIntV(pylist): + + v = snap.TIntV() + for i in pylist: + v.Add(i) + + return v + +# C++ conversion of Python list to SNAP vector +def SwigPyList(pylist): + v = snap.PyToTIntV(pylist) + return v + +def main(): + + n = 10**6 + + pylist = range(n) + + # Basic verification that both methods have the same effect. + #v1 = PyListToTIntV(pylist) + #assert v1.Len() == n + + #v2 = SwigPyList(pylist) + #assert v2.Len() == n + #assert v1 == v2 # Doesn't appear to check + #print("Converted %d values\n" % v2.Len()) + + setup = """\ +import snap +from __main__ import PyListToTIntV, SwigPyList +pylist = range(%d) +""" % n + + print("Method 1: Python-to-SNAP conversion:") + print("-" * 50) + s1 = "v1 = PyListToTIntV(pylist)" +# print(timeit.timeit(setup=setup, stmt=s1, number=5)/5.0) + cProfile.run(setup + s1) + + print("Method 2: Python-to-SNAP conversion:") + print("-" * 50) + + s2 = "v2 = SwigPyList(pylist)" +# print(timeit.timeit(setup=setup, stmt=s2, number=5)/5.0) + cProfile.run(setup + s2) + +if __name__ == "__main__": + main() + + diff --git a/snap-python/source/troubleshooting.md b/snap-python/source/troubleshooting.md new file mode 100644 index 0000000000000000000000000000000000000000..f24884bfd6df7dea524cffda561ca52f698a3859 --- /dev/null +++ b/snap-python/source/troubleshooting.md @@ -0,0 +1,20 @@ +# bug: snap_wrap.cxx:178:11: fatal error: 'Python.h' file not found: include . +This bug occurs when the system has difficulty finding the Python.h file that Python uses. It can be fixed with the below solutions. + +MacOS Solution: +The first thing one should do to resolve this bug is check if they have a Python.h file and to check where it is. This can be done with the following script 'find -L /usr -name "Python.h" -print' + +A lot of times this error can occur due to multiple versions of Python being installed on a given system and therefore multiple Python.h files. To resolve this, on MacOS, one option is to get rid of the excess versions of Python, leaving only the system version of Python. If you would like to keep all of your versions of Python, you can simply change the include directory (add '-I/usr/') in the Makefile (in the swig subdirectory) to the directory of the Python.h file found above. + +Linux Solution: +Check that python-dev is installed: if not use 'sudo apt-get install python-dev' If this does not solve the problem, try parts of the above solution. + +Windows Solution: +Add the directory of your Python headers to the VC++ Directories in Visual Studio's settings. This can be found in Project -> Properties -> VC++ Directories + +# Fatal Python error: PyThreadState_Get: no current thread +MacOS Solution: +This bug is caused by multiple versions of Python being installed. It can thus be solved by the latter part of the above solution. + +# error: self assert when running tests +You need to install gnuplot and/or graphviz